| 1 |
- {"version":3,"file":"xrpl-latest-min.js","mappings":"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3E,IACrC,IAEAe,EAAehE,EAAW,YAAY,WACpC,OAAO50E,KAAK0pE,MAAMgP,UAAU14E,KAAKk4E,IACnC,IAEAtD,EAAU30E,UAAUq5E,QAAU,WAC5B,OAAOt5E,KAAK83E,WAAWv0E,OAAOvD,KAAKq5E,WACrC,EAEAzE,EAAU30E,UAAUuhE,MAAQ,WAC1B,OAAO4C,EAAMrjE,OAAOf,KAAKs5E,UAAW,OAAO5rE,aAC7C,EAEAhJ,EAAOrF,QAAUu1E,YChEjBlwE,EAAOrF,QAAU,CACfyrE,QAAS,CACPG,KAAM,EACNK,OAAQ,CACN,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,kEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,kEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,kEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,kEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,kEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,sEAINN,IAAK,CACHxvB,IAAK,EACL8vB,OAAQ,CACN,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,kEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,kEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,kEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,kEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,iEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,kEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,mEACA,mEAEF,CACE,mEACA,oEAEF,CACE,mEACA,oEAEF,CACE,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","sources":["webpack://xrpl/../../node_modules/asn1.js/lib/asn1.js","webpack://xrpl/../../node_modules/asn1.js/lib/asn1/api.js","webpack://xrpl/../../node_modules/asn1.js/lib/asn1/base/buffer.js","webpack://xrpl/../../node_modules/asn1.js/lib/asn1/base/index.js","webpack://xrpl/../../node_modules/asn1.js/lib/asn1/base/node.js","webpack://xrpl/../../node_modules/asn1.js/lib/asn1/base/reporter.js","webpack://xrpl/../../node_modules/asn1.js/lib/asn1/constants/der.js","webpack://xrpl/../../node_modules/asn1.js/lib/asn1/constants/index.js","webpack://xrpl/../../node_modules/asn1.js/lib/asn1/decoders/der.js","webpack://xrpl/../../node_modules/asn1.js/lib/asn1/decoders/index.js","webpack://xrpl/../../node_modules/asn1.js/lib/asn1/decoders/pem.js","webpack://xrpl/../../node_modules/asn1.js/lib/asn1/encoders/der.js","webpack://xrpl/../../node_modules/asn1.js/lib/asn1/encoders/index.js","webpack://xrpl/../../node_modules/asn1.js/lib/asn1/encoders/pem.js","webpack://xrpl/../../node_modules/assert/build/assert.js","webpack://xrpl/../../node_modules/assert/build/internal/assert/assertion_error.js","webpack://xrpl/../../node_modules/assert/build/internal/errors.js","webpack://xrpl/../../node_modules/assert/build/internal/util/comparisons.js","webpack://xrpl/../../node_modules/base-x/src/index.js","webpack://xrpl/../../node_modules/base64-js/index.js","webpack://xrpl/../../node_modules/big-integer/BigInteger.js","webpack://xrpl/../../node_modules/bignumber.js/bignumber.js","webpack://xrpl/../../node_modules/bip32/src/bip32.js","webpack://xrpl/../../node_modules/bip32/src/crypto.js","webpack://xrpl/../../node_modules/bip32/src/index.js","webpack://xrpl/../../node_modules/bip39/src/_wordlists.js","webpack://xrpl/../../node_modules/bip39/src/index.js","webpack://xrpl/../../node_modules/bn.js/lib/bn.js","webpack://xrpl/../../node_modules/brorand/index.js","webpack://xrpl/../../node_modules/browserify-aes/aes.js","webpack://xrpl/../../node_modules/browserify-aes/authCipher.js","webpack://xrpl/../../node_modules/browserify-aes/browser.js","webpack://xrpl/../../node_modules/browserify-aes/decrypter.js","webpack://xrpl/../../node_modules/browserify-aes/encrypter.js","webpack://xrpl/../../node_modules/browserify-aes/ghash.js","webpack://xrpl/../../node_modules/browserify-aes/incr32.js","webpack://xrpl/../../node_modules/browserify-aes/modes/cbc.js","webpack://xrpl/../../node_modules/browserify-aes/modes/cfb.js","webpack://xrpl/../../node_modules/browserify-aes/modes/cfb1.js","webpack://xrpl/../../node_modules/browserify-aes/modes/cfb8.js","webpack://xrpl/../../node_modules/browserify-aes/modes/ctr.js","webpack://xrpl/../../node_modules/browserify-aes/modes/ecb.js","webpack://xrpl/../../node_modules/browserify-aes/modes/index.js","webpack://xrpl/../../node_modules/browserify-aes/modes/ofb.js","webpack://xrpl/../../node_modules/browserify-aes/streamCipher.js","webpack://xrpl/../../node_modules/browserify-cipher/browser.js","webpack://xrpl/../../node_modules/browserify-des/index.js","webpack://xrpl/../../node_modules/browserify-des/modes.js","webpack://xrpl/../../node_modules/browserify-rsa/index.js","webpack://xrpl/../../node_modules/browserify-sign/algos.js","webpack://xrpl/../../node_modules/browserify-sign/browser/index.js","webpack://xrpl/../../node_modules/browserify-sign/browser/sign.js","webpack://xrpl/../../node_modules/browserify-sign/browser/verify.js","webpack://xrpl/../../node_modules/bs58/index.js","webpack://xrpl/../../node_modules/bs58check/base.js","webpack://xrpl/../../node_modules/bs58check/index.js","webpack://xrpl/../../node_modules/buffer-xor/index.js","webpack://xrpl/../../node_modules/buffer/index.js","webpack://xrpl/../../node_modules/builtin-status-codes/browser.js","webpack://xrpl/../../node_modules/call-bind/callBound.js","webpack://xrpl/../../node_modules/call-bind/index.js","webpack://xrpl/../../node_modules/cipher-base/index.js","webpack://xrpl/../../node_modules/create-ecdh/browser.js","webpack://xrpl/../../node_modules/create-hash/browser.js","webpack://xrpl/../../node_modules/create-hash/md5.js","webpack://xrpl/../../node_modules/create-hmac/browser.js","webpack://xrpl/../../node_modules/create-hmac/legacy.js","webpack://xrpl/../../node_modules/crypto-browserify/index.js","webpack://xrpl/../../node_modules/decimal.js/decimal.js","webpack://xrpl/../../node_modules/define-properties/index.js","webpack://xrpl/../../node_modules/des.js/lib/des.js","webpack://xrpl/../../node_modules/des.js/lib/des/cbc.js","webpack://xrpl/../../node_modules/des.js/lib/des/cipher.js","webpack://xrpl/../../node_modules/des.js/lib/des/des.js","webpack://xrpl/../../node_modules/des.js/lib/des/ede.js","webpack://xrpl/../../node_modules/des.js/lib/des/utils.js","webpack://xrpl/../../node_modules/diffie-hellman/browser.js","webpack://xrpl/../../node_modules/diffie-hellman/lib/dh.js","webpack://xrpl/../../node_modules/diffie-hellman/lib/generatePrime.js","webpack://xrpl/../../node_modules/diffie-hellman/node_modules/bn.js/lib/bn.js","webpack://xrpl/../../node_modules/elliptic/lib/elliptic.js","webpack://xrpl/../../node_modules/elliptic/lib/elliptic/curve/base.js","webpack://xrpl/../../node_modules/elliptic/lib/elliptic/curve/edwards.js","webpack://xrpl/../../node_modules/elliptic/lib/elliptic/curve/index.js","webpack://xrpl/../../node_modules/elliptic/lib/elliptic/curve/mont.js","webpack://xrpl/../../node_modules/elliptic/lib/elliptic/curve/short.js","webpack://xrpl/../../node_modules/elliptic/lib/elliptic/curves.js","webpack://xrpl/../../node_modules/elliptic/lib/elliptic/ec/index.js","webpack://xrpl/../../node_modules/elliptic/lib/elliptic/ec/key.js","webpack://xrpl/../../node_modules/elliptic/lib/elliptic/ec/signature.js","webpack://xrpl/../../node_modules/elliptic/lib/elliptic/eddsa/index.js","webpack://xrpl/../../node_modules/elliptic/lib/elliptic/eddsa/key.js","webpack://xrpl/../../node_modules/elliptic/lib/elliptic/eddsa/signature.js","webpack://xrpl/../../node_modules/elliptic/lib/elliptic/precomputed/secp256k1.js","webpack://xrpl/../../node_modules/elliptic/lib/elliptic/utils.js","webpack://xrpl/../../node_modules/es6-object-assign/index.js","webpack://xrpl/../../node_modules/events/events.js","webpack://xrpl/../../node_modules/evp_bytestokey/index.js","webpack://xrpl/../../node_modules/for-each/index.js","webpack://xrpl/../../node_modules/function-bind/implementation.js","webpack://xrpl/../../node_modules/function-bind/index.js","webpack://xrpl/../../node_modules/get-intrinsic/index.js","webpack://xrpl/../../node_modules/gopd/index.js","webpack://xrpl/../../node_modules/has-property-descriptors/index.js","webpack://xrpl/../../node_modules/has-symbols/index.js","webpack://xrpl/../../node_modules/has-symbols/shams.js","webpack://xrpl/../../node_modules/has-tostringtag/shams.js","webpack://xrpl/../../node_modules/has/src/index.js","webpack://xrpl/../../node_modules/hash-base/index.js","webpack://xrpl/../../node_modules/hash.js/lib/hash.js","webpack://xrpl/../../node_modules/hash.js/lib/hash/common.js","webpack://xrpl/../../node_modules/hash.js/lib/hash/hmac.js","webpack://xrpl/../../node_modules/hash.js/lib/hash/ripemd.js","webpack://xrpl/../../node_modules/hash.js/lib/hash/sha.js","webpack://xrpl/../../node_modules/hash.js/lib/hash/sha/1.js","webpack://xrpl/../../node_modules/hash.js/lib/hash/sha/224.js","webpack://xrpl/../../node_modules/hash.js/lib/hash/sha/256.js","webpack://xrpl/../../node_modules/hash.js/lib/hash/sha/384.js","webpack://xrpl/../../node_modules/hash.js/lib/hash/sha/512.js","webpack://xrpl/../../node_modules/hash.js/lib/hash/sha/common.js","webpack://xrpl/../../node_modules/hash.js/lib/hash/utils.js","webpack://xrpl/../../node_modules/hmac-drbg/lib/hmac-drbg.js","webpack://xrpl/../../node_modules/https-browserify/index.js","webpack://xrpl/../../node_modules/ieee754/index.js","webpack://xrpl/../../node_modules/inherits/inherits_browser.js","webpack://xrpl/../../node_modules/is-arguments/index.js","webpack://xrpl/../../node_modules/is-callable/index.js","webpack://xrpl/../../node_modules/is-generator-function/index.js","webpack://xrpl/../../node_modules/is-nan/implementation.js","webpack://xrpl/../../node_modules/is-nan/index.js","webpack://xrpl/../../node_modules/is-nan/polyfill.js","webpack://xrpl/../../node_modules/is-nan/shim.js","webpack://xrpl/../../node_modules/is-typed-array/index.js","webpack://xrpl/../../node_modules/lodash/_DataView.js","webpack://xrpl/../../node_modules/lodash/_Hash.js","webpack://xrpl/../../node_modules/lodash/_ListCache.js","webpack://xrpl/../../node_modules/lodash/_Map.js","webpack://xrpl/../../node_modules/lodash/_MapCache.js","webpack://xrpl/../../node_modules/lodash/_Promise.js","webpack://xrpl/../../node_modules/lodash/_Set.js","webpack://xrpl/../../node_modules/lodash/_SetCache.js","webpack://xrpl/../../node_modules/lodash/_Stack.js","webpack://xrpl/../../node_modules/lodash/_Symbol.js","webpack://xrpl/../../node_modules/lodash/_Uint8Array.js","webpack://xrpl/../../node_modules/lodash/_WeakMap.js","webpack://xrpl/../../node_modules/lodash/_arrayAggregator.js","webpack://xrpl/../../node_modules/lodash/_arrayFilter.js","webpack://xrpl/../../node_modules/lodash/_arrayLikeKeys.js","webpack://xrpl/../../node_modules/lodash/_arrayMap.js","webpack://xrpl/../../node_modules/lodash/_arrayPush.js","webpack://xrpl/../../node_modules/lodash/_arraySome.js","webpack://xrpl/../../node_modules/lodash/_assignValue.js","webpack://xrpl/../../node_modules/lodash/_assocIndexOf.js","webpack://xrpl/../../node_modules/lodash/_baseAggregator.js","webpack://xrpl/../../node_modules/lodash/_baseAssignValue.js","webpack://xrpl/../../node_modules/lodash/_baseEach.js","webpack://xrpl/../../node_modules/lodash/_baseFlatten.js","webpack://xrpl/../../node_modules/lodash/_baseFor.js","webpack://xrpl/../../node_modules/lodash/_baseForOwn.js","webpack://xrpl/../../node_modules/lodash/_baseGet.js","webpack://xrpl/../../node_modules/lodash/_baseGetAllKeys.js","webpack://xrpl/../../node_modules/lodash/_baseGetTag.js","webpack://xrpl/../../node_modules/lodash/_baseHasIn.js","webpack://xrpl/../../node_modules/lodash/_baseIsArguments.js","webpack://xrpl/../../node_modules/lodash/_baseIsEqual.js","webpack://xrpl/../../node_modules/lodash/_baseIsEqualDeep.js","webpack://xrpl/../../node_modules/lodash/_baseIsMatch.js","webpack://xrpl/../../node_modules/lodash/_baseIsNative.js","webpack://xrpl/../../node_modules/lodash/_baseIsTypedArray.js","webpack://xrpl/../../node_modules/lodash/_baseIteratee.js","webpack://xrpl/../../node_modules/lodash/_baseKeys.js","webpack://xrpl/../../node_modules/lodash/_baseKeysIn.js","webpack://xrpl/../../node_modules/lodash/_baseMap.js","webpack://xrpl/../../node_modules/lodash/_baseMatches.js","webpack://xrpl/../../node_modules/lodash/_baseMatchesProperty.js","webpack://xrpl/../../node_modules/lodash/_basePickBy.js","webpack://xrpl/../../node_modules/lodash/_baseProperty.js","webpack://xrpl/../../node_modules/lodash/_basePropertyDeep.js","webpack://xrpl/../../node_modules/lodash/_baseSet.js","webpack://xrpl/../../node_modules/lodash/_baseTimes.js","webpack://xrpl/../../node_modules/lodash/_baseToString.js","webpack://xrpl/../../node_modules/lodash/_baseUnary.js","webpack://xrpl/../../node_modules/lodash/_cacheHas.js","webpack://xrpl/../../node_modules/lodash/_castPath.js","webpack://xrpl/../../node_modules/lodash/_coreJsData.js","webpack://xrpl/../../node_modules/lodash/_createAggregator.js","webpack://xrpl/../../node_modules/lodash/_createBaseEach.js","webpack://xrpl/../../node_modules/lodash/_createBaseFor.js","webpack://xrpl/../../node_modules/lodash/_defineProperty.js","webpack://xrpl/../../node_modules/lodash/_equalArrays.js","webpack://xrpl/../../node_modules/lodash/_equalByTag.js","webpack://xrpl/../../node_modules/lodash/_equalObjects.js","webpack://xrpl/../../node_modules/lodash/_freeGlobal.js","webpack://xrpl/../../node_modules/lodash/_getAllKeys.js","webpack://xrpl/../../node_modules/lodash/_getAllKeysIn.js","webpack://xrpl/../../node_modules/lodash/_getMapData.js","webpack://xrpl/../../node_modules/lodash/_getMatchData.js","webpack://xrpl/../../node_modules/lodash/_getNative.js","webpack://xrpl/../../node_modules/lodash/_getPrototype.js","webpack://xrpl/../../node_modules/lodash/_getRawTag.js","webpack://xrpl/../../node_modules/lodash/_getSymbols.js","webpack://xrpl/../../node_modules/lodash/_getSymbolsIn.js","webpack://xrpl/../../node_modules/lodash/_getTag.js","webpack://xrpl/../../node_modules/lodash/_getValue.js","webpack://xrpl/../../node_modules/lodash/_hasPath.js","webpack://xrpl/../../node_modules/lodash/_hashClear.js","webpack://xrpl/../../node_modules/lodash/_hashDelete.js","webpack://xrpl/../../node_modules/lodash/_hashGet.js","webpack://xrpl/../../node_modules/lodash/_hashHas.js","webpack://xrpl/../../node_modules/lodash/_hashSet.js","webpack://xrpl/../../node_modules/lodash/_isFlattenable.js","webpack://xrpl/../../node_modules/lodash/_isIndex.js","webpack://xrpl/../../node_modules/lodash/_isKey.js","webpack://xrpl/../../node_modules/lodash/_isKeyable.js","webpack://xrpl/../../node_modules/lodash/_isMasked.js","webpack://xrpl/../../node_modules/lodash/_isPrototype.js","webpack://xrpl/../../node_modules/lodash/_isStrictComparable.js","webpack://xrpl/../../node_modules/lodash/_listCacheClear.js","webpack://xrpl/../../node_modules/lodash/_listCacheDelete.js","webpack://xrpl/../../node_modules/lodash/_listCacheGet.js","webpack://xrpl/../../node_modules/lodash/_listCacheHas.js","webpack://xrpl/../../node_modules/lodash/_listCacheSet.js","webpack://xrpl/../../node_modules/lodash/_mapCacheClear.js","webpack://xrpl/../../node_modules/lodash/_mapCacheDelete.js","webpack://xrpl/../../node_modules/lodash/_mapCacheGet.js","webpack://xrpl/../../node_modules/lodash/_mapCacheHas.js","webpack://xrpl/../../node_modules/lodash/_mapCacheSet.js","webpack://xrpl/../../node_modules/lodash/_mapToArray.js","webpack://xrpl/../../node_modules/lodash/_matchesStrictComparable.js","webpack://xrpl/../../node_modules/lodash/_memoizeCapped.js","webpack://xrpl/../../node_modules/lodash/_nativeCreate.js","webpack://xrpl/../../node_modules/lodash/_nativeKeys.js","webpack://xrpl/../../node_modules/lodash/_nativeKeysIn.js","webpack://xrpl/../../node_modules/lodash/_nodeUtil.js","webpack://xrpl/../../node_modules/lodash/_objectToString.js","webpack://xrpl/../../node_modules/lodash/_overArg.js","webpack://xrpl/../../node_modules/lodash/_root.js","webpack://xrpl/../../node_modules/lodash/_setCacheAdd.js","webpack://xrpl/../../node_modules/lodash/_setCacheHas.js","webpack://xrpl/../../node_modules/lodash/_setToArray.js","webpack://xrpl/../../node_modules/lodash/_stackClear.js","webpack://xrpl/../../node_modules/lodash/_stackDelete.js","webpack://xrpl/../../node_modules/lodash/_stackGet.js","webpack://xrpl/../../node_modules/lodash/_stackHas.js","webpack://xrpl/../../node_modules/lodash/_stackSet.js","webpack://xrpl/../../node_modules/lodash/_stringToPath.js","webpack://xrpl/../../node_modules/lodash/_toKey.js","webpack://xrpl/../../node_modules/lodash/_toSource.js","webpack://xrpl/../../node_modules/lodash/eq.js","webpack://xrpl/../../node_modules/lodash/flatMap.js","webpack://xrpl/../../node_modules/lodash/flatten.js","webpack://xrpl/../../node_modules/lodash/get.js","webpack://xrpl/../../node_modules/lodash/groupBy.js","webpack://xrpl/../../node_modules/lodash/hasIn.js","webpack://xrpl/../../node_modules/lodash/identity.js","webpack://xrpl/../../node_modules/lodash/isArguments.js","webpack://xrpl/../../node_modules/lodash/isArray.js","webpack://xrpl/../../node_modules/lodash/isArrayLike.js","webpack://xrpl/../../node_modules/lodash/isBuffer.js","webpack://xrpl/../../node_modules/lodash/isEqual.js","webpack://xrpl/../../node_modules/lodash/isFunction.js","webpack://xrpl/../../node_modules/lodash/isLength.js","webpack://xrpl/../../node_modules/lodash/isObject.js","webpack://xrpl/../../node_modules/lodash/isObjectLike.js","webpack://xrpl/../../node_modules/lodash/isSymbol.js","webpack://xrpl/../../node_modules/lodash/isTypedArray.js","webpack://xrpl/../../node_modules/lodash/keys.js","webpack://xrpl/../../node_modules/lodash/keysIn.js","webpack://xrpl/../../node_modules/lodash/lodash.js","webpack://xrpl/../../node_modules/lodash/map.js","webpack://xrpl/../../node_modules/lodash/memoize.js","webpack://xrpl/../../node_modules/lodash/negate.js","webpack://xrpl/../../node_modules/lodash/omitBy.js","webpack://xrpl/../../node_modules/lodash/pickBy.js","webpack://xrpl/../../node_modules/lodash/property.js","webpack://xrpl/../../node_modules/lodash/stubArray.js","webpack://xrpl/../../node_modules/lodash/stubFalse.js","webpack://xrpl/../../node_modules/lodash/toString.js","webpack://xrpl/../../node_modules/md5.js/index.js","webpack://xrpl/../../node_modules/miller-rabin/lib/mr.js","webpack://xrpl/../../node_modules/minimalistic-assert/index.js","webpack://xrpl/../../node_modules/minimalistic-crypto-utils/lib/utils.js","webpack://xrpl/../../node_modules/object-is/implementation.js","webpack://xrpl/../../node_modules/object-is/index.js","webpack://xrpl/../../node_modules/object-is/polyfill.js","webpack://xrpl/../../node_modules/object-is/shim.js","webpack://xrpl/../../node_modules/object-keys/implementation.js","webpack://xrpl/../../node_modules/object-keys/index.js","webpack://xrpl/../../node_modules/object-keys/isArguments.js","webpack://xrpl/../../node_modules/parse-asn1/asn1.js","webpack://xrpl/../../node_modules/parse-asn1/certificate.js","webpack://xrpl/../../node_modules/parse-asn1/fixProc.js","webpack://xrpl/../../node_modules/parse-asn1/index.js","webpack://xrpl/../../node_modules/pbkdf2/browser.js","webpack://xrpl/../../node_modules/pbkdf2/lib/async.js","webpack://xrpl/../../node_modules/pbkdf2/lib/default-encoding.js","webpack://xrpl/../../node_modules/pbkdf2/lib/precondition.js","webpack://xrpl/../../node_modules/pbkdf2/lib/sync-browser.js","webpack://xrpl/../../node_modules/pbkdf2/lib/to-buffer.js","webpack://xrpl/../../node_modules/process/browser.js","webpack://xrpl/../../node_modules/public-encrypt/browser.js","webpack://xrpl/../../node_modules/public-encrypt/mgf.js","webpack://xrpl/../../node_modules/public-encrypt/privateDecrypt.js","webpack://xrpl/../../node_modules/public-encrypt/publicEncrypt.js","webpack://xrpl/../../node_modules/public-encrypt/withPublic.js","webpack://xrpl/../../node_modules/public-encrypt/xor.js","webpack://xrpl/../../node_modules/querystring/decode.js","webpack://xrpl/../../node_modules/querystring/encode.js","webpack://xrpl/../../node_modules/querystring/index.js","webpack://xrpl/../../node_modules/randombytes/browser.js","webpack://xrpl/../../node_modules/randomfill/browser.js","webpack://xrpl/../../node_modules/readable-stream/errors-browser.js","webpack://xrpl/../../node_modules/readable-stream/lib/_stream_duplex.js","webpack://xrpl/../../node_modules/readable-stream/lib/_stream_passthrough.js","webpack://xrpl/../../node_modules/readable-stream/lib/_stream_readable.js","webpack://xrpl/../../node_modules/readable-stream/lib/_stream_transform.js","webpack://xrpl/../../node_modules/readable-stream/lib/_stream_writable.js","webpack://xrpl/../../node_modules/readable-stream/lib/internal/streams/async_iterator.js","webpack://xrpl/../../node_modules/readable-stream/lib/internal/streams/buffer_list.js","webpack://xrpl/../../node_modules/readable-stream/lib/internal/streams/destroy.js","webpack://xrpl/../../node_modules/readable-stream/lib/internal/streams/end-of-stream.js","webpack://xrpl/../../node_modules/readable-stream/lib/internal/streams/from-browser.js","webpack://xrpl/../../node_modules/readable-stream/lib/internal/streams/pipeline.js","webpack://xrpl/../../node_modules/readable-stream/lib/internal/streams/state.js","webpack://xrpl/../../node_modules/readable-stream/lib/internal/streams/stream-browser.js","webpack://xrpl/../../node_modules/readable-stream/readable-browser.js","webpack://xrpl/../../node_modules/ripemd160/index.js","webpack://xrpl/../../node_modules/ripple-address-codec/src/index.ts","webpack://xrpl/../../node_modules/ripple-address-codec/src/utils.ts","webpack://xrpl/../../node_modules/ripple-address-codec/src/xrp-codec.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/binary.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/coretypes.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/enums/index.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/hash-prefixes.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/hashes.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/index.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/ledger-hashes.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/quality.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/serdes/binary-parser.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/serdes/binary-serializer.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/shamap.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/account-id.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/amount.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/blob.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/currency.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/hash-128.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/hash-160.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/hash-256.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/hash.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/index.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/path-set.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/serialized-type.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/st-array.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/st-object.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/uint-16.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/uint-32.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/uint-64.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/uint-8.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/uint.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/src/types/vector-256.ts","webpack://xrpl/../../node_modules/ripple-binary-codec/node_modules/buffer/index.js","webpack://xrpl/../../node_modules/ripple-keypairs/src/Sha512.ts","webpack://xrpl/../../node_modules/ripple-keypairs/src/index.ts","webpack://xrpl/../../node_modules/ripple-keypairs/src/secp256k1.ts","webpack://xrpl/../../node_modules/ripple-keypairs/src/utils.ts","webpack://xrpl/../../node_modules/safe-buffer/index.js","webpack://xrpl/../../node_modules/safer-buffer/safer.js","webpack://xrpl/../../node_modules/sha.js/hash.js","webpack://xrpl/../../node_modules/sha.js/index.js","webpack://xrpl/../../node_modules/sha.js/sha.js","webpack://xrpl/../../node_modules/sha.js/sha1.js","webpack://xrpl/../../node_modules/sha.js/sha224.js","webpack://xrpl/../../node_modules/sha.js/sha256.js","webpack://xrpl/../../node_modules/sha.js/sha384.js","webpack://xrpl/../../node_modules/sha.js/sha512.js","webpack://xrpl/../../node_modules/stream-browserify/index.js","webpack://xrpl/../../node_modules/stream-http/index.js","webpack://xrpl/../../node_modules/stream-http/lib/capability.js","webpack://xrpl/../../node_modules/stream-http/lib/request.js","webpack://xrpl/../../node_modules/stream-http/lib/response.js","webpack://xrpl/../../node_modules/string_decoder/lib/string_decoder.js","webpack://xrpl/../../node_modules/tiny-secp256k1/js.js","webpack://xrpl/../../node_modules/tiny-secp256k1/rfc6979.js","webpack://xrpl/../../node_modules/typeforce/errors.js","webpack://xrpl/../../node_modules/typeforce/extra.js","webpack://xrpl/../../node_modules/typeforce/index.js","webpack://xrpl/../../node_modules/typeforce/native.js","webpack://xrpl/../../node_modules/url/node_modules/punycode/punycode.js","webpack://xrpl/../../node_modules/url/url.js","webpack://xrpl/../../node_modules/url/util.js","webpack://xrpl/../../node_modules/util-deprecate/browser.js","webpack://xrpl/../../node_modules/util/support/isBufferBrowser.js","webpack://xrpl/../../node_modules/util/support/types.js","webpack://xrpl/../../node_modules/util/util.js","webpack://xrpl/../../node_modules/which-typed-array/index.js","webpack://xrpl/../../node_modules/wif/index.js","webpack://xrpl/../../node_modules/xtend/immutable.js","webpack://xrpl/./src/ECDSA.ts","webpack://xrpl/./src/Wallet/defaultFaucets.ts","webpack://xrpl/./src/Wallet/fundWallet.ts","webpack://xrpl/./src/Wallet/index.ts","webpack://xrpl/./src/Wallet/rfc1751.ts","webpack://xrpl/./src/Wallet/signer.ts","webpack://xrpl/./src/client/BroadcastClient.ts","webpack://xrpl/./src/client/ConnectionManager.ts","webpack://xrpl/./src/client/ExponentialBackoff.ts","webpack://xrpl/./src/client/RequestManager.ts","webpack://xrpl/./src/client/WSWrapper.ts","webpack://xrpl/./src/client/connection.ts","webpack://xrpl/./src/client/index.ts","webpack://xrpl/./src/client/partialPayment.ts","webpack://xrpl/./src/errors.ts","webpack://xrpl/./src/index.ts","webpack://xrpl/./src/models/index.ts","webpack://xrpl/./src/models/ledger/AccountRoot.ts","webpack://xrpl/./src/models/ledger/Offer.ts","webpack://xrpl/./src/models/ledger/RippleState.ts","webpack://xrpl/./src/models/ledger/SignerList.ts","webpack://xrpl/./src/models/ledger/index.ts","webpack://xrpl/./src/models/transactions/NFTokenAcceptOffer.ts","webpack://xrpl/./src/models/transactions/NFTokenBurn.ts","webpack://xrpl/./src/models/transactions/NFTokenCancelOffer.ts","webpack://xrpl/./src/models/transactions/NFTokenCreateOffer.ts","webpack://xrpl/./src/models/transactions/NFTokenMint.ts","webpack://xrpl/./src/models/transactions/accountDelete.ts","webpack://xrpl/./src/models/transactions/accountSet.ts","webpack://xrpl/./src/models/transactions/checkCancel.ts","webpack://xrpl/./src/models/transactions/checkCash.ts","webpack://xrpl/./src/models/transactions/checkCreate.ts","webpack://xrpl/./src/models/transactions/common.ts","webpack://xrpl/./src/models/transactions/depositPreauth.ts","webpack://xrpl/./src/models/transactions/escrowCancel.ts","webpack://xrpl/./src/models/transactions/escrowCreate.ts","webpack://xrpl/./src/models/transactions/escrowFinish.ts","webpack://xrpl/./src/models/transactions/index.ts","webpack://xrpl/./src/models/transactions/metadata.ts","webpack://xrpl/./src/models/transactions/offerCancel.ts","webpack://xrpl/./src/models/transactions/offerCreate.ts","webpack://xrpl/./src/models/transactions/payment.ts","webpack://xrpl/./src/models/transactions/paymentChannelClaim.ts","webpack://xrpl/./src/models/transactions/paymentChannelCreate.ts","webpack://xrpl/./src/models/transactions/paymentChannelFund.ts","webpack://xrpl/./src/models/transactions/setRegularKey.ts","webpack://xrpl/./src/models/transactions/signerListSet.ts","webpack://xrpl/./src/models/transactions/ticketCreate.ts","webpack://xrpl/./src/models/transactions/transaction.ts","webpack://xrpl/./src/models/transactions/trustSet.ts","webpack://xrpl/./src/models/utils/flags.ts","webpack://xrpl/./src/models/utils/index.ts","webpack://xrpl/./src/sugar/autofill.ts","webpack://xrpl/./src/sugar/balances.ts","webpack://xrpl/./src/sugar/getFeeXrp.ts","webpack://xrpl/./src/sugar/getLedgerIndex.ts","webpack://xrpl/./src/sugar/getOrderbook.ts","webpack://xrpl/./src/sugar/index.ts","webpack://xrpl/./src/sugar/submit.ts","webpack://xrpl/./src/sugar/utils.ts","webpack://xrpl/./src/utils/createCrossChainPayment.ts","webpack://xrpl/./src/utils/derive.ts","webpack://xrpl/./src/utils/getBalanceChanges.ts","webpack://xrpl/./src/utils/getNFTokenID.ts","webpack://xrpl/./src/utils/hashes/HashPrefix.ts","webpack://xrpl/./src/utils/hashes/SHAMap/InnerNode.ts","webpack://xrpl/./src/utils/hashes/SHAMap/LeafNode.ts","webpack://xrpl/./src/utils/hashes/SHAMap/index.ts","webpack://xrpl/./src/utils/hashes/SHAMap/node.ts","webpack://xrpl/./src/utils/hashes/hashLedger.ts","webpack://xrpl/./src/utils/hashes/index.ts","webpack://xrpl/./src/utils/hashes/ledgerSpaces.ts","webpack://xrpl/./src/utils/hashes/sha512Half.ts","webpack://xrpl/./src/utils/index.ts","webpack://xrpl/./src/utils/parseNFTokenID.ts","webpack://xrpl/./src/utils/quality.ts","webpack://xrpl/./src/utils/signPaymentChannelClaim.ts","webpack://xrpl/./src/utils/stringConversion.ts","webpack://xrpl/./src/utils/timeConversion.ts","webpack://xrpl/./src/utils/verifyPaymentChannelClaim.ts","webpack://xrpl/./src/utils/xrpConversion.ts","webpack://xrpl/../../node_modules/available-typed-arrays/index.js","webpack://xrpl/webpack/bootstrap","webpack://xrpl/webpack/runtime/global","webpack://xrpl/webpack/runtime/node module decorator","webpack://xrpl/webpack/startup"],"sourcesContent":["'use strict';\n\nconst asn1 = exports;\n\nasn1.bignum = require('bn.js');\n\nasn1.define = require('./asn1/api').define;\nasn1.base = require('./asn1/base');\nasn1.constants = require('./asn1/constants');\nasn1.decoders = require('./asn1/decoders');\nasn1.encoders = require('./asn1/encoders');\n","'use strict';\n\nconst encoders = require('./encoders');\nconst decoders = require('./decoders');\nconst inherits = require('inherits');\n\nconst api = exports;\n\napi.define = function define(name, body) {\n return new Entity(name, body);\n};\n\nfunction Entity(name, body) {\n this.name = name;\n this.body = body;\n\n this.decoders = {};\n this.encoders = {};\n}\n\nEntity.prototype._createNamed = function createNamed(Base) {\n const name = this.name;\n\n function Generated(entity) {\n this._initNamed(entity, name);\n }\n inherits(Generated, Base);\n Generated.prototype._initNamed = function _initNamed(entity, name) {\n Base.call(this, entity, name);\n };\n\n return new Generated(this);\n};\n\nEntity.prototype._getDecoder = function _getDecoder(enc) {\n enc = enc || 'der';\n // Lazily create decoder\n if (!this.decoders.hasOwnProperty(enc))\n this.decoders[enc] = this._createNamed(decoders[enc]);\n return this.decoders[enc];\n};\n\nEntity.prototype.decode = function decode(data, enc, options) {\n return this._getDecoder(enc).decode(data, options);\n};\n\nEntity.prototype._getEncoder = function _getEncoder(enc) {\n enc = enc || 'der';\n // Lazily create encoder\n if (!this.encoders.hasOwnProperty(enc))\n this.encoders[enc] = this._createNamed(encoders[enc]);\n return this.encoders[enc];\n};\n\nEntity.prototype.encode = function encode(data, enc, /* internal */ reporter) {\n return this._getEncoder(enc).encode(data, reporter);\n};\n","'use strict';\n\nconst inherits = require('inherits');\nconst Reporter = require('../base/reporter').Reporter;\nconst Buffer = require('safer-buffer').Buffer;\n\nfunction DecoderBuffer(base, options) {\n Reporter.call(this, options);\n if (!Buffer.isBuffer(base)) {\n this.error('Input not Buffer');\n return;\n }\n\n this.base = base;\n this.offset = 0;\n this.length = base.length;\n}\ninherits(DecoderBuffer, Reporter);\nexports.DecoderBuffer = DecoderBuffer;\n\nDecoderBuffer.isDecoderBuffer = function isDecoderBuffer(data) {\n if (data instanceof DecoderBuffer) {\n return true;\n }\n\n // Or accept compatible API\n const isCompatible = typeof data === 'object' &&\n Buffer.isBuffer(data.base) &&\n data.constructor.name === 'DecoderBuffer' &&\n typeof data.offset === 'number' &&\n typeof data.length === 'number' &&\n typeof data.save === 'function' &&\n typeof data.restore === 'function' &&\n typeof data.isEmpty === 'function' &&\n typeof data.readUInt8 === 'function' &&\n typeof data.skip === 'function' &&\n typeof data.raw === 'function';\n\n return isCompatible;\n};\n\nDecoderBuffer.prototype.save = function save() {\n return { offset: this.offset, reporter: Reporter.prototype.save.call(this) };\n};\n\nDecoderBuffer.prototype.restore = function restore(save) {\n // Return skipped data\n const res = new DecoderBuffer(this.base);\n res.offset = save.offset;\n res.length = this.offset;\n\n this.offset = save.offset;\n Reporter.prototype.restore.call(this, save.reporter);\n\n return res;\n};\n\nDecoderBuffer.prototype.isEmpty = function isEmpty() {\n return this.offset === this.length;\n};\n\nDecoderBuffer.prototype.readUInt8 = function readUInt8(fail) {\n if (this.offset + 1 <= this.length)\n return this.base.readUInt8(this.offset++, true);\n else\n return this.error(fail || 'DecoderBuffer overrun');\n};\n\nDecoderBuffer.prototype.skip = function skip(bytes, fail) {\n if (!(this.offset + bytes <= this.length))\n return this.error(fail || 'DecoderBuffer overrun');\n\n const res = new DecoderBuffer(this.base);\n\n // Share reporter state\n res._reporterState = this._reporterState;\n\n res.offset = this.offset;\n res.length = this.offset + bytes;\n this.offset += bytes;\n return res;\n};\n\nDecoderBuffer.prototype.raw = function raw(save) {\n return this.base.slice(save ? save.offset : this.offset, this.length);\n};\n\nfunction EncoderBuffer(value, reporter) {\n if (Array.isArray(value)) {\n this.length = 0;\n this.value = value.map(function(item) {\n if (!EncoderBuffer.isEncoderBuffer(item))\n item = new EncoderBuffer(item, reporter);\n this.length += item.length;\n return item;\n }, this);\n } else if (typeof value === 'number') {\n if (!(0 <= value && value <= 0xff))\n return reporter.error('non-byte EncoderBuffer value');\n this.value = value;\n this.length = 1;\n } else if (typeof value === 'string') {\n this.value = value;\n this.length = Buffer.byteLength(value);\n } else if (Buffer.isBuffer(value)) {\n this.value = value;\n this.length = value.length;\n } else {\n return reporter.error('Unsupported type: ' + typeof value);\n }\n}\nexports.EncoderBuffer = EncoderBuffer;\n\nEncoderBuffer.isEncoderBuffer = function isEncoderBuffer(data) {\n if (data instanceof EncoderBuffer) {\n return true;\n }\n\n // Or accept compatible API\n const isCompatible = typeof data === 'object' &&\n data.constructor.name === 'EncoderBuffer' &&\n typeof data.length === 'number' &&\n typeof data.join === 'function';\n\n return isCompatible;\n};\n\nEncoderBuffer.prototype.join = function join(out, offset) {\n if (!out)\n out = Buffer.alloc(this.length);\n if (!offset)\n offset = 0;\n\n if (this.length === 0)\n return out;\n\n if (Array.isArray(this.value)) {\n this.value.forEach(function(item) {\n item.join(out, offset);\n offset += item.length;\n });\n } else {\n if (typeof this.value === 'number')\n out[offset] = this.value;\n else if (typeof this.value === 'string')\n out.write(this.value, offset);\n else if (Buffer.isBuffer(this.value))\n this.value.copy(out, offset);\n offset += this.length;\n }\n\n return out;\n};\n","'use strict';\n\nconst base = exports;\n\nbase.Reporter = require('./reporter').Reporter;\nbase.DecoderBuffer = require('./buffer').DecoderBuffer;\nbase.EncoderBuffer = require('./buffer').EncoderBuffer;\nbase.Node = require('./node');\n","'use strict';\n\nconst Reporter = require('../base/reporter').Reporter;\nconst EncoderBuffer = require('../base/buffer').EncoderBuffer;\nconst DecoderBuffer = require('../base/buffer').DecoderBuffer;\nconst assert = require('minimalistic-assert');\n\n// Supported tags\nconst tags = [\n 'seq', 'seqof', 'set', 'setof', 'objid', 'bool',\n 'gentime', 'utctime', 'null_', 'enum', 'int', 'objDesc',\n 'bitstr', 'bmpstr', 'charstr', 'genstr', 'graphstr', 'ia5str', 'iso646str',\n 'numstr', 'octstr', 'printstr', 't61str', 'unistr', 'utf8str', 'videostr'\n];\n\n// Public methods list\nconst methods = [\n 'key', 'obj', 'use', 'optional', 'explicit', 'implicit', 'def', 'choice',\n 'any', 'contains'\n].concat(tags);\n\n// Overrided methods list\nconst overrided = [\n '_peekTag', '_decodeTag', '_use',\n '_decodeStr', '_decodeObjid', '_decodeTime',\n '_decodeNull', '_decodeInt', '_decodeBool', '_decodeList',\n\n '_encodeComposite', '_encodeStr', '_encodeObjid', '_encodeTime',\n '_encodeNull', '_encodeInt', '_encodeBool'\n];\n\nfunction Node(enc, parent, name) {\n const state = {};\n this._baseState = state;\n\n state.name = name;\n state.enc = enc;\n\n state.parent = parent || null;\n state.children = null;\n\n // State\n state.tag = null;\n state.args = null;\n state.reverseArgs = null;\n state.choice = null;\n state.optional = false;\n state.any = false;\n state.obj = false;\n state.use = null;\n state.useDecoder = null;\n state.key = null;\n state['default'] = null;\n state.explicit = null;\n state.implicit = null;\n state.contains = null;\n\n // Should create new instance on each method\n if (!state.parent) {\n state.children = [];\n this._wrap();\n }\n}\nmodule.exports = Node;\n\nconst stateProps = [\n 'enc', 'parent', 'children', 'tag', 'args', 'reverseArgs', 'choice',\n 'optional', 'any', 'obj', 'use', 'alteredUse', 'key', 'default', 'explicit',\n 'implicit', 'contains'\n];\n\nNode.prototype.clone = function clone() {\n const state = this._baseState;\n const cstate = {};\n stateProps.forEach(function(prop) {\n cstate[prop] = state[prop];\n });\n const res = new this.constructor(cstate.parent);\n res._baseState = cstate;\n return res;\n};\n\nNode.prototype._wrap = function wrap() {\n const state = this._baseState;\n methods.forEach(function(method) {\n this[method] = function _wrappedMethod() {\n const clone = new this.constructor(this);\n state.children.push(clone);\n return clone[method].apply(clone, arguments);\n };\n }, this);\n};\n\nNode.prototype._init = function init(body) {\n const state = this._baseState;\n\n assert(state.parent === null);\n body.call(this);\n\n // Filter children\n state.children = state.children.filter(function(child) {\n return child._baseState.parent === this;\n }, this);\n assert.equal(state.children.length, 1, 'Root node can have only one child');\n};\n\nNode.prototype._useArgs = function useArgs(args) {\n const state = this._baseState;\n\n // Filter children and args\n const children = args.filter(function(arg) {\n return arg instanceof this.constructor;\n }, this);\n args = args.filter(function(arg) {\n return !(arg instanceof this.constructor);\n }, this);\n\n if (children.length !== 0) {\n assert(state.children === null);\n state.children = children;\n\n // Replace parent to maintain backward link\n children.forEach(function(child) {\n child._baseState.parent = this;\n }, this);\n }\n if (args.length !== 0) {\n assert(state.args === null);\n state.args = args;\n state.reverseArgs = args.map(function(arg) {\n if (typeof arg !== 'object' || arg.constructor !== Object)\n return arg;\n\n const res = {};\n Object.keys(arg).forEach(function(key) {\n if (key == (key | 0))\n key |= 0;\n const value = arg[key];\n res[value] = key;\n });\n return res;\n });\n }\n};\n\n//\n// Overrided methods\n//\n\noverrided.forEach(function(method) {\n Node.prototype[method] = function _overrided() {\n const state = this._baseState;\n throw new Error(method + ' not implemented for encoding: ' + state.enc);\n };\n});\n\n//\n// Public methods\n//\n\ntags.forEach(function(tag) {\n Node.prototype[tag] = function _tagMethod() {\n const state = this._baseState;\n const args = Array.prototype.slice.call(arguments);\n\n assert(state.tag === null);\n state.tag = tag;\n\n this._useArgs(args);\n\n return this;\n };\n});\n\nNode.prototype.use = function use(item) {\n assert(item);\n const state = this._baseState;\n\n assert(state.use === null);\n state.use = item;\n\n return this;\n};\n\nNode.prototype.optional = function optional() {\n const state = this._baseState;\n\n state.optional = true;\n\n return this;\n};\n\nNode.prototype.def = function def(val) {\n const state = this._baseState;\n\n assert(state['default'] === null);\n state['default'] = val;\n state.optional = true;\n\n return this;\n};\n\nNode.prototype.explicit = function explicit(num) {\n const state = this._baseState;\n\n assert(state.explicit === null && state.implicit === null);\n state.explicit = num;\n\n return this;\n};\n\nNode.prototype.implicit = function implicit(num) {\n const state = this._baseState;\n\n assert(state.explicit === null && state.implicit === null);\n state.implicit = num;\n\n return this;\n};\n\nNode.prototype.obj = function obj() {\n const state = this._baseState;\n const args = Array.prototype.slice.call(arguments);\n\n state.obj = true;\n\n if (args.length !== 0)\n this._useArgs(args);\n\n return this;\n};\n\nNode.prototype.key = function key(newKey) {\n const state = this._baseState;\n\n assert(state.key === null);\n state.key = newKey;\n\n return this;\n};\n\nNode.prototype.any = function any() {\n const state = this._baseState;\n\n state.any = true;\n\n return this;\n};\n\nNode.prototype.choice = function choice(obj) {\n const state = this._baseState;\n\n assert(state.choice === null);\n state.choice = obj;\n this._useArgs(Object.keys(obj).map(function(key) {\n return obj[key];\n }));\n\n return this;\n};\n\nNode.prototype.contains = function contains(item) {\n const state = this._baseState;\n\n assert(state.use === null);\n state.contains = item;\n\n return this;\n};\n\n//\n// Decoding\n//\n\nNode.prototype._decode = function decode(input, options) {\n const state = this._baseState;\n\n // Decode root node\n if (state.parent === null)\n return input.wrapResult(state.children[0]._decode(input, options));\n\n let result = state['default'];\n let present = true;\n\n let prevKey = null;\n if (state.key !== null)\n prevKey = input.enterKey(state.key);\n\n // Check if tag is there\n if (state.optional) {\n let tag = null;\n if (state.explicit !== null)\n tag = state.explicit;\n else if (state.implicit !== null)\n tag = state.implicit;\n else if (state.tag !== null)\n tag = state.tag;\n\n if (tag === null && !state.any) {\n // Trial and Error\n const save = input.save();\n try {\n if (state.choice === null)\n this._decodeGeneric(state.tag, input, options);\n else\n this._decodeChoice(input, options);\n present = true;\n } catch (e) {\n present = false;\n }\n input.restore(save);\n } else {\n present = this._peekTag(input, tag, state.any);\n\n if (input.isError(present))\n return present;\n }\n }\n\n // Push object on stack\n let prevObj;\n if (state.obj && present)\n prevObj = input.enterObject();\n\n if (present) {\n // Unwrap explicit values\n if (state.explicit !== null) {\n const explicit = this._decodeTag(input, state.explicit);\n if (input.isError(explicit))\n return explicit;\n input = explicit;\n }\n\n const start = input.offset;\n\n // Unwrap implicit and normal values\n if (state.use === null && state.choice === null) {\n let save;\n if (state.any)\n save = input.save();\n const body = this._decodeTag(\n input,\n state.implicit !== null ? state.implicit : state.tag,\n state.any\n );\n if (input.isError(body))\n return body;\n\n if (state.any)\n result = input.raw(save);\n else\n input = body;\n }\n\n if (options && options.track && state.tag !== null)\n options.track(input.path(), start, input.length, 'tagged');\n\n if (options && options.track && state.tag !== null)\n options.track(input.path(), input.offset, input.length, 'content');\n\n // Select proper method for tag\n if (state.any) {\n // no-op\n } else if (state.choice === null) {\n result = this._decodeGeneric(state.tag, input, options);\n } else {\n result = this._decodeChoice(input, options);\n }\n\n if (input.isError(result))\n return result;\n\n // Decode children\n if (!state.any && state.choice === null && state.children !== null) {\n state.children.forEach(function decodeChildren(child) {\n // NOTE: We are ignoring errors here, to let parser continue with other\n // parts of encoded data\n child._decode(input, options);\n });\n }\n\n // Decode contained/encoded by schema, only in bit or octet strings\n if (state.contains && (state.tag === 'octstr' || state.tag === 'bitstr')) {\n const data = new DecoderBuffer(result);\n result = this._getUse(state.contains, input._reporterState.obj)\n ._decode(data, options);\n }\n }\n\n // Pop object\n if (state.obj && present)\n result = input.leaveObject(prevObj);\n\n // Set key\n if (state.key !== null && (result !== null || present === true))\n input.leaveKey(prevKey, state.key, result);\n else if (prevKey !== null)\n input.exitKey(prevKey);\n\n return result;\n};\n\nNode.prototype._decodeGeneric = function decodeGeneric(tag, input, options) {\n const state = this._baseState;\n\n if (tag === 'seq' || tag === 'set')\n return null;\n if (tag === 'seqof' || tag === 'setof')\n return this._decodeList(input, tag, state.args[0], options);\n else if (/str$/.test(tag))\n return this._decodeStr(input, tag, options);\n else if (tag === 'objid' && state.args)\n return this._decodeObjid(input, state.args[0], state.args[1], options);\n else if (tag === 'objid')\n return this._decodeObjid(input, null, null, options);\n else if (tag === 'gentime' || tag === 'utctime')\n return this._decodeTime(input, tag, options);\n else if (tag === 'null_')\n return this._decodeNull(input, options);\n else if (tag === 'bool')\n return this._decodeBool(input, options);\n else if (tag === 'objDesc')\n return this._decodeStr(input, tag, options);\n else if (tag === 'int' || tag === 'enum')\n return this._decodeInt(input, state.args && state.args[0], options);\n\n if (state.use !== null) {\n return this._getUse(state.use, input._reporterState.obj)\n ._decode(input, options);\n } else {\n return input.error('unknown tag: ' + tag);\n }\n};\n\nNode.prototype._getUse = function _getUse(entity, obj) {\n\n const state = this._baseState;\n // Create altered use decoder if implicit is set\n state.useDecoder = this._use(entity, obj);\n assert(state.useDecoder._baseState.parent === null);\n state.useDecoder = state.useDecoder._baseState.children[0];\n if (state.implicit !== state.useDecoder._baseState.implicit) {\n state.useDecoder = state.useDecoder.clone();\n state.useDecoder._baseState.implicit = state.implicit;\n }\n return state.useDecoder;\n};\n\nNode.prototype._decodeChoice = function decodeChoice(input, options) {\n const state = this._baseState;\n let result = null;\n let match = false;\n\n Object.keys(state.choice).some(function(key) {\n const save = input.save();\n const node = state.choice[key];\n try {\n const value = node._decode(input, options);\n if (input.isError(value))\n return false;\n\n result = { type: key, value: value };\n match = true;\n } catch (e) {\n input.restore(save);\n return false;\n }\n return true;\n }, this);\n\n if (!match)\n return input.error('Choice not matched');\n\n return result;\n};\n\n//\n// Encoding\n//\n\nNode.prototype._createEncoderBuffer = function createEncoderBuffer(data) {\n return new EncoderBuffer(data, this.reporter);\n};\n\nNode.prototype._encode = function encode(data, reporter, parent) {\n const state = this._baseState;\n if (state['default'] !== null && state['default'] === data)\n return;\n\n const result = this._encodeValue(data, reporter, parent);\n if (result === undefined)\n return;\n\n if (this._skipDefault(result, reporter, parent))\n return;\n\n return result;\n};\n\nNode.prototype._encodeValue = function encode(data, reporter, parent) {\n const state = this._baseState;\n\n // Decode root node\n if (state.parent === null)\n return state.children[0]._encode(data, reporter || new Reporter());\n\n let result = null;\n\n // Set reporter to share it with a child class\n this.reporter = reporter;\n\n // Check if data is there\n if (state.optional && data === undefined) {\n if (state['default'] !== null)\n data = state['default'];\n else\n return;\n }\n\n // Encode children first\n let content = null;\n let primitive = false;\n if (state.any) {\n // Anything that was given is translated to buffer\n result = this._createEncoderBuffer(data);\n } else if (state.choice) {\n result = this._encodeChoice(data, reporter);\n } else if (state.contains) {\n content = this._getUse(state.contains, parent)._encode(data, reporter);\n primitive = true;\n } else if (state.children) {\n content = state.children.map(function(child) {\n if (child._baseState.tag === 'null_')\n return child._encode(null, reporter, data);\n\n if (child._baseState.key === null)\n return reporter.error('Child should have a key');\n const prevKey = reporter.enterKey(child._baseState.key);\n\n if (typeof data !== 'object')\n return reporter.error('Child expected, but input is not object');\n\n const res = child._encode(data[child._baseState.key], reporter, data);\n reporter.leaveKey(prevKey);\n\n return res;\n }, this).filter(function(child) {\n return child;\n });\n content = this._createEncoderBuffer(content);\n } else {\n if (state.tag === 'seqof' || state.tag === 'setof') {\n // TODO(indutny): this should be thrown on DSL level\n if (!(state.args && state.args.length === 1))\n return reporter.error('Too many args for : ' + state.tag);\n\n if (!Array.isArray(data))\n return reporter.error('seqof/setof, but data is not Array');\n\n const child = this.clone();\n child._baseState.implicit = null;\n content = this._createEncoderBuffer(data.map(function(item) {\n const state = this._baseState;\n\n return this._getUse(state.args[0], data)._encode(item, reporter);\n }, child));\n } else if (state.use !== null) {\n result = this._getUse(state.use, parent)._encode(data, reporter);\n } else {\n content = this._encodePrimitive(state.tag, data);\n primitive = true;\n }\n }\n\n // Encode data itself\n if (!state.any && state.choice === null) {\n const tag = state.implicit !== null ? state.implicit : state.tag;\n const cls = state.implicit === null ? 'universal' : 'context';\n\n if (tag === null) {\n if (state.use === null)\n reporter.error('Tag could be omitted only for .use()');\n } else {\n if (state.use === null)\n result = this._encodeComposite(tag, primitive, cls, content);\n }\n }\n\n // Wrap in explicit\n if (state.explicit !== null)\n result = this._encodeComposite(state.explicit, false, 'context', result);\n\n return result;\n};\n\nNode.prototype._encodeChoice = function encodeChoice(data, reporter) {\n const state = this._baseState;\n\n const node = state.choice[data.type];\n if (!node) {\n assert(\n false,\n data.type + ' not found in ' +\n JSON.stringify(Object.keys(state.choice)));\n }\n return node._encode(data.value, reporter);\n};\n\nNode.prototype._encodePrimitive = function encodePrimitive(tag, data) {\n const state = this._baseState;\n\n if (/str$/.test(tag))\n return this._encodeStr(data, tag);\n else if (tag === 'objid' && state.args)\n return this._encodeObjid(data, state.reverseArgs[0], state.args[1]);\n else if (tag === 'objid')\n return this._encodeObjid(data, null, null);\n else if (tag === 'gentime' || tag === 'utctime')\n return this._encodeTime(data, tag);\n else if (tag === 'null_')\n return this._encodeNull();\n else if (tag === 'int' || tag === 'enum')\n return this._encodeInt(data, state.args && state.reverseArgs[0]);\n else if (tag === 'bool')\n return this._encodeBool(data);\n else if (tag === 'objDesc')\n return this._encodeStr(data, tag);\n else\n throw new Error('Unsupported tag: ' + tag);\n};\n\nNode.prototype._isNumstr = function isNumstr(str) {\n return /^[0-9 ]*$/.test(str);\n};\n\nNode.prototype._isPrintstr = function isPrintstr(str) {\n return /^[A-Za-z0-9 '()+,-./:=?]*$/.test(str);\n};\n","'use strict';\n\nconst inherits = require('inherits');\n\nfunction Reporter(options) {\n this._reporterState = {\n obj: null,\n path: [],\n options: options || {},\n errors: []\n };\n}\nexports.Reporter = Reporter;\n\nReporter.prototype.isError = function isError(obj) {\n return obj instanceof ReporterError;\n};\n\nReporter.prototype.save = function save() {\n const state = this._reporterState;\n\n return { obj: state.obj, pathLen: state.path.length };\n};\n\nReporter.prototype.restore = function restore(data) {\n const state = this._reporterState;\n\n state.obj = data.obj;\n state.path = state.path.slice(0, data.pathLen);\n};\n\nReporter.prototype.enterKey = function enterKey(key) {\n return this._reporterState.path.push(key);\n};\n\nReporter.prototype.exitKey = function exitKey(index) {\n const state = this._reporterState;\n\n state.path = state.path.slice(0, index - 1);\n};\n\nReporter.prototype.leaveKey = function leaveKey(index, key, value) {\n const state = this._reporterState;\n\n this.exitKey(index);\n if (state.obj !== null)\n state.obj[key] = value;\n};\n\nReporter.prototype.path = function path() {\n return this._reporterState.path.join('/');\n};\n\nReporter.prototype.enterObject = function enterObject() {\n const state = this._reporterState;\n\n const prev = state.obj;\n state.obj = {};\n return prev;\n};\n\nReporter.prototype.leaveObject = function leaveObject(prev) {\n const state = this._reporterState;\n\n const now = state.obj;\n state.obj = prev;\n return now;\n};\n\nReporter.prototype.error = function error(msg) {\n let err;\n const state = this._reporterState;\n\n const inherited = msg instanceof ReporterError;\n if (inherited) {\n err = msg;\n } else {\n err = new ReporterError(state.path.map(function(elem) {\n return '[' + JSON.stringify(elem) + ']';\n }).join(''), msg.message || msg, msg.stack);\n }\n\n if (!state.options.partial)\n throw err;\n\n if (!inherited)\n state.errors.push(err);\n\n return err;\n};\n\nReporter.prototype.wrapResult = function wrapResult(result) {\n const state = this._reporterState;\n if (!state.options.partial)\n return result;\n\n return {\n result: this.isError(result) ? null : result,\n errors: state.errors\n };\n};\n\nfunction ReporterError(path, msg) {\n this.path = path;\n this.rethrow(msg);\n}\ninherits(ReporterError, Error);\n\nReporterError.prototype.rethrow = function rethrow(msg) {\n this.message = msg + ' at: ' + (this.path || '(shallow)');\n if (Error.captureStackTrace)\n Error.captureStackTrace(this, ReporterError);\n\n if (!this.stack) {\n try {\n // IE only adds stack when thrown\n throw new Error(this.message);\n } catch (e) {\n this.stack = e.stack;\n }\n }\n return this;\n};\n","'use strict';\n\n// Helper\nfunction reverse(map) {\n const res = {};\n\n Object.keys(map).forEach(function(key) {\n // Convert key to integer if it is stringified\n if ((key | 0) == key)\n key = key | 0;\n\n const value = map[key];\n res[value] = key;\n });\n\n return res;\n}\n\nexports.tagClass = {\n 0: 'universal',\n 1: 'application',\n 2: 'context',\n 3: 'private'\n};\nexports.tagClassByName = reverse(exports.tagClass);\n\nexports.tag = {\n 0x00: 'end',\n 0x01: 'bool',\n 0x02: 'int',\n 0x03: 'bitstr',\n 0x04: 'octstr',\n 0x05: 'null_',\n 0x06: 'objid',\n 0x07: 'objDesc',\n 0x08: 'external',\n 0x09: 'real',\n 0x0a: 'enum',\n 0x0b: 'embed',\n 0x0c: 'utf8str',\n 0x0d: 'relativeOid',\n 0x10: 'seq',\n 0x11: 'set',\n 0x12: 'numstr',\n 0x13: 'printstr',\n 0x14: 't61str',\n 0x15: 'videostr',\n 0x16: 'ia5str',\n 0x17: 'utctime',\n 0x18: 'gentime',\n 0x19: 'graphstr',\n 0x1a: 'iso646str',\n 0x1b: 'genstr',\n 0x1c: 'unistr',\n 0x1d: 'charstr',\n 0x1e: 'bmpstr'\n};\nexports.tagByName = reverse(exports.tag);\n","'use strict';\n\nconst constants = exports;\n\n// Helper\nconstants._reverse = function reverse(map) {\n const res = {};\n\n Object.keys(map).forEach(function(key) {\n // Convert key to integer if it is stringified\n if ((key | 0) == key)\n key = key | 0;\n\n const value = map[key];\n res[value] = key;\n });\n\n return res;\n};\n\nconstants.der = require('./der');\n","'use strict';\n\nconst inherits = require('inherits');\n\nconst bignum = require('bn.js');\nconst DecoderBuffer = require('../base/buffer').DecoderBuffer;\nconst Node = require('../base/node');\n\n// Import DER constants\nconst der = require('../constants/der');\n\nfunction DERDecoder(entity) {\n this.enc = 'der';\n this.name = entity.name;\n this.entity = entity;\n\n // Construct base tree\n this.tree = new DERNode();\n this.tree._init(entity.body);\n}\nmodule.exports = DERDecoder;\n\nDERDecoder.prototype.decode = function decode(data, options) {\n if (!DecoderBuffer.isDecoderBuffer(data)) {\n data = new DecoderBuffer(data, options);\n }\n\n return this.tree._decode(data, options);\n};\n\n// Tree methods\n\nfunction DERNode(parent) {\n Node.call(this, 'der', parent);\n}\ninherits(DERNode, Node);\n\nDERNode.prototype._peekTag = function peekTag(buffer, tag, any) {\n if (buffer.isEmpty())\n return false;\n\n const state = buffer.save();\n const decodedTag = derDecodeTag(buffer, 'Failed to peek tag: \"' + tag + '\"');\n if (buffer.isError(decodedTag))\n return decodedTag;\n\n buffer.restore(state);\n\n return decodedTag.tag === tag || decodedTag.tagStr === tag ||\n (decodedTag.tagStr + 'of') === tag || any;\n};\n\nDERNode.prototype._decodeTag = function decodeTag(buffer, tag, any) {\n const decodedTag = derDecodeTag(buffer,\n 'Failed to decode tag of \"' + tag + '\"');\n if (buffer.isError(decodedTag))\n return decodedTag;\n\n let len = derDecodeLen(buffer,\n decodedTag.primitive,\n 'Failed to get length of \"' + tag + '\"');\n\n // Failure\n if (buffer.isError(len))\n return len;\n\n if (!any &&\n decodedTag.tag !== tag &&\n decodedTag.tagStr !== tag &&\n decodedTag.tagStr + 'of' !== tag) {\n return buffer.error('Failed to match tag: \"' + tag + '\"');\n }\n\n if (decodedTag.primitive || len !== null)\n return buffer.skip(len, 'Failed to match body of: \"' + tag + '\"');\n\n // Indefinite length... find END tag\n const state = buffer.save();\n const res = this._skipUntilEnd(\n buffer,\n 'Failed to skip indefinite length body: \"' + this.tag + '\"');\n if (buffer.isError(res))\n return res;\n\n len = buffer.offset - state.offset;\n buffer.restore(state);\n return buffer.skip(len, 'Failed to match body of: \"' + tag + '\"');\n};\n\nDERNode.prototype._skipUntilEnd = function skipUntilEnd(buffer, fail) {\n for (;;) {\n const tag = derDecodeTag(buffer, fail);\n if (buffer.isError(tag))\n return tag;\n const len = derDecodeLen(buffer, tag.primitive, fail);\n if (buffer.isError(len))\n return len;\n\n let res;\n if (tag.primitive || len !== null)\n res = buffer.skip(len);\n else\n res = this._skipUntilEnd(buffer, fail);\n\n // Failure\n if (buffer.isError(res))\n return res;\n\n if (tag.tagStr === 'end')\n break;\n }\n};\n\nDERNode.prototype._decodeList = function decodeList(buffer, tag, decoder,\n options) {\n const result = [];\n while (!buffer.isEmpty()) {\n const possibleEnd = this._peekTag(buffer, 'end');\n if (buffer.isError(possibleEnd))\n return possibleEnd;\n\n const res = decoder.decode(buffer, 'der', options);\n if (buffer.isError(res) && possibleEnd)\n break;\n result.push(res);\n }\n return result;\n};\n\nDERNode.prototype._decodeStr = function decodeStr(buffer, tag) {\n if (tag === 'bitstr') {\n const unused = buffer.readUInt8();\n if (buffer.isError(unused))\n return unused;\n return { unused: unused, data: buffer.raw() };\n } else if (tag === 'bmpstr') {\n const raw = buffer.raw();\n if (raw.length % 2 === 1)\n return buffer.error('Decoding of string type: bmpstr length mismatch');\n\n let str = '';\n for (let i = 0; i < raw.length / 2; i++) {\n str += String.fromCharCode(raw.readUInt16BE(i * 2));\n }\n return str;\n } else if (tag === 'numstr') {\n const numstr = buffer.raw().toString('ascii');\n if (!this._isNumstr(numstr)) {\n return buffer.error('Decoding of string type: ' +\n 'numstr unsupported characters');\n }\n return numstr;\n } else if (tag === 'octstr') {\n return buffer.raw();\n } else if (tag === 'objDesc') {\n return buffer.raw();\n } else if (tag === 'printstr') {\n const printstr = buffer.raw().toString('ascii');\n if (!this._isPrintstr(printstr)) {\n return buffer.error('Decoding of string type: ' +\n 'printstr unsupported characters');\n }\n return printstr;\n } else if (/str$/.test(tag)) {\n return buffer.raw().toString();\n } else {\n return buffer.error('Decoding of string type: ' + tag + ' unsupported');\n }\n};\n\nDERNode.prototype._decodeObjid = function decodeObjid(buffer, values, relative) {\n let result;\n const identifiers = [];\n let ident = 0;\n let subident = 0;\n while (!buffer.isEmpty()) {\n subident = buffer.readUInt8();\n ident <<= 7;\n ident |= subident & 0x7f;\n if ((subident & 0x80) === 0) {\n identifiers.push(ident);\n ident = 0;\n }\n }\n if (subident & 0x80)\n identifiers.push(ident);\n\n const first = (identifiers[0] / 40) | 0;\n const second = identifiers[0] % 40;\n\n if (relative)\n result = identifiers;\n else\n result = [first, second].concat(identifiers.slice(1));\n\n if (values) {\n let tmp = values[result.join(' ')];\n if (tmp === undefined)\n tmp = values[result.join('.')];\n if (tmp !== undefined)\n result = tmp;\n }\n\n return result;\n};\n\nDERNode.prototype._decodeTime = function decodeTime(buffer, tag) {\n const str = buffer.raw().toString();\n\n let year;\n let mon;\n let day;\n let hour;\n let min;\n let sec;\n if (tag === 'gentime') {\n year = str.slice(0, 4) | 0;\n mon = str.slice(4, 6) | 0;\n day = str.slice(6, 8) | 0;\n hour = str.slice(8, 10) | 0;\n min = str.slice(10, 12) | 0;\n sec = str.slice(12, 14) | 0;\n } else if (tag === 'utctime') {\n year = str.slice(0, 2) | 0;\n mon = str.slice(2, 4) | 0;\n day = str.slice(4, 6) | 0;\n hour = str.slice(6, 8) | 0;\n min = str.slice(8, 10) | 0;\n sec = str.slice(10, 12) | 0;\n if (year < 70)\n year = 2000 + year;\n else\n year = 1900 + year;\n } else {\n return buffer.error('Decoding ' + tag + ' time is not supported yet');\n }\n\n return Date.UTC(year, mon - 1, day, hour, min, sec, 0);\n};\n\nDERNode.prototype._decodeNull = function decodeNull() {\n return null;\n};\n\nDERNode.prototype._decodeBool = function decodeBool(buffer) {\n const res = buffer.readUInt8();\n if (buffer.isError(res))\n return res;\n else\n return res !== 0;\n};\n\nDERNode.prototype._decodeInt = function decodeInt(buffer, values) {\n // Bigint, return as it is (assume big endian)\n const raw = buffer.raw();\n let res = new bignum(raw);\n\n if (values)\n res = values[res.toString(10)] || res;\n\n return res;\n};\n\nDERNode.prototype._use = function use(entity, obj) {\n if (typeof entity === 'function')\n entity = entity(obj);\n return entity._getDecoder('der').tree;\n};\n\n// Utility methods\n\nfunction derDecodeTag(buf, fail) {\n let tag = buf.readUInt8(fail);\n if (buf.isError(tag))\n return tag;\n\n const cls = der.tagClass[tag >> 6];\n const primitive = (tag & 0x20) === 0;\n\n // Multi-octet tag - load\n if ((tag & 0x1f) === 0x1f) {\n let oct = tag;\n tag = 0;\n while ((oct & 0x80) === 0x80) {\n oct = buf.readUInt8(fail);\n if (buf.isError(oct))\n return oct;\n\n tag <<= 7;\n tag |= oct & 0x7f;\n }\n } else {\n tag &= 0x1f;\n }\n const tagStr = der.tag[tag];\n\n return {\n cls: cls,\n primitive: primitive,\n tag: tag,\n tagStr: tagStr\n };\n}\n\nfunction derDecodeLen(buf, primitive, fail) {\n let len = buf.readUInt8(fail);\n if (buf.isError(len))\n return len;\n\n // Indefinite form\n if (!primitive && len === 0x80)\n return null;\n\n // Definite form\n if ((len & 0x80) === 0) {\n // Short form\n return len;\n }\n\n // Long form\n const num = len & 0x7f;\n if (num > 4)\n return buf.error('length octect is too long');\n\n len = 0;\n for (let i = 0; i < num; i++) {\n len <<= 8;\n const j = buf.readUInt8(fail);\n if (buf.isError(j))\n return j;\n len |= j;\n }\n\n return len;\n}\n","'use strict';\n\nconst decoders = exports;\n\ndecoders.der = require('./der');\ndecoders.pem = require('./pem');\n","'use strict';\n\nconst inherits = require('inherits');\nconst Buffer = require('safer-buffer').Buffer;\n\nconst DERDecoder = require('./der');\n\nfunction PEMDecoder(entity) {\n DERDecoder.call(this, entity);\n this.enc = 'pem';\n}\ninherits(PEMDecoder, DERDecoder);\nmodule.exports = PEMDecoder;\n\nPEMDecoder.prototype.decode = function decode(data, options) {\n const lines = data.toString().split(/[\\r\\n]+/g);\n\n const label = options.label.toUpperCase();\n\n const re = /^-----(BEGIN|END) ([^-]+)-----$/;\n let start = -1;\n let end = -1;\n for (let i = 0; i < lines.length; i++) {\n const match = lines[i].match(re);\n if (match === null)\n continue;\n\n if (match[2] !== label)\n continue;\n\n if (start === -1) {\n if (match[1] !== 'BEGIN')\n break;\n start = i;\n } else {\n if (match[1] !== 'END')\n break;\n end = i;\n break;\n }\n }\n if (start === -1 || end === -1)\n throw new Error('PEM section not found for: ' + label);\n\n const base64 = lines.slice(start + 1, end).join('');\n // Remove excessive symbols\n base64.replace(/[^a-z0-9+/=]+/gi, '');\n\n const input = Buffer.from(base64, 'base64');\n return DERDecoder.prototype.decode.call(this, input, options);\n};\n","'use strict';\n\nconst inherits = require('inherits');\nconst Buffer = require('safer-buffer').Buffer;\nconst Node = require('../base/node');\n\n// Import DER constants\nconst der = require('../constants/der');\n\nfunction DEREncoder(entity) {\n this.enc = 'der';\n this.name = entity.name;\n this.entity = entity;\n\n // Construct base tree\n this.tree = new DERNode();\n this.tree._init(entity.body);\n}\nmodule.exports = DEREncoder;\n\nDEREncoder.prototype.encode = function encode(data, reporter) {\n return this.tree._encode(data, reporter).join();\n};\n\n// Tree methods\n\nfunction DERNode(parent) {\n Node.call(this, 'der', parent);\n}\ninherits(DERNode, Node);\n\nDERNode.prototype._encodeComposite = function encodeComposite(tag,\n primitive,\n cls,\n content) {\n const encodedTag = encodeTag(tag, primitive, cls, this.reporter);\n\n // Short form\n if (content.length < 0x80) {\n const header = Buffer.alloc(2);\n header[0] = encodedTag;\n header[1] = content.length;\n return this._createEncoderBuffer([ header, content ]);\n }\n\n // Long form\n // Count octets required to store length\n let lenOctets = 1;\n for (let i = content.length; i >= 0x100; i >>= 8)\n lenOctets++;\n\n const header = Buffer.alloc(1 + 1 + lenOctets);\n header[0] = encodedTag;\n header[1] = 0x80 | lenOctets;\n\n for (let i = 1 + lenOctets, j = content.length; j > 0; i--, j >>= 8)\n header[i] = j & 0xff;\n\n return this._createEncoderBuffer([ header, content ]);\n};\n\nDERNode.prototype._encodeStr = function encodeStr(str, tag) {\n if (tag === 'bitstr') {\n return this._createEncoderBuffer([ str.unused | 0, str.data ]);\n } else if (tag === 'bmpstr') {\n const buf = Buffer.alloc(str.length * 2);\n for (let i = 0; i < str.length; i++) {\n buf.writeUInt16BE(str.charCodeAt(i), i * 2);\n }\n return this._createEncoderBuffer(buf);\n } else if (tag === 'numstr') {\n if (!this._isNumstr(str)) {\n return this.reporter.error('Encoding of string type: numstr supports ' +\n 'only digits and space');\n }\n return this._createEncoderBuffer(str);\n } else if (tag === 'printstr') {\n if (!this._isPrintstr(str)) {\n return this.reporter.error('Encoding of string type: printstr supports ' +\n 'only latin upper and lower case letters, ' +\n 'digits, space, apostrophe, left and rigth ' +\n 'parenthesis, plus sign, comma, hyphen, ' +\n 'dot, slash, colon, equal sign, ' +\n 'question mark');\n }\n return this._createEncoderBuffer(str);\n } else if (/str$/.test(tag)) {\n return this._createEncoderBuffer(str);\n } else if (tag === 'objDesc') {\n return this._createEncoderBuffer(str);\n } else {\n return this.reporter.error('Encoding of string type: ' + tag +\n ' unsupported');\n }\n};\n\nDERNode.prototype._encodeObjid = function encodeObjid(id, values, relative) {\n if (typeof id === 'string') {\n if (!values)\n return this.reporter.error('string objid given, but no values map found');\n if (!values.hasOwnProperty(id))\n return this.reporter.error('objid not found in values map');\n id = values[id].split(/[\\s.]+/g);\n for (let i = 0; i < id.length; i++)\n id[i] |= 0;\n } else if (Array.isArray(id)) {\n id = id.slice();\n for (let i = 0; i < id.length; i++)\n id[i] |= 0;\n }\n\n if (!Array.isArray(id)) {\n return this.reporter.error('objid() should be either array or string, ' +\n 'got: ' + JSON.stringify(id));\n }\n\n if (!relative) {\n if (id[1] >= 40)\n return this.reporter.error('Second objid identifier OOB');\n id.splice(0, 2, id[0] * 40 + id[1]);\n }\n\n // Count number of octets\n let size = 0;\n for (let i = 0; i < id.length; i++) {\n let ident = id[i];\n for (size++; ident >= 0x80; ident >>= 7)\n size++;\n }\n\n const objid = Buffer.alloc(size);\n let offset = objid.length - 1;\n for (let i = id.length - 1; i >= 0; i--) {\n let ident = id[i];\n objid[offset--] = ident & 0x7f;\n while ((ident >>= 7) > 0)\n objid[offset--] = 0x80 | (ident & 0x7f);\n }\n\n return this._createEncoderBuffer(objid);\n};\n\nfunction two(num) {\n if (num < 10)\n return '0' + num;\n else\n return num;\n}\n\nDERNode.prototype._encodeTime = function encodeTime(time, tag) {\n let str;\n const date = new Date(time);\n\n if (tag === 'gentime') {\n str = [\n two(date.getUTCFullYear()),\n two(date.getUTCMonth() + 1),\n two(date.getUTCDate()),\n two(date.getUTCHours()),\n two(date.getUTCMinutes()),\n two(date.getUTCSeconds()),\n 'Z'\n ].join('');\n } else if (tag === 'utctime') {\n str = [\n two(date.getUTCFullYear() % 100),\n two(date.getUTCMonth() + 1),\n two(date.getUTCDate()),\n two(date.getUTCHours()),\n two(date.getUTCMinutes()),\n two(date.getUTCSeconds()),\n 'Z'\n ].join('');\n } else {\n this.reporter.error('Encoding ' + tag + ' time is not supported yet');\n }\n\n return this._encodeStr(str, 'octstr');\n};\n\nDERNode.prototype._encodeNull = function encodeNull() {\n return this._createEncoderBuffer('');\n};\n\nDERNode.prototype._encodeInt = function encodeInt(num, values) {\n if (typeof num === 'string') {\n if (!values)\n return this.reporter.error('String int or enum given, but no values map');\n if (!values.hasOwnProperty(num)) {\n return this.reporter.error('Values map doesn\\'t contain: ' +\n JSON.stringify(num));\n }\n num = values[num];\n }\n\n // Bignum, assume big endian\n if (typeof num !== 'number' && !Buffer.isBuffer(num)) {\n const numArray = num.toArray();\n if (!num.sign && numArray[0] & 0x80) {\n numArray.unshift(0);\n }\n num = Buffer.from(numArray);\n }\n\n if (Buffer.isBuffer(num)) {\n let size = num.length;\n if (num.length === 0)\n size++;\n\n const out = Buffer.alloc(size);\n num.copy(out);\n if (num.length === 0)\n out[0] = 0;\n return this._createEncoderBuffer(out);\n }\n\n if (num < 0x80)\n return this._createEncoderBuffer(num);\n\n if (num < 0x100)\n return this._createEncoderBuffer([0, num]);\n\n let size = 1;\n for (let i = num; i >= 0x100; i >>= 8)\n size++;\n\n const out = new Array(size);\n for (let i = out.length - 1; i >= 0; i--) {\n out[i] = num & 0xff;\n num >>= 8;\n }\n if(out[0] & 0x80) {\n out.unshift(0);\n }\n\n return this._createEncoderBuffer(Buffer.from(out));\n};\n\nDERNode.prototype._encodeBool = function encodeBool(value) {\n return this._createEncoderBuffer(value ? 0xff : 0);\n};\n\nDERNode.prototype._use = function use(entity, obj) {\n if (typeof entity === 'function')\n entity = entity(obj);\n return entity._getEncoder('der').tree;\n};\n\nDERNode.prototype._skipDefault = function skipDefault(dataBuffer, reporter, parent) {\n const state = this._baseState;\n let i;\n if (state['default'] === null)\n return false;\n\n const data = dataBuffer.join();\n if (state.defaultBuffer === undefined)\n state.defaultBuffer = this._encodeValue(state['default'], reporter, parent).join();\n\n if (data.length !== state.defaultBuffer.length)\n return false;\n\n for (i=0; i < data.length; i++)\n if (data[i] !== state.defaultBuffer[i])\n return false;\n\n return true;\n};\n\n// Utility methods\n\nfunction encodeTag(tag, primitive, cls, reporter) {\n let res;\n\n if (tag === 'seqof')\n tag = 'seq';\n else if (tag === 'setof')\n tag = 'set';\n\n if (der.tagByName.hasOwnProperty(tag))\n res = der.tagByName[tag];\n else if (typeof tag === 'number' && (tag | 0) === tag)\n res = tag;\n else\n return reporter.error('Unknown tag: ' + tag);\n\n if (res >= 0x1f)\n return reporter.error('Multi-octet tag encoding unsupported');\n\n if (!primitive)\n res |= 0x20;\n\n res |= (der.tagClassByName[cls || 'universal'] << 6);\n\n return res;\n}\n","'use strict';\n\nconst encoders = exports;\n\nencoders.der = require('./der');\nencoders.pem = require('./pem');\n","'use strict';\n\nconst inherits = require('inherits');\n\nconst DEREncoder = require('./der');\n\nfunction PEMEncoder(entity) {\n DEREncoder.call(this, entity);\n this.enc = 'pem';\n}\ninherits(PEMEncoder, DEREncoder);\nmodule.exports = PEMEncoder;\n\nPEMEncoder.prototype.encode = function encode(data, options) {\n const buf = DEREncoder.prototype.encode.call(this, data);\n\n const p = buf.toString('base64');\n const out = [ '-----BEGIN ' + options.label + '-----' ];\n for (let i = 0; i < p.length; i += 64)\n out.push(p.slice(i, i + 64));\n out.push('-----END ' + options.label + '-----');\n return out.join('\\n');\n};\n","// Currently in sync with Node.js lib/assert.js\n// https://github.com/nodejs/node/commit/2a51ae424a513ec9a6aa3466baa0cc1d55dd4f3b\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n'use strict';\n\nfunction _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar _require = require('./internal/errors'),\n _require$codes = _require.codes,\n ERR_AMBIGUOUS_ARGUMENT = _require$codes.ERR_AMBIGUOUS_ARGUMENT,\n ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n ERR_INVALID_ARG_VALUE = _require$codes.ERR_INVALID_ARG_VALUE,\n ERR_INVALID_RETURN_VALUE = _require$codes.ERR_INVALID_RETURN_VALUE,\n ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS;\n\nvar AssertionError = require('./internal/assert/assertion_error');\n\nvar _require2 = require('util/'),\n inspect = _require2.inspect;\n\nvar _require$types = require('util/').types,\n isPromise = _require$types.isPromise,\n isRegExp = _require$types.isRegExp;\n\nvar objectAssign = Object.assign ? Object.assign : require('es6-object-assign').assign;\nvar objectIs = Object.is ? Object.is : require('object-is');\nvar errorCache = new Map();\nvar isDeepEqual;\nvar isDeepStrictEqual;\nvar parseExpressionAt;\nvar findNodeAround;\nvar decoder;\n\nfunction lazyLoadComparison() {\n var comparison = require('./internal/util/comparisons');\n\n isDeepEqual = comparison.isDeepEqual;\n isDeepStrictEqual = comparison.isDeepStrictEqual;\n} // Escape control characters but not \\n and \\t to keep the line breaks and\n// indentation intact.\n// eslint-disable-next-line no-control-regex\n\n\nvar escapeSequencesRegExp = /[\\x00-\\x08\\x0b\\x0c\\x0e-\\x1f]/g;\nvar meta = [\"\\\\u0000\", \"\\\\u0001\", \"\\\\u0002\", \"\\\\u0003\", \"\\\\u0004\", \"\\\\u0005\", \"\\\\u0006\", \"\\\\u0007\", '\\\\b', '', '', \"\\\\u000b\", '\\\\f', '', \"\\\\u000e\", \"\\\\u000f\", \"\\\\u0010\", \"\\\\u0011\", \"\\\\u0012\", \"\\\\u0013\", \"\\\\u0014\", \"\\\\u0015\", \"\\\\u0016\", \"\\\\u0017\", \"\\\\u0018\", \"\\\\u0019\", \"\\\\u001a\", \"\\\\u001b\", \"\\\\u001c\", \"\\\\u001d\", \"\\\\u001e\", \"\\\\u001f\"];\n\nvar escapeFn = function escapeFn(str) {\n return meta[str.charCodeAt(0)];\n};\n\nvar warned = false; // The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\nvar NO_EXCEPTION_SENTINEL = {}; // All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided. All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction innerFail(obj) {\n if (obj.message instanceof Error) throw obj.message;\n throw new AssertionError(obj);\n}\n\nfunction fail(actual, expected, message, operator, stackStartFn) {\n var argsLen = arguments.length;\n var internalMessage;\n\n if (argsLen === 0) {\n internalMessage = 'Failed';\n } else if (argsLen === 1) {\n message = actual;\n actual = undefined;\n } else {\n if (warned === false) {\n warned = true;\n var warn = process.emitWarning ? process.emitWarning : console.warn.bind(console);\n warn('assert.fail() with more than one argument is deprecated. ' + 'Please use assert.strictEqual() instead or only pass a message.', 'DeprecationWarning', 'DEP0094');\n }\n\n if (argsLen === 2) operator = '!=';\n }\n\n if (message instanceof Error) throw message;\n var errArgs = {\n actual: actual,\n expected: expected,\n operator: operator === undefined ? 'fail' : operator,\n stackStartFn: stackStartFn || fail\n };\n\n if (message !== undefined) {\n errArgs.message = message;\n }\n\n var err = new AssertionError(errArgs);\n\n if (internalMessage) {\n err.message = internalMessage;\n err.generatedMessage = true;\n }\n\n throw err;\n}\n\nassert.fail = fail; // The AssertionError is defined in internal/error.\n\nassert.AssertionError = AssertionError;\n\nfunction innerOk(fn, argLen, value, message) {\n if (!value) {\n var generatedMessage = false;\n\n if (argLen === 0) {\n generatedMessage = true;\n message = 'No value argument passed to `assert.ok()`';\n } else if (message instanceof Error) {\n throw message;\n }\n\n var err = new AssertionError({\n actual: value,\n expected: true,\n message: message,\n operator: '==',\n stackStartFn: fn\n });\n err.generatedMessage = generatedMessage;\n throw err;\n }\n} // Pure assertion tests whether a value is truthy, as determined\n// by !!value.\n\n\nfunction ok() {\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n innerOk.apply(void 0, [ok, args.length].concat(args));\n}\n\nassert.ok = ok; // The equality assertion tests shallow, coercive equality with ==.\n\n/* eslint-disable no-restricted-properties */\n\nassert.equal = function equal(actual, expected, message) {\n if (arguments.length < 2) {\n throw new ERR_MISSING_ARGS('actual', 'expected');\n } // eslint-disable-next-line eqeqeq\n\n\n if (actual != expected) {\n innerFail({\n actual: actual,\n expected: expected,\n message: message,\n operator: '==',\n stackStartFn: equal\n });\n }\n}; // The non-equality assertion tests for whether two objects are not\n// equal with !=.\n\n\nassert.notEqual = function notEqual(actual, expected, message) {\n if (arguments.length < 2) {\n throw new ERR_MISSING_ARGS('actual', 'expected');\n } // eslint-disable-next-line eqeqeq\n\n\n if (actual == expected) {\n innerFail({\n actual: actual,\n expected: expected,\n message: message,\n operator: '!=',\n stackStartFn: notEqual\n });\n }\n}; // The equivalence assertion tests a deep equality relation.\n\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n if (arguments.length < 2) {\n throw new ERR_MISSING_ARGS('actual', 'expected');\n }\n\n if (isDeepEqual === undefined) lazyLoadComparison();\n\n if (!isDeepEqual(actual, expected)) {\n innerFail({\n actual: actual,\n expected: expected,\n message: message,\n operator: 'deepEqual',\n stackStartFn: deepEqual\n });\n }\n}; // The non-equivalence assertion tests for any deep inequality.\n\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n if (arguments.length < 2) {\n throw new ERR_MISSING_ARGS('actual', 'expected');\n }\n\n if (isDeepEqual === undefined) lazyLoadComparison();\n\n if (isDeepEqual(actual, expected)) {\n innerFail({\n actual: actual,\n expected: expected,\n message: message,\n operator: 'notDeepEqual',\n stackStartFn: notDeepEqual\n });\n }\n};\n/* eslint-enable */\n\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n if (arguments.length < 2) {\n throw new ERR_MISSING_ARGS('actual', 'expected');\n }\n\n if (isDeepEqual === undefined) lazyLoadComparison();\n\n if (!isDeepStrictEqual(actual, expected)) {\n innerFail({\n actual: actual,\n expected: expected,\n message: message,\n operator: 'deepStrictEqual',\n stackStartFn: deepStrictEqual\n });\n }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\n\nfunction notDeepStrictEqual(actual, expected, message) {\n if (arguments.length < 2) {\n throw new ERR_MISSING_ARGS('actual', 'expected');\n }\n\n if (isDeepEqual === undefined) lazyLoadComparison();\n\n if (isDeepStrictEqual(actual, expected)) {\n innerFail({\n actual: actual,\n expected: expected,\n message: message,\n operator: 'notDeepStrictEqual',\n stackStartFn: notDeepStrictEqual\n });\n }\n}\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n if (arguments.length < 2) {\n throw new ERR_MISSING_ARGS('actual', 'expected');\n }\n\n if (!objectIs(actual, expected)) {\n innerFail({\n actual: actual,\n expected: expected,\n message: message,\n operator: 'strictEqual',\n stackStartFn: strictEqual\n });\n }\n};\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n if (arguments.length < 2) {\n throw new ERR_MISSING_ARGS('actual', 'expected');\n }\n\n if (objectIs(actual, expected)) {\n innerFail({\n actual: actual,\n expected: expected,\n message: message,\n operator: 'notStrictEqual',\n stackStartFn: notStrictEqual\n });\n }\n};\n\nvar Comparison = function Comparison(obj, keys, actual) {\n var _this = this;\n\n _classCallCheck(this, Comparison);\n\n keys.forEach(function (key) {\n if (key in obj) {\n if (actual !== undefined && typeof actual[key] === 'string' && isRegExp(obj[key]) && obj[key].test(actual[key])) {\n _this[key] = actual[key];\n } else {\n _this[key] = obj[key];\n }\n }\n });\n};\n\nfunction compareExceptionKey(actual, expected, key, message, keys, fn) {\n if (!(key in actual) || !isDeepStrictEqual(actual[key], expected[key])) {\n if (!message) {\n // Create placeholder objects to create a nice output.\n var a = new Comparison(actual, keys);\n var b = new Comparison(expected, keys, actual);\n var err = new AssertionError({\n actual: a,\n expected: b,\n operator: 'deepStrictEqual',\n stackStartFn: fn\n });\n err.actual = actual;\n err.expected = expected;\n err.operator = fn.name;\n throw err;\n }\n\n innerFail({\n actual: actual,\n expected: expected,\n message: message,\n operator: fn.name,\n stackStartFn: fn\n });\n }\n}\n\nfunction expectedException(actual, expected, msg, fn) {\n if (typeof expected !== 'function') {\n if (isRegExp(expected)) return expected.test(actual); // assert.doesNotThrow does not accept objects.\n\n if (arguments.length === 2) {\n throw new ERR_INVALID_ARG_TYPE('expected', ['Function', 'RegExp'], expected);\n } // Handle primitives properly.\n\n\n if (_typeof(actual) !== 'object' || actual === null) {\n var err = new AssertionError({\n actual: actual,\n expected: expected,\n message: msg,\n operator: 'deepStrictEqual',\n stackStartFn: fn\n });\n err.operator = fn.name;\n throw err;\n }\n\n var keys = Object.keys(expected); // Special handle errors to make sure the name and the message are compared\n // as well.\n\n if (expected instanceof Error) {\n keys.push('name', 'message');\n } else if (keys.length === 0) {\n throw new ERR_INVALID_ARG_VALUE('error', expected, 'may not be an empty object');\n }\n\n if (isDeepEqual === undefined) lazyLoadComparison();\n keys.forEach(function (key) {\n if (typeof actual[key] === 'string' && isRegExp(expected[key]) && expected[key].test(actual[key])) {\n return;\n }\n\n compareExceptionKey(actual, expected, key, msg, keys, fn);\n });\n return true;\n } // Guard instanceof against arrow functions as they don't have a prototype.\n\n\n if (expected.prototype !== undefined && actual instanceof expected) {\n return true;\n }\n\n if (Error.isPrototypeOf(expected)) {\n return false;\n }\n\n return expected.call({}, actual) === true;\n}\n\nfunction getActual(fn) {\n if (typeof fn !== 'function') {\n throw new ERR_INVALID_ARG_TYPE('fn', 'Function', fn);\n }\n\n try {\n fn();\n } catch (e) {\n return e;\n }\n\n return NO_EXCEPTION_SENTINEL;\n}\n\nfunction checkIsPromise(obj) {\n // Accept native ES6 promises and promises that are implemented in a similar\n // way. Do not accept thenables that use a function as `obj` and that have no\n // `catch` handler.\n // TODO: thenables are checked up until they have the correct methods,\n // but according to documentation, the `then` method should receive\n // the `fulfill` and `reject` arguments as well or it may be never resolved.\n return isPromise(obj) || obj !== null && _typeof(obj) === 'object' && typeof obj.then === 'function' && typeof obj.catch === 'function';\n}\n\nfunction waitForActual(promiseFn) {\n return Promise.resolve().then(function () {\n var resultPromise;\n\n if (typeof promiseFn === 'function') {\n // Return a rejected promise if `promiseFn` throws synchronously.\n resultPromise = promiseFn(); // Fail in case no promise is returned.\n\n if (!checkIsPromise(resultPromise)) {\n throw new ERR_INVALID_RETURN_VALUE('instance of Promise', 'promiseFn', resultPromise);\n }\n } else if (checkIsPromise(promiseFn)) {\n resultPromise = promiseFn;\n } else {\n throw new ERR_INVALID_ARG_TYPE('promiseFn', ['Function', 'Promise'], promiseFn);\n }\n\n return Promise.resolve().then(function () {\n return resultPromise;\n }).then(function () {\n return NO_EXCEPTION_SENTINEL;\n }).catch(function (e) {\n return e;\n });\n });\n}\n\nfunction expectsError(stackStartFn, actual, error, message) {\n if (typeof error === 'string') {\n if (arguments.length === 4) {\n throw new ERR_INVALID_ARG_TYPE('error', ['Object', 'Error', 'Function', 'RegExp'], error);\n }\n\n if (_typeof(actual) === 'object' && actual !== null) {\n if (actual.message === error) {\n throw new ERR_AMBIGUOUS_ARGUMENT('error/message', \"The error message \\\"\".concat(actual.message, \"\\\" is identical to the message.\"));\n }\n } else if (actual === error) {\n throw new ERR_AMBIGUOUS_ARGUMENT('error/message', \"The error \\\"\".concat(actual, \"\\\" is identical to the message.\"));\n }\n\n message = error;\n error = undefined;\n } else if (error != null && _typeof(error) !== 'object' && typeof error !== 'function') {\n throw new ERR_INVALID_ARG_TYPE('error', ['Object', 'Error', 'Function', 'RegExp'], error);\n }\n\n if (actual === NO_EXCEPTION_SENTINEL) {\n var details = '';\n\n if (error && error.name) {\n details += \" (\".concat(error.name, \")\");\n }\n\n details += message ? \": \".concat(message) : '.';\n var fnType = stackStartFn.name === 'rejects' ? 'rejection' : 'exception';\n innerFail({\n actual: undefined,\n expected: error,\n operator: stackStartFn.name,\n message: \"Missing expected \".concat(fnType).concat(details),\n stackStartFn: stackStartFn\n });\n }\n\n if (error && !expectedException(actual, error, message, stackStartFn)) {\n throw actual;\n }\n}\n\nfunction expectsNoError(stackStartFn, actual, error, message) {\n if (actual === NO_EXCEPTION_SENTINEL) return;\n\n if (typeof error === 'string') {\n message = error;\n error = undefined;\n }\n\n if (!error || expectedException(actual, error)) {\n var details = message ? \": \".concat(message) : '.';\n var fnType = stackStartFn.name === 'doesNotReject' ? 'rejection' : 'exception';\n innerFail({\n actual: actual,\n expected: error,\n operator: stackStartFn.name,\n message: \"Got unwanted \".concat(fnType).concat(details, \"\\n\") + \"Actual message: \\\"\".concat(actual && actual.message, \"\\\"\"),\n stackStartFn: stackStartFn\n });\n }\n\n throw actual;\n}\n\nassert.throws = function throws(promiseFn) {\n for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {\n args[_key2 - 1] = arguments[_key2];\n }\n\n expectsError.apply(void 0, [throws, getActual(promiseFn)].concat(args));\n};\n\nassert.rejects = function rejects(promiseFn) {\n for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {\n args[_key3 - 1] = arguments[_key3];\n }\n\n return waitForActual(promiseFn).then(function (result) {\n return expectsError.apply(void 0, [rejects, result].concat(args));\n });\n};\n\nassert.doesNotThrow = function doesNotThrow(fn) {\n for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {\n args[_key4 - 1] = arguments[_key4];\n }\n\n expectsNoError.apply(void 0, [doesNotThrow, getActual(fn)].concat(args));\n};\n\nassert.doesNotReject = function doesNotReject(fn) {\n for (var _len5 = arguments.length, args = new Array(_len5 > 1 ? _len5 - 1 : 0), _key5 = 1; _key5 < _len5; _key5++) {\n args[_key5 - 1] = arguments[_key5];\n }\n\n return waitForActual(fn).then(function (result) {\n return expectsNoError.apply(void 0, [doesNotReject, result].concat(args));\n });\n};\n\nassert.ifError = function ifError(err) {\n if (err !== null && err !== undefined) {\n var message = 'ifError got unwanted exception: ';\n\n if (_typeof(err) === 'object' && typeof err.message === 'string') {\n if (err.message.length === 0 && err.constructor) {\n message += err.constructor.name;\n } else {\n message += err.message;\n }\n } else {\n message += inspect(err);\n }\n\n var newErr = new AssertionError({\n actual: err,\n expected: null,\n operator: 'ifError',\n message: message,\n stackStartFn: ifError\n }); // Make sure we actually have a stack trace!\n\n var origStack = err.stack;\n\n if (typeof origStack === 'string') {\n // This will remove any duplicated frames from the error frames taken\n // from within `ifError` and add the original error frames to the newly\n // created ones.\n var tmp2 = origStack.split('\\n');\n tmp2.shift(); // Filter all frames existing in err.stack.\n\n var tmp1 = newErr.stack.split('\\n');\n\n for (var i = 0; i < tmp2.length; i++) {\n // Find the first occurrence of the frame.\n var pos = tmp1.indexOf(tmp2[i]);\n\n if (pos !== -1) {\n // Only keep new frames.\n tmp1 = tmp1.slice(0, pos);\n break;\n }\n }\n\n newErr.stack = \"\".concat(tmp1.join('\\n'), \"\\n\").concat(tmp2.join('\\n'));\n }\n\n throw newErr;\n }\n}; // Expose a strict only variant of assert\n\n\nfunction strict() {\n for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {\n args[_key6] = arguments[_key6];\n }\n\n innerOk.apply(void 0, [strict, args.length].concat(args));\n}\n\nassert.strict = objectAssign(strict, assert, {\n equal: assert.strictEqual,\n deepEqual: assert.deepStrictEqual,\n notEqual: assert.notStrictEqual,\n notDeepEqual: assert.notDeepStrictEqual\n});\nassert.strict.strict = assert.strict;","// Currently in sync with Node.js lib/internal/assert/assertion_error.js\n// https://github.com/nodejs/node/commit/0817840f775032169ddd70c85ac059f18ffcc81c\n'use strict';\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; var ownKeys = Object.keys(source); if (typeof Object.getOwnPropertySymbols === 'function') { ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { return Object.getOwnPropertyDescriptor(source, sym).enumerable; })); } ownKeys.forEach(function (key) { _defineProperty(target, key, source[key]); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _wrapNativeSuper(Class) { var _cache = typeof Map === \"function\" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== \"function\") { throw new TypeError(\"Super expression must either be null or a function\"); } if (typeof _cache !== \"undefined\") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }\n\nfunction isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\nfunction _construct(Parent, args, Class) { if (isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }\n\nfunction _isNativeFunction(fn) { return Function.toString.call(fn).indexOf(\"[native code]\") !== -1; }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nvar _require = require('util/'),\n inspect = _require.inspect;\n\nvar _require2 = require('../errors'),\n ERR_INVALID_ARG_TYPE = _require2.codes.ERR_INVALID_ARG_TYPE; // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\n\n\nfunction endsWith(str, search, this_len) {\n if (this_len === undefined || this_len > str.length) {\n this_len = str.length;\n }\n\n return str.substring(this_len - search.length, this_len) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat\n\n\nfunction repeat(str, count) {\n count = Math.floor(count);\n if (str.length == 0 || count == 0) return '';\n var maxCount = str.length * count;\n count = Math.floor(Math.log(count) / Math.log(2));\n\n while (count) {\n str += str;\n count--;\n }\n\n str += str.substring(0, maxCount - str.length);\n return str;\n}\n\nvar blue = '';\nvar green = '';\nvar red = '';\nvar white = '';\nvar kReadableOperator = {\n deepStrictEqual: 'Expected values to be strictly deep-equal:',\n strictEqual: 'Expected values to be strictly equal:',\n strictEqualObject: 'Expected \"actual\" to be reference-equal to \"expected\":',\n deepEqual: 'Expected values to be loosely deep-equal:',\n equal: 'Expected values to be loosely equal:',\n notDeepStrictEqual: 'Expected \"actual\" not to be strictly deep-equal to:',\n notStrictEqual: 'Expected \"actual\" to be strictly unequal to:',\n notStrictEqualObject: 'Expected \"actual\" not to be reference-equal to \"expected\":',\n notDeepEqual: 'Expected \"actual\" not to be loosely deep-equal to:',\n notEqual: 'Expected \"actual\" to be loosely unequal to:',\n notIdentical: 'Values identical but not reference-equal:'\n}; // Comparing short primitives should just show === / !== instead of using the\n// diff.\n\nvar kMaxShortLength = 10;\n\nfunction copyError(source) {\n var keys = Object.keys(source);\n var target = Object.create(Object.getPrototypeOf(source));\n keys.forEach(function (key) {\n target[key] = source[key];\n });\n Object.defineProperty(target, 'message', {\n value: source.message\n });\n return target;\n}\n\nfunction inspectValue(val) {\n // The util.inspect default values could be changed. This makes sure the\n // error messages contain the necessary information nevertheless.\n return inspect(val, {\n compact: false,\n customInspect: false,\n depth: 1000,\n maxArrayLength: Infinity,\n // Assert compares only enumerable properties (with a few exceptions).\n showHidden: false,\n // Having a long line as error is better than wrapping the line for\n // comparison for now.\n // TODO(BridgeAR): `breakLength` should be limited as soon as soon as we\n // have meta information about the inspected properties (i.e., know where\n // in what line the property starts and ends).\n breakLength: Infinity,\n // Assert does not detect proxies currently.\n showProxy: false,\n sorted: true,\n // Inspect getters as we also check them when comparing entries.\n getters: true\n });\n}\n\nfunction createErrDiff(actual, expected, operator) {\n var other = '';\n var res = '';\n var lastPos = 0;\n var end = '';\n var skipped = false;\n var actualInspected = inspectValue(actual);\n var actualLines = actualInspected.split('\\n');\n var expectedLines = inspectValue(expected).split('\\n');\n var i = 0;\n var indicator = ''; // In case both values are objects explicitly mark them as not reference equal\n // for the `strictEqual` operator.\n\n if (operator === 'strictEqual' && _typeof(actual) === 'object' && _typeof(expected) === 'object' && actual !== null && expected !== null) {\n operator = 'strictEqualObject';\n } // If \"actual\" and \"expected\" fit on a single line and they are not strictly\n // equal, check further special handling.\n\n\n if (actualLines.length === 1 && expectedLines.length === 1 && actualLines[0] !== expectedLines[0]) {\n var inputLength = actualLines[0].length + expectedLines[0].length; // If the character length of \"actual\" and \"expected\" together is less than\n // kMaxShortLength and if neither is an object and at least one of them is\n // not `zero`, use the strict equal comparison to visualize the output.\n\n if (inputLength <= kMaxShortLength) {\n if ((_typeof(actual) !== 'object' || actual === null) && (_typeof(expected) !== 'object' || expected === null) && (actual !== 0 || expected !== 0)) {\n // -0 === +0\n return \"\".concat(kReadableOperator[operator], \"\\n\\n\") + \"\".concat(actualLines[0], \" !== \").concat(expectedLines[0], \"\\n\");\n }\n } else if (operator !== 'strictEqualObject') {\n // If the stderr is a tty and the input length is lower than the current\n // columns per line, add a mismatch indicator below the output. If it is\n // not a tty, use a default value of 80 characters.\n var maxLength = process.stderr && process.stderr.isTTY ? process.stderr.columns : 80;\n\n if (inputLength < maxLength) {\n while (actualLines[0][i] === expectedLines[0][i]) {\n i++;\n } // Ignore the first characters.\n\n\n if (i > 2) {\n // Add position indicator for the first mismatch in case it is a\n // single line and the input length is less than the column length.\n indicator = \"\\n \".concat(repeat(' ', i), \"^\");\n i = 0;\n }\n }\n }\n } // Remove all ending lines that match (this optimizes the output for\n // readability by reducing the number of total changed lines).\n\n\n var a = actualLines[actualLines.length - 1];\n var b = expectedLines[expectedLines.length - 1];\n\n while (a === b) {\n if (i++ < 2) {\n end = \"\\n \".concat(a).concat(end);\n } else {\n other = a;\n }\n\n actualLines.pop();\n expectedLines.pop();\n if (actualLines.length === 0 || expectedLines.length === 0) break;\n a = actualLines[actualLines.length - 1];\n b = expectedLines[expectedLines.length - 1];\n }\n\n var maxLines = Math.max(actualLines.length, expectedLines.length); // Strict equal with identical objects that are not identical by reference.\n // E.g., assert.deepStrictEqual({ a: Symbol() }, { a: Symbol() })\n\n if (maxLines === 0) {\n // We have to get the result again. The lines were all removed before.\n var _actualLines = actualInspected.split('\\n'); // Only remove lines in case it makes sense to collapse those.\n // TODO: Accept env to always show the full error.\n\n\n if (_actualLines.length > 30) {\n _actualLines[26] = \"\".concat(blue, \"...\").concat(white);\n\n while (_actualLines.length > 27) {\n _actualLines.pop();\n }\n }\n\n return \"\".concat(kReadableOperator.notIdentical, \"\\n\\n\").concat(_actualLines.join('\\n'), \"\\n\");\n }\n\n if (i > 3) {\n end = \"\\n\".concat(blue, \"...\").concat(white).concat(end);\n skipped = true;\n }\n\n if (other !== '') {\n end = \"\\n \".concat(other).concat(end);\n other = '';\n }\n\n var printedLines = 0;\n var msg = kReadableOperator[operator] + \"\\n\".concat(green, \"+ actual\").concat(white, \" \").concat(red, \"- expected\").concat(white);\n var skippedMsg = \" \".concat(blue, \"...\").concat(white, \" Lines skipped\");\n\n for (i = 0; i < maxLines; i++) {\n // Only extra expected lines exist\n var cur = i - lastPos;\n\n if (actualLines.length < i + 1) {\n // If the last diverging line is more than one line above and the\n // current line is at least line three, add some of the former lines and\n // also add dots to indicate skipped entries.\n if (cur > 1 && i > 2) {\n if (cur > 4) {\n res += \"\\n\".concat(blue, \"...\").concat(white);\n skipped = true;\n } else if (cur > 3) {\n res += \"\\n \".concat(expectedLines[i - 2]);\n printedLines++;\n }\n\n res += \"\\n \".concat(expectedLines[i - 1]);\n printedLines++;\n } // Mark the current line as the last diverging one.\n\n\n lastPos = i; // Add the expected line to the cache.\n\n other += \"\\n\".concat(red, \"-\").concat(white, \" \").concat(expectedLines[i]);\n printedLines++; // Only extra actual lines exist\n } else if (expectedLines.length < i + 1) {\n // If the last diverging line is more than one line above and the\n // current line is at least line three, add some of the former lines and\n // also add dots to indicate skipped entries.\n if (cur > 1 && i > 2) {\n if (cur > 4) {\n res += \"\\n\".concat(blue, \"...\").concat(white);\n skipped = true;\n } else if (cur > 3) {\n res += \"\\n \".concat(actualLines[i - 2]);\n printedLines++;\n }\n\n res += \"\\n \".concat(actualLines[i - 1]);\n printedLines++;\n } // Mark the current line as the last diverging one.\n\n\n lastPos = i; // Add the actual line to the result.\n\n res += \"\\n\".concat(green, \"+\").concat(white, \" \").concat(actualLines[i]);\n printedLines++; // Lines diverge\n } else {\n var expectedLine = expectedLines[i];\n var actualLine = actualLines[i]; // If the lines diverge, specifically check for lines that only diverge by\n // a trailing comma. In that case it is actually identical and we should\n // mark it as such.\n\n var divergingLines = actualLine !== expectedLine && (!endsWith(actualLine, ',') || actualLine.slice(0, -1) !== expectedLine); // If the expected line has a trailing comma but is otherwise identical,\n // add a comma at the end of the actual line. Otherwise the output could\n // look weird as in:\n //\n // [\n // 1 // No comma at the end!\n // + 2\n // ]\n //\n\n if (divergingLines && endsWith(expectedLine, ',') && expectedLine.slice(0, -1) === actualLine) {\n divergingLines = false;\n actualLine += ',';\n }\n\n if (divergingLines) {\n // If the last diverging line is more than one line above and the\n // current line is at least line three, add some of the former lines and\n // also add dots to indicate skipped entries.\n if (cur > 1 && i > 2) {\n if (cur > 4) {\n res += \"\\n\".concat(blue, \"...\").concat(white);\n skipped = true;\n } else if (cur > 3) {\n res += \"\\n \".concat(actualLines[i - 2]);\n printedLines++;\n }\n\n res += \"\\n \".concat(actualLines[i - 1]);\n printedLines++;\n } // Mark the current line as the last diverging one.\n\n\n lastPos = i; // Add the actual line to the result and cache the expected diverging\n // line so consecutive diverging lines show up as +++--- and not +-+-+-.\n\n res += \"\\n\".concat(green, \"+\").concat(white, \" \").concat(actualLine);\n other += \"\\n\".concat(red, \"-\").concat(white, \" \").concat(expectedLine);\n printedLines += 2; // Lines are identical\n } else {\n // Add all cached information to the result before adding other things\n // and reset the cache.\n res += other;\n other = ''; // If the last diverging line is exactly one line above or if it is the\n // very first line, add the line to the result.\n\n if (cur === 1 || i === 0) {\n res += \"\\n \".concat(actualLine);\n printedLines++;\n }\n }\n } // Inspected object to big (Show ~20 rows max)\n\n\n if (printedLines > 20 && i < maxLines - 2) {\n return \"\".concat(msg).concat(skippedMsg, \"\\n\").concat(res, \"\\n\").concat(blue, \"...\").concat(white).concat(other, \"\\n\") + \"\".concat(blue, \"...\").concat(white);\n }\n }\n\n return \"\".concat(msg).concat(skipped ? skippedMsg : '', \"\\n\").concat(res).concat(other).concat(end).concat(indicator);\n}\n\nvar AssertionError =\n/*#__PURE__*/\nfunction (_Error) {\n _inherits(AssertionError, _Error);\n\n function AssertionError(options) {\n var _this;\n\n _classCallCheck(this, AssertionError);\n\n if (_typeof(options) !== 'object' || options === null) {\n throw new ERR_INVALID_ARG_TYPE('options', 'Object', options);\n }\n\n var message = options.message,\n operator = options.operator,\n stackStartFn = options.stackStartFn;\n var actual = options.actual,\n expected = options.expected;\n var limit = Error.stackTraceLimit;\n Error.stackTraceLimit = 0;\n\n if (message != null) {\n _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, String(message)));\n } else {\n if (process.stderr && process.stderr.isTTY) {\n // Reset on each call to make sure we handle dynamically set environment\n // variables correct.\n if (process.stderr && process.stderr.getColorDepth && process.stderr.getColorDepth() !== 1) {\n blue = \"\\x1B[34m\";\n green = \"\\x1B[32m\";\n white = \"\\x1B[39m\";\n red = \"\\x1B[31m\";\n } else {\n blue = '';\n green = '';\n white = '';\n red = '';\n }\n } // Prevent the error stack from being visible by duplicating the error\n // in a very close way to the original in case both sides are actually\n // instances of Error.\n\n\n if (_typeof(actual) === 'object' && actual !== null && _typeof(expected) === 'object' && expected !== null && 'stack' in actual && actual instanceof Error && 'stack' in expected && expected instanceof Error) {\n actual = copyError(actual);\n expected = copyError(expected);\n }\n\n if (operator === 'deepStrictEqual' || operator === 'strictEqual') {\n _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, createErrDiff(actual, expected, operator)));\n } else if (operator === 'notDeepStrictEqual' || operator === 'notStrictEqual') {\n // In case the objects are equal but the operator requires unequal, show\n // the first object and say A equals B\n var base = kReadableOperator[operator];\n var res = inspectValue(actual).split('\\n'); // In case \"actual\" is an object, it should not be reference equal.\n\n if (operator === 'notStrictEqual' && _typeof(actual) === 'object' && actual !== null) {\n base = kReadableOperator.notStrictEqualObject;\n } // Only remove lines in case it makes sense to collapse those.\n // TODO: Accept env to always show the full error.\n\n\n if (res.length > 30) {\n res[26] = \"\".concat(blue, \"...\").concat(white);\n\n while (res.length > 27) {\n res.pop();\n }\n } // Only print a single input.\n\n\n if (res.length === 1) {\n _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, \"\".concat(base, \" \").concat(res[0])));\n } else {\n _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, \"\".concat(base, \"\\n\\n\").concat(res.join('\\n'), \"\\n\")));\n }\n } else {\n var _res = inspectValue(actual);\n\n var other = '';\n var knownOperators = kReadableOperator[operator];\n\n if (operator === 'notDeepEqual' || operator === 'notEqual') {\n _res = \"\".concat(kReadableOperator[operator], \"\\n\\n\").concat(_res);\n\n if (_res.length > 1024) {\n _res = \"\".concat(_res.slice(0, 1021), \"...\");\n }\n } else {\n other = \"\".concat(inspectValue(expected));\n\n if (_res.length > 512) {\n _res = \"\".concat(_res.slice(0, 509), \"...\");\n }\n\n if (other.length > 512) {\n other = \"\".concat(other.slice(0, 509), \"...\");\n }\n\n if (operator === 'deepEqual' || operator === 'equal') {\n _res = \"\".concat(knownOperators, \"\\n\\n\").concat(_res, \"\\n\\nshould equal\\n\\n\");\n } else {\n other = \" \".concat(operator, \" \").concat(other);\n }\n }\n\n _this = _possibleConstructorReturn(this, _getPrototypeOf(AssertionError).call(this, \"\".concat(_res).concat(other)));\n }\n }\n\n Error.stackTraceLimit = limit;\n _this.generatedMessage = !message;\n Object.defineProperty(_assertThisInitialized(_this), 'name', {\n value: 'AssertionError [ERR_ASSERTION]',\n enumerable: false,\n writable: true,\n configurable: true\n });\n _this.code = 'ERR_ASSERTION';\n _this.actual = actual;\n _this.expected = expected;\n _this.operator = operator;\n\n if (Error.captureStackTrace) {\n // eslint-disable-next-line no-restricted-syntax\n Error.captureStackTrace(_assertThisInitialized(_this), stackStartFn);\n } // Create error message including the error code in the name.\n\n\n _this.stack; // Reset the name.\n\n _this.name = 'AssertionError';\n return _possibleConstructorReturn(_this);\n }\n\n _createClass(AssertionError, [{\n key: \"toString\",\n value: function toString() {\n return \"\".concat(this.name, \" [\").concat(this.code, \"]: \").concat(this.message);\n }\n }, {\n key: inspect.custom,\n value: function value(recurseTimes, ctx) {\n // This limits the `actual` and `expected` property default inspection to\n // the minimum depth. Otherwise those values would be too verbose compared\n // to the actual error message which contains a combined view of these two\n // input values.\n return inspect(this, _objectSpread({}, ctx, {\n customInspect: false,\n depth: 0\n }));\n }\n }]);\n\n return AssertionError;\n}(_wrapNativeSuper(Error));\n\nmodule.exports = AssertionError;","// Currently in sync with Node.js lib/internal/errors.js\n// https://github.com/nodejs/node/commit/3b044962c48fe313905877a96b5d0894a5404f6f\n\n/* eslint node-core/documented-errors: \"error\" */\n\n/* eslint node-core/alphabetize-errors: \"error\" */\n\n/* eslint node-core/prefer-util-format-errors: \"error\" */\n'use strict'; // The whole point behind this internal module is to allow Node.js to no\n// longer be forced to treat every error message change as a semver-major\n// change. The NodeError classes here all expose a `code` property whose\n// value statically and permanently identifies the error. While the error\n// message may change, the code should not.\n\nfunction _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) { return call; } return _assertThisInitialized(self); }\n\nfunction _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return self; }\n\nfunction _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }\n\nfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function\"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }\n\nfunction _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }\n\nvar codes = {}; // Lazy loaded\n\nvar assert;\nvar util;\n\nfunction createErrorType(code, message, Base) {\n if (!Base) {\n Base = Error;\n }\n\n function getMessage(arg1, arg2, arg3) {\n if (typeof message === 'string') {\n return message;\n } else {\n return message(arg1, arg2, arg3);\n }\n }\n\n var NodeError =\n /*#__PURE__*/\n function (_Base) {\n _inherits(NodeError, _Base);\n\n function NodeError(arg1, arg2, arg3) {\n var _this;\n\n _classCallCheck(this, NodeError);\n\n _this = _possibleConstructorReturn(this, _getPrototypeOf(NodeError).call(this, getMessage(arg1, arg2, arg3)));\n _this.code = code;\n return _this;\n }\n\n return NodeError;\n }(Base);\n\n codes[code] = NodeError;\n} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js\n\n\nfunction oneOf(expected, thing) {\n if (Array.isArray(expected)) {\n var len = expected.length;\n expected = expected.map(function (i) {\n return String(i);\n });\n\n if (len > 2) {\n return \"one of \".concat(thing, \" \").concat(expected.slice(0, len - 1).join(', '), \", or \") + expected[len - 1];\n } else if (len === 2) {\n return \"one of \".concat(thing, \" \").concat(expected[0], \" or \").concat(expected[1]);\n } else {\n return \"of \".concat(thing, \" \").concat(expected[0]);\n }\n } else {\n return \"of \".concat(thing, \" \").concat(String(expected));\n }\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith\n\n\nfunction startsWith(str, search, pos) {\n return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\n\n\nfunction endsWith(str, search, this_len) {\n if (this_len === undefined || this_len > str.length) {\n this_len = str.length;\n }\n\n return str.substring(this_len - search.length, this_len) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes\n\n\nfunction includes(str, search, start) {\n if (typeof start !== 'number') {\n start = 0;\n }\n\n if (start + search.length > str.length) {\n return false;\n } else {\n return str.indexOf(search, start) !== -1;\n }\n}\n\ncreateErrorType('ERR_AMBIGUOUS_ARGUMENT', 'The \"%s\" argument is ambiguous. %s', TypeError);\ncreateErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {\n if (assert === undefined) assert = require('../assert');\n assert(typeof name === 'string', \"'name' must be a string\"); // determiner: 'must be' or 'must not be'\n\n var determiner;\n\n if (typeof expected === 'string' && startsWith(expected, 'not ')) {\n determiner = 'must not be';\n expected = expected.replace(/^not /, '');\n } else {\n determiner = 'must be';\n }\n\n var msg;\n\n if (endsWith(name, ' argument')) {\n // For cases like 'first argument'\n msg = \"The \".concat(name, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n } else {\n var type = includes(name, '.') ? 'property' : 'argument';\n msg = \"The \\\"\".concat(name, \"\\\" \").concat(type, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n } // TODO(BridgeAR): Improve the output by showing `null` and similar.\n\n\n msg += \". Received type \".concat(_typeof(actual));\n return msg;\n}, TypeError);\ncreateErrorType('ERR_INVALID_ARG_VALUE', function (name, value) {\n var reason = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'is invalid';\n if (util === undefined) util = require('util/');\n var inspected = util.inspect(value);\n\n if (inspected.length > 128) {\n inspected = \"\".concat(inspected.slice(0, 128), \"...\");\n }\n\n return \"The argument '\".concat(name, \"' \").concat(reason, \". Received \").concat(inspected);\n}, TypeError, RangeError);\ncreateErrorType('ERR_INVALID_RETURN_VALUE', function (input, name, value) {\n var type;\n\n if (value && value.constructor && value.constructor.name) {\n type = \"instance of \".concat(value.constructor.name);\n } else {\n type = \"type \".concat(_typeof(value));\n }\n\n return \"Expected \".concat(input, \" to be returned from the \\\"\").concat(name, \"\\\"\") + \" function but got \".concat(type, \".\");\n}, TypeError);\ncreateErrorType('ERR_MISSING_ARGS', function () {\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n if (assert === undefined) assert = require('../assert');\n assert(args.length > 0, 'At least one arg needs to be specified');\n var msg = 'The ';\n var len = args.length;\n args = args.map(function (a) {\n return \"\\\"\".concat(a, \"\\\"\");\n });\n\n switch (len) {\n case 1:\n msg += \"\".concat(args[0], \" argument\");\n break;\n\n case 2:\n msg += \"\".concat(args[0], \" and \").concat(args[1], \" arguments\");\n break;\n\n default:\n msg += args.slice(0, len - 1).join(', ');\n msg += \", and \".concat(args[len - 1], \" arguments\");\n break;\n }\n\n return \"\".concat(msg, \" must be specified\");\n}, TypeError);\nmodule.exports.codes = codes;","// Currently in sync with Node.js lib/internal/util/comparisons.js\n// https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9\n'use strict';\n\nfunction _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }\n\nfunction _nonIterableRest() { throw new TypeError(\"Invalid attempt to destructure non-iterable instance\"); }\n\nfunction _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i[\"return\"] != null) _i[\"return\"](); } finally { if (_d) throw _e; } } return _arr; }\n\nfunction _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }\n\nfunction _typeof(obj) { if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; }; } return _typeof(obj); }\n\nvar regexFlagsSupported = /a/g.flags !== undefined;\n\nvar arrayFromSet = function arrayFromSet(set) {\n var array = [];\n set.forEach(function (value) {\n return array.push(value);\n });\n return array;\n};\n\nvar arrayFromMap = function arrayFromMap(map) {\n var array = [];\n map.forEach(function (value, key) {\n return array.push([key, value]);\n });\n return array;\n};\n\nvar objectIs = Object.is ? Object.is : require('object-is');\nvar objectGetOwnPropertySymbols = Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols : function () {\n return [];\n};\nvar numberIsNaN = Number.isNaN ? Number.isNaN : require('is-nan');\n\nfunction uncurryThis(f) {\n return f.call.bind(f);\n}\n\nvar hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);\nvar propertyIsEnumerable = uncurryThis(Object.prototype.propertyIsEnumerable);\nvar objectToString = uncurryThis(Object.prototype.toString);\n\nvar _require$types = require('util/').types,\n isAnyArrayBuffer = _require$types.isAnyArrayBuffer,\n isArrayBufferView = _require$types.isArrayBufferView,\n isDate = _require$types.isDate,\n isMap = _require$types.isMap,\n isRegExp = _require$types.isRegExp,\n isSet = _require$types.isSet,\n isNativeError = _require$types.isNativeError,\n isBoxedPrimitive = _require$types.isBoxedPrimitive,\n isNumberObject = _require$types.isNumberObject,\n isStringObject = _require$types.isStringObject,\n isBooleanObject = _require$types.isBooleanObject,\n isBigIntObject = _require$types.isBigIntObject,\n isSymbolObject = _require$types.isSymbolObject,\n isFloat32Array = _require$types.isFloat32Array,\n isFloat64Array = _require$types.isFloat64Array;\n\nfunction isNonIndex(key) {\n if (key.length === 0 || key.length > 10) return true;\n\n for (var i = 0; i < key.length; i++) {\n var code = key.charCodeAt(i);\n if (code < 48 || code > 57) return true;\n } // The maximum size for an array is 2 ** 32 -1.\n\n\n return key.length === 10 && key >= Math.pow(2, 32);\n}\n\nfunction getOwnNonIndexProperties(value) {\n return Object.keys(value).filter(isNonIndex).concat(objectGetOwnPropertySymbols(value).filter(Object.prototype.propertyIsEnumerable.bind(value)));\n} // Taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license MIT\n */\n\n\nfunction compare(a, b) {\n if (a === b) {\n return 0;\n }\n\n var x = a.length;\n var y = b.length;\n\n for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i];\n y = b[i];\n break;\n }\n }\n\n if (x < y) {\n return -1;\n }\n\n if (y < x) {\n return 1;\n }\n\n return 0;\n}\n\nvar ONLY_ENUMERABLE = undefined;\nvar kStrict = true;\nvar kLoose = false;\nvar kNoIterator = 0;\nvar kIsArray = 1;\nvar kIsSet = 2;\nvar kIsMap = 3; // Check if they have the same source and flags\n\nfunction areSimilarRegExps(a, b) {\n return regexFlagsSupported ? a.source === b.source && a.flags === b.flags : RegExp.prototype.toString.call(a) === RegExp.prototype.toString.call(b);\n}\n\nfunction areSimilarFloatArrays(a, b) {\n if (a.byteLength !== b.byteLength) {\n return false;\n }\n\n for (var offset = 0; offset < a.byteLength; offset++) {\n if (a[offset] !== b[offset]) {\n return false;\n }\n }\n\n return true;\n}\n\nfunction areSimilarTypedArrays(a, b) {\n if (a.byteLength !== b.byteLength) {\n return false;\n }\n\n return compare(new Uint8Array(a.buffer, a.byteOffset, a.byteLength), new Uint8Array(b.buffer, b.byteOffset, b.byteLength)) === 0;\n}\n\nfunction areEqualArrayBuffers(buf1, buf2) {\n return buf1.byteLength === buf2.byteLength && compare(new Uint8Array(buf1), new Uint8Array(buf2)) === 0;\n}\n\nfunction isEqualBoxedPrimitive(val1, val2) {\n if (isNumberObject(val1)) {\n return isNumberObject(val2) && objectIs(Number.prototype.valueOf.call(val1), Number.prototype.valueOf.call(val2));\n }\n\n if (isStringObject(val1)) {\n return isStringObject(val2) && String.prototype.valueOf.call(val1) === String.prototype.valueOf.call(val2);\n }\n\n if (isBooleanObject(val1)) {\n return isBooleanObject(val2) && Boolean.prototype.valueOf.call(val1) === Boolean.prototype.valueOf.call(val2);\n }\n\n if (isBigIntObject(val1)) {\n return isBigIntObject(val2) && BigInt.prototype.valueOf.call(val1) === BigInt.prototype.valueOf.call(val2);\n }\n\n return isSymbolObject(val2) && Symbol.prototype.valueOf.call(val1) === Symbol.prototype.valueOf.call(val2);\n} // Notes: Type tags are historical [[Class]] properties that can be set by\n// FunctionTemplate::SetClassName() in C++ or Symbol.toStringTag in JS\n// and retrieved using Object.prototype.toString.call(obj) in JS\n// See https://tc39.github.io/ecma262/#sec-object.prototype.tostring\n// for a list of tags pre-defined in the spec.\n// There are some unspecified tags in the wild too (e.g. typed array tags).\n// Since tags can be altered, they only serve fast failures\n//\n// Typed arrays and buffers are checked by comparing the content in their\n// underlying ArrayBuffer. This optimization requires that it's\n// reasonable to interpret their underlying memory in the same way,\n// which is checked by comparing their type tags.\n// (e.g. a Uint8Array and a Uint16Array with the same memory content\n// could still be different because they will be interpreted differently).\n//\n// For strict comparison, objects should have\n// a) The same built-in type tags\n// b) The same prototypes.\n\n\nfunction innerDeepEqual(val1, val2, strict, memos) {\n // All identical values are equivalent, as determined by ===.\n if (val1 === val2) {\n if (val1 !== 0) return true;\n return strict ? objectIs(val1, val2) : true;\n } // Check more closely if val1 and val2 are equal.\n\n\n if (strict) {\n if (_typeof(val1) !== 'object') {\n return typeof val1 === 'number' && numberIsNaN(val1) && numberIsNaN(val2);\n }\n\n if (_typeof(val2) !== 'object' || val1 === null || val2 === null) {\n return false;\n }\n\n if (Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {\n return false;\n }\n } else {\n if (val1 === null || _typeof(val1) !== 'object') {\n if (val2 === null || _typeof(val2) !== 'object') {\n // eslint-disable-next-line eqeqeq\n return val1 == val2;\n }\n\n return false;\n }\n\n if (val2 === null || _typeof(val2) !== 'object') {\n return false;\n }\n }\n\n var val1Tag = objectToString(val1);\n var val2Tag = objectToString(val2);\n\n if (val1Tag !== val2Tag) {\n return false;\n }\n\n if (Array.isArray(val1)) {\n // Check for sparse arrays and general fast path\n if (val1.length !== val2.length) {\n return false;\n }\n\n var keys1 = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);\n var keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);\n\n if (keys1.length !== keys2.length) {\n return false;\n }\n\n return keyCheck(val1, val2, strict, memos, kIsArray, keys1);\n } // [browserify] This triggers on certain types in IE (Map/Set) so we don't\n // wan't to early return out of the rest of the checks. However we can check\n // if the second value is one of these values and the first isn't.\n\n\n if (val1Tag === '[object Object]') {\n // return keyCheck(val1, val2, strict, memos, kNoIterator);\n if (!isMap(val1) && isMap(val2) || !isSet(val1) && isSet(val2)) {\n return false;\n }\n }\n\n if (isDate(val1)) {\n if (!isDate(val2) || Date.prototype.getTime.call(val1) !== Date.prototype.getTime.call(val2)) {\n return false;\n }\n } else if (isRegExp(val1)) {\n if (!isRegExp(val2) || !areSimilarRegExps(val1, val2)) {\n return false;\n }\n } else if (isNativeError(val1) || val1 instanceof Error) {\n // Do not compare the stack as it might differ even though the error itself\n // is otherwise identical.\n if (val1.message !== val2.message || val1.name !== val2.name) {\n return false;\n }\n } else if (isArrayBufferView(val1)) {\n if (!strict && (isFloat32Array(val1) || isFloat64Array(val1))) {\n if (!areSimilarFloatArrays(val1, val2)) {\n return false;\n }\n } else if (!areSimilarTypedArrays(val1, val2)) {\n return false;\n } // Buffer.compare returns true, so val1.length === val2.length. If they both\n // only contain numeric keys, we don't need to exam further than checking\n // the symbols.\n\n\n var _keys = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);\n\n var _keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);\n\n if (_keys.length !== _keys2.length) {\n return false;\n }\n\n return keyCheck(val1, val2, strict, memos, kNoIterator, _keys);\n } else if (isSet(val1)) {\n if (!isSet(val2) || val1.size !== val2.size) {\n return false;\n }\n\n return keyCheck(val1, val2, strict, memos, kIsSet);\n } else if (isMap(val1)) {\n if (!isMap(val2) || val1.size !== val2.size) {\n return false;\n }\n\n return keyCheck(val1, val2, strict, memos, kIsMap);\n } else if (isAnyArrayBuffer(val1)) {\n if (!areEqualArrayBuffers(val1, val2)) {\n return false;\n }\n } else if (isBoxedPrimitive(val1) && !isEqualBoxedPrimitive(val1, val2)) {\n return false;\n }\n\n return keyCheck(val1, val2, strict, memos, kNoIterator);\n}\n\nfunction getEnumerables(val, keys) {\n return keys.filter(function (k) {\n return propertyIsEnumerable(val, k);\n });\n}\n\nfunction keyCheck(val1, val2, strict, memos, iterationType, aKeys) {\n // For all remaining Object pairs, including Array, objects and Maps,\n // equivalence is determined by having:\n // a) The same number of owned enumerable properties\n // b) The same set of keys/indexes (although not necessarily the same order)\n // c) Equivalent values for every corresponding key/index\n // d) For Sets and Maps, equal contents\n // Note: this accounts for both named and indexed properties on Arrays.\n if (arguments.length === 5) {\n aKeys = Object.keys(val1);\n var bKeys = Object.keys(val2); // The pair must have the same number of owned properties.\n\n if (aKeys.length !== bKeys.length) {\n return false;\n }\n } // Cheap key test\n\n\n var i = 0;\n\n for (; i < aKeys.length; i++) {\n if (!hasOwnProperty(val2, aKeys[i])) {\n return false;\n }\n }\n\n if (strict && arguments.length === 5) {\n var symbolKeysA = objectGetOwnPropertySymbols(val1);\n\n if (symbolKeysA.length !== 0) {\n var count = 0;\n\n for (i = 0; i < symbolKeysA.length; i++) {\n var key = symbolKeysA[i];\n\n if (propertyIsEnumerable(val1, key)) {\n if (!propertyIsEnumerable(val2, key)) {\n return false;\n }\n\n aKeys.push(key);\n count++;\n } else if (propertyIsEnumerable(val2, key)) {\n return false;\n }\n }\n\n var symbolKeysB = objectGetOwnPropertySymbols(val2);\n\n if (symbolKeysA.length !== symbolKeysB.length && getEnumerables(val2, symbolKeysB).length !== count) {\n return false;\n }\n } else {\n var _symbolKeysB = objectGetOwnPropertySymbols(val2);\n\n if (_symbolKeysB.length !== 0 && getEnumerables(val2, _symbolKeysB).length !== 0) {\n return false;\n }\n }\n }\n\n if (aKeys.length === 0 && (iterationType === kNoIterator || iterationType === kIsArray && val1.length === 0 || val1.size === 0)) {\n return true;\n } // Use memos to handle cycles.\n\n\n if (memos === undefined) {\n memos = {\n val1: new Map(),\n val2: new Map(),\n position: 0\n };\n } else {\n // We prevent up to two map.has(x) calls by directly retrieving the value\n // and checking for undefined. The map can only contain numbers, so it is\n // safe to check for undefined only.\n var val2MemoA = memos.val1.get(val1);\n\n if (val2MemoA !== undefined) {\n var val2MemoB = memos.val2.get(val2);\n\n if (val2MemoB !== undefined) {\n return val2MemoA === val2MemoB;\n }\n }\n\n memos.position++;\n }\n\n memos.val1.set(val1, memos.position);\n memos.val2.set(val2, memos.position);\n var areEq = objEquiv(val1, val2, strict, aKeys, memos, iterationType);\n memos.val1.delete(val1);\n memos.val2.delete(val2);\n return areEq;\n}\n\nfunction setHasEqualElement(set, val1, strict, memo) {\n // Go looking.\n var setValues = arrayFromSet(set);\n\n for (var i = 0; i < setValues.length; i++) {\n var val2 = setValues[i];\n\n if (innerDeepEqual(val1, val2, strict, memo)) {\n // Remove the matching element to make sure we do not check that again.\n set.delete(val2);\n return true;\n }\n }\n\n return false;\n} // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness#Loose_equality_using\n// Sadly it is not possible to detect corresponding values properly in case the\n// type is a string, number, bigint or boolean. The reason is that those values\n// can match lots of different string values (e.g., 1n == '+00001').\n\n\nfunction findLooseMatchingPrimitives(prim) {\n switch (_typeof(prim)) {\n case 'undefined':\n return null;\n\n case 'object':\n // Only pass in null as object!\n return undefined;\n\n case 'symbol':\n return false;\n\n case 'string':\n prim = +prim;\n // Loose equal entries exist only if the string is possible to convert to\n // a regular number and not NaN.\n // Fall through\n\n case 'number':\n if (numberIsNaN(prim)) {\n return false;\n }\n\n }\n\n return true;\n}\n\nfunction setMightHaveLoosePrim(a, b, prim) {\n var altValue = findLooseMatchingPrimitives(prim);\n if (altValue != null) return altValue;\n return b.has(altValue) && !a.has(altValue);\n}\n\nfunction mapMightHaveLoosePrim(a, b, prim, item, memo) {\n var altValue = findLooseMatchingPrimitives(prim);\n\n if (altValue != null) {\n return altValue;\n }\n\n var curB = b.get(altValue);\n\n if (curB === undefined && !b.has(altValue) || !innerDeepEqual(item, curB, false, memo)) {\n return false;\n }\n\n return !a.has(altValue) && innerDeepEqual(item, curB, false, memo);\n}\n\nfunction setEquiv(a, b, strict, memo) {\n // This is a lazily initiated Set of entries which have to be compared\n // pairwise.\n var set = null;\n var aValues = arrayFromSet(a);\n\n for (var i = 0; i < aValues.length; i++) {\n var val = aValues[i]; // Note: Checking for the objects first improves the performance for object\n // heavy sets but it is a minor slow down for primitives. As they are fast\n // to check this improves the worst case scenario instead.\n\n if (_typeof(val) === 'object' && val !== null) {\n if (set === null) {\n set = new Set();\n } // If the specified value doesn't exist in the second set its an not null\n // object (or non strict only: a not matching primitive) we'll need to go\n // hunting for something thats deep-(strict-)equal to it. To make this\n // O(n log n) complexity we have to copy these values in a new set first.\n\n\n set.add(val);\n } else if (!b.has(val)) {\n if (strict) return false; // Fast path to detect missing string, symbol, undefined and null values.\n\n if (!setMightHaveLoosePrim(a, b, val)) {\n return false;\n }\n\n if (set === null) {\n set = new Set();\n }\n\n set.add(val);\n }\n }\n\n if (set !== null) {\n var bValues = arrayFromSet(b);\n\n for (var _i = 0; _i < bValues.length; _i++) {\n var _val = bValues[_i]; // We have to check if a primitive value is already\n // matching and only if it's not, go hunting for it.\n\n if (_typeof(_val) === 'object' && _val !== null) {\n if (!setHasEqualElement(set, _val, strict, memo)) return false;\n } else if (!strict && !a.has(_val) && !setHasEqualElement(set, _val, strict, memo)) {\n return false;\n }\n }\n\n return set.size === 0;\n }\n\n return true;\n}\n\nfunction mapHasEqualEntry(set, map, key1, item1, strict, memo) {\n // To be able to handle cases like:\n // Map([[{}, 'a'], [{}, 'b']]) vs Map([[{}, 'b'], [{}, 'a']])\n // ... we need to consider *all* matching keys, not just the first we find.\n var setValues = arrayFromSet(set);\n\n for (var i = 0; i < setValues.length; i++) {\n var key2 = setValues[i];\n\n if (innerDeepEqual(key1, key2, strict, memo) && innerDeepEqual(item1, map.get(key2), strict, memo)) {\n set.delete(key2);\n return true;\n }\n }\n\n return false;\n}\n\nfunction mapEquiv(a, b, strict, memo) {\n var set = null;\n var aEntries = arrayFromMap(a);\n\n for (var i = 0; i < aEntries.length; i++) {\n var _aEntries$i = _slicedToArray(aEntries[i], 2),\n key = _aEntries$i[0],\n item1 = _aEntries$i[1];\n\n if (_typeof(key) === 'object' && key !== null) {\n if (set === null) {\n set = new Set();\n }\n\n set.add(key);\n } else {\n // By directly retrieving the value we prevent another b.has(key) check in\n // almost all possible cases.\n var item2 = b.get(key);\n\n if (item2 === undefined && !b.has(key) || !innerDeepEqual(item1, item2, strict, memo)) {\n if (strict) return false; // Fast path to detect missing string, symbol, undefined and null\n // keys.\n\n if (!mapMightHaveLoosePrim(a, b, key, item1, memo)) return false;\n\n if (set === null) {\n set = new Set();\n }\n\n set.add(key);\n }\n }\n }\n\n if (set !== null) {\n var bEntries = arrayFromMap(b);\n\n for (var _i2 = 0; _i2 < bEntries.length; _i2++) {\n var _bEntries$_i = _slicedToArray(bEntries[_i2], 2),\n key = _bEntries$_i[0],\n item = _bEntries$_i[1];\n\n if (_typeof(key) === 'object' && key !== null) {\n if (!mapHasEqualEntry(set, a, key, item, strict, memo)) return false;\n } else if (!strict && (!a.has(key) || !innerDeepEqual(a.get(key), item, false, memo)) && !mapHasEqualEntry(set, a, key, item, false, memo)) {\n return false;\n }\n }\n\n return set.size === 0;\n }\n\n return true;\n}\n\nfunction objEquiv(a, b, strict, keys, memos, iterationType) {\n // Sets and maps don't have their entries accessible via normal object\n // properties.\n var i = 0;\n\n if (iterationType === kIsSet) {\n if (!setEquiv(a, b, strict, memos)) {\n return false;\n }\n } else if (iterationType === kIsMap) {\n if (!mapEquiv(a, b, strict, memos)) {\n return false;\n }\n } else if (iterationType === kIsArray) {\n for (; i < a.length; i++) {\n if (hasOwnProperty(a, i)) {\n if (!hasOwnProperty(b, i) || !innerDeepEqual(a[i], b[i], strict, memos)) {\n return false;\n }\n } else if (hasOwnProperty(b, i)) {\n return false;\n } else {\n // Array is sparse.\n var keysA = Object.keys(a);\n\n for (; i < keysA.length; i++) {\n var key = keysA[i];\n\n if (!hasOwnProperty(b, key) || !innerDeepEqual(a[key], b[key], strict, memos)) {\n return false;\n }\n }\n\n if (keysA.length !== Object.keys(b).length) {\n return false;\n }\n\n return true;\n }\n }\n } // The pair must have equivalent values for every corresponding key.\n // Possibly expensive deep test:\n\n\n for (i = 0; i < keys.length; i++) {\n var _key = keys[i];\n\n if (!innerDeepEqual(a[_key], b[_key], strict, memos)) {\n return false;\n }\n }\n\n return true;\n}\n\nfunction isDeepEqual(val1, val2) {\n return innerDeepEqual(val1, val2, kLoose);\n}\n\nfunction isDeepStrictEqual(val1, val2) {\n return innerDeepEqual(val1, val2, kStrict);\n}\n\nmodule.exports = {\n isDeepEqual: isDeepEqual,\n isDeepStrictEqual: isDeepStrictEqual\n};","'use strict'\n// base-x encoding / decoding\n// Copyright (c) 2018 base-x contributors\n// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)\n// Distributed under the MIT software license, see the accompanying\n// file LICENSE or http://www.opensource.org/licenses/mit-license.php.\n// @ts-ignore\nvar _Buffer = require('safe-buffer').Buffer\nfunction base (ALPHABET) {\n if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }\n var BASE_MAP = new Uint8Array(256)\n for (var j = 0; j < BASE_MAP.length; j++) {\n BASE_MAP[j] = 255\n }\n for (var i = 0; i < ALPHABET.length; i++) {\n var x = ALPHABET.charAt(i)\n var xc = x.charCodeAt(0)\n if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }\n BASE_MAP[xc] = i\n }\n var BASE = ALPHABET.length\n var LEADER = ALPHABET.charAt(0)\n var FACTOR = Math.log(BASE) / Math.log(256) // log(BASE) / log(256), rounded up\n var iFACTOR = Math.log(256) / Math.log(BASE) // log(256) / log(BASE), rounded up\n function encode (source) {\n if (Array.isArray(source) || source instanceof Uint8Array) { source = _Buffer.from(source) }\n if (!_Buffer.isBuffer(source)) { throw new TypeError('Expected Buffer') }\n if (source.length === 0) { return '' }\n // Skip & count leading zeroes.\n var zeroes = 0\n var length = 0\n var pbegin = 0\n var pend = source.length\n while (pbegin !== pend && source[pbegin] === 0) {\n pbegin++\n zeroes++\n }\n // Allocate enough space in big-endian base58 representation.\n var size = ((pend - pbegin) * iFACTOR + 1) >>> 0\n var b58 = new Uint8Array(size)\n // Process the bytes.\n while (pbegin !== pend) {\n var carry = source[pbegin]\n // Apply \"b58 = b58 * 256 + ch\".\n var i = 0\n for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {\n carry += (256 * b58[it1]) >>> 0\n b58[it1] = (carry % BASE) >>> 0\n carry = (carry / BASE) >>> 0\n }\n if (carry !== 0) { throw new Error('Non-zero carry') }\n length = i\n pbegin++\n }\n // Skip leading zeroes in base58 result.\n var it2 = size - length\n while (it2 !== size && b58[it2] === 0) {\n it2++\n }\n // Translate the result into a string.\n var str = LEADER.repeat(zeroes)\n for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]) }\n return str\n }\n function decodeUnsafe (source) {\n if (typeof source !== 'string') { throw new TypeError('Expected String') }\n if (source.length === 0) { return _Buffer.alloc(0) }\n var psz = 0\n // Skip and count leading '1's.\n var zeroes = 0\n var length = 0\n while (source[psz] === LEADER) {\n zeroes++\n psz++\n }\n // Allocate enough space in big-endian base256 representation.\n var size = (((source.length - psz) * FACTOR) + 1) >>> 0 // log(58) / log(256), rounded up.\n var b256 = new Uint8Array(size)\n // Process the characters.\n while (source[psz]) {\n // Decode character\n var carry = BASE_MAP[source.charCodeAt(psz)]\n // Invalid character\n if (carry === 255) { return }\n var i = 0\n for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {\n carry += (BASE * b256[it3]) >>> 0\n b256[it3] = (carry % 256) >>> 0\n carry = (carry / 256) >>> 0\n }\n if (carry !== 0) { throw new Error('Non-zero carry') }\n length = i\n psz++\n }\n // Skip leading zeroes in b256.\n var it4 = size - length\n while (it4 !== size && b256[it4] === 0) {\n it4++\n }\n var vch = _Buffer.allocUnsafe(zeroes + (size - it4))\n vch.fill(0x00, 0, zeroes)\n var j = zeroes\n while (it4 !== size) {\n vch[j++] = b256[it4++]\n }\n return vch\n }\n function decode (string) {\n var buffer = decodeUnsafe(string)\n if (buffer) { return buffer }\n throw new Error('Non-base' + BASE + ' character')\n }\n return {\n encode: encode,\n decodeUnsafe: decodeUnsafe,\n decode: decode\n }\n}\nmodule.exports = base\n","'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","var bigInt = (function (undefined) {\r\n \"use strict\";\r\n\r\n var BASE = 1e7,\r\n LOG_BASE = 7,\r\n MAX_INT = 9007199254740992,\r\n MAX_INT_ARR = smallToArray(MAX_INT),\r\n DEFAULT_ALPHABET = \"0123456789abcdefghijklmnopqrstuvwxyz\";\r\n\r\n var supportsNativeBigInt = typeof BigInt === \"function\";\r\n\r\n function Integer(v, radix, alphabet, caseSensitive) {\r\n if (typeof v === \"undefined\") return Integer[0];\r\n if (typeof radix !== \"undefined\") return +radix === 10 && !alphabet ? parseValue(v) : parseBase(v, radix, alphabet, caseSensitive);\r\n return parseValue(v);\r\n }\r\n\r\n function BigInteger(value, sign) {\r\n this.value = value;\r\n this.sign = sign;\r\n this.isSmall = false;\r\n }\r\n BigInteger.prototype = Object.create(Integer.prototype);\r\n\r\n function SmallInteger(value) {\r\n this.value = value;\r\n this.sign = value < 0;\r\n this.isSmall = true;\r\n }\r\n SmallInteger.prototype = Object.create(Integer.prototype);\r\n\r\n function NativeBigInt(value) {\r\n this.value = value;\r\n }\r\n NativeBigInt.prototype = Object.create(Integer.prototype);\r\n\r\n function isPrecise(n) {\r\n return -MAX_INT < n && n < MAX_INT;\r\n }\r\n\r\n function smallToArray(n) { // For performance reasons doesn't reference BASE, need to change this function if BASE changes\r\n if (n < 1e7)\r\n return [n];\r\n if (n < 1e14)\r\n return [n % 1e7, Math.floor(n / 1e7)];\r\n return [n % 1e7, Math.floor(n / 1e7) % 1e7, Math.floor(n / 1e14)];\r\n }\r\n\r\n function arrayToSmall(arr) { // If BASE changes this function may need to change\r\n trim(arr);\r\n var length = arr.length;\r\n if (length < 4 && compareAbs(arr, MAX_INT_ARR) < 0) {\r\n switch (length) {\r\n case 0: return 0;\r\n case 1: return arr[0];\r\n case 2: return arr[0] + arr[1] * BASE;\r\n default: return arr[0] + (arr[1] + arr[2] * BASE) * BASE;\r\n }\r\n }\r\n return arr;\r\n }\r\n\r\n function trim(v) {\r\n var i = v.length;\r\n while (v[--i] === 0);\r\n v.length = i + 1;\r\n }\r\n\r\n function createArray(length) { // function shamelessly stolen from Yaffle's library https://github.com/Yaffle/BigInteger\r\n var x = new Array(length);\r\n var i = -1;\r\n while (++i < length) {\r\n x[i] = 0;\r\n }\r\n return x;\r\n }\r\n\r\n function truncate(n) {\r\n if (n > 0) return Math.floor(n);\r\n return Math.ceil(n);\r\n }\r\n\r\n function add(a, b) { // assumes a and b are arrays with a.length >= b.length\r\n var l_a = a.length,\r\n l_b = b.length,\r\n r = new Array(l_a),\r\n carry = 0,\r\n base = BASE,\r\n sum, i;\r\n for (i = 0; i < l_b; i++) {\r\n sum = a[i] + b[i] + carry;\r\n carry = sum >= base ? 1 : 0;\r\n r[i] = sum - carry * base;\r\n }\r\n while (i < l_a) {\r\n sum = a[i] + carry;\r\n carry = sum === base ? 1 : 0;\r\n r[i++] = sum - carry * base;\r\n }\r\n if (carry > 0) r.push(carry);\r\n return r;\r\n }\r\n\r\n function addAny(a, b) {\r\n if (a.length >= b.length) return add(a, b);\r\n return add(b, a);\r\n }\r\n\r\n function addSmall(a, carry) { // assumes a is array, carry is number with 0 <= carry < MAX_INT\r\n var l = a.length,\r\n r = new Array(l),\r\n base = BASE,\r\n sum, i;\r\n for (i = 0; i < l; i++) {\r\n sum = a[i] - base + carry;\r\n carry = Math.floor(sum / base);\r\n r[i] = sum - carry * base;\r\n carry += 1;\r\n }\r\n while (carry > 0) {\r\n r[i++] = carry % base;\r\n carry = Math.floor(carry / base);\r\n }\r\n return r;\r\n }\r\n\r\n BigInteger.prototype.add = function (v) {\r\n var n = parseValue(v);\r\n if (this.sign !== n.sign) {\r\n return this.subtract(n.negate());\r\n }\r\n var a = this.value, b = n.value;\r\n if (n.isSmall) {\r\n return new BigInteger(addSmall(a, Math.abs(b)), this.sign);\r\n }\r\n return new BigInteger(addAny(a, b), this.sign);\r\n };\r\n BigInteger.prototype.plus = BigInteger.prototype.add;\r\n\r\n SmallInteger.prototype.add = function (v) {\r\n var n = parseValue(v);\r\n var a = this.value;\r\n if (a < 0 !== n.sign) {\r\n return this.subtract(n.negate());\r\n }\r\n var b = n.value;\r\n if (n.isSmall) {\r\n if (isPrecise(a + b)) return new SmallInteger(a + b);\r\n b = smallToArray(Math.abs(b));\r\n }\r\n return new BigInteger(addSmall(b, Math.abs(a)), a < 0);\r\n };\r\n SmallInteger.prototype.plus = SmallInteger.prototype.add;\r\n\r\n NativeBigInt.prototype.add = function (v) {\r\n return new NativeBigInt(this.value + parseValue(v).value);\r\n }\r\n NativeBigInt.prototype.plus = NativeBigInt.prototype.add;\r\n\r\n function subtract(a, b) { // assumes a and b are arrays with a >= b\r\n var a_l = a.length,\r\n b_l = b.length,\r\n r = new Array(a_l),\r\n borrow = 0,\r\n base = BASE,\r\n i, difference;\r\n for (i = 0; i < b_l; i++) {\r\n difference = a[i] - borrow - b[i];\r\n if (difference < 0) {\r\n difference += base;\r\n borrow = 1;\r\n } else borrow = 0;\r\n r[i] = difference;\r\n }\r\n for (i = b_l; i < a_l; i++) {\r\n difference = a[i] - borrow;\r\n if (difference < 0) difference += base;\r\n else {\r\n r[i++] = difference;\r\n break;\r\n }\r\n r[i] = difference;\r\n }\r\n for (; i < a_l; i++) {\r\n r[i] = a[i];\r\n }\r\n trim(r);\r\n return r;\r\n }\r\n\r\n function subtractAny(a, b, sign) {\r\n var value;\r\n if (compareAbs(a, b) >= 0) {\r\n value = subtract(a, b);\r\n } else {\r\n value = subtract(b, a);\r\n sign = !sign;\r\n }\r\n value = arrayToSmall(value);\r\n if (typeof value === \"number\") {\r\n if (sign) value = -value;\r\n return new SmallInteger(value);\r\n }\r\n return new BigInteger(value, sign);\r\n }\r\n\r\n function subtractSmall(a, b, sign) { // assumes a is array, b is number with 0 <= b < MAX_INT\r\n var l = a.length,\r\n r = new Array(l),\r\n carry = -b,\r\n base = BASE,\r\n i, difference;\r\n for (i = 0; i < l; i++) {\r\n difference = a[i] + carry;\r\n carry = Math.floor(difference / base);\r\n difference %= base;\r\n r[i] = difference < 0 ? difference + base : difference;\r\n }\r\n r = arrayToSmall(r);\r\n if (typeof r === \"number\") {\r\n if (sign) r = -r;\r\n return new SmallInteger(r);\r\n } return new BigInteger(r, sign);\r\n }\r\n\r\n BigInteger.prototype.subtract = function (v) {\r\n var n = parseValue(v);\r\n if (this.sign !== n.sign) {\r\n return this.add(n.negate());\r\n }\r\n var a = this.value, b = n.value;\r\n if (n.isSmall)\r\n return subtractSmall(a, Math.abs(b), this.sign);\r\n return subtractAny(a, b, this.sign);\r\n };\r\n BigInteger.prototype.minus = BigInteger.prototype.subtract;\r\n\r\n SmallInteger.prototype.subtract = function (v) {\r\n var n = parseValue(v);\r\n var a = this.value;\r\n if (a < 0 !== n.sign) {\r\n return this.add(n.negate());\r\n }\r\n var b = n.value;\r\n if (n.isSmall) {\r\n return new SmallInteger(a - b);\r\n }\r\n return subtractSmall(b, Math.abs(a), a >= 0);\r\n };\r\n SmallInteger.prototype.minus = SmallInteger.prototype.subtract;\r\n\r\n NativeBigInt.prototype.subtract = function (v) {\r\n return new NativeBigInt(this.value - parseValue(v).value);\r\n }\r\n NativeBigInt.prototype.minus = NativeBigInt.prototype.subtract;\r\n\r\n BigInteger.prototype.negate = function () {\r\n return new BigInteger(this.value, !this.sign);\r\n };\r\n SmallInteger.prototype.negate = function () {\r\n var sign = this.sign;\r\n var small = new SmallInteger(-this.value);\r\n small.sign = !sign;\r\n return small;\r\n };\r\n NativeBigInt.prototype.negate = function () {\r\n return new NativeBigInt(-this.value);\r\n }\r\n\r\n BigInteger.prototype.abs = function () {\r\n return new BigInteger(this.value, false);\r\n };\r\n SmallInteger.prototype.abs = function () {\r\n return new SmallInteger(Math.abs(this.value));\r\n };\r\n NativeBigInt.prototype.abs = function () {\r\n return new NativeBigInt(this.value >= 0 ? this.value : -this.value);\r\n }\r\n\r\n\r\n function multiplyLong(a, b) {\r\n var a_l = a.length,\r\n b_l = b.length,\r\n l = a_l + b_l,\r\n r = createArray(l),\r\n base = BASE,\r\n product, carry, i, a_i, b_j;\r\n for (i = 0; i < a_l; ++i) {\r\n a_i = a[i];\r\n for (var j = 0; j < b_l; ++j) {\r\n b_j = b[j];\r\n product = a_i * b_j + r[i + j];\r\n carry = Math.floor(product / base);\r\n r[i + j] = product - carry * base;\r\n r[i + j + 1] += carry;\r\n }\r\n }\r\n trim(r);\r\n return r;\r\n }\r\n\r\n function multiplySmall(a, b) { // assumes a is array, b is number with |b| < BASE\r\n var l = a.length,\r\n r = new Array(l),\r\n base = BASE,\r\n carry = 0,\r\n product, i;\r\n for (i = 0; i < l; i++) {\r\n product = a[i] * b + carry;\r\n carry = Math.floor(product / base);\r\n r[i] = product - carry * base;\r\n }\r\n while (carry > 0) {\r\n r[i++] = carry % base;\r\n carry = Math.floor(carry / base);\r\n }\r\n return r;\r\n }\r\n\r\n function shiftLeft(x, n) {\r\n var r = [];\r\n while (n-- > 0) r.push(0);\r\n return r.concat(x);\r\n }\r\n\r\n function multiplyKaratsuba(x, y) {\r\n var n = Math.max(x.length, y.length);\r\n\r\n if (n <= 30) return multiplyLong(x, y);\r\n n = Math.ceil(n / 2);\r\n\r\n var b = x.slice(n),\r\n a = x.slice(0, n),\r\n d = y.slice(n),\r\n c = y.slice(0, n);\r\n\r\n var ac = multiplyKaratsuba(a, c),\r\n bd = multiplyKaratsuba(b, d),\r\n abcd = multiplyKaratsuba(addAny(a, b), addAny(c, d));\r\n\r\n var product = addAny(addAny(ac, shiftLeft(subtract(subtract(abcd, ac), bd), n)), shiftLeft(bd, 2 * n));\r\n trim(product);\r\n return product;\r\n }\r\n\r\n // The following function is derived from a surface fit of a graph plotting the performance difference\r\n // between long multiplication and karatsuba multiplication versus the lengths of the two arrays.\r\n function useKaratsuba(l1, l2) {\r\n return -0.012 * l1 - 0.012 * l2 + 0.000015 * l1 * l2 > 0;\r\n }\r\n\r\n BigInteger.prototype.multiply = function (v) {\r\n var n = parseValue(v),\r\n a = this.value, b = n.value,\r\n sign = this.sign !== n.sign,\r\n abs;\r\n if (n.isSmall) {\r\n if (b === 0) return Integer[0];\r\n if (b === 1) return this;\r\n if (b === -1) return this.negate();\r\n abs = Math.abs(b);\r\n if (abs < BASE) {\r\n return new BigInteger(multiplySmall(a, abs), sign);\r\n }\r\n b = smallToArray(abs);\r\n }\r\n if (useKaratsuba(a.length, b.length)) // Karatsuba is only faster for certain array sizes\r\n return new BigInteger(multiplyKaratsuba(a, b), sign);\r\n return new BigInteger(multiplyLong(a, b), sign);\r\n };\r\n\r\n BigInteger.prototype.times = BigInteger.prototype.multiply;\r\n\r\n function multiplySmallAndArray(a, b, sign) { // a >= 0\r\n if (a < BASE) {\r\n return new BigInteger(multiplySmall(b, a), sign);\r\n }\r\n return new BigInteger(multiplyLong(b, smallToArray(a)), sign);\r\n }\r\n SmallInteger.prototype._multiplyBySmall = function (a) {\r\n if (isPrecise(a.value * this.value)) {\r\n return new SmallInteger(a.value * this.value);\r\n }\r\n return multiplySmallAndArray(Math.abs(a.value), smallToArray(Math.abs(this.value)), this.sign !== a.sign);\r\n };\r\n BigInteger.prototype._multiplyBySmall = function (a) {\r\n if (a.value === 0) return Integer[0];\r\n if (a.value === 1) return this;\r\n if (a.value === -1) return this.negate();\r\n return multiplySmallAndArray(Math.abs(a.value), this.value, this.sign !== a.sign);\r\n };\r\n SmallInteger.prototype.multiply = function (v) {\r\n return parseValue(v)._multiplyBySmall(this);\r\n };\r\n SmallInteger.prototype.times = SmallInteger.prototype.multiply;\r\n\r\n NativeBigInt.prototype.multiply = function (v) {\r\n return new NativeBigInt(this.value * parseValue(v).value);\r\n }\r\n NativeBigInt.prototype.times = NativeBigInt.prototype.multiply;\r\n\r\n function square(a) {\r\n //console.assert(2 * BASE * BASE < MAX_INT);\r\n var l = a.length,\r\n r = createArray(l + l),\r\n base = BASE,\r\n product, carry, i, a_i, a_j;\r\n for (i = 0; i < l; i++) {\r\n a_i = a[i];\r\n carry = 0 - a_i * a_i;\r\n for (var j = i; j < l; j++) {\r\n a_j = a[j];\r\n product = 2 * (a_i * a_j) + r[i + j] + carry;\r\n carry = Math.floor(product / base);\r\n r[i + j] = product - carry * base;\r\n }\r\n r[i + l] = carry;\r\n }\r\n trim(r);\r\n return r;\r\n }\r\n\r\n BigInteger.prototype.square = function () {\r\n return new BigInteger(square(this.value), false);\r\n };\r\n\r\n SmallInteger.prototype.square = function () {\r\n var value = this.value * this.value;\r\n if (isPrecise(value)) return new SmallInteger(value);\r\n return new BigInteger(square(smallToArray(Math.abs(this.value))), false);\r\n };\r\n\r\n NativeBigInt.prototype.square = function (v) {\r\n return new NativeBigInt(this.value * this.value);\r\n }\r\n\r\n function divMod1(a, b) { // Left over from previous version. Performs faster than divMod2 on smaller input sizes.\r\n var a_l = a.length,\r\n b_l = b.length,\r\n base = BASE,\r\n result = createArray(b.length),\r\n divisorMostSignificantDigit = b[b_l - 1],\r\n // normalization\r\n lambda = Math.ceil(base / (2 * divisorMostSignificantDigit)),\r\n remainder = multiplySmall(a, lambda),\r\n divisor = multiplySmall(b, lambda),\r\n quotientDigit, shift, carry, borrow, i, l, q;\r\n if (remainder.length <= a_l) remainder.push(0);\r\n divisor.push(0);\r\n divisorMostSignificantDigit = divisor[b_l - 1];\r\n for (shift = a_l - b_l; shift >= 0; shift--) {\r\n quotientDigit = base - 1;\r\n if (remainder[shift + b_l] !== divisorMostSignificantDigit) {\r\n quotientDigit = Math.floor((remainder[shift + b_l] * base + remainder[shift + b_l - 1]) / divisorMostSignificantDigit);\r\n }\r\n // quotientDigit <= base - 1\r\n carry = 0;\r\n borrow = 0;\r\n l = divisor.length;\r\n for (i = 0; i < l; i++) {\r\n carry += quotientDigit * divisor[i];\r\n q = Math.floor(carry / base);\r\n borrow += remainder[shift + i] - (carry - q * base);\r\n carry = q;\r\n if (borrow < 0) {\r\n remainder[shift + i] = borrow + base;\r\n borrow = -1;\r\n } else {\r\n remainder[shift + i] = borrow;\r\n borrow = 0;\r\n }\r\n }\r\n while (borrow !== 0) {\r\n quotientDigit -= 1;\r\n carry = 0;\r\n for (i = 0; i < l; i++) {\r\n carry += remainder[shift + i] - base + divisor[i];\r\n if (carry < 0) {\r\n remainder[shift + i] = carry + base;\r\n carry = 0;\r\n } else {\r\n remainder[shift + i] = carry;\r\n carry = 1;\r\n }\r\n }\r\n borrow += carry;\r\n }\r\n result[shift] = quotientDigit;\r\n }\r\n // denormalization\r\n remainder = divModSmall(remainder, lambda)[0];\r\n return [arrayToSmall(result), arrayToSmall(remainder)];\r\n }\r\n\r\n function divMod2(a, b) { // Implementation idea shamelessly stolen from Silent Matt's library http://silentmatt.com/biginteger/\r\n // Performs faster than divMod1 on larger input sizes.\r\n var a_l = a.length,\r\n b_l = b.length,\r\n result = [],\r\n part = [],\r\n base = BASE,\r\n guess, xlen, highx, highy, check;\r\n while (a_l) {\r\n part.unshift(a[--a_l]);\r\n trim(part);\r\n if (compareAbs(part, b) < 0) {\r\n result.push(0);\r\n continue;\r\n }\r\n xlen = part.length;\r\n highx = part[xlen - 1] * base + part[xlen - 2];\r\n highy = b[b_l - 1] * base + b[b_l - 2];\r\n if (xlen > b_l) {\r\n highx = (highx + 1) * base;\r\n }\r\n guess = Math.ceil(highx / highy);\r\n do {\r\n check = multiplySmall(b, guess);\r\n if (compareAbs(check, part) <= 0) break;\r\n guess--;\r\n } while (guess);\r\n result.push(guess);\r\n part = subtract(part, check);\r\n }\r\n result.reverse();\r\n return [arrayToSmall(result), arrayToSmall(part)];\r\n }\r\n\r\n function divModSmall(value, lambda) {\r\n var length = value.length,\r\n quotient = createArray(length),\r\n base = BASE,\r\n i, q, remainder, divisor;\r\n remainder = 0;\r\n for (i = length - 1; i >= 0; --i) {\r\n divisor = remainder * base + value[i];\r\n q = truncate(divisor / lambda);\r\n remainder = divisor - q * lambda;\r\n quotient[i] = q | 0;\r\n }\r\n return [quotient, remainder | 0];\r\n }\r\n\r\n function divModAny(self, v) {\r\n var value, n = parseValue(v);\r\n if (supportsNativeBigInt) {\r\n return [new NativeBigInt(self.value / n.value), new NativeBigInt(self.value % n.value)];\r\n }\r\n var a = self.value, b = n.value;\r\n var quotient;\r\n if (b === 0) throw new Error(\"Cannot divide by zero\");\r\n if (self.isSmall) {\r\n if (n.isSmall) {\r\n return [new SmallInteger(truncate(a / b)), new SmallInteger(a % b)];\r\n }\r\n return [Integer[0], self];\r\n }\r\n if (n.isSmall) {\r\n if (b === 1) return [self, Integer[0]];\r\n if (b == -1) return [self.negate(), Integer[0]];\r\n var abs = Math.abs(b);\r\n if (abs < BASE) {\r\n value = divModSmall(a, abs);\r\n quotient = arrayToSmall(value[0]);\r\n var remainder = value[1];\r\n if (self.sign) remainder = -remainder;\r\n if (typeof quotient === \"number\") {\r\n if (self.sign !== n.sign) quotient = -quotient;\r\n return [new SmallInteger(quotient), new SmallInteger(remainder)];\r\n }\r\n return [new BigInteger(quotient, self.sign !== n.sign), new SmallInteger(remainder)];\r\n }\r\n b = smallToArray(abs);\r\n }\r\n var comparison = compareAbs(a, b);\r\n if (comparison === -1) return [Integer[0], self];\r\n if (comparison === 0) return [Integer[self.sign === n.sign ? 1 : -1], Integer[0]];\r\n\r\n // divMod1 is faster on smaller input sizes\r\n if (a.length + b.length <= 200)\r\n value = divMod1(a, b);\r\n else value = divMod2(a, b);\r\n\r\n quotient = value[0];\r\n var qSign = self.sign !== n.sign,\r\n mod = value[1],\r\n mSign = self.sign;\r\n if (typeof quotient === \"number\") {\r\n if (qSign) quotient = -quotient;\r\n quotient = new SmallInteger(quotient);\r\n } else quotient = new BigInteger(quotient, qSign);\r\n if (typeof mod === \"number\") {\r\n if (mSign) mod = -mod;\r\n mod = new SmallInteger(mod);\r\n } else mod = new BigInteger(mod, mSign);\r\n return [quotient, mod];\r\n }\r\n\r\n BigInteger.prototype.divmod = function (v) {\r\n var result = divModAny(this, v);\r\n return {\r\n quotient: result[0],\r\n remainder: result[1]\r\n };\r\n };\r\n NativeBigInt.prototype.divmod = SmallInteger.prototype.divmod = BigInteger.prototype.divmod;\r\n\r\n\r\n BigInteger.prototype.divide = function (v) {\r\n return divModAny(this, v)[0];\r\n };\r\n NativeBigInt.prototype.over = NativeBigInt.prototype.divide = function (v) {\r\n return new NativeBigInt(this.value / parseValue(v).value);\r\n };\r\n SmallInteger.prototype.over = SmallInteger.prototype.divide = BigInteger.prototype.over = BigInteger.prototype.divide;\r\n\r\n BigInteger.prototype.mod = function (v) {\r\n return divModAny(this, v)[1];\r\n };\r\n NativeBigInt.prototype.mod = NativeBigInt.prototype.remainder = function (v) {\r\n return new NativeBigInt(this.value % parseValue(v).value);\r\n };\r\n SmallInteger.prototype.remainder = SmallInteger.prototype.mod = BigInteger.prototype.remainder = BigInteger.prototype.mod;\r\n\r\n BigInteger.prototype.pow = function (v) {\r\n var n = parseValue(v),\r\n a = this.value,\r\n b = n.value,\r\n value, x, y;\r\n if (b === 0) return Integer[1];\r\n if (a === 0) return Integer[0];\r\n if (a === 1) return Integer[1];\r\n if (a === -1) return n.isEven() ? Integer[1] : Integer[-1];\r\n if (n.sign) {\r\n return Integer[0];\r\n }\r\n if (!n.isSmall) throw new Error(\"The exponent \" + n.toString() + \" is too large.\");\r\n if (this.isSmall) {\r\n if (isPrecise(value = Math.pow(a, b)))\r\n return new SmallInteger(truncate(value));\r\n }\r\n x = this;\r\n y = Integer[1];\r\n while (true) {\r\n if (b & 1 === 1) {\r\n y = y.times(x);\r\n --b;\r\n }\r\n if (b === 0) break;\r\n b /= 2;\r\n x = x.square();\r\n }\r\n return y;\r\n };\r\n SmallInteger.prototype.pow = BigInteger.prototype.pow;\r\n\r\n NativeBigInt.prototype.pow = function (v) {\r\n var n = parseValue(v);\r\n var a = this.value, b = n.value;\r\n var _0 = BigInt(0), _1 = BigInt(1), _2 = BigInt(2);\r\n if (b === _0) return Integer[1];\r\n if (a === _0) return Integer[0];\r\n if (a === _1) return Integer[1];\r\n if (a === BigInt(-1)) return n.isEven() ? Integer[1] : Integer[-1];\r\n if (n.isNegative()) return new NativeBigInt(_0);\r\n var x = this;\r\n var y = Integer[1];\r\n while (true) {\r\n if ((b & _1) === _1) {\r\n y = y.times(x);\r\n --b;\r\n }\r\n if (b === _0) break;\r\n b /= _2;\r\n x = x.square();\r\n }\r\n return y;\r\n }\r\n\r\n BigInteger.prototype.modPow = function (exp, mod) {\r\n exp = parseValue(exp);\r\n mod = parseValue(mod);\r\n if (mod.isZero()) throw new Error(\"Cannot take modPow with modulus 0\");\r\n var r = Integer[1],\r\n base = this.mod(mod);\r\n if (exp.isNegative()) {\r\n exp = exp.multiply(Integer[-1]);\r\n base = base.modInv(mod);\r\n }\r\n while (exp.isPositive()) {\r\n if (base.isZero()) return Integer[0];\r\n if (exp.isOdd()) r = r.multiply(base).mod(mod);\r\n exp = exp.divide(2);\r\n base = base.square().mod(mod);\r\n }\r\n return r;\r\n };\r\n NativeBigInt.prototype.modPow = SmallInteger.prototype.modPow = BigInteger.prototype.modPow;\r\n\r\n function compareAbs(a, b) {\r\n if (a.length !== b.length) {\r\n return a.length > b.length ? 1 : -1;\r\n }\r\n for (var i = a.length - 1; i >= 0; i--) {\r\n if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;\r\n }\r\n return 0;\r\n }\r\n\r\n BigInteger.prototype.compareAbs = function (v) {\r\n var n = parseValue(v),\r\n a = this.value,\r\n b = n.value;\r\n if (n.isSmall) return 1;\r\n return compareAbs(a, b);\r\n };\r\n SmallInteger.prototype.compareAbs = function (v) {\r\n var n = parseValue(v),\r\n a = Math.abs(this.value),\r\n b = n.value;\r\n if (n.isSmall) {\r\n b = Math.abs(b);\r\n return a === b ? 0 : a > b ? 1 : -1;\r\n }\r\n return -1;\r\n };\r\n NativeBigInt.prototype.compareAbs = function (v) {\r\n var a = this.value;\r\n var b = parseValue(v).value;\r\n a = a >= 0 ? a : -a;\r\n b = b >= 0 ? b : -b;\r\n return a === b ? 0 : a > b ? 1 : -1;\r\n }\r\n\r\n BigInteger.prototype.compare = function (v) {\r\n // See discussion about comparison with Infinity:\r\n // https://github.com/peterolson/BigInteger.js/issues/61\r\n if (v === Infinity) {\r\n return -1;\r\n }\r\n if (v === -Infinity) {\r\n return 1;\r\n }\r\n\r\n var n = parseValue(v),\r\n a = this.value,\r\n b = n.value;\r\n if (this.sign !== n.sign) {\r\n return n.sign ? 1 : -1;\r\n }\r\n if (n.isSmall) {\r\n return this.sign ? -1 : 1;\r\n }\r\n return compareAbs(a, b) * (this.sign ? -1 : 1);\r\n };\r\n BigInteger.prototype.compareTo = BigInteger.prototype.compare;\r\n\r\n SmallInteger.prototype.compare = function (v) {\r\n if (v === Infinity) {\r\n return -1;\r\n }\r\n if (v === -Infinity) {\r\n return 1;\r\n }\r\n\r\n var n = parseValue(v),\r\n a = this.value,\r\n b = n.value;\r\n if (n.isSmall) {\r\n return a == b ? 0 : a > b ? 1 : -1;\r\n }\r\n if (a < 0 !== n.sign) {\r\n return a < 0 ? -1 : 1;\r\n }\r\n return a < 0 ? 1 : -1;\r\n };\r\n SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;\r\n\r\n NativeBigInt.prototype.compare = function (v) {\r\n if (v === Infinity) {\r\n return -1;\r\n }\r\n if (v === -Infinity) {\r\n return 1;\r\n }\r\n var a = this.value;\r\n var b = parseValue(v).value;\r\n return a === b ? 0 : a > b ? 1 : -1;\r\n }\r\n NativeBigInt.prototype.compareTo = NativeBigInt.prototype.compare;\r\n\r\n BigInteger.prototype.equals = function (v) {\r\n return this.compare(v) === 0;\r\n };\r\n NativeBigInt.prototype.eq = NativeBigInt.prototype.equals = SmallInteger.prototype.eq = SmallInteger.prototype.equals = BigInteger.prototype.eq = BigInteger.prototype.equals;\r\n\r\n BigInteger.prototype.notEquals = function (v) {\r\n return this.compare(v) !== 0;\r\n };\r\n NativeBigInt.prototype.neq = NativeBigInt.prototype.notEquals = SmallInteger.prototype.neq = SmallInteger.prototype.notEquals = BigInteger.prototype.neq = BigInteger.prototype.notEquals;\r\n\r\n BigInteger.prototype.greater = function (v) {\r\n return this.compare(v) > 0;\r\n };\r\n NativeBigInt.prototype.gt = NativeBigInt.prototype.greater = SmallInteger.prototype.gt = SmallInteger.prototype.greater = BigInteger.prototype.gt = BigInteger.prototype.greater;\r\n\r\n BigInteger.prototype.lesser = function (v) {\r\n return this.compare(v) < 0;\r\n };\r\n NativeBigInt.prototype.lt = NativeBigInt.prototype.lesser = SmallInteger.prototype.lt = SmallInteger.prototype.lesser = BigInteger.prototype.lt = BigInteger.prototype.lesser;\r\n\r\n BigInteger.prototype.greaterOrEquals = function (v) {\r\n return this.compare(v) >= 0;\r\n };\r\n NativeBigInt.prototype.geq = NativeBigInt.prototype.greaterOrEquals = SmallInteger.prototype.geq = SmallInteger.prototype.greaterOrEquals = BigInteger.prototype.geq = BigInteger.prototype.greaterOrEquals;\r\n\r\n BigInteger.prototype.lesserOrEquals = function (v) {\r\n return this.compare(v) <= 0;\r\n };\r\n NativeBigInt.prototype.leq = NativeBigInt.prototype.lesserOrEquals = SmallInteger.prototype.leq = SmallInteger.prototype.lesserOrEquals = BigInteger.prototype.leq = BigInteger.prototype.lesserOrEquals;\r\n\r\n BigInteger.prototype.isEven = function () {\r\n return (this.value[0] & 1) === 0;\r\n };\r\n SmallInteger.prototype.isEven = function () {\r\n return (this.value & 1) === 0;\r\n };\r\n NativeBigInt.prototype.isEven = function () {\r\n return (this.value & BigInt(1)) === BigInt(0);\r\n }\r\n\r\n BigInteger.prototype.isOdd = function () {\r\n return (this.value[0] & 1) === 1;\r\n };\r\n SmallInteger.prototype.isOdd = function () {\r\n return (this.value & 1) === 1;\r\n };\r\n NativeBigInt.prototype.isOdd = function () {\r\n return (this.value & BigInt(1)) === BigInt(1);\r\n }\r\n\r\n BigInteger.prototype.isPositive = function () {\r\n return !this.sign;\r\n };\r\n SmallInteger.prototype.isPositive = function () {\r\n return this.value > 0;\r\n };\r\n NativeBigInt.prototype.isPositive = SmallInteger.prototype.isPositive;\r\n\r\n BigInteger.prototype.isNegative = function () {\r\n return this.sign;\r\n };\r\n SmallInteger.prototype.isNegative = function () {\r\n return this.value < 0;\r\n };\r\n NativeBigInt.prototype.isNegative = SmallInteger.prototype.isNegative;\r\n\r\n BigInteger.prototype.isUnit = function () {\r\n return false;\r\n };\r\n SmallInteger.prototype.isUnit = function () {\r\n return Math.abs(this.value) === 1;\r\n };\r\n NativeBigInt.prototype.isUnit = function () {\r\n return this.abs().value === BigInt(1);\r\n }\r\n\r\n BigInteger.prototype.isZero = function () {\r\n return false;\r\n };\r\n SmallInteger.prototype.isZero = function () {\r\n return this.value === 0;\r\n };\r\n NativeBigInt.prototype.isZero = function () {\r\n return this.value === BigInt(0);\r\n }\r\n\r\n BigInteger.prototype.isDivisibleBy = function (v) {\r\n var n = parseValue(v);\r\n if (n.isZero()) return false;\r\n if (n.isUnit()) return true;\r\n if (n.compareAbs(2) === 0) return this.isEven();\r\n return this.mod(n).isZero();\r\n };\r\n NativeBigInt.prototype.isDivisibleBy = SmallInteger.prototype.isDivisibleBy = BigInteger.prototype.isDivisibleBy;\r\n\r\n function isBasicPrime(v) {\r\n var n = v.abs();\r\n if (n.isUnit()) return false;\r\n if (n.equals(2) || n.equals(3) || n.equals(5)) return true;\r\n if (n.isEven() || n.isDivisibleBy(3) || n.isDivisibleBy(5)) return false;\r\n if (n.lesser(49)) return true;\r\n // we don't know if it's prime: let the other functions figure it out\r\n }\r\n\r\n function millerRabinTest(n, a) {\r\n var nPrev = n.prev(),\r\n b = nPrev,\r\n r = 0,\r\n d, t, i, x;\r\n while (b.isEven()) b = b.divide(2), r++;\r\n next: for (i = 0; i < a.length; i++) {\r\n if (n.lesser(a[i])) continue;\r\n x = bigInt(a[i]).modPow(b, n);\r\n if (x.isUnit() || x.equals(nPrev)) continue;\r\n for (d = r - 1; d != 0; d--) {\r\n x = x.square().mod(n);\r\n if (x.isUnit()) return false;\r\n if (x.equals(nPrev)) continue next;\r\n }\r\n return false;\r\n }\r\n return true;\r\n }\r\n\r\n // Set \"strict\" to true to force GRH-supported lower bound of 2*log(N)^2\r\n BigInteger.prototype.isPrime = function (strict) {\r\n var isPrime = isBasicPrime(this);\r\n if (isPrime !== undefined) return isPrime;\r\n var n = this.abs();\r\n var bits = n.bitLength();\r\n if (bits <= 64)\r\n return millerRabinTest(n, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);\r\n var logN = Math.log(2) * bits.toJSNumber();\r\n var t = Math.ceil((strict === true) ? (2 * Math.pow(logN, 2)) : logN);\r\n for (var a = [], i = 0; i < t; i++) {\r\n a.push(bigInt(i + 2));\r\n }\r\n return millerRabinTest(n, a);\r\n };\r\n NativeBigInt.prototype.isPrime = SmallInteger.prototype.isPrime = BigInteger.prototype.isPrime;\r\n\r\n BigInteger.prototype.isProbablePrime = function (iterations, rng) {\r\n var isPrime = isBasicPrime(this);\r\n if (isPrime !== undefined) return isPrime;\r\n var n = this.abs();\r\n var t = iterations === undefined ? 5 : iterations;\r\n for (var a = [], i = 0; i < t; i++) {\r\n a.push(bigInt.randBetween(2, n.minus(2), rng));\r\n }\r\n return millerRabinTest(n, a);\r\n };\r\n NativeBigInt.prototype.isProbablePrime = SmallInteger.prototype.isProbablePrime = BigInteger.prototype.isProbablePrime;\r\n\r\n BigInteger.prototype.modInv = function (n) {\r\n var t = bigInt.zero, newT = bigInt.one, r = parseValue(n), newR = this.abs(), q, lastT, lastR;\r\n while (!newR.isZero()) {\r\n q = r.divide(newR);\r\n lastT = t;\r\n lastR = r;\r\n t = newT;\r\n r = newR;\r\n newT = lastT.subtract(q.multiply(newT));\r\n newR = lastR.subtract(q.multiply(newR));\r\n }\r\n if (!r.isUnit()) throw new Error(this.toString() + \" and \" + n.toString() + \" are not co-prime\");\r\n if (t.compare(0) === -1) {\r\n t = t.add(n);\r\n }\r\n if (this.isNegative()) {\r\n return t.negate();\r\n }\r\n return t;\r\n };\r\n\r\n NativeBigInt.prototype.modInv = SmallInteger.prototype.modInv = BigInteger.prototype.modInv;\r\n\r\n BigInteger.prototype.next = function () {\r\n var value = this.value;\r\n if (this.sign) {\r\n return subtractSmall(value, 1, this.sign);\r\n }\r\n return new BigInteger(addSmall(value, 1), this.sign);\r\n };\r\n SmallInteger.prototype.next = function () {\r\n var value = this.value;\r\n if (value + 1 < MAX_INT) return new SmallInteger(value + 1);\r\n return new BigInteger(MAX_INT_ARR, false);\r\n };\r\n NativeBigInt.prototype.next = function () {\r\n return new NativeBigInt(this.value + BigInt(1));\r\n }\r\n\r\n BigInteger.prototype.prev = function () {\r\n var value = this.value;\r\n if (this.sign) {\r\n return new BigInteger(addSmall(value, 1), true);\r\n }\r\n return subtractSmall(value, 1, this.sign);\r\n };\r\n SmallInteger.prototype.prev = function () {\r\n var value = this.value;\r\n if (value - 1 > -MAX_INT) return new SmallInteger(value - 1);\r\n return new BigInteger(MAX_INT_ARR, true);\r\n };\r\n NativeBigInt.prototype.prev = function () {\r\n return new NativeBigInt(this.value - BigInt(1));\r\n }\r\n\r\n var powersOfTwo = [1];\r\n while (2 * powersOfTwo[powersOfTwo.length - 1] <= BASE) powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);\r\n var powers2Length = powersOfTwo.length, highestPower2 = powersOfTwo[powers2Length - 1];\r\n\r\n function shift_isSmall(n) {\r\n return Math.abs(n) <= BASE;\r\n }\r\n\r\n BigInteger.prototype.shiftLeft = function (v) {\r\n var n = parseValue(v).toJSNumber();\r\n if (!shift_isSmall(n)) {\r\n throw new Error(String(n) + \" is too large for shifting.\");\r\n }\r\n if (n < 0) return this.shiftRight(-n);\r\n var result = this;\r\n if (result.isZero()) return result;\r\n while (n >= powers2Length) {\r\n result = result.multiply(highestPower2);\r\n n -= powers2Length - 1;\r\n }\r\n return result.multiply(powersOfTwo[n]);\r\n };\r\n NativeBigInt.prototype.shiftLeft = SmallInteger.prototype.shiftLeft = BigInteger.prototype.shiftLeft;\r\n\r\n BigInteger.prototype.shiftRight = function (v) {\r\n var remQuo;\r\n var n = parseValue(v).toJSNumber();\r\n if (!shift_isSmall(n)) {\r\n throw new Error(String(n) + \" is too large for shifting.\");\r\n }\r\n if (n < 0) return this.shiftLeft(-n);\r\n var result = this;\r\n while (n >= powers2Length) {\r\n if (result.isZero() || (result.isNegative() && result.isUnit())) return result;\r\n remQuo = divModAny(result, highestPower2);\r\n result = remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];\r\n n -= powers2Length - 1;\r\n }\r\n remQuo = divModAny(result, powersOfTwo[n]);\r\n return remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];\r\n };\r\n NativeBigInt.prototype.shiftRight = SmallInteger.prototype.shiftRight = BigInteger.prototype.shiftRight;\r\n\r\n function bitwise(x, y, fn) {\r\n y = parseValue(y);\r\n var xSign = x.isNegative(), ySign = y.isNegative();\r\n var xRem = xSign ? x.not() : x,\r\n yRem = ySign ? y.not() : y;\r\n var xDigit = 0, yDigit = 0;\r\n var xDivMod = null, yDivMod = null;\r\n var result = [];\r\n while (!xRem.isZero() || !yRem.isZero()) {\r\n xDivMod = divModAny(xRem, highestPower2);\r\n xDigit = xDivMod[1].toJSNumber();\r\n if (xSign) {\r\n xDigit = highestPower2 - 1 - xDigit; // two's complement for negative numbers\r\n }\r\n\r\n yDivMod = divModAny(yRem, highestPower2);\r\n yDigit = yDivMod[1].toJSNumber();\r\n if (ySign) {\r\n yDigit = highestPower2 - 1 - yDigit; // two's complement for negative numbers\r\n }\r\n\r\n xRem = xDivMod[0];\r\n yRem = yDivMod[0];\r\n result.push(fn(xDigit, yDigit));\r\n }\r\n var sum = fn(xSign ? 1 : 0, ySign ? 1 : 0) !== 0 ? bigInt(-1) : bigInt(0);\r\n for (var i = result.length - 1; i >= 0; i -= 1) {\r\n sum = sum.multiply(highestPower2).add(bigInt(result[i]));\r\n }\r\n return sum;\r\n }\r\n\r\n BigInteger.prototype.not = function () {\r\n return this.negate().prev();\r\n };\r\n NativeBigInt.prototype.not = SmallInteger.prototype.not = BigInteger.prototype.not;\r\n\r\n BigInteger.prototype.and = function (n) {\r\n return bitwise(this, n, function (a, b) { return a & b; });\r\n };\r\n NativeBigInt.prototype.and = SmallInteger.prototype.and = BigInteger.prototype.and;\r\n\r\n BigInteger.prototype.or = function (n) {\r\n return bitwise(this, n, function (a, b) { return a | b; });\r\n };\r\n NativeBigInt.prototype.or = SmallInteger.prototype.or = BigInteger.prototype.or;\r\n\r\n BigInteger.prototype.xor = function (n) {\r\n return bitwise(this, n, function (a, b) { return a ^ b; });\r\n };\r\n NativeBigInt.prototype.xor = SmallInteger.prototype.xor = BigInteger.prototype.xor;\r\n\r\n var LOBMASK_I = 1 << 30, LOBMASK_BI = (BASE & -BASE) * (BASE & -BASE) | LOBMASK_I;\r\n function roughLOB(n) { // get lowestOneBit (rough)\r\n // SmallInteger: return Min(lowestOneBit(n), 1 << 30)\r\n // BigInteger: return Min(lowestOneBit(n), 1 << 14) [BASE=1e7]\r\n var v = n.value,\r\n x = typeof v === \"number\" ? v | LOBMASK_I :\r\n typeof v === \"bigint\" ? v | BigInt(LOBMASK_I) :\r\n v[0] + v[1] * BASE | LOBMASK_BI;\r\n return x & -x;\r\n }\r\n\r\n function integerLogarithm(value, base) {\r\n if (base.compareTo(value) <= 0) {\r\n var tmp = integerLogarithm(value, base.square(base));\r\n var p = tmp.p;\r\n var e = tmp.e;\r\n var t = p.multiply(base);\r\n return t.compareTo(value) <= 0 ? { p: t, e: e * 2 + 1 } : { p: p, e: e * 2 };\r\n }\r\n return { p: bigInt(1), e: 0 };\r\n }\r\n\r\n BigInteger.prototype.bitLength = function () {\r\n var n = this;\r\n if (n.compareTo(bigInt(0)) < 0) {\r\n n = n.negate().subtract(bigInt(1));\r\n }\r\n if (n.compareTo(bigInt(0)) === 0) {\r\n return bigInt(0);\r\n }\r\n return bigInt(integerLogarithm(n, bigInt(2)).e).add(bigInt(1));\r\n }\r\n NativeBigInt.prototype.bitLength = SmallInteger.prototype.bitLength = BigInteger.prototype.bitLength;\r\n\r\n function max(a, b) {\r\n a = parseValue(a);\r\n b = parseValue(b);\r\n return a.greater(b) ? a : b;\r\n }\r\n function min(a, b) {\r\n a = parseValue(a);\r\n b = parseValue(b);\r\n return a.lesser(b) ? a : b;\r\n }\r\n function gcd(a, b) {\r\n a = parseValue(a).abs();\r\n b = parseValue(b).abs();\r\n if (a.equals(b)) return a;\r\n if (a.isZero()) return b;\r\n if (b.isZero()) return a;\r\n var c = Integer[1], d, t;\r\n while (a.isEven() && b.isEven()) {\r\n d = min(roughLOB(a), roughLOB(b));\r\n a = a.divide(d);\r\n b = b.divide(d);\r\n c = c.multiply(d);\r\n }\r\n while (a.isEven()) {\r\n a = a.divide(roughLOB(a));\r\n }\r\n do {\r\n while (b.isEven()) {\r\n b = b.divide(roughLOB(b));\r\n }\r\n if (a.greater(b)) {\r\n t = b; b = a; a = t;\r\n }\r\n b = b.subtract(a);\r\n } while (!b.isZero());\r\n return c.isUnit() ? a : a.multiply(c);\r\n }\r\n function lcm(a, b) {\r\n a = parseValue(a).abs();\r\n b = parseValue(b).abs();\r\n return a.divide(gcd(a, b)).multiply(b);\r\n }\r\n function randBetween(a, b, rng) {\r\n a = parseValue(a);\r\n b = parseValue(b);\r\n var usedRNG = rng || Math.random;\r\n var low = min(a, b), high = max(a, b);\r\n var range = high.subtract(low).add(1);\r\n if (range.isSmall) return low.add(Math.floor(usedRNG() * range));\r\n var digits = toBase(range, BASE).value;\r\n var result = [], restricted = true;\r\n for (var i = 0; i < digits.length; i++) {\r\n var top = restricted ? digits[i] + (i + 1 < digits.length ? digits[i + 1] / BASE : 0) : BASE;\r\n var digit = truncate(usedRNG() * top);\r\n result.push(digit);\r\n if (digit < digits[i]) restricted = false;\r\n }\r\n return low.add(Integer.fromArray(result, BASE, false));\r\n }\r\n\r\n var parseBase = function (text, base, alphabet, caseSensitive) {\r\n alphabet = alphabet || DEFAULT_ALPHABET;\r\n text = String(text);\r\n if (!caseSensitive) {\r\n text = text.toLowerCase();\r\n alphabet = alphabet.toLowerCase();\r\n }\r\n var length = text.length;\r\n var i;\r\n var absBase = Math.abs(base);\r\n var alphabetValues = {};\r\n for (i = 0; i < alphabet.length; i++) {\r\n alphabetValues[alphabet[i]] = i;\r\n }\r\n for (i = 0; i < length; i++) {\r\n var c = text[i];\r\n if (c === \"-\") continue;\r\n if (c in alphabetValues) {\r\n if (alphabetValues[c] >= absBase) {\r\n if (c === \"1\" && absBase === 1) continue;\r\n throw new Error(c + \" is not a valid digit in base \" + base + \".\");\r\n }\r\n }\r\n }\r\n base = parseValue(base);\r\n var digits = [];\r\n var isNegative = text[0] === \"-\";\r\n for (i = isNegative ? 1 : 0; i < text.length; i++) {\r\n var c = text[i];\r\n if (c in alphabetValues) digits.push(parseValue(alphabetValues[c]));\r\n else if (c === \"<\") {\r\n var start = i;\r\n do { i++; } while (text[i] !== \">\" && i < text.length);\r\n digits.push(parseValue(text.slice(start + 1, i)));\r\n }\r\n else throw new Error(c + \" is not a valid character\");\r\n }\r\n return parseBaseFromArray(digits, base, isNegative);\r\n };\r\n\r\n function parseBaseFromArray(digits, base, isNegative) {\r\n var val = Integer[0], pow = Integer[1], i;\r\n for (i = digits.length - 1; i >= 0; i--) {\r\n val = val.add(digits[i].times(pow));\r\n pow = pow.times(base);\r\n }\r\n return isNegative ? val.negate() : val;\r\n }\r\n\r\n function stringify(digit, alphabet) {\r\n alphabet = alphabet || DEFAULT_ALPHABET;\r\n if (digit < alphabet.length) {\r\n return alphabet[digit];\r\n }\r\n return \"<\" + digit + \">\";\r\n }\r\n\r\n function toBase(n, base) {\r\n base = bigInt(base);\r\n if (base.isZero()) {\r\n if (n.isZero()) return { value: [0], isNegative: false };\r\n throw new Error(\"Cannot convert nonzero numbers to base 0.\");\r\n }\r\n if (base.equals(-1)) {\r\n if (n.isZero()) return { value: [0], isNegative: false };\r\n if (n.isNegative())\r\n return {\r\n value: [].concat.apply([], Array.apply(null, Array(-n.toJSNumber()))\r\n .map(Array.prototype.valueOf, [1, 0])\r\n ),\r\n isNegative: false\r\n };\r\n\r\n var arr = Array.apply(null, Array(n.toJSNumber() - 1))\r\n .map(Array.prototype.valueOf, [0, 1]);\r\n arr.unshift([1]);\r\n return {\r\n value: [].concat.apply([], arr),\r\n isNegative: false\r\n };\r\n }\r\n\r\n var neg = false;\r\n if (n.isNegative() && base.isPositive()) {\r\n neg = true;\r\n n = n.abs();\r\n }\r\n if (base.isUnit()) {\r\n if (n.isZero()) return { value: [0], isNegative: false };\r\n\r\n return {\r\n value: Array.apply(null, Array(n.toJSNumber()))\r\n .map(Number.prototype.valueOf, 1),\r\n isNegative: neg\r\n };\r\n }\r\n var out = [];\r\n var left = n, divmod;\r\n while (left.isNegative() || left.compareAbs(base) >= 0) {\r\n divmod = left.divmod(base);\r\n left = divmod.quotient;\r\n var digit = divmod.remainder;\r\n if (digit.isNegative()) {\r\n digit = base.minus(digit).abs();\r\n left = left.next();\r\n }\r\n out.push(digit.toJSNumber());\r\n }\r\n out.push(left.toJSNumber());\r\n return { value: out.reverse(), isNegative: neg };\r\n }\r\n\r\n function toBaseString(n, base, alphabet) {\r\n var arr = toBase(n, base);\r\n return (arr.isNegative ? \"-\" : \"\") + arr.value.map(function (x) {\r\n return stringify(x, alphabet);\r\n }).join('');\r\n }\r\n\r\n BigInteger.prototype.toArray = function (radix) {\r\n return toBase(this, radix);\r\n };\r\n\r\n SmallInteger.prototype.toArray = function (radix) {\r\n return toBase(this, radix);\r\n };\r\n\r\n NativeBigInt.prototype.toArray = function (radix) {\r\n return toBase(this, radix);\r\n };\r\n\r\n BigInteger.prototype.toString = function (radix, alphabet) {\r\n if (radix === undefined) radix = 10;\r\n if (radix !== 10) return toBaseString(this, radix, alphabet);\r\n var v = this.value, l = v.length, str = String(v[--l]), zeros = \"0000000\", digit;\r\n while (--l >= 0) {\r\n digit = String(v[l]);\r\n str += zeros.slice(digit.length) + digit;\r\n }\r\n var sign = this.sign ? \"-\" : \"\";\r\n return sign + str;\r\n };\r\n\r\n SmallInteger.prototype.toString = function (radix, alphabet) {\r\n if (radix === undefined) radix = 10;\r\n if (radix != 10) return toBaseString(this, radix, alphabet);\r\n return String(this.value);\r\n };\r\n\r\n NativeBigInt.prototype.toString = SmallInteger.prototype.toString;\r\n\r\n NativeBigInt.prototype.toJSON = BigInteger.prototype.toJSON = SmallInteger.prototype.toJSON = function () { return this.toString(); }\r\n\r\n BigInteger.prototype.valueOf = function () {\r\n return parseInt(this.toString(), 10);\r\n };\r\n BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;\r\n\r\n SmallInteger.prototype.valueOf = function () {\r\n return this.value;\r\n };\r\n SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;\r\n NativeBigInt.prototype.valueOf = NativeBigInt.prototype.toJSNumber = function () {\r\n return parseInt(this.toString(), 10);\r\n }\r\n\r\n function parseStringValue(v) {\r\n if (isPrecise(+v)) {\r\n var x = +v;\r\n if (x === truncate(x))\r\n return supportsNativeBigInt ? new NativeBigInt(BigInt(x)) : new SmallInteger(x);\r\n throw new Error(\"Invalid integer: \" + v);\r\n }\r\n var sign = v[0] === \"-\";\r\n if (sign) v = v.slice(1);\r\n var split = v.split(/e/i);\r\n if (split.length > 2) throw new Error(\"Invalid integer: \" + split.join(\"e\"));\r\n if (split.length === 2) {\r\n var exp = split[1];\r\n if (exp[0] === \"+\") exp = exp.slice(1);\r\n exp = +exp;\r\n if (exp !== truncate(exp) || !isPrecise(exp)) throw new Error(\"Invalid integer: \" + exp + \" is not a valid exponent.\");\r\n var text = split[0];\r\n var decimalPlace = text.indexOf(\".\");\r\n if (decimalPlace >= 0) {\r\n exp -= text.length - decimalPlace - 1;\r\n text = text.slice(0, decimalPlace) + text.slice(decimalPlace + 1);\r\n }\r\n if (exp < 0) throw new Error(\"Cannot include negative exponent part for integers\");\r\n text += (new Array(exp + 1)).join(\"0\");\r\n v = text;\r\n }\r\n var isValid = /^([0-9][0-9]*)$/.test(v);\r\n if (!isValid) throw new Error(\"Invalid integer: \" + v);\r\n if (supportsNativeBigInt) {\r\n return new NativeBigInt(BigInt(sign ? \"-\" + v : v));\r\n }\r\n var r = [], max = v.length, l = LOG_BASE, min = max - l;\r\n while (max > 0) {\r\n r.push(+v.slice(min, max));\r\n min -= l;\r\n if (min < 0) min = 0;\r\n max -= l;\r\n }\r\n trim(r);\r\n return new BigInteger(r, sign);\r\n }\r\n\r\n function parseNumberValue(v) {\r\n if (supportsNativeBigInt) {\r\n return new NativeBigInt(BigInt(v));\r\n }\r\n if (isPrecise(v)) {\r\n if (v !== truncate(v)) throw new Error(v + \" is not an integer.\");\r\n return new SmallInteger(v);\r\n }\r\n return parseStringValue(v.toString());\r\n }\r\n\r\n function parseValue(v) {\r\n if (typeof v === \"number\") {\r\n return parseNumberValue(v);\r\n }\r\n if (typeof v === \"string\") {\r\n return parseStringValue(v);\r\n }\r\n if (typeof v === \"bigint\") {\r\n return new NativeBigInt(v);\r\n }\r\n return v;\r\n }\r\n // Pre-define numbers in range [-999,999]\r\n for (var i = 0; i < 1000; i++) {\r\n Integer[i] = parseValue(i);\r\n if (i > 0) Integer[-i] = parseValue(-i);\r\n }\r\n // Backwards compatibility\r\n Integer.one = Integer[1];\r\n Integer.zero = Integer[0];\r\n Integer.minusOne = Integer[-1];\r\n Integer.max = max;\r\n Integer.min = min;\r\n Integer.gcd = gcd;\r\n Integer.lcm = lcm;\r\n Integer.isInstance = function (x) { return x instanceof BigInteger || x instanceof SmallInteger || x instanceof NativeBigInt; };\r\n Integer.randBetween = randBetween;\r\n\r\n Integer.fromArray = function (digits, base, isNegative) {\r\n return parseBaseFromArray(digits.map(parseValue), parseValue(base || 10), isNegative);\r\n };\r\n\r\n return Integer;\r\n})();\r\n\r\n// Node.js check\r\nif (typeof module !== \"undefined\" && module.hasOwnProperty(\"exports\")) {\r\n module.exports = bigInt;\r\n}\r\n\r\n//amd check\r\nif (typeof define === \"function\" && define.amd) {\r\n define( function () {\r\n return bigInt;\r\n });\r\n}\r\n",";(function (globalObject) {\r\n 'use strict';\r\n\r\n/*\r\n * bignumber.js v9.1.1\r\n * A JavaScript library for arbitrary-precision arithmetic.\r\n * https://github.com/MikeMcl/bignumber.js\r\n * Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>\r\n * MIT Licensed.\r\n *\r\n * BigNumber.prototype methods | BigNumber methods\r\n * |\r\n * absoluteValue abs | clone\r\n * comparedTo | config set\r\n * decimalPlaces dp | DECIMAL_PLACES\r\n * dividedBy div | ROUNDING_MODE\r\n * dividedToIntegerBy idiv | EXPONENTIAL_AT\r\n * exponentiatedBy pow | RANGE\r\n * integerValue | CRYPTO\r\n * isEqualTo eq | MODULO_MODE\r\n * isFinite | POW_PRECISION\r\n * isGreaterThan gt | FORMAT\r\n * isGreaterThanOrEqualTo gte | ALPHABET\r\n * isInteger | isBigNumber\r\n * isLessThan lt | maximum max\r\n * isLessThanOrEqualTo lte | minimum min\r\n * isNaN | random\r\n * isNegative | sum\r\n * isPositive |\r\n * isZero |\r\n * minus |\r\n * modulo mod |\r\n * multipliedBy times |\r\n * negated |\r\n * plus |\r\n * precision sd |\r\n * shiftedBy |\r\n * squareRoot sqrt |\r\n * toExponential |\r\n * toFixed |\r\n * toFormat |\r\n * toFraction |\r\n * toJSON |\r\n * toNumber |\r\n * toPrecision |\r\n * toString |\r\n * valueOf |\r\n *\r\n */\r\n\r\n\r\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 alphabetHasNormalDecimalDigits = true;\r\n\r\n\r\n //------------------------------------------------------------------------------------------\r\n\r\n\r\n // CONSTRUCTOR\r\n\r\n\r\n /*\r\n * The BigNumber constructor and exported function.\r\n * Create and return a new instance of a BigNumber object.\r\n *\r\n * v {number|string|BigNumber} A numeric value.\r\n * [b] {number} The base of v. Integer, 2 to ALPHABET.length inclusive.\r\n */\r\n function BigNumber(v, b) {\r\n var alphabet, c, caseChanged, e, i, isNum, len, str,\r\n x = this;\r\n\r\n // Enable constructor call without `new`.\r\n if (!(x instanceof BigNumber)) return new BigNumber(v, b);\r\n\r\n if (b == null) {\r\n\r\n if (v && v._isBigNumber === true) {\r\n x.s = v.s;\r\n\r\n if (!v.c || v.e > MAX_EXP) {\r\n x.c = x.e = null;\r\n } else if (v.e < MIN_EXP) {\r\n x.c = [x.e = 0];\r\n } else {\r\n x.e = v.e;\r\n x.c = v.c.slice();\r\n }\r\n\r\n return;\r\n }\r\n\r\n if ((isNum = typeof v == 'number') && v * 0 == 0) {\r\n\r\n // Use `1 / n` to handle minus zero also.\r\n x.s = 1 / v < 0 ? (v = -v, -1) : 1;\r\n\r\n // Fast path for integers, where n < 2147483648 (2**31).\r\n if (v === ~~v) {\r\n for (e = 0, i = v; i >= 10; i /= 10, e++);\r\n\r\n if (e > MAX_EXP) {\r\n x.c = x.e = null;\r\n } else {\r\n x.e = e;\r\n x.c = [v];\r\n }\r\n\r\n return;\r\n }\r\n\r\n str = String(v);\r\n } else {\r\n\r\n if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);\r\n\r\n x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;\r\n }\r\n\r\n // Decimal point?\r\n if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\r\n // Exponential form?\r\n if ((i = str.search(/e/i)) > 0) {\r\n\r\n // Determine exponent.\r\n if (e < 0) e = i;\r\n e += +str.slice(i + 1);\r\n str = str.substring(0, i);\r\n } else if (e < 0) {\r\n\r\n // Integer.\r\n e = str.length;\r\n }\r\n\r\n } else {\r\n\r\n // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n intCheck(b, 2, ALPHABET.length, 'Base');\r\n\r\n // Allow exponential notation to be used with base 10 argument, while\r\n // also rounding to DECIMAL_PLACES as with other bases.\r\n if (b == 10 && alphabetHasNormalDecimalDigits) {\r\n x = new BigNumber(v);\r\n return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);\r\n }\r\n\r\n str = String(v);\r\n\r\n if (isNum = typeof v == 'number') {\r\n\r\n // Avoid potential interpretation of Infinity and NaN as base 44+ values.\r\n if (v * 0 != 0) return parseNumeric(x, str, isNum, b);\r\n\r\n x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;\r\n\r\n // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n if (BigNumber.DEBUG && str.replace(/^0\\.0*|\\./, '').length > 15) {\r\n throw Error\r\n (tooManyDigits + v);\r\n }\r\n } else {\r\n x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;\r\n }\r\n\r\n alphabet = ALPHABET.slice(0, b);\r\n e = i = 0;\r\n\r\n // Check that str is a valid base b number.\r\n // Don't use RegExp, so alphabet can contain special characters.\r\n for (len = str.length; i < len; i++) {\r\n if (alphabet.indexOf(c = str.charAt(i)) < 0) {\r\n if (c == '.') {\r\n\r\n // If '.' is not the first character and it has not be found before.\r\n if (i > e) {\r\n e = len;\r\n continue;\r\n }\r\n } else if (!caseChanged) {\r\n\r\n // Allow e.g. hexadecimal 'FF' as well as 'ff'.\r\n if (str == str.toUpperCase() && (str = str.toLowerCase()) ||\r\n str == str.toLowerCase() && (str = str.toUpperCase())) {\r\n caseChanged = true;\r\n i = -1;\r\n e = 0;\r\n continue;\r\n }\r\n }\r\n\r\n return parseNumeric(x, String(v), isNum, b);\r\n }\r\n }\r\n\r\n // Prevent later check for length on converted number.\r\n isNum = false;\r\n str = convertBase(str, b, 10, x.s);\r\n\r\n // Decimal point?\r\n if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n else e = str.length;\r\n }\r\n\r\n // Determine leading zeros.\r\n for (i = 0; str.charCodeAt(i) === 48; i++);\r\n\r\n // Determine trailing zeros.\r\n for (len = str.length; str.charCodeAt(--len) === 48;);\r\n\r\n if (str = str.slice(i, ++len)) {\r\n len -= i;\r\n\r\n // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n if (isNum && BigNumber.DEBUG &&\r\n len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {\r\n throw Error\r\n (tooManyDigits + (x.s * v));\r\n }\r\n\r\n // Overflow?\r\n if ((e = e - i - 1) > MAX_EXP) {\r\n\r\n // Infinity.\r\n x.c = x.e = null;\r\n\r\n // Underflow?\r\n } else if (e < MIN_EXP) {\r\n\r\n // Zero.\r\n x.c = [x.e = 0];\r\n } else {\r\n x.e = e;\r\n x.c = [];\r\n\r\n // Transform base\r\n\r\n // e is the base 10 exponent.\r\n // i is where to slice str to get the first element of the coefficient array.\r\n i = (e + 1) % LOG_BASE;\r\n if (e < 0) i += LOG_BASE; // i < 1\r\n\r\n if (i < len) {\r\n if (i) x.c.push(+str.slice(0, i));\r\n\r\n for (len -= LOG_BASE; i < len;) {\r\n x.c.push(+str.slice(i, i += LOG_BASE));\r\n }\r\n\r\n i = LOG_BASE - (str = str.slice(i)).length;\r\n } else {\r\n i -= len;\r\n }\r\n\r\n for (; i--; str += '0');\r\n x.c.push(+str);\r\n }\r\n } else {\r\n\r\n // Zero.\r\n x.c = [x.e = 0];\r\n }\r\n }\r\n\r\n\r\n // CONSTRUCTOR PROPERTIES\r\n\r\n\r\n BigNumber.clone = clone;\r\n\r\n BigNumber.ROUND_UP = 0;\r\n BigNumber.ROUND_DOWN = 1;\r\n BigNumber.ROUND_CEIL = 2;\r\n BigNumber.ROUND_FLOOR = 3;\r\n BigNumber.ROUND_HALF_UP = 4;\r\n BigNumber.ROUND_HALF_DOWN = 5;\r\n BigNumber.ROUND_HALF_EVEN = 6;\r\n BigNumber.ROUND_HALF_CEIL = 7;\r\n BigNumber.ROUND_HALF_FLOOR = 8;\r\n BigNumber.EUCLID = 9;\r\n\r\n\r\n /*\r\n * Configure infrequently-changing library-wide settings.\r\n *\r\n * Accept an object with the following optional properties (if the value of a property is\r\n * a number, it must be an integer within the inclusive range stated):\r\n *\r\n * DECIMAL_PLACES {number} 0 to MAX\r\n * ROUNDING_MODE {number} 0 to 8\r\n * EXPONENTIAL_AT {number|number[]} -MAX to MAX or [-MAX to 0, 0 to MAX]\r\n * RANGE {number|number[]} -MAX to MAX (not zero) or [-MAX to -1, 1 to MAX]\r\n * CRYPTO {boolean} true or false\r\n * MODULO_MODE {number} 0 to 9\r\n * POW_PRECISION {number} 0 to MAX\r\n * ALPHABET {string} A string of two or more unique characters which does\r\n * not contain '.'.\r\n * FORMAT {object} An object with some of the following properties:\r\n * prefix {string}\r\n * groupSize {number}\r\n * secondaryGroupSize {number}\r\n * groupSeparator {string}\r\n * decimalSeparator {string}\r\n * fractionGroupSize {number}\r\n * fractionGroupSeparator {string}\r\n * suffix {string}\r\n *\r\n * (The values assigned to the above FORMAT object properties are not checked for validity.)\r\n *\r\n * E.g.\r\n * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })\r\n *\r\n * Ignore properties/parameters set to null or undefined, except for ALPHABET.\r\n *\r\n * Return an object with the properties current values.\r\n */\r\n BigNumber.config = BigNumber.set = function (obj) {\r\n var p, v;\r\n\r\n if (obj != null) {\r\n\r\n if (typeof obj == 'object') {\r\n\r\n // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.\r\n // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'\r\n if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {\r\n v = obj[p];\r\n intCheck(v, 0, MAX, p);\r\n DECIMAL_PLACES = v;\r\n }\r\n\r\n // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.\r\n // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {\r\n v = obj[p];\r\n intCheck(v, 0, 8, p);\r\n ROUNDING_MODE = v;\r\n }\r\n\r\n // EXPONENTIAL_AT {number|number[]}\r\n // Integer, -MAX to MAX inclusive or\r\n // [integer -MAX to 0 inclusive, 0 to MAX inclusive].\r\n // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'\r\n if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {\r\n v = obj[p];\r\n if (v && v.pop) {\r\n intCheck(v[0], -MAX, 0, p);\r\n intCheck(v[1], 0, MAX, p);\r\n TO_EXP_NEG = v[0];\r\n TO_EXP_POS = v[1];\r\n } else {\r\n intCheck(v, -MAX, MAX, p);\r\n TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);\r\n }\r\n }\r\n\r\n // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or\r\n // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].\r\n // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'\r\n if (obj.hasOwnProperty(p = 'RANGE')) {\r\n v = obj[p];\r\n if (v && v.pop) {\r\n intCheck(v[0], -MAX, -1, p);\r\n intCheck(v[1], 1, MAX, p);\r\n MIN_EXP = v[0];\r\n MAX_EXP = v[1];\r\n } else {\r\n intCheck(v, -MAX, MAX, p);\r\n if (v) {\r\n MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);\r\n } else {\r\n throw Error\r\n (bignumberError + p + ' cannot be zero: ' + v);\r\n }\r\n }\r\n }\r\n\r\n // CRYPTO {boolean} true or false.\r\n // '[BigNumber Error] CRYPTO not true or false: {v}'\r\n // '[BigNumber Error] crypto unavailable'\r\n if (obj.hasOwnProperty(p = 'CRYPTO')) {\r\n v = obj[p];\r\n if (v === !!v) {\r\n if (v) {\r\n if (typeof crypto != 'undefined' && crypto &&\r\n (crypto.getRandomValues || crypto.randomBytes)) {\r\n CRYPTO = v;\r\n } else {\r\n CRYPTO = !v;\r\n throw Error\r\n (bignumberError + 'crypto unavailable');\r\n }\r\n } else {\r\n CRYPTO = v;\r\n }\r\n } else {\r\n throw Error\r\n (bignumberError + p + ' not true or false: ' + v);\r\n }\r\n }\r\n\r\n // MODULO_MODE {number} Integer, 0 to 9 inclusive.\r\n // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n if (obj.hasOwnProperty(p = 'MODULO_MODE')) {\r\n v = obj[p];\r\n intCheck(v, 0, 9, p);\r\n MODULO_MODE = v;\r\n }\r\n\r\n // POW_PRECISION {number} Integer, 0 to MAX inclusive.\r\n // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'\r\n if (obj.hasOwnProperty(p = 'POW_PRECISION')) {\r\n v = obj[p];\r\n intCheck(v, 0, MAX, p);\r\n POW_PRECISION = v;\r\n }\r\n\r\n // FORMAT {object}\r\n // '[BigNumber Error] FORMAT not an object: {v}'\r\n if (obj.hasOwnProperty(p = 'FORMAT')) {\r\n v = obj[p];\r\n if (typeof v == 'object') FORMAT = v;\r\n else throw Error\r\n (bignumberError + p + ' not an object: ' + v);\r\n }\r\n\r\n // ALPHABET {string}\r\n // '[BigNumber Error] ALPHABET invalid: {v}'\r\n if (obj.hasOwnProperty(p = 'ALPHABET')) {\r\n v = obj[p];\r\n\r\n // Disallow if less than two characters,\r\n // or if it contains '+', '-', '.', whitespace, or a repeated character.\r\n if (typeof v == 'string' && !/^.?$|[+\\-.\\s]|(.).*\\1/.test(v)) {\r\n alphabetHasNormalDecimalDigits = v.slice(0, 10) == '0123456789';\r\n ALPHABET = v;\r\n } else {\r\n throw Error\r\n (bignumberError + p + ' invalid: ' + v);\r\n }\r\n }\r\n\r\n } else {\r\n\r\n // '[BigNumber Error] Object expected: {v}'\r\n throw Error\r\n (bignumberError + 'Object expected: ' + obj);\r\n }\r\n }\r\n\r\n return {\r\n DECIMAL_PLACES: DECIMAL_PLACES,\r\n ROUNDING_MODE: ROUNDING_MODE,\r\n EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],\r\n RANGE: [MIN_EXP, MAX_EXP],\r\n CRYPTO: CRYPTO,\r\n MODULO_MODE: MODULO_MODE,\r\n POW_PRECISION: POW_PRECISION,\r\n FORMAT: FORMAT,\r\n ALPHABET: ALPHABET\r\n };\r\n };\r\n\r\n\r\n /*\r\n * Return true if v is a BigNumber instance, otherwise return false.\r\n *\r\n * If BigNumber.DEBUG is true, throw if a BigNumber instance is not well-formed.\r\n *\r\n * v {any}\r\n *\r\n * '[BigNumber Error] Invalid BigNumber: {v}'\r\n */\r\n BigNumber.isBigNumber = function (v) {\r\n if (!v || v._isBigNumber !== true) return false;\r\n if (!BigNumber.DEBUG) return true;\r\n\r\n var i, n,\r\n c = v.c,\r\n e = v.e,\r\n s = v.s;\r\n\r\n out: if ({}.toString.call(c) == '[object Array]') {\r\n\r\n if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {\r\n\r\n // If the first element is zero, the BigNumber value must be zero.\r\n if (c[0] === 0) {\r\n if (e === 0 && c.length === 1) return true;\r\n break out;\r\n }\r\n\r\n // Calculate number of digits that c[0] should have, based on the exponent.\r\n i = (e + 1) % LOG_BASE;\r\n if (i < 1) i += LOG_BASE;\r\n\r\n // Calculate number of digits of c[0].\r\n //if (Math.ceil(Math.log(c[0] + 1) / Math.LN10) == i) {\r\n if (String(c[0]).length == i) {\r\n\r\n for (i = 0; i < c.length; i++) {\r\n n = c[i];\r\n if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;\r\n }\r\n\r\n // Last element cannot be zero, unless it is the only element.\r\n if (n !== 0) return true;\r\n }\r\n }\r\n\r\n // Infinity/NaN\r\n } else if (c === null && e === null && (s === null || s === 1 || s === -1)) {\r\n return true;\r\n }\r\n\r\n throw Error\r\n (bignumberError + 'Invalid BigNumber: ' + v);\r\n };\r\n\r\n\r\n /*\r\n * Return a new BigNumber whose value is the maximum of the arguments.\r\n *\r\n * arguments {number|string|BigNumber}\r\n */\r\n BigNumber.maximum = BigNumber.max = function () {\r\n return maxOrMin(arguments, P.lt);\r\n };\r\n\r\n\r\n /*\r\n * Return a new BigNumber whose value is the minimum of the arguments.\r\n *\r\n * arguments {number|string|BigNumber}\r\n */\r\n BigNumber.minimum = BigNumber.min = function () {\r\n return maxOrMin(arguments, P.gt);\r\n };\r\n\r\n\r\n /*\r\n * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\r\n * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\r\n * zeros are produced).\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'\r\n * '[BigNumber Error] crypto unavailable'\r\n */\r\n BigNumber.random = (function () {\r\n var pow2_53 = 0x20000000000000;\r\n\r\n // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\r\n // Check if Math.random() produces more than 32 bits of randomness.\r\n // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\r\n // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\r\n var random53bitInt = (Math.random() * pow2_53) & 0x1fffff\r\n ? function () { return mathfloor(Math.random() * pow2_53); }\r\n : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +\r\n (Math.random() * 0x800000 | 0); };\r\n\r\n return function (dp) {\r\n var a, b, e, k, v,\r\n i = 0,\r\n c = [],\r\n rand = new BigNumber(ONE);\r\n\r\n if (dp == null) dp = DECIMAL_PLACES;\r\n else intCheck(dp, 0, MAX);\r\n\r\n k = mathceil(dp / LOG_BASE);\r\n\r\n if (CRYPTO) {\r\n\r\n // Browsers supporting crypto.getRandomValues.\r\n if (crypto.getRandomValues) {\r\n\r\n a = crypto.getRandomValues(new Uint32Array(k *= 2));\r\n\r\n for (; i < k;) {\r\n\r\n // 53 bits:\r\n // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\r\n // 11111 11111111 11111111 11111111 11100000 00000000 00000000\r\n // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\r\n // 11111 11111111 11111111\r\n // 0x20000 is 2^21.\r\n v = a[i] * 0x20000 + (a[i + 1] >>> 11);\r\n\r\n // Rejection sampling:\r\n // 0 <= v < 9007199254740992\r\n // Probability that v >= 9e15, is\r\n // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\r\n if (v >= 9e15) {\r\n b = crypto.getRandomValues(new Uint32Array(2));\r\n a[i] = b[0];\r\n a[i + 1] = b[1];\r\n } else {\r\n\r\n // 0 <= v <= 8999999999999999\r\n // 0 <= (v % 1e14) <= 99999999999999\r\n c.push(v % 1e14);\r\n i += 2;\r\n }\r\n }\r\n i = k / 2;\r\n\r\n // Node.js supporting crypto.randomBytes.\r\n } else if (crypto.randomBytes) {\r\n\r\n // buffer\r\n a = crypto.randomBytes(k *= 7);\r\n\r\n for (; i < k;) {\r\n\r\n // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\r\n // 0x100000000 is 2^32, 0x1000000 is 2^24\r\n // 11111 11111111 11111111 11111111 11111111 11111111 11111111\r\n // 0 <= v < 9007199254740992\r\n v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +\r\n (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +\r\n (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];\r\n\r\n if (v >= 9e15) {\r\n crypto.randomBytes(7).copy(a, i);\r\n } else {\r\n\r\n // 0 <= (v % 1e14) <= 99999999999999\r\n c.push(v % 1e14);\r\n i += 7;\r\n }\r\n }\r\n i = k / 7;\r\n } else {\r\n CRYPTO = false;\r\n throw Error\r\n (bignumberError + 'crypto unavailable');\r\n }\r\n }\r\n\r\n // Use Math.random.\r\n if (!CRYPTO) {\r\n\r\n for (; i < k;) {\r\n v = random53bitInt();\r\n if (v < 9e15) c[i++] = v % 1e14;\r\n }\r\n }\r\n\r\n k = c[--i];\r\n dp %= LOG_BASE;\r\n\r\n // Convert trailing digits to zeros according to dp.\r\n if (k && dp) {\r\n v = POWS_TEN[LOG_BASE - dp];\r\n c[i] = mathfloor(k / v) * v;\r\n }\r\n\r\n // Remove trailing elements which are zero.\r\n for (; c[i] === 0; c.pop(), i--);\r\n\r\n // Zero?\r\n if (i < 0) {\r\n c = [e = 0];\r\n } else {\r\n\r\n // Remove leading elements which are zero and adjust exponent accordingly.\r\n for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);\r\n\r\n // Count the digits of the first element of c to determine leading zeros, and...\r\n for (i = 1, v = c[0]; v >= 10; v /= 10, i++);\r\n\r\n // adjust the exponent accordingly.\r\n if (i < LOG_BASE) e -= LOG_BASE - i;\r\n }\r\n\r\n rand.e = e;\r\n rand.c = c;\r\n return rand;\r\n };\r\n })();\r\n\r\n\r\n /*\r\n * Return a BigNumber whose value is the sum of the arguments.\r\n *\r\n * arguments {number|string|BigNumber}\r\n */\r\n BigNumber.sum = function () {\r\n var i = 1,\r\n args = arguments,\r\n sum = new BigNumber(args[0]);\r\n for (; i < args.length;) sum = sum.plus(args[i++]);\r\n return sum;\r\n };\r\n\r\n\r\n // PRIVATE FUNCTIONS\r\n\r\n\r\n // Called by BigNumber and BigNumber.prototype.toString.\r\n convertBase = (function () {\r\n var decimal = '0123456789';\r\n\r\n /*\r\n * Convert string of baseIn to an array of numbers of baseOut.\r\n * Eg. toBaseOut('255', 10, 16) returns [15, 15].\r\n * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].\r\n */\r\n function toBaseOut(str, baseIn, baseOut, alphabet) {\r\n var j,\r\n arr = [0],\r\n arrL,\r\n i = 0,\r\n len = str.length;\r\n\r\n for (; i < len;) {\r\n for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);\r\n\r\n arr[0] += alphabet.indexOf(str.charAt(i++));\r\n\r\n for (j = 0; j < arr.length; j++) {\r\n\r\n if (arr[j] > baseOut - 1) {\r\n if (arr[j + 1] == null) arr[j + 1] = 0;\r\n arr[j + 1] += arr[j] / baseOut | 0;\r\n arr[j] %= baseOut;\r\n }\r\n }\r\n }\r\n\r\n return arr.reverse();\r\n }\r\n\r\n // Convert a numeric string of baseIn to a numeric string of baseOut.\r\n // If the caller is toString, we are converting from base 10 to baseOut.\r\n // If the caller is BigNumber, we are converting from baseIn to base 10.\r\n return function (str, baseIn, baseOut, sign, callerIsToString) {\r\n var alphabet, d, e, k, r, x, xc, y,\r\n i = str.indexOf('.'),\r\n dp = DECIMAL_PLACES,\r\n rm = ROUNDING_MODE;\r\n\r\n // Non-integer.\r\n if (i >= 0) {\r\n k = POW_PRECISION;\r\n\r\n // Unlimited precision.\r\n POW_PRECISION = 0;\r\n str = str.replace('.', '');\r\n y = new BigNumber(baseIn);\r\n x = y.pow(str.length - i);\r\n POW_PRECISION = k;\r\n\r\n // Convert str as if an integer, then restore the fraction part by dividing the\r\n // result by its base raised to a power.\r\n\r\n y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),\r\n 10, baseOut, decimal);\r\n y.e = y.c.length;\r\n }\r\n\r\n // Convert the number as integer.\r\n\r\n xc = toBaseOut(str, baseIn, baseOut, callerIsToString\r\n ? (alphabet = ALPHABET, decimal)\r\n : (alphabet = decimal, ALPHABET));\r\n\r\n // xc now represents str as an integer and converted to baseOut. e is the exponent.\r\n e = k = xc.length;\r\n\r\n // Remove trailing zeros.\r\n for (; xc[--k] == 0; xc.pop());\r\n\r\n // Zero?\r\n if (!xc[0]) return alphabet.charAt(0);\r\n\r\n // Does str represent an integer? If so, no need for the division.\r\n if (i < 0) {\r\n --e;\r\n } else {\r\n x.c = xc;\r\n x.e = e;\r\n\r\n // The sign is needed for correct rounding.\r\n x.s = sign;\r\n x = div(x, y, dp, rm, baseOut);\r\n xc = x.c;\r\n r = x.r;\r\n e = x.e;\r\n }\r\n\r\n // xc now represents str converted to baseOut.\r\n\r\n // THe index of the rounding digit.\r\n d = e + dp + 1;\r\n\r\n // The rounding digit: the digit to the right of the digit that may be rounded up.\r\n i = xc[d];\r\n\r\n // Look at the rounding digits and mode to determine whether to round up.\r\n\r\n k = baseOut / 2;\r\n r = r || d < 0 || xc[d + 1] != null;\r\n\r\n r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||\r\n rm == (x.s < 0 ? 8 : 7));\r\n\r\n // If the index of the rounding digit is not greater than zero, or xc represents\r\n // zero, then the result of the base conversion is zero or, if rounding up, a value\r\n // such as 0.00001.\r\n if (d < 1 || !xc[0]) {\r\n\r\n // 1^-dp or 0\r\n str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);\r\n } else {\r\n\r\n // Truncate xc to the required number of decimal places.\r\n xc.length = d;\r\n\r\n // Round up?\r\n if (r) {\r\n\r\n // Rounding up may mean the previous digit has to be rounded up and so on.\r\n for (--baseOut; ++xc[--d] > baseOut;) {\r\n xc[d] = 0;\r\n\r\n if (!d) {\r\n ++e;\r\n xc = [1].concat(xc);\r\n }\r\n }\r\n }\r\n\r\n // Determine trailing zeros.\r\n for (k = xc.length; !xc[--k];);\r\n\r\n // E.g. [4, 11, 15] becomes 4bf.\r\n for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));\r\n\r\n // Add leading zeros, decimal point and trailing zeros as required.\r\n str = toFixedPoint(str, e, alphabet.charAt(0));\r\n }\r\n\r\n // The caller will add the sign.\r\n return str;\r\n };\r\n })();\r\n\r\n\r\n // Perform division in the specified base. Called by div and convertBase.\r\n div = (function () {\r\n\r\n // Assume non-zero x and k.\r\n function multiply(x, k, base) {\r\n var m, temp, xlo, xhi,\r\n carry = 0,\r\n i = x.length,\r\n klo = k % SQRT_BASE,\r\n khi = k / SQRT_BASE | 0;\r\n\r\n for (x = x.slice(); i--;) {\r\n xlo = x[i] % SQRT_BASE;\r\n xhi = x[i] / SQRT_BASE | 0;\r\n m = khi * xlo + xhi * klo;\r\n temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;\r\n carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;\r\n x[i] = temp % base;\r\n }\r\n\r\n if (carry) x = [carry].concat(x);\r\n\r\n return x;\r\n }\r\n\r\n function compare(a, b, aL, bL) {\r\n var i, cmp;\r\n\r\n if (aL != bL) {\r\n cmp = aL > bL ? 1 : -1;\r\n } else {\r\n\r\n for (i = cmp = 0; i < aL; i++) {\r\n\r\n if (a[i] != b[i]) {\r\n cmp = a[i] > b[i] ? 1 : -1;\r\n break;\r\n }\r\n }\r\n }\r\n\r\n return cmp;\r\n }\r\n\r\n function subtract(a, b, aL, base) {\r\n var i = 0;\r\n\r\n // Subtract b from a.\r\n for (; aL--;) {\r\n a[aL] -= i;\r\n i = a[aL] < b[aL] ? 1 : 0;\r\n a[aL] = i * base + a[aL] - b[aL];\r\n }\r\n\r\n // Remove leading zeros.\r\n for (; !a[0] && a.length > 1; a.splice(0, 1));\r\n }\r\n\r\n // x: dividend, y: divisor.\r\n return function (x, y, dp, rm, base) {\r\n var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,\r\n yL, yz,\r\n s = x.s == y.s ? 1 : -1,\r\n xc = x.c,\r\n yc = y.c;\r\n\r\n // Either NaN, Infinity or 0?\r\n if (!xc || !xc[0] || !yc || !yc[0]) {\r\n\r\n return new BigNumber(\r\n\r\n // Return NaN if either NaN, or both Infinity or 0.\r\n !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :\r\n\r\n // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\r\n xc && xc[0] == 0 || !yc ? s * 0 : s / 0\r\n );\r\n }\r\n\r\n q = new BigNumber(s);\r\n qc = q.c = [];\r\n e = x.e - y.e;\r\n s = dp + e + 1;\r\n\r\n if (!base) {\r\n base = BASE;\r\n e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);\r\n s = s / LOG_BASE | 0;\r\n }\r\n\r\n // Result exponent may be one less then the current value of e.\r\n // The coefficients of the BigNumbers from convertBase may have trailing zeros.\r\n for (i = 0; yc[i] == (xc[i] || 0); i++);\r\n\r\n if (yc[i] > (xc[i] || 0)) e--;\r\n\r\n if (s < 0) {\r\n qc.push(1);\r\n more = true;\r\n } else {\r\n xL = xc.length;\r\n yL = yc.length;\r\n i = 0;\r\n s += 2;\r\n\r\n // Normalise xc and yc so highest order digit of yc is >= base / 2.\r\n\r\n n = mathfloor(base / (yc[0] + 1));\r\n\r\n // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.\r\n // if (n > 1 || n++ == 1 && yc[0] < base / 2) {\r\n if (n > 1) {\r\n yc = multiply(yc, n, base);\r\n xc = multiply(xc, n, base);\r\n yL = yc.length;\r\n xL = xc.length;\r\n }\r\n\r\n xi = yL;\r\n rem = xc.slice(0, yL);\r\n remL = rem.length;\r\n\r\n // Add zeros to make remainder as long as divisor.\r\n for (; remL < yL; rem[remL++] = 0);\r\n yz = yc.slice();\r\n yz = [0].concat(yz);\r\n yc0 = yc[0];\r\n if (yc[1] >= base / 2) yc0++;\r\n // Not necessary, but to prevent trial digit n > base, when using base 3.\r\n // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;\r\n\r\n do {\r\n n = 0;\r\n\r\n // Compare divisor and remainder.\r\n cmp = compare(yc, rem, yL, remL);\r\n\r\n // If divisor < remainder.\r\n if (cmp < 0) {\r\n\r\n // Calculate trial digit, n.\r\n\r\n rem0 = rem[0];\r\n if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n // n is how many times the divisor goes into the current remainder.\r\n n = mathfloor(rem0 / yc0);\r\n\r\n // Algorithm:\r\n // product = divisor multiplied by trial digit (n).\r\n // Compare product and remainder.\r\n // If product is greater than remainder:\r\n // Subtract divisor from product, decrement trial digit.\r\n // Subtract product from remainder.\r\n // If product was less than remainder at the last compare:\r\n // Compare new remainder and divisor.\r\n // If remainder is greater than divisor:\r\n // Subtract divisor from remainder, increment trial digit.\r\n\r\n if (n > 1) {\r\n\r\n // n may be > base only when base is 3.\r\n if (n >= base) n = base - 1;\r\n\r\n // product = divisor * trial digit.\r\n prod = multiply(yc, n, base);\r\n prodL = prod.length;\r\n remL = rem.length;\r\n\r\n // Compare product and remainder.\r\n // If product > remainder then trial digit n too high.\r\n // n is 1 too high about 5% of the time, and is not known to have\r\n // ever been more than 1 too high.\r\n while (compare(prod, rem, prodL, remL) == 1) {\r\n n--;\r\n\r\n // Subtract divisor from product.\r\n subtract(prod, yL < prodL ? yz : yc, prodL, base);\r\n prodL = prod.length;\r\n cmp = 1;\r\n }\r\n } else {\r\n\r\n // n is 0 or 1, cmp is -1.\r\n // If n is 0, there is no need to compare yc and rem again below,\r\n // so change cmp to 1 to avoid it.\r\n // If n is 1, leave cmp as -1, so yc and rem are compared again.\r\n if (n == 0) {\r\n\r\n // divisor < remainder, so n must be at least 1.\r\n cmp = n = 1;\r\n }\r\n\r\n // product = divisor\r\n prod = yc.slice();\r\n prodL = prod.length;\r\n }\r\n\r\n if (prodL < remL) prod = [0].concat(prod);\r\n\r\n // Subtract product from remainder.\r\n subtract(rem, prod, remL, base);\r\n remL = rem.length;\r\n\r\n // If product was < remainder.\r\n if (cmp == -1) {\r\n\r\n // Compare divisor and new remainder.\r\n // If divisor < new remainder, subtract divisor from remainder.\r\n // Trial digit n too low.\r\n // n is 1 too low about 5% of the time, and very rarely 2 too low.\r\n while (compare(yc, rem, yL, remL) < 1) {\r\n n++;\r\n\r\n // Subtract divisor from remainder.\r\n subtract(rem, yL < remL ? yz : yc, remL, base);\r\n remL = rem.length;\r\n }\r\n }\r\n } else if (cmp === 0) {\r\n n++;\r\n rem = [0];\r\n } // else cmp === 1 and n will be 0\r\n\r\n // Add the next digit, n, to the result array.\r\n qc[i++] = n;\r\n\r\n // Update the remainder.\r\n if (rem[0]) {\r\n rem[remL++] = xc[xi] || 0;\r\n } else {\r\n rem = [xc[xi]];\r\n remL = 1;\r\n }\r\n } while ((xi++ < xL || rem[0] != null) && s--);\r\n\r\n more = rem[0] != null;\r\n\r\n // Leading zero?\r\n if (!qc[0]) qc.splice(0, 1);\r\n }\r\n\r\n if (base == BASE) {\r\n\r\n // To calculate q.e, first get the number of digits of qc[0].\r\n for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);\r\n\r\n round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);\r\n\r\n // Caller is convertBase.\r\n } else {\r\n q.e = e;\r\n q.r = +more;\r\n }\r\n\r\n return q;\r\n };\r\n })();\r\n\r\n\r\n /*\r\n * Return a string representing the value of BigNumber n in fixed-point or exponential\r\n * notation rounded to the specified decimal places or significant digits.\r\n *\r\n * n: a BigNumber.\r\n * i: the index of the last digit required (i.e. the digit that may be rounded up).\r\n * rm: the rounding mode.\r\n * id: 1 (toExponential) or 2 (toPrecision).\r\n */\r\n function format(n, i, rm, id) {\r\n var c0, e, ne, len, str;\r\n\r\n if (rm == null) rm = ROUNDING_MODE;\r\n else intCheck(rm, 0, 8);\r\n\r\n if (!n.c) return n.toString();\r\n\r\n c0 = n.c[0];\r\n ne = n.e;\r\n\r\n if (i == null) {\r\n str = coeffToString(n.c);\r\n str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS)\r\n ? toExponential(str, ne)\r\n : toFixedPoint(str, ne, '0');\r\n } else {\r\n n = round(new BigNumber(n), i, rm);\r\n\r\n // n.e may have changed if the value was rounded up.\r\n e = n.e;\r\n\r\n str = coeffToString(n.c);\r\n len = str.length;\r\n\r\n // toPrecision returns exponential notation if the number of significant digits\r\n // specified is less than the number of digits necessary to represent the integer\r\n // part of the value in fixed-point notation.\r\n\r\n // Exponential notation.\r\n if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {\r\n\r\n // Append zeros?\r\n for (; len < i; str += '0', len++);\r\n str = toExponential(str, e);\r\n\r\n // Fixed-point notation.\r\n } else {\r\n i -= ne;\r\n str = toFixedPoint(str, e, '0');\r\n\r\n // Append zeros?\r\n if (e + 1 > len) {\r\n if (--i > 0) for (str += '.'; i--; str += '0');\r\n } else {\r\n i += e - len;\r\n if (i > 0) {\r\n if (e + 1 == len) str += '.';\r\n for (; i--; str += '0');\r\n }\r\n }\r\n }\r\n }\r\n\r\n return n.s < 0 && c0 ? '-' + str : str;\r\n }\r\n\r\n\r\n // Handle BigNumber.max and BigNumber.min.\r\n function maxOrMin(args, method) {\r\n var n,\r\n i = 1,\r\n m = new BigNumber(args[0]);\r\n\r\n for (; i < args.length; i++) {\r\n n = new BigNumber(args[i]);\r\n\r\n // If any number is NaN, return NaN.\r\n if (!n.s) {\r\n m = n;\r\n break;\r\n } else if (method.call(m, n)) {\r\n m = n;\r\n }\r\n }\r\n\r\n return m;\r\n }\r\n\r\n\r\n /*\r\n * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\r\n * Called by minus, plus and times.\r\n */\r\n function normalise(n, c, e) {\r\n var i = 1,\r\n j = c.length;\r\n\r\n // Remove trailing zeros.\r\n for (; !c[--j]; c.pop());\r\n\r\n // Calculate the base 10 exponent. First get the number of digits of c[0].\r\n for (j = c[0]; j >= 10; j /= 10, i++);\r\n\r\n // Overflow?\r\n if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {\r\n\r\n // Infinity.\r\n n.c = n.e = null;\r\n\r\n // Underflow?\r\n } else if (e < MIN_EXP) {\r\n\r\n // Zero.\r\n n.c = [n.e = 0];\r\n } else {\r\n n.e = e;\r\n n.c = c;\r\n }\r\n\r\n return n;\r\n }\r\n\r\n\r\n // Handle values that fail the validity test in BigNumber.\r\n parseNumeric = (function () {\r\n var basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i,\r\n dotAfter = /^([^.]+)\\.$/,\r\n dotBefore = /^\\.([^.]+)$/,\r\n isInfinityOrNaN = /^-?(Infinity|NaN)$/,\r\n whitespaceOrPlus = /^\\s*\\+(?=[\\w.])|^\\s+|\\s+$/g;\r\n\r\n return function (x, str, isNum, b) {\r\n var base,\r\n s = isNum ? str : str.replace(whitespaceOrPlus, '');\r\n\r\n // No exception on ±Infinity or NaN.\r\n if (isInfinityOrNaN.test(s)) {\r\n x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\r\n } else {\r\n if (!isNum) {\r\n\r\n // basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i\r\n s = s.replace(basePrefix, function (m, p1, p2) {\r\n base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\r\n return !b || b == base ? p1 : m;\r\n });\r\n\r\n if (b) {\r\n base = b;\r\n\r\n // E.g. '1.' to '1', '.1' to '0.1'\r\n s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');\r\n }\r\n\r\n if (str != s) return new BigNumber(s, base);\r\n }\r\n\r\n // '[BigNumber Error] Not a number: {n}'\r\n // '[BigNumber Error] Not a base {b} number: {n}'\r\n if (BigNumber.DEBUG) {\r\n throw Error\r\n (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);\r\n }\r\n\r\n // NaN\r\n x.s = null;\r\n }\r\n\r\n x.c = x.e = null;\r\n }\r\n })();\r\n\r\n\r\n /*\r\n * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\r\n * If r is truthy, it is known that there are more digits after the rounding digit.\r\n */\r\n function round(x, sd, rm, r) {\r\n var d, i, j, k, n, ni, rd,\r\n xc = x.c,\r\n pows10 = POWS_TEN;\r\n\r\n // if x is not Infinity or NaN...\r\n if (xc) {\r\n\r\n // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n // n is a base 1e14 number, the value of the element of array x.c containing rd.\r\n // ni is the index of n within x.c.\r\n // d is the number of digits of n.\r\n // i is the index of rd within n including leading zeros.\r\n // j is the actual index of rd within n (if < 0, rd is a leading zero).\r\n out: {\r\n\r\n // Get the number of digits of the first element of xc.\r\n for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);\r\n i = sd - d;\r\n\r\n // If the rounding digit is in the first element of xc...\r\n if (i < 0) {\r\n i += LOG_BASE;\r\n j = sd;\r\n n = xc[ni = 0];\r\n\r\n // Get the rounding digit at index j of n.\r\n rd = n / pows10[d - j - 1] % 10 | 0;\r\n } else {\r\n ni = mathceil((i + 1) / LOG_BASE);\r\n\r\n if (ni >= xc.length) {\r\n\r\n if (r) {\r\n\r\n // Needed by sqrt.\r\n for (; xc.length <= ni; xc.push(0));\r\n n = rd = 0;\r\n d = 1;\r\n i %= LOG_BASE;\r\n j = i - LOG_BASE + 1;\r\n } else {\r\n break out;\r\n }\r\n } else {\r\n n = k = xc[ni];\r\n\r\n // Get the number of digits of n.\r\n for (d = 1; k >= 10; k /= 10, d++);\r\n\r\n // Get the index of rd within n.\r\n i %= LOG_BASE;\r\n\r\n // Get the index of rd within n, adjusted for leading zeros.\r\n // The number of leading zeros of n is given by LOG_BASE - d.\r\n j = i - LOG_BASE + d;\r\n\r\n // Get the rounding digit at index j of n.\r\n rd = j < 0 ? 0 : n / pows10[d - j - 1] % 10 | 0;\r\n }\r\n }\r\n\r\n r = r || sd < 0 ||\r\n\r\n // Are there any non-zero digits after the rounding digit?\r\n // The expression n % pows10[d - j - 1] returns all digits of n to the right\r\n // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\r\n xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);\r\n\r\n r = rm < 4\r\n ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&\r\n\r\n // Check whether the digit to the left of the rounding digit is odd.\r\n ((i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||\r\n rm == (x.s < 0 ? 8 : 7));\r\n\r\n if (sd < 1 || !xc[0]) {\r\n xc.length = 0;\r\n\r\n if (r) {\r\n\r\n // Convert sd to decimal places.\r\n sd -= x.e + 1;\r\n\r\n // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];\r\n x.e = -sd || 0;\r\n } else {\r\n\r\n // Zero.\r\n xc[0] = x.e = 0;\r\n }\r\n\r\n return x;\r\n }\r\n\r\n // Remove excess digits.\r\n if (i == 0) {\r\n xc.length = ni;\r\n k = 1;\r\n ni--;\r\n } else {\r\n xc.length = ni + 1;\r\n k = pows10[LOG_BASE - i];\r\n\r\n // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n // j > 0 means i > number of leading zeros of n.\r\n xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;\r\n }\r\n\r\n // Round up?\r\n if (r) {\r\n\r\n for (; ;) {\r\n\r\n // If the digit to be rounded up is in the first element of xc...\r\n if (ni == 0) {\r\n\r\n // i will be the length of xc[0] before k is added.\r\n for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);\r\n j = xc[0] += k;\r\n for (k = 1; j >= 10; j /= 10, k++);\r\n\r\n // if i != k the length has increased.\r\n if (i != k) {\r\n x.e++;\r\n if (xc[0] == BASE) xc[0] = 1;\r\n }\r\n\r\n break;\r\n } else {\r\n xc[ni] += k;\r\n if (xc[ni] != BASE) break;\r\n xc[ni--] = 0;\r\n k = 1;\r\n }\r\n }\r\n }\r\n\r\n // Remove trailing zeros.\r\n for (i = xc.length; xc[--i] === 0; xc.pop());\r\n }\r\n\r\n // Overflow? Infinity.\r\n if (x.e > MAX_EXP) {\r\n x.c = x.e = null;\r\n\r\n // Underflow? Zero.\r\n } else if (x.e < MIN_EXP) {\r\n x.c = [x.e = 0];\r\n }\r\n }\r\n\r\n return x;\r\n }\r\n\r\n\r\n function valueOf(n) {\r\n var str,\r\n e = n.e;\r\n\r\n if (e === null) return n.toString();\r\n\r\n str = coeffToString(n.c);\r\n\r\n str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n ? toExponential(str, e)\r\n : toFixedPoint(str, e, '0');\r\n\r\n return n.s < 0 ? '-' + str : str;\r\n }\r\n\r\n\r\n // PROTOTYPE/INSTANCE METHODS\r\n\r\n\r\n /*\r\n * Return a new BigNumber whose value is the absolute value of this BigNumber.\r\n */\r\n P.absoluteValue = P.abs = function () {\r\n var x = new BigNumber(this);\r\n if (x.s < 0) x.s = 1;\r\n return x;\r\n };\r\n\r\n\r\n /*\r\n * Return\r\n * 1 if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n * -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n * 0 if they have the same value,\r\n * or null if the value of either is NaN.\r\n */\r\n P.comparedTo = function (y, b) {\r\n return compare(this, new BigNumber(y, b));\r\n };\r\n\r\n\r\n /*\r\n * If dp is undefined or null or true or false, return the number of decimal places of the\r\n * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n *\r\n * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this\r\n * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or\r\n * ROUNDING_MODE if rm is omitted.\r\n *\r\n * [dp] {number} Decimal places: integer, 0 to MAX inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n */\r\n P.decimalPlaces = P.dp = function (dp, rm) {\r\n var c, n, v,\r\n x = this;\r\n\r\n if (dp != null) {\r\n intCheck(dp, 0, MAX);\r\n if (rm == null) rm = ROUNDING_MODE;\r\n else intCheck(rm, 0, 8);\r\n\r\n return round(new BigNumber(x), dp + x.e + 1, rm);\r\n }\r\n\r\n if (!(c = x.c)) return null;\r\n n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n // Subtract the number of trailing zeros of the last number.\r\n if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);\r\n if (n < 0) n = 0;\r\n\r\n return n;\r\n };\r\n\r\n\r\n /*\r\n * n / 0 = I\r\n * n / N = N\r\n * n / I = 0\r\n * 0 / n = 0\r\n * 0 / 0 = N\r\n * 0 / N = N\r\n * 0 / I = 0\r\n * N / n = N\r\n * N / 0 = N\r\n * N / N = N\r\n * N / I = N\r\n * I / n = I\r\n * I / 0 = I\r\n * I / N = N\r\n * I / I = N\r\n *\r\n * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\r\n * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n */\r\n P.dividedBy = P.div = function (y, b) {\r\n return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);\r\n };\r\n\r\n\r\n /*\r\n * Return a new BigNumber whose value is the integer part of dividing the value of this\r\n * BigNumber by the value of BigNumber(y, b).\r\n */\r\n P.dividedToIntegerBy = P.idiv = function (y, b) {\r\n return div(this, new BigNumber(y, b), 0, 1);\r\n };\r\n\r\n\r\n /*\r\n * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.\r\n *\r\n * If m is present, return the result modulo m.\r\n * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\r\n * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.\r\n *\r\n * The modular power operation works efficiently when x, n, and m are integers, otherwise it\r\n * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.\r\n *\r\n * n {number|string|BigNumber} The exponent. An integer.\r\n * [m] {number|string|BigNumber} The modulus.\r\n *\r\n * '[BigNumber Error] Exponent not an integer: {n}'\r\n */\r\n P.exponentiatedBy = P.pow = function (n, m) {\r\n var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y,\r\n x = this;\r\n\r\n n = new BigNumber(n);\r\n\r\n // Allow NaN and ±Infinity, but not other non-integers.\r\n if (n.c && !n.isInteger()) {\r\n throw Error\r\n (bignumberError + 'Exponent not an integer: ' + valueOf(n));\r\n }\r\n\r\n if (m != null) m = new BigNumber(m);\r\n\r\n // Exponent of MAX_SAFE_INTEGER is 15.\r\n nIsBig = n.e > 14;\r\n\r\n // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.\r\n if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {\r\n\r\n // The sign of the result of pow when x is negative depends on the evenness of n.\r\n // If +n overflows to ±Infinity, the evenness of n would be not be known.\r\n y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? n.s * (2 - isOdd(n)) : +valueOf(n)));\r\n return m ? y.mod(m) : y;\r\n }\r\n\r\n nIsNeg = n.s < 0;\r\n\r\n if (m) {\r\n\r\n // x % m returns NaN if abs(m) is zero, or m is NaN.\r\n if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);\r\n\r\n isModExp = !nIsNeg && x.isInteger() && m.isInteger();\r\n\r\n if (isModExp) x = x.mod(m);\r\n\r\n // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.\r\n // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.\r\n } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0\r\n // [1, 240000000]\r\n ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7\r\n // [80000000000000] [99999750000000]\r\n : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {\r\n\r\n // If x is negative and n is odd, k = -0, else k = 0.\r\n k = x.s < 0 && isOdd(n) ? -0 : 0;\r\n\r\n // If x >= 1, k = ±Infinity.\r\n if (x.e > -1) k = 1 / k;\r\n\r\n // If n is negative return ±0, else return ±Infinity.\r\n return new BigNumber(nIsNeg ? 1 / k : k);\r\n\r\n } else if (POW_PRECISION) {\r\n\r\n // Truncating each coefficient array to a length of k after each multiplication\r\n // equates to truncating significant digits to POW_PRECISION + [28, 41],\r\n // i.e. there will be a minimum of 28 guard digits retained.\r\n k = mathceil(POW_PRECISION / LOG_BASE + 2);\r\n }\r\n\r\n if (nIsBig) {\r\n half = new BigNumber(0.5);\r\n if (nIsNeg) n.s = 1;\r\n nIsOdd = isOdd(n);\r\n } else {\r\n i = Math.abs(+valueOf(n));\r\n nIsOdd = i % 2;\r\n }\r\n\r\n y = new BigNumber(ONE);\r\n\r\n // Performs 54 loop iterations for n of 9007199254740991.\r\n for (; ;) {\r\n\r\n if (nIsOdd) {\r\n y = y.times(x);\r\n if (!y.c) break;\r\n\r\n if (k) {\r\n if (y.c.length > k) y.c.length = k;\r\n } else if (isModExp) {\r\n y = y.mod(m); //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));\r\n }\r\n }\r\n\r\n if (i) {\r\n i = mathfloor(i / 2);\r\n if (i === 0) break;\r\n nIsOdd = i % 2;\r\n } else {\r\n n = n.times(half);\r\n round(n, n.e + 1, 1);\r\n\r\n if (n.e > 14) {\r\n nIsOdd = isOdd(n);\r\n } else {\r\n i = +valueOf(n);\r\n if (i === 0) break;\r\n nIsOdd = i % 2;\r\n }\r\n }\r\n\r\n x = x.times(x);\r\n\r\n if (k) {\r\n if (x.c && x.c.length > k) x.c.length = k;\r\n } else if (isModExp) {\r\n x = x.mod(m); //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));\r\n }\r\n }\r\n\r\n if (isModExp) return y;\r\n if (nIsNeg) y = ONE.div(y);\r\n\r\n return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;\r\n };\r\n\r\n\r\n /*\r\n * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer\r\n * using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n *\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'\r\n */\r\n P.integerValue = function (rm) {\r\n var n = new BigNumber(this);\r\n if (rm == null) rm = ROUNDING_MODE;\r\n else intCheck(rm, 0, 8);\r\n return round(n, n.e + 1, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\r\n * otherwise return false.\r\n */\r\n P.isEqualTo = P.eq = function (y, b) {\r\n return compare(this, new BigNumber(y, b)) === 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is a finite number, otherwise return false.\r\n */\r\n P.isFinite = function () {\r\n return !!this.c;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n * otherwise return false.\r\n */\r\n P.isGreaterThan = P.gt = function (y, b) {\r\n return compare(this, new BigNumber(y, b)) > 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is greater than or equal to the value of\r\n * BigNumber(y, b), otherwise return false.\r\n */\r\n P.isGreaterThanOrEqualTo = P.gte = function (y, b) {\r\n return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;\r\n\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is an integer, otherwise return false.\r\n */\r\n P.isInteger = function () {\r\n return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n * otherwise return false.\r\n */\r\n P.isLessThan = P.lt = function (y, b) {\r\n return compare(this, new BigNumber(y, b)) < 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is less than or equal to the value of\r\n * BigNumber(y, b), otherwise return false.\r\n */\r\n P.isLessThanOrEqualTo = P.lte = function (y, b) {\r\n return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is NaN, otherwise return false.\r\n */\r\n P.isNaN = function () {\r\n return !this.s;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is negative, otherwise return false.\r\n */\r\n P.isNegative = function () {\r\n return this.s < 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is positive, otherwise return false.\r\n */\r\n P.isPositive = function () {\r\n return this.s > 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this BigNumber is 0 or -0, otherwise return false.\r\n */\r\n P.isZero = function () {\r\n return !!this.c && this.c[0] == 0;\r\n };\r\n\r\n\r\n /*\r\n * n - 0 = n\r\n * n - N = N\r\n * n - I = -I\r\n * 0 - n = -n\r\n * 0 - 0 = 0\r\n * 0 - N = N\r\n * 0 - I = -I\r\n * N - n = N\r\n * N - 0 = N\r\n * N - N = N\r\n * N - I = N\r\n * I - n = I\r\n * I - 0 = I\r\n * I - N = N\r\n * I - I = N\r\n *\r\n * Return a new BigNumber whose value is the value of this BigNumber minus the value of\r\n * BigNumber(y, b).\r\n */\r\n P.minus = function (y, b) {\r\n var i, j, t, xLTy,\r\n x = this,\r\n a = x.s;\r\n\r\n y = new BigNumber(y, b);\r\n b = y.s;\r\n\r\n // Either NaN?\r\n if (!a || !b) return new BigNumber(NaN);\r\n\r\n // Signs differ?\r\n if (a != b) {\r\n y.s = -b;\r\n return x.plus(y);\r\n }\r\n\r\n var xe = x.e / LOG_BASE,\r\n ye = y.e / LOG_BASE,\r\n xc = x.c,\r\n yc = y.c;\r\n\r\n if (!xe || !ye) {\r\n\r\n // Either Infinity?\r\n if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);\r\n\r\n // Either zero?\r\n if (!xc[0] || !yc[0]) {\r\n\r\n // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :\r\n\r\n // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\r\n ROUNDING_MODE == 3 ? -0 : 0);\r\n }\r\n }\r\n\r\n xe = bitFloor(xe);\r\n ye = bitFloor(ye);\r\n xc = xc.slice();\r\n\r\n // Determine which is the bigger number.\r\n if (a = xe - ye) {\r\n\r\n if (xLTy = a < 0) {\r\n a = -a;\r\n t = xc;\r\n } else {\r\n ye = xe;\r\n t = yc;\r\n }\r\n\r\n t.reverse();\r\n\r\n // Prepend zeros to equalise exponents.\r\n for (b = a; b--; t.push(0));\r\n t.reverse();\r\n } else {\r\n\r\n // Exponents equal. Check digit by digit.\r\n j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;\r\n\r\n for (a = b = 0; b < j; b++) {\r\n\r\n if (xc[b] != yc[b]) {\r\n xLTy = xc[b] < yc[b];\r\n break;\r\n }\r\n }\r\n }\r\n\r\n // x < y? Point xc to the array of the bigger number.\r\n if (xLTy) {\r\n t = xc;\r\n xc = yc;\r\n yc = t;\r\n y.s = -y.s;\r\n }\r\n\r\n b = (j = yc.length) - (i = xc.length);\r\n\r\n // Append zeros to xc if shorter.\r\n // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\r\n if (b > 0) for (; b--; xc[i++] = 0);\r\n b = BASE - 1;\r\n\r\n // Subtract yc from xc.\r\n for (; j > a;) {\r\n\r\n if (xc[--j] < yc[j]) {\r\n for (i = j; i && !xc[--i]; xc[i] = b);\r\n --xc[i];\r\n xc[j] += BASE;\r\n }\r\n\r\n xc[j] -= yc[j];\r\n }\r\n\r\n // Remove leading zeros and adjust exponent accordingly.\r\n for (; xc[0] == 0; xc.splice(0, 1), --ye);\r\n\r\n // Zero?\r\n if (!xc[0]) {\r\n\r\n // Following IEEE 754 (2008) 6.3,\r\n // n - n = +0 but n - n = -0 when rounding towards -Infinity.\r\n y.s = ROUNDING_MODE == 3 ? -1 : 1;\r\n y.c = [y.e = 0];\r\n return y;\r\n }\r\n\r\n // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\r\n // for finite x and y.\r\n return normalise(y, xc, ye);\r\n };\r\n\r\n\r\n /*\r\n * n % 0 = N\r\n * n % N = N\r\n * n % I = n\r\n * 0 % n = 0\r\n * -0 % n = -0\r\n * 0 % 0 = N\r\n * 0 % N = N\r\n * 0 % I = 0\r\n * N % n = N\r\n * N % 0 = N\r\n * N % N = N\r\n * N % I = N\r\n * I % n = N\r\n * I % 0 = N\r\n * I % N = N\r\n * I % I = N\r\n *\r\n * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\r\n * BigNumber(y, b). The result depends on the value of MODULO_MODE.\r\n */\r\n P.modulo = P.mod = function (y, b) {\r\n var q, s,\r\n x = this;\r\n\r\n y = new BigNumber(y, b);\r\n\r\n // Return NaN if x is Infinity or NaN, or y is NaN or zero.\r\n if (!x.c || !y.s || y.c && !y.c[0]) {\r\n return new BigNumber(NaN);\r\n\r\n // Return x if y is Infinity or x is zero.\r\n } else if (!y.c || x.c && !x.c[0]) {\r\n return new BigNumber(x);\r\n }\r\n\r\n if (MODULO_MODE == 9) {\r\n\r\n // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n // r = x - qy where 0 <= r < abs(y)\r\n s = y.s;\r\n y.s = 1;\r\n q = div(x, y, 0, 3);\r\n y.s = s;\r\n q.s *= s;\r\n } else {\r\n q = div(x, y, 0, MODULO_MODE);\r\n }\r\n\r\n y = x.minus(q.times(y));\r\n\r\n // To match JavaScript %, ensure sign of zero is sign of dividend.\r\n if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;\r\n\r\n return y;\r\n };\r\n\r\n\r\n /*\r\n * n * 0 = 0\r\n * n * N = N\r\n * n * I = I\r\n * 0 * n = 0\r\n * 0 * 0 = 0\r\n * 0 * N = N\r\n * 0 * I = N\r\n * N * n = N\r\n * N * 0 = N\r\n * N * N = N\r\n * N * I = N\r\n * I * n = I\r\n * I * 0 = N\r\n * I * N = N\r\n * I * I = I\r\n *\r\n * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value\r\n * of BigNumber(y, b).\r\n */\r\n P.multipliedBy = P.times = function (y, b) {\r\n var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,\r\n base, sqrtBase,\r\n x = this,\r\n xc = x.c,\r\n yc = (y = new BigNumber(y, b)).c;\r\n\r\n // Either NaN, ±Infinity or ±0?\r\n if (!xc || !yc || !xc[0] || !yc[0]) {\r\n\r\n // Return NaN if either is NaN, or one is 0 and the other is Infinity.\r\n if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {\r\n y.c = y.e = y.s = null;\r\n } else {\r\n y.s *= x.s;\r\n\r\n // Return ±Infinity if either is ±Infinity.\r\n if (!xc || !yc) {\r\n y.c = y.e = null;\r\n\r\n // Return ±0 if either is ±0.\r\n } else {\r\n y.c = [0];\r\n y.e = 0;\r\n }\r\n }\r\n\r\n return y;\r\n }\r\n\r\n e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);\r\n y.s *= x.s;\r\n xcL = xc.length;\r\n ycL = yc.length;\r\n\r\n // Ensure xc points to longer array and xcL to its length.\r\n if (xcL < ycL) {\r\n zc = xc;\r\n xc = yc;\r\n yc = zc;\r\n i = xcL;\r\n xcL = ycL;\r\n ycL = i;\r\n }\r\n\r\n // Initialise the result array with zeros.\r\n for (i = xcL + ycL, zc = []; i--; zc.push(0));\r\n\r\n base = BASE;\r\n sqrtBase = SQRT_BASE;\r\n\r\n for (i = ycL; --i >= 0;) {\r\n c = 0;\r\n ylo = yc[i] % sqrtBase;\r\n yhi = yc[i] / sqrtBase | 0;\r\n\r\n for (k = xcL, j = i + k; j > i;) {\r\n xlo = xc[--k] % sqrtBase;\r\n xhi = xc[k] / sqrtBase | 0;\r\n m = yhi * xlo + xhi * ylo;\r\n xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;\r\n c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;\r\n zc[j--] = xlo % base;\r\n }\r\n\r\n zc[j] = c;\r\n }\r\n\r\n if (c) {\r\n ++e;\r\n } else {\r\n zc.splice(0, 1);\r\n }\r\n\r\n return normalise(y, zc, e);\r\n };\r\n\r\n\r\n /*\r\n * Return a new BigNumber whose value is the value of this BigNumber negated,\r\n * i.e. multiplied by -1.\r\n */\r\n P.negated = function () {\r\n var x = new BigNumber(this);\r\n x.s = -x.s || null;\r\n return x;\r\n };\r\n\r\n\r\n /*\r\n * n + 0 = n\r\n * n + N = N\r\n * n + I = I\r\n * 0 + n = n\r\n * 0 + 0 = 0\r\n * 0 + N = N\r\n * 0 + I = I\r\n * N + n = N\r\n * N + 0 = N\r\n * N + N = N\r\n * N + I = N\r\n * I + n = I\r\n * I + 0 = I\r\n * I + N = N\r\n * I + I = I\r\n *\r\n * Return a new BigNumber whose value is the value of this BigNumber plus the value of\r\n * BigNumber(y, b).\r\n */\r\n P.plus = function (y, b) {\r\n var t,\r\n x = this,\r\n a = x.s;\r\n\r\n y = new BigNumber(y, b);\r\n b = y.s;\r\n\r\n // Either NaN?\r\n if (!a || !b) return new BigNumber(NaN);\r\n\r\n // Signs differ?\r\n if (a != b) {\r\n y.s = -b;\r\n return x.minus(y);\r\n }\r\n\r\n var xe = x.e / LOG_BASE,\r\n ye = y.e / LOG_BASE,\r\n xc = x.c,\r\n yc = y.c;\r\n\r\n if (!xe || !ye) {\r\n\r\n // Return ±Infinity if either ±Infinity.\r\n if (!xc || !yc) return new BigNumber(a / 0);\r\n\r\n // Either zero?\r\n // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);\r\n }\r\n\r\n xe = bitFloor(xe);\r\n ye = bitFloor(ye);\r\n xc = xc.slice();\r\n\r\n // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\r\n if (a = xe - ye) {\r\n if (a > 0) {\r\n ye = xe;\r\n t = yc;\r\n } else {\r\n a = -a;\r\n t = xc;\r\n }\r\n\r\n t.reverse();\r\n for (; a--; t.push(0));\r\n t.reverse();\r\n }\r\n\r\n a = xc.length;\r\n b = yc.length;\r\n\r\n // Point xc to the longer array, and b to the shorter length.\r\n if (a - b < 0) {\r\n t = yc;\r\n yc = xc;\r\n xc = t;\r\n b = a;\r\n }\r\n\r\n // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\r\n for (a = 0; b;) {\r\n a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;\r\n xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;\r\n }\r\n\r\n if (a) {\r\n xc = [a].concat(xc);\r\n ++ye;\r\n }\r\n\r\n // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n // ye = MAX_EXP + 1 possible\r\n return normalise(y, xc, ye);\r\n };\r\n\r\n\r\n /*\r\n * If sd is undefined or null or true or false, return the number of significant digits of\r\n * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n * If sd is true include integer-part trailing zeros in the count.\r\n *\r\n * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this\r\n * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or\r\n * ROUNDING_MODE if rm is omitted.\r\n *\r\n * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.\r\n * boolean: whether to count integer-part trailing zeros: true or false.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n */\r\n P.precision = P.sd = function (sd, rm) {\r\n var c, n, v,\r\n x = this;\r\n\r\n if (sd != null && sd !== !!sd) {\r\n intCheck(sd, 1, MAX);\r\n if (rm == null) rm = ROUNDING_MODE;\r\n else intCheck(rm, 0, 8);\r\n\r\n return round(new BigNumber(x), sd, rm);\r\n }\r\n\r\n if (!(c = x.c)) return null;\r\n v = c.length - 1;\r\n n = v * LOG_BASE + 1;\r\n\r\n if (v = c[v]) {\r\n\r\n // Subtract the number of trailing zeros of the last element.\r\n for (; v % 10 == 0; v /= 10, n--);\r\n\r\n // Add the number of digits of the first element.\r\n for (v = c[0]; v >= 10; v /= 10, n++);\r\n }\r\n\r\n if (sd && x.e + 1 > n) n = x.e + 1;\r\n\r\n return n;\r\n };\r\n\r\n\r\n /*\r\n * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\r\n * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\r\n *\r\n * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'\r\n */\r\n P.shiftedBy = function (k) {\r\n intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);\r\n return this.times('1e' + k);\r\n };\r\n\r\n\r\n /*\r\n * sqrt(-n) = N\r\n * sqrt(N) = N\r\n * sqrt(-I) = N\r\n * sqrt(I) = I\r\n * sqrt(0) = 0\r\n * sqrt(-0) = -0\r\n *\r\n * Return a new BigNumber whose value is the square root of the value of this BigNumber,\r\n * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n */\r\n P.squareRoot = P.sqrt = function () {\r\n var m, n, r, rep, t,\r\n x = this,\r\n c = x.c,\r\n s = x.s,\r\n e = x.e,\r\n dp = DECIMAL_PLACES + 4,\r\n half = new BigNumber('0.5');\r\n\r\n // Negative/NaN/Infinity/zero?\r\n if (s !== 1 || !c || !c[0]) {\r\n return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);\r\n }\r\n\r\n // Initial estimate.\r\n s = Math.sqrt(+valueOf(x));\r\n\r\n // Math.sqrt underflow/overflow?\r\n // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n if (s == 0 || s == 1 / 0) {\r\n n = coeffToString(c);\r\n if ((n.length + e) % 2 == 0) n += '0';\r\n s = Math.sqrt(+n);\r\n e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n if (s == 1 / 0) {\r\n n = '5e' + e;\r\n } else {\r\n n = s.toExponential();\r\n n = n.slice(0, n.indexOf('e') + 1) + e;\r\n }\r\n\r\n r = new BigNumber(n);\r\n } else {\r\n r = new BigNumber(s + '');\r\n }\r\n\r\n // Check for zero.\r\n // r could be zero if MIN_EXP is changed after the this value was created.\r\n // This would cause a division by zero (x/t) and hence Infinity below, which would cause\r\n // coeffToString to throw.\r\n if (r.c[0]) {\r\n e = r.e;\r\n s = e + dp;\r\n if (s < 3) s = 0;\r\n\r\n // Newton-Raphson iteration.\r\n for (; ;) {\r\n t = r;\r\n r = half.times(t.plus(div(x, t, dp, 1)));\r\n\r\n if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {\r\n\r\n // The exponent of r may here be one less than the final result exponent,\r\n // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\r\n // are indexed correctly.\r\n if (r.e < e) --s;\r\n n = n.slice(s - 3, s + 1);\r\n\r\n // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\r\n // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\r\n // iteration.\r\n if (n == '9999' || !rep && n == '4999') {\r\n\r\n // On the first iteration only, check to see if rounding up gives the\r\n // exact result as the nines may infinitely repeat.\r\n if (!rep) {\r\n round(t, t.e + DECIMAL_PLACES + 2, 0);\r\n\r\n if (t.times(t).eq(x)) {\r\n r = t;\r\n break;\r\n }\r\n }\r\n\r\n dp += 4;\r\n s += 4;\r\n rep = 1;\r\n } else {\r\n\r\n // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\r\n // result. If not, then there are further digits and m will be truthy.\r\n if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n // Truncate to the first rounding digit.\r\n round(r, r.e + DECIMAL_PLACES + 2, 1);\r\n m = !r.times(r).eq(x);\r\n }\r\n\r\n break;\r\n }\r\n }\r\n }\r\n }\r\n\r\n return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this BigNumber in exponential notation and\r\n * rounded using ROUNDING_MODE to dp fixed decimal places.\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n */\r\n P.toExponential = function (dp, rm) {\r\n if (dp != null) {\r\n intCheck(dp, 0, MAX);\r\n dp++;\r\n }\r\n return format(this, dp, rm, 1);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this BigNumber in fixed-point notation rounding\r\n * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n *\r\n * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\r\n * but e.g. (-0.00001).toFixed(0) is '-0'.\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n */\r\n P.toFixed = function (dp, rm) {\r\n if (dp != null) {\r\n intCheck(dp, 0, MAX);\r\n dp = dp + this.e + 1;\r\n }\r\n return format(this, dp, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this BigNumber in fixed-point notation rounded\r\n * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\r\n * of the format or FORMAT object (see BigNumber.set).\r\n *\r\n * The formatting object may contain some or all of the properties shown below.\r\n *\r\n * FORMAT = {\r\n * prefix: '',\r\n * groupSize: 3,\r\n * secondaryGroupSize: 0,\r\n * groupSeparator: ',',\r\n * decimalSeparator: '.',\r\n * fractionGroupSize: 0,\r\n * fractionGroupSeparator: '\\xA0', // non-breaking space\r\n * suffix: ''\r\n * };\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n * [format] {object} Formatting options. See FORMAT pbject above.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n * '[BigNumber Error] Argument not an object: {format}'\r\n */\r\n P.toFormat = function (dp, rm, format) {\r\n var str,\r\n x = this;\r\n\r\n if (format == null) {\r\n if (dp != null && rm && typeof rm == 'object') {\r\n format = rm;\r\n rm = null;\r\n } else if (dp && typeof dp == 'object') {\r\n format = dp;\r\n dp = rm = null;\r\n } else {\r\n format = FORMAT;\r\n }\r\n } else if (typeof format != 'object') {\r\n throw Error\r\n (bignumberError + 'Argument not an object: ' + format);\r\n }\r\n\r\n str = x.toFixed(dp, rm);\r\n\r\n if (x.c) {\r\n var i,\r\n arr = str.split('.'),\r\n g1 = +format.groupSize,\r\n g2 = +format.secondaryGroupSize,\r\n groupSeparator = format.groupSeparator || '',\r\n intPart = arr[0],\r\n fractionPart = arr[1],\r\n isNeg = x.s < 0,\r\n intDigits = isNeg ? intPart.slice(1) : intPart,\r\n len = intDigits.length;\r\n\r\n if (g2) {\r\n i = g1;\r\n g1 = g2;\r\n g2 = i;\r\n len -= i;\r\n }\r\n\r\n if (g1 > 0 && len > 0) {\r\n i = len % g1 || g1;\r\n intPart = intDigits.substr(0, i);\r\n for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);\r\n if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);\r\n if (isNeg) intPart = '-' + intPart;\r\n }\r\n\r\n str = fractionPart\r\n ? intPart + (format.decimalSeparator || '') + ((g2 = +format.fractionGroupSize)\r\n ? fractionPart.replace(new RegExp('\\\\d{' + g2 + '}\\\\B', 'g'),\r\n '$&' + (format.fractionGroupSeparator || ''))\r\n : fractionPart)\r\n : intPart;\r\n }\r\n\r\n return (format.prefix || '') + str + (format.suffix || '');\r\n };\r\n\r\n\r\n /*\r\n * Return an array of two BigNumbers representing the value of this BigNumber as a simple\r\n * fraction with an integer numerator and an integer denominator.\r\n * The denominator will be a positive non-zero value less than or equal to the specified\r\n * maximum denominator. If a maximum denominator is not specified, the denominator will be\r\n * the lowest value necessary to represent the number exactly.\r\n *\r\n * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.\r\n *\r\n * '[BigNumber Error] Argument {not an integer|out of range} : {md}'\r\n */\r\n P.toFraction = function (md) {\r\n var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s,\r\n x = this,\r\n xc = x.c;\r\n\r\n if (md != null) {\r\n n = new BigNumber(md);\r\n\r\n // Throw if md is less than one or is not an integer, unless it is Infinity.\r\n if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {\r\n throw Error\r\n (bignumberError + 'Argument ' +\r\n (n.isInteger() ? 'out of range: ' : 'not an integer: ') + valueOf(n));\r\n }\r\n }\r\n\r\n if (!xc) return new BigNumber(x);\r\n\r\n d = new BigNumber(ONE);\r\n n1 = d0 = new BigNumber(ONE);\r\n d1 = n0 = new BigNumber(ONE);\r\n s = coeffToString(xc);\r\n\r\n // Determine initial denominator.\r\n // d is a power of 10 and the minimum max denominator that specifies the value exactly.\r\n e = d.e = s.length - x.e - 1;\r\n d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];\r\n md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;\r\n\r\n exp = MAX_EXP;\r\n MAX_EXP = 1 / 0;\r\n n = new BigNumber(s);\r\n\r\n // n0 = d1 = 0\r\n n0.c[0] = 0;\r\n\r\n for (; ;) {\r\n q = div(n, d, 0, 1);\r\n d2 = d0.plus(q.times(d1));\r\n if (d2.comparedTo(md) == 1) break;\r\n d0 = d1;\r\n d1 = d2;\r\n n1 = n0.plus(q.times(d2 = n1));\r\n n0 = d2;\r\n d = n.minus(q.times(d2 = d));\r\n n = d2;\r\n }\r\n\r\n d2 = div(md.minus(d0), d1, 0, 1);\r\n n0 = n0.plus(d2.times(n1));\r\n d0 = d0.plus(d2.times(d1));\r\n n0.s = n1.s = x.s;\r\n e = e * 2;\r\n\r\n // Determine which fraction is closer to x, n0/d0 or n1/d1\r\n r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(\r\n div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];\r\n\r\n MAX_EXP = exp;\r\n\r\n return r;\r\n };\r\n\r\n\r\n /*\r\n * Return the value of this BigNumber converted to a number primitive.\r\n */\r\n P.toNumber = function () {\r\n return +valueOf(this);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this BigNumber rounded to sd significant digits\r\n * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\r\n * necessary to represent the integer part of the value in fixed-point notation, then use\r\n * exponential notation.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n */\r\n P.toPrecision = function (sd, rm) {\r\n if (sd != null) intCheck(sd, 1, MAX);\r\n return format(this, sd, rm, 2);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this BigNumber in base b, or base 10 if b is\r\n * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\r\n * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\r\n * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\r\n * TO_EXP_NEG, return exponential notation.\r\n *\r\n * [b] {number} Integer, 2 to ALPHABET.length inclusive.\r\n *\r\n * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n */\r\n P.toString = function (b) {\r\n var str,\r\n n = this,\r\n s = n.s,\r\n e = n.e;\r\n\r\n // Infinity or NaN?\r\n if (e === null) {\r\n if (s) {\r\n str = 'Infinity';\r\n if (s < 0) str = '-' + str;\r\n } else {\r\n str = 'NaN';\r\n }\r\n } else {\r\n if (b == null) {\r\n str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n ? toExponential(coeffToString(n.c), e)\r\n : toFixedPoint(coeffToString(n.c), e, '0');\r\n } else if (b === 10 && alphabetHasNormalDecimalDigits) {\r\n n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);\r\n str = toFixedPoint(coeffToString(n.c), n.e, '0');\r\n } else {\r\n intCheck(b, 2, ALPHABET.length, 'Base');\r\n str = convertBase(toFixedPoint(coeffToString(n.c), e, '0'), 10, b, s, true);\r\n }\r\n\r\n if (s < 0 && n.c[0]) str = '-' + str;\r\n }\r\n\r\n return str;\r\n };\r\n\r\n\r\n /*\r\n * Return as toString, but do not accept a base argument, and include the minus sign for\r\n * negative zero.\r\n */\r\n P.valueOf = P.toJSON = function () {\r\n return valueOf(this);\r\n };\r\n\r\n\r\n P._isBigNumber = true;\r\n\r\n 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","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst crypto = require(\"./crypto\");\nconst bs58check = require('bs58check');\nconst ecc = require('tiny-secp256k1');\nconst typeforce = require('typeforce');\nconst wif = require('wif');\nconst UINT256_TYPE = typeforce.BufferN(32);\nconst NETWORK_TYPE = typeforce.compile({\n wif: typeforce.UInt8,\n bip32: {\n public: typeforce.UInt32,\n private: typeforce.UInt32,\n },\n});\nconst BITCOIN = {\n messagePrefix: '\\x18Bitcoin Signed Message:\\n',\n bech32: 'bc',\n bip32: {\n public: 0x0488b21e,\n private: 0x0488ade4,\n },\n pubKeyHash: 0x00,\n scriptHash: 0x05,\n wif: 0x80,\n};\nconst HIGHEST_BIT = 0x80000000;\nconst UINT31_MAX = Math.pow(2, 31) - 1;\nfunction BIP32Path(value) {\n return (typeforce.String(value) && value.match(/^(m\\/)?(\\d+'?\\/)*\\d+'?$/) !== null);\n}\nfunction UInt31(value) {\n return typeforce.UInt32(value) && value <= UINT31_MAX;\n}\nclass BIP32 {\n constructor(__D, __Q, chainCode, network, __DEPTH = 0, __INDEX = 0, __PARENT_FINGERPRINT = 0x00000000) {\n this.__D = __D;\n this.__Q = __Q;\n this.chainCode = chainCode;\n this.network = network;\n this.__DEPTH = __DEPTH;\n this.__INDEX = __INDEX;\n this.__PARENT_FINGERPRINT = __PARENT_FINGERPRINT;\n typeforce(NETWORK_TYPE, network);\n this.lowR = false;\n }\n get depth() {\n return this.__DEPTH;\n }\n get index() {\n return this.__INDEX;\n }\n get parentFingerprint() {\n return this.__PARENT_FINGERPRINT;\n }\n get publicKey() {\n if (this.__Q === undefined)\n this.__Q = ecc.pointFromScalar(this.__D, true);\n return this.__Q;\n }\n get privateKey() {\n return this.__D;\n }\n get identifier() {\n return crypto.hash160(this.publicKey);\n }\n get fingerprint() {\n return this.identifier.slice(0, 4);\n }\n get compressed() {\n return true;\n }\n // Private === not neutered\n // Public === neutered\n isNeutered() {\n return this.__D === undefined;\n }\n neutered() {\n return fromPublicKeyLocal(this.publicKey, this.chainCode, this.network, this.depth, this.index, this.parentFingerprint);\n }\n toBase58() {\n const network = this.network;\n const version = !this.isNeutered()\n ? network.bip32.private\n : network.bip32.public;\n const buffer = Buffer.allocUnsafe(78);\n // 4 bytes: version bytes\n buffer.writeUInt32BE(version, 0);\n // 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ....\n buffer.writeUInt8(this.depth, 4);\n // 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)\n buffer.writeUInt32BE(this.parentFingerprint, 5);\n // 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key being serialized.\n // This is encoded in big endian. (0x00000000 if master key)\n buffer.writeUInt32BE(this.index, 9);\n // 32 bytes: the chain code\n this.chainCode.copy(buffer, 13);\n // 33 bytes: the public key or private key data\n if (!this.isNeutered()) {\n // 0x00 + k for private keys\n buffer.writeUInt8(0, 45);\n this.privateKey.copy(buffer, 46);\n // 33 bytes: the public key\n }\n else {\n // X9.62 encoding for public keys\n this.publicKey.copy(buffer, 45);\n }\n return bs58check.encode(buffer);\n }\n toWIF() {\n if (!this.privateKey)\n throw new TypeError('Missing private key');\n return wif.encode(this.network.wif, this.privateKey, true);\n }\n // https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#child-key-derivation-ckd-functions\n derive(index) {\n typeforce(typeforce.UInt32, index);\n const isHardened = index >= HIGHEST_BIT;\n const data = Buffer.allocUnsafe(37);\n // Hardened child\n if (isHardened) {\n if (this.isNeutered())\n throw new TypeError('Missing private key for hardened child key');\n // data = 0x00 || ser256(kpar) || ser32(index)\n data[0] = 0x00;\n this.privateKey.copy(data, 1);\n data.writeUInt32BE(index, 33);\n // Normal child\n }\n else {\n // data = serP(point(kpar)) || ser32(index)\n // = serP(Kpar) || ser32(index)\n this.publicKey.copy(data, 0);\n data.writeUInt32BE(index, 33);\n }\n const I = crypto.hmacSHA512(this.chainCode, data);\n const IL = I.slice(0, 32);\n const IR = I.slice(32);\n // if parse256(IL) >= n, proceed with the next value for i\n if (!ecc.isPrivate(IL))\n return this.derive(index + 1);\n // Private parent key -> private child key\n let hd;\n if (!this.isNeutered()) {\n // ki = parse256(IL) + kpar (mod n)\n const ki = ecc.privateAdd(this.privateKey, IL);\n // In case ki == 0, proceed with the next value for i\n if (ki == null)\n return this.derive(index + 1);\n hd = fromPrivateKeyLocal(ki, IR, this.network, this.depth + 1, index, this.fingerprint.readUInt32BE(0));\n // Public parent key -> public child key\n }\n else {\n // Ki = point(parse256(IL)) + Kpar\n // = G*IL + Kpar\n const Ki = ecc.pointAddScalar(this.publicKey, IL, true);\n // In case Ki is the point at infinity, proceed with the next value for i\n if (Ki === null)\n return this.derive(index + 1);\n hd = fromPublicKeyLocal(Ki, IR, this.network, this.depth + 1, index, this.fingerprint.readUInt32BE(0));\n }\n return hd;\n }\n deriveHardened(index) {\n typeforce(UInt31, index);\n // Only derives hardened private keys by default\n return this.derive(index + HIGHEST_BIT);\n }\n derivePath(path) {\n typeforce(BIP32Path, path);\n let splitPath = path.split('/');\n if (splitPath[0] === 'm') {\n if (this.parentFingerprint)\n throw new TypeError('Expected master, got child');\n splitPath = splitPath.slice(1);\n }\n return splitPath.reduce((prevHd, indexStr) => {\n let index;\n if (indexStr.slice(-1) === `'`) {\n index = parseInt(indexStr.slice(0, -1), 10);\n return prevHd.deriveHardened(index);\n }\n else {\n index = parseInt(indexStr, 10);\n return prevHd.derive(index);\n }\n }, this);\n }\n sign(hash, lowR) {\n if (!this.privateKey)\n throw new Error('Missing private key');\n if (lowR === undefined)\n lowR = this.lowR;\n if (lowR === false) {\n return ecc.sign(hash, this.privateKey);\n }\n else {\n let sig = ecc.sign(hash, this.privateKey);\n const extraData = Buffer.alloc(32, 0);\n let counter = 0;\n // if first try is lowR, skip the loop\n // for second try and on, add extra entropy counting up\n while (sig[0] > 0x7f) {\n counter++;\n extraData.writeUIntLE(counter, 0, 6);\n sig = ecc.signWithEntropy(hash, this.privateKey, extraData);\n }\n return sig;\n }\n }\n verify(hash, signature) {\n return ecc.verify(hash, this.publicKey, signature);\n }\n}\nfunction fromBase58(inString, network) {\n const buffer = bs58check.decode(inString);\n if (buffer.length !== 78)\n throw new TypeError('Invalid buffer length');\n network = network || BITCOIN;\n // 4 bytes: version bytes\n const version = buffer.readUInt32BE(0);\n if (version !== network.bip32.private && version !== network.bip32.public)\n throw new TypeError('Invalid network version');\n // 1 byte: depth: 0x00 for master nodes, 0x01 for level-1 descendants, ...\n const depth = buffer[4];\n // 4 bytes: the fingerprint of the parent's key (0x00000000 if master key)\n const parentFingerprint = buffer.readUInt32BE(5);\n if (depth === 0) {\n if (parentFingerprint !== 0x00000000)\n throw new TypeError('Invalid parent fingerprint');\n }\n // 4 bytes: child number. This is the number i in xi = xpar/i, with xi the key being serialized.\n // This is encoded in MSB order. (0x00000000 if master key)\n const index = buffer.readUInt32BE(9);\n if (depth === 0 && index !== 0)\n throw new TypeError('Invalid index');\n // 32 bytes: the chain code\n const chainCode = buffer.slice(13, 45);\n let hd;\n // 33 bytes: private key data (0x00 + k)\n if (version === network.bip32.private) {\n if (buffer.readUInt8(45) !== 0x00)\n throw new TypeError('Invalid private key');\n const k = buffer.slice(46, 78);\n hd = fromPrivateKeyLocal(k, chainCode, network, depth, index, parentFingerprint);\n // 33 bytes: public key data (0x02 + X or 0x03 + X)\n }\n else {\n const X = buffer.slice(45, 78);\n hd = fromPublicKeyLocal(X, chainCode, network, depth, index, parentFingerprint);\n }\n return hd;\n}\nexports.fromBase58 = fromBase58;\nfunction fromPrivateKey(privateKey, chainCode, network) {\n return fromPrivateKeyLocal(privateKey, chainCode, network);\n}\nexports.fromPrivateKey = fromPrivateKey;\nfunction fromPrivateKeyLocal(privateKey, chainCode, network, depth, index, parentFingerprint) {\n typeforce({\n privateKey: UINT256_TYPE,\n chainCode: UINT256_TYPE,\n }, { privateKey, chainCode });\n network = network || BITCOIN;\n if (!ecc.isPrivate(privateKey))\n throw new TypeError('Private key not in range [1, n)');\n return new BIP32(privateKey, undefined, chainCode, network, depth, index, parentFingerprint);\n}\nfunction fromPublicKey(publicKey, chainCode, network) {\n return fromPublicKeyLocal(publicKey, chainCode, network);\n}\nexports.fromPublicKey = fromPublicKey;\nfunction fromPublicKeyLocal(publicKey, chainCode, network, depth, index, parentFingerprint) {\n typeforce({\n publicKey: typeforce.BufferN(33),\n chainCode: UINT256_TYPE,\n }, { publicKey, chainCode });\n network = network || BITCOIN;\n // verify the X coordinate is a point on the curve\n if (!ecc.isPoint(publicKey))\n throw new TypeError('Point is not on the curve');\n return new BIP32(undefined, publicKey, chainCode, network, depth, index, parentFingerprint);\n}\nfunction fromSeed(seed, network) {\n typeforce(typeforce.Buffer, seed);\n if (seed.length < 16)\n throw new TypeError('Seed should be at least 128 bits');\n if (seed.length > 64)\n throw new TypeError('Seed should be at most 512 bits');\n network = network || BITCOIN;\n const I = crypto.hmacSHA512(Buffer.from('Bitcoin seed', 'utf8'), seed);\n const IL = I.slice(0, 32);\n const IR = I.slice(32);\n return fromPrivateKey(IL, IR, network);\n}\nexports.fromSeed = fromSeed;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst createHash = require('create-hash');\nconst createHmac = require('create-hmac');\nfunction hash160(buffer) {\n const sha256Hash = createHash('sha256')\n .update(buffer)\n .digest();\n try {\n return createHash('rmd160')\n .update(sha256Hash)\n .digest();\n }\n catch (err) {\n return createHash('ripemd160')\n .update(sha256Hash)\n .digest();\n }\n}\nexports.hash160 = hash160;\nfunction hmacSHA512(key, data) {\n return createHmac('sha512', key)\n .update(data)\n .digest();\n}\nexports.hmacSHA512 = hmacSHA512;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar bip32_1 = require(\"./bip32\");\nexports.fromSeed = bip32_1.fromSeed;\nexports.fromBase58 = bip32_1.fromBase58;\nexports.fromPublicKey = bip32_1.fromPublicKey;\nexports.fromPrivateKey = bip32_1.fromPrivateKey;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n// browserify by default only pulls in files that are hard coded in requires\n// In order of last to first in this file, the default wordlist will be chosen\n// based on what is present. (Bundles may remove wordlists they don't need)\nconst wordlists = {};\nexports.wordlists = wordlists;\nlet _default;\nexports._default = _default;\ntry {\n exports._default = _default = require('./wordlists/czech.json');\n wordlists.czech = _default;\n}\ncatch (err) { }\ntry {\n exports._default = _default = require('./wordlists/chinese_simplified.json');\n wordlists.chinese_simplified = _default;\n}\ncatch (err) { }\ntry {\n exports._default = _default = require('./wordlists/chinese_traditional.json');\n wordlists.chinese_traditional = _default;\n}\ncatch (err) { }\ntry {\n exports._default = _default = require('./wordlists/korean.json');\n wordlists.korean = _default;\n}\ncatch (err) { }\ntry {\n exports._default = _default = require('./wordlists/french.json');\n wordlists.french = _default;\n}\ncatch (err) { }\ntry {\n exports._default = _default = require('./wordlists/italian.json');\n wordlists.italian = _default;\n}\ncatch (err) { }\ntry {\n exports._default = _default = require('./wordlists/spanish.json');\n wordlists.spanish = _default;\n}\ncatch (err) { }\ntry {\n exports._default = _default = require('./wordlists/japanese.json');\n wordlists.japanese = _default;\n wordlists.JA = _default;\n}\ncatch (err) { }\ntry {\n exports._default = _default = require('./wordlists/portuguese.json');\n wordlists.portuguese = _default;\n}\ncatch (err) { }\ntry {\n exports._default = _default = require('./wordlists/english.json');\n wordlists.english = _default;\n wordlists.EN = _default;\n}\ncatch (err) { }\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst createHash = require(\"create-hash\");\nconst pbkdf2_1 = require(\"pbkdf2\");\nconst randomBytes = require(\"randombytes\");\nconst _wordlists_1 = require(\"./_wordlists\");\nlet DEFAULT_WORDLIST = _wordlists_1._default;\nconst INVALID_MNEMONIC = 'Invalid mnemonic';\nconst INVALID_ENTROPY = 'Invalid entropy';\nconst INVALID_CHECKSUM = 'Invalid mnemonic checksum';\nconst WORDLIST_REQUIRED = 'A wordlist is required but a default could not be found.\\n' +\n 'Please pass a 2048 word array explicitly.';\nfunction pbkdf2Promise(password, saltMixin, iterations, keylen, digest) {\n return Promise.resolve().then(() => new Promise((resolve, reject) => {\n const callback = (err, derivedKey) => {\n if (err) {\n return reject(err);\n }\n else {\n return resolve(derivedKey);\n }\n };\n pbkdf2_1.pbkdf2(password, saltMixin, iterations, keylen, digest, callback);\n }));\n}\nfunction normalize(str) {\n return (str || '').normalize('NFKD');\n}\nfunction lpad(str, padString, length) {\n while (str.length < length) {\n str = padString + str;\n }\n return str;\n}\nfunction binaryToByte(bin) {\n return parseInt(bin, 2);\n}\nfunction bytesToBinary(bytes) {\n return bytes.map((x) => lpad(x.toString(2), '0', 8)).join('');\n}\nfunction deriveChecksumBits(entropyBuffer) {\n const ENT = entropyBuffer.length * 8;\n const CS = ENT / 32;\n const hash = createHash('sha256')\n .update(entropyBuffer)\n .digest();\n return bytesToBinary(Array.from(hash)).slice(0, CS);\n}\nfunction salt(password) {\n return 'mnemonic' + (password || '');\n}\nfunction mnemonicToSeedSync(mnemonic, password) {\n const mnemonicBuffer = Buffer.from(normalize(mnemonic), 'utf8');\n const saltBuffer = Buffer.from(salt(normalize(password)), 'utf8');\n return pbkdf2_1.pbkdf2Sync(mnemonicBuffer, saltBuffer, 2048, 64, 'sha512');\n}\nexports.mnemonicToSeedSync = mnemonicToSeedSync;\nfunction mnemonicToSeed(mnemonic, password) {\n return Promise.resolve().then(() => {\n const mnemonicBuffer = Buffer.from(normalize(mnemonic), 'utf8');\n const saltBuffer = Buffer.from(salt(normalize(password)), 'utf8');\n return pbkdf2Promise(mnemonicBuffer, saltBuffer, 2048, 64, 'sha512');\n });\n}\nexports.mnemonicToSeed = mnemonicToSeed;\nfunction mnemonicToEntropy(mnemonic, wordlist) {\n wordlist = wordlist || DEFAULT_WORDLIST;\n if (!wordlist) {\n throw new Error(WORDLIST_REQUIRED);\n }\n const words = normalize(mnemonic).split(' ');\n if (words.length % 3 !== 0) {\n throw new Error(INVALID_MNEMONIC);\n }\n // convert word indices to 11 bit binary strings\n const bits = words\n .map((word) => {\n const index = wordlist.indexOf(word);\n if (index === -1) {\n throw new Error(INVALID_MNEMONIC);\n }\n return lpad(index.toString(2), '0', 11);\n })\n .join('');\n // split the binary string into ENT/CS\n const dividerIndex = Math.floor(bits.length / 33) * 32;\n const entropyBits = bits.slice(0, dividerIndex);\n const checksumBits = bits.slice(dividerIndex);\n // calculate the checksum and compare\n const entropyBytes = entropyBits.match(/(.{1,8})/g).map(binaryToByte);\n if (entropyBytes.length < 16) {\n throw new Error(INVALID_ENTROPY);\n }\n if (entropyBytes.length > 32) {\n throw new Error(INVALID_ENTROPY);\n }\n if (entropyBytes.length % 4 !== 0) {\n throw new Error(INVALID_ENTROPY);\n }\n const entropy = Buffer.from(entropyBytes);\n const newChecksum = deriveChecksumBits(entropy);\n if (newChecksum !== checksumBits) {\n throw new Error(INVALID_CHECKSUM);\n }\n return entropy.toString('hex');\n}\nexports.mnemonicToEntropy = mnemonicToEntropy;\nfunction entropyToMnemonic(entropy, wordlist) {\n if (!Buffer.isBuffer(entropy)) {\n entropy = Buffer.from(entropy, 'hex');\n }\n wordlist = wordlist || DEFAULT_WORDLIST;\n if (!wordlist) {\n throw new Error(WORDLIST_REQUIRED);\n }\n // 128 <= ENT <= 256\n if (entropy.length < 16) {\n throw new TypeError(INVALID_ENTROPY);\n }\n if (entropy.length > 32) {\n throw new TypeError(INVALID_ENTROPY);\n }\n if (entropy.length % 4 !== 0) {\n throw new TypeError(INVALID_ENTROPY);\n }\n const entropyBits = bytesToBinary(Array.from(entropy));\n const checksumBits = deriveChecksumBits(entropy);\n const bits = entropyBits + checksumBits;\n const chunks = bits.match(/(.{1,11})/g);\n const words = chunks.map((binary) => {\n const index = binaryToByte(binary);\n return wordlist[index];\n });\n return wordlist[0] === '\\u3042\\u3044\\u3053\\u304f\\u3057\\u3093' // Japanese wordlist\n ? words.join('\\u3000')\n : words.join(' ');\n}\nexports.entropyToMnemonic = entropyToMnemonic;\nfunction generateMnemonic(strength, rng, wordlist) {\n strength = strength || 128;\n if (strength % 32 !== 0) {\n throw new TypeError(INVALID_ENTROPY);\n }\n rng = rng || randomBytes;\n return entropyToMnemonic(rng(strength / 8), wordlist);\n}\nexports.generateMnemonic = generateMnemonic;\nfunction validateMnemonic(mnemonic, wordlist) {\n try {\n mnemonicToEntropy(mnemonic, wordlist);\n }\n catch (e) {\n return false;\n }\n return true;\n}\nexports.validateMnemonic = validateMnemonic;\nfunction setDefaultWordlist(language) {\n const result = _wordlists_1.wordlists[language];\n if (result) {\n DEFAULT_WORDLIST = result;\n }\n else {\n throw new Error('Could not find wordlist for language \"' + language + '\"');\n }\n}\nexports.setDefaultWordlist = setDefaultWordlist;\nfunction getDefaultWordlist() {\n if (!DEFAULT_WORDLIST) {\n throw new Error('No Default Wordlist set');\n }\n return Object.keys(_wordlists_1.wordlists).filter((lang) => {\n if (lang === 'JA' || lang === 'EN') {\n return false;\n }\n return _wordlists_1.wordlists[lang].every((word, index) => word === DEFAULT_WORDLIST[index]);\n })[0];\n}\nexports.getDefaultWordlist = getDefaultWordlist;\nvar _wordlists_2 = require(\"./_wordlists\");\nexports.wordlists = _wordlists_2.wordlists;\n","(function (module, exports) {\n 'use strict';\n\n // Utils\n function assert (val, msg) {\n if (!val) throw new Error(msg || 'Assertion failed');\n }\n\n // Could use `inherits` module, but don't want to move from single file\n // architecture yet.\n function inherits (ctor, superCtor) {\n ctor.super_ = superCtor;\n var TempCtor = function () {};\n TempCtor.prototype = superCtor.prototype;\n ctor.prototype = new TempCtor();\n ctor.prototype.constructor = ctor;\n }\n\n // BN\n\n function BN (number, base, endian) {\n if (BN.isBN(number)) {\n return number;\n }\n\n this.negative = 0;\n this.words = null;\n this.length = 0;\n\n // Reduction context\n this.red = null;\n\n if (number !== null) {\n if (base === 'le' || base === 'be') {\n endian = base;\n base = 10;\n }\n\n this._init(number || 0, base || 10, endian || 'be');\n }\n }\n if (typeof module === 'object') {\n module.exports = BN;\n } else {\n exports.BN = BN;\n }\n\n BN.BN = BN;\n BN.wordSize = 26;\n\n var Buffer;\n try {\n if (typeof window !== 'undefined' && typeof window.Buffer !== 'undefined') {\n Buffer = window.Buffer;\n } else {\n Buffer = require('buffer').Buffer;\n }\n } catch (e) {\n }\n\n BN.isBN = function isBN (num) {\n if (num instanceof BN) {\n return true;\n }\n\n return num !== null && typeof num === 'object' &&\n num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);\n };\n\n BN.max = function max (left, right) {\n if (left.cmp(right) > 0) return left;\n return right;\n };\n\n BN.min = function min (left, right) {\n if (left.cmp(right) < 0) return left;\n return right;\n };\n\n BN.prototype._init = function init (number, base, endian) {\n if (typeof number === 'number') {\n return this._initNumber(number, base, endian);\n }\n\n if (typeof number === 'object') {\n return this._initArray(number, base, endian);\n }\n\n if (base === 'hex') {\n base = 16;\n }\n assert(base === (base | 0) && base >= 2 && base <= 36);\n\n number = number.toString().replace(/\\s+/g, '');\n var start = 0;\n if (number[0] === '-') {\n start++;\n this.negative = 1;\n }\n\n if (start < number.length) {\n if (base === 16) {\n this._parseHex(number, start, endian);\n } else {\n this._parseBase(number, base, start);\n if (endian === 'le') {\n this._initArray(this.toArray(), base, endian);\n }\n }\n }\n };\n\n BN.prototype._initNumber = function _initNumber (number, base, endian) {\n if (number < 0) {\n this.negative = 1;\n number = -number;\n }\n if (number < 0x4000000) {\n this.words = [number & 0x3ffffff];\n this.length = 1;\n } else if (number < 0x10000000000000) {\n this.words = [\n number & 0x3ffffff,\n (number / 0x4000000) & 0x3ffffff\n ];\n this.length = 2;\n } else {\n assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)\n this.words = [\n number & 0x3ffffff,\n (number / 0x4000000) & 0x3ffffff,\n 1\n ];\n this.length = 3;\n }\n\n if (endian !== 'le') return;\n\n // Reverse the bytes\n this._initArray(this.toArray(), base, endian);\n };\n\n BN.prototype._initArray = function _initArray (number, base, endian) {\n // Perhaps a Uint8Array\n assert(typeof number.length === 'number');\n if (number.length <= 0) {\n this.words = [0];\n this.length = 1;\n return this;\n }\n\n this.length = Math.ceil(number.length / 3);\n this.words = new Array(this.length);\n for (var i = 0; i < this.length; i++) {\n this.words[i] = 0;\n }\n\n var j, w;\n var off = 0;\n if (endian === 'be') {\n for (i = number.length - 1, j = 0; i >= 0; i -= 3) {\n w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);\n this.words[j] |= (w << off) & 0x3ffffff;\n this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;\n off += 24;\n if (off >= 26) {\n off -= 26;\n j++;\n }\n }\n } else if (endian === 'le') {\n for (i = 0, j = 0; i < number.length; i += 3) {\n w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);\n this.words[j] |= (w << off) & 0x3ffffff;\n this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;\n off += 24;\n if (off >= 26) {\n off -= 26;\n j++;\n }\n }\n }\n return this._strip();\n };\n\n function parseHex4Bits (string, index) {\n var c = string.charCodeAt(index);\n // '0' - '9'\n if (c >= 48 && c <= 57) {\n return c - 48;\n // 'A' - 'F'\n } else if (c >= 65 && c <= 70) {\n return c - 55;\n // 'a' - 'f'\n } else if (c >= 97 && c <= 102) {\n return c - 87;\n } else {\n assert(false, 'Invalid character in ' + string);\n }\n }\n\n function parseHexByte (string, lowerBound, index) {\n var r = parseHex4Bits(string, index);\n if (index - 1 >= lowerBound) {\n r |= parseHex4Bits(string, index - 1) << 4;\n }\n return r;\n }\n\n BN.prototype._parseHex = function _parseHex (number, start, endian) {\n // Create possibly bigger array to ensure that it fits the number\n this.length = Math.ceil((number.length - start) / 6);\n this.words = new Array(this.length);\n for (var i = 0; i < this.length; i++) {\n this.words[i] = 0;\n }\n\n // 24-bits chunks\n var off = 0;\n var j = 0;\n\n var w;\n if (endian === 'be') {\n for (i = number.length - 1; i >= start; i -= 2) {\n w = parseHexByte(number, start, i) << off;\n this.words[j] |= w & 0x3ffffff;\n if (off >= 18) {\n off -= 18;\n j += 1;\n this.words[j] |= w >>> 26;\n } else {\n off += 8;\n }\n }\n } else {\n var parseLength = number.length - start;\n for (i = parseLength % 2 === 0 ? start + 1 : start; i < number.length; i += 2) {\n w = parseHexByte(number, start, i) << off;\n this.words[j] |= w & 0x3ffffff;\n if (off >= 18) {\n off -= 18;\n j += 1;\n this.words[j] |= w >>> 26;\n } else {\n off += 8;\n }\n }\n }\n\n this._strip();\n };\n\n function parseBase (str, start, end, mul) {\n var r = 0;\n var b = 0;\n var len = Math.min(str.length, end);\n for (var i = start; i < len; i++) {\n var c = str.charCodeAt(i) - 48;\n\n r *= mul;\n\n // 'a'\n if (c >= 49) {\n b = c - 49 + 0xa;\n\n // 'A'\n } else if (c >= 17) {\n b = c - 17 + 0xa;\n\n // '0' - '9'\n } else {\n b = c;\n }\n assert(c >= 0 && b < mul, 'Invalid character');\n r += b;\n }\n return r;\n }\n\n BN.prototype._parseBase = function _parseBase (number, base, start) {\n // Initialize as zero\n this.words = [0];\n this.length = 1;\n\n // Find length of limb in base\n for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {\n limbLen++;\n }\n limbLen--;\n limbPow = (limbPow / base) | 0;\n\n var total = number.length - start;\n var mod = total % limbLen;\n var end = Math.min(total, total - mod) + start;\n\n var word = 0;\n for (var i = start; i < end; i += limbLen) {\n word = parseBase(number, i, i + limbLen, base);\n\n this.imuln(limbPow);\n if (this.words[0] + word < 0x4000000) {\n this.words[0] += word;\n } else {\n this._iaddn(word);\n }\n }\n\n if (mod !== 0) {\n var pow = 1;\n word = parseBase(number, i, number.length, base);\n\n for (i = 0; i < mod; i++) {\n pow *= base;\n }\n\n this.imuln(pow);\n if (this.words[0] + word < 0x4000000) {\n this.words[0] += word;\n } else {\n this._iaddn(word);\n }\n }\n\n this._strip();\n };\n\n BN.prototype.copy = function copy (dest) {\n dest.words = new Array(this.length);\n for (var i = 0; i < this.length; i++) {\n dest.words[i] = this.words[i];\n }\n dest.length = this.length;\n dest.negative = this.negative;\n dest.red = this.red;\n };\n\n function move (dest, src) {\n dest.words = src.words;\n dest.length = src.length;\n dest.negative = src.negative;\n dest.red = src.red;\n }\n\n BN.prototype._move = function _move (dest) {\n move(dest, this);\n };\n\n BN.prototype.clone = function clone () {\n var r = new BN(null);\n this.copy(r);\n return r;\n };\n\n BN.prototype._expand = function _expand (size) {\n while (this.length < size) {\n this.words[this.length++] = 0;\n }\n return this;\n };\n\n // Remove leading `0` from `this`\n BN.prototype._strip = function strip () {\n while (this.length > 1 && this.words[this.length - 1] === 0) {\n this.length--;\n }\n return this._normSign();\n };\n\n BN.prototype._normSign = function _normSign () {\n // -0 = 0\n if (this.length === 1 && this.words[0] === 0) {\n this.negative = 0;\n }\n return this;\n };\n\n // Check Symbol.for because not everywhere where Symbol defined\n // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol#Browser_compatibility\n if (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function') {\n try {\n BN.prototype[Symbol.for('nodejs.util.inspect.custom')] = inspect;\n } catch (e) {\n BN.prototype.inspect = inspect;\n }\n } else {\n BN.prototype.inspect = inspect;\n }\n\n function inspect () {\n return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';\n }\n\n /*\n\n var zeros = [];\n var groupSizes = [];\n var groupBases = [];\n\n var s = '';\n var i = -1;\n while (++i < BN.wordSize) {\n zeros[i] = s;\n s += '0';\n }\n groupSizes[0] = 0;\n groupSizes[1] = 0;\n groupBases[0] = 0;\n groupBases[1] = 0;\n var base = 2 - 1;\n while (++base < 36 + 1) {\n var groupSize = 0;\n var groupBase = 1;\n while (groupBase < (1 << BN.wordSize) / base) {\n groupBase *= base;\n groupSize += 1;\n }\n groupSizes[base] = groupSize;\n groupBases[base] = groupBase;\n }\n\n */\n\n var zeros = [\n '',\n '0',\n '00',\n '000',\n '0000',\n '00000',\n '000000',\n '0000000',\n '00000000',\n '000000000',\n '0000000000',\n '00000000000',\n '000000000000',\n '0000000000000',\n '00000000000000',\n '000000000000000',\n '0000000000000000',\n '00000000000000000',\n '000000000000000000',\n '0000000000000000000',\n '00000000000000000000',\n '000000000000000000000',\n '0000000000000000000000',\n '00000000000000000000000',\n '000000000000000000000000',\n '0000000000000000000000000'\n ];\n\n var groupSizes = [\n 0, 0,\n 25, 16, 12, 11, 10, 9, 8,\n 8, 7, 7, 7, 7, 6, 6,\n 6, 6, 6, 6, 6, 5, 5,\n 5, 5, 5, 5, 5, 5, 5,\n 5, 5, 5, 5, 5, 5, 5\n ];\n\n var groupBases = [\n 0, 0,\n 33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,\n 43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,\n 16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,\n 6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,\n 24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176\n ];\n\n BN.prototype.toString = function toString (base, padding) {\n base = base || 10;\n padding = padding | 0 || 1;\n\n var out;\n if (base === 16 || base === 'hex') {\n out = '';\n var off = 0;\n var carry = 0;\n for (var i = 0; i < this.length; i++) {\n var w = this.words[i];\n var word = (((w << off) | carry) & 0xffffff).toString(16);\n carry = (w >>> (24 - off)) & 0xffffff;\n off += 2;\n if (off >= 26) {\n off -= 26;\n i--;\n }\n if (carry !== 0 || i !== this.length - 1) {\n out = zeros[6 - word.length] + word + out;\n } else {\n out = word + out;\n }\n }\n if (carry !== 0) {\n out = carry.toString(16) + out;\n }\n while (out.length % padding !== 0) {\n out = '0' + out;\n }\n if (this.negative !== 0) {\n out = '-' + out;\n }\n return out;\n }\n\n if (base === (base | 0) && base >= 2 && base <= 36) {\n // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));\n var groupSize = groupSizes[base];\n // var groupBase = Math.pow(base, groupSize);\n var groupBase = groupBases[base];\n out = '';\n var c = this.clone();\n c.negative = 0;\n while (!c.isZero()) {\n var r = c.modrn(groupBase).toString(base);\n c = c.idivn(groupBase);\n\n if (!c.isZero()) {\n out = zeros[groupSize - r.length] + r + out;\n } else {\n out = r + out;\n }\n }\n if (this.isZero()) {\n out = '0' + out;\n }\n while (out.length % padding !== 0) {\n out = '0' + out;\n }\n if (this.negative !== 0) {\n out = '-' + out;\n }\n return out;\n }\n\n assert(false, 'Base should be between 2 and 36');\n };\n\n BN.prototype.toNumber = function toNumber () {\n var ret = this.words[0];\n if (this.length === 2) {\n ret += this.words[1] * 0x4000000;\n } else if (this.length === 3 && this.words[2] === 0x01) {\n // NOTE: at this stage it is known that the top bit is set\n ret += 0x10000000000000 + (this.words[1] * 0x4000000);\n } else if (this.length > 2) {\n assert(false, 'Number can only safely store up to 53 bits');\n }\n return (this.negative !== 0) ? -ret : ret;\n };\n\n BN.prototype.toJSON = function toJSON () {\n return this.toString(16, 2);\n };\n\n if (Buffer) {\n BN.prototype.toBuffer = function toBuffer (endian, length) {\n return this.toArrayLike(Buffer, endian, length);\n };\n }\n\n BN.prototype.toArray = function toArray (endian, length) {\n return this.toArrayLike(Array, endian, length);\n };\n\n var allocate = function allocate (ArrayType, size) {\n if (ArrayType.allocUnsafe) {\n return ArrayType.allocUnsafe(size);\n }\n return new ArrayType(size);\n };\n\n BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {\n this._strip();\n\n var byteLength = this.byteLength();\n var reqLength = length || Math.max(1, byteLength);\n assert(byteLength <= reqLength, 'byte array longer than desired length');\n assert(reqLength > 0, 'Requested array length <= 0');\n\n var res = allocate(ArrayType, reqLength);\n var postfix = endian === 'le' ? 'LE' : 'BE';\n this['_toArrayLike' + postfix](res, byteLength);\n return res;\n };\n\n BN.prototype._toArrayLikeLE = function _toArrayLikeLE (res, byteLength) {\n var position = 0;\n var carry = 0;\n\n for (var i = 0, shift = 0; i < this.length; i++) {\n var word = (this.words[i] << shift) | carry;\n\n res[position++] = word & 0xff;\n if (position < res.length) {\n res[position++] = (word >> 8) & 0xff;\n }\n if (position < res.length) {\n res[position++] = (word >> 16) & 0xff;\n }\n\n if (shift === 6) {\n if (position < res.length) {\n res[position++] = (word >> 24) & 0xff;\n }\n carry = 0;\n shift = 0;\n } else {\n carry = word >>> 24;\n shift += 2;\n }\n }\n\n if (position < res.length) {\n res[position++] = carry;\n\n while (position < res.length) {\n res[position++] = 0;\n }\n }\n };\n\n BN.prototype._toArrayLikeBE = function _toArrayLikeBE (res, byteLength) {\n var position = res.length - 1;\n var carry = 0;\n\n for (var i = 0, shift = 0; i < this.length; i++) {\n var word = (this.words[i] << shift) | carry;\n\n res[position--] = word & 0xff;\n if (position >= 0) {\n res[position--] = (word >> 8) & 0xff;\n }\n if (position >= 0) {\n res[position--] = (word >> 16) & 0xff;\n }\n\n if (shift === 6) {\n if (position >= 0) {\n res[position--] = (word >> 24) & 0xff;\n }\n carry = 0;\n shift = 0;\n } else {\n carry = word >>> 24;\n shift += 2;\n }\n }\n\n if (position >= 0) {\n res[position--] = carry;\n\n while (position >= 0) {\n res[position--] = 0;\n }\n }\n };\n\n if (Math.clz32) {\n BN.prototype._countBits = function _countBits (w) {\n return 32 - Math.clz32(w);\n };\n } else {\n BN.prototype._countBits = function _countBits (w) {\n var t = w;\n var r = 0;\n if (t >= 0x1000) {\n r += 13;\n t >>>= 13;\n }\n if (t >= 0x40) {\n r += 7;\n t >>>= 7;\n }\n if (t >= 0x8) {\n r += 4;\n t >>>= 4;\n }\n if (t >= 0x02) {\n r += 2;\n t >>>= 2;\n }\n return r + t;\n };\n }\n\n BN.prototype._zeroBits = function _zeroBits (w) {\n // Short-cut\n if (w === 0) return 26;\n\n var t = w;\n var r = 0;\n if ((t & 0x1fff) === 0) {\n r += 13;\n t >>>= 13;\n }\n if ((t & 0x7f) === 0) {\n r += 7;\n t >>>= 7;\n }\n if ((t & 0xf) === 0) {\n r += 4;\n t >>>= 4;\n }\n if ((t & 0x3) === 0) {\n r += 2;\n t >>>= 2;\n }\n if ((t & 0x1) === 0) {\n r++;\n }\n return r;\n };\n\n // Return number of used bits in a BN\n BN.prototype.bitLength = function bitLength () {\n var w = this.words[this.length - 1];\n var hi = this._countBits(w);\n return (this.length - 1) * 26 + hi;\n };\n\n function toBitArray (num) {\n var w = new Array(num.bitLength());\n\n for (var bit = 0; bit < w.length; bit++) {\n var off = (bit / 26) | 0;\n var wbit = bit % 26;\n\n w[bit] = (num.words[off] >>> wbit) & 0x01;\n }\n\n return w;\n }\n\n // Number of trailing zero bits\n BN.prototype.zeroBits = function zeroBits () {\n if (this.isZero()) return 0;\n\n var r = 0;\n for (var i = 0; i < this.length; i++) {\n var b = this._zeroBits(this.words[i]);\n r += b;\n if (b !== 26) break;\n }\n return r;\n };\n\n BN.prototype.byteLength = function byteLength () {\n return Math.ceil(this.bitLength() / 8);\n };\n\n BN.prototype.toTwos = function toTwos (width) {\n if (this.negative !== 0) {\n return this.abs().inotn(width).iaddn(1);\n }\n return this.clone();\n };\n\n BN.prototype.fromTwos = function fromTwos (width) {\n if (this.testn(width - 1)) {\n return this.notn(width).iaddn(1).ineg();\n }\n return this.clone();\n };\n\n BN.prototype.isNeg = function isNeg () {\n return this.negative !== 0;\n };\n\n // Return negative clone of `this`\n BN.prototype.neg = function neg () {\n return this.clone().ineg();\n };\n\n BN.prototype.ineg = function ineg () {\n if (!this.isZero()) {\n this.negative ^= 1;\n }\n\n return this;\n };\n\n // Or `num` with `this` in-place\n BN.prototype.iuor = function iuor (num) {\n while (this.length < num.length) {\n this.words[this.length++] = 0;\n }\n\n for (var i = 0; i < num.length; i++) {\n this.words[i] = this.words[i] | num.words[i];\n }\n\n return this._strip();\n };\n\n BN.prototype.ior = function ior (num) {\n assert((this.negative | num.negative) === 0);\n return this.iuor(num);\n };\n\n // Or `num` with `this`\n BN.prototype.or = function or (num) {\n if (this.length > num.length) return this.clone().ior(num);\n return num.clone().ior(this);\n };\n\n BN.prototype.uor = function uor (num) {\n if (this.length > num.length) return this.clone().iuor(num);\n return num.clone().iuor(this);\n };\n\n // And `num` with `this` in-place\n BN.prototype.iuand = function iuand (num) {\n // b = min-length(num, this)\n var b;\n if (this.length > num.length) {\n b = num;\n } else {\n b = this;\n }\n\n for (var i = 0; i < b.length; i++) {\n this.words[i] = this.words[i] & num.words[i];\n }\n\n this.length = b.length;\n\n return this._strip();\n };\n\n BN.prototype.iand = function iand (num) {\n assert((this.negative | num.negative) === 0);\n return this.iuand(num);\n };\n\n // And `num` with `this`\n BN.prototype.and = function and (num) {\n if (this.length > num.length) return this.clone().iand(num);\n return num.clone().iand(this);\n };\n\n BN.prototype.uand = function uand (num) {\n if (this.length > num.length) return this.clone().iuand(num);\n return num.clone().iuand(this);\n };\n\n // Xor `num` with `this` in-place\n BN.prototype.iuxor = function iuxor (num) {\n // a.length > b.length\n var a;\n var b;\n if (this.length > num.length) {\n a = this;\n b = num;\n } else {\n a = num;\n b = this;\n }\n\n for (var i = 0; i < b.length; i++) {\n this.words[i] = a.words[i] ^ b.words[i];\n }\n\n if (this !== a) {\n for (; i < a.length; i++) {\n this.words[i] = a.words[i];\n }\n }\n\n this.length = a.length;\n\n return this._strip();\n };\n\n BN.prototype.ixor = function ixor (num) {\n assert((this.negative | num.negative) === 0);\n return this.iuxor(num);\n };\n\n // Xor `num` with `this`\n BN.prototype.xor = function xor (num) {\n if (this.length > num.length) return this.clone().ixor(num);\n return num.clone().ixor(this);\n };\n\n BN.prototype.uxor = function uxor (num) {\n if (this.length > num.length) return this.clone().iuxor(num);\n return num.clone().iuxor(this);\n };\n\n // Not ``this`` with ``width`` bitwidth\n BN.prototype.inotn = function inotn (width) {\n assert(typeof width === 'number' && width >= 0);\n\n var bytesNeeded = Math.ceil(width / 26) | 0;\n var bitsLeft = width % 26;\n\n // Extend the buffer with leading zeroes\n this._expand(bytesNeeded);\n\n if (bitsLeft > 0) {\n bytesNeeded--;\n }\n\n // Handle complete words\n for (var i = 0; i < bytesNeeded; i++) {\n this.words[i] = ~this.words[i] & 0x3ffffff;\n }\n\n // Handle the residue\n if (bitsLeft > 0) {\n this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));\n }\n\n // And remove leading zeroes\n return this._strip();\n };\n\n BN.prototype.notn = function notn (width) {\n return this.clone().inotn(width);\n };\n\n // Set `bit` of `this`\n BN.prototype.setn = function setn (bit, val) {\n assert(typeof bit === 'number' && bit >= 0);\n\n var off = (bit / 26) | 0;\n var wbit = bit % 26;\n\n this._expand(off + 1);\n\n if (val) {\n this.words[off] = this.words[off] | (1 << wbit);\n } else {\n this.words[off] = this.words[off] & ~(1 << wbit);\n }\n\n return this._strip();\n };\n\n // Add `num` to `this` in-place\n BN.prototype.iadd = function iadd (num) {\n var r;\n\n // negative + positive\n if (this.negative !== 0 && num.negative === 0) {\n this.negative = 0;\n r = this.isub(num);\n this.negative ^= 1;\n return this._normSign();\n\n // positive + negative\n } else if (this.negative === 0 && num.negative !== 0) {\n num.negative = 0;\n r = this.isub(num);\n num.negative = 1;\n return r._normSign();\n }\n\n // a.length > b.length\n var a, b;\n if (this.length > num.length) {\n a = this;\n b = num;\n } else {\n a = num;\n b = this;\n }\n\n var carry = 0;\n for (var i = 0; i < b.length; i++) {\n r = (a.words[i] | 0) + (b.words[i] | 0) + carry;\n this.words[i] = r & 0x3ffffff;\n carry = r >>> 26;\n }\n for (; carry !== 0 && i < a.length; i++) {\n r = (a.words[i] | 0) + carry;\n this.words[i] = r & 0x3ffffff;\n carry = r >>> 26;\n }\n\n this.length = a.length;\n if (carry !== 0) {\n this.words[this.length] = carry;\n this.length++;\n // Copy the rest of the words\n } else if (a !== this) {\n for (; i < a.length; i++) {\n this.words[i] = a.words[i];\n }\n }\n\n return this;\n };\n\n // Add `num` to `this`\n BN.prototype.add = function add (num) {\n var res;\n if (num.negative !== 0 && this.negative === 0) {\n num.negative = 0;\n res = this.sub(num);\n num.negative ^= 1;\n return res;\n } else if (num.negative === 0 && this.negative !== 0) {\n this.negative = 0;\n res = num.sub(this);\n this.negative = 1;\n return res;\n }\n\n if (this.length > num.length) return this.clone().iadd(num);\n\n return num.clone().iadd(this);\n };\n\n // Subtract `num` from `this` in-place\n BN.prototype.isub = function isub (num) {\n // this - (-num) = this + num\n if (num.negative !== 0) {\n num.negative = 0;\n var r = this.iadd(num);\n num.negative = 1;\n return r._normSign();\n\n // -this - num = -(this + num)\n } else if (this.negative !== 0) {\n this.negative = 0;\n this.iadd(num);\n this.negative = 1;\n return this._normSign();\n }\n\n // At this point both numbers are positive\n var cmp = this.cmp(num);\n\n // Optimization - zeroify\n if (cmp === 0) {\n this.negative = 0;\n this.length = 1;\n this.words[0] = 0;\n return this;\n }\n\n // a > b\n var a, b;\n if (cmp > 0) {\n a = this;\n b = num;\n } else {\n a = num;\n b = this;\n }\n\n var carry = 0;\n for (var i = 0; i < b.length; i++) {\n r = (a.words[i] | 0) - (b.words[i] | 0) + carry;\n carry = r >> 26;\n this.words[i] = r & 0x3ffffff;\n }\n for (; carry !== 0 && i < a.length; i++) {\n r = (a.words[i] | 0) + carry;\n carry = r >> 26;\n this.words[i] = r & 0x3ffffff;\n }\n\n // Copy rest of the words\n if (carry === 0 && i < a.length && a !== this) {\n for (; i < a.length; i++) {\n this.words[i] = a.words[i];\n }\n }\n\n this.length = Math.max(this.length, i);\n\n if (a !== this) {\n this.negative = 1;\n }\n\n return this._strip();\n };\n\n // Subtract `num` from `this`\n BN.prototype.sub = function sub (num) {\n return this.clone().isub(num);\n };\n\n function smallMulTo (self, num, out) {\n out.negative = num.negative ^ self.negative;\n var len = (self.length + num.length) | 0;\n out.length = len;\n len = (len - 1) | 0;\n\n // Peel one iteration (compiler can't do it, because of code complexity)\n var a = self.words[0] | 0;\n var b = num.words[0] | 0;\n var r = a * b;\n\n var lo = r & 0x3ffffff;\n var carry = (r / 0x4000000) | 0;\n out.words[0] = lo;\n\n for (var k = 1; k < len; k++) {\n // Sum all words with the same `i + j = k` and accumulate `ncarry`,\n // note that ncarry could be >= 0x3ffffff\n var ncarry = carry >>> 26;\n var rword = carry & 0x3ffffff;\n var maxJ = Math.min(k, num.length - 1);\n for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {\n var i = (k - j) | 0;\n a = self.words[i] | 0;\n b = num.words[j] | 0;\n r = a * b + rword;\n ncarry += (r / 0x4000000) | 0;\n rword = r & 0x3ffffff;\n }\n out.words[k] = rword | 0;\n carry = ncarry | 0;\n }\n if (carry !== 0) {\n out.words[k] = carry | 0;\n } else {\n out.length--;\n }\n\n return out._strip();\n }\n\n // TODO(indutny): it may be reasonable to omit it for users who don't need\n // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit\n // multiplication (like elliptic secp256k1).\n var comb10MulTo = function comb10MulTo (self, num, out) {\n var a = self.words;\n var b = num.words;\n var o = out.words;\n var c = 0;\n var lo;\n var mid;\n var hi;\n var a0 = a[0] | 0;\n var al0 = a0 & 0x1fff;\n var ah0 = a0 >>> 13;\n var a1 = a[1] | 0;\n var al1 = a1 & 0x1fff;\n var ah1 = a1 >>> 13;\n var a2 = a[2] | 0;\n var al2 = a2 & 0x1fff;\n var ah2 = a2 >>> 13;\n var a3 = a[3] | 0;\n var al3 = a3 & 0x1fff;\n var ah3 = a3 >>> 13;\n var a4 = a[4] | 0;\n var al4 = a4 & 0x1fff;\n var ah4 = a4 >>> 13;\n var a5 = a[5] | 0;\n var al5 = a5 & 0x1fff;\n var ah5 = a5 >>> 13;\n var a6 = a[6] | 0;\n var al6 = a6 & 0x1fff;\n var ah6 = a6 >>> 13;\n var a7 = a[7] | 0;\n var al7 = a7 & 0x1fff;\n var ah7 = a7 >>> 13;\n var a8 = a[8] | 0;\n var al8 = a8 & 0x1fff;\n var ah8 = a8 >>> 13;\n var a9 = a[9] | 0;\n var al9 = a9 & 0x1fff;\n var ah9 = a9 >>> 13;\n var b0 = b[0] | 0;\n var bl0 = b0 & 0x1fff;\n var bh0 = b0 >>> 13;\n var b1 = b[1] | 0;\n var bl1 = b1 & 0x1fff;\n var bh1 = b1 >>> 13;\n var b2 = b[2] | 0;\n var bl2 = b2 & 0x1fff;\n var bh2 = b2 >>> 13;\n var b3 = b[3] | 0;\n var bl3 = b3 & 0x1fff;\n var bh3 = b3 >>> 13;\n var b4 = b[4] | 0;\n var bl4 = b4 & 0x1fff;\n var bh4 = b4 >>> 13;\n var b5 = b[5] | 0;\n var bl5 = b5 & 0x1fff;\n var bh5 = b5 >>> 13;\n var b6 = b[6] | 0;\n var bl6 = b6 & 0x1fff;\n var bh6 = b6 >>> 13;\n var b7 = b[7] | 0;\n var bl7 = b7 & 0x1fff;\n var bh7 = b7 >>> 13;\n var b8 = b[8] | 0;\n var bl8 = b8 & 0x1fff;\n var bh8 = b8 >>> 13;\n var b9 = b[9] | 0;\n var bl9 = b9 & 0x1fff;\n var bh9 = b9 >>> 13;\n\n out.negative = self.negative ^ num.negative;\n out.length = 19;\n /* k = 0 */\n lo = Math.imul(al0, bl0);\n mid = Math.imul(al0, bh0);\n mid = (mid + Math.imul(ah0, bl0)) | 0;\n hi = Math.imul(ah0, bh0);\n var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0;\n w0 &= 0x3ffffff;\n /* k = 1 */\n lo = Math.imul(al1, bl0);\n mid = Math.imul(al1, bh0);\n mid = (mid + Math.imul(ah1, bl0)) | 0;\n hi = Math.imul(ah1, bh0);\n lo = (lo + Math.imul(al0, bl1)) | 0;\n mid = (mid + Math.imul(al0, bh1)) | 0;\n mid = (mid + Math.imul(ah0, bl1)) | 0;\n hi = (hi + Math.imul(ah0, bh1)) | 0;\n var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0;\n w1 &= 0x3ffffff;\n /* k = 2 */\n lo = Math.imul(al2, bl0);\n mid = Math.imul(al2, bh0);\n mid = (mid + Math.imul(ah2, bl0)) | 0;\n hi = Math.imul(ah2, bh0);\n lo = (lo + Math.imul(al1, bl1)) | 0;\n mid = (mid + Math.imul(al1, bh1)) | 0;\n mid = (mid + Math.imul(ah1, bl1)) | 0;\n hi = (hi + Math.imul(ah1, bh1)) | 0;\n lo = (lo + Math.imul(al0, bl2)) | 0;\n mid = (mid + Math.imul(al0, bh2)) | 0;\n mid = (mid + Math.imul(ah0, bl2)) | 0;\n hi = (hi + Math.imul(ah0, bh2)) | 0;\n var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0;\n w2 &= 0x3ffffff;\n /* k = 3 */\n lo = Math.imul(al3, bl0);\n mid = Math.imul(al3, bh0);\n mid = (mid + Math.imul(ah3, bl0)) | 0;\n hi = Math.imul(ah3, bh0);\n lo = (lo + Math.imul(al2, bl1)) | 0;\n mid = (mid + Math.imul(al2, bh1)) | 0;\n mid = (mid + Math.imul(ah2, bl1)) | 0;\n hi = (hi + Math.imul(ah2, bh1)) | 0;\n lo = (lo + Math.imul(al1, bl2)) | 0;\n mid = (mid + Math.imul(al1, bh2)) | 0;\n mid = (mid + Math.imul(ah1, bl2)) | 0;\n hi = (hi + Math.imul(ah1, bh2)) | 0;\n lo = (lo + Math.imul(al0, bl3)) | 0;\n mid = (mid + Math.imul(al0, bh3)) | 0;\n mid = (mid + Math.imul(ah0, bl3)) | 0;\n hi = (hi + Math.imul(ah0, bh3)) | 0;\n var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0;\n w3 &= 0x3ffffff;\n /* k = 4 */\n lo = Math.imul(al4, bl0);\n mid = Math.imul(al4, bh0);\n mid = (mid + Math.imul(ah4, bl0)) | 0;\n hi = Math.imul(ah4, bh0);\n lo = (lo + Math.imul(al3, bl1)) | 0;\n mid = (mid + Math.imul(al3, bh1)) | 0;\n mid = (mid + Math.imul(ah3, bl1)) | 0;\n hi = (hi + Math.imul(ah3, bh1)) | 0;\n lo = (lo + Math.imul(al2, bl2)) | 0;\n mid = (mid + Math.imul(al2, bh2)) | 0;\n mid = (mid + Math.imul(ah2, bl2)) | 0;\n hi = (hi + Math.imul(ah2, bh2)) | 0;\n lo = (lo + Math.imul(al1, bl3)) | 0;\n mid = (mid + Math.imul(al1, bh3)) | 0;\n mid = (mid + Math.imul(ah1, bl3)) | 0;\n hi = (hi + Math.imul(ah1, bh3)) | 0;\n lo = (lo + Math.imul(al0, bl4)) | 0;\n mid = (mid + Math.imul(al0, bh4)) | 0;\n mid = (mid + Math.imul(ah0, bl4)) | 0;\n hi = (hi + Math.imul(ah0, bh4)) | 0;\n var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0;\n w4 &= 0x3ffffff;\n /* k = 5 */\n lo = Math.imul(al5, bl0);\n mid = Math.imul(al5, bh0);\n mid = (mid + Math.imul(ah5, bl0)) | 0;\n hi = Math.imul(ah5, bh0);\n lo = (lo + Math.imul(al4, bl1)) | 0;\n mid = (mid + Math.imul(al4, bh1)) | 0;\n mid = (mid + Math.imul(ah4, bl1)) | 0;\n hi = (hi + Math.imul(ah4, bh1)) | 0;\n lo = (lo + Math.imul(al3, bl2)) | 0;\n mid = (mid + Math.imul(al3, bh2)) | 0;\n mid = (mid + Math.imul(ah3, bl2)) | 0;\n hi = (hi + Math.imul(ah3, bh2)) | 0;\n lo = (lo + Math.imul(al2, bl3)) | 0;\n mid = (mid + Math.imul(al2, bh3)) | 0;\n mid = (mid + Math.imul(ah2, bl3)) | 0;\n hi = (hi + Math.imul(ah2, bh3)) | 0;\n lo = (lo + Math.imul(al1, bl4)) | 0;\n mid = (mid + Math.imul(al1, bh4)) | 0;\n mid = (mid + Math.imul(ah1, bl4)) | 0;\n hi = (hi + Math.imul(ah1, bh4)) | 0;\n lo = (lo + Math.imul(al0, bl5)) | 0;\n mid = (mid + Math.imul(al0, bh5)) | 0;\n mid = (mid + Math.imul(ah0, bl5)) | 0;\n hi = (hi + Math.imul(ah0, bh5)) | 0;\n var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0;\n w5 &= 0x3ffffff;\n /* k = 6 */\n lo = Math.imul(al6, bl0);\n mid = Math.imul(al6, bh0);\n mid = (mid + Math.imul(ah6, bl0)) | 0;\n hi = Math.imul(ah6, bh0);\n lo = (lo + Math.imul(al5, bl1)) | 0;\n mid = (mid + Math.imul(al5, bh1)) | 0;\n mid = (mid + Math.imul(ah5, bl1)) | 0;\n hi = (hi + Math.imul(ah5, bh1)) | 0;\n lo = (lo + Math.imul(al4, bl2)) | 0;\n mid = (mid + Math.imul(al4, bh2)) | 0;\n mid = (mid + Math.imul(ah4, bl2)) | 0;\n hi = (hi + Math.imul(ah4, bh2)) | 0;\n lo = (lo + Math.imul(al3, bl3)) | 0;\n mid = (mid + Math.imul(al3, bh3)) | 0;\n mid = (mid + Math.imul(ah3, bl3)) | 0;\n hi = (hi + Math.imul(ah3, bh3)) | 0;\n lo = (lo + Math.imul(al2, bl4)) | 0;\n mid = (mid + Math.imul(al2, bh4)) | 0;\n mid = (mid + Math.imul(ah2, bl4)) | 0;\n hi = (hi + Math.imul(ah2, bh4)) | 0;\n lo = (lo + Math.imul(al1, bl5)) | 0;\n mid = (mid + Math.imul(al1, bh5)) | 0;\n mid = (mid + Math.imul(ah1, bl5)) | 0;\n hi = (hi + Math.imul(ah1, bh5)) | 0;\n lo = (lo + Math.imul(al0, bl6)) | 0;\n mid = (mid + Math.imul(al0, bh6)) | 0;\n mid = (mid + Math.imul(ah0, bl6)) | 0;\n hi = (hi + Math.imul(ah0, bh6)) | 0;\n var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0;\n w6 &= 0x3ffffff;\n /* k = 7 */\n lo = Math.imul(al7, bl0);\n mid = Math.imul(al7, bh0);\n mid = (mid + Math.imul(ah7, bl0)) | 0;\n hi = Math.imul(ah7, bh0);\n lo = (lo + Math.imul(al6, bl1)) | 0;\n mid = (mid + Math.imul(al6, bh1)) | 0;\n mid = (mid + Math.imul(ah6, bl1)) | 0;\n hi = (hi + Math.imul(ah6, bh1)) | 0;\n lo = (lo + Math.imul(al5, bl2)) | 0;\n mid = (mid + Math.imul(al5, bh2)) | 0;\n mid = (mid + Math.imul(ah5, bl2)) | 0;\n hi = (hi + Math.imul(ah5, bh2)) | 0;\n lo = (lo + Math.imul(al4, bl3)) | 0;\n mid = (mid + Math.imul(al4, bh3)) | 0;\n mid = (mid + Math.imul(ah4, bl3)) | 0;\n hi = (hi + Math.imul(ah4, bh3)) | 0;\n lo = (lo + Math.imul(al3, bl4)) | 0;\n mid = (mid + Math.imul(al3, bh4)) | 0;\n mid = (mid + Math.imul(ah3, bl4)) | 0;\n hi = (hi + Math.imul(ah3, bh4)) | 0;\n lo = (lo + Math.imul(al2, bl5)) | 0;\n mid = (mid + Math.imul(al2, bh5)) | 0;\n mid = (mid + Math.imul(ah2, bl5)) | 0;\n hi = (hi + Math.imul(ah2, bh5)) | 0;\n lo = (lo + Math.imul(al1, bl6)) | 0;\n mid = (mid + Math.imul(al1, bh6)) | 0;\n mid = (mid + Math.imul(ah1, bl6)) | 0;\n hi = (hi + Math.imul(ah1, bh6)) | 0;\n lo = (lo + Math.imul(al0, bl7)) | 0;\n mid = (mid + Math.imul(al0, bh7)) | 0;\n mid = (mid + Math.imul(ah0, bl7)) | 0;\n hi = (hi + Math.imul(ah0, bh7)) | 0;\n var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0;\n w7 &= 0x3ffffff;\n /* k = 8 */\n lo = Math.imul(al8, bl0);\n mid = Math.imul(al8, bh0);\n mid = (mid + Math.imul(ah8, bl0)) | 0;\n hi = Math.imul(ah8, bh0);\n lo = (lo + Math.imul(al7, bl1)) | 0;\n mid = (mid + Math.imul(al7, bh1)) | 0;\n mid = (mid + Math.imul(ah7, bl1)) | 0;\n hi = (hi + Math.imul(ah7, bh1)) | 0;\n lo = (lo + Math.imul(al6, bl2)) | 0;\n mid = (mid + Math.imul(al6, bh2)) | 0;\n mid = (mid + Math.imul(ah6, bl2)) | 0;\n hi = (hi + Math.imul(ah6, bh2)) | 0;\n lo = (lo + Math.imul(al5, bl3)) | 0;\n mid = (mid + Math.imul(al5, bh3)) | 0;\n mid = (mid + Math.imul(ah5, bl3)) | 0;\n hi = (hi + Math.imul(ah5, bh3)) | 0;\n lo = (lo + Math.imul(al4, bl4)) | 0;\n mid = (mid + Math.imul(al4, bh4)) | 0;\n mid = (mid + Math.imul(ah4, bl4)) | 0;\n hi = (hi + Math.imul(ah4, bh4)) | 0;\n lo = (lo + Math.imul(al3, bl5)) | 0;\n mid = (mid + Math.imul(al3, bh5)) | 0;\n mid = (mid + Math.imul(ah3, bl5)) | 0;\n hi = (hi + Math.imul(ah3, bh5)) | 0;\n lo = (lo + Math.imul(al2, bl6)) | 0;\n mid = (mid + Math.imul(al2, bh6)) | 0;\n mid = (mid + Math.imul(ah2, bl6)) | 0;\n hi = (hi + Math.imul(ah2, bh6)) | 0;\n lo = (lo + Math.imul(al1, bl7)) | 0;\n mid = (mid + Math.imul(al1, bh7)) | 0;\n mid = (mid + Math.imul(ah1, bl7)) | 0;\n hi = (hi + Math.imul(ah1, bh7)) | 0;\n lo = (lo + Math.imul(al0, bl8)) | 0;\n mid = (mid + Math.imul(al0, bh8)) | 0;\n mid = (mid + Math.imul(ah0, bl8)) | 0;\n hi = (hi + Math.imul(ah0, bh8)) | 0;\n var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0;\n w8 &= 0x3ffffff;\n /* k = 9 */\n lo = Math.imul(al9, bl0);\n mid = Math.imul(al9, bh0);\n mid = (mid + Math.imul(ah9, bl0)) | 0;\n hi = Math.imul(ah9, bh0);\n lo = (lo + Math.imul(al8, bl1)) | 0;\n mid = (mid + Math.imul(al8, bh1)) | 0;\n mid = (mid + Math.imul(ah8, bl1)) | 0;\n hi = (hi + Math.imul(ah8, bh1)) | 0;\n lo = (lo + Math.imul(al7, bl2)) | 0;\n mid = (mid + Math.imul(al7, bh2)) | 0;\n mid = (mid + Math.imul(ah7, bl2)) | 0;\n hi = (hi + Math.imul(ah7, bh2)) | 0;\n lo = (lo + Math.imul(al6, bl3)) | 0;\n mid = (mid + Math.imul(al6, bh3)) | 0;\n mid = (mid + Math.imul(ah6, bl3)) | 0;\n hi = (hi + Math.imul(ah6, bh3)) | 0;\n lo = (lo + Math.imul(al5, bl4)) | 0;\n mid = (mid + Math.imul(al5, bh4)) | 0;\n mid = (mid + Math.imul(ah5, bl4)) | 0;\n hi = (hi + Math.imul(ah5, bh4)) | 0;\n lo = (lo + Math.imul(al4, bl5)) | 0;\n mid = (mid + Math.imul(al4, bh5)) | 0;\n mid = (mid + Math.imul(ah4, bl5)) | 0;\n hi = (hi + Math.imul(ah4, bh5)) | 0;\n lo = (lo + Math.imul(al3, bl6)) | 0;\n mid = (mid + Math.imul(al3, bh6)) | 0;\n mid = (mid + Math.imul(ah3, bl6)) | 0;\n hi = (hi + Math.imul(ah3, bh6)) | 0;\n lo = (lo + Math.imul(al2, bl7)) | 0;\n mid = (mid + Math.imul(al2, bh7)) | 0;\n mid = (mid + Math.imul(ah2, bl7)) | 0;\n hi = (hi + Math.imul(ah2, bh7)) | 0;\n lo = (lo + Math.imul(al1, bl8)) | 0;\n mid = (mid + Math.imul(al1, bh8)) | 0;\n mid = (mid + Math.imul(ah1, bl8)) | 0;\n hi = (hi + Math.imul(ah1, bh8)) | 0;\n lo = (lo + Math.imul(al0, bl9)) | 0;\n mid = (mid + Math.imul(al0, bh9)) | 0;\n mid = (mid + Math.imul(ah0, bl9)) | 0;\n hi = (hi + Math.imul(ah0, bh9)) | 0;\n var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0;\n w9 &= 0x3ffffff;\n /* k = 10 */\n lo = Math.imul(al9, bl1);\n mid = Math.imul(al9, bh1);\n mid = (mid + Math.imul(ah9, bl1)) | 0;\n hi = Math.imul(ah9, bh1);\n lo = (lo + Math.imul(al8, bl2)) | 0;\n mid = (mid + Math.imul(al8, bh2)) | 0;\n mid = (mid + Math.imul(ah8, bl2)) | 0;\n hi = (hi + Math.imul(ah8, bh2)) | 0;\n lo = (lo + Math.imul(al7, bl3)) | 0;\n mid = (mid + Math.imul(al7, bh3)) | 0;\n mid = (mid + Math.imul(ah7, bl3)) | 0;\n hi = (hi + Math.imul(ah7, bh3)) | 0;\n lo = (lo + Math.imul(al6, bl4)) | 0;\n mid = (mid + Math.imul(al6, bh4)) | 0;\n mid = (mid + Math.imul(ah6, bl4)) | 0;\n hi = (hi + Math.imul(ah6, bh4)) | 0;\n lo = (lo + Math.imul(al5, bl5)) | 0;\n mid = (mid + Math.imul(al5, bh5)) | 0;\n mid = (mid + Math.imul(ah5, bl5)) | 0;\n hi = (hi + Math.imul(ah5, bh5)) | 0;\n lo = (lo + Math.imul(al4, bl6)) | 0;\n mid = (mid + Math.imul(al4, bh6)) | 0;\n mid = (mid + Math.imul(ah4, bl6)) | 0;\n hi = (hi + Math.imul(ah4, bh6)) | 0;\n lo = (lo + Math.imul(al3, bl7)) | 0;\n mid = (mid + Math.imul(al3, bh7)) | 0;\n mid = (mid + Math.imul(ah3, bl7)) | 0;\n hi = (hi + Math.imul(ah3, bh7)) | 0;\n lo = (lo + Math.imul(al2, bl8)) | 0;\n mid = (mid + Math.imul(al2, bh8)) | 0;\n mid = (mid + Math.imul(ah2, bl8)) | 0;\n hi = (hi + Math.imul(ah2, bh8)) | 0;\n lo = (lo + Math.imul(al1, bl9)) | 0;\n mid = (mid + Math.imul(al1, bh9)) | 0;\n mid = (mid + Math.imul(ah1, bl9)) | 0;\n hi = (hi + Math.imul(ah1, bh9)) | 0;\n var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0;\n w10 &= 0x3ffffff;\n /* k = 11 */\n lo = Math.imul(al9, bl2);\n mid = Math.imul(al9, bh2);\n mid = (mid + Math.imul(ah9, bl2)) | 0;\n hi = Math.imul(ah9, bh2);\n lo = (lo + Math.imul(al8, bl3)) | 0;\n mid = (mid + Math.imul(al8, bh3)) | 0;\n mid = (mid + Math.imul(ah8, bl3)) | 0;\n hi = (hi + Math.imul(ah8, bh3)) | 0;\n lo = (lo + Math.imul(al7, bl4)) | 0;\n mid = (mid + Math.imul(al7, bh4)) | 0;\n mid = (mid + Math.imul(ah7, bl4)) | 0;\n hi = (hi + Math.imul(ah7, bh4)) | 0;\n lo = (lo + Math.imul(al6, bl5)) | 0;\n mid = (mid + Math.imul(al6, bh5)) | 0;\n mid = (mid + Math.imul(ah6, bl5)) | 0;\n hi = (hi + Math.imul(ah6, bh5)) | 0;\n lo = (lo + Math.imul(al5, bl6)) | 0;\n mid = (mid + Math.imul(al5, bh6)) | 0;\n mid = (mid + Math.imul(ah5, bl6)) | 0;\n hi = (hi + Math.imul(ah5, bh6)) | 0;\n lo = (lo + Math.imul(al4, bl7)) | 0;\n mid = (mid + Math.imul(al4, bh7)) | 0;\n mid = (mid + Math.imul(ah4, bl7)) | 0;\n hi = (hi + Math.imul(ah4, bh7)) | 0;\n lo = (lo + Math.imul(al3, bl8)) | 0;\n mid = (mid + Math.imul(al3, bh8)) | 0;\n mid = (mid + Math.imul(ah3, bl8)) | 0;\n hi = (hi + Math.imul(ah3, bh8)) | 0;\n lo = (lo + Math.imul(al2, bl9)) | 0;\n mid = (mid + Math.imul(al2, bh9)) | 0;\n mid = (mid + Math.imul(ah2, bl9)) | 0;\n hi = (hi + Math.imul(ah2, bh9)) | 0;\n var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0;\n w11 &= 0x3ffffff;\n /* k = 12 */\n lo = Math.imul(al9, bl3);\n mid = Math.imul(al9, bh3);\n mid = (mid + Math.imul(ah9, bl3)) | 0;\n hi = Math.imul(ah9, bh3);\n lo = (lo + Math.imul(al8, bl4)) | 0;\n mid = (mid + Math.imul(al8, bh4)) | 0;\n mid = (mid + Math.imul(ah8, bl4)) | 0;\n hi = (hi + Math.imul(ah8, bh4)) | 0;\n lo = (lo + Math.imul(al7, bl5)) | 0;\n mid = (mid + Math.imul(al7, bh5)) | 0;\n mid = (mid + Math.imul(ah7, bl5)) | 0;\n hi = (hi + Math.imul(ah7, bh5)) | 0;\n lo = (lo + Math.imul(al6, bl6)) | 0;\n mid = (mid + Math.imul(al6, bh6)) | 0;\n mid = (mid + Math.imul(ah6, bl6)) | 0;\n hi = (hi + Math.imul(ah6, bh6)) | 0;\n lo = (lo + Math.imul(al5, bl7)) | 0;\n mid = (mid + Math.imul(al5, bh7)) | 0;\n mid = (mid + Math.imul(ah5, bl7)) | 0;\n hi = (hi + Math.imul(ah5, bh7)) | 0;\n lo = (lo + Math.imul(al4, bl8)) | 0;\n mid = (mid + Math.imul(al4, bh8)) | 0;\n mid = (mid + Math.imul(ah4, bl8)) | 0;\n hi = (hi + Math.imul(ah4, bh8)) | 0;\n lo = (lo + Math.imul(al3, bl9)) | 0;\n mid = (mid + Math.imul(al3, bh9)) | 0;\n mid = (mid + Math.imul(ah3, bl9)) | 0;\n hi = (hi + Math.imul(ah3, bh9)) | 0;\n var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0;\n w12 &= 0x3ffffff;\n /* k = 13 */\n lo = Math.imul(al9, bl4);\n mid = Math.imul(al9, bh4);\n mid = (mid + Math.imul(ah9, bl4)) | 0;\n hi = Math.imul(ah9, bh4);\n lo = (lo + Math.imul(al8, bl5)) | 0;\n mid = (mid + Math.imul(al8, bh5)) | 0;\n mid = (mid + Math.imul(ah8, bl5)) | 0;\n hi = (hi + Math.imul(ah8, bh5)) | 0;\n lo = (lo + Math.imul(al7, bl6)) | 0;\n mid = (mid + Math.imul(al7, bh6)) | 0;\n mid = (mid + Math.imul(ah7, bl6)) | 0;\n hi = (hi + Math.imul(ah7, bh6)) | 0;\n lo = (lo + Math.imul(al6, bl7)) | 0;\n mid = (mid + Math.imul(al6, bh7)) | 0;\n mid = (mid + Math.imul(ah6, bl7)) | 0;\n hi = (hi + Math.imul(ah6, bh7)) | 0;\n lo = (lo + Math.imul(al5, bl8)) | 0;\n mid = (mid + Math.imul(al5, bh8)) | 0;\n mid = (mid + Math.imul(ah5, bl8)) | 0;\n hi = (hi + Math.imul(ah5, bh8)) | 0;\n lo = (lo + Math.imul(al4, bl9)) | 0;\n mid = (mid + Math.imul(al4, bh9)) | 0;\n mid = (mid + Math.imul(ah4, bl9)) | 0;\n hi = (hi + Math.imul(ah4, bh9)) | 0;\n var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0;\n w13 &= 0x3ffffff;\n /* k = 14 */\n lo = Math.imul(al9, bl5);\n mid = Math.imul(al9, bh5);\n mid = (mid + Math.imul(ah9, bl5)) | 0;\n hi = Math.imul(ah9, bh5);\n lo = (lo + Math.imul(al8, bl6)) | 0;\n mid = (mid + Math.imul(al8, bh6)) | 0;\n mid = (mid + Math.imul(ah8, bl6)) | 0;\n hi = (hi + Math.imul(ah8, bh6)) | 0;\n lo = (lo + Math.imul(al7, bl7)) | 0;\n mid = (mid + Math.imul(al7, bh7)) | 0;\n mid = (mid + Math.imul(ah7, bl7)) | 0;\n hi = (hi + Math.imul(ah7, bh7)) | 0;\n lo = (lo + Math.imul(al6, bl8)) | 0;\n mid = (mid + Math.imul(al6, bh8)) | 0;\n mid = (mid + Math.imul(ah6, bl8)) | 0;\n hi = (hi + Math.imul(ah6, bh8)) | 0;\n lo = (lo + Math.imul(al5, bl9)) | 0;\n mid = (mid + Math.imul(al5, bh9)) | 0;\n mid = (mid + Math.imul(ah5, bl9)) | 0;\n hi = (hi + Math.imul(ah5, bh9)) | 0;\n var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0;\n w14 &= 0x3ffffff;\n /* k = 15 */\n lo = Math.imul(al9, bl6);\n mid = Math.imul(al9, bh6);\n mid = (mid + Math.imul(ah9, bl6)) | 0;\n hi = Math.imul(ah9, bh6);\n lo = (lo + Math.imul(al8, bl7)) | 0;\n mid = (mid + Math.imul(al8, bh7)) | 0;\n mid = (mid + Math.imul(ah8, bl7)) | 0;\n hi = (hi + Math.imul(ah8, bh7)) | 0;\n lo = (lo + Math.imul(al7, bl8)) | 0;\n mid = (mid + Math.imul(al7, bh8)) | 0;\n mid = (mid + Math.imul(ah7, bl8)) | 0;\n hi = (hi + Math.imul(ah7, bh8)) | 0;\n lo = (lo + Math.imul(al6, bl9)) | 0;\n mid = (mid + Math.imul(al6, bh9)) | 0;\n mid = (mid + Math.imul(ah6, bl9)) | 0;\n hi = (hi + Math.imul(ah6, bh9)) | 0;\n var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0;\n w15 &= 0x3ffffff;\n /* k = 16 */\n lo = Math.imul(al9, bl7);\n mid = Math.imul(al9, bh7);\n mid = (mid + Math.imul(ah9, bl7)) | 0;\n hi = Math.imul(ah9, bh7);\n lo = (lo + Math.imul(al8, bl8)) | 0;\n mid = (mid + Math.imul(al8, bh8)) | 0;\n mid = (mid + Math.imul(ah8, bl8)) | 0;\n hi = (hi + Math.imul(ah8, bh8)) | 0;\n lo = (lo + Math.imul(al7, bl9)) | 0;\n mid = (mid + Math.imul(al7, bh9)) | 0;\n mid = (mid + Math.imul(ah7, bl9)) | 0;\n hi = (hi + Math.imul(ah7, bh9)) | 0;\n var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0;\n w16 &= 0x3ffffff;\n /* k = 17 */\n lo = Math.imul(al9, bl8);\n mid = Math.imul(al9, bh8);\n mid = (mid + Math.imul(ah9, bl8)) | 0;\n hi = Math.imul(ah9, bh8);\n lo = (lo + Math.imul(al8, bl9)) | 0;\n mid = (mid + Math.imul(al8, bh9)) | 0;\n mid = (mid + Math.imul(ah8, bl9)) | 0;\n hi = (hi + Math.imul(ah8, bh9)) | 0;\n var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0;\n w17 &= 0x3ffffff;\n /* k = 18 */\n lo = Math.imul(al9, bl9);\n mid = Math.imul(al9, bh9);\n mid = (mid + Math.imul(ah9, bl9)) | 0;\n hi = Math.imul(ah9, bh9);\n var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0;\n w18 &= 0x3ffffff;\n o[0] = w0;\n o[1] = w1;\n o[2] = w2;\n o[3] = w3;\n o[4] = w4;\n o[5] = w5;\n o[6] = w6;\n o[7] = w7;\n o[8] = w8;\n o[9] = w9;\n o[10] = w10;\n o[11] = w11;\n o[12] = w12;\n o[13] = w13;\n o[14] = w14;\n o[15] = w15;\n o[16] = w16;\n o[17] = w17;\n o[18] = w18;\n if (c !== 0) {\n o[19] = c;\n out.length++;\n }\n return out;\n };\n\n // Polyfill comb\n if (!Math.imul) {\n comb10MulTo = smallMulTo;\n }\n\n function bigMulTo (self, num, out) {\n out.negative = num.negative ^ self.negative;\n out.length = self.length + num.length;\n\n var carry = 0;\n var hncarry = 0;\n for (var k = 0; k < out.length - 1; k++) {\n // Sum all words with the same `i + j = k` and accumulate `ncarry`,\n // note that ncarry could be >= 0x3ffffff\n var ncarry = hncarry;\n hncarry = 0;\n var rword = carry & 0x3ffffff;\n var maxJ = Math.min(k, num.length - 1);\n for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {\n var i = k - j;\n var a = self.words[i] | 0;\n var b = num.words[j] | 0;\n var r = a * b;\n\n var lo = r & 0x3ffffff;\n ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;\n lo = (lo + rword) | 0;\n rword = lo & 0x3ffffff;\n ncarry = (ncarry + (lo >>> 26)) | 0;\n\n hncarry += ncarry >>> 26;\n ncarry &= 0x3ffffff;\n }\n out.words[k] = rword;\n carry = ncarry;\n ncarry = hncarry;\n }\n if (carry !== 0) {\n out.words[k] = carry;\n } else {\n out.length--;\n }\n\n return out._strip();\n }\n\n function jumboMulTo (self, num, out) {\n // Temporary disable, see https://github.com/indutny/bn.js/issues/211\n // var fftm = new FFTM();\n // return fftm.mulp(self, num, out);\n return bigMulTo(self, num, out);\n }\n\n BN.prototype.mulTo = function mulTo (num, out) {\n var res;\n var len = this.length + num.length;\n if (this.length === 10 && num.length === 10) {\n res = comb10MulTo(this, num, out);\n } else if (len < 63) {\n res = smallMulTo(this, num, out);\n } else if (len < 1024) {\n res = bigMulTo(this, num, out);\n } else {\n res = jumboMulTo(this, num, out);\n }\n\n return res;\n };\n\n // Cooley-Tukey algorithm for FFT\n // slightly revisited to rely on looping instead of recursion\n\n function FFTM (x, y) {\n this.x = x;\n this.y = y;\n }\n\n FFTM.prototype.makeRBT = function makeRBT (N) {\n var t = new Array(N);\n var l = BN.prototype._countBits(N) - 1;\n for (var i = 0; i < N; i++) {\n t[i] = this.revBin(i, l, N);\n }\n\n return t;\n };\n\n // Returns binary-reversed representation of `x`\n FFTM.prototype.revBin = function revBin (x, l, N) {\n if (x === 0 || x === N - 1) return x;\n\n var rb = 0;\n for (var i = 0; i < l; i++) {\n rb |= (x & 1) << (l - i - 1);\n x >>= 1;\n }\n\n return rb;\n };\n\n // Performs \"tweedling\" phase, therefore 'emulating'\n // behaviour of the recursive algorithm\n FFTM.prototype.permute = function permute (rbt, rws, iws, rtws, itws, N) {\n for (var i = 0; i < N; i++) {\n rtws[i] = rws[rbt[i]];\n itws[i] = iws[rbt[i]];\n }\n };\n\n FFTM.prototype.transform = function transform (rws, iws, rtws, itws, N, rbt) {\n this.permute(rbt, rws, iws, rtws, itws, N);\n\n for (var s = 1; s < N; s <<= 1) {\n var l = s << 1;\n\n var rtwdf = Math.cos(2 * Math.PI / l);\n var itwdf = Math.sin(2 * Math.PI / l);\n\n for (var p = 0; p < N; p += l) {\n var rtwdf_ = rtwdf;\n var itwdf_ = itwdf;\n\n for (var j = 0; j < s; j++) {\n var re = rtws[p + j];\n var ie = itws[p + j];\n\n var ro = rtws[p + j + s];\n var io = itws[p + j + s];\n\n var rx = rtwdf_ * ro - itwdf_ * io;\n\n io = rtwdf_ * io + itwdf_ * ro;\n ro = rx;\n\n rtws[p + j] = re + ro;\n itws[p + j] = ie + io;\n\n rtws[p + j + s] = re - ro;\n itws[p + j + s] = ie - io;\n\n /* jshint maxdepth : false */\n if (j !== l) {\n rx = rtwdf * rtwdf_ - itwdf * itwdf_;\n\n itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;\n rtwdf_ = rx;\n }\n }\n }\n }\n };\n\n FFTM.prototype.guessLen13b = function guessLen13b (n, m) {\n var N = Math.max(m, n) | 1;\n var odd = N & 1;\n var i = 0;\n for (N = N / 2 | 0; N; N = N >>> 1) {\n i++;\n }\n\n return 1 << i + 1 + odd;\n };\n\n FFTM.prototype.conjugate = function conjugate (rws, iws, N) {\n if (N <= 1) return;\n\n for (var i = 0; i < N / 2; i++) {\n var t = rws[i];\n\n rws[i] = rws[N - i - 1];\n rws[N - i - 1] = t;\n\n t = iws[i];\n\n iws[i] = -iws[N - i - 1];\n iws[N - i - 1] = -t;\n }\n };\n\n FFTM.prototype.normalize13b = function normalize13b (ws, N) {\n var carry = 0;\n for (var i = 0; i < N / 2; i++) {\n var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +\n Math.round(ws[2 * i] / N) +\n carry;\n\n ws[i] = w & 0x3ffffff;\n\n if (w < 0x4000000) {\n carry = 0;\n } else {\n carry = w / 0x4000000 | 0;\n }\n }\n\n return ws;\n };\n\n FFTM.prototype.convert13b = function convert13b (ws, len, rws, N) {\n var carry = 0;\n for (var i = 0; i < len; i++) {\n carry = carry + (ws[i] | 0);\n\n rws[2 * i] = carry & 0x1fff; carry = carry >>> 13;\n rws[2 * i + 1] = carry & 0x1fff; carry = carry >>> 13;\n }\n\n // Pad with zeroes\n for (i = 2 * len; i < N; ++i) {\n rws[i] = 0;\n }\n\n assert(carry === 0);\n assert((carry & ~0x1fff) === 0);\n };\n\n FFTM.prototype.stub = function stub (N) {\n var ph = new Array(N);\n for (var i = 0; i < N; i++) {\n ph[i] = 0;\n }\n\n return ph;\n };\n\n FFTM.prototype.mulp = function mulp (x, y, out) {\n var N = 2 * this.guessLen13b(x.length, y.length);\n\n var rbt = this.makeRBT(N);\n\n var _ = this.stub(N);\n\n var rws = new Array(N);\n var rwst = new Array(N);\n var iwst = new Array(N);\n\n var nrws = new Array(N);\n var nrwst = new Array(N);\n var niwst = new Array(N);\n\n var rmws = out.words;\n rmws.length = N;\n\n this.convert13b(x.words, x.length, rws, N);\n this.convert13b(y.words, y.length, nrws, N);\n\n this.transform(rws, _, rwst, iwst, N, rbt);\n this.transform(nrws, _, nrwst, niwst, N, rbt);\n\n for (var i = 0; i < N; i++) {\n var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];\n iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];\n rwst[i] = rx;\n }\n\n this.conjugate(rwst, iwst, N);\n this.transform(rwst, iwst, rmws, _, N, rbt);\n this.conjugate(rmws, _, N);\n this.normalize13b(rmws, N);\n\n out.negative = x.negative ^ y.negative;\n out.length = x.length + y.length;\n return out._strip();\n };\n\n // Multiply `this` by `num`\n BN.prototype.mul = function mul (num) {\n var out = new BN(null);\n out.words = new Array(this.length + num.length);\n return this.mulTo(num, out);\n };\n\n // Multiply employing FFT\n BN.prototype.mulf = function mulf (num) {\n var out = new BN(null);\n out.words = new Array(this.length + num.length);\n return jumboMulTo(this, num, out);\n };\n\n // In-place Multiplication\n BN.prototype.imul = function imul (num) {\n return this.clone().mulTo(num, this);\n };\n\n BN.prototype.imuln = function imuln (num) {\n var isNegNum = num < 0;\n if (isNegNum) num = -num;\n\n assert(typeof num === 'number');\n assert(num < 0x4000000);\n\n // Carry\n var carry = 0;\n for (var i = 0; i < this.length; i++) {\n var w = (this.words[i] | 0) * num;\n var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);\n carry >>= 26;\n carry += (w / 0x4000000) | 0;\n // NOTE: lo is 27bit maximum\n carry += lo >>> 26;\n this.words[i] = lo & 0x3ffffff;\n }\n\n if (carry !== 0) {\n this.words[i] = carry;\n this.length++;\n }\n\n return isNegNum ? this.ineg() : this;\n };\n\n BN.prototype.muln = function muln (num) {\n return this.clone().imuln(num);\n };\n\n // `this` * `this`\n BN.prototype.sqr = function sqr () {\n return this.mul(this);\n };\n\n // `this` * `this` in-place\n BN.prototype.isqr = function isqr () {\n return this.imul(this.clone());\n };\n\n // Math.pow(`this`, `num`)\n BN.prototype.pow = function pow (num) {\n var w = toBitArray(num);\n if (w.length === 0) return new BN(1);\n\n // Skip leading zeroes\n var res = this;\n for (var i = 0; i < w.length; i++, res = res.sqr()) {\n if (w[i] !== 0) break;\n }\n\n if (++i < w.length) {\n for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {\n if (w[i] === 0) continue;\n\n res = res.mul(q);\n }\n }\n\n return res;\n };\n\n // Shift-left in-place\n BN.prototype.iushln = function iushln (bits) {\n assert(typeof bits === 'number' && bits >= 0);\n var r = bits % 26;\n var s = (bits - r) / 26;\n var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);\n var i;\n\n if (r !== 0) {\n var carry = 0;\n\n for (i = 0; i < this.length; i++) {\n var newCarry = this.words[i] & carryMask;\n var c = ((this.words[i] | 0) - newCarry) << r;\n this.words[i] = c | carry;\n carry = newCarry >>> (26 - r);\n }\n\n if (carry) {\n this.words[i] = carry;\n this.length++;\n }\n }\n\n if (s !== 0) {\n for (i = this.length - 1; i >= 0; i--) {\n this.words[i + s] = this.words[i];\n }\n\n for (i = 0; i < s; i++) {\n this.words[i] = 0;\n }\n\n this.length += s;\n }\n\n return this._strip();\n };\n\n BN.prototype.ishln = function ishln (bits) {\n // TODO(indutny): implement me\n assert(this.negative === 0);\n return this.iushln(bits);\n };\n\n // Shift-right in-place\n // NOTE: `hint` is a lowest bit before trailing zeroes\n // NOTE: if `extended` is present - it will be filled with destroyed bits\n BN.prototype.iushrn = function iushrn (bits, hint, extended) {\n assert(typeof bits === 'number' && bits >= 0);\n var h;\n if (hint) {\n h = (hint - (hint % 26)) / 26;\n } else {\n h = 0;\n }\n\n var r = bits % 26;\n var s = Math.min((bits - r) / 26, this.length);\n var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);\n var maskedWords = extended;\n\n h -= s;\n h = Math.max(0, h);\n\n // Extended mode, copy masked part\n if (maskedWords) {\n for (var i = 0; i < s; i++) {\n maskedWords.words[i] = this.words[i];\n }\n maskedWords.length = s;\n }\n\n if (s === 0) {\n // No-op, we should not move anything at all\n } else if (this.length > s) {\n this.length -= s;\n for (i = 0; i < this.length; i++) {\n this.words[i] = this.words[i + s];\n }\n } else {\n this.words[0] = 0;\n this.length = 1;\n }\n\n var carry = 0;\n for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {\n var word = this.words[i] | 0;\n this.words[i] = (carry << (26 - r)) | (word >>> r);\n carry = word & mask;\n }\n\n // Push carried bits as a mask\n if (maskedWords && carry !== 0) {\n maskedWords.words[maskedWords.length++] = carry;\n }\n\n if (this.length === 0) {\n this.words[0] = 0;\n this.length = 1;\n }\n\n return this._strip();\n };\n\n BN.prototype.ishrn = function ishrn (bits, hint, extended) {\n // TODO(indutny): implement me\n assert(this.negative === 0);\n return this.iushrn(bits, hint, extended);\n };\n\n // Shift-left\n BN.prototype.shln = function shln (bits) {\n return this.clone().ishln(bits);\n };\n\n BN.prototype.ushln = function ushln (bits) {\n return this.clone().iushln(bits);\n };\n\n // Shift-right\n BN.prototype.shrn = function shrn (bits) {\n return this.clone().ishrn(bits);\n };\n\n BN.prototype.ushrn = function ushrn (bits) {\n return this.clone().iushrn(bits);\n };\n\n // Test if n bit is set\n BN.prototype.testn = function testn (bit) {\n assert(typeof bit === 'number' && bit >= 0);\n var r = bit % 26;\n var s = (bit - r) / 26;\n var q = 1 << r;\n\n // Fast case: bit is much higher than all existing words\n if (this.length <= s) return false;\n\n // Check bit and return\n var w = this.words[s];\n\n return !!(w & q);\n };\n\n // Return only lowers bits of number (in-place)\n BN.prototype.imaskn = function imaskn (bits) {\n assert(typeof bits === 'number' && bits >= 0);\n var r = bits % 26;\n var s = (bits - r) / 26;\n\n assert(this.negative === 0, 'imaskn works only with positive numbers');\n\n if (this.length <= s) {\n return this;\n }\n\n if (r !== 0) {\n s++;\n }\n this.length = Math.min(s, this.length);\n\n if (r !== 0) {\n var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);\n this.words[this.length - 1] &= mask;\n }\n\n return this._strip();\n };\n\n // Return only lowers bits of number\n BN.prototype.maskn = function maskn (bits) {\n return this.clone().imaskn(bits);\n };\n\n // Add plain number `num` to `this`\n BN.prototype.iaddn = function iaddn (num) {\n assert(typeof num === 'number');\n assert(num < 0x4000000);\n if (num < 0) return this.isubn(-num);\n\n // Possible sign change\n if (this.negative !== 0) {\n if (this.length === 1 && (this.words[0] | 0) <= num) {\n this.words[0] = num - (this.words[0] | 0);\n this.negative = 0;\n return this;\n }\n\n this.negative = 0;\n this.isubn(num);\n this.negative = 1;\n return this;\n }\n\n // Add without checks\n return this._iaddn(num);\n };\n\n BN.prototype._iaddn = function _iaddn (num) {\n this.words[0] += num;\n\n // Carry\n for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {\n this.words[i] -= 0x4000000;\n if (i === this.length - 1) {\n this.words[i + 1] = 1;\n } else {\n this.words[i + 1]++;\n }\n }\n this.length = Math.max(this.length, i + 1);\n\n return this;\n };\n\n // Subtract plain number `num` from `this`\n BN.prototype.isubn = function isubn (num) {\n assert(typeof num === 'number');\n assert(num < 0x4000000);\n if (num < 0) return this.iaddn(-num);\n\n if (this.negative !== 0) {\n this.negative = 0;\n this.iaddn(num);\n this.negative = 1;\n return this;\n }\n\n this.words[0] -= num;\n\n if (this.length === 1 && this.words[0] < 0) {\n this.words[0] = -this.words[0];\n this.negative = 1;\n } else {\n // Carry\n for (var i = 0; i < this.length && this.words[i] < 0; i++) {\n this.words[i] += 0x4000000;\n this.words[i + 1] -= 1;\n }\n }\n\n return this._strip();\n };\n\n BN.prototype.addn = function addn (num) {\n return this.clone().iaddn(num);\n };\n\n BN.prototype.subn = function subn (num) {\n return this.clone().isubn(num);\n };\n\n BN.prototype.iabs = function iabs () {\n this.negative = 0;\n\n return this;\n };\n\n BN.prototype.abs = function abs () {\n return this.clone().iabs();\n };\n\n BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) {\n var len = num.length + shift;\n var i;\n\n this._expand(len);\n\n var w;\n var carry = 0;\n for (i = 0; i < num.length; i++) {\n w = (this.words[i + shift] | 0) + carry;\n var right = (num.words[i] | 0) * mul;\n w -= right & 0x3ffffff;\n carry = (w >> 26) - ((right / 0x4000000) | 0);\n this.words[i + shift] = w & 0x3ffffff;\n }\n for (; i < this.length - shift; i++) {\n w = (this.words[i + shift] | 0) + carry;\n carry = w >> 26;\n this.words[i + shift] = w & 0x3ffffff;\n }\n\n if (carry === 0) return this._strip();\n\n // Subtraction overflow\n assert(carry === -1);\n carry = 0;\n for (i = 0; i < this.length; i++) {\n w = -(this.words[i] | 0) + carry;\n carry = w >> 26;\n this.words[i] = w & 0x3ffffff;\n }\n this.negative = 1;\n\n return this._strip();\n };\n\n BN.prototype._wordDiv = function _wordDiv (num, mode) {\n var shift = this.length - num.length;\n\n var a = this.clone();\n var b = num;\n\n // Normalize\n var bhi = b.words[b.length - 1] | 0;\n var bhiBits = this._countBits(bhi);\n shift = 26 - bhiBits;\n if (shift !== 0) {\n b = b.ushln(shift);\n a.iushln(shift);\n bhi = b.words[b.length - 1] | 0;\n }\n\n // Initialize quotient\n var m = a.length - b.length;\n var q;\n\n if (mode !== 'mod') {\n q = new BN(null);\n q.length = m + 1;\n q.words = new Array(q.length);\n for (var i = 0; i < q.length; i++) {\n q.words[i] = 0;\n }\n }\n\n var diff = a.clone()._ishlnsubmul(b, 1, m);\n if (diff.negative === 0) {\n a = diff;\n if (q) {\n q.words[m] = 1;\n }\n }\n\n for (var j = m - 1; j >= 0; j--) {\n var qj = (a.words[b.length + j] | 0) * 0x4000000 +\n (a.words[b.length + j - 1] | 0);\n\n // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max\n // (0x7ffffff)\n qj = Math.min((qj / bhi) | 0, 0x3ffffff);\n\n a._ishlnsubmul(b, qj, j);\n while (a.negative !== 0) {\n qj--;\n a.negative = 0;\n a._ishlnsubmul(b, 1, j);\n if (!a.isZero()) {\n a.negative ^= 1;\n }\n }\n if (q) {\n q.words[j] = qj;\n }\n }\n if (q) {\n q._strip();\n }\n a._strip();\n\n // Denormalize\n if (mode !== 'div' && shift !== 0) {\n a.iushrn(shift);\n }\n\n return {\n div: q || null,\n mod: a\n };\n };\n\n // NOTE: 1) `mode` can be set to `mod` to request mod only,\n // to `div` to request div only, or be absent to\n // request both div & mod\n // 2) `positive` is true if unsigned mod is requested\n BN.prototype.divmod = function divmod (num, mode, positive) {\n assert(!num.isZero());\n\n if (this.isZero()) {\n return {\n div: new BN(0),\n mod: new BN(0)\n };\n }\n\n var div, mod, res;\n if (this.negative !== 0 && num.negative === 0) {\n res = this.neg().divmod(num, mode);\n\n if (mode !== 'mod') {\n div = res.div.neg();\n }\n\n if (mode !== 'div') {\n mod = res.mod.neg();\n if (positive && mod.negative !== 0) {\n mod.iadd(num);\n }\n }\n\n return {\n div: div,\n mod: mod\n };\n }\n\n if (this.negative === 0 && num.negative !== 0) {\n res = this.divmod(num.neg(), mode);\n\n if (mode !== 'mod') {\n div = res.div.neg();\n }\n\n return {\n div: div,\n mod: res.mod\n };\n }\n\n if ((this.negative & num.negative) !== 0) {\n res = this.neg().divmod(num.neg(), mode);\n\n if (mode !== 'div') {\n mod = res.mod.neg();\n if (positive && mod.negative !== 0) {\n mod.isub(num);\n }\n }\n\n return {\n div: res.div,\n mod: mod\n };\n }\n\n // Both numbers are positive at this point\n\n // Strip both numbers to approximate shift value\n if (num.length > this.length || this.cmp(num) < 0) {\n return {\n div: new BN(0),\n mod: this\n };\n }\n\n // Very short reduction\n if (num.length === 1) {\n if (mode === 'div') {\n return {\n div: this.divn(num.words[0]),\n mod: null\n };\n }\n\n if (mode === 'mod') {\n return {\n div: null,\n mod: new BN(this.modrn(num.words[0]))\n };\n }\n\n return {\n div: this.divn(num.words[0]),\n mod: new BN(this.modrn(num.words[0]))\n };\n }\n\n return this._wordDiv(num, mode);\n };\n\n // Find `this` / `num`\n BN.prototype.div = function div (num) {\n return this.divmod(num, 'div', false).div;\n };\n\n // Find `this` % `num`\n BN.prototype.mod = function mod (num) {\n return this.divmod(num, 'mod', false).mod;\n };\n\n BN.prototype.umod = function umod (num) {\n return this.divmod(num, 'mod', true).mod;\n };\n\n // Find Round(`this` / `num`)\n BN.prototype.divRound = function divRound (num) {\n var dm = this.divmod(num);\n\n // Fast case - exact division\n if (dm.mod.isZero()) return dm.div;\n\n var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;\n\n var half = num.ushrn(1);\n var r2 = num.andln(1);\n var cmp = mod.cmp(half);\n\n // Round down\n if (cmp < 0 || (r2 === 1 && cmp === 0)) return dm.div;\n\n // Round up\n return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);\n };\n\n BN.prototype.modrn = function modrn (num) {\n var isNegNum = num < 0;\n if (isNegNum) num = -num;\n\n assert(num <= 0x3ffffff);\n var p = (1 << 26) % num;\n\n var acc = 0;\n for (var i = this.length - 1; i >= 0; i--) {\n acc = (p * acc + (this.words[i] | 0)) % num;\n }\n\n return isNegNum ? -acc : acc;\n };\n\n // WARNING: DEPRECATED\n BN.prototype.modn = function modn (num) {\n return this.modrn(num);\n };\n\n // In-place division by number\n BN.prototype.idivn = function idivn (num) {\n var isNegNum = num < 0;\n if (isNegNum) num = -num;\n\n assert(num <= 0x3ffffff);\n\n var carry = 0;\n for (var i = this.length - 1; i >= 0; i--) {\n var w = (this.words[i] | 0) + carry * 0x4000000;\n this.words[i] = (w / num) | 0;\n carry = w % num;\n }\n\n this._strip();\n return isNegNum ? this.ineg() : this;\n };\n\n BN.prototype.divn = function divn (num) {\n return this.clone().idivn(num);\n };\n\n BN.prototype.egcd = function egcd (p) {\n assert(p.negative === 0);\n assert(!p.isZero());\n\n var x = this;\n var y = p.clone();\n\n if (x.negative !== 0) {\n x = x.umod(p);\n } else {\n x = x.clone();\n }\n\n // A * x + B * y = x\n var A = new BN(1);\n var B = new BN(0);\n\n // C * x + D * y = y\n var C = new BN(0);\n var D = new BN(1);\n\n var g = 0;\n\n while (x.isEven() && y.isEven()) {\n x.iushrn(1);\n y.iushrn(1);\n ++g;\n }\n\n var yp = y.clone();\n var xp = x.clone();\n\n while (!x.isZero()) {\n for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);\n if (i > 0) {\n x.iushrn(i);\n while (i-- > 0) {\n if (A.isOdd() || B.isOdd()) {\n A.iadd(yp);\n B.isub(xp);\n }\n\n A.iushrn(1);\n B.iushrn(1);\n }\n }\n\n for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);\n if (j > 0) {\n y.iushrn(j);\n while (j-- > 0) {\n if (C.isOdd() || D.isOdd()) {\n C.iadd(yp);\n D.isub(xp);\n }\n\n C.iushrn(1);\n D.iushrn(1);\n }\n }\n\n if (x.cmp(y) >= 0) {\n x.isub(y);\n A.isub(C);\n B.isub(D);\n } else {\n y.isub(x);\n C.isub(A);\n D.isub(B);\n }\n }\n\n return {\n a: C,\n b: D,\n gcd: y.iushln(g)\n };\n };\n\n // This is reduced incarnation of the binary EEA\n // above, designated to invert members of the\n // _prime_ fields F(p) at a maximal speed\n BN.prototype._invmp = function _invmp (p) {\n assert(p.negative === 0);\n assert(!p.isZero());\n\n var a = this;\n var b = p.clone();\n\n if (a.negative !== 0) {\n a = a.umod(p);\n } else {\n a = a.clone();\n }\n\n var x1 = new BN(1);\n var x2 = new BN(0);\n\n var delta = b.clone();\n\n while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {\n for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);\n if (i > 0) {\n a.iushrn(i);\n while (i-- > 0) {\n if (x1.isOdd()) {\n x1.iadd(delta);\n }\n\n x1.iushrn(1);\n }\n }\n\n for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);\n if (j > 0) {\n b.iushrn(j);\n while (j-- > 0) {\n if (x2.isOdd()) {\n x2.iadd(delta);\n }\n\n x2.iushrn(1);\n }\n }\n\n if (a.cmp(b) >= 0) {\n a.isub(b);\n x1.isub(x2);\n } else {\n b.isub(a);\n x2.isub(x1);\n }\n }\n\n var res;\n if (a.cmpn(1) === 0) {\n res = x1;\n } else {\n res = x2;\n }\n\n if (res.cmpn(0) < 0) {\n res.iadd(p);\n }\n\n return res;\n };\n\n BN.prototype.gcd = function gcd (num) {\n if (this.isZero()) return num.abs();\n if (num.isZero()) return this.abs();\n\n var a = this.clone();\n var b = num.clone();\n a.negative = 0;\n b.negative = 0;\n\n // Remove common factor of two\n for (var shift = 0; a.isEven() && b.isEven(); shift++) {\n a.iushrn(1);\n b.iushrn(1);\n }\n\n do {\n while (a.isEven()) {\n a.iushrn(1);\n }\n while (b.isEven()) {\n b.iushrn(1);\n }\n\n var r = a.cmp(b);\n if (r < 0) {\n // Swap `a` and `b` to make `a` always bigger than `b`\n var t = a;\n a = b;\n b = t;\n } else if (r === 0 || b.cmpn(1) === 0) {\n break;\n }\n\n a.isub(b);\n } while (true);\n\n return b.iushln(shift);\n };\n\n // Invert number in the field F(num)\n BN.prototype.invm = function invm (num) {\n return this.egcd(num).a.umod(num);\n };\n\n BN.prototype.isEven = function isEven () {\n return (this.words[0] & 1) === 0;\n };\n\n BN.prototype.isOdd = function isOdd () {\n return (this.words[0] & 1) === 1;\n };\n\n // And first word and num\n BN.prototype.andln = function andln (num) {\n return this.words[0] & num;\n };\n\n // Increment at the bit position in-line\n BN.prototype.bincn = function bincn (bit) {\n assert(typeof bit === 'number');\n var r = bit % 26;\n var s = (bit - r) / 26;\n var q = 1 << r;\n\n // Fast case: bit is much higher than all existing words\n if (this.length <= s) {\n this._expand(s + 1);\n this.words[s] |= q;\n return this;\n }\n\n // Add bit and propagate, if needed\n var carry = q;\n for (var i = s; carry !== 0 && i < this.length; i++) {\n var w = this.words[i] | 0;\n w += carry;\n carry = w >>> 26;\n w &= 0x3ffffff;\n this.words[i] = w;\n }\n if (carry !== 0) {\n this.words[i] = carry;\n this.length++;\n }\n return this;\n };\n\n BN.prototype.isZero = function isZero () {\n return this.length === 1 && this.words[0] === 0;\n };\n\n BN.prototype.cmpn = function cmpn (num) {\n var negative = num < 0;\n\n if (this.negative !== 0 && !negative) return -1;\n if (this.negative === 0 && negative) return 1;\n\n this._strip();\n\n var res;\n if (this.length > 1) {\n res = 1;\n } else {\n if (negative) {\n num = -num;\n }\n\n assert(num <= 0x3ffffff, 'Number is too big');\n\n var w = this.words[0] | 0;\n res = w === num ? 0 : w < num ? -1 : 1;\n }\n if (this.negative !== 0) return -res | 0;\n return res;\n };\n\n // Compare two numbers and return:\n // 1 - if `this` > `num`\n // 0 - if `this` == `num`\n // -1 - if `this` < `num`\n BN.prototype.cmp = function cmp (num) {\n if (this.negative !== 0 && num.negative === 0) return -1;\n if (this.negative === 0 && num.negative !== 0) return 1;\n\n var res = this.ucmp(num);\n if (this.negative !== 0) return -res | 0;\n return res;\n };\n\n // Unsigned comparison\n BN.prototype.ucmp = function ucmp (num) {\n // At this point both numbers have the same sign\n if (this.length > num.length) return 1;\n if (this.length < num.length) return -1;\n\n var res = 0;\n for (var i = this.length - 1; i >= 0; i--) {\n var a = this.words[i] | 0;\n var b = num.words[i] | 0;\n\n if (a === b) continue;\n if (a < b) {\n res = -1;\n } else if (a > b) {\n res = 1;\n }\n break;\n }\n return res;\n };\n\n BN.prototype.gtn = function gtn (num) {\n return this.cmpn(num) === 1;\n };\n\n BN.prototype.gt = function gt (num) {\n return this.cmp(num) === 1;\n };\n\n BN.prototype.gten = function gten (num) {\n return this.cmpn(num) >= 0;\n };\n\n BN.prototype.gte = function gte (num) {\n return this.cmp(num) >= 0;\n };\n\n BN.prototype.ltn = function ltn (num) {\n return this.cmpn(num) === -1;\n };\n\n BN.prototype.lt = function lt (num) {\n return this.cmp(num) === -1;\n };\n\n BN.prototype.lten = function lten (num) {\n return this.cmpn(num) <= 0;\n };\n\n BN.prototype.lte = function lte (num) {\n return this.cmp(num) <= 0;\n };\n\n BN.prototype.eqn = function eqn (num) {\n return this.cmpn(num) === 0;\n };\n\n BN.prototype.eq = function eq (num) {\n return this.cmp(num) === 0;\n };\n\n //\n // A reduce context, could be using montgomery or something better, depending\n // on the `m` itself.\n //\n BN.red = function red (num) {\n return new Red(num);\n };\n\n BN.prototype.toRed = function toRed (ctx) {\n assert(!this.red, 'Already a number in reduction context');\n assert(this.negative === 0, 'red works only with positives');\n return ctx.convertTo(this)._forceRed(ctx);\n };\n\n BN.prototype.fromRed = function fromRed () {\n assert(this.red, 'fromRed works only with numbers in reduction context');\n return this.red.convertFrom(this);\n };\n\n BN.prototype._forceRed = function _forceRed (ctx) {\n this.red = ctx;\n return this;\n };\n\n BN.prototype.forceRed = function forceRed (ctx) {\n assert(!this.red, 'Already a number in reduction context');\n return this._forceRed(ctx);\n };\n\n BN.prototype.redAdd = function redAdd (num) {\n assert(this.red, 'redAdd works only with red numbers');\n return this.red.add(this, num);\n };\n\n BN.prototype.redIAdd = function redIAdd (num) {\n assert(this.red, 'redIAdd works only with red numbers');\n return this.red.iadd(this, num);\n };\n\n BN.prototype.redSub = function redSub (num) {\n assert(this.red, 'redSub works only with red numbers');\n return this.red.sub(this, num);\n };\n\n BN.prototype.redISub = function redISub (num) {\n assert(this.red, 'redISub works only with red numbers');\n return this.red.isub(this, num);\n };\n\n BN.prototype.redShl = function redShl (num) {\n assert(this.red, 'redShl works only with red numbers');\n return this.red.shl(this, num);\n };\n\n BN.prototype.redMul = function redMul (num) {\n assert(this.red, 'redMul works only with red numbers');\n this.red._verify2(this, num);\n return this.red.mul(this, num);\n };\n\n BN.prototype.redIMul = function redIMul (num) {\n assert(this.red, 'redMul works only with red numbers');\n this.red._verify2(this, num);\n return this.red.imul(this, num);\n };\n\n BN.prototype.redSqr = function redSqr () {\n assert(this.red, 'redSqr works only with red numbers');\n this.red._verify1(this);\n return this.red.sqr(this);\n };\n\n BN.prototype.redISqr = function redISqr () {\n assert(this.red, 'redISqr works only with red numbers');\n this.red._verify1(this);\n return this.red.isqr(this);\n };\n\n // Square root over p\n BN.prototype.redSqrt = function redSqrt () {\n assert(this.red, 'redSqrt works only with red numbers');\n this.red._verify1(this);\n return this.red.sqrt(this);\n };\n\n BN.prototype.redInvm = function redInvm () {\n assert(this.red, 'redInvm works only with red numbers');\n this.red._verify1(this);\n return this.red.invm(this);\n };\n\n // Return negative clone of `this` % `red modulo`\n BN.prototype.redNeg = function redNeg () {\n assert(this.red, 'redNeg works only with red numbers');\n this.red._verify1(this);\n return this.red.neg(this);\n };\n\n BN.prototype.redPow = function redPow (num) {\n assert(this.red && !num.red, 'redPow(normalNum)');\n this.red._verify1(this);\n return this.red.pow(this, num);\n };\n\n // Prime numbers with efficient reduction\n var primes = {\n k256: null,\n p224: null,\n p192: null,\n p25519: null\n };\n\n // Pseudo-Mersenne prime\n function MPrime (name, p) {\n // P = 2 ^ N - K\n this.name = name;\n this.p = new BN(p, 16);\n this.n = this.p.bitLength();\n this.k = new BN(1).iushln(this.n).isub(this.p);\n\n this.tmp = this._tmp();\n }\n\n MPrime.prototype._tmp = function _tmp () {\n var tmp = new BN(null);\n tmp.words = new Array(Math.ceil(this.n / 13));\n return tmp;\n };\n\n MPrime.prototype.ireduce = function ireduce (num) {\n // Assumes that `num` is less than `P^2`\n // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)\n var r = num;\n var rlen;\n\n do {\n this.split(r, this.tmp);\n r = this.imulK(r);\n r = r.iadd(this.tmp);\n rlen = r.bitLength();\n } while (rlen > this.n);\n\n var cmp = rlen < this.n ? -1 : r.ucmp(this.p);\n if (cmp === 0) {\n r.words[0] = 0;\n r.length = 1;\n } else if (cmp > 0) {\n r.isub(this.p);\n } else {\n if (r.strip !== undefined) {\n // r is a BN v4 instance\n r.strip();\n } else {\n // r is a BN v5 instance\n r._strip();\n }\n }\n\n return r;\n };\n\n MPrime.prototype.split = function split (input, out) {\n input.iushrn(this.n, 0, out);\n };\n\n MPrime.prototype.imulK = function imulK (num) {\n return num.imul(this.k);\n };\n\n function K256 () {\n MPrime.call(\n this,\n 'k256',\n 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');\n }\n inherits(K256, MPrime);\n\n K256.prototype.split = function split (input, output) {\n // 256 = 9 * 26 + 22\n var mask = 0x3fffff;\n\n var outLen = Math.min(input.length, 9);\n for (var i = 0; i < outLen; i++) {\n output.words[i] = input.words[i];\n }\n output.length = outLen;\n\n if (input.length <= 9) {\n input.words[0] = 0;\n input.length = 1;\n return;\n }\n\n // Shift by 9 limbs\n var prev = input.words[9];\n output.words[output.length++] = prev & mask;\n\n for (i = 10; i < input.length; i++) {\n var next = input.words[i] | 0;\n input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22);\n prev = next;\n }\n prev >>>= 22;\n input.words[i - 10] = prev;\n if (prev === 0 && input.length > 10) {\n input.length -= 10;\n } else {\n input.length -= 9;\n }\n };\n\n K256.prototype.imulK = function imulK (num) {\n // K = 0x1000003d1 = [ 0x40, 0x3d1 ]\n num.words[num.length] = 0;\n num.words[num.length + 1] = 0;\n num.length += 2;\n\n // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390\n var lo = 0;\n for (var i = 0; i < num.length; i++) {\n var w = num.words[i] | 0;\n lo += w * 0x3d1;\n num.words[i] = lo & 0x3ffffff;\n lo = w * 0x40 + ((lo / 0x4000000) | 0);\n }\n\n // Fast length reduction\n if (num.words[num.length - 1] === 0) {\n num.length--;\n if (num.words[num.length - 1] === 0) {\n num.length--;\n }\n }\n return num;\n };\n\n function P224 () {\n MPrime.call(\n this,\n 'p224',\n 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');\n }\n inherits(P224, MPrime);\n\n function P192 () {\n MPrime.call(\n this,\n 'p192',\n 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');\n }\n inherits(P192, MPrime);\n\n function P25519 () {\n // 2 ^ 255 - 19\n MPrime.call(\n this,\n '25519',\n '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');\n }\n inherits(P25519, MPrime);\n\n P25519.prototype.imulK = function imulK (num) {\n // K = 0x13\n var carry = 0;\n for (var i = 0; i < num.length; i++) {\n var hi = (num.words[i] | 0) * 0x13 + carry;\n var lo = hi & 0x3ffffff;\n hi >>>= 26;\n\n num.words[i] = lo;\n carry = hi;\n }\n if (carry !== 0) {\n num.words[num.length++] = carry;\n }\n return num;\n };\n\n // Exported mostly for testing purposes, use plain name instead\n BN._prime = function prime (name) {\n // Cached version of prime\n if (primes[name]) return primes[name];\n\n var prime;\n if (name === 'k256') {\n prime = new K256();\n } else if (name === 'p224') {\n prime = new P224();\n } else if (name === 'p192') {\n prime = new P192();\n } else if (name === 'p25519') {\n prime = new P25519();\n } else {\n throw new Error('Unknown prime ' + name);\n }\n primes[name] = prime;\n\n return prime;\n };\n\n //\n // Base reduction engine\n //\n function Red (m) {\n if (typeof m === 'string') {\n var prime = BN._prime(m);\n this.m = prime.p;\n this.prime = prime;\n } else {\n assert(m.gtn(1), 'modulus must be greater than 1');\n this.m = m;\n this.prime = null;\n }\n }\n\n Red.prototype._verify1 = function _verify1 (a) {\n assert(a.negative === 0, 'red works only with positives');\n assert(a.red, 'red works only with red numbers');\n };\n\n Red.prototype._verify2 = function _verify2 (a, b) {\n assert((a.negative | b.negative) === 0, 'red works only with positives');\n assert(a.red && a.red === b.red,\n 'red works only with red numbers');\n };\n\n Red.prototype.imod = function imod (a) {\n if (this.prime) return this.prime.ireduce(a)._forceRed(this);\n\n move(a, a.umod(this.m)._forceRed(this));\n return a;\n };\n\n Red.prototype.neg = function neg (a) {\n if (a.isZero()) {\n return a.clone();\n }\n\n return this.m.sub(a)._forceRed(this);\n };\n\n Red.prototype.add = function add (a, b) {\n this._verify2(a, b);\n\n var res = a.add(b);\n if (res.cmp(this.m) >= 0) {\n res.isub(this.m);\n }\n return res._forceRed(this);\n };\n\n Red.prototype.iadd = function iadd (a, b) {\n this._verify2(a, b);\n\n var res = a.iadd(b);\n if (res.cmp(this.m) >= 0) {\n res.isub(this.m);\n }\n return res;\n };\n\n Red.prototype.sub = function sub (a, b) {\n this._verify2(a, b);\n\n var res = a.sub(b);\n if (res.cmpn(0) < 0) {\n res.iadd(this.m);\n }\n return res._forceRed(this);\n };\n\n Red.prototype.isub = function isub (a, b) {\n this._verify2(a, b);\n\n var res = a.isub(b);\n if (res.cmpn(0) < 0) {\n res.iadd(this.m);\n }\n return res;\n };\n\n Red.prototype.shl = function shl (a, num) {\n this._verify1(a);\n return this.imod(a.ushln(num));\n };\n\n Red.prototype.imul = function imul (a, b) {\n this._verify2(a, b);\n return this.imod(a.imul(b));\n };\n\n Red.prototype.mul = function mul (a, b) {\n this._verify2(a, b);\n return this.imod(a.mul(b));\n };\n\n Red.prototype.isqr = function isqr (a) {\n return this.imul(a, a.clone());\n };\n\n Red.prototype.sqr = function sqr (a) {\n return this.mul(a, a);\n };\n\n Red.prototype.sqrt = function sqrt (a) {\n if (a.isZero()) return a.clone();\n\n var mod3 = this.m.andln(3);\n assert(mod3 % 2 === 1);\n\n // Fast case\n if (mod3 === 3) {\n var pow = this.m.add(new BN(1)).iushrn(2);\n return this.pow(a, pow);\n }\n\n // Tonelli-Shanks algorithm (Totally unoptimized and slow)\n //\n // Find Q and S, that Q * 2 ^ S = (P - 1)\n var q = this.m.subn(1);\n var s = 0;\n while (!q.isZero() && q.andln(1) === 0) {\n s++;\n q.iushrn(1);\n }\n assert(!q.isZero());\n\n var one = new BN(1).toRed(this);\n var nOne = one.redNeg();\n\n // Find quadratic non-residue\n // NOTE: Max is such because of generalized Riemann hypothesis.\n var lpow = this.m.subn(1).iushrn(1);\n var z = this.m.bitLength();\n z = new BN(2 * z * z).toRed(this);\n\n while (this.pow(z, lpow).cmp(nOne) !== 0) {\n z.redIAdd(nOne);\n }\n\n var c = this.pow(z, q);\n var r = this.pow(a, q.addn(1).iushrn(1));\n var t = this.pow(a, q);\n var m = s;\n while (t.cmp(one) !== 0) {\n var tmp = t;\n for (var i = 0; tmp.cmp(one) !== 0; i++) {\n tmp = tmp.redSqr();\n }\n assert(i < m);\n var b = this.pow(c, new BN(1).iushln(m - i - 1));\n\n r = r.redMul(b);\n c = b.redSqr();\n t = t.redMul(c);\n m = i;\n }\n\n return r;\n };\n\n Red.prototype.invm = function invm (a) {\n var inv = a._invmp(this.m);\n if (inv.negative !== 0) {\n inv.negative = 0;\n return this.imod(inv).redNeg();\n } else {\n return this.imod(inv);\n }\n };\n\n Red.prototype.pow = function pow (a, num) {\n if (num.isZero()) return new BN(1).toRed(this);\n if (num.cmpn(1) === 0) return a.clone();\n\n var windowSize = 4;\n var wnd = new Array(1 << windowSize);\n wnd[0] = new BN(1).toRed(this);\n wnd[1] = a;\n for (var i = 2; i < wnd.length; i++) {\n wnd[i] = this.mul(wnd[i - 1], a);\n }\n\n var res = wnd[0];\n var current = 0;\n var currentLen = 0;\n var start = num.bitLength() % 26;\n if (start === 0) {\n start = 26;\n }\n\n for (i = num.length - 1; i >= 0; i--) {\n var word = num.words[i];\n for (var j = start - 1; j >= 0; j--) {\n var bit = (word >> j) & 1;\n if (res !== wnd[0]) {\n res = this.sqr(res);\n }\n\n if (bit === 0 && current === 0) {\n currentLen = 0;\n continue;\n }\n\n current <<= 1;\n current |= bit;\n currentLen++;\n if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;\n\n res = this.mul(res, wnd[current]);\n currentLen = 0;\n current = 0;\n }\n start = 26;\n }\n\n return res;\n };\n\n Red.prototype.convertTo = function convertTo (num) {\n var r = num.umod(this.m);\n\n return r === num ? r.clone() : r;\n };\n\n Red.prototype.convertFrom = function convertFrom (num) {\n var res = num.clone();\n res.red = null;\n return res;\n };\n\n //\n // Montgomery method engine\n //\n\n BN.mont = function mont (num) {\n return new Mont(num);\n };\n\n function Mont (m) {\n Red.call(this, m);\n\n this.shift = this.m.bitLength();\n if (this.shift % 26 !== 0) {\n this.shift += 26 - (this.shift % 26);\n }\n\n this.r = new BN(1).iushln(this.shift);\n this.r2 = this.imod(this.r.sqr());\n this.rinv = this.r._invmp(this.m);\n\n this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);\n this.minv = this.minv.umod(this.r);\n this.minv = this.r.sub(this.minv);\n }\n inherits(Mont, Red);\n\n Mont.prototype.convertTo = function convertTo (num) {\n return this.imod(num.ushln(this.shift));\n };\n\n Mont.prototype.convertFrom = function convertFrom (num) {\n var r = this.imod(num.mul(this.rinv));\n r.red = null;\n return r;\n };\n\n Mont.prototype.imul = function imul (a, b) {\n if (a.isZero() || b.isZero()) {\n a.words[0] = 0;\n a.length = 1;\n return a;\n }\n\n var t = a.imul(b);\n var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);\n var u = t.isub(c).iushrn(this.shift);\n var res = u;\n\n if (u.cmp(this.m) >= 0) {\n res = u.isub(this.m);\n } else if (u.cmpn(0) < 0) {\n res = u.iadd(this.m);\n }\n\n return res._forceRed(this);\n };\n\n Mont.prototype.mul = function mul (a, b) {\n if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);\n\n var t = a.mul(b);\n var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);\n var u = t.isub(c).iushrn(this.shift);\n var res = u;\n if (u.cmp(this.m) >= 0) {\n res = u.isub(this.m);\n } else if (u.cmpn(0) < 0) {\n res = u.iadd(this.m);\n }\n\n return res._forceRed(this);\n };\n\n Mont.prototype.invm = function invm (a) {\n // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R\n var res = this.imod(a._invmp(this.m).mul(this.r2));\n return res._forceRed(this);\n };\n})(typeof module === 'undefined' || module, this);\n","var r;\n\nmodule.exports = function rand(len) {\n if (!r)\n r = new Rand(null);\n\n return r.generate(len);\n};\n\nfunction Rand(rand) {\n this.rand = rand;\n}\nmodule.exports.Rand = Rand;\n\nRand.prototype.generate = function generate(len) {\n return this._rand(len);\n};\n\n// Emulate crypto API using randy\nRand.prototype._rand = function _rand(n) {\n if (this.rand.getBytes)\n return this.rand.getBytes(n);\n\n var res = new Uint8Array(n);\n for (var i = 0; i < res.length; i++)\n res[i] = this.rand.getByte();\n return res;\n};\n\nif (typeof self === 'object') {\n if (self.crypto && self.crypto.getRandomValues) {\n // Modern browsers\n Rand.prototype._rand = function _rand(n) {\n var arr = new Uint8Array(n);\n self.crypto.getRandomValues(arr);\n return arr;\n };\n } else if (self.msCrypto && self.msCrypto.getRandomValues) {\n // IE\n Rand.prototype._rand = function _rand(n) {\n var arr = new Uint8Array(n);\n self.msCrypto.getRandomValues(arr);\n return arr;\n };\n\n // Safari's WebWorkers do not have `crypto`\n } else if (typeof window === 'object') {\n // Old junk\n Rand.prototype._rand = function() {\n throw new Error('Not implemented yet');\n };\n }\n} else {\n // Node.js or Web worker with no crypto support\n try {\n var crypto = require('crypto');\n if (typeof crypto.randomBytes !== 'function')\n throw new Error('Not supported');\n\n Rand.prototype._rand = function _rand(n) {\n return crypto.randomBytes(n);\n };\n } catch (e) {\n }\n}\n","// based on the aes implimentation in triple sec\n// https://github.com/keybase/triplesec\n// which is in turn based on the one from crypto-js\n// https://code.google.com/p/crypto-js/\n\nvar Buffer = require('safe-buffer').Buffer\n\nfunction asUInt32Array (buf) {\n if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)\n\n var len = (buf.length / 4) | 0\n var out = new Array(len)\n\n for (var i = 0; i < len; i++) {\n out[i] = buf.readUInt32BE(i * 4)\n }\n\n return out\n}\n\nfunction scrubVec (v) {\n for (var i = 0; i < v.length; v++) {\n v[i] = 0\n }\n}\n\nfunction cryptBlock (M, keySchedule, SUB_MIX, SBOX, nRounds) {\n var SUB_MIX0 = SUB_MIX[0]\n var SUB_MIX1 = SUB_MIX[1]\n var SUB_MIX2 = SUB_MIX[2]\n var SUB_MIX3 = SUB_MIX[3]\n\n var s0 = M[0] ^ keySchedule[0]\n var s1 = M[1] ^ keySchedule[1]\n var s2 = M[2] ^ keySchedule[2]\n var s3 = M[3] ^ keySchedule[3]\n var t0, t1, t2, t3\n var ksRow = 4\n\n for (var round = 1; round < nRounds; round++) {\n t0 = SUB_MIX0[s0 >>> 24] ^ SUB_MIX1[(s1 >>> 16) & 0xff] ^ SUB_MIX2[(s2 >>> 8) & 0xff] ^ SUB_MIX3[s3 & 0xff] ^ keySchedule[ksRow++]\n t1 = SUB_MIX0[s1 >>> 24] ^ SUB_MIX1[(s2 >>> 16) & 0xff] ^ SUB_MIX2[(s3 >>> 8) & 0xff] ^ SUB_MIX3[s0 & 0xff] ^ keySchedule[ksRow++]\n t2 = SUB_MIX0[s2 >>> 24] ^ SUB_MIX1[(s3 >>> 16) & 0xff] ^ SUB_MIX2[(s0 >>> 8) & 0xff] ^ SUB_MIX3[s1 & 0xff] ^ keySchedule[ksRow++]\n t3 = SUB_MIX0[s3 >>> 24] ^ SUB_MIX1[(s0 >>> 16) & 0xff] ^ SUB_MIX2[(s1 >>> 8) & 0xff] ^ SUB_MIX3[s2 & 0xff] ^ keySchedule[ksRow++]\n s0 = t0\n s1 = t1\n s2 = t2\n s3 = t3\n }\n\n t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++]\n t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++]\n t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++]\n t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++]\n t0 = t0 >>> 0\n t1 = t1 >>> 0\n t2 = t2 >>> 0\n t3 = t3 >>> 0\n\n return [t0, t1, t2, t3]\n}\n\n// AES constants\nvar RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36]\nvar G = (function () {\n // Compute double table\n var d = new Array(256)\n for (var j = 0; j < 256; j++) {\n if (j < 128) {\n d[j] = j << 1\n } else {\n d[j] = (j << 1) ^ 0x11b\n }\n }\n\n var SBOX = []\n var INV_SBOX = []\n var SUB_MIX = [[], [], [], []]\n var INV_SUB_MIX = [[], [], [], []]\n\n // Walk GF(2^8)\n var x = 0\n var xi = 0\n for (var i = 0; i < 256; ++i) {\n // Compute sbox\n var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4)\n sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63\n SBOX[x] = sx\n INV_SBOX[sx] = x\n\n // Compute multiplication\n var x2 = d[x]\n var x4 = d[x2]\n var x8 = d[x4]\n\n // Compute sub bytes, mix columns tables\n var t = (d[sx] * 0x101) ^ (sx * 0x1010100)\n SUB_MIX[0][x] = (t << 24) | (t >>> 8)\n SUB_MIX[1][x] = (t << 16) | (t >>> 16)\n SUB_MIX[2][x] = (t << 8) | (t >>> 24)\n SUB_MIX[3][x] = t\n\n // Compute inv sub bytes, inv mix columns tables\n t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100)\n INV_SUB_MIX[0][sx] = (t << 24) | (t >>> 8)\n INV_SUB_MIX[1][sx] = (t << 16) | (t >>> 16)\n INV_SUB_MIX[2][sx] = (t << 8) | (t >>> 24)\n INV_SUB_MIX[3][sx] = t\n\n if (x === 0) {\n x = xi = 1\n } else {\n x = x2 ^ d[d[d[x8 ^ x2]]]\n xi ^= d[d[xi]]\n }\n }\n\n return {\n SBOX: SBOX,\n INV_SBOX: INV_SBOX,\n SUB_MIX: SUB_MIX,\n INV_SUB_MIX: INV_SUB_MIX\n }\n})()\n\nfunction AES (key) {\n this._key = asUInt32Array(key)\n this._reset()\n}\n\nAES.blockSize = 4 * 4\nAES.keySize = 256 / 8\nAES.prototype.blockSize = AES.blockSize\nAES.prototype.keySize = AES.keySize\nAES.prototype._reset = function () {\n var keyWords = this._key\n var keySize = keyWords.length\n var nRounds = keySize + 6\n var ksRows = (nRounds + 1) * 4\n\n var keySchedule = []\n for (var k = 0; k < keySize; k++) {\n keySchedule[k] = keyWords[k]\n }\n\n for (k = keySize; k < ksRows; k++) {\n var t = keySchedule[k - 1]\n\n if (k % keySize === 0) {\n t = (t << 8) | (t >>> 24)\n t =\n (G.SBOX[t >>> 24] << 24) |\n (G.SBOX[(t >>> 16) & 0xff] << 16) |\n (G.SBOX[(t >>> 8) & 0xff] << 8) |\n (G.SBOX[t & 0xff])\n\n t ^= RCON[(k / keySize) | 0] << 24\n } else if (keySize > 6 && k % keySize === 4) {\n t =\n (G.SBOX[t >>> 24] << 24) |\n (G.SBOX[(t >>> 16) & 0xff] << 16) |\n (G.SBOX[(t >>> 8) & 0xff] << 8) |\n (G.SBOX[t & 0xff])\n }\n\n keySchedule[k] = keySchedule[k - keySize] ^ t\n }\n\n var invKeySchedule = []\n for (var ik = 0; ik < ksRows; ik++) {\n var ksR = ksRows - ik\n var tt = keySchedule[ksR - (ik % 4 ? 0 : 4)]\n\n if (ik < 4 || ksR <= 4) {\n invKeySchedule[ik] = tt\n } else {\n invKeySchedule[ik] =\n G.INV_SUB_MIX[0][G.SBOX[tt >>> 24]] ^\n G.INV_SUB_MIX[1][G.SBOX[(tt >>> 16) & 0xff]] ^\n G.INV_SUB_MIX[2][G.SBOX[(tt >>> 8) & 0xff]] ^\n G.INV_SUB_MIX[3][G.SBOX[tt & 0xff]]\n }\n }\n\n this._nRounds = nRounds\n this._keySchedule = keySchedule\n this._invKeySchedule = invKeySchedule\n}\n\nAES.prototype.encryptBlockRaw = function (M) {\n M = asUInt32Array(M)\n return cryptBlock(M, this._keySchedule, G.SUB_MIX, G.SBOX, this._nRounds)\n}\n\nAES.prototype.encryptBlock = function (M) {\n var out = this.encryptBlockRaw(M)\n var buf = Buffer.allocUnsafe(16)\n buf.writeUInt32BE(out[0], 0)\n buf.writeUInt32BE(out[1], 4)\n buf.writeUInt32BE(out[2], 8)\n buf.writeUInt32BE(out[3], 12)\n return buf\n}\n\nAES.prototype.decryptBlock = function (M) {\n M = asUInt32Array(M)\n\n // swap\n var m1 = M[1]\n M[1] = M[3]\n M[3] = m1\n\n var out = cryptBlock(M, this._invKeySchedule, G.INV_SUB_MIX, G.INV_SBOX, this._nRounds)\n var buf = Buffer.allocUnsafe(16)\n buf.writeUInt32BE(out[0], 0)\n buf.writeUInt32BE(out[3], 4)\n buf.writeUInt32BE(out[2], 8)\n buf.writeUInt32BE(out[1], 12)\n return buf\n}\n\nAES.prototype.scrub = function () {\n scrubVec(this._keySchedule)\n scrubVec(this._invKeySchedule)\n scrubVec(this._key)\n}\n\nmodule.exports.AES = AES\n","var aes = require('./aes')\nvar Buffer = require('safe-buffer').Buffer\nvar Transform = require('cipher-base')\nvar inherits = require('inherits')\nvar GHASH = require('./ghash')\nvar xor = require('buffer-xor')\nvar incr32 = require('./incr32')\n\nfunction xorTest (a, b) {\n var out = 0\n if (a.length !== b.length) out++\n\n var len = Math.min(a.length, b.length)\n for (var i = 0; i < len; ++i) {\n out += (a[i] ^ b[i])\n }\n\n return out\n}\n\nfunction calcIv (self, iv, ck) {\n if (iv.length === 12) {\n self._finID = Buffer.concat([iv, Buffer.from([0, 0, 0, 1])])\n return Buffer.concat([iv, Buffer.from([0, 0, 0, 2])])\n }\n var ghash = new GHASH(ck)\n var len = iv.length\n var toPad = len % 16\n ghash.update(iv)\n if (toPad) {\n toPad = 16 - toPad\n ghash.update(Buffer.alloc(toPad, 0))\n }\n ghash.update(Buffer.alloc(8, 0))\n var ivBits = len * 8\n var tail = Buffer.alloc(8)\n tail.writeUIntBE(ivBits, 0, 8)\n ghash.update(tail)\n self._finID = ghash.state\n var out = Buffer.from(self._finID)\n incr32(out)\n return out\n}\nfunction StreamCipher (mode, key, iv, decrypt) {\n Transform.call(this)\n\n var h = Buffer.alloc(4, 0)\n\n this._cipher = new aes.AES(key)\n var ck = this._cipher.encryptBlock(h)\n this._ghash = new GHASH(ck)\n iv = calcIv(this, iv, ck)\n\n this._prev = Buffer.from(iv)\n this._cache = Buffer.allocUnsafe(0)\n this._secCache = Buffer.allocUnsafe(0)\n this._decrypt = decrypt\n this._alen = 0\n this._len = 0\n this._mode = mode\n\n this._authTag = null\n this._called = false\n}\n\ninherits(StreamCipher, Transform)\n\nStreamCipher.prototype._update = function (chunk) {\n if (!this._called && this._alen) {\n var rump = 16 - (this._alen % 16)\n if (rump < 16) {\n rump = Buffer.alloc(rump, 0)\n this._ghash.update(rump)\n }\n }\n\n this._called = true\n var out = this._mode.encrypt(this, chunk)\n if (this._decrypt) {\n this._ghash.update(chunk)\n } else {\n this._ghash.update(out)\n }\n this._len += chunk.length\n return out\n}\n\nStreamCipher.prototype._final = function () {\n if (this._decrypt && !this._authTag) throw new Error('Unsupported state or unable to authenticate data')\n\n var tag = xor(this._ghash.final(this._alen * 8, this._len * 8), this._cipher.encryptBlock(this._finID))\n if (this._decrypt && xorTest(tag, this._authTag)) throw new Error('Unsupported state or unable to authenticate data')\n\n this._authTag = tag\n this._cipher.scrub()\n}\n\nStreamCipher.prototype.getAuthTag = function getAuthTag () {\n if (this._decrypt || !Buffer.isBuffer(this._authTag)) throw new Error('Attempting to get auth tag in unsupported state')\n\n return this._authTag\n}\n\nStreamCipher.prototype.setAuthTag = function setAuthTag (tag) {\n if (!this._decrypt) throw new Error('Attempting to set auth tag in unsupported state')\n\n this._authTag = tag\n}\n\nStreamCipher.prototype.setAAD = function setAAD (buf) {\n if (this._called) throw new Error('Attempting to set AAD in unsupported state')\n\n this._ghash.update(buf)\n this._alen += buf.length\n}\n\nmodule.exports = StreamCipher\n","var ciphers = require('./encrypter')\nvar deciphers = require('./decrypter')\nvar modes = require('./modes/list.json')\n\nfunction getCiphers () {\n return Object.keys(modes)\n}\n\nexports.createCipher = exports.Cipher = ciphers.createCipher\nexports.createCipheriv = exports.Cipheriv = ciphers.createCipheriv\nexports.createDecipher = exports.Decipher = deciphers.createDecipher\nexports.createDecipheriv = exports.Decipheriv = deciphers.createDecipheriv\nexports.listCiphers = exports.getCiphers = getCiphers\n","var AuthCipher = require('./authCipher')\nvar Buffer = require('safe-buffer').Buffer\nvar MODES = require('./modes')\nvar StreamCipher = require('./streamCipher')\nvar Transform = require('cipher-base')\nvar aes = require('./aes')\nvar ebtk = require('evp_bytestokey')\nvar inherits = require('inherits')\n\nfunction Decipher (mode, key, iv) {\n Transform.call(this)\n\n this._cache = new Splitter()\n this._last = void 0\n this._cipher = new aes.AES(key)\n this._prev = Buffer.from(iv)\n this._mode = mode\n this._autopadding = true\n}\n\ninherits(Decipher, Transform)\n\nDecipher.prototype._update = function (data) {\n this._cache.add(data)\n var chunk\n var thing\n var out = []\n while ((chunk = this._cache.get(this._autopadding))) {\n thing = this._mode.decrypt(this, chunk)\n out.push(thing)\n }\n return Buffer.concat(out)\n}\n\nDecipher.prototype._final = function () {\n var chunk = this._cache.flush()\n if (this._autopadding) {\n return unpad(this._mode.decrypt(this, chunk))\n } else if (chunk) {\n throw new Error('data not multiple of block length')\n }\n}\n\nDecipher.prototype.setAutoPadding = function (setTo) {\n this._autopadding = !!setTo\n return this\n}\n\nfunction Splitter () {\n this.cache = Buffer.allocUnsafe(0)\n}\n\nSplitter.prototype.add = function (data) {\n this.cache = Buffer.concat([this.cache, data])\n}\n\nSplitter.prototype.get = function (autoPadding) {\n var out\n if (autoPadding) {\n if (this.cache.length > 16) {\n out = this.cache.slice(0, 16)\n this.cache = this.cache.slice(16)\n return out\n }\n } else {\n if (this.cache.length >= 16) {\n out = this.cache.slice(0, 16)\n this.cache = this.cache.slice(16)\n return out\n }\n }\n\n return null\n}\n\nSplitter.prototype.flush = function () {\n if (this.cache.length) return this.cache\n}\n\nfunction unpad (last) {\n var padded = last[15]\n if (padded < 1 || padded > 16) {\n throw new Error('unable to decrypt data')\n }\n var i = -1\n while (++i < padded) {\n if (last[(i + (16 - padded))] !== padded) {\n throw new Error('unable to decrypt data')\n }\n }\n if (padded === 16) return\n\n return last.slice(0, 16 - padded)\n}\n\nfunction createDecipheriv (suite, password, iv) {\n var config = MODES[suite.toLowerCase()]\n if (!config) throw new TypeError('invalid suite type')\n\n if (typeof iv === 'string') iv = Buffer.from(iv)\n if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError('invalid iv length ' + iv.length)\n\n if (typeof password === 'string') password = Buffer.from(password)\n if (password.length !== config.key / 8) throw new TypeError('invalid key length ' + password.length)\n\n if (config.type === 'stream') {\n return new StreamCipher(config.module, password, iv, true)\n } else if (config.type === 'auth') {\n return new AuthCipher(config.module, password, iv, true)\n }\n\n return new Decipher(config.module, password, iv)\n}\n\nfunction createDecipher (suite, password) {\n var config = MODES[suite.toLowerCase()]\n if (!config) throw new TypeError('invalid suite type')\n\n var keys = ebtk(password, false, config.key, config.iv)\n return createDecipheriv(suite, keys.key, keys.iv)\n}\n\nexports.createDecipher = createDecipher\nexports.createDecipheriv = createDecipheriv\n","var MODES = require('./modes')\nvar AuthCipher = require('./authCipher')\nvar Buffer = require('safe-buffer').Buffer\nvar StreamCipher = require('./streamCipher')\nvar Transform = require('cipher-base')\nvar aes = require('./aes')\nvar ebtk = require('evp_bytestokey')\nvar inherits = require('inherits')\n\nfunction Cipher (mode, key, iv) {\n Transform.call(this)\n\n this._cache = new Splitter()\n this._cipher = new aes.AES(key)\n this._prev = Buffer.from(iv)\n this._mode = mode\n this._autopadding = true\n}\n\ninherits(Cipher, Transform)\n\nCipher.prototype._update = function (data) {\n this._cache.add(data)\n var chunk\n var thing\n var out = []\n\n while ((chunk = this._cache.get())) {\n thing = this._mode.encrypt(this, chunk)\n out.push(thing)\n }\n\n return Buffer.concat(out)\n}\n\nvar PADDING = Buffer.alloc(16, 0x10)\n\nCipher.prototype._final = function () {\n var chunk = this._cache.flush()\n if (this._autopadding) {\n chunk = this._mode.encrypt(this, chunk)\n this._cipher.scrub()\n return chunk\n }\n\n if (!chunk.equals(PADDING)) {\n this._cipher.scrub()\n throw new Error('data not multiple of block length')\n }\n}\n\nCipher.prototype.setAutoPadding = function (setTo) {\n this._autopadding = !!setTo\n return this\n}\n\nfunction Splitter () {\n this.cache = Buffer.allocUnsafe(0)\n}\n\nSplitter.prototype.add = function (data) {\n this.cache = Buffer.concat([this.cache, data])\n}\n\nSplitter.prototype.get = function () {\n if (this.cache.length > 15) {\n var out = this.cache.slice(0, 16)\n this.cache = this.cache.slice(16)\n return out\n }\n return null\n}\n\nSplitter.prototype.flush = function () {\n var len = 16 - this.cache.length\n var padBuff = Buffer.allocUnsafe(len)\n\n var i = -1\n while (++i < len) {\n padBuff.writeUInt8(len, i)\n }\n\n return Buffer.concat([this.cache, padBuff])\n}\n\nfunction createCipheriv (suite, password, iv) {\n var config = MODES[suite.toLowerCase()]\n if (!config) throw new TypeError('invalid suite type')\n\n if (typeof password === 'string') password = Buffer.from(password)\n if (password.length !== config.key / 8) throw new TypeError('invalid key length ' + password.length)\n\n if (typeof iv === 'string') iv = Buffer.from(iv)\n if (config.mode !== 'GCM' && iv.length !== config.iv) throw new TypeError('invalid iv length ' + iv.length)\n\n if (config.type === 'stream') {\n return new StreamCipher(config.module, password, iv)\n } else if (config.type === 'auth') {\n return new AuthCipher(config.module, password, iv)\n }\n\n return new Cipher(config.module, password, iv)\n}\n\nfunction createCipher (suite, password) {\n var config = MODES[suite.toLowerCase()]\n if (!config) throw new TypeError('invalid suite type')\n\n var keys = ebtk(password, false, config.key, config.iv)\n return createCipheriv(suite, keys.key, keys.iv)\n}\n\nexports.createCipheriv = createCipheriv\nexports.createCipher = createCipher\n","var Buffer = require('safe-buffer').Buffer\nvar ZEROES = Buffer.alloc(16, 0)\n\nfunction toArray (buf) {\n return [\n buf.readUInt32BE(0),\n buf.readUInt32BE(4),\n buf.readUInt32BE(8),\n buf.readUInt32BE(12)\n ]\n}\n\nfunction fromArray (out) {\n var buf = Buffer.allocUnsafe(16)\n buf.writeUInt32BE(out[0] >>> 0, 0)\n buf.writeUInt32BE(out[1] >>> 0, 4)\n buf.writeUInt32BE(out[2] >>> 0, 8)\n buf.writeUInt32BE(out[3] >>> 0, 12)\n return buf\n}\n\nfunction GHASH (key) {\n this.h = key\n this.state = Buffer.alloc(16, 0)\n this.cache = Buffer.allocUnsafe(0)\n}\n\n// from http://bitwiseshiftleft.github.io/sjcl/doc/symbols/src/core_gcm.js.html\n// by Juho Vähä-Herttua\nGHASH.prototype.ghash = function (block) {\n var i = -1\n while (++i < block.length) {\n this.state[i] ^= block[i]\n }\n this._multiply()\n}\n\nGHASH.prototype._multiply = function () {\n var Vi = toArray(this.h)\n var Zi = [0, 0, 0, 0]\n var j, xi, lsbVi\n var i = -1\n while (++i < 128) {\n xi = (this.state[~~(i / 8)] & (1 << (7 - (i % 8)))) !== 0\n if (xi) {\n // Z_i+1 = Z_i ^ V_i\n Zi[0] ^= Vi[0]\n Zi[1] ^= Vi[1]\n Zi[2] ^= Vi[2]\n Zi[3] ^= Vi[3]\n }\n\n // Store the value of LSB(V_i)\n lsbVi = (Vi[3] & 1) !== 0\n\n // V_i+1 = V_i >> 1\n for (j = 3; j > 0; j--) {\n Vi[j] = (Vi[j] >>> 1) | ((Vi[j - 1] & 1) << 31)\n }\n Vi[0] = Vi[0] >>> 1\n\n // If LSB(V_i) is 1, V_i+1 = (V_i >> 1) ^ R\n if (lsbVi) {\n Vi[0] = Vi[0] ^ (0xe1 << 24)\n }\n }\n this.state = fromArray(Zi)\n}\n\nGHASH.prototype.update = function (buf) {\n this.cache = Buffer.concat([this.cache, buf])\n var chunk\n while (this.cache.length >= 16) {\n chunk = this.cache.slice(0, 16)\n this.cache = this.cache.slice(16)\n this.ghash(chunk)\n }\n}\n\nGHASH.prototype.final = function (abl, bl) {\n if (this.cache.length) {\n this.ghash(Buffer.concat([this.cache, ZEROES], 16))\n }\n\n this.ghash(fromArray([0, abl, 0, bl]))\n return this.state\n}\n\nmodule.exports = GHASH\n","function incr32 (iv) {\n var len = iv.length\n var item\n while (len--) {\n item = iv.readUInt8(len)\n if (item === 255) {\n iv.writeUInt8(0, len)\n } else {\n item++\n iv.writeUInt8(item, len)\n break\n }\n }\n}\nmodule.exports = incr32\n","var xor = require('buffer-xor')\n\nexports.encrypt = function (self, block) {\n var data = xor(block, self._prev)\n\n self._prev = self._cipher.encryptBlock(data)\n return self._prev\n}\n\nexports.decrypt = function (self, block) {\n var pad = self._prev\n\n self._prev = block\n var out = self._cipher.decryptBlock(block)\n\n return xor(out, pad)\n}\n","var Buffer = require('safe-buffer').Buffer\nvar xor = require('buffer-xor')\n\nfunction encryptStart (self, data, decrypt) {\n var len = data.length\n var out = xor(data, self._cache)\n self._cache = self._cache.slice(len)\n self._prev = Buffer.concat([self._prev, decrypt ? data : out])\n return out\n}\n\nexports.encrypt = function (self, data, decrypt) {\n var out = Buffer.allocUnsafe(0)\n var len\n\n while (data.length) {\n if (self._cache.length === 0) {\n self._cache = self._cipher.encryptBlock(self._prev)\n self._prev = Buffer.allocUnsafe(0)\n }\n\n if (self._cache.length <= data.length) {\n len = self._cache.length\n out = Buffer.concat([out, encryptStart(self, data.slice(0, len), decrypt)])\n data = data.slice(len)\n } else {\n out = Buffer.concat([out, encryptStart(self, data, decrypt)])\n break\n }\n }\n\n return out\n}\n","var Buffer = require('safe-buffer').Buffer\n\nfunction encryptByte (self, byteParam, decrypt) {\n var pad\n var i = -1\n var len = 8\n var out = 0\n var bit, value\n while (++i < len) {\n pad = self._cipher.encryptBlock(self._prev)\n bit = (byteParam & (1 << (7 - i))) ? 0x80 : 0\n value = pad[0] ^ bit\n out += ((value & 0x80) >> (i % 8))\n self._prev = shiftIn(self._prev, decrypt ? bit : value)\n }\n return out\n}\n\nfunction shiftIn (buffer, value) {\n var len = buffer.length\n var i = -1\n var out = Buffer.allocUnsafe(buffer.length)\n buffer = Buffer.concat([buffer, Buffer.from([value])])\n\n while (++i < len) {\n out[i] = buffer[i] << 1 | buffer[i + 1] >> (7)\n }\n\n return out\n}\n\nexports.encrypt = function (self, chunk, decrypt) {\n var len = chunk.length\n var out = Buffer.allocUnsafe(len)\n var i = -1\n\n while (++i < len) {\n out[i] = encryptByte(self, chunk[i], decrypt)\n }\n\n return out\n}\n","var Buffer = require('safe-buffer').Buffer\n\nfunction encryptByte (self, byteParam, decrypt) {\n var pad = self._cipher.encryptBlock(self._prev)\n var out = pad[0] ^ byteParam\n\n self._prev = Buffer.concat([\n self._prev.slice(1),\n Buffer.from([decrypt ? byteParam : out])\n ])\n\n return out\n}\n\nexports.encrypt = function (self, chunk, decrypt) {\n var len = chunk.length\n var out = Buffer.allocUnsafe(len)\n var i = -1\n\n while (++i < len) {\n out[i] = encryptByte(self, chunk[i], decrypt)\n }\n\n return out\n}\n","var xor = require('buffer-xor')\nvar Buffer = require('safe-buffer').Buffer\nvar incr32 = require('../incr32')\n\nfunction getBlock (self) {\n var out = self._cipher.encryptBlockRaw(self._prev)\n incr32(self._prev)\n return out\n}\n\nvar blockSize = 16\nexports.encrypt = function (self, chunk) {\n var chunkNum = Math.ceil(chunk.length / blockSize)\n var start = self._cache.length\n self._cache = Buffer.concat([\n self._cache,\n Buffer.allocUnsafe(chunkNum * blockSize)\n ])\n for (var i = 0; i < chunkNum; i++) {\n var out = getBlock(self)\n var offset = start + i * blockSize\n self._cache.writeUInt32BE(out[0], offset + 0)\n self._cache.writeUInt32BE(out[1], offset + 4)\n self._cache.writeUInt32BE(out[2], offset + 8)\n self._cache.writeUInt32BE(out[3], offset + 12)\n }\n var pad = self._cache.slice(0, chunk.length)\n self._cache = self._cache.slice(chunk.length)\n return xor(chunk, pad)\n}\n","exports.encrypt = function (self, block) {\n return self._cipher.encryptBlock(block)\n}\n\nexports.decrypt = function (self, block) {\n return self._cipher.decryptBlock(block)\n}\n","var modeModules = {\n ECB: require('./ecb'),\n CBC: require('./cbc'),\n CFB: require('./cfb'),\n CFB8: require('./cfb8'),\n CFB1: require('./cfb1'),\n OFB: require('./ofb'),\n CTR: require('./ctr'),\n GCM: require('./ctr')\n}\n\nvar modes = require('./list.json')\n\nfor (var key in modes) {\n modes[key].module = modeModules[modes[key].mode]\n}\n\nmodule.exports = modes\n","var xor = require('buffer-xor')\n\nfunction getBlock (self) {\n self._prev = self._cipher.encryptBlock(self._prev)\n return self._prev\n}\n\nexports.encrypt = function (self, chunk) {\n while (self._cache.length < chunk.length) {\n self._cache = Buffer.concat([self._cache, getBlock(self)])\n }\n\n var pad = self._cache.slice(0, chunk.length)\n self._cache = self._cache.slice(chunk.length)\n return xor(chunk, pad)\n}\n","var aes = require('./aes')\nvar Buffer = require('safe-buffer').Buffer\nvar Transform = require('cipher-base')\nvar inherits = require('inherits')\n\nfunction StreamCipher (mode, key, iv, decrypt) {\n Transform.call(this)\n\n this._cipher = new aes.AES(key)\n this._prev = Buffer.from(iv)\n this._cache = Buffer.allocUnsafe(0)\n this._secCache = Buffer.allocUnsafe(0)\n this._decrypt = decrypt\n this._mode = mode\n}\n\ninherits(StreamCipher, Transform)\n\nStreamCipher.prototype._update = function (chunk) {\n return this._mode.encrypt(this, chunk, this._decrypt)\n}\n\nStreamCipher.prototype._final = function () {\n this._cipher.scrub()\n}\n\nmodule.exports = StreamCipher\n","var DES = require('browserify-des')\nvar aes = require('browserify-aes/browser')\nvar aesModes = require('browserify-aes/modes')\nvar desModes = require('browserify-des/modes')\nvar ebtk = require('evp_bytestokey')\n\nfunction createCipher (suite, password) {\n suite = suite.toLowerCase()\n\n var keyLen, ivLen\n if (aesModes[suite]) {\n keyLen = aesModes[suite].key\n ivLen = aesModes[suite].iv\n } else if (desModes[suite]) {\n keyLen = desModes[suite].key * 8\n ivLen = desModes[suite].iv\n } else {\n throw new TypeError('invalid suite type')\n }\n\n var keys = ebtk(password, false, keyLen, ivLen)\n return createCipheriv(suite, keys.key, keys.iv)\n}\n\nfunction createDecipher (suite, password) {\n suite = suite.toLowerCase()\n\n var keyLen, ivLen\n if (aesModes[suite]) {\n keyLen = aesModes[suite].key\n ivLen = aesModes[suite].iv\n } else if (desModes[suite]) {\n keyLen = desModes[suite].key * 8\n ivLen = desModes[suite].iv\n } else {\n throw new TypeError('invalid suite type')\n }\n\n var keys = ebtk(password, false, keyLen, ivLen)\n return createDecipheriv(suite, keys.key, keys.iv)\n}\n\nfunction createCipheriv (suite, key, iv) {\n suite = suite.toLowerCase()\n if (aesModes[suite]) return aes.createCipheriv(suite, key, iv)\n if (desModes[suite]) return new DES({ key: key, iv: iv, mode: suite })\n\n throw new TypeError('invalid suite type')\n}\n\nfunction createDecipheriv (suite, key, iv) {\n suite = suite.toLowerCase()\n if (aesModes[suite]) return aes.createDecipheriv(suite, key, iv)\n if (desModes[suite]) return new DES({ key: key, iv: iv, mode: suite, decrypt: true })\n\n throw new TypeError('invalid suite type')\n}\n\nfunction getCiphers () {\n return Object.keys(desModes).concat(aes.getCiphers())\n}\n\nexports.createCipher = exports.Cipher = createCipher\nexports.createCipheriv = exports.Cipheriv = createCipheriv\nexports.createDecipher = exports.Decipher = createDecipher\nexports.createDecipheriv = exports.Decipheriv = createDecipheriv\nexports.listCiphers = exports.getCiphers = getCiphers\n","var CipherBase = require('cipher-base')\nvar des = require('des.js')\nvar inherits = require('inherits')\nvar Buffer = require('safe-buffer').Buffer\n\nvar modes = {\n 'des-ede3-cbc': des.CBC.instantiate(des.EDE),\n 'des-ede3': des.EDE,\n 'des-ede-cbc': des.CBC.instantiate(des.EDE),\n 'des-ede': des.EDE,\n 'des-cbc': des.CBC.instantiate(des.DES),\n 'des-ecb': des.DES\n}\nmodes.des = modes['des-cbc']\nmodes.des3 = modes['des-ede3-cbc']\nmodule.exports = DES\ninherits(DES, CipherBase)\nfunction DES (opts) {\n CipherBase.call(this)\n var modeName = opts.mode.toLowerCase()\n var mode = modes[modeName]\n var type\n if (opts.decrypt) {\n type = 'decrypt'\n } else {\n type = 'encrypt'\n }\n var key = opts.key\n if (!Buffer.isBuffer(key)) {\n key = Buffer.from(key)\n }\n if (modeName === 'des-ede' || modeName === 'des-ede-cbc') {\n key = Buffer.concat([key, key.slice(0, 8)])\n }\n var iv = opts.iv\n if (!Buffer.isBuffer(iv)) {\n iv = Buffer.from(iv)\n }\n this._des = mode.create({\n key: key,\n iv: iv,\n type: type\n })\n}\nDES.prototype._update = function (data) {\n return Buffer.from(this._des.update(data))\n}\nDES.prototype._final = function () {\n return Buffer.from(this._des.final())\n}\n","exports['des-ecb'] = {\n key: 8,\n iv: 0\n}\nexports['des-cbc'] = exports.des = {\n key: 8,\n iv: 8\n}\nexports['des-ede3-cbc'] = exports.des3 = {\n key: 24,\n iv: 8\n}\nexports['des-ede3'] = {\n key: 24,\n iv: 0\n}\nexports['des-ede-cbc'] = {\n key: 16,\n iv: 8\n}\nexports['des-ede'] = {\n key: 16,\n iv: 0\n}\n","var BN = require('bn.js')\nvar randomBytes = require('randombytes')\n\nfunction blind (priv) {\n var r = getr(priv)\n var blinder = r.toRed(BN.mont(priv.modulus)).redPow(new BN(priv.publicExponent)).fromRed()\n return { blinder: blinder, unblinder: r.invm(priv.modulus) }\n}\n\nfunction getr (priv) {\n var len = priv.modulus.byteLength()\n var r\n do {\n r = new BN(randomBytes(len))\n } while (r.cmp(priv.modulus) >= 0 || !r.umod(priv.prime1) || !r.umod(priv.prime2))\n return r\n}\n\nfunction crt (msg, priv) {\n var blinds = blind(priv)\n var len = priv.modulus.byteLength()\n var blinded = new BN(msg).mul(blinds.blinder).umod(priv.modulus)\n var c1 = blinded.toRed(BN.mont(priv.prime1))\n var c2 = blinded.toRed(BN.mont(priv.prime2))\n var qinv = priv.coefficient\n var p = priv.prime1\n var q = priv.prime2\n var m1 = c1.redPow(priv.exponent1).fromRed()\n var m2 = c2.redPow(priv.exponent2).fromRed()\n var h = m1.isub(m2).imul(qinv).umod(p).imul(q)\n return m2.iadd(h).imul(blinds.unblinder).umod(priv.modulus).toArrayLike(Buffer, 'be', len)\n}\ncrt.getr = getr\n\nmodule.exports = crt\n","module.exports = require('./browser/algorithms.json')\n","var Buffer = require('safe-buffer').Buffer\nvar createHash = require('create-hash')\nvar stream = require('readable-stream')\nvar inherits = require('inherits')\nvar sign = require('./sign')\nvar verify = require('./verify')\n\nvar algorithms = require('./algorithms.json')\nObject.keys(algorithms).forEach(function (key) {\n algorithms[key].id = Buffer.from(algorithms[key].id, 'hex')\n algorithms[key.toLowerCase()] = algorithms[key]\n})\n\nfunction Sign (algorithm) {\n stream.Writable.call(this)\n\n var data = algorithms[algorithm]\n if (!data) throw new Error('Unknown message digest')\n\n this._hashType = data.hash\n this._hash = createHash(data.hash)\n this._tag = data.id\n this._signType = data.sign\n}\ninherits(Sign, stream.Writable)\n\nSign.prototype._write = function _write (data, _, done) {\n this._hash.update(data)\n done()\n}\n\nSign.prototype.update = function update (data, enc) {\n if (typeof data === 'string') data = Buffer.from(data, enc)\n\n this._hash.update(data)\n return this\n}\n\nSign.prototype.sign = function signMethod (key, enc) {\n this.end()\n var hash = this._hash.digest()\n var sig = sign(hash, key, this._hashType, this._signType, this._tag)\n\n return enc ? sig.toString(enc) : sig\n}\n\nfunction Verify (algorithm) {\n stream.Writable.call(this)\n\n var data = algorithms[algorithm]\n if (!data) throw new Error('Unknown message digest')\n\n this._hash = createHash(data.hash)\n this._tag = data.id\n this._signType = data.sign\n}\ninherits(Verify, stream.Writable)\n\nVerify.prototype._write = function _write (data, _, done) {\n this._hash.update(data)\n done()\n}\n\nVerify.prototype.update = function update (data, enc) {\n if (typeof data === 'string') data = Buffer.from(data, enc)\n\n this._hash.update(data)\n return this\n}\n\nVerify.prototype.verify = function verifyMethod (key, sig, enc) {\n if (typeof sig === 'string') sig = Buffer.from(sig, enc)\n\n this.end()\n var hash = this._hash.digest()\n return verify(sig, hash, key, this._signType, this._tag)\n}\n\nfunction createSign (algorithm) {\n return new Sign(algorithm)\n}\n\nfunction createVerify (algorithm) {\n return new Verify(algorithm)\n}\n\nmodule.exports = {\n Sign: createSign,\n Verify: createVerify,\n createSign: createSign,\n createVerify: createVerify\n}\n","// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js\nvar Buffer = require('safe-buffer').Buffer\nvar createHmac = require('create-hmac')\nvar crt = require('browserify-rsa')\nvar EC = require('elliptic').ec\nvar BN = require('bn.js')\nvar parseKeys = require('parse-asn1')\nvar curves = require('./curves.json')\n\nfunction sign (hash, key, hashType, signType, tag) {\n var priv = parseKeys(key)\n if (priv.curve) {\n // rsa keys can be interpreted as ecdsa ones in openssl\n if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error('wrong private key type')\n return ecSign(hash, priv)\n } else if (priv.type === 'dsa') {\n if (signType !== 'dsa') throw new Error('wrong private key type')\n return dsaSign(hash, priv, hashType)\n } else {\n if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error('wrong private key type')\n }\n hash = Buffer.concat([tag, hash])\n var len = priv.modulus.byteLength()\n var pad = [0, 1]\n while (hash.length + pad.length + 1 < len) pad.push(0xff)\n pad.push(0x00)\n var i = -1\n while (++i < hash.length) pad.push(hash[i])\n\n var out = crt(pad, priv)\n return out\n}\n\nfunction ecSign (hash, priv) {\n var curveId = curves[priv.curve.join('.')]\n if (!curveId) throw new Error('unknown curve ' + priv.curve.join('.'))\n\n var curve = new EC(curveId)\n var key = curve.keyFromPrivate(priv.privateKey)\n var out = key.sign(hash)\n\n return Buffer.from(out.toDER())\n}\n\nfunction dsaSign (hash, priv, algo) {\n var x = priv.params.priv_key\n var p = priv.params.p\n var q = priv.params.q\n var g = priv.params.g\n var r = new BN(0)\n var k\n var H = bits2int(hash, q).mod(q)\n var s = false\n var kv = getKey(x, q, hash, algo)\n while (s === false) {\n k = makeKey(q, kv, algo)\n r = makeR(g, k, p, q)\n s = k.invm(q).imul(H.add(x.mul(r))).mod(q)\n if (s.cmpn(0) === 0) {\n s = false\n r = new BN(0)\n }\n }\n return toDER(r, s)\n}\n\nfunction toDER (r, s) {\n r = r.toArray()\n s = s.toArray()\n\n // Pad values\n if (r[0] & 0x80) r = [0].concat(r)\n if (s[0] & 0x80) s = [0].concat(s)\n\n var total = r.length + s.length + 4\n var res = [0x30, total, 0x02, r.length]\n res = res.concat(r, [0x02, s.length], s)\n return Buffer.from(res)\n}\n\nfunction getKey (x, q, hash, algo) {\n x = Buffer.from(x.toArray())\n if (x.length < q.byteLength()) {\n var zeros = Buffer.alloc(q.byteLength() - x.length)\n x = Buffer.concat([zeros, x])\n }\n var hlen = hash.length\n var hbits = bits2octets(hash, q)\n var v = Buffer.alloc(hlen)\n v.fill(1)\n var k = Buffer.alloc(hlen)\n k = createHmac(algo, k).update(v).update(Buffer.from([0])).update(x).update(hbits).digest()\n v = createHmac(algo, k).update(v).digest()\n k = createHmac(algo, k).update(v).update(Buffer.from([1])).update(x).update(hbits).digest()\n v = createHmac(algo, k).update(v).digest()\n return { k: k, v: v }\n}\n\nfunction bits2int (obits, q) {\n var bits = new BN(obits)\n var shift = (obits.length << 3) - q.bitLength()\n if (shift > 0) bits.ishrn(shift)\n return bits\n}\n\nfunction bits2octets (bits, q) {\n bits = bits2int(bits, q)\n bits = bits.mod(q)\n var out = Buffer.from(bits.toArray())\n if (out.length < q.byteLength()) {\n var zeros = Buffer.alloc(q.byteLength() - out.length)\n out = Buffer.concat([zeros, out])\n }\n return out\n}\n\nfunction makeKey (q, kv, algo) {\n var t\n var k\n\n do {\n t = Buffer.alloc(0)\n\n while (t.length * 8 < q.bitLength()) {\n kv.v = createHmac(algo, kv.k).update(kv.v).digest()\n t = Buffer.concat([t, kv.v])\n }\n\n k = bits2int(t, q)\n kv.k = createHmac(algo, kv.k).update(kv.v).update(Buffer.from([0])).digest()\n kv.v = createHmac(algo, kv.k).update(kv.v).digest()\n } while (k.cmp(q) !== -1)\n\n return k\n}\n\nfunction makeR (g, k, p, q) {\n return g.toRed(BN.mont(p)).redPow(k).fromRed().mod(q)\n}\n\nmodule.exports = sign\nmodule.exports.getKey = getKey\nmodule.exports.makeKey = makeKey\n","// much of this based on https://github.com/indutny/self-signed/blob/gh-pages/lib/rsa.js\nvar Buffer = require('safe-buffer').Buffer\nvar BN = require('bn.js')\nvar EC = require('elliptic').ec\nvar parseKeys = require('parse-asn1')\nvar curves = require('./curves.json')\n\nfunction verify (sig, hash, key, signType, tag) {\n var pub = parseKeys(key)\n if (pub.type === 'ec') {\n // rsa keys can be interpreted as ecdsa ones in openssl\n if (signType !== 'ecdsa' && signType !== 'ecdsa/rsa') throw new Error('wrong public key type')\n return ecVerify(sig, hash, pub)\n } else if (pub.type === 'dsa') {\n if (signType !== 'dsa') throw new Error('wrong public key type')\n return dsaVerify(sig, hash, pub)\n } else {\n if (signType !== 'rsa' && signType !== 'ecdsa/rsa') throw new Error('wrong public key type')\n }\n hash = Buffer.concat([tag, hash])\n var len = pub.modulus.byteLength()\n var pad = [1]\n var padNum = 0\n while (hash.length + pad.length + 2 < len) {\n pad.push(0xff)\n padNum++\n }\n pad.push(0x00)\n var i = -1\n while (++i < hash.length) {\n pad.push(hash[i])\n }\n pad = Buffer.from(pad)\n var red = BN.mont(pub.modulus)\n sig = new BN(sig).toRed(red)\n\n sig = sig.redPow(new BN(pub.publicExponent))\n sig = Buffer.from(sig.fromRed().toArray())\n var out = padNum < 8 ? 1 : 0\n len = Math.min(sig.length, pad.length)\n if (sig.length !== pad.length) out = 1\n\n i = -1\n while (++i < len) out |= sig[i] ^ pad[i]\n return out === 0\n}\n\nfunction ecVerify (sig, hash, pub) {\n var curveId = curves[pub.data.algorithm.curve.join('.')]\n if (!curveId) throw new Error('unknown curve ' + pub.data.algorithm.curve.join('.'))\n\n var curve = new EC(curveId)\n var pubkey = pub.data.subjectPrivateKey.data\n\n return curve.verify(hash, sig, pubkey)\n}\n\nfunction dsaVerify (sig, hash, pub) {\n var p = pub.data.p\n var q = pub.data.q\n var g = pub.data.g\n var y = pub.data.pub_key\n var unpacked = parseKeys.signature.decode(sig, 'der')\n var s = unpacked.s\n var r = unpacked.r\n checkValue(s, q)\n checkValue(r, q)\n var montp = BN.mont(p)\n var w = s.invm(q)\n var v = g.toRed(montp)\n .redPow(new BN(hash).mul(w).mod(q))\n .fromRed()\n .mul(y.toRed(montp).redPow(r.mul(w).mod(q)).fromRed())\n .mod(p)\n .mod(q)\n return v.cmp(r) === 0\n}\n\nfunction checkValue (b, q) {\n if (b.cmpn(0) <= 0) throw new Error('invalid sig')\n if (b.cmp(q) >= q) throw new Error('invalid sig')\n}\n\nmodule.exports = verify\n","var basex = require('base-x')\nvar ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n\nmodule.exports = basex(ALPHABET)\n","'use strict'\n\nvar base58 = require('bs58')\nvar Buffer = require('safe-buffer').Buffer\n\nmodule.exports = function (checksumFn) {\n // Encode a buffer as a base58-check encoded string\n function encode (payload) {\n var checksum = checksumFn(payload)\n\n return base58.encode(Buffer.concat([\n payload,\n checksum\n ], payload.length + 4))\n }\n\n function decodeRaw (buffer) {\n var payload = buffer.slice(0, -4)\n var checksum = buffer.slice(-4)\n var newChecksum = checksumFn(payload)\n\n if (checksum[0] ^ newChecksum[0] |\n checksum[1] ^ newChecksum[1] |\n checksum[2] ^ newChecksum[2] |\n checksum[3] ^ newChecksum[3]) return\n\n return payload\n }\n\n // Decode a base58-check encoded string to a buffer, no result if checksum is wrong\n function decodeUnsafe (string) {\n var buffer = base58.decodeUnsafe(string)\n if (!buffer) return\n\n return decodeRaw(buffer)\n }\n\n function decode (string) {\n var buffer = base58.decode(string)\n var payload = decodeRaw(buffer, checksumFn)\n if (!payload) throw new Error('Invalid checksum')\n return payload\n }\n\n return {\n encode: encode,\n decode: decode,\n decodeUnsafe: decodeUnsafe\n }\n}\n","'use strict'\n\nvar createHash = require('create-hash')\nvar bs58checkBase = require('./base')\n\n// SHA256(SHA256(buffer))\nfunction sha256x2 (buffer) {\n var tmp = createHash('sha256').update(buffer).digest()\n return createHash('sha256').update(tmp).digest()\n}\n\nmodule.exports = bs58checkBase(sha256x2)\n","module.exports = function xor (a, b) {\n var length = Math.min(a.length, b.length)\n var buffer = new Buffer(length)\n\n for (var i = 0; i < length; ++i) {\n buffer[i] = a[i] ^ b[i]\n }\n\n return buffer\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh <https://feross.org>\n * @license MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nconst base64 = require('base64-js')\nconst ieee754 = require('ieee754')\nconst customInspectSymbol =\n (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation\n ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation\n : null\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nconst K_MAX_LENGTH = 0x7fffffff\nexports.kMaxLength = K_MAX_LENGTH\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n * === true Use Uint8Array implementation (fastest)\n * === false Print warning and recommend using `buffer` v4.x which has an Object\n * implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\n\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n typeof console.error === 'function') {\n console.error(\n 'This browser lacks typed array (Uint8Array) support which is required by ' +\n '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n )\n}\n\nfunction typedArraySupport () {\n // Can typed array instances can be augmented?\n try {\n const arr = new Uint8Array(1)\n const proto = { foo: function () { return 42 } }\n Object.setPrototypeOf(proto, Uint8Array.prototype)\n Object.setPrototypeOf(arr, proto)\n return arr.foo() === 42\n } catch (e) {\n return false\n }\n}\n\nObject.defineProperty(Buffer.prototype, 'parent', {\n enumerable: true,\n get: function () {\n if (!Buffer.isBuffer(this)) return undefined\n return this.buffer\n }\n})\n\nObject.defineProperty(Buffer.prototype, 'offset', {\n enumerable: true,\n get: function () {\n if (!Buffer.isBuffer(this)) return undefined\n return this.byteOffset\n }\n})\n\nfunction createBuffer (length) {\n if (length > K_MAX_LENGTH) {\n throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n }\n // Return an augmented `Uint8Array` instance\n const buf = new Uint8Array(length)\n Object.setPrototypeOf(buf, Buffer.prototype)\n return buf\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n // Common case.\n if (typeof arg === 'number') {\n if (typeof encodingOrOffset === 'string') {\n throw new TypeError(\n 'The \"string\" argument must be of type string. Received type number'\n )\n }\n return allocUnsafe(arg)\n }\n return from(arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\nfunction from (value, encodingOrOffset, length) {\n if (typeof value === 'string') {\n return fromString(value, encodingOrOffset)\n }\n\n if (ArrayBuffer.isView(value)) {\n return fromArrayView(value)\n }\n\n if (value == null) {\n throw new TypeError(\n 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n 'or Array-like Object. Received type ' + (typeof value)\n )\n }\n\n if (isInstance(value, ArrayBuffer) ||\n (value && isInstance(value.buffer, ArrayBuffer))) {\n return fromArrayBuffer(value, encodingOrOffset, length)\n }\n\n if (typeof SharedArrayBuffer !== 'undefined' &&\n (isInstance(value, SharedArrayBuffer) ||\n (value && isInstance(value.buffer, SharedArrayBuffer)))) {\n return fromArrayBuffer(value, encodingOrOffset, length)\n }\n\n if (typeof value === 'number') {\n throw new TypeError(\n 'The \"value\" argument must not be of type number. Received type number'\n )\n }\n\n const valueOf = value.valueOf && value.valueOf()\n if (valueOf != null && valueOf !== value) {\n return Buffer.from(valueOf, encodingOrOffset, length)\n }\n\n const b = fromObject(value)\n if (b) return b\n\n if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n typeof value[Symbol.toPrimitive] === 'function') {\n return Buffer.from(value[Symbol.toPrimitive]('string'), encodingOrOffset, length)\n }\n\n throw new TypeError(\n 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n 'or Array-like Object. Received type ' + (typeof value)\n )\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n return from(value, encodingOrOffset, length)\n}\n\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n// https://github.com/feross/buffer/pull/148\nObject.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)\nObject.setPrototypeOf(Buffer, Uint8Array)\n\nfunction assertSize (size) {\n if (typeof size !== 'number') {\n throw new TypeError('\"size\" argument must be of type number')\n } else if (size < 0) {\n throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n }\n}\n\nfunction alloc (size, fill, encoding) {\n assertSize(size)\n if (size <= 0) {\n return createBuffer(size)\n }\n if (fill !== undefined) {\n // Only pay attention to encoding if it's a string. This\n // prevents accidentally sending in a number that would\n // be interpreted as a start offset.\n return typeof encoding === 'string'\n ? createBuffer(size).fill(fill, encoding)\n : createBuffer(size).fill(fill)\n }\n return createBuffer(size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n return alloc(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n assertSize(size)\n return createBuffer(size < 0 ? 0 : checked(size) | 0)\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n return allocUnsafe(size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n return allocUnsafe(size)\n}\n\nfunction fromString (string, encoding) {\n if (typeof encoding !== 'string' || encoding === '') {\n encoding = 'utf8'\n }\n\n if (!Buffer.isEncoding(encoding)) {\n throw new TypeError('Unknown encoding: ' + encoding)\n }\n\n const length = byteLength(string, encoding) | 0\n let buf = createBuffer(length)\n\n const actual = buf.write(string, encoding)\n\n if (actual !== length) {\n // Writing a hex string, for example, that contains invalid characters will\n // cause everything after the first invalid character to be ignored. (e.g.\n // 'abxxcd' will be treated as 'ab')\n buf = buf.slice(0, actual)\n }\n\n return buf\n}\n\nfunction fromArrayLike (array) {\n const length = array.length < 0 ? 0 : checked(array.length) | 0\n const buf = createBuffer(length)\n for (let i = 0; i < length; i += 1) {\n buf[i] = array[i] & 255\n }\n return buf\n}\n\nfunction fromArrayView (arrayView) {\n if (isInstance(arrayView, Uint8Array)) {\n const copy = new Uint8Array(arrayView)\n return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)\n }\n return fromArrayLike(arrayView)\n}\n\nfunction fromArrayBuffer (array, byteOffset, length) {\n if (byteOffset < 0 || array.byteLength < byteOffset) {\n throw new RangeError('\"offset\" is outside of buffer bounds')\n }\n\n if (array.byteLength < byteOffset + (length || 0)) {\n throw new RangeError('\"length\" is outside of buffer bounds')\n }\n\n let buf\n if (byteOffset === undefined && length === undefined) {\n buf = new Uint8Array(array)\n } else if (length === undefined) {\n buf = new Uint8Array(array, byteOffset)\n } else {\n buf = new Uint8Array(array, byteOffset, length)\n }\n\n // Return an augmented `Uint8Array` instance\n Object.setPrototypeOf(buf, Buffer.prototype)\n\n return buf\n}\n\nfunction fromObject (obj) {\n if (Buffer.isBuffer(obj)) {\n const len = checked(obj.length) | 0\n const buf = createBuffer(len)\n\n if (buf.length === 0) {\n return buf\n }\n\n obj.copy(buf, 0, 0, len)\n return buf\n }\n\n if (obj.length !== undefined) {\n if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n return createBuffer(0)\n }\n return fromArrayLike(obj)\n }\n\n if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n return fromArrayLike(obj.data)\n }\n}\n\nfunction checked (length) {\n // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n // length is NaN (which is otherwise coerced to zero.)\n if (length >= K_MAX_LENGTH) {\n throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')\n }\n return length | 0\n}\n\nfunction SlowBuffer (length) {\n if (+length != length) { // eslint-disable-line eqeqeq\n length = 0\n }\n return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n return b != null && b._isBuffer === true &&\n b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n}\n\nBuffer.compare = function compare (a, b) {\n if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\n if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\n if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n throw new TypeError(\n 'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n )\n }\n\n if (a === b) return 0\n\n let x = a.length\n let y = b.length\n\n for (let i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i]\n y = b[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n switch (String(encoding).toLowerCase()) {\n case 'hex':\n case 'utf8':\n case 'utf-8':\n case 'ascii':\n case 'latin1':\n case 'binary':\n case 'base64':\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return true\n default:\n return false\n }\n}\n\nBuffer.concat = function concat (list, length) {\n if (!Array.isArray(list)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n\n if (list.length === 0) {\n return Buffer.alloc(0)\n }\n\n let i\n if (length === undefined) {\n length = 0\n for (i = 0; i < list.length; ++i) {\n length += list[i].length\n }\n }\n\n const buffer = Buffer.allocUnsafe(length)\n let pos = 0\n for (i = 0; i < list.length; ++i) {\n let buf = list[i]\n if (isInstance(buf, Uint8Array)) {\n if (pos + buf.length > buffer.length) {\n if (!Buffer.isBuffer(buf)) buf = Buffer.from(buf)\n buf.copy(buffer, pos)\n } else {\n Uint8Array.prototype.set.call(\n buffer,\n buf,\n pos\n )\n }\n } else if (!Buffer.isBuffer(buf)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n } else {\n buf.copy(buffer, pos)\n }\n pos += buf.length\n }\n return buffer\n}\n\nfunction byteLength (string, encoding) {\n if (Buffer.isBuffer(string)) {\n return string.length\n }\n if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n return string.byteLength\n }\n if (typeof string !== 'string') {\n throw new TypeError(\n 'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n 'Received type ' + typeof string\n )\n }\n\n const len = string.length\n const mustMatch = (arguments.length > 2 && arguments[2] === true)\n if (!mustMatch && len === 0) return 0\n\n // Use a for loop to avoid recursion\n let loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'ascii':\n case 'latin1':\n case 'binary':\n return len\n case 'utf8':\n case 'utf-8':\n return utf8ToBytes(string).length\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return len * 2\n case 'hex':\n return len >>> 1\n case 'base64':\n return base64ToBytes(string).length\n default:\n if (loweredCase) {\n return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n }\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n let loweredCase = false\n\n // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n // property of a typed array.\n\n // This behaves neither like String nor Uint8Array in that we set start/end\n // to their upper/lower bounds if the value passed is out of range.\n // undefined is handled specially as per ECMA-262 6th Edition,\n // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n if (start === undefined || start < 0) {\n start = 0\n }\n // Return early if start > this.length. Done here to prevent potential uint32\n // coercion fail below.\n if (start > this.length) {\n return ''\n }\n\n if (end === undefined || end > this.length) {\n end = this.length\n }\n\n if (end <= 0) {\n return ''\n }\n\n // Force coercion to uint32. This will also coerce falsey/NaN values to 0.\n end >>>= 0\n start >>>= 0\n\n if (end <= start) {\n return ''\n }\n\n if (!encoding) encoding = 'utf8'\n\n while (true) {\n switch (encoding) {\n case 'hex':\n return hexSlice(this, start, end)\n\n case 'utf8':\n case 'utf-8':\n return utf8Slice(this, start, end)\n\n case 'ascii':\n return asciiSlice(this, start, end)\n\n case 'latin1':\n case 'binary':\n return latin1Slice(this, start, end)\n\n case 'base64':\n return base64Slice(this, start, end)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return utf16leSlice(this, start, end)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = (encoding + '').toLowerCase()\n loweredCase = true\n }\n }\n}\n\n// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n// reliably in a browserify context because there could be multiple different\n// copies of the 'buffer' package in use. This method works even for Buffer\n// instances that were created from another copy of the `buffer` package.\n// See: https://github.com/feross/buffer/issues/154\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n const i = b[n]\n b[n] = b[m]\n b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n const len = this.length\n if (len % 2 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 16-bits')\n }\n for (let i = 0; i < len; i += 2) {\n swap(this, i, i + 1)\n }\n return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n const len = this.length\n if (len % 4 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 32-bits')\n }\n for (let i = 0; i < len; i += 4) {\n swap(this, i, i + 3)\n swap(this, i + 1, i + 2)\n }\n return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n const len = this.length\n if (len % 8 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 64-bits')\n }\n for (let i = 0; i < len; i += 8) {\n swap(this, i, i + 7)\n swap(this, i + 1, i + 6)\n swap(this, i + 2, i + 5)\n swap(this, i + 3, i + 4)\n }\n return this\n}\n\nBuffer.prototype.toString = function toString () {\n const length = this.length\n if (length === 0) return ''\n if (arguments.length === 0) return utf8Slice(this, 0, length)\n return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.toLocaleString = Buffer.prototype.toString\n\nBuffer.prototype.equals = function equals (b) {\n if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n if (this === b) return true\n return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n let str = ''\n const max = exports.INSPECT_MAX_BYTES\n str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\n if (this.length > max) str += ' ... '\n return '<Buffer ' + str + '>'\n}\nif (customInspectSymbol) {\n Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n if (isInstance(target, Uint8Array)) {\n target = Buffer.from(target, target.offset, target.byteLength)\n }\n if (!Buffer.isBuffer(target)) {\n throw new TypeError(\n 'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n 'Received type ' + (typeof target)\n )\n }\n\n if (start === undefined) {\n start = 0\n }\n if (end === undefined) {\n end = target ? target.length : 0\n }\n if (thisStart === undefined) {\n thisStart = 0\n }\n if (thisEnd === undefined) {\n thisEnd = this.length\n }\n\n if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n throw new RangeError('out of range index')\n }\n\n if (thisStart >= thisEnd && start >= end) {\n return 0\n }\n if (thisStart >= thisEnd) {\n return -1\n }\n if (start >= end) {\n return 1\n }\n\n start >>>= 0\n end >>>= 0\n thisStart >>>= 0\n thisEnd >>>= 0\n\n if (this === target) return 0\n\n let x = thisEnd - thisStart\n let y = end - start\n const len = Math.min(x, y)\n\n const thisCopy = this.slice(thisStart, thisEnd)\n const targetCopy = target.slice(start, end)\n\n for (let i = 0; i < len; ++i) {\n if (thisCopy[i] !== targetCopy[i]) {\n x = thisCopy[i]\n y = targetCopy[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n // Empty buffer means no match\n if (buffer.length === 0) return -1\n\n // Normalize byteOffset\n if (typeof byteOffset === 'string') {\n encoding = byteOffset\n byteOffset = 0\n } else if (byteOffset > 0x7fffffff) {\n byteOffset = 0x7fffffff\n } else if (byteOffset < -0x80000000) {\n byteOffset = -0x80000000\n }\n byteOffset = +byteOffset // Coerce to Number.\n if (numberIsNaN(byteOffset)) {\n // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n byteOffset = dir ? 0 : (buffer.length - 1)\n }\n\n // Normalize byteOffset: negative offsets start from the end of the buffer\n if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n if (byteOffset >= buffer.length) {\n if (dir) return -1\n else byteOffset = buffer.length - 1\n } else if (byteOffset < 0) {\n if (dir) byteOffset = 0\n else return -1\n }\n\n // Normalize val\n if (typeof val === 'string') {\n val = Buffer.from(val, encoding)\n }\n\n // Finally, search either indexOf (if dir is true) or lastIndexOf\n if (Buffer.isBuffer(val)) {\n // Special case: looking for empty string/buffer always fails\n if (val.length === 0) {\n return -1\n }\n return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n } else if (typeof val === 'number') {\n val = val & 0xFF // Search for a byte value [0-255]\n if (typeof Uint8Array.prototype.indexOf === 'function') {\n if (dir) {\n return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n } else {\n return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n }\n }\n return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)\n }\n\n throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n let indexSize = 1\n let arrLength = arr.length\n let valLength = val.length\n\n if (encoding !== undefined) {\n encoding = String(encoding).toLowerCase()\n if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n encoding === 'utf16le' || encoding === 'utf-16le') {\n if (arr.length < 2 || val.length < 2) {\n return -1\n }\n indexSize = 2\n arrLength /= 2\n valLength /= 2\n byteOffset /= 2\n }\n }\n\n function read (buf, i) {\n if (indexSize === 1) {\n return buf[i]\n } else {\n return buf.readUInt16BE(i * indexSize)\n }\n }\n\n let i\n if (dir) {\n let foundIndex = -1\n for (i = byteOffset; i < arrLength; i++) {\n if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n if (foundIndex === -1) foundIndex = i\n if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n } else {\n if (foundIndex !== -1) i -= i - foundIndex\n foundIndex = -1\n }\n }\n } else {\n if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n for (i = byteOffset; i >= 0; i--) {\n let found = true\n for (let j = 0; j < valLength; j++) {\n if (read(arr, i + j) !== read(val, j)) {\n found = false\n break\n }\n }\n if (found) return i\n }\n }\n\n return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n offset = Number(offset) || 0\n const remaining = buf.length - offset\n if (!length) {\n length = remaining\n } else {\n length = Number(length)\n if (length > remaining) {\n length = remaining\n }\n }\n\n const strLen = string.length\n\n if (length > strLen / 2) {\n length = strLen / 2\n }\n let i\n for (i = 0; i < length; ++i) {\n const parsed = parseInt(string.substr(i * 2, 2), 16)\n if (numberIsNaN(parsed)) return i\n buf[offset + i] = parsed\n }\n return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n // Buffer#write(string)\n if (offset === undefined) {\n encoding = 'utf8'\n length = this.length\n offset = 0\n // Buffer#write(string, encoding)\n } else if (length === undefined && typeof offset === 'string') {\n encoding = offset\n length = this.length\n offset = 0\n // Buffer#write(string, offset[, length][, encoding])\n } else if (isFinite(offset)) {\n offset = offset >>> 0\n if (isFinite(length)) {\n length = length >>> 0\n if (encoding === undefined) encoding = 'utf8'\n } else {\n encoding = length\n length = undefined\n }\n } else {\n throw new Error(\n 'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n )\n }\n\n const remaining = this.length - offset\n if (length === undefined || length > remaining) length = remaining\n\n if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n throw new RangeError('Attempt to write outside buffer bounds')\n }\n\n if (!encoding) encoding = 'utf8'\n\n let loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'hex':\n return hexWrite(this, string, offset, length)\n\n case 'utf8':\n case 'utf-8':\n return utf8Write(this, string, offset, length)\n\n case 'ascii':\n case 'latin1':\n case 'binary':\n return asciiWrite(this, string, offset, length)\n\n case 'base64':\n // Warning: maxLength not taken into account in base64Write\n return base64Write(this, string, offset, length)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return ucs2Write(this, string, offset, length)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n return {\n type: 'Buffer',\n data: Array.prototype.slice.call(this._arr || this, 0)\n }\n}\n\nfunction base64Slice (buf, start, end) {\n if (start === 0 && end === buf.length) {\n return base64.fromByteArray(buf)\n } else {\n return base64.fromByteArray(buf.slice(start, end))\n }\n}\n\nfunction utf8Slice (buf, start, end) {\n end = Math.min(buf.length, end)\n const res = []\n\n let i = start\n while (i < end) {\n const firstByte = buf[i]\n let codePoint = null\n let bytesPerSequence = (firstByte > 0xEF)\n ? 4\n : (firstByte > 0xDF)\n ? 3\n : (firstByte > 0xBF)\n ? 2\n : 1\n\n if (i + bytesPerSequence <= end) {\n let secondByte, thirdByte, fourthByte, tempCodePoint\n\n switch (bytesPerSequence) {\n case 1:\n if (firstByte < 0x80) {\n codePoint = firstByte\n }\n break\n case 2:\n secondByte = buf[i + 1]\n if ((secondByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n if (tempCodePoint > 0x7F) {\n codePoint = tempCodePoint\n }\n }\n break\n case 3:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n codePoint = tempCodePoint\n }\n }\n break\n case 4:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n fourthByte = buf[i + 3]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n codePoint = tempCodePoint\n }\n }\n }\n }\n\n if (codePoint === null) {\n // we did not generate a valid codePoint so insert a\n // replacement char (U+FFFD) and advance only 1 byte\n codePoint = 0xFFFD\n bytesPerSequence = 1\n } else if (codePoint > 0xFFFF) {\n // encode to utf16 (surrogate pair dance)\n codePoint -= 0x10000\n res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n codePoint = 0xDC00 | codePoint & 0x3FF\n }\n\n res.push(codePoint)\n i += bytesPerSequence\n }\n\n return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nconst MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n const len = codePoints.length\n if (len <= MAX_ARGUMENTS_LENGTH) {\n return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n }\n\n // Decode in chunks to avoid \"call stack size exceeded\".\n let res = ''\n let i = 0\n while (i < len) {\n res += String.fromCharCode.apply(\n String,\n codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n )\n }\n return res\n}\n\nfunction asciiSlice (buf, start, end) {\n let ret = ''\n end = Math.min(buf.length, end)\n\n for (let i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i] & 0x7F)\n }\n return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n let ret = ''\n end = Math.min(buf.length, end)\n\n for (let i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i])\n }\n return ret\n}\n\nfunction hexSlice (buf, start, end) {\n const len = buf.length\n\n if (!start || start < 0) start = 0\n if (!end || end < 0 || end > len) end = len\n\n let out = ''\n for (let i = start; i < end; ++i) {\n out += hexSliceLookupTable[buf[i]]\n }\n return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n const bytes = buf.slice(start, end)\n let res = ''\n // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)\n for (let i = 0; i < bytes.length - 1; i += 2) {\n res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))\n }\n return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n const len = this.length\n start = ~~start\n end = end === undefined ? len : ~~end\n\n if (start < 0) {\n start += len\n if (start < 0) start = 0\n } else if (start > len) {\n start = len\n }\n\n if (end < 0) {\n end += len\n if (end < 0) end = 0\n } else if (end > len) {\n end = len\n }\n\n if (end < start) end = start\n\n const newBuf = this.subarray(start, end)\n // Return an augmented `Uint8Array` instance\n Object.setPrototypeOf(newBuf, Buffer.prototype)\n\n return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUintLE =\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n let val = this[offset]\n let mul = 1\n let i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUintBE =\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) {\n checkOffset(offset, byteLength, this.length)\n }\n\n let val = this[offset + --byteLength]\n let mul = 1\n while (byteLength > 0 && (mul *= 0x100)) {\n val += this[offset + --byteLength] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUint8 =\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 1, this.length)\n return this[offset]\n}\n\nBuffer.prototype.readUint16LE =\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 2, this.length)\n return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUint16BE =\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 2, this.length)\n return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUint32LE =\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return ((this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16)) +\n (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUint32BE =\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] * 0x1000000) +\n ((this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n this[offset + 3])\n}\n\nBuffer.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE (offset) {\n offset = offset >>> 0\n validateNumber(offset, 'offset')\n const first = this[offset]\n const last = this[offset + 7]\n if (first === undefined || last === undefined) {\n boundsError(offset, this.length - 8)\n }\n\n const lo = first +\n this[++offset] * 2 ** 8 +\n this[++offset] * 2 ** 16 +\n this[++offset] * 2 ** 24\n\n const hi = this[++offset] +\n this[++offset] * 2 ** 8 +\n this[++offset] * 2 ** 16 +\n last * 2 ** 24\n\n return BigInt(lo) + (BigInt(hi) << BigInt(32))\n})\n\nBuffer.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE (offset) {\n offset = offset >>> 0\n validateNumber(offset, 'offset')\n const first = this[offset]\n const last = this[offset + 7]\n if (first === undefined || last === undefined) {\n boundsError(offset, this.length - 8)\n }\n\n const hi = first * 2 ** 24 +\n this[++offset] * 2 ** 16 +\n this[++offset] * 2 ** 8 +\n this[++offset]\n\n const lo = this[++offset] * 2 ** 24 +\n this[++offset] * 2 ** 16 +\n this[++offset] * 2 ** 8 +\n last\n\n return (BigInt(hi) << BigInt(32)) + BigInt(lo)\n})\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n let val = this[offset]\n let mul = 1\n let i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n let i = byteLength\n let mul = 1\n let val = this[offset + --i]\n while (i > 0 && (mul *= 0x100)) {\n val += this[offset + --i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 1, this.length)\n if (!(this[offset] & 0x80)) return (this[offset])\n return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 2, this.length)\n const val = this[offset] | (this[offset + 1] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 2, this.length)\n const val = this[offset + 1] | (this[offset] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16) |\n (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] << 24) |\n (this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n (this[offset + 3])\n}\n\nBuffer.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE (offset) {\n offset = offset >>> 0\n validateNumber(offset, 'offset')\n const first = this[offset]\n const last = this[offset + 7]\n if (first === undefined || last === undefined) {\n boundsError(offset, this.length - 8)\n }\n\n const val = this[offset + 4] +\n this[offset + 5] * 2 ** 8 +\n this[offset + 6] * 2 ** 16 +\n (last << 24) // Overflow\n\n return (BigInt(val) << BigInt(32)) +\n BigInt(first +\n this[++offset] * 2 ** 8 +\n this[++offset] * 2 ** 16 +\n this[++offset] * 2 ** 24)\n})\n\nBuffer.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE (offset) {\n offset = offset >>> 0\n validateNumber(offset, 'offset')\n const first = this[offset]\n const last = this[offset + 7]\n if (first === undefined || last === undefined) {\n boundsError(offset, this.length - 8)\n }\n\n const val = (first << 24) + // Overflow\n this[++offset] * 2 ** 16 +\n this[++offset] * 2 ** 8 +\n this[++offset]\n\n return (BigInt(val) << BigInt(32)) +\n BigInt(this[++offset] * 2 ** 24 +\n this[++offset] * 2 ** 16 +\n this[++offset] * 2 ** 8 +\n last)\n})\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUintLE =\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) {\n const maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n let mul = 1\n let i = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUintBE =\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) {\n const maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n let i = byteLength - 1\n let mul = 1\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUint8 =\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nBuffer.prototype.writeUint16LE =\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n return offset + 2\n}\n\nBuffer.prototype.writeUint16BE =\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n return offset + 2\n}\n\nBuffer.prototype.writeUint32LE =\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n this[offset + 3] = (value >>> 24)\n this[offset + 2] = (value >>> 16)\n this[offset + 1] = (value >>> 8)\n this[offset] = (value & 0xff)\n return offset + 4\n}\n\nBuffer.prototype.writeUint32BE =\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n return offset + 4\n}\n\nfunction wrtBigUInt64LE (buf, value, offset, min, max) {\n checkIntBI(value, min, max, buf, offset, 7)\n\n let lo = Number(value & BigInt(0xffffffff))\n buf[offset++] = lo\n lo = lo >> 8\n buf[offset++] = lo\n lo = lo >> 8\n buf[offset++] = lo\n lo = lo >> 8\n buf[offset++] = lo\n let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n buf[offset++] = hi\n hi = hi >> 8\n buf[offset++] = hi\n hi = hi >> 8\n buf[offset++] = hi\n hi = hi >> 8\n buf[offset++] = hi\n return offset\n}\n\nfunction wrtBigUInt64BE (buf, value, offset, min, max) {\n checkIntBI(value, min, max, buf, offset, 7)\n\n let lo = Number(value & BigInt(0xffffffff))\n buf[offset + 7] = lo\n lo = lo >> 8\n buf[offset + 6] = lo\n lo = lo >> 8\n buf[offset + 5] = lo\n lo = lo >> 8\n buf[offset + 4] = lo\n let hi = Number(value >> BigInt(32) & BigInt(0xffffffff))\n buf[offset + 3] = hi\n hi = hi >> 8\n buf[offset + 2] = hi\n hi = hi >> 8\n buf[offset + 1] = hi\n hi = hi >> 8\n buf[offset] = hi\n return offset + 8\n}\n\nBuffer.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE (value, offset = 0) {\n return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE (value, offset = 0) {\n return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt('0xffffffffffffffff'))\n})\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) {\n const limit = Math.pow(2, (8 * byteLength) - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n let i = 0\n let mul = 1\n let sub = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) {\n const limit = Math.pow(2, (8 * byteLength) - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n let i = byteLength - 1\n let mul = 1\n let sub = 0\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n if (value < 0) value = 0xff + value + 1\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n this[offset + 2] = (value >>> 16)\n this[offset + 3] = (value >>> 24)\n return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (value < 0) value = 0xffffffff + value + 1\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n return offset + 4\n}\n\nBuffer.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE (value, offset = 0) {\n return wrtBigUInt64LE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n})\n\nBuffer.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE (value, offset = 0) {\n return wrtBigUInt64BE(this, value, offset, -BigInt('0x8000000000000000'), BigInt('0x7fffffffffffffff'))\n})\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n }\n ieee754.write(buf, value, offset, littleEndian, 23, 4)\n return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n }\n ieee754.write(buf, value, offset, littleEndian, 52, 8)\n return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\n if (!start) start = 0\n if (!end && end !== 0) end = this.length\n if (targetStart >= target.length) targetStart = target.length\n if (!targetStart) targetStart = 0\n if (end > 0 && end < start) end = start\n\n // Copy 0 bytes; we're done\n if (end === start) return 0\n if (target.length === 0 || this.length === 0) return 0\n\n // Fatal error conditions\n if (targetStart < 0) {\n throw new RangeError('targetStart out of bounds')\n }\n if (start < 0 || start >= this.length) throw new RangeError('Index out of range')\n if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n // Are we oob?\n if (end > this.length) end = this.length\n if (target.length - targetStart < end - start) {\n end = target.length - targetStart + start\n }\n\n const len = end - start\n\n if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\n // Use built-in when available, missing from IE11\n this.copyWithin(targetStart, start, end)\n } else {\n Uint8Array.prototype.set.call(\n target,\n this.subarray(start, end),\n targetStart\n )\n }\n\n return len\n}\n\n// Usage:\n// buffer.fill(number[, offset[, end]])\n// buffer.fill(buffer[, offset[, end]])\n// buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n // Handle string cases:\n if (typeof val === 'string') {\n if (typeof start === 'string') {\n encoding = start\n start = 0\n end = this.length\n } else if (typeof end === 'string') {\n encoding = end\n end = this.length\n }\n if (encoding !== undefined && typeof encoding !== 'string') {\n throw new TypeError('encoding must be a string')\n }\n if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n throw new TypeError('Unknown encoding: ' + encoding)\n }\n if (val.length === 1) {\n const code = val.charCodeAt(0)\n if ((encoding === 'utf8' && code < 128) ||\n encoding === 'latin1') {\n // Fast path: If `val` fits into a single byte, use that numeric value.\n val = code\n }\n }\n } else if (typeof val === 'number') {\n val = val & 255\n } else if (typeof val === 'boolean') {\n val = Number(val)\n }\n\n // Invalid ranges are not set to a default, so can range check early.\n if (start < 0 || this.length < start || this.length < end) {\n throw new RangeError('Out of range index')\n }\n\n if (end <= start) {\n return this\n }\n\n start = start >>> 0\n end = end === undefined ? this.length : end >>> 0\n\n if (!val) val = 0\n\n let i\n if (typeof val === 'number') {\n for (i = start; i < end; ++i) {\n this[i] = val\n }\n } else {\n const bytes = Buffer.isBuffer(val)\n ? val\n : Buffer.from(val, encoding)\n const len = bytes.length\n if (len === 0) {\n throw new TypeError('The value \"' + val +\n '\" is invalid for argument \"value\"')\n }\n for (i = 0; i < end - start; ++i) {\n this[i + start] = bytes[i % len]\n }\n }\n\n return this\n}\n\n// CUSTOM ERRORS\n// =============\n\n// Simplified versions from Node, changed for Buffer-only usage\nconst errors = {}\nfunction E (sym, getMessage, Base) {\n errors[sym] = class NodeError extends Base {\n constructor () {\n super()\n\n Object.defineProperty(this, 'message', {\n value: getMessage.apply(this, arguments),\n writable: true,\n configurable: true\n })\n\n // Add the error code to the name to include it in the stack trace.\n this.name = `${this.name} [${sym}]`\n // Access the stack to generate the error message including the error code\n // from the name.\n this.stack // eslint-disable-line no-unused-expressions\n // Reset the name to the actual name.\n delete this.name\n }\n\n get code () {\n return sym\n }\n\n set code (value) {\n Object.defineProperty(this, 'code', {\n configurable: true,\n enumerable: true,\n value,\n writable: true\n })\n }\n\n toString () {\n return `${this.name} [${sym}]: ${this.message}`\n }\n }\n}\n\nE('ERR_BUFFER_OUT_OF_BOUNDS',\n function (name) {\n if (name) {\n return `${name} is outside of buffer bounds`\n }\n\n return 'Attempt to access memory outside buffer bounds'\n }, RangeError)\nE('ERR_INVALID_ARG_TYPE',\n function (name, actual) {\n return `The \"${name}\" argument must be of type number. Received type ${typeof actual}`\n }, TypeError)\nE('ERR_OUT_OF_RANGE',\n function (str, range, input) {\n let msg = `The value of \"${str}\" is out of range.`\n let received = input\n if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {\n received = addNumericalSeparator(String(input))\n } else if (typeof input === 'bigint') {\n received = String(input)\n if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {\n received = addNumericalSeparator(received)\n }\n received += 'n'\n }\n msg += ` It must be ${range}. Received ${received}`\n return msg\n }, RangeError)\n\nfunction addNumericalSeparator (val) {\n let res = ''\n let i = val.length\n const start = val[0] === '-' ? 1 : 0\n for (; i >= start + 4; i -= 3) {\n res = `_${val.slice(i - 3, i)}${res}`\n }\n return `${val.slice(0, i)}${res}`\n}\n\n// CHECK FUNCTIONS\n// ===============\n\nfunction checkBounds (buf, offset, byteLength) {\n validateNumber(offset, 'offset')\n if (buf[offset] === undefined || buf[offset + byteLength] === undefined) {\n boundsError(offset, buf.length - (byteLength + 1))\n }\n}\n\nfunction checkIntBI (value, min, max, buf, offset, byteLength) {\n if (value > max || value < min) {\n const n = typeof min === 'bigint' ? 'n' : ''\n let range\n if (byteLength > 3) {\n if (min === 0 || min === BigInt(0)) {\n range = `>= 0${n} and < 2${n} ** ${(byteLength + 1) * 8}${n}`\n } else {\n range = `>= -(2${n} ** ${(byteLength + 1) * 8 - 1}${n}) and < 2 ** ` +\n `${(byteLength + 1) * 8 - 1}${n}`\n }\n } else {\n range = `>= ${min}${n} and <= ${max}${n}`\n }\n throw new errors.ERR_OUT_OF_RANGE('value', range, value)\n }\n checkBounds(buf, offset, byteLength)\n}\n\nfunction validateNumber (value, name) {\n if (typeof value !== 'number') {\n throw new errors.ERR_INVALID_ARG_TYPE(name, 'number', value)\n }\n}\n\nfunction boundsError (value, length, type) {\n if (Math.floor(value) !== value) {\n validateNumber(value, type)\n throw new errors.ERR_OUT_OF_RANGE(type || 'offset', 'an integer', value)\n }\n\n if (length < 0) {\n throw new errors.ERR_BUFFER_OUT_OF_BOUNDS()\n }\n\n throw new errors.ERR_OUT_OF_RANGE(type || 'offset',\n `>= ${type ? 1 : 0} and <= ${length}`,\n value)\n}\n\n// HELPER FUNCTIONS\n// ================\n\nconst INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n // Node takes equal signs as end of the Base64 encoding\n str = str.split('=')[0]\n // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n str = str.trim().replace(INVALID_BASE64_RE, '')\n // Node converts strings with length < 2 to ''\n if (str.length < 2) return ''\n // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n while (str.length % 4 !== 0) {\n str = str + '='\n }\n return str\n}\n\nfunction utf8ToBytes (string, units) {\n units = units || Infinity\n let codePoint\n const length = string.length\n let leadSurrogate = null\n const bytes = []\n\n for (let i = 0; i < length; ++i) {\n codePoint = string.charCodeAt(i)\n\n // is surrogate component\n if (codePoint > 0xD7FF && codePoint < 0xE000) {\n // last char was a lead\n if (!leadSurrogate) {\n // no lead yet\n if (codePoint > 0xDBFF) {\n // unexpected trail\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n } else if (i + 1 === length) {\n // unpaired lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n }\n\n // valid lead\n leadSurrogate = codePoint\n\n continue\n }\n\n // 2 leads in a row\n if (codePoint < 0xDC00) {\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n leadSurrogate = codePoint\n continue\n }\n\n // valid surrogate pair\n codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n } else if (leadSurrogate) {\n // valid bmp char, but last char was a lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n }\n\n leadSurrogate = null\n\n // encode utf8\n if (codePoint < 0x80) {\n if ((units -= 1) < 0) break\n bytes.push(codePoint)\n } else if (codePoint < 0x800) {\n if ((units -= 2) < 0) break\n bytes.push(\n codePoint >> 0x6 | 0xC0,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x10000) {\n if ((units -= 3) < 0) break\n bytes.push(\n codePoint >> 0xC | 0xE0,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x110000) {\n if ((units -= 4) < 0) break\n bytes.push(\n codePoint >> 0x12 | 0xF0,\n codePoint >> 0xC & 0x3F | 0x80,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else {\n throw new Error('Invalid code point')\n }\n }\n\n return bytes\n}\n\nfunction asciiToBytes (str) {\n const byteArray = []\n for (let i = 0; i < str.length; ++i) {\n // Node's code seems to be doing this and not & 0x7F..\n byteArray.push(str.charCodeAt(i) & 0xFF)\n }\n return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n let c, hi, lo\n const byteArray = []\n for (let i = 0; i < str.length; ++i) {\n if ((units -= 2) < 0) break\n\n c = str.charCodeAt(i)\n hi = c >> 8\n lo = c % 256\n byteArray.push(lo)\n byteArray.push(hi)\n }\n\n return byteArray\n}\n\nfunction base64ToBytes (str) {\n return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n let i\n for (i = 0; i < length; ++i) {\n if ((i + offset >= dst.length) || (i >= src.length)) break\n dst[i + offset] = src[i]\n }\n return i\n}\n\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n// the `instanceof` check but they should be treated as of that type.\n// See: https://github.com/feross/buffer/issues/166\nfunction isInstance (obj, type) {\n return obj instanceof type ||\n (obj != null && obj.constructor != null && obj.constructor.name != null &&\n obj.constructor.name === type.name)\n}\nfunction numberIsNaN (obj) {\n // For IE11 support\n return obj !== obj // eslint-disable-line no-self-compare\n}\n\n// Create lookup table for `toString('hex')`\n// See: https://github.com/feross/buffer/issues/219\nconst hexSliceLookupTable = (function () {\n const alphabet = '0123456789abcdef'\n const table = new Array(256)\n for (let i = 0; i < 16; ++i) {\n const i16 = i * 16\n for (let j = 0; j < 16; ++j) {\n table[i16 + j] = alphabet[i] + alphabet[j]\n }\n }\n return table\n})()\n\n// Return not function with Error if BigInt not supported\nfunction defineBigIntMethod (fn) {\n return typeof BigInt === 'undefined' ? BufferBigIntNotDefined : fn\n}\n\nfunction BufferBigIntNotDefined () {\n throw new Error('BigInt not supported')\n}\n","module.exports = {\n \"100\": \"Continue\",\n \"101\": \"Switching Protocols\",\n \"102\": \"Processing\",\n \"200\": \"OK\",\n \"201\": \"Created\",\n \"202\": \"Accepted\",\n \"203\": \"Non-Authoritative Information\",\n \"204\": \"No Content\",\n \"205\": \"Reset Content\",\n \"206\": \"Partial Content\",\n \"207\": \"Multi-Status\",\n \"208\": \"Already Reported\",\n \"226\": \"IM Used\",\n \"300\": \"Multiple Choices\",\n \"301\": \"Moved Permanently\",\n \"302\": \"Found\",\n \"303\": \"See Other\",\n \"304\": \"Not Modified\",\n \"305\": \"Use Proxy\",\n \"307\": \"Temporary Redirect\",\n \"308\": \"Permanent Redirect\",\n \"400\": \"Bad Request\",\n \"401\": \"Unauthorized\",\n \"402\": \"Payment Required\",\n \"403\": \"Forbidden\",\n \"404\": \"Not Found\",\n \"405\": \"Method Not Allowed\",\n \"406\": \"Not Acceptable\",\n \"407\": \"Proxy Authentication Required\",\n \"408\": \"Request Timeout\",\n \"409\": \"Conflict\",\n \"410\": \"Gone\",\n \"411\": \"Length Required\",\n \"412\": \"Precondition Failed\",\n \"413\": \"Payload Too Large\",\n \"414\": \"URI Too Long\",\n \"415\": \"Unsupported Media Type\",\n \"416\": \"Range Not Satisfiable\",\n \"417\": \"Expectation Failed\",\n \"418\": \"I'm a teapot\",\n \"421\": \"Misdirected Request\",\n \"422\": \"Unprocessable Entity\",\n \"423\": \"Locked\",\n \"424\": \"Failed Dependency\",\n \"425\": \"Unordered Collection\",\n \"426\": \"Upgrade Required\",\n \"428\": \"Precondition Required\",\n \"429\": \"Too Many Requests\",\n \"431\": \"Request Header Fields Too Large\",\n \"451\": \"Unavailable For Legal Reasons\",\n \"500\": \"Internal Server Error\",\n \"501\": \"Not Implemented\",\n \"502\": \"Bad Gateway\",\n \"503\": \"Service Unavailable\",\n \"504\": \"Gateway Timeout\",\n \"505\": \"HTTP Version Not Supported\",\n \"506\": \"Variant Also Negotiates\",\n \"507\": \"Insufficient Storage\",\n \"508\": \"Loop Detected\",\n \"509\": \"Bandwidth Limit Exceeded\",\n \"510\": \"Not Extended\",\n \"511\": \"Network Authentication Required\"\n}\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar callBind = require('./');\n\nvar $indexOf = callBind(GetIntrinsic('String.prototype.indexOf'));\n\nmodule.exports = function callBoundIntrinsic(name, allowMissing) {\n\tvar intrinsic = GetIntrinsic(name, !!allowMissing);\n\tif (typeof intrinsic === 'function' && $indexOf(name, '.prototype.') > -1) {\n\t\treturn callBind(intrinsic);\n\t}\n\treturn intrinsic;\n};\n","'use strict';\n\nvar bind = require('function-bind');\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $apply = GetIntrinsic('%Function.prototype.apply%');\nvar $call = GetIntrinsic('%Function.prototype.call%');\nvar $reflectApply = GetIntrinsic('%Reflect.apply%', true) || bind.call($call, $apply);\n\nvar $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);\nvar $defineProperty = GetIntrinsic('%Object.defineProperty%', true);\nvar $max = GetIntrinsic('%Math.max%');\n\nif ($defineProperty) {\n\ttry {\n\t\t$defineProperty({}, 'a', { value: 1 });\n\t} catch (e) {\n\t\t// IE 8 has a broken defineProperty\n\t\t$defineProperty = null;\n\t}\n}\n\nmodule.exports = function callBind(originalFunction) {\n\tvar func = $reflectApply(bind, $call, arguments);\n\tif ($gOPD && $defineProperty) {\n\t\tvar desc = $gOPD(func, 'length');\n\t\tif (desc.configurable) {\n\t\t\t// original length, plus the receiver, minus any additional arguments (after the receiver)\n\t\t\t$defineProperty(\n\t\t\t\tfunc,\n\t\t\t\t'length',\n\t\t\t\t{ value: 1 + $max(0, originalFunction.length - (arguments.length - 1)) }\n\t\t\t);\n\t\t}\n\t}\n\treturn func;\n};\n\nvar applyBind = function applyBind() {\n\treturn $reflectApply(bind, $apply, arguments);\n};\n\nif ($defineProperty) {\n\t$defineProperty(module.exports, 'apply', { value: applyBind });\n} else {\n\tmodule.exports.apply = applyBind;\n}\n","var Buffer = require('safe-buffer').Buffer\nvar Transform = require('stream').Transform\nvar StringDecoder = require('string_decoder').StringDecoder\nvar inherits = require('inherits')\n\nfunction CipherBase (hashMode) {\n Transform.call(this)\n this.hashMode = typeof hashMode === 'string'\n if (this.hashMode) {\n this[hashMode] = this._finalOrDigest\n } else {\n this.final = this._finalOrDigest\n }\n if (this._final) {\n this.__final = this._final\n this._final = null\n }\n this._decoder = null\n this._encoding = null\n}\ninherits(CipherBase, Transform)\n\nCipherBase.prototype.update = function (data, inputEnc, outputEnc) {\n if (typeof data === 'string') {\n data = Buffer.from(data, inputEnc)\n }\n\n var outData = this._update(data)\n if (this.hashMode) return this\n\n if (outputEnc) {\n outData = this._toString(outData, outputEnc)\n }\n\n return outData\n}\n\nCipherBase.prototype.setAutoPadding = function () {}\nCipherBase.prototype.getAuthTag = function () {\n throw new Error('trying to get auth tag in unsupported state')\n}\n\nCipherBase.prototype.setAuthTag = function () {\n throw new Error('trying to set auth tag in unsupported state')\n}\n\nCipherBase.prototype.setAAD = function () {\n throw new Error('trying to set aad in unsupported state')\n}\n\nCipherBase.prototype._transform = function (data, _, next) {\n var err\n try {\n if (this.hashMode) {\n this._update(data)\n } else {\n this.push(this._update(data))\n }\n } catch (e) {\n err = e\n } finally {\n next(err)\n }\n}\nCipherBase.prototype._flush = function (done) {\n var err\n try {\n this.push(this.__final())\n } catch (e) {\n err = e\n }\n\n done(err)\n}\nCipherBase.prototype._finalOrDigest = function (outputEnc) {\n var outData = this.__final() || Buffer.alloc(0)\n if (outputEnc) {\n outData = this._toString(outData, outputEnc, true)\n }\n return outData\n}\n\nCipherBase.prototype._toString = function (value, enc, fin) {\n if (!this._decoder) {\n this._decoder = new StringDecoder(enc)\n this._encoding = enc\n }\n\n if (this._encoding !== enc) throw new Error('can\\'t switch encodings')\n\n var out = this._decoder.write(value)\n if (fin) {\n out += this._decoder.end()\n }\n\n return out\n}\n\nmodule.exports = CipherBase\n","var elliptic = require('elliptic')\nvar BN = require('bn.js')\n\nmodule.exports = function createECDH (curve) {\n return new ECDH(curve)\n}\n\nvar aliases = {\n secp256k1: {\n name: 'secp256k1',\n byteLength: 32\n },\n secp224r1: {\n name: 'p224',\n byteLength: 28\n },\n prime256v1: {\n name: 'p256',\n byteLength: 32\n },\n prime192v1: {\n name: 'p192',\n byteLength: 24\n },\n ed25519: {\n name: 'ed25519',\n byteLength: 32\n },\n secp384r1: {\n name: 'p384',\n byteLength: 48\n },\n secp521r1: {\n name: 'p521',\n byteLength: 66\n }\n}\n\naliases.p224 = aliases.secp224r1\naliases.p256 = aliases.secp256r1 = aliases.prime256v1\naliases.p192 = aliases.secp192r1 = aliases.prime192v1\naliases.p384 = aliases.secp384r1\naliases.p521 = aliases.secp521r1\n\nfunction ECDH (curve) {\n this.curveType = aliases[curve]\n if (!this.curveType) {\n this.curveType = {\n name: curve\n }\n }\n this.curve = new elliptic.ec(this.curveType.name) // eslint-disable-line new-cap\n this.keys = void 0\n}\n\nECDH.prototype.generateKeys = function (enc, format) {\n this.keys = this.curve.genKeyPair()\n return this.getPublicKey(enc, format)\n}\n\nECDH.prototype.computeSecret = function (other, inenc, enc) {\n inenc = inenc || 'utf8'\n if (!Buffer.isBuffer(other)) {\n other = new Buffer(other, inenc)\n }\n var otherPub = this.curve.keyFromPublic(other).getPublic()\n var out = otherPub.mul(this.keys.getPrivate()).getX()\n return formatReturnValue(out, enc, this.curveType.byteLength)\n}\n\nECDH.prototype.getPublicKey = function (enc, format) {\n var key = this.keys.getPublic(format === 'compressed', true)\n if (format === 'hybrid') {\n if (key[key.length - 1] % 2) {\n key[0] = 7\n } else {\n key[0] = 6\n }\n }\n return formatReturnValue(key, enc)\n}\n\nECDH.prototype.getPrivateKey = function (enc) {\n return formatReturnValue(this.keys.getPrivate(), enc)\n}\n\nECDH.prototype.setPublicKey = function (pub, enc) {\n enc = enc || 'utf8'\n if (!Buffer.isBuffer(pub)) {\n pub = new Buffer(pub, enc)\n }\n this.keys._importPublic(pub)\n return this\n}\n\nECDH.prototype.setPrivateKey = function (priv, enc) {\n enc = enc || 'utf8'\n if (!Buffer.isBuffer(priv)) {\n priv = new Buffer(priv, enc)\n }\n\n var _priv = new BN(priv)\n _priv = _priv.toString(16)\n this.keys = this.curve.genKeyPair()\n this.keys._importPrivate(_priv)\n return this\n}\n\nfunction formatReturnValue (bn, enc, len) {\n if (!Array.isArray(bn)) {\n bn = bn.toArray()\n }\n var buf = new Buffer(bn)\n if (len && buf.length < len) {\n var zeros = new Buffer(len - buf.length)\n zeros.fill(0)\n buf = Buffer.concat([zeros, buf])\n }\n if (!enc) {\n return buf\n } else {\n return buf.toString(enc)\n }\n}\n","'use strict'\nvar inherits = require('inherits')\nvar MD5 = require('md5.js')\nvar RIPEMD160 = require('ripemd160')\nvar sha = require('sha.js')\nvar Base = require('cipher-base')\n\nfunction Hash (hash) {\n Base.call(this, 'digest')\n\n this._hash = hash\n}\n\ninherits(Hash, Base)\n\nHash.prototype._update = function (data) {\n this._hash.update(data)\n}\n\nHash.prototype._final = function () {\n return this._hash.digest()\n}\n\nmodule.exports = function createHash (alg) {\n alg = alg.toLowerCase()\n if (alg === 'md5') return new MD5()\n if (alg === 'rmd160' || alg === 'ripemd160') return new RIPEMD160()\n\n return new Hash(sha(alg))\n}\n","var MD5 = require('md5.js')\n\nmodule.exports = function (buffer) {\n return new MD5().update(buffer).digest()\n}\n","'use strict'\nvar inherits = require('inherits')\nvar Legacy = require('./legacy')\nvar Base = require('cipher-base')\nvar Buffer = require('safe-buffer').Buffer\nvar md5 = require('create-hash/md5')\nvar RIPEMD160 = require('ripemd160')\n\nvar sha = require('sha.js')\n\nvar ZEROS = Buffer.alloc(128)\n\nfunction Hmac (alg, key) {\n Base.call(this, 'digest')\n if (typeof key === 'string') {\n key = Buffer.from(key)\n }\n\n var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64\n\n this._alg = alg\n this._key = key\n if (key.length > blocksize) {\n var hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)\n key = hash.update(key).digest()\n } else if (key.length < blocksize) {\n key = Buffer.concat([key, ZEROS], blocksize)\n }\n\n var ipad = this._ipad = Buffer.allocUnsafe(blocksize)\n var opad = this._opad = Buffer.allocUnsafe(blocksize)\n\n for (var i = 0; i < blocksize; i++) {\n ipad[i] = key[i] ^ 0x36\n opad[i] = key[i] ^ 0x5C\n }\n this._hash = alg === 'rmd160' ? new RIPEMD160() : sha(alg)\n this._hash.update(ipad)\n}\n\ninherits(Hmac, Base)\n\nHmac.prototype._update = function (data) {\n this._hash.update(data)\n}\n\nHmac.prototype._final = function () {\n var h = this._hash.digest()\n var hash = this._alg === 'rmd160' ? new RIPEMD160() : sha(this._alg)\n return hash.update(this._opad).update(h).digest()\n}\n\nmodule.exports = function createHmac (alg, key) {\n alg = alg.toLowerCase()\n if (alg === 'rmd160' || alg === 'ripemd160') {\n return new Hmac('rmd160', key)\n }\n if (alg === 'md5') {\n return new Legacy(md5, key)\n }\n return new Hmac(alg, key)\n}\n","'use strict'\nvar inherits = require('inherits')\nvar Buffer = require('safe-buffer').Buffer\n\nvar Base = require('cipher-base')\n\nvar ZEROS = Buffer.alloc(128)\nvar blocksize = 64\n\nfunction Hmac (alg, key) {\n Base.call(this, 'digest')\n if (typeof key === 'string') {\n key = Buffer.from(key)\n }\n\n this._alg = alg\n this._key = key\n\n if (key.length > blocksize) {\n key = alg(key)\n } else if (key.length < blocksize) {\n key = Buffer.concat([key, ZEROS], blocksize)\n }\n\n var ipad = this._ipad = Buffer.allocUnsafe(blocksize)\n var opad = this._opad = Buffer.allocUnsafe(blocksize)\n\n for (var i = 0; i < blocksize; i++) {\n ipad[i] = key[i] ^ 0x36\n opad[i] = key[i] ^ 0x5C\n }\n\n this._hash = [ipad]\n}\n\ninherits(Hmac, Base)\n\nHmac.prototype._update = function (data) {\n this._hash.push(data)\n}\n\nHmac.prototype._final = function () {\n var h = this._alg(Buffer.concat(this._hash))\n return this._alg(Buffer.concat([this._opad, h]))\n}\nmodule.exports = Hmac\n","'use strict'\n\nexports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = require('randombytes')\nexports.createHash = exports.Hash = require('create-hash')\nexports.createHmac = exports.Hmac = require('create-hmac')\n\nvar algos = require('browserify-sign/algos')\nvar algoKeys = Object.keys(algos)\nvar hashes = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'].concat(algoKeys)\nexports.getHashes = function () {\n return hashes\n}\n\nvar p = require('pbkdf2')\nexports.pbkdf2 = p.pbkdf2\nexports.pbkdf2Sync = p.pbkdf2Sync\n\nvar aes = require('browserify-cipher')\n\nexports.Cipher = aes.Cipher\nexports.createCipher = aes.createCipher\nexports.Cipheriv = aes.Cipheriv\nexports.createCipheriv = aes.createCipheriv\nexports.Decipher = aes.Decipher\nexports.createDecipher = aes.createDecipher\nexports.Decipheriv = aes.Decipheriv\nexports.createDecipheriv = aes.createDecipheriv\nexports.getCiphers = aes.getCiphers\nexports.listCiphers = aes.listCiphers\n\nvar dh = require('diffie-hellman')\n\nexports.DiffieHellmanGroup = dh.DiffieHellmanGroup\nexports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup\nexports.getDiffieHellman = dh.getDiffieHellman\nexports.createDiffieHellman = dh.createDiffieHellman\nexports.DiffieHellman = dh.DiffieHellman\n\nvar sign = require('browserify-sign')\n\nexports.createSign = sign.createSign\nexports.Sign = sign.Sign\nexports.createVerify = sign.createVerify\nexports.Verify = sign.Verify\n\nexports.createECDH = require('create-ecdh')\n\nvar publicEncrypt = require('public-encrypt')\n\nexports.publicEncrypt = publicEncrypt.publicEncrypt\nexports.privateEncrypt = publicEncrypt.privateEncrypt\nexports.publicDecrypt = publicEncrypt.publicDecrypt\nexports.privateDecrypt = publicEncrypt.privateDecrypt\n\n// the least I can do is make error messages for the rest of the node.js/crypto api.\n// ;[\n// 'createCredentials'\n// ].forEach(function (name) {\n// exports[name] = function () {\n// throw new Error([\n// 'sorry, ' + name + ' is not implemented yet',\n// 'we accept pull requests',\n// 'https://github.com/crypto-browserify/crypto-browserify'\n// ].join('\\n'))\n// }\n// })\n\nvar rf = require('randomfill')\n\nexports.randomFill = rf.randomFill\nexports.randomFillSync = rf.randomFillSync\n\nexports.createCredentials = function () {\n throw new Error([\n 'sorry, createCredentials is not implemented yet',\n 'we accept pull requests',\n 'https://github.com/crypto-browserify/crypto-browserify'\n ].join('\\n'))\n}\n\nexports.constants = {\n 'DH_CHECK_P_NOT_SAFE_PRIME': 2,\n 'DH_CHECK_P_NOT_PRIME': 1,\n 'DH_UNABLE_TO_CHECK_GENERATOR': 4,\n 'DH_NOT_SUITABLE_GENERATOR': 8,\n 'NPN_ENABLED': 1,\n 'ALPN_ENABLED': 1,\n 'RSA_PKCS1_PADDING': 1,\n 'RSA_SSLV23_PADDING': 2,\n 'RSA_NO_PADDING': 3,\n 'RSA_PKCS1_OAEP_PADDING': 4,\n 'RSA_X931_PADDING': 5,\n 'RSA_PKCS1_PSS_PADDING': 6,\n 'POINT_CONVERSION_COMPRESSED': 2,\n 'POINT_CONVERSION_UNCOMPRESSED': 4,\n 'POINT_CONVERSION_HYBRID': 6\n}\n",";(function (globalScope) {\r\n 'use strict';\r\n\r\n\r\n /*!\r\n * decimal.js v10.4.3\r\n * An arbitrary-precision Decimal type for JavaScript.\r\n * https://github.com/MikeMcl/decimal.js\r\n * Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>\r\n * MIT Licence\r\n */\r\n\r\n\r\n // ----------------------------------- EDITABLE DEFAULTS ------------------------------------ //\r\n\r\n\r\n // The maximum exponent magnitude.\r\n // The limit on the value of `toExpNeg`, `toExpPos`, `minE` and `maxE`.\r\n var EXP_LIMIT = 9e15, // 0 to 9e15\r\n\r\n // The limit on the value of `precision`, and on the value of the first argument to\r\n // `toDecimalPlaces`, `toExponential`, `toFixed`, `toPrecision` and `toSignificantDigits`.\r\n MAX_DIGITS = 1e9, // 0 to 1e9\r\n\r\n // Base conversion alphabet.\r\n NUMERALS = '0123456789abcdef',\r\n\r\n // The natural logarithm of 10 (1025 digits).\r\n LN10 = '2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058',\r\n\r\n // Pi (1025 digits).\r\n PI = '3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789',\r\n\r\n\r\n // The initial configuration properties of the Decimal constructor.\r\n DEFAULTS = {\r\n\r\n // These values must be integers within the stated ranges (inclusive).\r\n // Most of these values can be changed at run-time using the `Decimal.config` method.\r\n\r\n // The maximum number of significant digits of the result of a calculation or base conversion.\r\n // E.g. `Decimal.config({ precision: 20 });`\r\n precision: 20, // 1 to MAX_DIGITS\r\n\r\n // The rounding mode used when rounding to `precision`.\r\n //\r\n // ROUND_UP 0 Away from zero.\r\n // ROUND_DOWN 1 Towards zero.\r\n // ROUND_CEIL 2 Towards +Infinity.\r\n // ROUND_FLOOR 3 Towards -Infinity.\r\n // ROUND_HALF_UP 4 Towards nearest neighbour. If equidistant, up.\r\n // ROUND_HALF_DOWN 5 Towards nearest neighbour. If equidistant, down.\r\n // ROUND_HALF_EVEN 6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n // ROUND_HALF_CEIL 7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n // ROUND_HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n //\r\n // E.g.\r\n // `Decimal.rounding = 4;`\r\n // `Decimal.rounding = Decimal.ROUND_HALF_UP;`\r\n rounding: 4, // 0 to 8\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 (JavaScript %).\r\n // FLOOR 3 The remainder has the same sign as the divisor (Python %).\r\n // HALF_EVEN 6 The IEEE 754 remainder function.\r\n // EUCLID 9 Euclidian division. q = sign(n) * floor(a / abs(n)). Always positive.\r\n //\r\n // Truncated division (1), floored division (3), the IEEE 754 remainder (6), and Euclidian\r\n // division (9) are commonly used for the modulus operation. The other rounding modes can also\r\n // be used, but they may not give useful results.\r\n modulo: 1, // 0 to 9\r\n\r\n // The exponent value at and beneath which `toString` returns exponential notation.\r\n // JavaScript numbers: -7\r\n toExpNeg: -7, // 0 to -EXP_LIMIT\r\n\r\n // The exponent value at and above which `toString` returns exponential notation.\r\n // JavaScript numbers: 21\r\n toExpPos: 21, // 0 to EXP_LIMIT\r\n\r\n // The minimum exponent value, beneath which underflow to zero occurs.\r\n // JavaScript numbers: -324 (5e-324)\r\n minE: -EXP_LIMIT, // -1 to -EXP_LIMIT\r\n\r\n // The maximum exponent value, above which overflow to Infinity occurs.\r\n // JavaScript numbers: 308 (1.7976931348623157e+308)\r\n maxE: EXP_LIMIT, // 1 to EXP_LIMIT\r\n\r\n // Whether to use cryptographically-secure random number generation, if available.\r\n crypto: false // true/false\r\n },\r\n\r\n\r\n // ----------------------------------- END OF EDITABLE DEFAULTS ------------------------------- //\r\n\r\n\r\n Decimal, inexact, noConflict, quadrant,\r\n external = true,\r\n\r\n decimalError = '[DecimalError] ',\r\n invalidArgument = decimalError + 'Invalid argument: ',\r\n precisionLimitExceeded = decimalError + 'Precision limit exceeded',\r\n cryptoUnavailable = decimalError + 'crypto unavailable',\r\n tag = '[object Decimal]',\r\n\r\n mathfloor = Math.floor,\r\n mathpow = Math.pow,\r\n\r\n isBinary = /^0b([01]+(\\.[01]*)?|\\.[01]+)(p[+-]?\\d+)?$/i,\r\n isHex = /^0x([0-9a-f]+(\\.[0-9a-f]*)?|\\.[0-9a-f]+)(p[+-]?\\d+)?$/i,\r\n isOctal = /^0o([0-7]+(\\.[0-7]*)?|\\.[0-7]+)(p[+-]?\\d+)?$/i,\r\n isDecimal = /^(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i,\r\n\r\n BASE = 1e7,\r\n LOG_BASE = 7,\r\n MAX_SAFE_INTEGER = 9007199254740991,\r\n\r\n LN10_PRECISION = LN10.length - 1,\r\n PI_PRECISION = PI.length - 1,\r\n\r\n // Decimal.prototype object\r\n P = { toStringTag: tag };\r\n\r\n\r\n // Decimal prototype methods\r\n\r\n\r\n /*\r\n * absoluteValue abs\r\n * ceil\r\n * clampedTo clamp\r\n * comparedTo cmp\r\n * cosine cos\r\n * cubeRoot cbrt\r\n * decimalPlaces dp\r\n * dividedBy div\r\n * dividedToIntegerBy divToInt\r\n * equals eq\r\n * floor\r\n * greaterThan gt\r\n * greaterThanOrEqualTo gte\r\n * hyperbolicCosine cosh\r\n * hyperbolicSine sinh\r\n * hyperbolicTangent tanh\r\n * inverseCosine acos\r\n * inverseHyperbolicCosine acosh\r\n * inverseHyperbolicSine asinh\r\n * inverseHyperbolicTangent atanh\r\n * inverseSine asin\r\n * inverseTangent atan\r\n * isFinite\r\n * isInteger isInt\r\n * isNaN\r\n * isNegative isNeg\r\n * isPositive isPos\r\n * isZero\r\n * lessThan lt\r\n * lessThanOrEqualTo lte\r\n * logarithm log\r\n * [maximum] [max]\r\n * [minimum] [min]\r\n * minus sub\r\n * modulo mod\r\n * naturalExponential exp\r\n * naturalLogarithm ln\r\n * negated neg\r\n * plus add\r\n * precision sd\r\n * round\r\n * sine sin\r\n * squareRoot sqrt\r\n * tangent tan\r\n * times mul\r\n * toBinary\r\n * toDecimalPlaces toDP\r\n * toExponential\r\n * toFixed\r\n * toFraction\r\n * toHexadecimal toHex\r\n * toNearest\r\n * toNumber\r\n * toOctal\r\n * toPower pow\r\n * toPrecision\r\n * toSignificantDigits toSD\r\n * toString\r\n * truncated trunc\r\n * valueOf toJSON\r\n */\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the absolute value of this Decimal.\r\n *\r\n */\r\n P.absoluteValue = P.abs = function () {\r\n var x = new this.constructor(this);\r\n if (x.s < 0) x.s = 1;\r\n return finalise(x);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal rounded to a whole number in the\r\n * direction of positive Infinity.\r\n *\r\n */\r\n P.ceil = function () {\r\n return finalise(new this.constructor(this), this.e + 1, 2);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal clamped to the range\r\n * delineated by `min` and `max`.\r\n *\r\n * min {number|string|Decimal}\r\n * max {number|string|Decimal}\r\n *\r\n */\r\n P.clampedTo = P.clamp = function (min, max) {\r\n var k,\r\n x = this,\r\n Ctor = x.constructor;\r\n min = new Ctor(min);\r\n max = new Ctor(max);\r\n if (!min.s || !max.s) return new Ctor(NaN);\r\n if (min.gt(max)) throw Error(invalidArgument + max);\r\n k = x.cmp(min);\r\n return k < 0 ? min : x.cmp(max) > 0 ? max : new Ctor(x);\r\n };\r\n\r\n\r\n /*\r\n * Return\r\n * 1 if the value of this Decimal is greater than the value of `y`,\r\n * -1 if the value of this Decimal is less than the value of `y`,\r\n * 0 if they have the same value,\r\n * NaN if the value of either Decimal is NaN.\r\n *\r\n */\r\n P.comparedTo = P.cmp = function (y) {\r\n var i, j, xdL, ydL,\r\n x = this,\r\n xd = x.d,\r\n yd = (y = new x.constructor(y)).d,\r\n xs = x.s,\r\n ys = y.s;\r\n\r\n // Either NaN or ±Infinity?\r\n if (!xd || !yd) {\r\n return !xs || !ys ? NaN : xs !== ys ? xs : xd === yd ? 0 : !xd ^ xs < 0 ? 1 : -1;\r\n }\r\n\r\n // Either zero?\r\n if (!xd[0] || !yd[0]) return xd[0] ? xs : yd[0] ? -ys : 0;\r\n\r\n // Signs differ?\r\n if (xs !== ys) return xs;\r\n\r\n // Compare exponents.\r\n if (x.e !== y.e) return x.e > y.e ^ xs < 0 ? 1 : -1;\r\n\r\n xdL = xd.length;\r\n ydL = yd.length;\r\n\r\n // Compare digit by digit.\r\n for (i = 0, j = xdL < ydL ? xdL : ydL; i < j; ++i) {\r\n if (xd[i] !== yd[i]) return xd[i] > yd[i] ^ xs < 0 ? 1 : -1;\r\n }\r\n\r\n // Compare lengths.\r\n return xdL === ydL ? 0 : xdL > ydL ^ xs < 0 ? 1 : -1;\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the cosine of the value in radians of this Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-1, 1]\r\n *\r\n * cos(0) = 1\r\n * cos(-0) = 1\r\n * cos(Infinity) = NaN\r\n * cos(-Infinity) = NaN\r\n * cos(NaN) = NaN\r\n *\r\n */\r\n P.cosine = P.cos = function () {\r\n var pr, rm,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.d) return new Ctor(NaN);\r\n\r\n // cos(0) = cos(-0) = 1\r\n if (!x.d[0]) return new Ctor(1);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + Math.max(x.e, x.sd()) + LOG_BASE;\r\n Ctor.rounding = 1;\r\n\r\n x = cosine(Ctor, toLessThanHalfPi(Ctor, x));\r\n\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return finalise(quadrant == 2 || quadrant == 3 ? x.neg() : x, pr, rm, true);\r\n };\r\n\r\n\r\n /*\r\n *\r\n * Return a new Decimal whose value is the cube root of the value of this Decimal, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * cbrt(0) = 0\r\n * cbrt(-0) = -0\r\n * cbrt(1) = 1\r\n * cbrt(-1) = -1\r\n * cbrt(N) = N\r\n * cbrt(-I) = -I\r\n * cbrt(I) = I\r\n *\r\n * Math.cbrt(x) = (x < 0 ? -Math.pow(-x, 1/3) : Math.pow(x, 1/3))\r\n *\r\n */\r\n P.cubeRoot = P.cbrt = function () {\r\n var e, m, n, r, rep, s, sd, t, t3, t3plusx,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.isFinite() || x.isZero()) return new Ctor(x);\r\n external = false;\r\n\r\n // Initial estimate.\r\n s = x.s * mathpow(x.s * x, 1 / 3);\r\n\r\n // Math.cbrt underflow/overflow?\r\n // Pass x to Math.pow as integer, then adjust the exponent of the result.\r\n if (!s || Math.abs(s) == 1 / 0) {\r\n n = digitsToString(x.d);\r\n e = x.e;\r\n\r\n // Adjust n exponent so it is a multiple of 3 away from x exponent.\r\n if (s = (e - n.length + 1) % 3) n += (s == 1 || s == -2 ? '0' : '00');\r\n s = mathpow(n, 1 / 3);\r\n\r\n // Rarely, e may be one less than the result exponent value.\r\n e = mathfloor((e + 1) / 3) - (e % 3 == (e < 0 ? -1 : 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 Ctor(n);\r\n r.s = x.s;\r\n } else {\r\n r = new Ctor(s.toString());\r\n }\r\n\r\n sd = (e = Ctor.precision) + 3;\r\n\r\n // Halley's method.\r\n // TODO? Compare Newton's method.\r\n for (;;) {\r\n t = r;\r\n t3 = t.times(t).times(t);\r\n t3plusx = t3.plus(x);\r\n r = divide(t3plusx.plus(x).times(t), t3plusx.plus(t3), sd + 2, 1);\r\n\r\n // TODO? Replace with for-loop and checkRoundingDigits.\r\n if (digitsToString(t.d).slice(0, sd) === (n = digitsToString(r.d)).slice(0, sd)) {\r\n n = n.slice(sd - 3, sd + 1);\r\n\r\n // The 4th rounding digit may be in error by -1 so if the 4 rounding digits are 9999 or 4999\r\n // , i.e. approaching a rounding boundary, continue the 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 exact result as the\r\n // nines may infinitely repeat.\r\n if (!rep) {\r\n finalise(t, e + 1, 0);\r\n\r\n if (t.times(t).times(t).eq(x)) {\r\n r = t;\r\n break;\r\n }\r\n }\r\n\r\n sd += 4;\r\n rep = 1;\r\n } else {\r\n\r\n // If the rounding digits are null, 0{0,4} or 50{0,3}, check for an exact result.\r\n // 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 finalise(r, e + 1, 1);\r\n m = !r.times(r).times(r).eq(x);\r\n }\r\n\r\n break;\r\n }\r\n }\r\n }\r\n\r\n external = true;\r\n\r\n return finalise(r, e, Ctor.rounding, m);\r\n };\r\n\r\n\r\n /*\r\n * Return the number of decimal places of the value of this Decimal.\r\n *\r\n */\r\n P.decimalPlaces = P.dp = function () {\r\n var w,\r\n d = this.d,\r\n n = NaN;\r\n\r\n if (d) {\r\n w = d.length - 1;\r\n n = (w - mathfloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n // Subtract the number of trailing zeros of the last word.\r\n w = d[w];\r\n if (w) for (; w % 10 == 0; w /= 10) n--;\r\n if (n < 0) n = 0;\r\n }\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 Decimal whose value is the value of this Decimal divided by `y`, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n */\r\n P.dividedBy = P.div = function (y) {\r\n return divide(this, new this.constructor(y));\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the integer part of dividing the value of this Decimal\r\n * by the value of `y`, rounded to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n */\r\n P.dividedToIntegerBy = P.divToInt = function (y) {\r\n var x = this,\r\n Ctor = x.constructor;\r\n return finalise(divide(x, new Ctor(y), 0, 1, 1), Ctor.precision, Ctor.rounding);\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is equal to the value of `y`, otherwise return false.\r\n *\r\n */\r\n P.equals = P.eq = function (y) {\r\n return this.cmp(y) === 0;\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal rounded to a whole number in the\r\n * direction of negative Infinity.\r\n *\r\n */\r\n P.floor = function () {\r\n return finalise(new this.constructor(this), this.e + 1, 3);\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is greater than the value of `y`, otherwise return\r\n * false.\r\n *\r\n */\r\n P.greaterThan = P.gt = function (y) {\r\n return this.cmp(y) > 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is greater than or equal to the value of `y`,\r\n * otherwise return false.\r\n *\r\n */\r\n P.greaterThanOrEqualTo = P.gte = function (y) {\r\n var k = this.cmp(y);\r\n return k == 1 || k === 0;\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the hyperbolic cosine of the value in radians of this\r\n * Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [1, Infinity]\r\n *\r\n * cosh(x) = 1 + x^2/2! + x^4/4! + x^6/6! + ...\r\n *\r\n * cosh(0) = 1\r\n * cosh(-0) = 1\r\n * cosh(Infinity) = Infinity\r\n * cosh(-Infinity) = Infinity\r\n * cosh(NaN) = NaN\r\n *\r\n * x time taken (ms) result\r\n * 1000 9 9.8503555700852349694e+433\r\n * 10000 25 4.4034091128314607936e+4342\r\n * 100000 171 1.4033316802130615897e+43429\r\n * 1000000 3817 1.5166076984010437725e+434294\r\n * 10000000 abandoned after 2 minute wait\r\n *\r\n * TODO? Compare performance of cosh(x) = 0.5 * (exp(x) + exp(-x))\r\n *\r\n */\r\n P.hyperbolicCosine = P.cosh = function () {\r\n var k, n, pr, rm, len,\r\n x = this,\r\n Ctor = x.constructor,\r\n one = new Ctor(1);\r\n\r\n if (!x.isFinite()) return new Ctor(x.s ? 1 / 0 : NaN);\r\n if (x.isZero()) return one;\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + Math.max(x.e, x.sd()) + 4;\r\n Ctor.rounding = 1;\r\n len = x.d.length;\r\n\r\n // Argument reduction: cos(4x) = 1 - 8cos^2(x) + 8cos^4(x) + 1\r\n // i.e. cos(x) = 1 - cos^2(x/4)(8 - 8cos^2(x/4))\r\n\r\n // Estimate the optimum number of times to use the argument reduction.\r\n // TODO? Estimation reused from cosine() and may not be optimal here.\r\n if (len < 32) {\r\n k = Math.ceil(len / 3);\r\n n = (1 / tinyPow(4, k)).toString();\r\n } else {\r\n k = 16;\r\n n = '2.3283064365386962890625e-10';\r\n }\r\n\r\n x = taylorSeries(Ctor, 1, x.times(n), new Ctor(1), true);\r\n\r\n // Reverse argument reduction\r\n var cosh2_x,\r\n i = k,\r\n d8 = new Ctor(8);\r\n for (; i--;) {\r\n cosh2_x = x.times(x);\r\n x = one.minus(cosh2_x.times(d8.minus(cosh2_x.times(d8))));\r\n }\r\n\r\n return finalise(x, Ctor.precision = pr, Ctor.rounding = rm, true);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the hyperbolic sine of the value in radians of this\r\n * Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-Infinity, Infinity]\r\n *\r\n * sinh(x) = x + x^3/3! + x^5/5! + x^7/7! + ...\r\n *\r\n * sinh(0) = 0\r\n * sinh(-0) = -0\r\n * sinh(Infinity) = Infinity\r\n * sinh(-Infinity) = -Infinity\r\n * sinh(NaN) = NaN\r\n *\r\n * x time taken (ms)\r\n * 10 2 ms\r\n * 100 5 ms\r\n * 1000 14 ms\r\n * 10000 82 ms\r\n * 100000 886 ms 1.4033316802130615897e+43429\r\n * 200000 2613 ms\r\n * 300000 5407 ms\r\n * 400000 8824 ms\r\n * 500000 13026 ms 8.7080643612718084129e+217146\r\n * 1000000 48543 ms\r\n *\r\n * TODO? Compare performance of sinh(x) = 0.5 * (exp(x) - exp(-x))\r\n *\r\n */\r\n P.hyperbolicSine = P.sinh = function () {\r\n var k, pr, rm, len,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.isFinite() || x.isZero()) return new Ctor(x);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + Math.max(x.e, x.sd()) + 4;\r\n Ctor.rounding = 1;\r\n len = x.d.length;\r\n\r\n if (len < 3) {\r\n x = taylorSeries(Ctor, 2, x, x, true);\r\n } else {\r\n\r\n // Alternative argument reduction: sinh(3x) = sinh(x)(3 + 4sinh^2(x))\r\n // i.e. sinh(x) = sinh(x/3)(3 + 4sinh^2(x/3))\r\n // 3 multiplications and 1 addition\r\n\r\n // Argument reduction: sinh(5x) = sinh(x)(5 + sinh^2(x)(20 + 16sinh^2(x)))\r\n // i.e. sinh(x) = sinh(x/5)(5 + sinh^2(x/5)(20 + 16sinh^2(x/5)))\r\n // 4 multiplications and 2 additions\r\n\r\n // Estimate the optimum number of times to use the argument reduction.\r\n k = 1.4 * Math.sqrt(len);\r\n k = k > 16 ? 16 : k | 0;\r\n\r\n x = x.times(1 / tinyPow(5, k));\r\n x = taylorSeries(Ctor, 2, x, x, true);\r\n\r\n // Reverse argument reduction\r\n var sinh2_x,\r\n d5 = new Ctor(5),\r\n d16 = new Ctor(16),\r\n d20 = new Ctor(20);\r\n for (; k--;) {\r\n sinh2_x = x.times(x);\r\n x = x.times(d5.plus(sinh2_x.times(d16.times(sinh2_x).plus(d20))));\r\n }\r\n }\r\n\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return finalise(x, pr, rm, true);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the hyperbolic tangent of the value in radians of this\r\n * Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-1, 1]\r\n *\r\n * tanh(x) = sinh(x) / cosh(x)\r\n *\r\n * tanh(0) = 0\r\n * tanh(-0) = -0\r\n * tanh(Infinity) = 1\r\n * tanh(-Infinity) = -1\r\n * tanh(NaN) = NaN\r\n *\r\n */\r\n P.hyperbolicTangent = P.tanh = function () {\r\n var pr, rm,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.isFinite()) return new Ctor(x.s);\r\n if (x.isZero()) return new Ctor(x);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + 7;\r\n Ctor.rounding = 1;\r\n\r\n return divide(x.sinh(), x.cosh(), Ctor.precision = pr, Ctor.rounding = rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the arccosine (inverse cosine) in radians of the value of\r\n * this Decimal.\r\n *\r\n * Domain: [-1, 1]\r\n * Range: [0, pi]\r\n *\r\n * acos(x) = pi/2 - asin(x)\r\n *\r\n * acos(0) = pi/2\r\n * acos(-0) = pi/2\r\n * acos(1) = 0\r\n * acos(-1) = pi\r\n * acos(1/2) = pi/3\r\n * acos(-1/2) = 2*pi/3\r\n * acos(|x| > 1) = NaN\r\n * acos(NaN) = NaN\r\n *\r\n */\r\n P.inverseCosine = P.acos = function () {\r\n var halfPi,\r\n x = this,\r\n Ctor = x.constructor,\r\n k = x.abs().cmp(1),\r\n pr = Ctor.precision,\r\n rm = Ctor.rounding;\r\n\r\n if (k !== -1) {\r\n return k === 0\r\n // |x| is 1\r\n ? x.isNeg() ? getPi(Ctor, pr, rm) : new Ctor(0)\r\n // |x| > 1 or x is NaN\r\n : new Ctor(NaN);\r\n }\r\n\r\n if (x.isZero()) return getPi(Ctor, pr + 4, rm).times(0.5);\r\n\r\n // TODO? Special case acos(0.5) = pi/3 and acos(-0.5) = 2*pi/3\r\n\r\n Ctor.precision = pr + 6;\r\n Ctor.rounding = 1;\r\n\r\n x = x.asin();\r\n halfPi = getPi(Ctor, pr + 4, rm).times(0.5);\r\n\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return halfPi.minus(x);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic cosine in radians of the\r\n * value of this Decimal.\r\n *\r\n * Domain: [1, Infinity]\r\n * Range: [0, Infinity]\r\n *\r\n * acosh(x) = ln(x + sqrt(x^2 - 1))\r\n *\r\n * acosh(x < 1) = NaN\r\n * acosh(NaN) = NaN\r\n * acosh(Infinity) = Infinity\r\n * acosh(-Infinity) = NaN\r\n * acosh(0) = NaN\r\n * acosh(-0) = NaN\r\n * acosh(1) = 0\r\n * acosh(-1) = NaN\r\n *\r\n */\r\n P.inverseHyperbolicCosine = P.acosh = function () {\r\n var pr, rm,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (x.lte(1)) return new Ctor(x.eq(1) ? 0 : NaN);\r\n if (!x.isFinite()) return new Ctor(x);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + Math.max(Math.abs(x.e), x.sd()) + 4;\r\n Ctor.rounding = 1;\r\n external = false;\r\n\r\n x = x.times(x).minus(1).sqrt().plus(x);\r\n\r\n external = true;\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return x.ln();\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic sine in radians of the value\r\n * of this Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-Infinity, Infinity]\r\n *\r\n * asinh(x) = ln(x + sqrt(x^2 + 1))\r\n *\r\n * asinh(NaN) = NaN\r\n * asinh(Infinity) = Infinity\r\n * asinh(-Infinity) = -Infinity\r\n * asinh(0) = 0\r\n * asinh(-0) = -0\r\n *\r\n */\r\n P.inverseHyperbolicSine = P.asinh = function () {\r\n var pr, rm,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.isFinite() || x.isZero()) return new Ctor(x);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + 2 * Math.max(Math.abs(x.e), x.sd()) + 6;\r\n Ctor.rounding = 1;\r\n external = false;\r\n\r\n x = x.times(x).plus(1).sqrt().plus(x);\r\n\r\n external = true;\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return x.ln();\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic tangent in radians of the\r\n * value of this Decimal.\r\n *\r\n * Domain: [-1, 1]\r\n * Range: [-Infinity, Infinity]\r\n *\r\n * atanh(x) = 0.5 * ln((1 + x) / (1 - x))\r\n *\r\n * atanh(|x| > 1) = NaN\r\n * atanh(NaN) = NaN\r\n * atanh(Infinity) = NaN\r\n * atanh(-Infinity) = NaN\r\n * atanh(0) = 0\r\n * atanh(-0) = -0\r\n * atanh(1) = Infinity\r\n * atanh(-1) = -Infinity\r\n *\r\n */\r\n P.inverseHyperbolicTangent = P.atanh = function () {\r\n var pr, rm, wpr, xsd,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.isFinite()) return new Ctor(NaN);\r\n if (x.e >= 0) return new Ctor(x.abs().eq(1) ? x.s / 0 : x.isZero() ? x : NaN);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n xsd = x.sd();\r\n\r\n if (Math.max(xsd, pr) < 2 * -x.e - 1) return finalise(new Ctor(x), pr, rm, true);\r\n\r\n Ctor.precision = wpr = xsd - x.e;\r\n\r\n x = divide(x.plus(1), new Ctor(1).minus(x), wpr + pr, 1);\r\n\r\n Ctor.precision = pr + 4;\r\n Ctor.rounding = 1;\r\n\r\n x = x.ln();\r\n\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return x.times(0.5);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the arcsine (inverse sine) in radians of the value of this\r\n * Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-pi/2, pi/2]\r\n *\r\n * asin(x) = 2*atan(x/(1 + sqrt(1 - x^2)))\r\n *\r\n * asin(0) = 0\r\n * asin(-0) = -0\r\n * asin(1/2) = pi/6\r\n * asin(-1/2) = -pi/6\r\n * asin(1) = pi/2\r\n * asin(-1) = -pi/2\r\n * asin(|x| > 1) = NaN\r\n * asin(NaN) = NaN\r\n *\r\n * TODO? Compare performance of Taylor series.\r\n *\r\n */\r\n P.inverseSine = P.asin = function () {\r\n var halfPi, k,\r\n pr, rm,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (x.isZero()) return new Ctor(x);\r\n\r\n k = x.abs().cmp(1);\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n\r\n if (k !== -1) {\r\n\r\n // |x| is 1\r\n if (k === 0) {\r\n halfPi = getPi(Ctor, pr + 4, rm).times(0.5);\r\n halfPi.s = x.s;\r\n return halfPi;\r\n }\r\n\r\n // |x| > 1 or x is NaN\r\n return new Ctor(NaN);\r\n }\r\n\r\n // TODO? Special case asin(1/2) = pi/6 and asin(-1/2) = -pi/6\r\n\r\n Ctor.precision = pr + 6;\r\n Ctor.rounding = 1;\r\n\r\n x = x.div(new Ctor(1).minus(x.times(x)).sqrt().plus(1)).atan();\r\n\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return x.times(2);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the arctangent (inverse tangent) in radians of the value\r\n * of this Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-pi/2, pi/2]\r\n *\r\n * atan(x) = x - x^3/3 + x^5/5 - x^7/7 + ...\r\n *\r\n * atan(0) = 0\r\n * atan(-0) = -0\r\n * atan(1) = pi/4\r\n * atan(-1) = -pi/4\r\n * atan(Infinity) = pi/2\r\n * atan(-Infinity) = -pi/2\r\n * atan(NaN) = NaN\r\n *\r\n */\r\n P.inverseTangent = P.atan = function () {\r\n var i, j, k, n, px, t, r, wpr, x2,\r\n x = this,\r\n Ctor = x.constructor,\r\n pr = Ctor.precision,\r\n rm = Ctor.rounding;\r\n\r\n if (!x.isFinite()) {\r\n if (!x.s) return new Ctor(NaN);\r\n if (pr + 4 <= PI_PRECISION) {\r\n r = getPi(Ctor, pr + 4, rm).times(0.5);\r\n r.s = x.s;\r\n return r;\r\n }\r\n } else if (x.isZero()) {\r\n return new Ctor(x);\r\n } else if (x.abs().eq(1) && pr + 4 <= PI_PRECISION) {\r\n r = getPi(Ctor, pr + 4, rm).times(0.25);\r\n r.s = x.s;\r\n return r;\r\n }\r\n\r\n Ctor.precision = wpr = pr + 10;\r\n Ctor.rounding = 1;\r\n\r\n // TODO? if (x >= 1 && pr <= PI_PRECISION) atan(x) = halfPi * x.s - atan(1 / x);\r\n\r\n // Argument reduction\r\n // Ensure |x| < 0.42\r\n // atan(x) = 2 * atan(x / (1 + sqrt(1 + x^2)))\r\n\r\n k = Math.min(28, wpr / LOG_BASE + 2 | 0);\r\n\r\n for (i = k; i; --i) x = x.div(x.times(x).plus(1).sqrt().plus(1));\r\n\r\n external = false;\r\n\r\n j = Math.ceil(wpr / LOG_BASE);\r\n n = 1;\r\n x2 = x.times(x);\r\n r = new Ctor(x);\r\n px = x;\r\n\r\n // atan(x) = x - x^3/3 + x^5/5 - x^7/7 + ...\r\n for (; i !== -1;) {\r\n px = px.times(x2);\r\n t = r.minus(px.div(n += 2));\r\n\r\n px = px.times(x2);\r\n r = t.plus(px.div(n += 2));\r\n\r\n if (r.d[j] !== void 0) for (i = j; r.d[i] === t.d[i] && i--;);\r\n }\r\n\r\n if (k) r = r.times(2 << (k - 1));\r\n\r\n external = true;\r\n\r\n return finalise(r, Ctor.precision = pr, Ctor.rounding = rm, true);\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is a finite number, otherwise return false.\r\n *\r\n */\r\n P.isFinite = function () {\r\n return !!this.d;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is an integer, otherwise return false.\r\n *\r\n */\r\n P.isInteger = P.isInt = function () {\r\n return !!this.d && mathfloor(this.e / LOG_BASE) > this.d.length - 2;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is NaN, otherwise return false.\r\n *\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 Decimal is negative, otherwise return false.\r\n *\r\n */\r\n P.isNegative = P.isNeg = function () {\r\n return this.s < 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is positive, otherwise return false.\r\n *\r\n */\r\n P.isPositive = P.isPos = function () {\r\n return this.s > 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is 0 or -0, otherwise return false.\r\n *\r\n */\r\n P.isZero = function () {\r\n return !!this.d && this.d[0] === 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is less than `y`, otherwise return false.\r\n *\r\n */\r\n P.lessThan = P.lt = function (y) {\r\n return this.cmp(y) < 0;\r\n };\r\n\r\n\r\n /*\r\n * Return true if the value of this Decimal is less than or equal to `y`, otherwise return false.\r\n *\r\n */\r\n P.lessThanOrEqualTo = P.lte = function (y) {\r\n return this.cmp(y) < 1;\r\n };\r\n\r\n\r\n /*\r\n * Return the logarithm of the value of this Decimal to the specified base, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * If no base is specified, return log[10](arg).\r\n *\r\n * log[base](arg) = ln(arg) / ln(base)\r\n *\r\n * The result will always be correctly rounded if the base of the log is 10, and 'almost always'\r\n * otherwise:\r\n *\r\n * Depending on the rounding mode, the result may be incorrectly rounded if the first fifteen\r\n * rounding digits are [49]99999999999999 or [50]00000000000000. In that case, the maximum error\r\n * between the result and the correctly rounded result will be one ulp (unit in the last place).\r\n *\r\n * log[-b](a) = NaN\r\n * log[0](a) = NaN\r\n * log[1](a) = NaN\r\n * log[NaN](a) = NaN\r\n * log[Infinity](a) = NaN\r\n * log[b](0) = -Infinity\r\n * log[b](-0) = -Infinity\r\n * log[b](-a) = NaN\r\n * log[b](1) = 0\r\n * log[b](Infinity) = Infinity\r\n * log[b](NaN) = NaN\r\n *\r\n * [base] {number|string|Decimal} The base of the logarithm.\r\n *\r\n */\r\n P.logarithm = P.log = function (base) {\r\n var isBase10, d, denominator, k, inf, num, sd, r,\r\n arg = this,\r\n Ctor = arg.constructor,\r\n pr = Ctor.precision,\r\n rm = Ctor.rounding,\r\n guard = 5;\r\n\r\n // Default base is 10.\r\n if (base == null) {\r\n base = new Ctor(10);\r\n isBase10 = true;\r\n } else {\r\n base = new Ctor(base);\r\n d = base.d;\r\n\r\n // Return NaN if base is negative, or non-finite, or is 0 or 1.\r\n if (base.s < 0 || !d || !d[0] || base.eq(1)) return new Ctor(NaN);\r\n\r\n isBase10 = base.eq(10);\r\n }\r\n\r\n d = arg.d;\r\n\r\n // Is arg negative, non-finite, 0 or 1?\r\n if (arg.s < 0 || !d || !d[0] || arg.eq(1)) {\r\n return new Ctor(d && !d[0] ? -1 / 0 : arg.s != 1 ? NaN : d ? 0 : 1 / 0);\r\n }\r\n\r\n // The result will have a non-terminating decimal expansion if base is 10 and arg is not an\r\n // integer power of 10.\r\n if (isBase10) {\r\n if (d.length > 1) {\r\n inf = true;\r\n } else {\r\n for (k = d[0]; k % 10 === 0;) k /= 10;\r\n inf = k !== 1;\r\n }\r\n }\r\n\r\n external = false;\r\n sd = pr + guard;\r\n num = naturalLogarithm(arg, sd);\r\n denominator = isBase10 ? getLn10(Ctor, sd + 10) : naturalLogarithm(base, sd);\r\n\r\n // The result will have 5 rounding digits.\r\n r = divide(num, denominator, sd, 1);\r\n\r\n // If at a rounding boundary, i.e. the result's rounding digits are [49]9999 or [50]0000,\r\n // calculate 10 further digits.\r\n //\r\n // If the result is known to have an infinite decimal expansion, repeat this until it is clear\r\n // that the result is above or below the boundary. Otherwise, if after calculating the 10\r\n // further digits, the last 14 are nines, round up and assume the result is exact.\r\n // Also assume the result is exact if the last 14 are zero.\r\n //\r\n // Example of a result that will be incorrectly rounded:\r\n // log[1048576](4503599627370502) = 2.60000000000000009610279511444746...\r\n // The above result correctly rounded using ROUND_CEIL to 1 decimal place should be 2.7, but it\r\n // will be given as 2.6 as there are 15 zeros immediately after the requested decimal place, so\r\n // the exact result would be assumed to be 2.6, which rounded using ROUND_CEIL to 1 decimal\r\n // place is still 2.6.\r\n if (checkRoundingDigits(r.d, k = pr, rm)) {\r\n\r\n do {\r\n sd += 10;\r\n num = naturalLogarithm(arg, sd);\r\n denominator = isBase10 ? getLn10(Ctor, sd + 10) : naturalLogarithm(base, sd);\r\n r = divide(num, denominator, sd, 1);\r\n\r\n if (!inf) {\r\n\r\n // Check for 14 nines from the 2nd rounding digit, as the first may be 4.\r\n if (+digitsToString(r.d).slice(k + 1, k + 15) + 1 == 1e14) {\r\n r = finalise(r, pr + 1, 0);\r\n }\r\n\r\n break;\r\n }\r\n } while (checkRoundingDigits(r.d, k += 10, rm));\r\n }\r\n\r\n external = true;\r\n\r\n return finalise(r, pr, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the maximum of the arguments and the value of this Decimal.\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n P.max = function () {\r\n Array.prototype.push.call(arguments, this);\r\n return maxOrMin(this.constructor, arguments, 'lt');\r\n };\r\n */\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the minimum of the arguments and the value of this Decimal.\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n P.min = function () {\r\n Array.prototype.push.call(arguments, this);\r\n return maxOrMin(this.constructor, arguments, 'gt');\r\n };\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 Decimal whose value is the value of this Decimal minus `y`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n */\r\n P.minus = P.sub = function (y) {\r\n var d, e, i, j, k, len, pr, rm, xd, xe, xLTy, yd,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n y = new Ctor(y);\r\n\r\n // If either is not finite...\r\n if (!x.d || !y.d) {\r\n\r\n // Return NaN if either is NaN.\r\n if (!x.s || !y.s) y = new Ctor(NaN);\r\n\r\n // Return y negated if x is finite and y is ±Infinity.\r\n else if (x.d) y.s = -y.s;\r\n\r\n // Return x if y is finite and x is ±Infinity.\r\n // Return x if both are ±Infinity with different signs.\r\n // Return NaN if both are ±Infinity with the same sign.\r\n else y = new Ctor(y.d || x.s !== y.s ? x : NaN);\r\n\r\n return y;\r\n }\r\n\r\n // If signs differ...\r\n if (x.s != y.s) {\r\n y.s = -y.s;\r\n return x.plus(y);\r\n }\r\n\r\n xd = x.d;\r\n yd = y.d;\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n\r\n // If either is zero...\r\n if (!xd[0] || !yd[0]) {\r\n\r\n // Return y negated if x is zero and y is non-zero.\r\n if (yd[0]) y.s = -y.s;\r\n\r\n // Return x if y is zero and x is non-zero.\r\n else if (xd[0]) y = new Ctor(x);\r\n\r\n // Return zero if both are zero.\r\n // From IEEE 754 (2008) 6.3: 0 - 0 = -0 - -0 = -0 when rounding to -Infinity.\r\n else return new Ctor(rm === 3 ? -0 : 0);\r\n\r\n return external ? finalise(y, pr, rm) : y;\r\n }\r\n\r\n // x and y are finite, non-zero numbers with the same sign.\r\n\r\n // Calculate base 1e7 exponents.\r\n e = mathfloor(y.e / LOG_BASE);\r\n xe = mathfloor(x.e / LOG_BASE);\r\n\r\n xd = xd.slice();\r\n k = xe - e;\r\n\r\n // If base 1e7 exponents differ...\r\n if (k) {\r\n xLTy = k < 0;\r\n\r\n if (xLTy) {\r\n d = xd;\r\n k = -k;\r\n len = yd.length;\r\n } else {\r\n d = yd;\r\n e = xe;\r\n len = xd.length;\r\n }\r\n\r\n // Numbers with massively different exponents would result in a very high number of\r\n // zeros needing to be prepended, but this can be avoided while still ensuring correct\r\n // rounding by limiting the number of zeros to `Math.ceil(pr / LOG_BASE) + 2`.\r\n i = Math.max(Math.ceil(pr / LOG_BASE), len) + 2;\r\n\r\n if (k > i) {\r\n k = i;\r\n d.length = 1;\r\n }\r\n\r\n // Prepend zeros to equalise exponents.\r\n d.reverse();\r\n for (i = k; i--;) d.push(0);\r\n d.reverse();\r\n\r\n // Base 1e7 exponents equal.\r\n } else {\r\n\r\n // Check digits to determine which is the bigger number.\r\n\r\n i = xd.length;\r\n len = yd.length;\r\n xLTy = i < len;\r\n if (xLTy) len = i;\r\n\r\n for (i = 0; i < len; i++) {\r\n if (xd[i] != yd[i]) {\r\n xLTy = xd[i] < yd[i];\r\n break;\r\n }\r\n }\r\n\r\n k = 0;\r\n }\r\n\r\n if (xLTy) {\r\n d = xd;\r\n xd = yd;\r\n yd = d;\r\n y.s = -y.s;\r\n }\r\n\r\n len = xd.length;\r\n\r\n // Append zeros to `xd` if shorter.\r\n // Don't add zeros to `yd` if shorter as subtraction only needs to start at `yd` length.\r\n for (i = yd.length - len; i > 0; --i) xd[len++] = 0;\r\n\r\n // Subtract yd from xd.\r\n for (i = yd.length; i > k;) {\r\n\r\n if (xd[--i] < yd[i]) {\r\n for (j = i; j && xd[--j] === 0;) xd[j] = BASE - 1;\r\n --xd[j];\r\n xd[i] += BASE;\r\n }\r\n\r\n xd[i] -= yd[i];\r\n }\r\n\r\n // Remove trailing zeros.\r\n for (; xd[--len] === 0;) xd.pop();\r\n\r\n // Remove leading zeros and adjust exponent accordingly.\r\n for (; xd[0] === 0; xd.shift()) --e;\r\n\r\n // Zero?\r\n if (!xd[0]) return new Ctor(rm === 3 ? -0 : 0);\r\n\r\n y.d = xd;\r\n y.e = getBase10Exponent(xd, e);\r\n\r\n return external ? finalise(y, pr, rm) : y;\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 Decimal whose value is the value of this Decimal modulo `y`, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * The result depends on the modulo mode.\r\n *\r\n */\r\n P.modulo = P.mod = function (y) {\r\n var q,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n y = new Ctor(y);\r\n\r\n // Return NaN if x is ±Infinity or NaN, or y is NaN or ±0.\r\n if (!x.d || !y.s || y.d && !y.d[0]) return new Ctor(NaN);\r\n\r\n // Return x if y is ±Infinity or x is ±0.\r\n if (!y.d || x.d && !x.d[0]) {\r\n return finalise(new Ctor(x), Ctor.precision, Ctor.rounding);\r\n }\r\n\r\n // Prevent rounding of intermediate calculations.\r\n external = false;\r\n\r\n if (Ctor.modulo == 9) {\r\n\r\n // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n // result = x - q * y where 0 <= result < abs(y)\r\n q = divide(x, y.abs(), 0, 3, 1);\r\n q.s *= y.s;\r\n } else {\r\n q = divide(x, y, 0, Ctor.modulo, 1);\r\n }\r\n\r\n q = q.times(y);\r\n\r\n external = true;\r\n\r\n return x.minus(q);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the natural exponential of the value of this Decimal,\r\n * i.e. the base e raised to the power the value of this Decimal, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n */\r\n P.naturalExponential = P.exp = function () {\r\n return naturalExponential(this);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the natural logarithm of the value of this Decimal,\r\n * rounded to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n */\r\n P.naturalLogarithm = P.ln = function () {\r\n return naturalLogarithm(this);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal negated, i.e. as if multiplied by\r\n * -1.\r\n *\r\n */\r\n P.negated = P.neg = function () {\r\n var x = new this.constructor(this);\r\n x.s = -x.s;\r\n return finalise(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 Decimal whose value is the value of this Decimal plus `y`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n */\r\n P.plus = P.add = function (y) {\r\n var carry, d, e, i, k, len, pr, rm, xd, yd,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n y = new Ctor(y);\r\n\r\n // If either is not finite...\r\n if (!x.d || !y.d) {\r\n\r\n // Return NaN if either is NaN.\r\n if (!x.s || !y.s) y = new Ctor(NaN);\r\n\r\n // Return x if y is finite and x is ±Infinity.\r\n // Return x if both are ±Infinity with the same sign.\r\n // Return NaN if both are ±Infinity with different signs.\r\n // Return y if x is finite and y is ±Infinity.\r\n else if (!x.d) y = new Ctor(y.d || x.s === y.s ? x : NaN);\r\n\r\n return y;\r\n }\r\n\r\n // If signs differ...\r\n if (x.s != y.s) {\r\n y.s = -y.s;\r\n return x.minus(y);\r\n }\r\n\r\n xd = x.d;\r\n yd = y.d;\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n\r\n // If either is zero...\r\n if (!xd[0] || !yd[0]) {\r\n\r\n // Return x if y is zero.\r\n // Return y if y is non-zero.\r\n if (!yd[0]) y = new Ctor(x);\r\n\r\n return external ? finalise(y, pr, rm) : y;\r\n }\r\n\r\n // x and y are finite, non-zero numbers with the same sign.\r\n\r\n // Calculate base 1e7 exponents.\r\n k = mathfloor(x.e / LOG_BASE);\r\n e = mathfloor(y.e / LOG_BASE);\r\n\r\n xd = xd.slice();\r\n i = k - e;\r\n\r\n // If base 1e7 exponents differ...\r\n if (i) {\r\n\r\n if (i < 0) {\r\n d = xd;\r\n i = -i;\r\n len = yd.length;\r\n } else {\r\n d = yd;\r\n e = k;\r\n len = xd.length;\r\n }\r\n\r\n // Limit number of zeros prepended to max(ceil(pr / LOG_BASE), len) + 1.\r\n k = Math.ceil(pr / LOG_BASE);\r\n len = k > len ? k + 1 : len + 1;\r\n\r\n if (i > len) {\r\n i = len;\r\n d.length = 1;\r\n }\r\n\r\n // Prepend zeros to equalise exponents. Note: Faster to use reverse then do unshifts.\r\n d.reverse();\r\n for (; i--;) d.push(0);\r\n d.reverse();\r\n }\r\n\r\n len = xd.length;\r\n i = yd.length;\r\n\r\n // If yd is longer than xd, swap xd and yd so xd points to the longer array.\r\n if (len - i < 0) {\r\n i = len;\r\n d = yd;\r\n yd = xd;\r\n xd = d;\r\n }\r\n\r\n // Only start adding at yd.length - 1 as the further digits of xd can be left as they are.\r\n for (carry = 0; i;) {\r\n carry = (xd[--i] = xd[i] + yd[i] + carry) / BASE | 0;\r\n xd[i] %= BASE;\r\n }\r\n\r\n if (carry) {\r\n xd.unshift(carry);\r\n ++e;\r\n }\r\n\r\n // Remove trailing zeros.\r\n // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n for (len = xd.length; xd[--len] == 0;) xd.pop();\r\n\r\n y.d = xd;\r\n y.e = getBase10Exponent(xd, e);\r\n\r\n return external ? finalise(y, pr, rm) : y;\r\n };\r\n\r\n\r\n /*\r\n * Return the number of significant digits of the value of this Decimal.\r\n *\r\n * [z] {boolean|number} Whether to count integer-part trailing zeros: true, false, 1 or 0.\r\n *\r\n */\r\n P.precision = P.sd = function (z) {\r\n var k,\r\n x = this;\r\n\r\n if (z !== void 0 && z !== !!z && z !== 1 && z !== 0) throw Error(invalidArgument + z);\r\n\r\n if (x.d) {\r\n k = getPrecision(x.d);\r\n if (z && x.e + 1 > k) k = x.e + 1;\r\n } else {\r\n k = NaN;\r\n }\r\n\r\n return k;\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal rounded to a whole number using\r\n * rounding mode `rounding`.\r\n *\r\n */\r\n P.round = function () {\r\n var x = this,\r\n Ctor = x.constructor;\r\n\r\n return finalise(new Ctor(x), x.e + 1, Ctor.rounding);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the sine of the value in radians of this Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-1, 1]\r\n *\r\n * sin(x) = x - x^3/3! + x^5/5! - ...\r\n *\r\n * sin(0) = 0\r\n * sin(-0) = -0\r\n * sin(Infinity) = NaN\r\n * sin(-Infinity) = NaN\r\n * sin(NaN) = NaN\r\n *\r\n */\r\n P.sine = P.sin = function () {\r\n var pr, rm,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.isFinite()) return new Ctor(NaN);\r\n if (x.isZero()) return new Ctor(x);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + Math.max(x.e, x.sd()) + LOG_BASE;\r\n Ctor.rounding = 1;\r\n\r\n x = sine(Ctor, toLessThanHalfPi(Ctor, x));\r\n\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return finalise(quadrant > 2 ? x.neg() : x, pr, rm, true);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the square root of this Decimal, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\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 */\r\n P.squareRoot = P.sqrt = function () {\r\n var m, n, sd, r, rep, t,\r\n x = this,\r\n d = x.d,\r\n e = x.e,\r\n s = x.s,\r\n Ctor = x.constructor;\r\n\r\n // Negative/NaN/Infinity/zero?\r\n if (s !== 1 || !d || !d[0]) {\r\n return new Ctor(!s || s < 0 && (!d || d[0]) ? NaN : d ? x : 1 / 0);\r\n }\r\n\r\n external = false;\r\n\r\n // Initial estimate.\r\n s = Math.sqrt(+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 = digitsToString(d);\r\n\r\n if ((n.length + e) % 2 == 0) n += '0';\r\n s = Math.sqrt(n);\r\n e = mathfloor((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 Ctor(n);\r\n } else {\r\n r = new Ctor(s.toString());\r\n }\r\n\r\n sd = (e = Ctor.precision) + 3;\r\n\r\n // Newton-Raphson iteration.\r\n for (;;) {\r\n t = r;\r\n r = t.plus(divide(x, t, sd + 2, 1)).times(0.5);\r\n\r\n // TODO? Replace with for-loop and checkRoundingDigits.\r\n if (digitsToString(t.d).slice(0, sd) === (n = digitsToString(r.d)).slice(0, sd)) {\r\n n = n.slice(sd - 3, sd + 1);\r\n\r\n // The 4th rounding digit may be in error by -1 so if the 4 rounding digits are 9999 or\r\n // 4999, i.e. approaching a rounding boundary, continue the 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 exact result as the\r\n // nines may infinitely repeat.\r\n if (!rep) {\r\n finalise(t, e + 1, 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 sd += 4;\r\n rep = 1;\r\n } else {\r\n\r\n // If the rounding digits are null, 0{0,4} or 50{0,3}, check for an exact result.\r\n // 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 finalise(r, e + 1, 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 external = true;\r\n\r\n return finalise(r, e, Ctor.rounding, m);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the tangent of the value in radians of this Decimal.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-Infinity, Infinity]\r\n *\r\n * tan(0) = 0\r\n * tan(-0) = -0\r\n * tan(Infinity) = NaN\r\n * tan(-Infinity) = NaN\r\n * tan(NaN) = NaN\r\n *\r\n */\r\n P.tangent = P.tan = function () {\r\n var pr, rm,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (!x.isFinite()) return new Ctor(NaN);\r\n if (x.isZero()) return new Ctor(x);\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n Ctor.precision = pr + 10;\r\n Ctor.rounding = 1;\r\n\r\n x = x.sin();\r\n x.s = 1;\r\n x = divide(x, new Ctor(1).minus(x.times(x)).sqrt(), pr + 10, 0);\r\n\r\n Ctor.precision = pr;\r\n Ctor.rounding = rm;\r\n\r\n return finalise(quadrant == 2 || quadrant == 4 ? x.neg() : x, pr, rm, true);\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 Decimal whose value is this Decimal times `y`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n */\r\n P.times = P.mul = function (y) {\r\n var carry, e, i, k, r, rL, t, xdL, ydL,\r\n x = this,\r\n Ctor = x.constructor,\r\n xd = x.d,\r\n yd = (y = new Ctor(y)).d;\r\n\r\n y.s *= x.s;\r\n\r\n // If either is NaN, ±Infinity or ±0...\r\n if (!xd || !xd[0] || !yd || !yd[0]) {\r\n\r\n return new Ctor(!y.s || xd && !xd[0] && !yd || yd && !yd[0] && !xd\r\n\r\n // Return NaN if either is NaN.\r\n // Return NaN if x is ±0 and y is ±Infinity, or y is ±0 and x is ±Infinity.\r\n ? NaN\r\n\r\n // Return ±Infinity if either is ±Infinity.\r\n // Return ±0 if either is ±0.\r\n : !xd || !yd ? y.s / 0 : y.s * 0);\r\n }\r\n\r\n e = mathfloor(x.e / LOG_BASE) + mathfloor(y.e / LOG_BASE);\r\n xdL = xd.length;\r\n ydL = yd.length;\r\n\r\n // Ensure xd points to the longer array.\r\n if (xdL < ydL) {\r\n r = xd;\r\n xd = yd;\r\n yd = r;\r\n rL = xdL;\r\n xdL = ydL;\r\n ydL = rL;\r\n }\r\n\r\n // Initialise the result array with zeros.\r\n r = [];\r\n rL = xdL + ydL;\r\n for (i = rL; i--;) r.push(0);\r\n\r\n // Multiply!\r\n for (i = ydL; --i >= 0;) {\r\n carry = 0;\r\n for (k = xdL + i; k > i;) {\r\n t = r[k] + yd[i] * xd[k - i - 1] + carry;\r\n r[k--] = t % BASE | 0;\r\n carry = t / BASE | 0;\r\n }\r\n\r\n r[k] = (r[k] + carry) % BASE | 0;\r\n }\r\n\r\n // Remove trailing zeros.\r\n for (; !r[--rL];) r.pop();\r\n\r\n if (carry) ++e;\r\n else r.shift();\r\n\r\n y.d = r;\r\n y.e = getBase10Exponent(r, e);\r\n\r\n return external ? finalise(y, Ctor.precision, Ctor.rounding) : y;\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal in base 2, round to `sd` significant\r\n * digits using rounding mode `rm`.\r\n *\r\n * If the optional `sd` argument is present then return binary exponential notation.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\n P.toBinary = function (sd, rm) {\r\n return toStringBinary(this, 2, sd, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `dp`\r\n * decimal places using rounding mode `rm` or `rounding` if `rm` is omitted.\r\n *\r\n * If `dp` is omitted, return a new Decimal whose value is the value of this Decimal.\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\n P.toDecimalPlaces = P.toDP = function (dp, rm) {\r\n var x = this,\r\n Ctor = x.constructor;\r\n\r\n x = new Ctor(x);\r\n if (dp === void 0) return x;\r\n\r\n checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n if (rm === void 0) rm = Ctor.rounding;\r\n else checkInt32(rm, 0, 8);\r\n\r\n return finalise(x, dp + x.e + 1, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal in exponential notation rounded to\r\n * `dp` fixed decimal places using rounding mode `rounding`.\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\n P.toExponential = function (dp, rm) {\r\n var str,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (dp === void 0) {\r\n str = finiteToString(x, true);\r\n } else {\r\n checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n if (rm === void 0) rm = Ctor.rounding;\r\n else checkInt32(rm, 0, 8);\r\n\r\n x = finalise(new Ctor(x), dp + 1, rm);\r\n str = finiteToString(x, true, dp + 1);\r\n }\r\n\r\n return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal in normal (fixed-point) notation to\r\n * `dp` fixed decimal places and rounded using rounding mode `rm` or `rounding` if `rm` is\r\n * omitted.\r\n *\r\n * As with JavaScript numbers, (-0).toFixed(0) is '0', but e.g. (-0.00001).toFixed(0) is '-0'.\r\n *\r\n * [dp] {number} Decimal places. Integer, 0 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.\r\n * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.\r\n * (-0).toFixed(3) is '0.000'.\r\n * (-0.5).toFixed(0) is '-0'.\r\n *\r\n */\r\n P.toFixed = function (dp, rm) {\r\n var str, y,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (dp === void 0) {\r\n str = finiteToString(x);\r\n } else {\r\n checkInt32(dp, 0, MAX_DIGITS);\r\n\r\n if (rm === void 0) rm = Ctor.rounding;\r\n else checkInt32(rm, 0, 8);\r\n\r\n y = finalise(new Ctor(x), dp + x.e + 1, rm);\r\n str = finiteToString(y, false, dp + y.e + 1);\r\n }\r\n\r\n // To determine whether to add the minus sign look at the value before it was rounded,\r\n // i.e. look at `x` rather than `y`.\r\n return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n };\r\n\r\n\r\n /*\r\n * Return an array representing the value of this Decimal as a simple fraction with an integer\r\n * numerator and an integer denominator.\r\n *\r\n * The denominator will be a positive non-zero value less than or equal to the specified maximum\r\n * denominator. If a maximum denominator is not specified, the denominator will be the lowest\r\n * value necessary to represent the number exactly.\r\n *\r\n * [maxD] {number|string|Decimal} Maximum denominator. Integer >= 1 and < Infinity.\r\n *\r\n */\r\n P.toFraction = function (maxD) {\r\n var d, d0, d1, d2, e, k, n, n0, n1, pr, q, r,\r\n x = this,\r\n xd = x.d,\r\n Ctor = x.constructor;\r\n\r\n if (!xd) return new Ctor(x);\r\n\r\n n1 = d0 = new Ctor(1);\r\n d1 = n0 = new Ctor(0);\r\n\r\n d = new Ctor(d1);\r\n e = d.e = getPrecision(xd) - x.e - 1;\r\n k = e % LOG_BASE;\r\n d.d[0] = mathpow(10, k < 0 ? LOG_BASE + k : k);\r\n\r\n if (maxD == null) {\r\n\r\n // d is 10**e, the minimum max-denominator needed.\r\n maxD = e > 0 ? d : n1;\r\n } else {\r\n n = new Ctor(maxD);\r\n if (!n.isInt() || n.lt(n1)) throw Error(invalidArgument + n);\r\n maxD = n.gt(d) ? (e > 0 ? d : n1) : n;\r\n }\r\n\r\n external = false;\r\n n = new Ctor(digitsToString(xd));\r\n pr = Ctor.precision;\r\n Ctor.precision = e = xd.length * LOG_BASE * 2;\r\n\r\n for (;;) {\r\n q = divide(n, d, 0, 1, 1);\r\n d2 = d0.plus(q.times(d1));\r\n if (d2.cmp(maxD) == 1) break;\r\n d0 = d1;\r\n d1 = d2;\r\n d2 = n1;\r\n n1 = n0.plus(q.times(d2));\r\n n0 = d2;\r\n d2 = d;\r\n d = n.minus(q.times(d2));\r\n n = d2;\r\n }\r\n\r\n d2 = divide(maxD.minus(d0), d1, 0, 1, 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\r\n // Determine which fraction is closer to x, n0/d0 or n1/d1?\r\n r = divide(n1, d1, e, 1).minus(x).abs().cmp(divide(n0, d0, e, 1).minus(x).abs()) < 1\r\n ? [n1, d1] : [n0, d0];\r\n\r\n Ctor.precision = pr;\r\n external = true;\r\n\r\n return r;\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal in base 16, round to `sd` significant\r\n * digits using rounding mode `rm`.\r\n *\r\n * If the optional `sd` argument is present then return binary exponential notation.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\n P.toHexadecimal = P.toHex = function (sd, rm) {\r\n return toStringBinary(this, 16, sd, rm);\r\n };\r\n\r\n\r\n /*\r\n * Returns a new Decimal whose value is the nearest multiple of `y` in the direction of rounding\r\n * mode `rm`, or `Decimal.rounding` if `rm` is omitted, to the value of this Decimal.\r\n *\r\n * The return value will always have the same sign as this Decimal, unless either this Decimal\r\n * or `y` is NaN, in which case the return value will be also be NaN.\r\n *\r\n * The return value is not affected by the value of `precision`.\r\n *\r\n * y {number|string|Decimal} The magnitude to round to a multiple of.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * 'toNearest() rounding mode not an integer: {rm}'\r\n * 'toNearest() rounding mode out of range: {rm}'\r\n *\r\n */\r\n P.toNearest = function (y, rm) {\r\n var x = this,\r\n Ctor = x.constructor;\r\n\r\n x = new Ctor(x);\r\n\r\n if (y == null) {\r\n\r\n // If x is not finite, return x.\r\n if (!x.d) return x;\r\n\r\n y = new Ctor(1);\r\n rm = Ctor.rounding;\r\n } else {\r\n y = new Ctor(y);\r\n if (rm === void 0) {\r\n rm = Ctor.rounding;\r\n } else {\r\n checkInt32(rm, 0, 8);\r\n }\r\n\r\n // If x is not finite, return x if y is not NaN, else NaN.\r\n if (!x.d) return y.s ? x : y;\r\n\r\n // If y is not finite, return Infinity with the sign of x if y is Infinity, else NaN.\r\n if (!y.d) {\r\n if (y.s) y.s = x.s;\r\n return y;\r\n }\r\n }\r\n\r\n // If y is not zero, calculate the nearest multiple of y to x.\r\n if (y.d[0]) {\r\n external = false;\r\n x = divide(x, y, 0, rm, 1).times(y);\r\n external = true;\r\n finalise(x);\r\n\r\n // If y is zero, return zero with the sign of x.\r\n } else {\r\n y.s = x.s;\r\n x = y;\r\n }\r\n\r\n return x;\r\n };\r\n\r\n\r\n /*\r\n * Return the value of this Decimal converted to a number primitive.\r\n * Zero keeps its sign.\r\n *\r\n */\r\n P.toNumber = function () {\r\n return +this;\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal in base 8, round to `sd` significant\r\n * digits using rounding mode `rm`.\r\n *\r\n * If the optional `sd` argument is present then return binary exponential notation.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\n P.toOctal = function (sd, rm) {\r\n return toStringBinary(this, 8, sd, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal raised to the power `y`, rounded\r\n * to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * ECMAScript compliant.\r\n *\r\n * pow(x, NaN) = NaN\r\n * pow(x, ±0) = 1\r\n\r\n * pow(NaN, non-zero) = NaN\r\n * pow(abs(x) > 1, +Infinity) = +Infinity\r\n * pow(abs(x) > 1, -Infinity) = +0\r\n * pow(abs(x) == 1, ±Infinity) = NaN\r\n * pow(abs(x) < 1, +Infinity) = +0\r\n * pow(abs(x) < 1, -Infinity) = +Infinity\r\n * pow(+Infinity, y > 0) = +Infinity\r\n * pow(+Infinity, y < 0) = +0\r\n * pow(-Infinity, odd integer > 0) = -Infinity\r\n * pow(-Infinity, even integer > 0) = +Infinity\r\n * pow(-Infinity, odd integer < 0) = -0\r\n * pow(-Infinity, even integer < 0) = +0\r\n * pow(+0, y > 0) = +0\r\n * pow(+0, y < 0) = +Infinity\r\n * pow(-0, odd integer > 0) = -0\r\n * pow(-0, even integer > 0) = +0\r\n * pow(-0, odd integer < 0) = -Infinity\r\n * pow(-0, even integer < 0) = +Infinity\r\n * pow(finite x < 0, finite non-integer) = NaN\r\n *\r\n * For non-integer or very large exponents pow(x, y) is calculated using\r\n *\r\n * x^y = exp(y*ln(x))\r\n *\r\n * Assuming the first 15 rounding digits are each equally likely to be any digit 0-9, the\r\n * probability of an incorrectly rounded result\r\n * P([49]9{14} | [50]0{14}) = 2 * 0.2 * 10^-14 = 4e-15 = 1/2.5e+14\r\n * i.e. 1 in 250,000,000,000,000\r\n *\r\n * If a result is incorrectly rounded the maximum error will be 1 ulp (unit in last place).\r\n *\r\n * y {number|string|Decimal} The power to which to raise this Decimal.\r\n *\r\n */\r\n P.toPower = P.pow = function (y) {\r\n var e, k, pr, r, rm, s,\r\n x = this,\r\n Ctor = x.constructor,\r\n yn = +(y = new Ctor(y));\r\n\r\n // Either ±Infinity, NaN or ±0?\r\n if (!x.d || !y.d || !x.d[0] || !y.d[0]) return new Ctor(mathpow(+x, yn));\r\n\r\n x = new Ctor(x);\r\n\r\n if (x.eq(1)) return x;\r\n\r\n pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n\r\n if (y.eq(1)) return finalise(x, pr, rm);\r\n\r\n // y exponent\r\n e = mathfloor(y.e / LOG_BASE);\r\n\r\n // If y is a small integer use the 'exponentiation by squaring' algorithm.\r\n if (e >= y.d.length - 1 && (k = yn < 0 ? -yn : yn) <= MAX_SAFE_INTEGER) {\r\n r = intPow(Ctor, x, k, pr);\r\n return y.s < 0 ? new Ctor(1).div(r) : finalise(r, pr, rm);\r\n }\r\n\r\n s = x.s;\r\n\r\n // if x is negative\r\n if (s < 0) {\r\n\r\n // if y is not an integer\r\n if (e < y.d.length - 1) return new Ctor(NaN);\r\n\r\n // Result is positive if x is negative and the last digit of integer y is even.\r\n if ((y.d[e] & 1) == 0) s = 1;\r\n\r\n // if x.eq(-1)\r\n if (x.e == 0 && x.d[0] == 1 && x.d.length == 1) {\r\n x.s = s;\r\n return x;\r\n }\r\n }\r\n\r\n // Estimate result exponent.\r\n // x^y = 10^e, where e = y * log10(x)\r\n // log10(x) = log10(x_significand) + x_exponent\r\n // log10(x_significand) = ln(x_significand) / ln(10)\r\n k = mathpow(+x, yn);\r\n e = k == 0 || !isFinite(k)\r\n ? mathfloor(yn * (Math.log('0.' + digitsToString(x.d)) / Math.LN10 + x.e + 1))\r\n : new Ctor(k + '').e;\r\n\r\n // Exponent estimate may be incorrect e.g. x: 0.999999999999999999, y: 2.29, e: 0, r.e: -1.\r\n\r\n // Overflow/underflow?\r\n if (e > Ctor.maxE + 1 || e < Ctor.minE - 1) return new Ctor(e > 0 ? s / 0 : 0);\r\n\r\n external = false;\r\n Ctor.rounding = x.s = 1;\r\n\r\n // Estimate the extra guard digits needed to ensure five correct rounding digits from\r\n // naturalLogarithm(x). Example of failure without these extra digits (precision: 10):\r\n // new Decimal(2.32456).pow('2087987436534566.46411')\r\n // should be 1.162377823e+764914905173815, but is 1.162355823e+764914905173815\r\n k = Math.min(12, (e + '').length);\r\n\r\n // r = x^y = exp(y*ln(x))\r\n r = naturalExponential(y.times(naturalLogarithm(x, pr + k)), pr);\r\n\r\n // r may be Infinity, e.g. (0.9999999999999999).pow(-1e+40)\r\n if (r.d) {\r\n\r\n // Truncate to the required precision plus five rounding digits.\r\n r = finalise(r, pr + 5, 1);\r\n\r\n // If the rounding digits are [49]9999 or [50]0000 increase the precision by 10 and recalculate\r\n // the result.\r\n if (checkRoundingDigits(r.d, pr, rm)) {\r\n e = pr + 10;\r\n\r\n // Truncate to the increased precision plus five rounding digits.\r\n r = finalise(naturalExponential(y.times(naturalLogarithm(x, e + k)), e), e + 5, 1);\r\n\r\n // Check for 14 nines from the 2nd rounding digit (the first rounding digit may be 4 or 9).\r\n if (+digitsToString(r.d).slice(pr + 1, pr + 15) + 1 == 1e14) {\r\n r = finalise(r, pr + 1, 0);\r\n }\r\n }\r\n }\r\n\r\n r.s = s;\r\n external = true;\r\n Ctor.rounding = rm;\r\n\r\n return finalise(r, pr, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal rounded to `sd` significant digits\r\n * using rounding mode `rounding`.\r\n *\r\n * Return exponential notation if `sd` is less than the number of digits necessary to represent\r\n * the integer part of the value in normal notation.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n */\r\n P.toPrecision = function (sd, rm) {\r\n var str,\r\n x = this,\r\n Ctor = x.constructor;\r\n\r\n if (sd === void 0) {\r\n str = finiteToString(x, x.e <= Ctor.toExpNeg || x.e >= Ctor.toExpPos);\r\n } else {\r\n checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n if (rm === void 0) rm = Ctor.rounding;\r\n else checkInt32(rm, 0, 8);\r\n\r\n x = finalise(new Ctor(x), sd, rm);\r\n str = finiteToString(x, sd <= x.e || x.e <= Ctor.toExpNeg, sd);\r\n }\r\n\r\n return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal rounded to a maximum of `sd`\r\n * significant digits using rounding mode `rm`, or to `precision` and `rounding` respectively if\r\n * omitted.\r\n *\r\n * [sd] {number} Significant digits. Integer, 1 to MAX_DIGITS inclusive.\r\n * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n *\r\n * 'toSD() digits out of range: {sd}'\r\n * 'toSD() digits not an integer: {sd}'\r\n * 'toSD() rounding mode not an integer: {rm}'\r\n * 'toSD() rounding mode out of range: {rm}'\r\n *\r\n */\r\n P.toSignificantDigits = P.toSD = function (sd, rm) {\r\n var x = this,\r\n Ctor = x.constructor;\r\n\r\n if (sd === void 0) {\r\n sd = Ctor.precision;\r\n rm = Ctor.rounding;\r\n } else {\r\n checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n if (rm === void 0) rm = Ctor.rounding;\r\n else checkInt32(rm, 0, 8);\r\n }\r\n\r\n return finalise(new Ctor(x), sd, rm);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal.\r\n *\r\n * Return exponential notation if this Decimal has a positive exponent equal to or greater than\r\n * `toExpPos`, or a negative exponent equal to or less than `toExpNeg`.\r\n *\r\n */\r\n P.toString = function () {\r\n var x = this,\r\n Ctor = x.constructor,\r\n str = finiteToString(x, x.e <= Ctor.toExpNeg || x.e >= Ctor.toExpPos);\r\n\r\n return x.isNeg() && !x.isZero() ? '-' + str : str;\r\n };\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of this Decimal truncated to a whole number.\r\n *\r\n */\r\n P.truncated = P.trunc = function () {\r\n return finalise(new this.constructor(this), this.e + 1, 1);\r\n };\r\n\r\n\r\n /*\r\n * Return a string representing the value of this Decimal.\r\n * Unlike `toString`, negative zero will include the minus sign.\r\n *\r\n */\r\n P.valueOf = P.toJSON = function () {\r\n var x = this,\r\n Ctor = x.constructor,\r\n str = finiteToString(x, x.e <= Ctor.toExpNeg || x.e >= Ctor.toExpPos);\r\n\r\n return x.isNeg() ? '-' + str : str;\r\n };\r\n\r\n\r\n // Helper functions for Decimal.prototype (P) and/or Decimal methods, and their callers.\r\n\r\n\r\n /*\r\n * digitsToString P.cubeRoot, P.logarithm, P.squareRoot, P.toFraction, P.toPower,\r\n * finiteToString, naturalExponential, naturalLogarithm\r\n * checkInt32 P.toDecimalPlaces, P.toExponential, P.toFixed, P.toNearest,\r\n * P.toPrecision, P.toSignificantDigits, toStringBinary, random\r\n * checkRoundingDigits P.logarithm, P.toPower, naturalExponential, naturalLogarithm\r\n * convertBase toStringBinary, parseOther\r\n * cos P.cos\r\n * divide P.atanh, P.cubeRoot, P.dividedBy, P.dividedToIntegerBy,\r\n * P.logarithm, P.modulo, P.squareRoot, P.tan, P.tanh, P.toFraction,\r\n * P.toNearest, toStringBinary, naturalExponential, naturalLogarithm,\r\n * taylorSeries, atan2, parseOther\r\n * finalise P.absoluteValue, P.atan, P.atanh, P.ceil, P.cos, P.cosh,\r\n * P.cubeRoot, P.dividedToIntegerBy, P.floor, P.logarithm, P.minus,\r\n * P.modulo, P.negated, P.plus, P.round, P.sin, P.sinh, P.squareRoot,\r\n * P.tan, P.times, P.toDecimalPlaces, P.toExponential, P.toFixed,\r\n * P.toNearest, P.toPower, P.toPrecision, P.toSignificantDigits,\r\n * P.truncated, divide, getLn10, getPi, naturalExponential,\r\n * naturalLogarithm, ceil, floor, round, trunc\r\n * finiteToString P.toExponential, P.toFixed, P.toPrecision, P.toString, P.valueOf,\r\n * toStringBinary\r\n * getBase10Exponent P.minus, P.plus, P.times, parseOther\r\n * getLn10 P.logarithm, naturalLogarithm\r\n * getPi P.acos, P.asin, P.atan, toLessThanHalfPi, atan2\r\n * getPrecision P.precision, P.toFraction\r\n * getZeroString digitsToString, finiteToString\r\n * intPow P.toPower, parseOther\r\n * isOdd toLessThanHalfPi\r\n * maxOrMin max, min\r\n * naturalExponential P.naturalExponential, P.toPower\r\n * naturalLogarithm P.acosh, P.asinh, P.atanh, P.logarithm, P.naturalLogarithm,\r\n * P.toPower, naturalExponential\r\n * nonFiniteToString finiteToString, toStringBinary\r\n * parseDecimal Decimal\r\n * parseOther Decimal\r\n * sin P.sin\r\n * taylorSeries P.cosh, P.sinh, cos, sin\r\n * toLessThanHalfPi P.cos, P.sin\r\n * toStringBinary P.toBinary, P.toHexadecimal, P.toOctal\r\n * truncate intPow\r\n *\r\n * Throws: P.logarithm, P.precision, P.toFraction, checkInt32, getLn10, getPi,\r\n * naturalLogarithm, config, parseOther, random, Decimal\r\n */\r\n\r\n\r\n function digitsToString(d) {\r\n var i, k, ws,\r\n indexOfLastWord = d.length - 1,\r\n str = '',\r\n w = d[0];\r\n\r\n if (indexOfLastWord > 0) {\r\n str += w;\r\n for (i = 1; i < indexOfLastWord; i++) {\r\n ws = d[i] + '';\r\n k = LOG_BASE - ws.length;\r\n if (k) str += getZeroString(k);\r\n str += ws;\r\n }\r\n\r\n w = d[i];\r\n ws = w + '';\r\n k = LOG_BASE - ws.length;\r\n if (k) str += getZeroString(k);\r\n } else if (w === 0) {\r\n return '0';\r\n }\r\n\r\n // Remove trailing zeros of last w.\r\n for (; w % 10 === 0;) w /= 10;\r\n\r\n return str + w;\r\n }\r\n\r\n\r\n function checkInt32(i, min, max) {\r\n if (i !== ~~i || i < min || i > max) {\r\n throw Error(invalidArgument + i);\r\n }\r\n }\r\n\r\n\r\n /*\r\n * Check 5 rounding digits if `repeating` is null, 4 otherwise.\r\n * `repeating == null` if caller is `log` or `pow`,\r\n * `repeating != null` if caller is `naturalLogarithm` or `naturalExponential`.\r\n */\r\n function checkRoundingDigits(d, i, rm, repeating) {\r\n var di, k, r, rd;\r\n\r\n // Get the length of the first word of the array d.\r\n for (k = d[0]; k >= 10; k /= 10) --i;\r\n\r\n // Is the rounding digit in the first word of d?\r\n if (--i < 0) {\r\n i += LOG_BASE;\r\n di = 0;\r\n } else {\r\n di = Math.ceil((i + 1) / LOG_BASE);\r\n i %= LOG_BASE;\r\n }\r\n\r\n // i is the index (0 - 6) of the rounding digit.\r\n // E.g. if within the word 3487563 the first rounding digit is 5,\r\n // then i = 4, k = 1000, rd = 3487563 % 1000 = 563\r\n k = mathpow(10, LOG_BASE - i);\r\n rd = d[di] % k | 0;\r\n\r\n if (repeating == null) {\r\n if (i < 3) {\r\n if (i == 0) rd = rd / 100 | 0;\r\n else if (i == 1) rd = rd / 10 | 0;\r\n r = rm < 4 && rd == 99999 || rm > 3 && rd == 49999 || rd == 50000 || rd == 0;\r\n } else {\r\n r = (rm < 4 && rd + 1 == k || rm > 3 && rd + 1 == k / 2) &&\r\n (d[di + 1] / k / 100 | 0) == mathpow(10, i - 2) - 1 ||\r\n (rd == k / 2 || rd == 0) && (d[di + 1] / k / 100 | 0) == 0;\r\n }\r\n } else {\r\n if (i < 4) {\r\n if (i == 0) rd = rd / 1000 | 0;\r\n else if (i == 1) rd = rd / 100 | 0;\r\n else if (i == 2) rd = rd / 10 | 0;\r\n r = (repeating || rm < 4) && rd == 9999 || !repeating && rm > 3 && rd == 4999;\r\n } else {\r\n r = ((repeating || rm < 4) && rd + 1 == k ||\r\n (!repeating && rm > 3) && rd + 1 == k / 2) &&\r\n (d[di + 1] / k / 1000 | 0) == mathpow(10, i - 3) - 1;\r\n }\r\n }\r\n\r\n return r;\r\n }\r\n\r\n\r\n // Convert string of `baseIn` to an array of numbers of `baseOut`.\r\n // Eg. convertBase('255', 10, 16) returns [15, 15].\r\n // Eg. convertBase('ff', 16, 10) returns [2, 5, 5].\r\n function convertBase(str, baseIn, baseOut) {\r\n var j,\r\n arr = [0],\r\n arrL,\r\n i = 0,\r\n strL = str.length;\r\n\r\n for (; i < strL;) {\r\n for (arrL = arr.length; arrL--;) arr[arrL] *= baseIn;\r\n arr[0] += NUMERALS.indexOf(str.charAt(i++));\r\n for (j = 0; j < arr.length; j++) {\r\n if (arr[j] > baseOut - 1) {\r\n if (arr[j + 1] === void 0) 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\r\n /*\r\n * cos(x) = 1 - x^2/2! + x^4/4! - ...\r\n * |x| < pi/2\r\n *\r\n */\r\n function cosine(Ctor, x) {\r\n var k, len, y;\r\n\r\n if (x.isZero()) return x;\r\n\r\n // Argument reduction: cos(4x) = 8*(cos^4(x) - cos^2(x)) + 1\r\n // i.e. cos(x) = 8*(cos^4(x/4) - cos^2(x/4)) + 1\r\n\r\n // Estimate the optimum number of times to use the argument reduction.\r\n len = x.d.length;\r\n if (len < 32) {\r\n k = Math.ceil(len / 3);\r\n y = (1 / tinyPow(4, k)).toString();\r\n } else {\r\n k = 16;\r\n y = '2.3283064365386962890625e-10';\r\n }\r\n\r\n Ctor.precision += k;\r\n\r\n x = taylorSeries(Ctor, 1, x.times(y), new Ctor(1));\r\n\r\n // Reverse argument reduction\r\n for (var i = k; i--;) {\r\n var cos2x = x.times(x);\r\n x = cos2x.times(cos2x).minus(cos2x).times(8).plus(1);\r\n }\r\n\r\n Ctor.precision -= k;\r\n\r\n return x;\r\n }\r\n\r\n\r\n /*\r\n * Perform division in the specified base.\r\n */\r\n var divide = (function () {\r\n\r\n // Assumes non-zero x and k, and hence non-zero result.\r\n function multiplyInteger(x, k, base) {\r\n var temp,\r\n carry = 0,\r\n i = x.length;\r\n\r\n for (x = x.slice(); i--;) {\r\n temp = x[i] * k + carry;\r\n x[i] = temp % base | 0;\r\n carry = temp / base | 0;\r\n }\r\n\r\n if (carry) x.unshift(carry);\r\n\r\n return x;\r\n }\r\n\r\n function compare(a, b, aL, bL) {\r\n var i, r;\r\n\r\n if (aL != bL) {\r\n r = aL > bL ? 1 : -1;\r\n } else {\r\n for (i = r = 0; i < aL; i++) {\r\n if (a[i] != b[i]) {\r\n r = a[i] > b[i] ? 1 : -1;\r\n break;\r\n }\r\n }\r\n }\r\n\r\n return r;\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.shift();\r\n }\r\n\r\n return function (x, y, pr, rm, dp, base) {\r\n var cmp, e, i, k, logBase, more, prod, prodL, q, qd, rem, remL, rem0, sd, t, xi, xL, yd0,\r\n yL, yz,\r\n Ctor = x.constructor,\r\n sign = x.s == y.s ? 1 : -1,\r\n xd = x.d,\r\n yd = y.d;\r\n\r\n // Either NaN, Infinity or 0?\r\n if (!xd || !xd[0] || !yd || !yd[0]) {\r\n\r\n return new Ctor(// Return NaN if either NaN, or both Infinity or 0.\r\n !x.s || !y.s || (xd ? yd && xd[0] == yd[0] : !yd) ? NaN :\r\n\r\n // Return ±0 if x is 0 or y is ±Infinity, or return ±Infinity as y is 0.\r\n xd && xd[0] == 0 || !yd ? sign * 0 : sign / 0);\r\n }\r\n\r\n if (base) {\r\n logBase = 1;\r\n e = x.e - y.e;\r\n } else {\r\n base = BASE;\r\n logBase = LOG_BASE;\r\n e = mathfloor(x.e / logBase) - mathfloor(y.e / logBase);\r\n }\r\n\r\n yL = yd.length;\r\n xL = xd.length;\r\n q = new Ctor(sign);\r\n qd = q.d = [];\r\n\r\n // Result exponent may be one less than e.\r\n // The digit array of a Decimal from toStringBinary may have trailing zeros.\r\n for (i = 0; yd[i] == (xd[i] || 0); i++);\r\n\r\n if (yd[i] > (xd[i] || 0)) e--;\r\n\r\n if (pr == null) {\r\n sd = pr = Ctor.precision;\r\n rm = Ctor.rounding;\r\n } else if (dp) {\r\n sd = pr + (x.e - y.e) + 1;\r\n } else {\r\n sd = pr;\r\n }\r\n\r\n if (sd < 0) {\r\n qd.push(1);\r\n more = true;\r\n } else {\r\n\r\n // Convert precision in number of base 10 digits to base 1e7 digits.\r\n sd = sd / logBase + 2 | 0;\r\n i = 0;\r\n\r\n // divisor < 1e7\r\n if (yL == 1) {\r\n k = 0;\r\n yd = yd[0];\r\n sd++;\r\n\r\n // k is the carry.\r\n for (; (i < xL || k) && sd--; i++) {\r\n t = k * base + (xd[i] || 0);\r\n qd[i] = t / yd | 0;\r\n k = t % yd | 0;\r\n }\r\n\r\n more = k || i < xL;\r\n\r\n // divisor >= 1e7\r\n } else {\r\n\r\n // Normalise xd and yd so highest order digit of yd is >= base/2\r\n k = base / (yd[0] + 1) | 0;\r\n\r\n if (k > 1) {\r\n yd = multiplyInteger(yd, k, base);\r\n xd = multiplyInteger(xd, k, base);\r\n yL = yd.length;\r\n xL = xd.length;\r\n }\r\n\r\n xi = yL;\r\n rem = xd.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\r\n yz = yd.slice();\r\n yz.unshift(0);\r\n yd0 = yd[0];\r\n\r\n if (yd[1] >= base / 2) ++yd0;\r\n\r\n do {\r\n k = 0;\r\n\r\n // Compare divisor and remainder.\r\n cmp = compare(yd, rem, yL, remL);\r\n\r\n // If divisor < remainder.\r\n if (cmp < 0) {\r\n\r\n // Calculate trial digit, k.\r\n rem0 = rem[0];\r\n if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n // k will be how many times the divisor goes into the current remainder.\r\n k = rem0 / yd0 | 0;\r\n\r\n // Algorithm:\r\n // 1. product = divisor * trial digit (k)\r\n // 2. if product > remainder: product -= divisor, k--\r\n // 3. remainder -= product\r\n // 4. if product was < remainder at 2:\r\n // 5. compare new remainder and divisor\r\n // 6. If remainder > divisor: remainder -= divisor, k++\r\n\r\n if (k > 1) {\r\n if (k >= base) k = base - 1;\r\n\r\n // product = divisor * trial digit.\r\n prod = multiplyInteger(yd, k, base);\r\n prodL = prod.length;\r\n remL = rem.length;\r\n\r\n // Compare product and remainder.\r\n cmp = compare(prod, rem, prodL, remL);\r\n\r\n // product > remainder.\r\n if (cmp == 1) {\r\n k--;\r\n\r\n // Subtract divisor from product.\r\n subtract(prod, yL < prodL ? yz : yd, prodL, base);\r\n }\r\n } else {\r\n\r\n // cmp is -1.\r\n // If k is 0, there is no need to compare yd and rem again below, so change cmp to 1\r\n // to avoid it. If k is 1 there is a need to compare yd and rem again below.\r\n if (k == 0) cmp = k = 1;\r\n prod = yd.slice();\r\n }\r\n\r\n prodL = prod.length;\r\n if (prodL < remL) prod.unshift(0);\r\n\r\n // Subtract product from remainder.\r\n subtract(rem, prod, remL, base);\r\n\r\n // If product was < previous remainder.\r\n if (cmp == -1) {\r\n remL = rem.length;\r\n\r\n // Compare divisor and new remainder.\r\n cmp = compare(yd, rem, yL, remL);\r\n\r\n // If divisor < new remainder, subtract divisor from remainder.\r\n if (cmp < 1) {\r\n k++;\r\n\r\n // Subtract divisor from remainder.\r\n subtract(rem, yL < remL ? yz : yd, remL, base);\r\n }\r\n }\r\n\r\n remL = rem.length;\r\n } else if (cmp === 0) {\r\n k++;\r\n rem = [0];\r\n } // if cmp === 1, k will be 0\r\n\r\n // Add the next digit, k, to the result array.\r\n qd[i++] = k;\r\n\r\n // Update the remainder.\r\n if (cmp && rem[0]) {\r\n rem[remL++] = xd[xi] || 0;\r\n } else {\r\n rem = [xd[xi]];\r\n remL = 1;\r\n }\r\n\r\n } while ((xi++ < xL || rem[0] !== void 0) && sd--);\r\n\r\n more = rem[0] !== void 0;\r\n }\r\n\r\n // Leading zero?\r\n if (!qd[0]) qd.shift();\r\n }\r\n\r\n // logBase is 1 when divide is being used for base conversion.\r\n if (logBase == 1) {\r\n q.e = e;\r\n inexact = more;\r\n } else {\r\n\r\n // To calculate q.e, first get the number of digits of qd[0].\r\n for (i = 1, k = qd[0]; k >= 10; k /= 10) i++;\r\n q.e = i + e * logBase - 1;\r\n\r\n finalise(q, dp ? pr + q.e + 1 : pr, rm, more);\r\n }\r\n\r\n return q;\r\n };\r\n })();\r\n\r\n\r\n /*\r\n * Round `x` to `sd` significant digits using rounding mode `rm`.\r\n * Check for over/under-flow.\r\n */\r\n function finalise(x, sd, rm, isTruncated) {\r\n var digits, i, j, k, rd, roundUp, w, xd, xdi,\r\n Ctor = x.constructor;\r\n\r\n // Don't round if sd is null or undefined.\r\n out: if (sd != null) {\r\n xd = x.d;\r\n\r\n // Infinity/NaN.\r\n if (!xd) return x;\r\n\r\n // rd: the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n // w: the word of xd containing rd, a base 1e7 number.\r\n // xdi: the index of w within xd.\r\n // digits: the number of digits of w.\r\n // i: what would be the index of rd within w if all the numbers were 7 digits long (i.e. if\r\n // they had leading zeros)\r\n // j: if > 0, the actual index of rd within w (if < 0, rd is a leading zero).\r\n\r\n // Get the length of the first word of the digits array xd.\r\n for (digits = 1, k = xd[0]; k >= 10; k /= 10) digits++;\r\n i = sd - digits;\r\n\r\n // Is the rounding digit in the first word of xd?\r\n if (i < 0) {\r\n i += LOG_BASE;\r\n j = sd;\r\n w = xd[xdi = 0];\r\n\r\n // Get the rounding digit at index j of w.\r\n rd = w / mathpow(10, digits - j - 1) % 10 | 0;\r\n } else {\r\n xdi = Math.ceil((i + 1) / LOG_BASE);\r\n k = xd.length;\r\n if (xdi >= k) {\r\n if (isTruncated) {\r\n\r\n // Needed by `naturalExponential`, `naturalLogarithm` and `squareRoot`.\r\n for (; k++ <= xdi;) xd.push(0);\r\n w = rd = 0;\r\n digits = 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 w = k = xd[xdi];\r\n\r\n // Get the number of digits of w.\r\n for (digits = 1; k >= 10; k /= 10) digits++;\r\n\r\n // Get the index of rd within w.\r\n i %= LOG_BASE;\r\n\r\n // Get the index of rd within w, adjusted for leading zeros.\r\n // The number of leading zeros of w is given by LOG_BASE - digits.\r\n j = i - LOG_BASE + digits;\r\n\r\n // Get the rounding digit at index j of w.\r\n rd = j < 0 ? 0 : w / mathpow(10, digits - j - 1) % 10 | 0;\r\n }\r\n }\r\n\r\n // Are there any non-zero digits after the rounding digit?\r\n isTruncated = isTruncated || sd < 0 ||\r\n xd[xdi + 1] !== void 0 || (j < 0 ? w : w % mathpow(10, digits - j - 1));\r\n\r\n // The expression `w % mathpow(10, digits - j - 1)` returns all the digits of w to the right\r\n // of the digit at (left-to-right) index j, e.g. if w is 908714 and j is 2, the expression\r\n // will give 714.\r\n\r\n roundUp = rm < 4\r\n ? (rd || isTruncated) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n : rd > 5 || rd == 5 && (rm == 4 || isTruncated || 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 ? w / mathpow(10, digits - j) : 0 : xd[xdi - 1]) % 10) & 1 ||\r\n rm == (x.s < 0 ? 8 : 7));\r\n\r\n if (sd < 1 || !xd[0]) {\r\n xd.length = 0;\r\n if (roundUp) {\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 xd[0] = mathpow(10, (LOG_BASE - sd % LOG_BASE) % LOG_BASE);\r\n x.e = -sd || 0;\r\n } else {\r\n\r\n // Zero.\r\n xd[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 xd.length = xdi;\r\n k = 1;\r\n xdi--;\r\n } else {\r\n xd.length = xdi + 1;\r\n k = mathpow(10, 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 w.\r\n xd[xdi] = j > 0 ? (w / mathpow(10, digits - j) % mathpow(10, j) | 0) * k : 0;\r\n }\r\n\r\n if (roundUp) {\r\n for (;;) {\r\n\r\n // Is the digit to be rounded up in the first word of xd?\r\n if (xdi == 0) {\r\n\r\n // i will be the length of xd[0] before k is added.\r\n for (i = 1, j = xd[0]; j >= 10; j /= 10) i++;\r\n j = xd[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 (xd[0] == BASE) xd[0] = 1;\r\n }\r\n\r\n break;\r\n } else {\r\n xd[xdi] += k;\r\n if (xd[xdi] != BASE) break;\r\n xd[xdi--] = 0;\r\n k = 1;\r\n }\r\n }\r\n }\r\n\r\n // Remove trailing zeros.\r\n for (i = xd.length; xd[--i] === 0;) xd.pop();\r\n }\r\n\r\n if (external) {\r\n\r\n // Overflow?\r\n if (x.e > Ctor.maxE) {\r\n\r\n // Infinity.\r\n x.d = null;\r\n x.e = NaN;\r\n\r\n // Underflow?\r\n } else if (x.e < Ctor.minE) {\r\n\r\n // Zero.\r\n x.e = 0;\r\n x.d = [0];\r\n // Ctor.underflow = true;\r\n } // else Ctor.underflow = false;\r\n }\r\n\r\n return x;\r\n }\r\n\r\n\r\n function finiteToString(x, isExp, sd) {\r\n if (!x.isFinite()) return nonFiniteToString(x);\r\n var k,\r\n e = x.e,\r\n str = digitsToString(x.d),\r\n len = str.length;\r\n\r\n if (isExp) {\r\n if (sd && (k = sd - len) > 0) {\r\n str = str.charAt(0) + '.' + str.slice(1) + getZeroString(k);\r\n } else if (len > 1) {\r\n str = str.charAt(0) + '.' + str.slice(1);\r\n }\r\n\r\n str = str + (x.e < 0 ? 'e' : 'e+') + x.e;\r\n } else if (e < 0) {\r\n str = '0.' + getZeroString(-e - 1) + str;\r\n if (sd && (k = sd - len) > 0) str += getZeroString(k);\r\n } else if (e >= len) {\r\n str += getZeroString(e + 1 - len);\r\n if (sd && (k = sd - e - 1) > 0) str = str + '.' + getZeroString(k);\r\n } else {\r\n if ((k = e + 1) < len) str = str.slice(0, k) + '.' + str.slice(k);\r\n if (sd && (k = sd - len) > 0) {\r\n if (e + 1 === len) str += '.';\r\n str += getZeroString(k);\r\n }\r\n }\r\n\r\n return str;\r\n }\r\n\r\n\r\n // Calculate the base 10 exponent from the base 1e7 exponent.\r\n function getBase10Exponent(digits, e) {\r\n var w = digits[0];\r\n\r\n // Add the number of digits of the first word of the digits array.\r\n for ( e *= LOG_BASE; w >= 10; w /= 10) e++;\r\n return e;\r\n }\r\n\r\n\r\n function getLn10(Ctor, sd, pr) {\r\n if (sd > LN10_PRECISION) {\r\n\r\n // Reset global state in case the exception is caught.\r\n external = true;\r\n if (pr) Ctor.precision = pr;\r\n throw Error(precisionLimitExceeded);\r\n }\r\n return finalise(new Ctor(LN10), sd, 1, true);\r\n }\r\n\r\n\r\n function getPi(Ctor, sd, rm) {\r\n if (sd > PI_PRECISION) throw Error(precisionLimitExceeded);\r\n return finalise(new Ctor(PI), sd, rm, true);\r\n }\r\n\r\n\r\n function getPrecision(digits) {\r\n var w = digits.length - 1,\r\n len = w * LOG_BASE + 1;\r\n\r\n w = digits[w];\r\n\r\n // If non-zero...\r\n if (w) {\r\n\r\n // Subtract the number of trailing zeros of the last word.\r\n for (; w % 10 == 0; w /= 10) len--;\r\n\r\n // Add the number of digits of the first word.\r\n for (w = digits[0]; w >= 10; w /= 10) len++;\r\n }\r\n\r\n return len;\r\n }\r\n\r\n\r\n function getZeroString(k) {\r\n var zs = '';\r\n for (; k--;) zs += '0';\r\n return zs;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the value of Decimal `x` to the power `n`, where `n` is an\r\n * integer of type number.\r\n *\r\n * Implements 'exponentiation by squaring'. Called by `pow` and `parseOther`.\r\n *\r\n */\r\n function intPow(Ctor, x, n, pr) {\r\n var isTruncated,\r\n r = new Ctor(1),\r\n\r\n // Max n of 9007199254740991 takes 53 loop iterations.\r\n // Maximum digits array length; leaves [28, 34] guard digits.\r\n k = Math.ceil(pr / LOG_BASE + 4);\r\n\r\n external = false;\r\n\r\n for (;;) {\r\n if (n % 2) {\r\n r = r.times(x);\r\n if (truncate(r.d, k)) isTruncated = true;\r\n }\r\n\r\n n = mathfloor(n / 2);\r\n if (n === 0) {\r\n\r\n // To ensure correct rounding when r.d is truncated, increment the last word if it is zero.\r\n n = r.d.length - 1;\r\n if (isTruncated && r.d[n] === 0) ++r.d[n];\r\n break;\r\n }\r\n\r\n x = x.times(x);\r\n truncate(x.d, k);\r\n }\r\n\r\n external = true;\r\n\r\n return r;\r\n }\r\n\r\n\r\n function isOdd(n) {\r\n return n.d[n.d.length - 1] & 1;\r\n }\r\n\r\n\r\n /*\r\n * Handle `max` and `min`. `ltgt` is 'lt' or 'gt'.\r\n */\r\n function maxOrMin(Ctor, args, ltgt) {\r\n var y,\r\n x = new Ctor(args[0]),\r\n i = 0;\r\n\r\n for (; ++i < args.length;) {\r\n y = new Ctor(args[i]);\r\n if (!y.s) {\r\n x = y;\r\n break;\r\n } else if (x[ltgt](y)) {\r\n x = y;\r\n }\r\n }\r\n\r\n return x;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the natural exponential of `x` rounded to `sd` significant\r\n * digits.\r\n *\r\n * Taylor/Maclaurin series.\r\n *\r\n * exp(x) = x^0/0! + x^1/1! + x^2/2! + x^3/3! + ...\r\n *\r\n * Argument reduction:\r\n * Repeat x = x / 32, k += 5, until |x| < 0.1\r\n * exp(x) = exp(x / 2^k)^(2^k)\r\n *\r\n * Previously, the argument was initially reduced by\r\n * exp(x) = exp(r) * 10^k where r = x - k * ln10, k = floor(x / ln10)\r\n * to first put r in the range [0, ln10], before dividing by 32 until |x| < 0.1, but this was\r\n * found to be slower than just dividing repeatedly by 32 as above.\r\n *\r\n * Max integer argument: exp('20723265836946413') = 6.3e+9000000000000000\r\n * Min integer argument: exp('-20723265836946411') = 1.2e-9000000000000000\r\n * (Math object integer min/max: Math.exp(709) = 8.2e+307, Math.exp(-745) = 5e-324)\r\n *\r\n * exp(Infinity) = Infinity\r\n * exp(-Infinity) = 0\r\n * exp(NaN) = NaN\r\n * exp(±0) = 1\r\n *\r\n * exp(x) is non-terminating for any finite, non-zero x.\r\n *\r\n * The result will always be correctly rounded.\r\n *\r\n */\r\n function naturalExponential(x, sd) {\r\n var denominator, guard, j, pow, sum, t, wpr,\r\n rep = 0,\r\n i = 0,\r\n k = 0,\r\n Ctor = x.constructor,\r\n rm = Ctor.rounding,\r\n pr = Ctor.precision;\r\n\r\n // 0/NaN/Infinity?\r\n if (!x.d || !x.d[0] || x.e > 17) {\r\n\r\n return new Ctor(x.d\r\n ? !x.d[0] ? 1 : x.s < 0 ? 0 : 1 / 0\r\n : x.s ? x.s < 0 ? 0 : x : 0 / 0);\r\n }\r\n\r\n if (sd == null) {\r\n external = false;\r\n wpr = pr;\r\n } else {\r\n wpr = sd;\r\n }\r\n\r\n t = new Ctor(0.03125);\r\n\r\n // while abs(x) >= 0.1\r\n while (x.e > -2) {\r\n\r\n // x = x / 2^5\r\n x = x.times(t);\r\n k += 5;\r\n }\r\n\r\n // Use 2 * log10(2^k) + 5 (empirically derived) to estimate the increase in precision\r\n // necessary to ensure the first 4 rounding digits are correct.\r\n guard = Math.log(mathpow(2, k)) / Math.LN10 * 2 + 5 | 0;\r\n wpr += guard;\r\n denominator = pow = sum = new Ctor(1);\r\n Ctor.precision = wpr;\r\n\r\n for (;;) {\r\n pow = finalise(pow.times(x), wpr, 1);\r\n denominator = denominator.times(++i);\r\n t = sum.plus(divide(pow, denominator, wpr, 1));\r\n\r\n if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {\r\n j = k;\r\n while (j--) sum = finalise(sum.times(sum), wpr, 1);\r\n\r\n // Check to see if the first 4 rounding digits are [49]999.\r\n // If so, repeat the summation with a higher precision, otherwise\r\n // e.g. with precision: 18, rounding: 1\r\n // exp(18.404272462595034083567793919843761) = 98372560.1229999999 (should be 98372560.123)\r\n // `wpr - guard` is the index of first rounding digit.\r\n if (sd == null) {\r\n\r\n if (rep < 3 && checkRoundingDigits(sum.d, wpr - guard, rm, rep)) {\r\n Ctor.precision = wpr += 10;\r\n denominator = pow = t = new Ctor(1);\r\n i = 0;\r\n rep++;\r\n } else {\r\n return finalise(sum, Ctor.precision = pr, rm, external = true);\r\n }\r\n } else {\r\n Ctor.precision = pr;\r\n return sum;\r\n }\r\n }\r\n\r\n sum = t;\r\n }\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the natural logarithm of `x` rounded to `sd` significant\r\n * digits.\r\n *\r\n * ln(-n) = NaN\r\n * ln(0) = -Infinity\r\n * ln(-0) = -Infinity\r\n * ln(1) = 0\r\n * ln(Infinity) = Infinity\r\n * ln(-Infinity) = NaN\r\n * ln(NaN) = NaN\r\n *\r\n * ln(n) (n != 1) is non-terminating.\r\n *\r\n */\r\n function naturalLogarithm(y, sd) {\r\n var c, c0, denominator, e, numerator, rep, sum, t, wpr, x1, x2,\r\n n = 1,\r\n guard = 10,\r\n x = y,\r\n xd = x.d,\r\n Ctor = x.constructor,\r\n rm = Ctor.rounding,\r\n pr = Ctor.precision;\r\n\r\n // Is x negative or Infinity, NaN, 0 or 1?\r\n if (x.s < 0 || !xd || !xd[0] || !x.e && xd[0] == 1 && xd.length == 1) {\r\n return new Ctor(xd && !xd[0] ? -1 / 0 : x.s != 1 ? NaN : xd ? 0 : x);\r\n }\r\n\r\n if (sd == null) {\r\n external = false;\r\n wpr = pr;\r\n } else {\r\n wpr = sd;\r\n }\r\n\r\n Ctor.precision = wpr += guard;\r\n c = digitsToString(xd);\r\n c0 = c.charAt(0);\r\n\r\n if (Math.abs(e = x.e) < 1.5e15) {\r\n\r\n // Argument reduction.\r\n // The series converges faster the closer the argument is to 1, so using\r\n // ln(a^b) = b * ln(a), ln(a) = ln(a^b) / b\r\n // multiply the argument by itself until the leading digits of the significand are 7, 8, 9,\r\n // 10, 11, 12 or 13, recording the number of multiplications so the sum of the series can\r\n // later be divided by this number, then separate out the power of 10 using\r\n // ln(a*10^b) = ln(a) + b*ln(10).\r\n\r\n // max n is 21 (gives 0.9, 1.0 or 1.1) (9e15 / 21 = 4.2e14).\r\n //while (c0 < 9 && c0 != 1 || c0 == 1 && c.charAt(1) > 1) {\r\n // max n is 6 (gives 0.7 - 1.3)\r\n while (c0 < 7 && c0 != 1 || c0 == 1 && c.charAt(1) > 3) {\r\n x = x.times(y);\r\n c = digitsToString(x.d);\r\n c0 = c.charAt(0);\r\n n++;\r\n }\r\n\r\n e = x.e;\r\n\r\n if (c0 > 1) {\r\n x = new Ctor('0.' + c);\r\n e++;\r\n } else {\r\n x = new Ctor(c0 + '.' + c.slice(1));\r\n }\r\n } else {\r\n\r\n // The argument reduction method above may result in overflow if the argument y is a massive\r\n // number with exponent >= 1500000000000000 (9e15 / 6 = 1.5e15), so instead recall this\r\n // function using ln(x*10^e) = ln(x) + e*ln(10).\r\n t = getLn10(Ctor, wpr + 2, pr).times(e + '');\r\n x = naturalLogarithm(new Ctor(c0 + '.' + c.slice(1)), wpr - guard).plus(t);\r\n Ctor.precision = pr;\r\n\r\n return sd == null ? finalise(x, pr, rm, external = true) : x;\r\n }\r\n\r\n // x1 is x reduced to a value near 1.\r\n x1 = x;\r\n\r\n // Taylor series.\r\n // ln(y) = ln((1 + x)/(1 - x)) = 2(x + x^3/3 + x^5/5 + x^7/7 + ...)\r\n // where x = (y - 1)/(y + 1) (|x| < 1)\r\n sum = numerator = x = divide(x.minus(1), x.plus(1), wpr, 1);\r\n x2 = finalise(x.times(x), wpr, 1);\r\n denominator = 3;\r\n\r\n for (;;) {\r\n numerator = finalise(numerator.times(x2), wpr, 1);\r\n t = sum.plus(divide(numerator, new Ctor(denominator), wpr, 1));\r\n\r\n if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {\r\n sum = sum.times(2);\r\n\r\n // Reverse the argument reduction. Check that e is not 0 because, besides preventing an\r\n // unnecessary calculation, -0 + 0 = +0 and to ensure correct rounding -0 needs to stay -0.\r\n if (e !== 0) sum = sum.plus(getLn10(Ctor, wpr + 2, pr).times(e + ''));\r\n sum = divide(sum, new Ctor(n), wpr, 1);\r\n\r\n // Is rm > 3 and the first 4 rounding digits 4999, or rm < 4 (or the summation has\r\n // been repeated previously) and the first 4 rounding digits 9999?\r\n // If so, restart the summation with a higher precision, otherwise\r\n // e.g. with precision: 12, rounding: 1\r\n // ln(135520028.6126091714265381533) = 18.7246299999 when it should be 18.72463.\r\n // `wpr - guard` is the index of first rounding digit.\r\n if (sd == null) {\r\n if (checkRoundingDigits(sum.d, wpr - guard, rm, rep)) {\r\n Ctor.precision = wpr += guard;\r\n t = numerator = x = divide(x1.minus(1), x1.plus(1), wpr, 1);\r\n x2 = finalise(x.times(x), wpr, 1);\r\n denominator = rep = 1;\r\n } else {\r\n return finalise(sum, Ctor.precision = pr, rm, external = true);\r\n }\r\n } else {\r\n Ctor.precision = pr;\r\n return sum;\r\n }\r\n }\r\n\r\n sum = t;\r\n denominator += 2;\r\n }\r\n }\r\n\r\n\r\n // ±Infinity, NaN.\r\n function nonFiniteToString(x) {\r\n // Unsigned.\r\n return String(x.s * x.s / 0);\r\n }\r\n\r\n\r\n /*\r\n * Parse the value of a new Decimal `x` from string `str`.\r\n */\r\n function parseDecimal(x, str) {\r\n var e, i, len;\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 // 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 - 1) === 48; --len);\r\n str = str.slice(i, len);\r\n\r\n if (str) {\r\n len -= i;\r\n x.e = e = e - i - 1;\r\n x.d = [];\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 word of the digits array.\r\n i = (e + 1) % LOG_BASE;\r\n if (e < 0) i += LOG_BASE;\r\n\r\n if (i < len) {\r\n if (i) x.d.push(+str.slice(0, i));\r\n for (len -= LOG_BASE; i < len;) x.d.push(+str.slice(i, i += LOG_BASE));\r\n str = str.slice(i);\r\n i = LOG_BASE - str.length;\r\n } else {\r\n i -= len;\r\n }\r\n\r\n for (; i--;) str += '0';\r\n x.d.push(+str);\r\n\r\n if (external) {\r\n\r\n // Overflow?\r\n if (x.e > x.constructor.maxE) {\r\n\r\n // Infinity.\r\n x.d = null;\r\n x.e = NaN;\r\n\r\n // Underflow?\r\n } else if (x.e < x.constructor.minE) {\r\n\r\n // Zero.\r\n x.e = 0;\r\n x.d = [0];\r\n // x.constructor.underflow = true;\r\n } // else x.constructor.underflow = false;\r\n }\r\n } else {\r\n\r\n // Zero.\r\n x.e = 0;\r\n x.d = [0];\r\n }\r\n\r\n return x;\r\n }\r\n\r\n\r\n /*\r\n * Parse the value of a new Decimal `x` from a string `str`, which is not a decimal value.\r\n */\r\n function parseOther(x, str) {\r\n var base, Ctor, divisor, i, isFloat, len, p, xd, xe;\r\n\r\n if (str.indexOf('_') > -1) {\r\n str = str.replace(/(\\d)_(?=\\d)/g, '$1');\r\n if (isDecimal.test(str)) return parseDecimal(x, str);\r\n } else if (str === 'Infinity' || str === 'NaN') {\r\n if (!+str) x.s = NaN;\r\n x.e = NaN;\r\n x.d = null;\r\n return x;\r\n }\r\n\r\n if (isHex.test(str)) {\r\n base = 16;\r\n str = str.toLowerCase();\r\n } else if (isBinary.test(str)) {\r\n base = 2;\r\n } else if (isOctal.test(str)) {\r\n base = 8;\r\n } else {\r\n throw Error(invalidArgument + str);\r\n }\r\n\r\n // Is there a binary exponent part?\r\n i = str.search(/p/i);\r\n\r\n if (i > 0) {\r\n p = +str.slice(i + 1);\r\n str = str.substring(2, i);\r\n } else {\r\n str = str.slice(2);\r\n }\r\n\r\n // Convert `str` as an integer then divide the result by `base` raised to a power such that the\r\n // fraction part will be restored.\r\n i = str.indexOf('.');\r\n isFloat = i >= 0;\r\n Ctor = x.constructor;\r\n\r\n if (isFloat) {\r\n str = str.replace('.', '');\r\n len = str.length;\r\n i = len - i;\r\n\r\n // log[10](16) = 1.2041... , log[10](88) = 1.9444....\r\n divisor = intPow(Ctor, new Ctor(base), i, i * 2);\r\n }\r\n\r\n xd = convertBase(str, base, BASE);\r\n xe = xd.length - 1;\r\n\r\n // Remove trailing zeros.\r\n for (i = xe; xd[i] === 0; --i) xd.pop();\r\n if (i < 0) return new Ctor(x.s * 0);\r\n x.e = getBase10Exponent(xd, xe);\r\n x.d = xd;\r\n external = false;\r\n\r\n // At what precision to perform the division to ensure exact conversion?\r\n // maxDecimalIntegerPartDigitCount = ceil(log[10](b) * otherBaseIntegerPartDigitCount)\r\n // log[10](2) = 0.30103, log[10](8) = 0.90309, log[10](16) = 1.20412\r\n // E.g. ceil(1.2 * 3) = 4, so up to 4 decimal digits are needed to represent 3 hex int digits.\r\n // maxDecimalFractionPartDigitCount = {Hex:4|Oct:3|Bin:1} * otherBaseFractionPartDigitCount\r\n // Therefore using 4 * the number of digits of str will always be enough.\r\n if (isFloat) x = divide(x, divisor, len * 4);\r\n\r\n // Multiply by the binary exponent part if present.\r\n if (p) x = x.times(Math.abs(p) < 54 ? mathpow(2, p) : Decimal.pow(2, p));\r\n external = true;\r\n\r\n return x;\r\n }\r\n\r\n\r\n /*\r\n * sin(x) = x - x^3/3! + x^5/5! - ...\r\n * |x| < pi/2\r\n *\r\n */\r\n function sine(Ctor, x) {\r\n var k,\r\n len = x.d.length;\r\n\r\n if (len < 3) {\r\n return x.isZero() ? x : taylorSeries(Ctor, 2, x, x);\r\n }\r\n\r\n // Argument reduction: sin(5x) = 16*sin^5(x) - 20*sin^3(x) + 5*sin(x)\r\n // i.e. sin(x) = 16*sin^5(x/5) - 20*sin^3(x/5) + 5*sin(x/5)\r\n // and sin(x) = sin(x/5)(5 + sin^2(x/5)(16sin^2(x/5) - 20))\r\n\r\n // Estimate the optimum number of times to use the argument reduction.\r\n k = 1.4 * Math.sqrt(len);\r\n k = k > 16 ? 16 : k | 0;\r\n\r\n x = x.times(1 / tinyPow(5, k));\r\n x = taylorSeries(Ctor, 2, x, x);\r\n\r\n // Reverse argument reduction\r\n var sin2_x,\r\n d5 = new Ctor(5),\r\n d16 = new Ctor(16),\r\n d20 = new Ctor(20);\r\n for (; k--;) {\r\n sin2_x = x.times(x);\r\n x = x.times(d5.plus(sin2_x.times(d16.times(sin2_x).minus(d20))));\r\n }\r\n\r\n return x;\r\n }\r\n\r\n\r\n // Calculate Taylor series for `cos`, `cosh`, `sin` and `sinh`.\r\n function taylorSeries(Ctor, n, x, y, isHyperbolic) {\r\n var j, t, u, x2,\r\n i = 1,\r\n pr = Ctor.precision,\r\n k = Math.ceil(pr / LOG_BASE);\r\n\r\n external = false;\r\n x2 = x.times(x);\r\n u = new Ctor(y);\r\n\r\n for (;;) {\r\n t = divide(u.times(x2), new Ctor(n++ * n++), pr, 1);\r\n u = isHyperbolic ? y.plus(t) : y.minus(t);\r\n y = divide(t.times(x2), new Ctor(n++ * n++), pr, 1);\r\n t = u.plus(y);\r\n\r\n if (t.d[k] !== void 0) {\r\n for (j = k; t.d[j] === u.d[j] && j--;);\r\n if (j == -1) break;\r\n }\r\n\r\n j = u;\r\n u = y;\r\n y = t;\r\n t = j;\r\n i++;\r\n }\r\n\r\n external = true;\r\n t.d.length = k + 1;\r\n\r\n return t;\r\n }\r\n\r\n\r\n // Exponent e must be positive and non-zero.\r\n function tinyPow(b, e) {\r\n var n = b;\r\n while (--e) n *= b;\r\n return n;\r\n }\r\n\r\n\r\n // Return the absolute value of `x` reduced to less than or equal to half pi.\r\n function toLessThanHalfPi(Ctor, x) {\r\n var t,\r\n isNeg = x.s < 0,\r\n pi = getPi(Ctor, Ctor.precision, 1),\r\n halfPi = pi.times(0.5);\r\n\r\n x = x.abs();\r\n\r\n if (x.lte(halfPi)) {\r\n quadrant = isNeg ? 4 : 1;\r\n return x;\r\n }\r\n\r\n t = x.divToInt(pi);\r\n\r\n if (t.isZero()) {\r\n quadrant = isNeg ? 3 : 2;\r\n } else {\r\n x = x.minus(t.times(pi));\r\n\r\n // 0 <= x < pi\r\n if (x.lte(halfPi)) {\r\n quadrant = isOdd(t) ? (isNeg ? 2 : 3) : (isNeg ? 4 : 1);\r\n return x;\r\n }\r\n\r\n quadrant = isOdd(t) ? (isNeg ? 1 : 4) : (isNeg ? 3 : 2);\r\n }\r\n\r\n return x.minus(pi).abs();\r\n }\r\n\r\n\r\n /*\r\n * Return the value of Decimal `x` as a string in base `baseOut`.\r\n *\r\n * If the optional `sd` argument is present include a binary exponent suffix.\r\n */\r\n function toStringBinary(x, baseOut, sd, rm) {\r\n var base, e, i, k, len, roundUp, str, xd, y,\r\n Ctor = x.constructor,\r\n isExp = sd !== void 0;\r\n\r\n if (isExp) {\r\n checkInt32(sd, 1, MAX_DIGITS);\r\n if (rm === void 0) rm = Ctor.rounding;\r\n else checkInt32(rm, 0, 8);\r\n } else {\r\n sd = Ctor.precision;\r\n rm = Ctor.rounding;\r\n }\r\n\r\n if (!x.isFinite()) {\r\n str = nonFiniteToString(x);\r\n } else {\r\n str = finiteToString(x);\r\n i = str.indexOf('.');\r\n\r\n // Use exponential notation according to `toExpPos` and `toExpNeg`? No, but if required:\r\n // maxBinaryExponent = floor((decimalExponent + 1) * log[2](10))\r\n // minBinaryExponent = floor(decimalExponent * log[2](10))\r\n // log[2](10) = 3.321928094887362347870319429489390175864\r\n\r\n if (isExp) {\r\n base = 2;\r\n if (baseOut == 16) {\r\n sd = sd * 4 - 3;\r\n } else if (baseOut == 8) {\r\n sd = sd * 3 - 2;\r\n }\r\n } else {\r\n base = baseOut;\r\n }\r\n\r\n // Convert the number as an integer then divide the result by its base raised to a power such\r\n // that the fraction part will be restored.\r\n\r\n // Non-integer.\r\n if (i >= 0) {\r\n str = str.replace('.', '');\r\n y = new Ctor(1);\r\n y.e = str.length - i;\r\n y.d = convertBase(finiteToString(y), 10, base);\r\n y.e = y.d.length;\r\n }\r\n\r\n xd = convertBase(str, 10, base);\r\n e = len = xd.length;\r\n\r\n // Remove trailing zeros.\r\n for (; xd[--len] == 0;) xd.pop();\r\n\r\n if (!xd[0]) {\r\n str = isExp ? '0p+0' : '0';\r\n } else {\r\n if (i < 0) {\r\n e--;\r\n } else {\r\n x = new Ctor(x);\r\n x.d = xd;\r\n x.e = e;\r\n x = divide(x, y, sd, rm, 0, base);\r\n xd = x.d;\r\n e = x.e;\r\n roundUp = inexact;\r\n }\r\n\r\n // The rounding digit, i.e. the digit after the digit that may be rounded up.\r\n i = xd[sd];\r\n k = base / 2;\r\n roundUp = roundUp || xd[sd + 1] !== void 0;\r\n\r\n roundUp = rm < 4\r\n ? (i !== void 0 || roundUp) && (rm === 0 || rm === (x.s < 0 ? 3 : 2))\r\n : i > k || i === k && (rm === 4 || roundUp || rm === 6 && xd[sd - 1] & 1 ||\r\n rm === (x.s < 0 ? 8 : 7));\r\n\r\n xd.length = sd;\r\n\r\n if (roundUp) {\r\n\r\n // Rounding up may mean the previous digit has to be rounded up and so on.\r\n for (; ++xd[--sd] > base - 1;) {\r\n xd[sd] = 0;\r\n if (!sd) {\r\n ++e;\r\n xd.unshift(1);\r\n }\r\n }\r\n }\r\n\r\n // Determine trailing zeros.\r\n for (len = xd.length; !xd[len - 1]; --len);\r\n\r\n // E.g. [4, 11, 15] becomes 4bf.\r\n for (i = 0, str = ''; i < len; i++) str += NUMERALS.charAt(xd[i]);\r\n\r\n // Add binary exponent suffix?\r\n if (isExp) {\r\n if (len > 1) {\r\n if (baseOut == 16 || baseOut == 8) {\r\n i = baseOut == 16 ? 4 : 3;\r\n for (--len; len % i; len++) str += '0';\r\n xd = convertBase(str, base, baseOut);\r\n for (len = xd.length; !xd[len - 1]; --len);\r\n\r\n // xd[0] will always be be 1\r\n for (i = 1, str = '1.'; i < len; i++) str += NUMERALS.charAt(xd[i]);\r\n } else {\r\n str = str.charAt(0) + '.' + str.slice(1);\r\n }\r\n }\r\n\r\n str = str + (e < 0 ? 'p' : 'p+') + e;\r\n } else if (e < 0) {\r\n for (; ++e;) str = '0' + str;\r\n str = '0.' + str;\r\n } else {\r\n if (++e > len) for (e -= len; e-- ;) str += '0';\r\n else if (e < len) str = str.slice(0, e) + '.' + str.slice(e);\r\n }\r\n }\r\n\r\n str = (baseOut == 16 ? '0x' : baseOut == 2 ? '0b' : baseOut == 8 ? '0o' : '') + str;\r\n }\r\n\r\n return x.s < 0 ? '-' + str : str;\r\n }\r\n\r\n\r\n // Does not strip trailing zeros.\r\n function truncate(arr, len) {\r\n if (arr.length > len) {\r\n arr.length = len;\r\n return true;\r\n }\r\n }\r\n\r\n\r\n // Decimal methods\r\n\r\n\r\n /*\r\n * abs\r\n * acos\r\n * acosh\r\n * add\r\n * asin\r\n * asinh\r\n * atan\r\n * atanh\r\n * atan2\r\n * cbrt\r\n * ceil\r\n * clamp\r\n * clone\r\n * config\r\n * cos\r\n * cosh\r\n * div\r\n * exp\r\n * floor\r\n * hypot\r\n * ln\r\n * log\r\n * log2\r\n * log10\r\n * max\r\n * min\r\n * mod\r\n * mul\r\n * pow\r\n * random\r\n * round\r\n * set\r\n * sign\r\n * sin\r\n * sinh\r\n * sqrt\r\n * sub\r\n * sum\r\n * tan\r\n * tanh\r\n * trunc\r\n */\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the absolute value of `x`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function abs(x) {\r\n return new this(x).abs();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the arccosine in radians of `x`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function acos(x) {\r\n return new this(x).acos();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic cosine of `x`, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function acosh(x) {\r\n return new this(x).acosh();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the sum of `x` and `y`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n * y {number|string|Decimal}\r\n *\r\n */\r\n function add(x, y) {\r\n return new this(x).plus(y);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the arcsine in radians of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function asin(x) {\r\n return new this(x).asin();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic sine of `x`, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function asinh(x) {\r\n return new this(x).asinh();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the arctangent in radians of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function atan(x) {\r\n return new this(x).atan();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the inverse of the hyperbolic tangent of `x`, rounded to\r\n * `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function atanh(x) {\r\n return new this(x).atanh();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the arctangent in radians of `y/x` in the range -pi to pi\r\n * (inclusive), rounded to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * Domain: [-Infinity, Infinity]\r\n * Range: [-pi, pi]\r\n *\r\n * y {number|string|Decimal} The y-coordinate.\r\n * x {number|string|Decimal} The x-coordinate.\r\n *\r\n * atan2(±0, -0) = ±pi\r\n * atan2(±0, +0) = ±0\r\n * atan2(±0, -x) = ±pi for x > 0\r\n * atan2(±0, x) = ±0 for x > 0\r\n * atan2(-y, ±0) = -pi/2 for y > 0\r\n * atan2(y, ±0) = pi/2 for y > 0\r\n * atan2(±y, -Infinity) = ±pi for finite y > 0\r\n * atan2(±y, +Infinity) = ±0 for finite y > 0\r\n * atan2(±Infinity, x) = ±pi/2 for finite x\r\n * atan2(±Infinity, -Infinity) = ±3*pi/4\r\n * atan2(±Infinity, +Infinity) = ±pi/4\r\n * atan2(NaN, x) = NaN\r\n * atan2(y, NaN) = NaN\r\n *\r\n */\r\n function atan2(y, x) {\r\n y = new this(y);\r\n x = new this(x);\r\n var r,\r\n pr = this.precision,\r\n rm = this.rounding,\r\n wpr = pr + 4;\r\n\r\n // Either NaN\r\n if (!y.s || !x.s) {\r\n r = new this(NaN);\r\n\r\n // Both ±Infinity\r\n } else if (!y.d && !x.d) {\r\n r = getPi(this, wpr, 1).times(x.s > 0 ? 0.25 : 0.75);\r\n r.s = y.s;\r\n\r\n // x is ±Infinity or y is ±0\r\n } else if (!x.d || y.isZero()) {\r\n r = x.s < 0 ? getPi(this, pr, rm) : new this(0);\r\n r.s = y.s;\r\n\r\n // y is ±Infinity or x is ±0\r\n } else if (!y.d || x.isZero()) {\r\n r = getPi(this, wpr, 1).times(0.5);\r\n r.s = y.s;\r\n\r\n // Both non-zero and finite\r\n } else if (x.s < 0) {\r\n this.precision = wpr;\r\n this.rounding = 1;\r\n r = this.atan(divide(y, x, wpr, 1));\r\n x = getPi(this, wpr, 1);\r\n this.precision = pr;\r\n this.rounding = rm;\r\n r = y.s < 0 ? r.minus(x) : r.plus(x);\r\n } else {\r\n r = this.atan(divide(y, x, wpr, 1));\r\n }\r\n\r\n return r;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the cube root of `x`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function cbrt(x) {\r\n return new this(x).cbrt();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` rounded to an integer using `ROUND_CEIL`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function ceil(x) {\r\n return finalise(x = new this(x), x.e + 1, 2);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` clamped to the range delineated by `min` and `max`.\r\n *\r\n * x {number|string|Decimal}\r\n * min {number|string|Decimal}\r\n * max {number|string|Decimal}\r\n *\r\n */\r\n function clamp(x, min, max) {\r\n return new this(x).clamp(min, max);\r\n }\r\n\r\n\r\n /*\r\n * Configure global settings for a Decimal constructor.\r\n *\r\n * `obj` is an object with one or more of the following properties,\r\n *\r\n * precision {number}\r\n * rounding {number}\r\n * toExpNeg {number}\r\n * toExpPos {number}\r\n * maxE {number}\r\n * minE {number}\r\n * modulo {number}\r\n * crypto {boolean|number}\r\n * defaults {true}\r\n *\r\n * E.g. Decimal.config({ precision: 20, rounding: 4 })\r\n *\r\n */\r\n function config(obj) {\r\n if (!obj || typeof obj !== 'object') throw Error(decimalError + 'Object expected');\r\n var i, p, v,\r\n useDefaults = obj.defaults === true,\r\n ps = [\r\n 'precision', 1, MAX_DIGITS,\r\n 'rounding', 0, 8,\r\n 'toExpNeg', -EXP_LIMIT, 0,\r\n 'toExpPos', 0, EXP_LIMIT,\r\n 'maxE', 0, EXP_LIMIT,\r\n 'minE', -EXP_LIMIT, 0,\r\n 'modulo', 0, 9\r\n ];\r\n\r\n for (i = 0; i < ps.length; i += 3) {\r\n if (p = ps[i], useDefaults) this[p] = DEFAULTS[p];\r\n if ((v = obj[p]) !== void 0) {\r\n if (mathfloor(v) === v && v >= ps[i + 1] && v <= ps[i + 2]) this[p] = v;\r\n else throw Error(invalidArgument + p + ': ' + v);\r\n }\r\n }\r\n\r\n if (p = 'crypto', useDefaults) this[p] = DEFAULTS[p];\r\n if ((v = obj[p]) !== void 0) {\r\n if (v === true || v === false || v === 0 || v === 1) {\r\n if (v) {\r\n if (typeof crypto != 'undefined' && crypto &&\r\n (crypto.getRandomValues || crypto.randomBytes)) {\r\n this[p] = true;\r\n } else {\r\n throw Error(cryptoUnavailable);\r\n }\r\n } else {\r\n this[p] = false;\r\n }\r\n } else {\r\n throw Error(invalidArgument + p + ': ' + v);\r\n }\r\n }\r\n\r\n return this;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the cosine of `x`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function cos(x) {\r\n return new this(x).cos();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the hyperbolic cosine of `x`, rounded to precision\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function cosh(x) {\r\n return new this(x).cosh();\r\n }\r\n\r\n\r\n /*\r\n * Create and return a Decimal constructor with the same configuration properties as this Decimal\r\n * constructor.\r\n *\r\n */\r\n function clone(obj) {\r\n var i, p, ps;\r\n\r\n /*\r\n * The Decimal constructor and exported function.\r\n * Return a new Decimal instance.\r\n *\r\n * v {number|string|Decimal} A numeric value.\r\n *\r\n */\r\n function Decimal(v) {\r\n var e, i, t,\r\n x = this;\r\n\r\n // Decimal called without new.\r\n if (!(x instanceof Decimal)) return new Decimal(v);\r\n\r\n // Retain a reference to this Decimal constructor, and shadow Decimal.prototype.constructor\r\n // which points to Object.\r\n x.constructor = Decimal;\r\n\r\n // Duplicate.\r\n if (isDecimalInstance(v)) {\r\n x.s = v.s;\r\n\r\n if (external) {\r\n if (!v.d || v.e > Decimal.maxE) {\r\n\r\n // Infinity.\r\n x.e = NaN;\r\n x.d = null;\r\n } else if (v.e < Decimal.minE) {\r\n\r\n // Zero.\r\n x.e = 0;\r\n x.d = [0];\r\n } else {\r\n x.e = v.e;\r\n x.d = v.d.slice();\r\n }\r\n } else {\r\n x.e = v.e;\r\n x.d = v.d ? v.d.slice() : v.d;\r\n }\r\n\r\n return;\r\n }\r\n\r\n t = typeof v;\r\n\r\n if (t === 'number') {\r\n if (v === 0) {\r\n x.s = 1 / v < 0 ? -1 : 1;\r\n x.e = 0;\r\n x.d = [0];\r\n return;\r\n }\r\n\r\n if (v < 0) {\r\n v = -v;\r\n x.s = -1;\r\n } else {\r\n x.s = 1;\r\n }\r\n\r\n // Fast path for small integers.\r\n if (v === ~~v && v < 1e7) {\r\n for (e = 0, i = v; i >= 10; i /= 10) e++;\r\n\r\n if (external) {\r\n if (e > Decimal.maxE) {\r\n x.e = NaN;\r\n x.d = null;\r\n } else if (e < Decimal.minE) {\r\n x.e = 0;\r\n x.d = [0];\r\n } else {\r\n x.e = e;\r\n x.d = [v];\r\n }\r\n } else {\r\n x.e = e;\r\n x.d = [v];\r\n }\r\n\r\n return;\r\n\r\n // Infinity, NaN.\r\n } else if (v * 0 !== 0) {\r\n if (!v) x.s = NaN;\r\n x.e = NaN;\r\n x.d = null;\r\n return;\r\n }\r\n\r\n return parseDecimal(x, v.toString());\r\n\r\n } else if (t !== 'string') {\r\n throw Error(invalidArgument + v);\r\n }\r\n\r\n // Minus sign?\r\n if ((i = v.charCodeAt(0)) === 45) {\r\n v = v.slice(1);\r\n x.s = -1;\r\n } else {\r\n // Plus sign?\r\n if (i === 43) v = v.slice(1);\r\n x.s = 1;\r\n }\r\n\r\n return isDecimal.test(v) ? parseDecimal(x, v) : parseOther(x, v);\r\n }\r\n\r\n Decimal.prototype = P;\r\n\r\n Decimal.ROUND_UP = 0;\r\n Decimal.ROUND_DOWN = 1;\r\n Decimal.ROUND_CEIL = 2;\r\n Decimal.ROUND_FLOOR = 3;\r\n Decimal.ROUND_HALF_UP = 4;\r\n Decimal.ROUND_HALF_DOWN = 5;\r\n Decimal.ROUND_HALF_EVEN = 6;\r\n Decimal.ROUND_HALF_CEIL = 7;\r\n Decimal.ROUND_HALF_FLOOR = 8;\r\n Decimal.EUCLID = 9;\r\n\r\n Decimal.config = Decimal.set = config;\r\n Decimal.clone = clone;\r\n Decimal.isDecimal = isDecimalInstance;\r\n\r\n Decimal.abs = abs;\r\n Decimal.acos = acos;\r\n Decimal.acosh = acosh; // ES6\r\n Decimal.add = add;\r\n Decimal.asin = asin;\r\n Decimal.asinh = asinh; // ES6\r\n Decimal.atan = atan;\r\n Decimal.atanh = atanh; // ES6\r\n Decimal.atan2 = atan2;\r\n Decimal.cbrt = cbrt; // ES6\r\n Decimal.ceil = ceil;\r\n Decimal.clamp = clamp;\r\n Decimal.cos = cos;\r\n Decimal.cosh = cosh; // ES6\r\n Decimal.div = div;\r\n Decimal.exp = exp;\r\n Decimal.floor = floor;\r\n Decimal.hypot = hypot; // ES6\r\n Decimal.ln = ln;\r\n Decimal.log = log;\r\n Decimal.log10 = log10; // ES6\r\n Decimal.log2 = log2; // ES6\r\n Decimal.max = max;\r\n Decimal.min = min;\r\n Decimal.mod = mod;\r\n Decimal.mul = mul;\r\n Decimal.pow = pow;\r\n Decimal.random = random;\r\n Decimal.round = round;\r\n Decimal.sign = sign; // ES6\r\n Decimal.sin = sin;\r\n Decimal.sinh = sinh; // ES6\r\n Decimal.sqrt = sqrt;\r\n Decimal.sub = sub;\r\n Decimal.sum = sum;\r\n Decimal.tan = tan;\r\n Decimal.tanh = tanh; // ES6\r\n Decimal.trunc = trunc; // ES6\r\n\r\n if (obj === void 0) obj = {};\r\n if (obj) {\r\n if (obj.defaults !== true) {\r\n ps = ['precision', 'rounding', 'toExpNeg', 'toExpPos', 'maxE', 'minE', 'modulo', 'crypto'];\r\n for (i = 0; i < ps.length;) if (!obj.hasOwnProperty(p = ps[i++])) obj[p] = this[p];\r\n }\r\n }\r\n\r\n Decimal.config(obj);\r\n\r\n return Decimal;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` divided by `y`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n * y {number|string|Decimal}\r\n *\r\n */\r\n function div(x, y) {\r\n return new this(x).div(y);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the natural exponential of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} The power to which to raise the base of the natural log.\r\n *\r\n */\r\n function exp(x) {\r\n return new this(x).exp();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` round to an integer using `ROUND_FLOOR`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function floor(x) {\r\n return finalise(x = new this(x), x.e + 1, 3);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the square root of the sum of the squares of the arguments,\r\n * rounded to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * hypot(a, b, ...) = sqrt(a^2 + b^2 + ...)\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n */\r\n function hypot() {\r\n var i, n,\r\n t = new this(0);\r\n\r\n external = false;\r\n\r\n for (i = 0; i < arguments.length;) {\r\n n = new this(arguments[i++]);\r\n if (!n.d) {\r\n if (n.s) {\r\n external = true;\r\n return new this(1 / 0);\r\n }\r\n t = n;\r\n } else if (t.d) {\r\n t = t.plus(n.times(n));\r\n }\r\n }\r\n\r\n external = true;\r\n\r\n return t.sqrt();\r\n }\r\n\r\n\r\n /*\r\n * Return true if object is a Decimal instance (where Decimal is any Decimal constructor),\r\n * otherwise return false.\r\n *\r\n */\r\n function isDecimalInstance(obj) {\r\n return obj instanceof Decimal || obj && obj.toStringTag === tag || false;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the natural logarithm of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function ln(x) {\r\n return new this(x).ln();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the log of `x` to the base `y`, or to base 10 if no base\r\n * is specified, rounded to `precision` significant digits using rounding mode `rounding`.\r\n *\r\n * log[y](x)\r\n *\r\n * x {number|string|Decimal} The argument of the logarithm.\r\n * y {number|string|Decimal} The base of the logarithm.\r\n *\r\n */\r\n function log(x, y) {\r\n return new this(x).log(y);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the base 2 logarithm of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function log2(x) {\r\n return new this(x).log(2);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the base 10 logarithm of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function log10(x) {\r\n return new this(x).log(10);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the maximum of the arguments.\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n */\r\n function max() {\r\n return maxOrMin(this, arguments, 'lt');\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the minimum of the arguments.\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n */\r\n function min() {\r\n return maxOrMin(this, arguments, 'gt');\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` modulo `y`, rounded to `precision` significant digits\r\n * using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n * y {number|string|Decimal}\r\n *\r\n */\r\n function mod(x, y) {\r\n return new this(x).mod(y);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` multiplied by `y`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n * y {number|string|Decimal}\r\n *\r\n */\r\n function mul(x, y) {\r\n return new this(x).mul(y);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` raised to the power `y`, rounded to precision\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} The base.\r\n * y {number|string|Decimal} The exponent.\r\n *\r\n */\r\n function pow(x, y) {\r\n return new this(x).pow(y);\r\n }\r\n\r\n\r\n /*\r\n * Returns a new Decimal with a random value equal to or greater than 0 and less than 1, and with\r\n * `sd`, or `Decimal.precision` if `sd` is omitted, significant digits (or less if trailing zeros\r\n * are produced).\r\n *\r\n * [sd] {number} Significant digits. Integer, 0 to MAX_DIGITS inclusive.\r\n *\r\n */\r\n function random(sd) {\r\n var d, e, k, n,\r\n i = 0,\r\n r = new this(1),\r\n rd = [];\r\n\r\n if (sd === void 0) sd = this.precision;\r\n else checkInt32(sd, 1, MAX_DIGITS);\r\n\r\n k = Math.ceil(sd / LOG_BASE);\r\n\r\n if (!this.crypto) {\r\n for (; i < k;) rd[i++] = Math.random() * 1e7 | 0;\r\n\r\n // Browsers supporting crypto.getRandomValues.\r\n } else if (crypto.getRandomValues) {\r\n d = crypto.getRandomValues(new Uint32Array(k));\r\n\r\n for (; i < k;) {\r\n n = d[i];\r\n\r\n // 0 <= n < 4294967296\r\n // Probability n >= 4.29e9, is 4967296 / 4294967296 = 0.00116 (1 in 865).\r\n if (n >= 4.29e9) {\r\n d[i] = crypto.getRandomValues(new Uint32Array(1))[0];\r\n } else {\r\n\r\n // 0 <= n <= 4289999999\r\n // 0 <= (n % 1e7) <= 9999999\r\n rd[i++] = n % 1e7;\r\n }\r\n }\r\n\r\n // Node.js supporting crypto.randomBytes.\r\n } else if (crypto.randomBytes) {\r\n\r\n // buffer\r\n d = crypto.randomBytes(k *= 4);\r\n\r\n for (; i < k;) {\r\n\r\n // 0 <= n < 2147483648\r\n n = d[i] + (d[i + 1] << 8) + (d[i + 2] << 16) + ((d[i + 3] & 0x7f) << 24);\r\n\r\n // Probability n >= 2.14e9, is 7483648 / 2147483648 = 0.0035 (1 in 286).\r\n if (n >= 2.14e9) {\r\n crypto.randomBytes(4).copy(d, i);\r\n } else {\r\n\r\n // 0 <= n <= 2139999999\r\n // 0 <= (n % 1e7) <= 9999999\r\n rd.push(n % 1e7);\r\n i += 4;\r\n }\r\n }\r\n\r\n i = k / 4;\r\n } else {\r\n throw Error(cryptoUnavailable);\r\n }\r\n\r\n k = rd[--i];\r\n sd %= LOG_BASE;\r\n\r\n // Convert trailing digits to zeros according to sd.\r\n if (k && sd) {\r\n n = mathpow(10, LOG_BASE - sd);\r\n rd[i] = (k / n | 0) * n;\r\n }\r\n\r\n // Remove trailing words which are zero.\r\n for (; rd[i] === 0; i--) rd.pop();\r\n\r\n // Zero?\r\n if (i < 0) {\r\n e = 0;\r\n rd = [0];\r\n } else {\r\n e = -1;\r\n\r\n // Remove leading words which are zero and adjust exponent accordingly.\r\n for (; rd[0] === 0; e -= LOG_BASE) rd.shift();\r\n\r\n // Count the digits of the first word of rd to determine leading zeros.\r\n for (k = 1, n = rd[0]; n >= 10; n /= 10) k++;\r\n\r\n // Adjust the exponent for leading zeros of the first word of rd.\r\n if (k < LOG_BASE) e -= LOG_BASE - k;\r\n }\r\n\r\n r.e = e;\r\n r.d = rd;\r\n\r\n return r;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` rounded to an integer using rounding mode `rounding`.\r\n *\r\n * To emulate `Math.round`, set rounding to 7 (ROUND_HALF_CEIL).\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function round(x) {\r\n return finalise(x = new this(x), x.e + 1, this.rounding);\r\n }\r\n\r\n\r\n /*\r\n * Return\r\n * 1 if x > 0,\r\n * -1 if x < 0,\r\n * 0 if x is 0,\r\n * -0 if x is -0,\r\n * NaN otherwise\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function sign(x) {\r\n x = new this(x);\r\n return x.d ? (x.d[0] ? x.s : 0 * x.s) : x.s || NaN;\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the sine of `x`, rounded to `precision` significant digits\r\n * using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function sin(x) {\r\n return new this(x).sin();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the hyperbolic sine of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function sinh(x) {\r\n return new this(x).sinh();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the square root of `x`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function sqrt(x) {\r\n return new this(x).sqrt();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` minus `y`, rounded to `precision` significant digits\r\n * using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal}\r\n * y {number|string|Decimal}\r\n *\r\n */\r\n function sub(x, y) {\r\n return new this(x).sub(y);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the sum of the arguments, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * Only the result is rounded, not the intermediate calculations.\r\n *\r\n * arguments {number|string|Decimal}\r\n *\r\n */\r\n function sum() {\r\n var i = 0,\r\n args = arguments,\r\n x = new this(args[i]);\r\n\r\n external = false;\r\n for (; x.s && ++i < args.length;) x = x.plus(args[i]);\r\n external = true;\r\n\r\n return finalise(x, this.precision, this.rounding);\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the tangent of `x`, rounded to `precision` significant\r\n * digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function tan(x) {\r\n return new this(x).tan();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is the hyperbolic tangent of `x`, rounded to `precision`\r\n * significant digits using rounding mode `rounding`.\r\n *\r\n * x {number|string|Decimal} A value in radians.\r\n *\r\n */\r\n function tanh(x) {\r\n return new this(x).tanh();\r\n }\r\n\r\n\r\n /*\r\n * Return a new Decimal whose value is `x` truncated to an integer.\r\n *\r\n * x {number|string|Decimal}\r\n *\r\n */\r\n function trunc(x) {\r\n return finalise(x = new this(x), x.e + 1, 1);\r\n }\r\n\r\n\r\n // Create and configure initial Decimal constructor.\r\n Decimal = clone(DEFAULTS);\r\n Decimal.prototype.constructor = Decimal;\r\n Decimal['default'] = Decimal.Decimal = Decimal;\r\n\r\n // Create the internal constants from their string values.\r\n LN10 = new Decimal(LN10);\r\n PI = new Decimal(PI);\r\n\r\n\r\n // Export.\r\n\r\n\r\n // AMD.\r\n if (typeof define == 'function' && define.amd) {\r\n define(function () {\r\n return Decimal;\r\n });\r\n\r\n // Node and other environments that support module.exports.\r\n } else if (typeof module != 'undefined' && module.exports) {\r\n if (typeof Symbol == 'function' && typeof Symbol.iterator == 'symbol') {\r\n P[Symbol['for']('nodejs.util.inspect.custom')] = P.toString;\r\n P[Symbol.toStringTag] = 'Decimal';\r\n }\r\n\r\n module.exports = Decimal;\r\n\r\n // Browser.\r\n } else {\r\n if (!globalScope) {\r\n globalScope = typeof self != 'undefined' && self && self.self == self ? self : window;\r\n }\r\n\r\n noConflict = globalScope.Decimal;\r\n Decimal.noConflict = function () {\r\n globalScope.Decimal = noConflict;\r\n return Decimal;\r\n };\r\n\r\n globalScope.Decimal = Decimal;\r\n }\r\n})(this);\r\n","'use strict';\n\nvar keys = require('object-keys');\nvar hasSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';\n\nvar toStr = Object.prototype.toString;\nvar concat = Array.prototype.concat;\nvar origDefineProperty = Object.defineProperty;\n\nvar isFunction = function (fn) {\n\treturn typeof fn === 'function' && toStr.call(fn) === '[object Function]';\n};\n\nvar hasPropertyDescriptors = require('has-property-descriptors')();\n\nvar supportsDescriptors = origDefineProperty && hasPropertyDescriptors;\n\nvar defineProperty = function (object, name, value, predicate) {\n\tif (name in object && (!isFunction(predicate) || !predicate())) {\n\t\treturn;\n\t}\n\tif (supportsDescriptors) {\n\t\torigDefineProperty(object, name, {\n\t\t\tconfigurable: true,\n\t\t\tenumerable: false,\n\t\t\tvalue: value,\n\t\t\twritable: true\n\t\t});\n\t} else {\n\t\tobject[name] = value; // eslint-disable-line no-param-reassign\n\t}\n};\n\nvar defineProperties = function (object, map) {\n\tvar predicates = arguments.length > 2 ? arguments[2] : {};\n\tvar props = keys(map);\n\tif (hasSymbols) {\n\t\tprops = concat.call(props, Object.getOwnPropertySymbols(map));\n\t}\n\tfor (var i = 0; i < props.length; i += 1) {\n\t\tdefineProperty(object, props[i], map[props[i]], predicates[props[i]]);\n\t}\n};\n\ndefineProperties.supportsDescriptors = !!supportsDescriptors;\n\nmodule.exports = defineProperties;\n","'use strict';\n\nexports.utils = require('./des/utils');\nexports.Cipher = require('./des/cipher');\nexports.DES = require('./des/des');\nexports.CBC = require('./des/cbc');\nexports.EDE = require('./des/ede');\n","'use strict';\n\nvar assert = require('minimalistic-assert');\nvar inherits = require('inherits');\n\nvar proto = {};\n\nfunction CBCState(iv) {\n assert.equal(iv.length, 8, 'Invalid IV length');\n\n this.iv = new Array(8);\n for (var i = 0; i < this.iv.length; i++)\n this.iv[i] = iv[i];\n}\n\nfunction instantiate(Base) {\n function CBC(options) {\n Base.call(this, options);\n this._cbcInit();\n }\n inherits(CBC, Base);\n\n var keys = Object.keys(proto);\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n CBC.prototype[key] = proto[key];\n }\n\n CBC.create = function create(options) {\n return new CBC(options);\n };\n\n return CBC;\n}\n\nexports.instantiate = instantiate;\n\nproto._cbcInit = function _cbcInit() {\n var state = new CBCState(this.options.iv);\n this._cbcState = state;\n};\n\nproto._update = function _update(inp, inOff, out, outOff) {\n var state = this._cbcState;\n var superProto = this.constructor.super_.prototype;\n\n var iv = state.iv;\n if (this.type === 'encrypt') {\n for (var i = 0; i < this.blockSize; i++)\n iv[i] ^= inp[inOff + i];\n\n superProto._update.call(this, iv, 0, out, outOff);\n\n for (var i = 0; i < this.blockSize; i++)\n iv[i] = out[outOff + i];\n } else {\n superProto._update.call(this, inp, inOff, out, outOff);\n\n for (var i = 0; i < this.blockSize; i++)\n out[outOff + i] ^= iv[i];\n\n for (var i = 0; i < this.blockSize; i++)\n iv[i] = inp[inOff + i];\n }\n};\n","'use strict';\n\nvar assert = require('minimalistic-assert');\n\nfunction Cipher(options) {\n this.options = options;\n\n this.type = this.options.type;\n this.blockSize = 8;\n this._init();\n\n this.buffer = new Array(this.blockSize);\n this.bufferOff = 0;\n}\nmodule.exports = Cipher;\n\nCipher.prototype._init = function _init() {\n // Might be overrided\n};\n\nCipher.prototype.update = function update(data) {\n if (data.length === 0)\n return [];\n\n if (this.type === 'decrypt')\n return this._updateDecrypt(data);\n else\n return this._updateEncrypt(data);\n};\n\nCipher.prototype._buffer = function _buffer(data, off) {\n // Append data to buffer\n var min = Math.min(this.buffer.length - this.bufferOff, data.length - off);\n for (var i = 0; i < min; i++)\n this.buffer[this.bufferOff + i] = data[off + i];\n this.bufferOff += min;\n\n // Shift next\n return min;\n};\n\nCipher.prototype._flushBuffer = function _flushBuffer(out, off) {\n this._update(this.buffer, 0, out, off);\n this.bufferOff = 0;\n return this.blockSize;\n};\n\nCipher.prototype._updateEncrypt = function _updateEncrypt(data) {\n var inputOff = 0;\n var outputOff = 0;\n\n var count = ((this.bufferOff + data.length) / this.blockSize) | 0;\n var out = new Array(count * this.blockSize);\n\n if (this.bufferOff !== 0) {\n inputOff += this._buffer(data, inputOff);\n\n if (this.bufferOff === this.buffer.length)\n outputOff += this._flushBuffer(out, outputOff);\n }\n\n // Write blocks\n var max = data.length - ((data.length - inputOff) % this.blockSize);\n for (; inputOff < max; inputOff += this.blockSize) {\n this._update(data, inputOff, out, outputOff);\n outputOff += this.blockSize;\n }\n\n // Queue rest\n for (; inputOff < data.length; inputOff++, this.bufferOff++)\n this.buffer[this.bufferOff] = data[inputOff];\n\n return out;\n};\n\nCipher.prototype._updateDecrypt = function _updateDecrypt(data) {\n var inputOff = 0;\n var outputOff = 0;\n\n var count = Math.ceil((this.bufferOff + data.length) / this.blockSize) - 1;\n var out = new Array(count * this.blockSize);\n\n // TODO(indutny): optimize it, this is far from optimal\n for (; count > 0; count--) {\n inputOff += this._buffer(data, inputOff);\n outputOff += this._flushBuffer(out, outputOff);\n }\n\n // Buffer rest of the input\n inputOff += this._buffer(data, inputOff);\n\n return out;\n};\n\nCipher.prototype.final = function final(buffer) {\n var first;\n if (buffer)\n first = this.update(buffer);\n\n var last;\n if (this.type === 'encrypt')\n last = this._finalEncrypt();\n else\n last = this._finalDecrypt();\n\n if (first)\n return first.concat(last);\n else\n return last;\n};\n\nCipher.prototype._pad = function _pad(buffer, off) {\n if (off === 0)\n return false;\n\n while (off < buffer.length)\n buffer[off++] = 0;\n\n return true;\n};\n\nCipher.prototype._finalEncrypt = function _finalEncrypt() {\n if (!this._pad(this.buffer, this.bufferOff))\n return [];\n\n var out = new Array(this.blockSize);\n this._update(this.buffer, 0, out, 0);\n return out;\n};\n\nCipher.prototype._unpad = function _unpad(buffer) {\n return buffer;\n};\n\nCipher.prototype._finalDecrypt = function _finalDecrypt() {\n assert.equal(this.bufferOff, this.blockSize, 'Not enough data to decrypt');\n var out = new Array(this.blockSize);\n this._flushBuffer(out, 0);\n\n return this._unpad(out);\n};\n","'use strict';\n\nvar assert = require('minimalistic-assert');\nvar inherits = require('inherits');\n\nvar utils = require('./utils');\nvar Cipher = require('./cipher');\n\nfunction DESState() {\n this.tmp = new Array(2);\n this.keys = null;\n}\n\nfunction DES(options) {\n Cipher.call(this, options);\n\n var state = new DESState();\n this._desState = state;\n\n this.deriveKeys(state, options.key);\n}\ninherits(DES, Cipher);\nmodule.exports = DES;\n\nDES.create = function create(options) {\n return new DES(options);\n};\n\nvar shiftTable = [\n 1, 1, 2, 2, 2, 2, 2, 2,\n 1, 2, 2, 2, 2, 2, 2, 1\n];\n\nDES.prototype.deriveKeys = function deriveKeys(state, key) {\n state.keys = new Array(16 * 2);\n\n assert.equal(key.length, this.blockSize, 'Invalid key length');\n\n var kL = utils.readUInt32BE(key, 0);\n var kR = utils.readUInt32BE(key, 4);\n\n utils.pc1(kL, kR, state.tmp, 0);\n kL = state.tmp[0];\n kR = state.tmp[1];\n for (var i = 0; i < state.keys.length; i += 2) {\n var shift = shiftTable[i >>> 1];\n kL = utils.r28shl(kL, shift);\n kR = utils.r28shl(kR, shift);\n utils.pc2(kL, kR, state.keys, i);\n }\n};\n\nDES.prototype._update = function _update(inp, inOff, out, outOff) {\n var state = this._desState;\n\n var l = utils.readUInt32BE(inp, inOff);\n var r = utils.readUInt32BE(inp, inOff + 4);\n\n // Initial Permutation\n utils.ip(l, r, state.tmp, 0);\n l = state.tmp[0];\n r = state.tmp[1];\n\n if (this.type === 'encrypt')\n this._encrypt(state, l, r, state.tmp, 0);\n else\n this._decrypt(state, l, r, state.tmp, 0);\n\n l = state.tmp[0];\n r = state.tmp[1];\n\n utils.writeUInt32BE(out, l, outOff);\n utils.writeUInt32BE(out, r, outOff + 4);\n};\n\nDES.prototype._pad = function _pad(buffer, off) {\n var value = buffer.length - off;\n for (var i = off; i < buffer.length; i++)\n buffer[i] = value;\n\n return true;\n};\n\nDES.prototype._unpad = function _unpad(buffer) {\n var pad = buffer[buffer.length - 1];\n for (var i = buffer.length - pad; i < buffer.length; i++)\n assert.equal(buffer[i], pad);\n\n return buffer.slice(0, buffer.length - pad);\n};\n\nDES.prototype._encrypt = function _encrypt(state, lStart, rStart, out, off) {\n var l = lStart;\n var r = rStart;\n\n // Apply f() x16 times\n for (var i = 0; i < state.keys.length; i += 2) {\n var keyL = state.keys[i];\n var keyR = state.keys[i + 1];\n\n // f(r, k)\n utils.expand(r, state.tmp, 0);\n\n keyL ^= state.tmp[0];\n keyR ^= state.tmp[1];\n var s = utils.substitute(keyL, keyR);\n var f = utils.permute(s);\n\n var t = r;\n r = (l ^ f) >>> 0;\n l = t;\n }\n\n // Reverse Initial Permutation\n utils.rip(r, l, out, off);\n};\n\nDES.prototype._decrypt = function _decrypt(state, lStart, rStart, out, off) {\n var l = rStart;\n var r = lStart;\n\n // Apply f() x16 times\n for (var i = state.keys.length - 2; i >= 0; i -= 2) {\n var keyL = state.keys[i];\n var keyR = state.keys[i + 1];\n\n // f(r, k)\n utils.expand(l, state.tmp, 0);\n\n keyL ^= state.tmp[0];\n keyR ^= state.tmp[1];\n var s = utils.substitute(keyL, keyR);\n var f = utils.permute(s);\n\n var t = l;\n l = (r ^ f) >>> 0;\n r = t;\n }\n\n // Reverse Initial Permutation\n utils.rip(l, r, out, off);\n};\n","'use strict';\n\nvar assert = require('minimalistic-assert');\nvar inherits = require('inherits');\n\nvar Cipher = require('./cipher');\nvar DES = require('./des');\n\nfunction EDEState(type, key) {\n assert.equal(key.length, 24, 'Invalid key length');\n\n var k1 = key.slice(0, 8);\n var k2 = key.slice(8, 16);\n var k3 = key.slice(16, 24);\n\n if (type === 'encrypt') {\n this.ciphers = [\n DES.create({ type: 'encrypt', key: k1 }),\n DES.create({ type: 'decrypt', key: k2 }),\n DES.create({ type: 'encrypt', key: k3 })\n ];\n } else {\n this.ciphers = [\n DES.create({ type: 'decrypt', key: k3 }),\n DES.create({ type: 'encrypt', key: k2 }),\n DES.create({ type: 'decrypt', key: k1 })\n ];\n }\n}\n\nfunction EDE(options) {\n Cipher.call(this, options);\n\n var state = new EDEState(this.type, this.options.key);\n this._edeState = state;\n}\ninherits(EDE, Cipher);\n\nmodule.exports = EDE;\n\nEDE.create = function create(options) {\n return new EDE(options);\n};\n\nEDE.prototype._update = function _update(inp, inOff, out, outOff) {\n var state = this._edeState;\n\n state.ciphers[0]._update(inp, inOff, out, outOff);\n state.ciphers[1]._update(out, outOff, out, outOff);\n state.ciphers[2]._update(out, outOff, out, outOff);\n};\n\nEDE.prototype._pad = DES.prototype._pad;\nEDE.prototype._unpad = DES.prototype._unpad;\n","'use strict';\n\nexports.readUInt32BE = function readUInt32BE(bytes, off) {\n var res = (bytes[0 + off] << 24) |\n (bytes[1 + off] << 16) |\n (bytes[2 + off] << 8) |\n bytes[3 + off];\n return res >>> 0;\n};\n\nexports.writeUInt32BE = function writeUInt32BE(bytes, value, off) {\n bytes[0 + off] = value >>> 24;\n bytes[1 + off] = (value >>> 16) & 0xff;\n bytes[2 + off] = (value >>> 8) & 0xff;\n bytes[3 + off] = value & 0xff;\n};\n\nexports.ip = function ip(inL, inR, out, off) {\n var outL = 0;\n var outR = 0;\n\n for (var i = 6; i >= 0; i -= 2) {\n for (var j = 0; j <= 24; j += 8) {\n outL <<= 1;\n outL |= (inR >>> (j + i)) & 1;\n }\n for (var j = 0; j <= 24; j += 8) {\n outL <<= 1;\n outL |= (inL >>> (j + i)) & 1;\n }\n }\n\n for (var i = 6; i >= 0; i -= 2) {\n for (var j = 1; j <= 25; j += 8) {\n outR <<= 1;\n outR |= (inR >>> (j + i)) & 1;\n }\n for (var j = 1; j <= 25; j += 8) {\n outR <<= 1;\n outR |= (inL >>> (j + i)) & 1;\n }\n }\n\n out[off + 0] = outL >>> 0;\n out[off + 1] = outR >>> 0;\n};\n\nexports.rip = function rip(inL, inR, out, off) {\n var outL = 0;\n var outR = 0;\n\n for (var i = 0; i < 4; i++) {\n for (var j = 24; j >= 0; j -= 8) {\n outL <<= 1;\n outL |= (inR >>> (j + i)) & 1;\n outL <<= 1;\n outL |= (inL >>> (j + i)) & 1;\n }\n }\n for (var i = 4; i < 8; i++) {\n for (var j = 24; j >= 0; j -= 8) {\n outR <<= 1;\n outR |= (inR >>> (j + i)) & 1;\n outR <<= 1;\n outR |= (inL >>> (j + i)) & 1;\n }\n }\n\n out[off + 0] = outL >>> 0;\n out[off + 1] = outR >>> 0;\n};\n\nexports.pc1 = function pc1(inL, inR, out, off) {\n var outL = 0;\n var outR = 0;\n\n // 7, 15, 23, 31, 39, 47, 55, 63\n // 6, 14, 22, 30, 39, 47, 55, 63\n // 5, 13, 21, 29, 39, 47, 55, 63\n // 4, 12, 20, 28\n for (var i = 7; i >= 5; i--) {\n for (var j = 0; j <= 24; j += 8) {\n outL <<= 1;\n outL |= (inR >> (j + i)) & 1;\n }\n for (var j = 0; j <= 24; j += 8) {\n outL <<= 1;\n outL |= (inL >> (j + i)) & 1;\n }\n }\n for (var j = 0; j <= 24; j += 8) {\n outL <<= 1;\n outL |= (inR >> (j + i)) & 1;\n }\n\n // 1, 9, 17, 25, 33, 41, 49, 57\n // 2, 10, 18, 26, 34, 42, 50, 58\n // 3, 11, 19, 27, 35, 43, 51, 59\n // 36, 44, 52, 60\n for (var i = 1; i <= 3; i++) {\n for (var j = 0; j <= 24; j += 8) {\n outR <<= 1;\n outR |= (inR >> (j + i)) & 1;\n }\n for (var j = 0; j <= 24; j += 8) {\n outR <<= 1;\n outR |= (inL >> (j + i)) & 1;\n }\n }\n for (var j = 0; j <= 24; j += 8) {\n outR <<= 1;\n outR |= (inL >> (j + i)) & 1;\n }\n\n out[off + 0] = outL >>> 0;\n out[off + 1] = outR >>> 0;\n};\n\nexports.r28shl = function r28shl(num, shift) {\n return ((num << shift) & 0xfffffff) | (num >>> (28 - shift));\n};\n\nvar pc2table = [\n // inL => outL\n 14, 11, 17, 4, 27, 23, 25, 0,\n 13, 22, 7, 18, 5, 9, 16, 24,\n 2, 20, 12, 21, 1, 8, 15, 26,\n\n // inR => outR\n 15, 4, 25, 19, 9, 1, 26, 16,\n 5, 11, 23, 8, 12, 7, 17, 0,\n 22, 3, 10, 14, 6, 20, 27, 24\n];\n\nexports.pc2 = function pc2(inL, inR, out, off) {\n var outL = 0;\n var outR = 0;\n\n var len = pc2table.length >>> 1;\n for (var i = 0; i < len; i++) {\n outL <<= 1;\n outL |= (inL >>> pc2table[i]) & 0x1;\n }\n for (var i = len; i < pc2table.length; i++) {\n outR <<= 1;\n outR |= (inR >>> pc2table[i]) & 0x1;\n }\n\n out[off + 0] = outL >>> 0;\n out[off + 1] = outR >>> 0;\n};\n\nexports.expand = function expand(r, out, off) {\n var outL = 0;\n var outR = 0;\n\n outL = ((r & 1) << 5) | (r >>> 27);\n for (var i = 23; i >= 15; i -= 4) {\n outL <<= 6;\n outL |= (r >>> i) & 0x3f;\n }\n for (var i = 11; i >= 3; i -= 4) {\n outR |= (r >>> i) & 0x3f;\n outR <<= 6;\n }\n outR |= ((r & 0x1f) << 1) | (r >>> 31);\n\n out[off + 0] = outL >>> 0;\n out[off + 1] = outR >>> 0;\n};\n\nvar sTable = [\n 14, 0, 4, 15, 13, 7, 1, 4, 2, 14, 15, 2, 11, 13, 8, 1,\n 3, 10, 10, 6, 6, 12, 12, 11, 5, 9, 9, 5, 0, 3, 7, 8,\n 4, 15, 1, 12, 14, 8, 8, 2, 13, 4, 6, 9, 2, 1, 11, 7,\n 15, 5, 12, 11, 9, 3, 7, 14, 3, 10, 10, 0, 5, 6, 0, 13,\n\n 15, 3, 1, 13, 8, 4, 14, 7, 6, 15, 11, 2, 3, 8, 4, 14,\n 9, 12, 7, 0, 2, 1, 13, 10, 12, 6, 0, 9, 5, 11, 10, 5,\n 0, 13, 14, 8, 7, 10, 11, 1, 10, 3, 4, 15, 13, 4, 1, 2,\n 5, 11, 8, 6, 12, 7, 6, 12, 9, 0, 3, 5, 2, 14, 15, 9,\n\n 10, 13, 0, 7, 9, 0, 14, 9, 6, 3, 3, 4, 15, 6, 5, 10,\n 1, 2, 13, 8, 12, 5, 7, 14, 11, 12, 4, 11, 2, 15, 8, 1,\n 13, 1, 6, 10, 4, 13, 9, 0, 8, 6, 15, 9, 3, 8, 0, 7,\n 11, 4, 1, 15, 2, 14, 12, 3, 5, 11, 10, 5, 14, 2, 7, 12,\n\n 7, 13, 13, 8, 14, 11, 3, 5, 0, 6, 6, 15, 9, 0, 10, 3,\n 1, 4, 2, 7, 8, 2, 5, 12, 11, 1, 12, 10, 4, 14, 15, 9,\n 10, 3, 6, 15, 9, 0, 0, 6, 12, 10, 11, 1, 7, 13, 13, 8,\n 15, 9, 1, 4, 3, 5, 14, 11, 5, 12, 2, 7, 8, 2, 4, 14,\n\n 2, 14, 12, 11, 4, 2, 1, 12, 7, 4, 10, 7, 11, 13, 6, 1,\n 8, 5, 5, 0, 3, 15, 15, 10, 13, 3, 0, 9, 14, 8, 9, 6,\n 4, 11, 2, 8, 1, 12, 11, 7, 10, 1, 13, 14, 7, 2, 8, 13,\n 15, 6, 9, 15, 12, 0, 5, 9, 6, 10, 3, 4, 0, 5, 14, 3,\n\n 12, 10, 1, 15, 10, 4, 15, 2, 9, 7, 2, 12, 6, 9, 8, 5,\n 0, 6, 13, 1, 3, 13, 4, 14, 14, 0, 7, 11, 5, 3, 11, 8,\n 9, 4, 14, 3, 15, 2, 5, 12, 2, 9, 8, 5, 12, 15, 3, 10,\n 7, 11, 0, 14, 4, 1, 10, 7, 1, 6, 13, 0, 11, 8, 6, 13,\n\n 4, 13, 11, 0, 2, 11, 14, 7, 15, 4, 0, 9, 8, 1, 13, 10,\n 3, 14, 12, 3, 9, 5, 7, 12, 5, 2, 10, 15, 6, 8, 1, 6,\n 1, 6, 4, 11, 11, 13, 13, 8, 12, 1, 3, 4, 7, 10, 14, 7,\n 10, 9, 15, 5, 6, 0, 8, 15, 0, 14, 5, 2, 9, 3, 2, 12,\n\n 13, 1, 2, 15, 8, 13, 4, 8, 6, 10, 15, 3, 11, 7, 1, 4,\n 10, 12, 9, 5, 3, 6, 14, 11, 5, 0, 0, 14, 12, 9, 7, 2,\n 7, 2, 11, 1, 4, 14, 1, 7, 9, 4, 12, 10, 14, 8, 2, 13,\n 0, 15, 6, 12, 10, 9, 13, 0, 15, 3, 3, 5, 5, 6, 8, 11\n];\n\nexports.substitute = function substitute(inL, inR) {\n var out = 0;\n for (var i = 0; i < 4; i++) {\n var b = (inL >>> (18 - i * 6)) & 0x3f;\n var sb = sTable[i * 0x40 + b];\n\n out <<= 4;\n out |= sb;\n }\n for (var i = 0; i < 4; i++) {\n var b = (inR >>> (18 - i * 6)) & 0x3f;\n var sb = sTable[4 * 0x40 + i * 0x40 + b];\n\n out <<= 4;\n out |= sb;\n }\n return out >>> 0;\n};\n\nvar permuteTable = [\n 16, 25, 12, 11, 3, 20, 4, 15, 31, 17, 9, 6, 27, 14, 1, 22,\n 30, 24, 8, 18, 0, 5, 29, 23, 13, 19, 2, 26, 10, 21, 28, 7\n];\n\nexports.permute = function permute(num) {\n var out = 0;\n for (var i = 0; i < permuteTable.length; i++) {\n out <<= 1;\n out |= (num >>> permuteTable[i]) & 0x1;\n }\n return out >>> 0;\n};\n\nexports.padSplit = function padSplit(num, size, group) {\n var str = num.toString(2);\n while (str.length < size)\n str = '0' + str;\n\n var out = [];\n for (var i = 0; i < size; i += group)\n out.push(str.slice(i, i + group));\n return out.join(' ');\n};\n","var generatePrime = require('./lib/generatePrime')\nvar primes = require('./lib/primes.json')\n\nvar DH = require('./lib/dh')\n\nfunction getDiffieHellman (mod) {\n var prime = new Buffer(primes[mod].prime, 'hex')\n var gen = new Buffer(primes[mod].gen, 'hex')\n\n return new DH(prime, gen)\n}\n\nvar ENCODINGS = {\n 'binary': true, 'hex': true, 'base64': true\n}\n\nfunction createDiffieHellman (prime, enc, generator, genc) {\n if (Buffer.isBuffer(enc) || ENCODINGS[enc] === undefined) {\n return createDiffieHellman(prime, 'binary', enc, generator)\n }\n\n enc = enc || 'binary'\n genc = genc || 'binary'\n generator = generator || new Buffer([2])\n\n if (!Buffer.isBuffer(generator)) {\n generator = new Buffer(generator, genc)\n }\n\n if (typeof prime === 'number') {\n return new DH(generatePrime(prime, generator), generator, true)\n }\n\n if (!Buffer.isBuffer(prime)) {\n prime = new Buffer(prime, enc)\n }\n\n return new DH(prime, generator, true)\n}\n\nexports.DiffieHellmanGroup = exports.createDiffieHellmanGroup = exports.getDiffieHellman = getDiffieHellman\nexports.createDiffieHellman = exports.DiffieHellman = createDiffieHellman\n","var BN = require('bn.js');\nvar MillerRabin = require('miller-rabin');\nvar millerRabin = new MillerRabin();\nvar TWENTYFOUR = new BN(24);\nvar ELEVEN = new BN(11);\nvar TEN = new BN(10);\nvar THREE = new BN(3);\nvar SEVEN = new BN(7);\nvar primes = require('./generatePrime');\nvar randomBytes = require('randombytes');\nmodule.exports = DH;\n\nfunction setPublicKey(pub, enc) {\n enc = enc || 'utf8';\n if (!Buffer.isBuffer(pub)) {\n pub = new Buffer(pub, enc);\n }\n this._pub = new BN(pub);\n return this;\n}\n\nfunction setPrivateKey(priv, enc) {\n enc = enc || 'utf8';\n if (!Buffer.isBuffer(priv)) {\n priv = new Buffer(priv, enc);\n }\n this._priv = new BN(priv);\n return this;\n}\n\nvar primeCache = {};\nfunction checkPrime(prime, generator) {\n var gen = generator.toString('hex');\n var hex = [gen, prime.toString(16)].join('_');\n if (hex in primeCache) {\n return primeCache[hex];\n }\n var error = 0;\n\n if (prime.isEven() ||\n !primes.simpleSieve ||\n !primes.fermatTest(prime) ||\n !millerRabin.test(prime)) {\n //not a prime so +1\n error += 1;\n\n if (gen === '02' || gen === '05') {\n // we'd be able to check the generator\n // it would fail so +8\n error += 8;\n } else {\n //we wouldn't be able to test the generator\n // so +4\n error += 4;\n }\n primeCache[hex] = error;\n return error;\n }\n if (!millerRabin.test(prime.shrn(1))) {\n //not a safe prime\n error += 2;\n }\n var rem;\n switch (gen) {\n case '02':\n if (prime.mod(TWENTYFOUR).cmp(ELEVEN)) {\n // unsuidable generator\n error += 8;\n }\n break;\n case '05':\n rem = prime.mod(TEN);\n if (rem.cmp(THREE) && rem.cmp(SEVEN)) {\n // prime mod 10 needs to equal 3 or 7\n error += 8;\n }\n break;\n default:\n error += 4;\n }\n primeCache[hex] = error;\n return error;\n}\n\nfunction DH(prime, generator, malleable) {\n this.setGenerator(generator);\n this.__prime = new BN(prime);\n this._prime = BN.mont(this.__prime);\n this._primeLen = prime.length;\n this._pub = undefined;\n this._priv = undefined;\n this._primeCode = undefined;\n if (malleable) {\n this.setPublicKey = setPublicKey;\n this.setPrivateKey = setPrivateKey;\n } else {\n this._primeCode = 8;\n }\n}\nObject.defineProperty(DH.prototype, 'verifyError', {\n enumerable: true,\n get: function () {\n if (typeof this._primeCode !== 'number') {\n this._primeCode = checkPrime(this.__prime, this.__gen);\n }\n return this._primeCode;\n }\n});\nDH.prototype.generateKeys = function () {\n if (!this._priv) {\n this._priv = new BN(randomBytes(this._primeLen));\n }\n this._pub = this._gen.toRed(this._prime).redPow(this._priv).fromRed();\n return this.getPublicKey();\n};\n\nDH.prototype.computeSecret = function (other) {\n other = new BN(other);\n other = other.toRed(this._prime);\n var secret = other.redPow(this._priv).fromRed();\n var out = new Buffer(secret.toArray());\n var prime = this.getPrime();\n if (out.length < prime.length) {\n var front = new Buffer(prime.length - out.length);\n front.fill(0);\n out = Buffer.concat([front, out]);\n }\n return out;\n};\n\nDH.prototype.getPublicKey = function getPublicKey(enc) {\n return formatReturnValue(this._pub, enc);\n};\n\nDH.prototype.getPrivateKey = function getPrivateKey(enc) {\n return formatReturnValue(this._priv, enc);\n};\n\nDH.prototype.getPrime = function (enc) {\n return formatReturnValue(this.__prime, enc);\n};\n\nDH.prototype.getGenerator = function (enc) {\n return formatReturnValue(this._gen, enc);\n};\n\nDH.prototype.setGenerator = function (gen, enc) {\n enc = enc || 'utf8';\n if (!Buffer.isBuffer(gen)) {\n gen = new Buffer(gen, enc);\n }\n this.__gen = gen;\n this._gen = new BN(gen);\n return this;\n};\n\nfunction formatReturnValue(bn, enc) {\n var buf = new Buffer(bn.toArray());\n if (!enc) {\n return buf;\n } else {\n return buf.toString(enc);\n }\n}\n","var randomBytes = require('randombytes');\nmodule.exports = findPrime;\nfindPrime.simpleSieve = simpleSieve;\nfindPrime.fermatTest = fermatTest;\nvar BN = require('bn.js');\nvar TWENTYFOUR = new BN(24);\nvar MillerRabin = require('miller-rabin');\nvar millerRabin = new MillerRabin();\nvar ONE = new BN(1);\nvar TWO = new BN(2);\nvar FIVE = new BN(5);\nvar SIXTEEN = new BN(16);\nvar EIGHT = new BN(8);\nvar TEN = new BN(10);\nvar THREE = new BN(3);\nvar SEVEN = new BN(7);\nvar ELEVEN = new BN(11);\nvar FOUR = new BN(4);\nvar TWELVE = new BN(12);\nvar primes = null;\n\nfunction _getPrimes() {\n if (primes !== null)\n return primes;\n\n var limit = 0x100000;\n var res = [];\n res[0] = 2;\n for (var i = 1, k = 3; k < limit; k += 2) {\n var sqrt = Math.ceil(Math.sqrt(k));\n for (var j = 0; j < i && res[j] <= sqrt; j++)\n if (k % res[j] === 0)\n break;\n\n if (i !== j && res[j] <= sqrt)\n continue;\n\n res[i++] = k;\n }\n primes = res;\n return res;\n}\n\nfunction simpleSieve(p) {\n var primes = _getPrimes();\n\n for (var i = 0; i < primes.length; i++)\n if (p.modn(primes[i]) === 0) {\n if (p.cmpn(primes[i]) === 0) {\n return true;\n } else {\n return false;\n }\n }\n\n return true;\n}\n\nfunction fermatTest(p) {\n var red = BN.mont(p);\n return TWO.toRed(red).redPow(p.subn(1)).fromRed().cmpn(1) === 0;\n}\n\nfunction findPrime(bits, gen) {\n if (bits < 16) {\n // this is what openssl does\n if (gen === 2 || gen === 5) {\n return new BN([0x8c, 0x7b]);\n } else {\n return new BN([0x8c, 0x27]);\n }\n }\n gen = new BN(gen);\n\n var num, n2;\n\n while (true) {\n num = new BN(randomBytes(Math.ceil(bits / 8)));\n while (num.bitLength() > bits) {\n num.ishrn(1);\n }\n if (num.isEven()) {\n num.iadd(ONE);\n }\n if (!num.testn(1)) {\n num.iadd(TWO);\n }\n if (!gen.cmp(TWO)) {\n while (num.mod(TWENTYFOUR).cmp(ELEVEN)) {\n num.iadd(FOUR);\n }\n } else if (!gen.cmp(FIVE)) {\n while (num.mod(TEN).cmp(THREE)) {\n num.iadd(FOUR);\n }\n }\n n2 = num.shrn(1);\n if (simpleSieve(n2) && simpleSieve(num) &&\n fermatTest(n2) && fermatTest(num) &&\n millerRabin.test(n2) && millerRabin.test(num)) {\n return num;\n }\n }\n\n}\n","(function (module, exports) {\n 'use strict';\n\n // Utils\n function assert (val, msg) {\n if (!val) throw new Error(msg || 'Assertion failed');\n }\n\n // Could use `inherits` module, but don't want to move from single file\n // architecture yet.\n function inherits (ctor, superCtor) {\n ctor.super_ = superCtor;\n var TempCtor = function () {};\n TempCtor.prototype = superCtor.prototype;\n ctor.prototype = new TempCtor();\n ctor.prototype.constructor = ctor;\n }\n\n // BN\n\n function BN (number, base, endian) {\n if (BN.isBN(number)) {\n return number;\n }\n\n this.negative = 0;\n this.words = null;\n this.length = 0;\n\n // Reduction context\n this.red = null;\n\n if (number !== null) {\n if (base === 'le' || base === 'be') {\n endian = base;\n base = 10;\n }\n\n this._init(number || 0, base || 10, endian || 'be');\n }\n }\n if (typeof module === 'object') {\n module.exports = BN;\n } else {\n exports.BN = BN;\n }\n\n BN.BN = BN;\n BN.wordSize = 26;\n\n var Buffer;\n try {\n if (typeof window !== 'undefined' && typeof window.Buffer !== 'undefined') {\n Buffer = window.Buffer;\n } else {\n Buffer = require('buffer').Buffer;\n }\n } catch (e) {\n }\n\n BN.isBN = function isBN (num) {\n if (num instanceof BN) {\n return true;\n }\n\n return num !== null && typeof num === 'object' &&\n num.constructor.wordSize === BN.wordSize && Array.isArray(num.words);\n };\n\n BN.max = function max (left, right) {\n if (left.cmp(right) > 0) return left;\n return right;\n };\n\n BN.min = function min (left, right) {\n if (left.cmp(right) < 0) return left;\n return right;\n };\n\n BN.prototype._init = function init (number, base, endian) {\n if (typeof number === 'number') {\n return this._initNumber(number, base, endian);\n }\n\n if (typeof number === 'object') {\n return this._initArray(number, base, endian);\n }\n\n if (base === 'hex') {\n base = 16;\n }\n assert(base === (base | 0) && base >= 2 && base <= 36);\n\n number = number.toString().replace(/\\s+/g, '');\n var start = 0;\n if (number[0] === '-') {\n start++;\n this.negative = 1;\n }\n\n if (start < number.length) {\n if (base === 16) {\n this._parseHex(number, start, endian);\n } else {\n this._parseBase(number, base, start);\n if (endian === 'le') {\n this._initArray(this.toArray(), base, endian);\n }\n }\n }\n };\n\n BN.prototype._initNumber = function _initNumber (number, base, endian) {\n if (number < 0) {\n this.negative = 1;\n number = -number;\n }\n if (number < 0x4000000) {\n this.words = [ number & 0x3ffffff ];\n this.length = 1;\n } else if (number < 0x10000000000000) {\n this.words = [\n number & 0x3ffffff,\n (number / 0x4000000) & 0x3ffffff\n ];\n this.length = 2;\n } else {\n assert(number < 0x20000000000000); // 2 ^ 53 (unsafe)\n this.words = [\n number & 0x3ffffff,\n (number / 0x4000000) & 0x3ffffff,\n 1\n ];\n this.length = 3;\n }\n\n if (endian !== 'le') return;\n\n // Reverse the bytes\n this._initArray(this.toArray(), base, endian);\n };\n\n BN.prototype._initArray = function _initArray (number, base, endian) {\n // Perhaps a Uint8Array\n assert(typeof number.length === 'number');\n if (number.length <= 0) {\n this.words = [ 0 ];\n this.length = 1;\n return this;\n }\n\n this.length = Math.ceil(number.length / 3);\n this.words = new Array(this.length);\n for (var i = 0; i < this.length; i++) {\n this.words[i] = 0;\n }\n\n var j, w;\n var off = 0;\n if (endian === 'be') {\n for (i = number.length - 1, j = 0; i >= 0; i -= 3) {\n w = number[i] | (number[i - 1] << 8) | (number[i - 2] << 16);\n this.words[j] |= (w << off) & 0x3ffffff;\n this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;\n off += 24;\n if (off >= 26) {\n off -= 26;\n j++;\n }\n }\n } else if (endian === 'le') {\n for (i = 0, j = 0; i < number.length; i += 3) {\n w = number[i] | (number[i + 1] << 8) | (number[i + 2] << 16);\n this.words[j] |= (w << off) & 0x3ffffff;\n this.words[j + 1] = (w >>> (26 - off)) & 0x3ffffff;\n off += 24;\n if (off >= 26) {\n off -= 26;\n j++;\n }\n }\n }\n return this.strip();\n };\n\n function parseHex4Bits (string, index) {\n var c = string.charCodeAt(index);\n // 'A' - 'F'\n if (c >= 65 && c <= 70) {\n return c - 55;\n // 'a' - 'f'\n } else if (c >= 97 && c <= 102) {\n return c - 87;\n // '0' - '9'\n } else {\n return (c - 48) & 0xf;\n }\n }\n\n function parseHexByte (string, lowerBound, index) {\n var r = parseHex4Bits(string, index);\n if (index - 1 >= lowerBound) {\n r |= parseHex4Bits(string, index - 1) << 4;\n }\n return r;\n }\n\n BN.prototype._parseHex = function _parseHex (number, start, endian) {\n // Create possibly bigger array to ensure that it fits the number\n this.length = Math.ceil((number.length - start) / 6);\n this.words = new Array(this.length);\n for (var i = 0; i < this.length; i++) {\n this.words[i] = 0;\n }\n\n // 24-bits chunks\n var off = 0;\n var j = 0;\n\n var w;\n if (endian === 'be') {\n for (i = number.length - 1; i >= start; i -= 2) {\n w = parseHexByte(number, start, i) << off;\n this.words[j] |= w & 0x3ffffff;\n if (off >= 18) {\n off -= 18;\n j += 1;\n this.words[j] |= w >>> 26;\n } else {\n off += 8;\n }\n }\n } else {\n var parseLength = number.length - start;\n for (i = parseLength % 2 === 0 ? start + 1 : start; i < number.length; i += 2) {\n w = parseHexByte(number, start, i) << off;\n this.words[j] |= w & 0x3ffffff;\n if (off >= 18) {\n off -= 18;\n j += 1;\n this.words[j] |= w >>> 26;\n } else {\n off += 8;\n }\n }\n }\n\n this.strip();\n };\n\n function parseBase (str, start, end, mul) {\n var r = 0;\n var len = Math.min(str.length, end);\n for (var i = start; i < len; i++) {\n var c = str.charCodeAt(i) - 48;\n\n r *= mul;\n\n // 'a'\n if (c >= 49) {\n r += c - 49 + 0xa;\n\n // 'A'\n } else if (c >= 17) {\n r += c - 17 + 0xa;\n\n // '0' - '9'\n } else {\n r += c;\n }\n }\n return r;\n }\n\n BN.prototype._parseBase = function _parseBase (number, base, start) {\n // Initialize as zero\n this.words = [ 0 ];\n this.length = 1;\n\n // Find length of limb in base\n for (var limbLen = 0, limbPow = 1; limbPow <= 0x3ffffff; limbPow *= base) {\n limbLen++;\n }\n limbLen--;\n limbPow = (limbPow / base) | 0;\n\n var total = number.length - start;\n var mod = total % limbLen;\n var end = Math.min(total, total - mod) + start;\n\n var word = 0;\n for (var i = start; i < end; i += limbLen) {\n word = parseBase(number, i, i + limbLen, base);\n\n this.imuln(limbPow);\n if (this.words[0] + word < 0x4000000) {\n this.words[0] += word;\n } else {\n this._iaddn(word);\n }\n }\n\n if (mod !== 0) {\n var pow = 1;\n word = parseBase(number, i, number.length, base);\n\n for (i = 0; i < mod; i++) {\n pow *= base;\n }\n\n this.imuln(pow);\n if (this.words[0] + word < 0x4000000) {\n this.words[0] += word;\n } else {\n this._iaddn(word);\n }\n }\n\n this.strip();\n };\n\n BN.prototype.copy = function copy (dest) {\n dest.words = new Array(this.length);\n for (var i = 0; i < this.length; i++) {\n dest.words[i] = this.words[i];\n }\n dest.length = this.length;\n dest.negative = this.negative;\n dest.red = this.red;\n };\n\n BN.prototype.clone = function clone () {\n var r = new BN(null);\n this.copy(r);\n return r;\n };\n\n BN.prototype._expand = function _expand (size) {\n while (this.length < size) {\n this.words[this.length++] = 0;\n }\n return this;\n };\n\n // Remove leading `0` from `this`\n BN.prototype.strip = function strip () {\n while (this.length > 1 && this.words[this.length - 1] === 0) {\n this.length--;\n }\n return this._normSign();\n };\n\n BN.prototype._normSign = function _normSign () {\n // -0 = 0\n if (this.length === 1 && this.words[0] === 0) {\n this.negative = 0;\n }\n return this;\n };\n\n BN.prototype.inspect = function inspect () {\n return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';\n };\n\n /*\n\n var zeros = [];\n var groupSizes = [];\n var groupBases = [];\n\n var s = '';\n var i = -1;\n while (++i < BN.wordSize) {\n zeros[i] = s;\n s += '0';\n }\n groupSizes[0] = 0;\n groupSizes[1] = 0;\n groupBases[0] = 0;\n groupBases[1] = 0;\n var base = 2 - 1;\n while (++base < 36 + 1) {\n var groupSize = 0;\n var groupBase = 1;\n while (groupBase < (1 << BN.wordSize) / base) {\n groupBase *= base;\n groupSize += 1;\n }\n groupSizes[base] = groupSize;\n groupBases[base] = groupBase;\n }\n\n */\n\n var zeros = [\n '',\n '0',\n '00',\n '000',\n '0000',\n '00000',\n '000000',\n '0000000',\n '00000000',\n '000000000',\n '0000000000',\n '00000000000',\n '000000000000',\n '0000000000000',\n '00000000000000',\n '000000000000000',\n '0000000000000000',\n '00000000000000000',\n '000000000000000000',\n '0000000000000000000',\n '00000000000000000000',\n '000000000000000000000',\n '0000000000000000000000',\n '00000000000000000000000',\n '000000000000000000000000',\n '0000000000000000000000000'\n ];\n\n var groupSizes = [\n 0, 0,\n 25, 16, 12, 11, 10, 9, 8,\n 8, 7, 7, 7, 7, 6, 6,\n 6, 6, 6, 6, 6, 5, 5,\n 5, 5, 5, 5, 5, 5, 5,\n 5, 5, 5, 5, 5, 5, 5\n ];\n\n var groupBases = [\n 0, 0,\n 33554432, 43046721, 16777216, 48828125, 60466176, 40353607, 16777216,\n 43046721, 10000000, 19487171, 35831808, 62748517, 7529536, 11390625,\n 16777216, 24137569, 34012224, 47045881, 64000000, 4084101, 5153632,\n 6436343, 7962624, 9765625, 11881376, 14348907, 17210368, 20511149,\n 24300000, 28629151, 33554432, 39135393, 45435424, 52521875, 60466176\n ];\n\n BN.prototype.toString = function toString (base, padding) {\n base = base || 10;\n padding = padding | 0 || 1;\n\n var out;\n if (base === 16 || base === 'hex') {\n out = '';\n var off = 0;\n var carry = 0;\n for (var i = 0; i < this.length; i++) {\n var w = this.words[i];\n var word = (((w << off) | carry) & 0xffffff).toString(16);\n carry = (w >>> (24 - off)) & 0xffffff;\n if (carry !== 0 || i !== this.length - 1) {\n out = zeros[6 - word.length] + word + out;\n } else {\n out = word + out;\n }\n off += 2;\n if (off >= 26) {\n off -= 26;\n i--;\n }\n }\n if (carry !== 0) {\n out = carry.toString(16) + out;\n }\n while (out.length % padding !== 0) {\n out = '0' + out;\n }\n if (this.negative !== 0) {\n out = '-' + out;\n }\n return out;\n }\n\n if (base === (base | 0) && base >= 2 && base <= 36) {\n // var groupSize = Math.floor(BN.wordSize * Math.LN2 / Math.log(base));\n var groupSize = groupSizes[base];\n // var groupBase = Math.pow(base, groupSize);\n var groupBase = groupBases[base];\n out = '';\n var c = this.clone();\n c.negative = 0;\n while (!c.isZero()) {\n var r = c.modn(groupBase).toString(base);\n c = c.idivn(groupBase);\n\n if (!c.isZero()) {\n out = zeros[groupSize - r.length] + r + out;\n } else {\n out = r + out;\n }\n }\n if (this.isZero()) {\n out = '0' + out;\n }\n while (out.length % padding !== 0) {\n out = '0' + out;\n }\n if (this.negative !== 0) {\n out = '-' + out;\n }\n return out;\n }\n\n assert(false, 'Base should be between 2 and 36');\n };\n\n BN.prototype.toNumber = function toNumber () {\n var ret = this.words[0];\n if (this.length === 2) {\n ret += this.words[1] * 0x4000000;\n } else if (this.length === 3 && this.words[2] === 0x01) {\n // NOTE: at this stage it is known that the top bit is set\n ret += 0x10000000000000 + (this.words[1] * 0x4000000);\n } else if (this.length > 2) {\n assert(false, 'Number can only safely store up to 53 bits');\n }\n return (this.negative !== 0) ? -ret : ret;\n };\n\n BN.prototype.toJSON = function toJSON () {\n return this.toString(16);\n };\n\n BN.prototype.toBuffer = function toBuffer (endian, length) {\n assert(typeof Buffer !== 'undefined');\n return this.toArrayLike(Buffer, endian, length);\n };\n\n BN.prototype.toArray = function toArray (endian, length) {\n return this.toArrayLike(Array, endian, length);\n };\n\n BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {\n var byteLength = this.byteLength();\n var reqLength = length || Math.max(1, byteLength);\n assert(byteLength <= reqLength, 'byte array longer than desired length');\n assert(reqLength > 0, 'Requested array length <= 0');\n\n this.strip();\n var littleEndian = endian === 'le';\n var res = new ArrayType(reqLength);\n\n var b, i;\n var q = this.clone();\n if (!littleEndian) {\n // Assume big-endian\n for (i = 0; i < reqLength - byteLength; i++) {\n res[i] = 0;\n }\n\n for (i = 0; !q.isZero(); i++) {\n b = q.andln(0xff);\n q.iushrn(8);\n\n res[reqLength - i - 1] = b;\n }\n } else {\n for (i = 0; !q.isZero(); i++) {\n b = q.andln(0xff);\n q.iushrn(8);\n\n res[i] = b;\n }\n\n for (; i < reqLength; i++) {\n res[i] = 0;\n }\n }\n\n return res;\n };\n\n if (Math.clz32) {\n BN.prototype._countBits = function _countBits (w) {\n return 32 - Math.clz32(w);\n };\n } else {\n BN.prototype._countBits = function _countBits (w) {\n var t = w;\n var r = 0;\n if (t >= 0x1000) {\n r += 13;\n t >>>= 13;\n }\n if (t >= 0x40) {\n r += 7;\n t >>>= 7;\n }\n if (t >= 0x8) {\n r += 4;\n t >>>= 4;\n }\n if (t >= 0x02) {\n r += 2;\n t >>>= 2;\n }\n return r + t;\n };\n }\n\n BN.prototype._zeroBits = function _zeroBits (w) {\n // Short-cut\n if (w === 0) return 26;\n\n var t = w;\n var r = 0;\n if ((t & 0x1fff) === 0) {\n r += 13;\n t >>>= 13;\n }\n if ((t & 0x7f) === 0) {\n r += 7;\n t >>>= 7;\n }\n if ((t & 0xf) === 0) {\n r += 4;\n t >>>= 4;\n }\n if ((t & 0x3) === 0) {\n r += 2;\n t >>>= 2;\n }\n if ((t & 0x1) === 0) {\n r++;\n }\n return r;\n };\n\n // Return number of used bits in a BN\n BN.prototype.bitLength = function bitLength () {\n var w = this.words[this.length - 1];\n var hi = this._countBits(w);\n return (this.length - 1) * 26 + hi;\n };\n\n function toBitArray (num) {\n var w = new Array(num.bitLength());\n\n for (var bit = 0; bit < w.length; bit++) {\n var off = (bit / 26) | 0;\n var wbit = bit % 26;\n\n w[bit] = (num.words[off] & (1 << wbit)) >>> wbit;\n }\n\n return w;\n }\n\n // Number of trailing zero bits\n BN.prototype.zeroBits = function zeroBits () {\n if (this.isZero()) return 0;\n\n var r = 0;\n for (var i = 0; i < this.length; i++) {\n var b = this._zeroBits(this.words[i]);\n r += b;\n if (b !== 26) break;\n }\n return r;\n };\n\n BN.prototype.byteLength = function byteLength () {\n return Math.ceil(this.bitLength() / 8);\n };\n\n BN.prototype.toTwos = function toTwos (width) {\n if (this.negative !== 0) {\n return this.abs().inotn(width).iaddn(1);\n }\n return this.clone();\n };\n\n BN.prototype.fromTwos = function fromTwos (width) {\n if (this.testn(width - 1)) {\n return this.notn(width).iaddn(1).ineg();\n }\n return this.clone();\n };\n\n BN.prototype.isNeg = function isNeg () {\n return this.negative !== 0;\n };\n\n // Return negative clone of `this`\n BN.prototype.neg = function neg () {\n return this.clone().ineg();\n };\n\n BN.prototype.ineg = function ineg () {\n if (!this.isZero()) {\n this.negative ^= 1;\n }\n\n return this;\n };\n\n // Or `num` with `this` in-place\n BN.prototype.iuor = function iuor (num) {\n while (this.length < num.length) {\n this.words[this.length++] = 0;\n }\n\n for (var i = 0; i < num.length; i++) {\n this.words[i] = this.words[i] | num.words[i];\n }\n\n return this.strip();\n };\n\n BN.prototype.ior = function ior (num) {\n assert((this.negative | num.negative) === 0);\n return this.iuor(num);\n };\n\n // Or `num` with `this`\n BN.prototype.or = function or (num) {\n if (this.length > num.length) return this.clone().ior(num);\n return num.clone().ior(this);\n };\n\n BN.prototype.uor = function uor (num) {\n if (this.length > num.length) return this.clone().iuor(num);\n return num.clone().iuor(this);\n };\n\n // And `num` with `this` in-place\n BN.prototype.iuand = function iuand (num) {\n // b = min-length(num, this)\n var b;\n if (this.length > num.length) {\n b = num;\n } else {\n b = this;\n }\n\n for (var i = 0; i < b.length; i++) {\n this.words[i] = this.words[i] & num.words[i];\n }\n\n this.length = b.length;\n\n return this.strip();\n };\n\n BN.prototype.iand = function iand (num) {\n assert((this.negative | num.negative) === 0);\n return this.iuand(num);\n };\n\n // And `num` with `this`\n BN.prototype.and = function and (num) {\n if (this.length > num.length) return this.clone().iand(num);\n return num.clone().iand(this);\n };\n\n BN.prototype.uand = function uand (num) {\n if (this.length > num.length) return this.clone().iuand(num);\n return num.clone().iuand(this);\n };\n\n // Xor `num` with `this` in-place\n BN.prototype.iuxor = function iuxor (num) {\n // a.length > b.length\n var a;\n var b;\n if (this.length > num.length) {\n a = this;\n b = num;\n } else {\n a = num;\n b = this;\n }\n\n for (var i = 0; i < b.length; i++) {\n this.words[i] = a.words[i] ^ b.words[i];\n }\n\n if (this !== a) {\n for (; i < a.length; i++) {\n this.words[i] = a.words[i];\n }\n }\n\n this.length = a.length;\n\n return this.strip();\n };\n\n BN.prototype.ixor = function ixor (num) {\n assert((this.negative | num.negative) === 0);\n return this.iuxor(num);\n };\n\n // Xor `num` with `this`\n BN.prototype.xor = function xor (num) {\n if (this.length > num.length) return this.clone().ixor(num);\n return num.clone().ixor(this);\n };\n\n BN.prototype.uxor = function uxor (num) {\n if (this.length > num.length) return this.clone().iuxor(num);\n return num.clone().iuxor(this);\n };\n\n // Not ``this`` with ``width`` bitwidth\n BN.prototype.inotn = function inotn (width) {\n assert(typeof width === 'number' && width >= 0);\n\n var bytesNeeded = Math.ceil(width / 26) | 0;\n var bitsLeft = width % 26;\n\n // Extend the buffer with leading zeroes\n this._expand(bytesNeeded);\n\n if (bitsLeft > 0) {\n bytesNeeded--;\n }\n\n // Handle complete words\n for (var i = 0; i < bytesNeeded; i++) {\n this.words[i] = ~this.words[i] & 0x3ffffff;\n }\n\n // Handle the residue\n if (bitsLeft > 0) {\n this.words[i] = ~this.words[i] & (0x3ffffff >> (26 - bitsLeft));\n }\n\n // And remove leading zeroes\n return this.strip();\n };\n\n BN.prototype.notn = function notn (width) {\n return this.clone().inotn(width);\n };\n\n // Set `bit` of `this`\n BN.prototype.setn = function setn (bit, val) {\n assert(typeof bit === 'number' && bit >= 0);\n\n var off = (bit / 26) | 0;\n var wbit = bit % 26;\n\n this._expand(off + 1);\n\n if (val) {\n this.words[off] = this.words[off] | (1 << wbit);\n } else {\n this.words[off] = this.words[off] & ~(1 << wbit);\n }\n\n return this.strip();\n };\n\n // Add `num` to `this` in-place\n BN.prototype.iadd = function iadd (num) {\n var r;\n\n // negative + positive\n if (this.negative !== 0 && num.negative === 0) {\n this.negative = 0;\n r = this.isub(num);\n this.negative ^= 1;\n return this._normSign();\n\n // positive + negative\n } else if (this.negative === 0 && num.negative !== 0) {\n num.negative = 0;\n r = this.isub(num);\n num.negative = 1;\n return r._normSign();\n }\n\n // a.length > b.length\n var a, b;\n if (this.length > num.length) {\n a = this;\n b = num;\n } else {\n a = num;\n b = this;\n }\n\n var carry = 0;\n for (var i = 0; i < b.length; i++) {\n r = (a.words[i] | 0) + (b.words[i] | 0) + carry;\n this.words[i] = r & 0x3ffffff;\n carry = r >>> 26;\n }\n for (; carry !== 0 && i < a.length; i++) {\n r = (a.words[i] | 0) + carry;\n this.words[i] = r & 0x3ffffff;\n carry = r >>> 26;\n }\n\n this.length = a.length;\n if (carry !== 0) {\n this.words[this.length] = carry;\n this.length++;\n // Copy the rest of the words\n } else if (a !== this) {\n for (; i < a.length; i++) {\n this.words[i] = a.words[i];\n }\n }\n\n return this;\n };\n\n // Add `num` to `this`\n BN.prototype.add = function add (num) {\n var res;\n if (num.negative !== 0 && this.negative === 0) {\n num.negative = 0;\n res = this.sub(num);\n num.negative ^= 1;\n return res;\n } else if (num.negative === 0 && this.negative !== 0) {\n this.negative = 0;\n res = num.sub(this);\n this.negative = 1;\n return res;\n }\n\n if (this.length > num.length) return this.clone().iadd(num);\n\n return num.clone().iadd(this);\n };\n\n // Subtract `num` from `this` in-place\n BN.prototype.isub = function isub (num) {\n // this - (-num) = this + num\n if (num.negative !== 0) {\n num.negative = 0;\n var r = this.iadd(num);\n num.negative = 1;\n return r._normSign();\n\n // -this - num = -(this + num)\n } else if (this.negative !== 0) {\n this.negative = 0;\n this.iadd(num);\n this.negative = 1;\n return this._normSign();\n }\n\n // At this point both numbers are positive\n var cmp = this.cmp(num);\n\n // Optimization - zeroify\n if (cmp === 0) {\n this.negative = 0;\n this.length = 1;\n this.words[0] = 0;\n return this;\n }\n\n // a > b\n var a, b;\n if (cmp > 0) {\n a = this;\n b = num;\n } else {\n a = num;\n b = this;\n }\n\n var carry = 0;\n for (var i = 0; i < b.length; i++) {\n r = (a.words[i] | 0) - (b.words[i] | 0) + carry;\n carry = r >> 26;\n this.words[i] = r & 0x3ffffff;\n }\n for (; carry !== 0 && i < a.length; i++) {\n r = (a.words[i] | 0) + carry;\n carry = r >> 26;\n this.words[i] = r & 0x3ffffff;\n }\n\n // Copy rest of the words\n if (carry === 0 && i < a.length && a !== this) {\n for (; i < a.length; i++) {\n this.words[i] = a.words[i];\n }\n }\n\n this.length = Math.max(this.length, i);\n\n if (a !== this) {\n this.negative = 1;\n }\n\n return this.strip();\n };\n\n // Subtract `num` from `this`\n BN.prototype.sub = function sub (num) {\n return this.clone().isub(num);\n };\n\n function smallMulTo (self, num, out) {\n out.negative = num.negative ^ self.negative;\n var len = (self.length + num.length) | 0;\n out.length = len;\n len = (len - 1) | 0;\n\n // Peel one iteration (compiler can't do it, because of code complexity)\n var a = self.words[0] | 0;\n var b = num.words[0] | 0;\n var r = a * b;\n\n var lo = r & 0x3ffffff;\n var carry = (r / 0x4000000) | 0;\n out.words[0] = lo;\n\n for (var k = 1; k < len; k++) {\n // Sum all words with the same `i + j = k` and accumulate `ncarry`,\n // note that ncarry could be >= 0x3ffffff\n var ncarry = carry >>> 26;\n var rword = carry & 0x3ffffff;\n var maxJ = Math.min(k, num.length - 1);\n for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {\n var i = (k - j) | 0;\n a = self.words[i] | 0;\n b = num.words[j] | 0;\n r = a * b + rword;\n ncarry += (r / 0x4000000) | 0;\n rword = r & 0x3ffffff;\n }\n out.words[k] = rword | 0;\n carry = ncarry | 0;\n }\n if (carry !== 0) {\n out.words[k] = carry | 0;\n } else {\n out.length--;\n }\n\n return out.strip();\n }\n\n // TODO(indutny): it may be reasonable to omit it for users who don't need\n // to work with 256-bit numbers, otherwise it gives 20% improvement for 256-bit\n // multiplication (like elliptic secp256k1).\n var comb10MulTo = function comb10MulTo (self, num, out) {\n var a = self.words;\n var b = num.words;\n var o = out.words;\n var c = 0;\n var lo;\n var mid;\n var hi;\n var a0 = a[0] | 0;\n var al0 = a0 & 0x1fff;\n var ah0 = a0 >>> 13;\n var a1 = a[1] | 0;\n var al1 = a1 & 0x1fff;\n var ah1 = a1 >>> 13;\n var a2 = a[2] | 0;\n var al2 = a2 & 0x1fff;\n var ah2 = a2 >>> 13;\n var a3 = a[3] | 0;\n var al3 = a3 & 0x1fff;\n var ah3 = a3 >>> 13;\n var a4 = a[4] | 0;\n var al4 = a4 & 0x1fff;\n var ah4 = a4 >>> 13;\n var a5 = a[5] | 0;\n var al5 = a5 & 0x1fff;\n var ah5 = a5 >>> 13;\n var a6 = a[6] | 0;\n var al6 = a6 & 0x1fff;\n var ah6 = a6 >>> 13;\n var a7 = a[7] | 0;\n var al7 = a7 & 0x1fff;\n var ah7 = a7 >>> 13;\n var a8 = a[8] | 0;\n var al8 = a8 & 0x1fff;\n var ah8 = a8 >>> 13;\n var a9 = a[9] | 0;\n var al9 = a9 & 0x1fff;\n var ah9 = a9 >>> 13;\n var b0 = b[0] | 0;\n var bl0 = b0 & 0x1fff;\n var bh0 = b0 >>> 13;\n var b1 = b[1] | 0;\n var bl1 = b1 & 0x1fff;\n var bh1 = b1 >>> 13;\n var b2 = b[2] | 0;\n var bl2 = b2 & 0x1fff;\n var bh2 = b2 >>> 13;\n var b3 = b[3] | 0;\n var bl3 = b3 & 0x1fff;\n var bh3 = b3 >>> 13;\n var b4 = b[4] | 0;\n var bl4 = b4 & 0x1fff;\n var bh4 = b4 >>> 13;\n var b5 = b[5] | 0;\n var bl5 = b5 & 0x1fff;\n var bh5 = b5 >>> 13;\n var b6 = b[6] | 0;\n var bl6 = b6 & 0x1fff;\n var bh6 = b6 >>> 13;\n var b7 = b[7] | 0;\n var bl7 = b7 & 0x1fff;\n var bh7 = b7 >>> 13;\n var b8 = b[8] | 0;\n var bl8 = b8 & 0x1fff;\n var bh8 = b8 >>> 13;\n var b9 = b[9] | 0;\n var bl9 = b9 & 0x1fff;\n var bh9 = b9 >>> 13;\n\n out.negative = self.negative ^ num.negative;\n out.length = 19;\n /* k = 0 */\n lo = Math.imul(al0, bl0);\n mid = Math.imul(al0, bh0);\n mid = (mid + Math.imul(ah0, bl0)) | 0;\n hi = Math.imul(ah0, bh0);\n var w0 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w0 >>> 26)) | 0;\n w0 &= 0x3ffffff;\n /* k = 1 */\n lo = Math.imul(al1, bl0);\n mid = Math.imul(al1, bh0);\n mid = (mid + Math.imul(ah1, bl0)) | 0;\n hi = Math.imul(ah1, bh0);\n lo = (lo + Math.imul(al0, bl1)) | 0;\n mid = (mid + Math.imul(al0, bh1)) | 0;\n mid = (mid + Math.imul(ah0, bl1)) | 0;\n hi = (hi + Math.imul(ah0, bh1)) | 0;\n var w1 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w1 >>> 26)) | 0;\n w1 &= 0x3ffffff;\n /* k = 2 */\n lo = Math.imul(al2, bl0);\n mid = Math.imul(al2, bh0);\n mid = (mid + Math.imul(ah2, bl0)) | 0;\n hi = Math.imul(ah2, bh0);\n lo = (lo + Math.imul(al1, bl1)) | 0;\n mid = (mid + Math.imul(al1, bh1)) | 0;\n mid = (mid + Math.imul(ah1, bl1)) | 0;\n hi = (hi + Math.imul(ah1, bh1)) | 0;\n lo = (lo + Math.imul(al0, bl2)) | 0;\n mid = (mid + Math.imul(al0, bh2)) | 0;\n mid = (mid + Math.imul(ah0, bl2)) | 0;\n hi = (hi + Math.imul(ah0, bh2)) | 0;\n var w2 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w2 >>> 26)) | 0;\n w2 &= 0x3ffffff;\n /* k = 3 */\n lo = Math.imul(al3, bl0);\n mid = Math.imul(al3, bh0);\n mid = (mid + Math.imul(ah3, bl0)) | 0;\n hi = Math.imul(ah3, bh0);\n lo = (lo + Math.imul(al2, bl1)) | 0;\n mid = (mid + Math.imul(al2, bh1)) | 0;\n mid = (mid + Math.imul(ah2, bl1)) | 0;\n hi = (hi + Math.imul(ah2, bh1)) | 0;\n lo = (lo + Math.imul(al1, bl2)) | 0;\n mid = (mid + Math.imul(al1, bh2)) | 0;\n mid = (mid + Math.imul(ah1, bl2)) | 0;\n hi = (hi + Math.imul(ah1, bh2)) | 0;\n lo = (lo + Math.imul(al0, bl3)) | 0;\n mid = (mid + Math.imul(al0, bh3)) | 0;\n mid = (mid + Math.imul(ah0, bl3)) | 0;\n hi = (hi + Math.imul(ah0, bh3)) | 0;\n var w3 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w3 >>> 26)) | 0;\n w3 &= 0x3ffffff;\n /* k = 4 */\n lo = Math.imul(al4, bl0);\n mid = Math.imul(al4, bh0);\n mid = (mid + Math.imul(ah4, bl0)) | 0;\n hi = Math.imul(ah4, bh0);\n lo = (lo + Math.imul(al3, bl1)) | 0;\n mid = (mid + Math.imul(al3, bh1)) | 0;\n mid = (mid + Math.imul(ah3, bl1)) | 0;\n hi = (hi + Math.imul(ah3, bh1)) | 0;\n lo = (lo + Math.imul(al2, bl2)) | 0;\n mid = (mid + Math.imul(al2, bh2)) | 0;\n mid = (mid + Math.imul(ah2, bl2)) | 0;\n hi = (hi + Math.imul(ah2, bh2)) | 0;\n lo = (lo + Math.imul(al1, bl3)) | 0;\n mid = (mid + Math.imul(al1, bh3)) | 0;\n mid = (mid + Math.imul(ah1, bl3)) | 0;\n hi = (hi + Math.imul(ah1, bh3)) | 0;\n lo = (lo + Math.imul(al0, bl4)) | 0;\n mid = (mid + Math.imul(al0, bh4)) | 0;\n mid = (mid + Math.imul(ah0, bl4)) | 0;\n hi = (hi + Math.imul(ah0, bh4)) | 0;\n var w4 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w4 >>> 26)) | 0;\n w4 &= 0x3ffffff;\n /* k = 5 */\n lo = Math.imul(al5, bl0);\n mid = Math.imul(al5, bh0);\n mid = (mid + Math.imul(ah5, bl0)) | 0;\n hi = Math.imul(ah5, bh0);\n lo = (lo + Math.imul(al4, bl1)) | 0;\n mid = (mid + Math.imul(al4, bh1)) | 0;\n mid = (mid + Math.imul(ah4, bl1)) | 0;\n hi = (hi + Math.imul(ah4, bh1)) | 0;\n lo = (lo + Math.imul(al3, bl2)) | 0;\n mid = (mid + Math.imul(al3, bh2)) | 0;\n mid = (mid + Math.imul(ah3, bl2)) | 0;\n hi = (hi + Math.imul(ah3, bh2)) | 0;\n lo = (lo + Math.imul(al2, bl3)) | 0;\n mid = (mid + Math.imul(al2, bh3)) | 0;\n mid = (mid + Math.imul(ah2, bl3)) | 0;\n hi = (hi + Math.imul(ah2, bh3)) | 0;\n lo = (lo + Math.imul(al1, bl4)) | 0;\n mid = (mid + Math.imul(al1, bh4)) | 0;\n mid = (mid + Math.imul(ah1, bl4)) | 0;\n hi = (hi + Math.imul(ah1, bh4)) | 0;\n lo = (lo + Math.imul(al0, bl5)) | 0;\n mid = (mid + Math.imul(al0, bh5)) | 0;\n mid = (mid + Math.imul(ah0, bl5)) | 0;\n hi = (hi + Math.imul(ah0, bh5)) | 0;\n var w5 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w5 >>> 26)) | 0;\n w5 &= 0x3ffffff;\n /* k = 6 */\n lo = Math.imul(al6, bl0);\n mid = Math.imul(al6, bh0);\n mid = (mid + Math.imul(ah6, bl0)) | 0;\n hi = Math.imul(ah6, bh0);\n lo = (lo + Math.imul(al5, bl1)) | 0;\n mid = (mid + Math.imul(al5, bh1)) | 0;\n mid = (mid + Math.imul(ah5, bl1)) | 0;\n hi = (hi + Math.imul(ah5, bh1)) | 0;\n lo = (lo + Math.imul(al4, bl2)) | 0;\n mid = (mid + Math.imul(al4, bh2)) | 0;\n mid = (mid + Math.imul(ah4, bl2)) | 0;\n hi = (hi + Math.imul(ah4, bh2)) | 0;\n lo = (lo + Math.imul(al3, bl3)) | 0;\n mid = (mid + Math.imul(al3, bh3)) | 0;\n mid = (mid + Math.imul(ah3, bl3)) | 0;\n hi = (hi + Math.imul(ah3, bh3)) | 0;\n lo = (lo + Math.imul(al2, bl4)) | 0;\n mid = (mid + Math.imul(al2, bh4)) | 0;\n mid = (mid + Math.imul(ah2, bl4)) | 0;\n hi = (hi + Math.imul(ah2, bh4)) | 0;\n lo = (lo + Math.imul(al1, bl5)) | 0;\n mid = (mid + Math.imul(al1, bh5)) | 0;\n mid = (mid + Math.imul(ah1, bl5)) | 0;\n hi = (hi + Math.imul(ah1, bh5)) | 0;\n lo = (lo + Math.imul(al0, bl6)) | 0;\n mid = (mid + Math.imul(al0, bh6)) | 0;\n mid = (mid + Math.imul(ah0, bl6)) | 0;\n hi = (hi + Math.imul(ah0, bh6)) | 0;\n var w6 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w6 >>> 26)) | 0;\n w6 &= 0x3ffffff;\n /* k = 7 */\n lo = Math.imul(al7, bl0);\n mid = Math.imul(al7, bh0);\n mid = (mid + Math.imul(ah7, bl0)) | 0;\n hi = Math.imul(ah7, bh0);\n lo = (lo + Math.imul(al6, bl1)) | 0;\n mid = (mid + Math.imul(al6, bh1)) | 0;\n mid = (mid + Math.imul(ah6, bl1)) | 0;\n hi = (hi + Math.imul(ah6, bh1)) | 0;\n lo = (lo + Math.imul(al5, bl2)) | 0;\n mid = (mid + Math.imul(al5, bh2)) | 0;\n mid = (mid + Math.imul(ah5, bl2)) | 0;\n hi = (hi + Math.imul(ah5, bh2)) | 0;\n lo = (lo + Math.imul(al4, bl3)) | 0;\n mid = (mid + Math.imul(al4, bh3)) | 0;\n mid = (mid + Math.imul(ah4, bl3)) | 0;\n hi = (hi + Math.imul(ah4, bh3)) | 0;\n lo = (lo + Math.imul(al3, bl4)) | 0;\n mid = (mid + Math.imul(al3, bh4)) | 0;\n mid = (mid + Math.imul(ah3, bl4)) | 0;\n hi = (hi + Math.imul(ah3, bh4)) | 0;\n lo = (lo + Math.imul(al2, bl5)) | 0;\n mid = (mid + Math.imul(al2, bh5)) | 0;\n mid = (mid + Math.imul(ah2, bl5)) | 0;\n hi = (hi + Math.imul(ah2, bh5)) | 0;\n lo = (lo + Math.imul(al1, bl6)) | 0;\n mid = (mid + Math.imul(al1, bh6)) | 0;\n mid = (mid + Math.imul(ah1, bl6)) | 0;\n hi = (hi + Math.imul(ah1, bh6)) | 0;\n lo = (lo + Math.imul(al0, bl7)) | 0;\n mid = (mid + Math.imul(al0, bh7)) | 0;\n mid = (mid + Math.imul(ah0, bl7)) | 0;\n hi = (hi + Math.imul(ah0, bh7)) | 0;\n var w7 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w7 >>> 26)) | 0;\n w7 &= 0x3ffffff;\n /* k = 8 */\n lo = Math.imul(al8, bl0);\n mid = Math.imul(al8, bh0);\n mid = (mid + Math.imul(ah8, bl0)) | 0;\n hi = Math.imul(ah8, bh0);\n lo = (lo + Math.imul(al7, bl1)) | 0;\n mid = (mid + Math.imul(al7, bh1)) | 0;\n mid = (mid + Math.imul(ah7, bl1)) | 0;\n hi = (hi + Math.imul(ah7, bh1)) | 0;\n lo = (lo + Math.imul(al6, bl2)) | 0;\n mid = (mid + Math.imul(al6, bh2)) | 0;\n mid = (mid + Math.imul(ah6, bl2)) | 0;\n hi = (hi + Math.imul(ah6, bh2)) | 0;\n lo = (lo + Math.imul(al5, bl3)) | 0;\n mid = (mid + Math.imul(al5, bh3)) | 0;\n mid = (mid + Math.imul(ah5, bl3)) | 0;\n hi = (hi + Math.imul(ah5, bh3)) | 0;\n lo = (lo + Math.imul(al4, bl4)) | 0;\n mid = (mid + Math.imul(al4, bh4)) | 0;\n mid = (mid + Math.imul(ah4, bl4)) | 0;\n hi = (hi + Math.imul(ah4, bh4)) | 0;\n lo = (lo + Math.imul(al3, bl5)) | 0;\n mid = (mid + Math.imul(al3, bh5)) | 0;\n mid = (mid + Math.imul(ah3, bl5)) | 0;\n hi = (hi + Math.imul(ah3, bh5)) | 0;\n lo = (lo + Math.imul(al2, bl6)) | 0;\n mid = (mid + Math.imul(al2, bh6)) | 0;\n mid = (mid + Math.imul(ah2, bl6)) | 0;\n hi = (hi + Math.imul(ah2, bh6)) | 0;\n lo = (lo + Math.imul(al1, bl7)) | 0;\n mid = (mid + Math.imul(al1, bh7)) | 0;\n mid = (mid + Math.imul(ah1, bl7)) | 0;\n hi = (hi + Math.imul(ah1, bh7)) | 0;\n lo = (lo + Math.imul(al0, bl8)) | 0;\n mid = (mid + Math.imul(al0, bh8)) | 0;\n mid = (mid + Math.imul(ah0, bl8)) | 0;\n hi = (hi + Math.imul(ah0, bh8)) | 0;\n var w8 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w8 >>> 26)) | 0;\n w8 &= 0x3ffffff;\n /* k = 9 */\n lo = Math.imul(al9, bl0);\n mid = Math.imul(al9, bh0);\n mid = (mid + Math.imul(ah9, bl0)) | 0;\n hi = Math.imul(ah9, bh0);\n lo = (lo + Math.imul(al8, bl1)) | 0;\n mid = (mid + Math.imul(al8, bh1)) | 0;\n mid = (mid + Math.imul(ah8, bl1)) | 0;\n hi = (hi + Math.imul(ah8, bh1)) | 0;\n lo = (lo + Math.imul(al7, bl2)) | 0;\n mid = (mid + Math.imul(al7, bh2)) | 0;\n mid = (mid + Math.imul(ah7, bl2)) | 0;\n hi = (hi + Math.imul(ah7, bh2)) | 0;\n lo = (lo + Math.imul(al6, bl3)) | 0;\n mid = (mid + Math.imul(al6, bh3)) | 0;\n mid = (mid + Math.imul(ah6, bl3)) | 0;\n hi = (hi + Math.imul(ah6, bh3)) | 0;\n lo = (lo + Math.imul(al5, bl4)) | 0;\n mid = (mid + Math.imul(al5, bh4)) | 0;\n mid = (mid + Math.imul(ah5, bl4)) | 0;\n hi = (hi + Math.imul(ah5, bh4)) | 0;\n lo = (lo + Math.imul(al4, bl5)) | 0;\n mid = (mid + Math.imul(al4, bh5)) | 0;\n mid = (mid + Math.imul(ah4, bl5)) | 0;\n hi = (hi + Math.imul(ah4, bh5)) | 0;\n lo = (lo + Math.imul(al3, bl6)) | 0;\n mid = (mid + Math.imul(al3, bh6)) | 0;\n mid = (mid + Math.imul(ah3, bl6)) | 0;\n hi = (hi + Math.imul(ah3, bh6)) | 0;\n lo = (lo + Math.imul(al2, bl7)) | 0;\n mid = (mid + Math.imul(al2, bh7)) | 0;\n mid = (mid + Math.imul(ah2, bl7)) | 0;\n hi = (hi + Math.imul(ah2, bh7)) | 0;\n lo = (lo + Math.imul(al1, bl8)) | 0;\n mid = (mid + Math.imul(al1, bh8)) | 0;\n mid = (mid + Math.imul(ah1, bl8)) | 0;\n hi = (hi + Math.imul(ah1, bh8)) | 0;\n lo = (lo + Math.imul(al0, bl9)) | 0;\n mid = (mid + Math.imul(al0, bh9)) | 0;\n mid = (mid + Math.imul(ah0, bl9)) | 0;\n hi = (hi + Math.imul(ah0, bh9)) | 0;\n var w9 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w9 >>> 26)) | 0;\n w9 &= 0x3ffffff;\n /* k = 10 */\n lo = Math.imul(al9, bl1);\n mid = Math.imul(al9, bh1);\n mid = (mid + Math.imul(ah9, bl1)) | 0;\n hi = Math.imul(ah9, bh1);\n lo = (lo + Math.imul(al8, bl2)) | 0;\n mid = (mid + Math.imul(al8, bh2)) | 0;\n mid = (mid + Math.imul(ah8, bl2)) | 0;\n hi = (hi + Math.imul(ah8, bh2)) | 0;\n lo = (lo + Math.imul(al7, bl3)) | 0;\n mid = (mid + Math.imul(al7, bh3)) | 0;\n mid = (mid + Math.imul(ah7, bl3)) | 0;\n hi = (hi + Math.imul(ah7, bh3)) | 0;\n lo = (lo + Math.imul(al6, bl4)) | 0;\n mid = (mid + Math.imul(al6, bh4)) | 0;\n mid = (mid + Math.imul(ah6, bl4)) | 0;\n hi = (hi + Math.imul(ah6, bh4)) | 0;\n lo = (lo + Math.imul(al5, bl5)) | 0;\n mid = (mid + Math.imul(al5, bh5)) | 0;\n mid = (mid + Math.imul(ah5, bl5)) | 0;\n hi = (hi + Math.imul(ah5, bh5)) | 0;\n lo = (lo + Math.imul(al4, bl6)) | 0;\n mid = (mid + Math.imul(al4, bh6)) | 0;\n mid = (mid + Math.imul(ah4, bl6)) | 0;\n hi = (hi + Math.imul(ah4, bh6)) | 0;\n lo = (lo + Math.imul(al3, bl7)) | 0;\n mid = (mid + Math.imul(al3, bh7)) | 0;\n mid = (mid + Math.imul(ah3, bl7)) | 0;\n hi = (hi + Math.imul(ah3, bh7)) | 0;\n lo = (lo + Math.imul(al2, bl8)) | 0;\n mid = (mid + Math.imul(al2, bh8)) | 0;\n mid = (mid + Math.imul(ah2, bl8)) | 0;\n hi = (hi + Math.imul(ah2, bh8)) | 0;\n lo = (lo + Math.imul(al1, bl9)) | 0;\n mid = (mid + Math.imul(al1, bh9)) | 0;\n mid = (mid + Math.imul(ah1, bl9)) | 0;\n hi = (hi + Math.imul(ah1, bh9)) | 0;\n var w10 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w10 >>> 26)) | 0;\n w10 &= 0x3ffffff;\n /* k = 11 */\n lo = Math.imul(al9, bl2);\n mid = Math.imul(al9, bh2);\n mid = (mid + Math.imul(ah9, bl2)) | 0;\n hi = Math.imul(ah9, bh2);\n lo = (lo + Math.imul(al8, bl3)) | 0;\n mid = (mid + Math.imul(al8, bh3)) | 0;\n mid = (mid + Math.imul(ah8, bl3)) | 0;\n hi = (hi + Math.imul(ah8, bh3)) | 0;\n lo = (lo + Math.imul(al7, bl4)) | 0;\n mid = (mid + Math.imul(al7, bh4)) | 0;\n mid = (mid + Math.imul(ah7, bl4)) | 0;\n hi = (hi + Math.imul(ah7, bh4)) | 0;\n lo = (lo + Math.imul(al6, bl5)) | 0;\n mid = (mid + Math.imul(al6, bh5)) | 0;\n mid = (mid + Math.imul(ah6, bl5)) | 0;\n hi = (hi + Math.imul(ah6, bh5)) | 0;\n lo = (lo + Math.imul(al5, bl6)) | 0;\n mid = (mid + Math.imul(al5, bh6)) | 0;\n mid = (mid + Math.imul(ah5, bl6)) | 0;\n hi = (hi + Math.imul(ah5, bh6)) | 0;\n lo = (lo + Math.imul(al4, bl7)) | 0;\n mid = (mid + Math.imul(al4, bh7)) | 0;\n mid = (mid + Math.imul(ah4, bl7)) | 0;\n hi = (hi + Math.imul(ah4, bh7)) | 0;\n lo = (lo + Math.imul(al3, bl8)) | 0;\n mid = (mid + Math.imul(al3, bh8)) | 0;\n mid = (mid + Math.imul(ah3, bl8)) | 0;\n hi = (hi + Math.imul(ah3, bh8)) | 0;\n lo = (lo + Math.imul(al2, bl9)) | 0;\n mid = (mid + Math.imul(al2, bh9)) | 0;\n mid = (mid + Math.imul(ah2, bl9)) | 0;\n hi = (hi + Math.imul(ah2, bh9)) | 0;\n var w11 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w11 >>> 26)) | 0;\n w11 &= 0x3ffffff;\n /* k = 12 */\n lo = Math.imul(al9, bl3);\n mid = Math.imul(al9, bh3);\n mid = (mid + Math.imul(ah9, bl3)) | 0;\n hi = Math.imul(ah9, bh3);\n lo = (lo + Math.imul(al8, bl4)) | 0;\n mid = (mid + Math.imul(al8, bh4)) | 0;\n mid = (mid + Math.imul(ah8, bl4)) | 0;\n hi = (hi + Math.imul(ah8, bh4)) | 0;\n lo = (lo + Math.imul(al7, bl5)) | 0;\n mid = (mid + Math.imul(al7, bh5)) | 0;\n mid = (mid + Math.imul(ah7, bl5)) | 0;\n hi = (hi + Math.imul(ah7, bh5)) | 0;\n lo = (lo + Math.imul(al6, bl6)) | 0;\n mid = (mid + Math.imul(al6, bh6)) | 0;\n mid = (mid + Math.imul(ah6, bl6)) | 0;\n hi = (hi + Math.imul(ah6, bh6)) | 0;\n lo = (lo + Math.imul(al5, bl7)) | 0;\n mid = (mid + Math.imul(al5, bh7)) | 0;\n mid = (mid + Math.imul(ah5, bl7)) | 0;\n hi = (hi + Math.imul(ah5, bh7)) | 0;\n lo = (lo + Math.imul(al4, bl8)) | 0;\n mid = (mid + Math.imul(al4, bh8)) | 0;\n mid = (mid + Math.imul(ah4, bl8)) | 0;\n hi = (hi + Math.imul(ah4, bh8)) | 0;\n lo = (lo + Math.imul(al3, bl9)) | 0;\n mid = (mid + Math.imul(al3, bh9)) | 0;\n mid = (mid + Math.imul(ah3, bl9)) | 0;\n hi = (hi + Math.imul(ah3, bh9)) | 0;\n var w12 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w12 >>> 26)) | 0;\n w12 &= 0x3ffffff;\n /* k = 13 */\n lo = Math.imul(al9, bl4);\n mid = Math.imul(al9, bh4);\n mid = (mid + Math.imul(ah9, bl4)) | 0;\n hi = Math.imul(ah9, bh4);\n lo = (lo + Math.imul(al8, bl5)) | 0;\n mid = (mid + Math.imul(al8, bh5)) | 0;\n mid = (mid + Math.imul(ah8, bl5)) | 0;\n hi = (hi + Math.imul(ah8, bh5)) | 0;\n lo = (lo + Math.imul(al7, bl6)) | 0;\n mid = (mid + Math.imul(al7, bh6)) | 0;\n mid = (mid + Math.imul(ah7, bl6)) | 0;\n hi = (hi + Math.imul(ah7, bh6)) | 0;\n lo = (lo + Math.imul(al6, bl7)) | 0;\n mid = (mid + Math.imul(al6, bh7)) | 0;\n mid = (mid + Math.imul(ah6, bl7)) | 0;\n hi = (hi + Math.imul(ah6, bh7)) | 0;\n lo = (lo + Math.imul(al5, bl8)) | 0;\n mid = (mid + Math.imul(al5, bh8)) | 0;\n mid = (mid + Math.imul(ah5, bl8)) | 0;\n hi = (hi + Math.imul(ah5, bh8)) | 0;\n lo = (lo + Math.imul(al4, bl9)) | 0;\n mid = (mid + Math.imul(al4, bh9)) | 0;\n mid = (mid + Math.imul(ah4, bl9)) | 0;\n hi = (hi + Math.imul(ah4, bh9)) | 0;\n var w13 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w13 >>> 26)) | 0;\n w13 &= 0x3ffffff;\n /* k = 14 */\n lo = Math.imul(al9, bl5);\n mid = Math.imul(al9, bh5);\n mid = (mid + Math.imul(ah9, bl5)) | 0;\n hi = Math.imul(ah9, bh5);\n lo = (lo + Math.imul(al8, bl6)) | 0;\n mid = (mid + Math.imul(al8, bh6)) | 0;\n mid = (mid + Math.imul(ah8, bl6)) | 0;\n hi = (hi + Math.imul(ah8, bh6)) | 0;\n lo = (lo + Math.imul(al7, bl7)) | 0;\n mid = (mid + Math.imul(al7, bh7)) | 0;\n mid = (mid + Math.imul(ah7, bl7)) | 0;\n hi = (hi + Math.imul(ah7, bh7)) | 0;\n lo = (lo + Math.imul(al6, bl8)) | 0;\n mid = (mid + Math.imul(al6, bh8)) | 0;\n mid = (mid + Math.imul(ah6, bl8)) | 0;\n hi = (hi + Math.imul(ah6, bh8)) | 0;\n lo = (lo + Math.imul(al5, bl9)) | 0;\n mid = (mid + Math.imul(al5, bh9)) | 0;\n mid = (mid + Math.imul(ah5, bl9)) | 0;\n hi = (hi + Math.imul(ah5, bh9)) | 0;\n var w14 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w14 >>> 26)) | 0;\n w14 &= 0x3ffffff;\n /* k = 15 */\n lo = Math.imul(al9, bl6);\n mid = Math.imul(al9, bh6);\n mid = (mid + Math.imul(ah9, bl6)) | 0;\n hi = Math.imul(ah9, bh6);\n lo = (lo + Math.imul(al8, bl7)) | 0;\n mid = (mid + Math.imul(al8, bh7)) | 0;\n mid = (mid + Math.imul(ah8, bl7)) | 0;\n hi = (hi + Math.imul(ah8, bh7)) | 0;\n lo = (lo + Math.imul(al7, bl8)) | 0;\n mid = (mid + Math.imul(al7, bh8)) | 0;\n mid = (mid + Math.imul(ah7, bl8)) | 0;\n hi = (hi + Math.imul(ah7, bh8)) | 0;\n lo = (lo + Math.imul(al6, bl9)) | 0;\n mid = (mid + Math.imul(al6, bh9)) | 0;\n mid = (mid + Math.imul(ah6, bl9)) | 0;\n hi = (hi + Math.imul(ah6, bh9)) | 0;\n var w15 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w15 >>> 26)) | 0;\n w15 &= 0x3ffffff;\n /* k = 16 */\n lo = Math.imul(al9, bl7);\n mid = Math.imul(al9, bh7);\n mid = (mid + Math.imul(ah9, bl7)) | 0;\n hi = Math.imul(ah9, bh7);\n lo = (lo + Math.imul(al8, bl8)) | 0;\n mid = (mid + Math.imul(al8, bh8)) | 0;\n mid = (mid + Math.imul(ah8, bl8)) | 0;\n hi = (hi + Math.imul(ah8, bh8)) | 0;\n lo = (lo + Math.imul(al7, bl9)) | 0;\n mid = (mid + Math.imul(al7, bh9)) | 0;\n mid = (mid + Math.imul(ah7, bl9)) | 0;\n hi = (hi + Math.imul(ah7, bh9)) | 0;\n var w16 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w16 >>> 26)) | 0;\n w16 &= 0x3ffffff;\n /* k = 17 */\n lo = Math.imul(al9, bl8);\n mid = Math.imul(al9, bh8);\n mid = (mid + Math.imul(ah9, bl8)) | 0;\n hi = Math.imul(ah9, bh8);\n lo = (lo + Math.imul(al8, bl9)) | 0;\n mid = (mid + Math.imul(al8, bh9)) | 0;\n mid = (mid + Math.imul(ah8, bl9)) | 0;\n hi = (hi + Math.imul(ah8, bh9)) | 0;\n var w17 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w17 >>> 26)) | 0;\n w17 &= 0x3ffffff;\n /* k = 18 */\n lo = Math.imul(al9, bl9);\n mid = Math.imul(al9, bh9);\n mid = (mid + Math.imul(ah9, bl9)) | 0;\n hi = Math.imul(ah9, bh9);\n var w18 = (((c + lo) | 0) + ((mid & 0x1fff) << 13)) | 0;\n c = (((hi + (mid >>> 13)) | 0) + (w18 >>> 26)) | 0;\n w18 &= 0x3ffffff;\n o[0] = w0;\n o[1] = w1;\n o[2] = w2;\n o[3] = w3;\n o[4] = w4;\n o[5] = w5;\n o[6] = w6;\n o[7] = w7;\n o[8] = w8;\n o[9] = w9;\n o[10] = w10;\n o[11] = w11;\n o[12] = w12;\n o[13] = w13;\n o[14] = w14;\n o[15] = w15;\n o[16] = w16;\n o[17] = w17;\n o[18] = w18;\n if (c !== 0) {\n o[19] = c;\n out.length++;\n }\n return out;\n };\n\n // Polyfill comb\n if (!Math.imul) {\n comb10MulTo = smallMulTo;\n }\n\n function bigMulTo (self, num, out) {\n out.negative = num.negative ^ self.negative;\n out.length = self.length + num.length;\n\n var carry = 0;\n var hncarry = 0;\n for (var k = 0; k < out.length - 1; k++) {\n // Sum all words with the same `i + j = k` and accumulate `ncarry`,\n // note that ncarry could be >= 0x3ffffff\n var ncarry = hncarry;\n hncarry = 0;\n var rword = carry & 0x3ffffff;\n var maxJ = Math.min(k, num.length - 1);\n for (var j = Math.max(0, k - self.length + 1); j <= maxJ; j++) {\n var i = k - j;\n var a = self.words[i] | 0;\n var b = num.words[j] | 0;\n var r = a * b;\n\n var lo = r & 0x3ffffff;\n ncarry = (ncarry + ((r / 0x4000000) | 0)) | 0;\n lo = (lo + rword) | 0;\n rword = lo & 0x3ffffff;\n ncarry = (ncarry + (lo >>> 26)) | 0;\n\n hncarry += ncarry >>> 26;\n ncarry &= 0x3ffffff;\n }\n out.words[k] = rword;\n carry = ncarry;\n ncarry = hncarry;\n }\n if (carry !== 0) {\n out.words[k] = carry;\n } else {\n out.length--;\n }\n\n return out.strip();\n }\n\n function jumboMulTo (self, num, out) {\n var fftm = new FFTM();\n return fftm.mulp(self, num, out);\n }\n\n BN.prototype.mulTo = function mulTo (num, out) {\n var res;\n var len = this.length + num.length;\n if (this.length === 10 && num.length === 10) {\n res = comb10MulTo(this, num, out);\n } else if (len < 63) {\n res = smallMulTo(this, num, out);\n } else if (len < 1024) {\n res = bigMulTo(this, num, out);\n } else {\n res = jumboMulTo(this, num, out);\n }\n\n return res;\n };\n\n // Cooley-Tukey algorithm for FFT\n // slightly revisited to rely on looping instead of recursion\n\n function FFTM (x, y) {\n this.x = x;\n this.y = y;\n }\n\n FFTM.prototype.makeRBT = function makeRBT (N) {\n var t = new Array(N);\n var l = BN.prototype._countBits(N) - 1;\n for (var i = 0; i < N; i++) {\n t[i] = this.revBin(i, l, N);\n }\n\n return t;\n };\n\n // Returns binary-reversed representation of `x`\n FFTM.prototype.revBin = function revBin (x, l, N) {\n if (x === 0 || x === N - 1) return x;\n\n var rb = 0;\n for (var i = 0; i < l; i++) {\n rb |= (x & 1) << (l - i - 1);\n x >>= 1;\n }\n\n return rb;\n };\n\n // Performs \"tweedling\" phase, therefore 'emulating'\n // behaviour of the recursive algorithm\n FFTM.prototype.permute = function permute (rbt, rws, iws, rtws, itws, N) {\n for (var i = 0; i < N; i++) {\n rtws[i] = rws[rbt[i]];\n itws[i] = iws[rbt[i]];\n }\n };\n\n FFTM.prototype.transform = function transform (rws, iws, rtws, itws, N, rbt) {\n this.permute(rbt, rws, iws, rtws, itws, N);\n\n for (var s = 1; s < N; s <<= 1) {\n var l = s << 1;\n\n var rtwdf = Math.cos(2 * Math.PI / l);\n var itwdf = Math.sin(2 * Math.PI / l);\n\n for (var p = 0; p < N; p += l) {\n var rtwdf_ = rtwdf;\n var itwdf_ = itwdf;\n\n for (var j = 0; j < s; j++) {\n var re = rtws[p + j];\n var ie = itws[p + j];\n\n var ro = rtws[p + j + s];\n var io = itws[p + j + s];\n\n var rx = rtwdf_ * ro - itwdf_ * io;\n\n io = rtwdf_ * io + itwdf_ * ro;\n ro = rx;\n\n rtws[p + j] = re + ro;\n itws[p + j] = ie + io;\n\n rtws[p + j + s] = re - ro;\n itws[p + j + s] = ie - io;\n\n /* jshint maxdepth : false */\n if (j !== l) {\n rx = rtwdf * rtwdf_ - itwdf * itwdf_;\n\n itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;\n rtwdf_ = rx;\n }\n }\n }\n }\n };\n\n FFTM.prototype.guessLen13b = function guessLen13b (n, m) {\n var N = Math.max(m, n) | 1;\n var odd = N & 1;\n var i = 0;\n for (N = N / 2 | 0; N; N = N >>> 1) {\n i++;\n }\n\n return 1 << i + 1 + odd;\n };\n\n FFTM.prototype.conjugate = function conjugate (rws, iws, N) {\n if (N <= 1) return;\n\n for (var i = 0; i < N / 2; i++) {\n var t = rws[i];\n\n rws[i] = rws[N - i - 1];\n rws[N - i - 1] = t;\n\n t = iws[i];\n\n iws[i] = -iws[N - i - 1];\n iws[N - i - 1] = -t;\n }\n };\n\n FFTM.prototype.normalize13b = function normalize13b (ws, N) {\n var carry = 0;\n for (var i = 0; i < N / 2; i++) {\n var w = Math.round(ws[2 * i + 1] / N) * 0x2000 +\n Math.round(ws[2 * i] / N) +\n carry;\n\n ws[i] = w & 0x3ffffff;\n\n if (w < 0x4000000) {\n carry = 0;\n } else {\n carry = w / 0x4000000 | 0;\n }\n }\n\n return ws;\n };\n\n FFTM.prototype.convert13b = function convert13b (ws, len, rws, N) {\n var carry = 0;\n for (var i = 0; i < len; i++) {\n carry = carry + (ws[i] | 0);\n\n rws[2 * i] = carry & 0x1fff; carry = carry >>> 13;\n rws[2 * i + 1] = carry & 0x1fff; carry = carry >>> 13;\n }\n\n // Pad with zeroes\n for (i = 2 * len; i < N; ++i) {\n rws[i] = 0;\n }\n\n assert(carry === 0);\n assert((carry & ~0x1fff) === 0);\n };\n\n FFTM.prototype.stub = function stub (N) {\n var ph = new Array(N);\n for (var i = 0; i < N; i++) {\n ph[i] = 0;\n }\n\n return ph;\n };\n\n FFTM.prototype.mulp = function mulp (x, y, out) {\n var N = 2 * this.guessLen13b(x.length, y.length);\n\n var rbt = this.makeRBT(N);\n\n var _ = this.stub(N);\n\n var rws = new Array(N);\n var rwst = new Array(N);\n var iwst = new Array(N);\n\n var nrws = new Array(N);\n var nrwst = new Array(N);\n var niwst = new Array(N);\n\n var rmws = out.words;\n rmws.length = N;\n\n this.convert13b(x.words, x.length, rws, N);\n this.convert13b(y.words, y.length, nrws, N);\n\n this.transform(rws, _, rwst, iwst, N, rbt);\n this.transform(nrws, _, nrwst, niwst, N, rbt);\n\n for (var i = 0; i < N; i++) {\n var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];\n iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];\n rwst[i] = rx;\n }\n\n this.conjugate(rwst, iwst, N);\n this.transform(rwst, iwst, rmws, _, N, rbt);\n this.conjugate(rmws, _, N);\n this.normalize13b(rmws, N);\n\n out.negative = x.negative ^ y.negative;\n out.length = x.length + y.length;\n return out.strip();\n };\n\n // Multiply `this` by `num`\n BN.prototype.mul = function mul (num) {\n var out = new BN(null);\n out.words = new Array(this.length + num.length);\n return this.mulTo(num, out);\n };\n\n // Multiply employing FFT\n BN.prototype.mulf = function mulf (num) {\n var out = new BN(null);\n out.words = new Array(this.length + num.length);\n return jumboMulTo(this, num, out);\n };\n\n // In-place Multiplication\n BN.prototype.imul = function imul (num) {\n return this.clone().mulTo(num, this);\n };\n\n BN.prototype.imuln = function imuln (num) {\n assert(typeof num === 'number');\n assert(num < 0x4000000);\n\n // Carry\n var carry = 0;\n for (var i = 0; i < this.length; i++) {\n var w = (this.words[i] | 0) * num;\n var lo = (w & 0x3ffffff) + (carry & 0x3ffffff);\n carry >>= 26;\n carry += (w / 0x4000000) | 0;\n // NOTE: lo is 27bit maximum\n carry += lo >>> 26;\n this.words[i] = lo & 0x3ffffff;\n }\n\n if (carry !== 0) {\n this.words[i] = carry;\n this.length++;\n }\n\n return this;\n };\n\n BN.prototype.muln = function muln (num) {\n return this.clone().imuln(num);\n };\n\n // `this` * `this`\n BN.prototype.sqr = function sqr () {\n return this.mul(this);\n };\n\n // `this` * `this` in-place\n BN.prototype.isqr = function isqr () {\n return this.imul(this.clone());\n };\n\n // Math.pow(`this`, `num`)\n BN.prototype.pow = function pow (num) {\n var w = toBitArray(num);\n if (w.length === 0) return new BN(1);\n\n // Skip leading zeroes\n var res = this;\n for (var i = 0; i < w.length; i++, res = res.sqr()) {\n if (w[i] !== 0) break;\n }\n\n if (++i < w.length) {\n for (var q = res.sqr(); i < w.length; i++, q = q.sqr()) {\n if (w[i] === 0) continue;\n\n res = res.mul(q);\n }\n }\n\n return res;\n };\n\n // Shift-left in-place\n BN.prototype.iushln = function iushln (bits) {\n assert(typeof bits === 'number' && bits >= 0);\n var r = bits % 26;\n var s = (bits - r) / 26;\n var carryMask = (0x3ffffff >>> (26 - r)) << (26 - r);\n var i;\n\n if (r !== 0) {\n var carry = 0;\n\n for (i = 0; i < this.length; i++) {\n var newCarry = this.words[i] & carryMask;\n var c = ((this.words[i] | 0) - newCarry) << r;\n this.words[i] = c | carry;\n carry = newCarry >>> (26 - r);\n }\n\n if (carry) {\n this.words[i] = carry;\n this.length++;\n }\n }\n\n if (s !== 0) {\n for (i = this.length - 1; i >= 0; i--) {\n this.words[i + s] = this.words[i];\n }\n\n for (i = 0; i < s; i++) {\n this.words[i] = 0;\n }\n\n this.length += s;\n }\n\n return this.strip();\n };\n\n BN.prototype.ishln = function ishln (bits) {\n // TODO(indutny): implement me\n assert(this.negative === 0);\n return this.iushln(bits);\n };\n\n // Shift-right in-place\n // NOTE: `hint` is a lowest bit before trailing zeroes\n // NOTE: if `extended` is present - it will be filled with destroyed bits\n BN.prototype.iushrn = function iushrn (bits, hint, extended) {\n assert(typeof bits === 'number' && bits >= 0);\n var h;\n if (hint) {\n h = (hint - (hint % 26)) / 26;\n } else {\n h = 0;\n }\n\n var r = bits % 26;\n var s = Math.min((bits - r) / 26, this.length);\n var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);\n var maskedWords = extended;\n\n h -= s;\n h = Math.max(0, h);\n\n // Extended mode, copy masked part\n if (maskedWords) {\n for (var i = 0; i < s; i++) {\n maskedWords.words[i] = this.words[i];\n }\n maskedWords.length = s;\n }\n\n if (s === 0) {\n // No-op, we should not move anything at all\n } else if (this.length > s) {\n this.length -= s;\n for (i = 0; i < this.length; i++) {\n this.words[i] = this.words[i + s];\n }\n } else {\n this.words[0] = 0;\n this.length = 1;\n }\n\n var carry = 0;\n for (i = this.length - 1; i >= 0 && (carry !== 0 || i >= h); i--) {\n var word = this.words[i] | 0;\n this.words[i] = (carry << (26 - r)) | (word >>> r);\n carry = word & mask;\n }\n\n // Push carried bits as a mask\n if (maskedWords && carry !== 0) {\n maskedWords.words[maskedWords.length++] = carry;\n }\n\n if (this.length === 0) {\n this.words[0] = 0;\n this.length = 1;\n }\n\n return this.strip();\n };\n\n BN.prototype.ishrn = function ishrn (bits, hint, extended) {\n // TODO(indutny): implement me\n assert(this.negative === 0);\n return this.iushrn(bits, hint, extended);\n };\n\n // Shift-left\n BN.prototype.shln = function shln (bits) {\n return this.clone().ishln(bits);\n };\n\n BN.prototype.ushln = function ushln (bits) {\n return this.clone().iushln(bits);\n };\n\n // Shift-right\n BN.prototype.shrn = function shrn (bits) {\n return this.clone().ishrn(bits);\n };\n\n BN.prototype.ushrn = function ushrn (bits) {\n return this.clone().iushrn(bits);\n };\n\n // Test if n bit is set\n BN.prototype.testn = function testn (bit) {\n assert(typeof bit === 'number' && bit >= 0);\n var r = bit % 26;\n var s = (bit - r) / 26;\n var q = 1 << r;\n\n // Fast case: bit is much higher than all existing words\n if (this.length <= s) return false;\n\n // Check bit and return\n var w = this.words[s];\n\n return !!(w & q);\n };\n\n // Return only lowers bits of number (in-place)\n BN.prototype.imaskn = function imaskn (bits) {\n assert(typeof bits === 'number' && bits >= 0);\n var r = bits % 26;\n var s = (bits - r) / 26;\n\n assert(this.negative === 0, 'imaskn works only with positive numbers');\n\n if (this.length <= s) {\n return this;\n }\n\n if (r !== 0) {\n s++;\n }\n this.length = Math.min(s, this.length);\n\n if (r !== 0) {\n var mask = 0x3ffffff ^ ((0x3ffffff >>> r) << r);\n this.words[this.length - 1] &= mask;\n }\n\n return this.strip();\n };\n\n // Return only lowers bits of number\n BN.prototype.maskn = function maskn (bits) {\n return this.clone().imaskn(bits);\n };\n\n // Add plain number `num` to `this`\n BN.prototype.iaddn = function iaddn (num) {\n assert(typeof num === 'number');\n assert(num < 0x4000000);\n if (num < 0) return this.isubn(-num);\n\n // Possible sign change\n if (this.negative !== 0) {\n if (this.length === 1 && (this.words[0] | 0) < num) {\n this.words[0] = num - (this.words[0] | 0);\n this.negative = 0;\n return this;\n }\n\n this.negative = 0;\n this.isubn(num);\n this.negative = 1;\n return this;\n }\n\n // Add without checks\n return this._iaddn(num);\n };\n\n BN.prototype._iaddn = function _iaddn (num) {\n this.words[0] += num;\n\n // Carry\n for (var i = 0; i < this.length && this.words[i] >= 0x4000000; i++) {\n this.words[i] -= 0x4000000;\n if (i === this.length - 1) {\n this.words[i + 1] = 1;\n } else {\n this.words[i + 1]++;\n }\n }\n this.length = Math.max(this.length, i + 1);\n\n return this;\n };\n\n // Subtract plain number `num` from `this`\n BN.prototype.isubn = function isubn (num) {\n assert(typeof num === 'number');\n assert(num < 0x4000000);\n if (num < 0) return this.iaddn(-num);\n\n if (this.negative !== 0) {\n this.negative = 0;\n this.iaddn(num);\n this.negative = 1;\n return this;\n }\n\n this.words[0] -= num;\n\n if (this.length === 1 && this.words[0] < 0) {\n this.words[0] = -this.words[0];\n this.negative = 1;\n } else {\n // Carry\n for (var i = 0; i < this.length && this.words[i] < 0; i++) {\n this.words[i] += 0x4000000;\n this.words[i + 1] -= 1;\n }\n }\n\n return this.strip();\n };\n\n BN.prototype.addn = function addn (num) {\n return this.clone().iaddn(num);\n };\n\n BN.prototype.subn = function subn (num) {\n return this.clone().isubn(num);\n };\n\n BN.prototype.iabs = function iabs () {\n this.negative = 0;\n\n return this;\n };\n\n BN.prototype.abs = function abs () {\n return this.clone().iabs();\n };\n\n BN.prototype._ishlnsubmul = function _ishlnsubmul (num, mul, shift) {\n var len = num.length + shift;\n var i;\n\n this._expand(len);\n\n var w;\n var carry = 0;\n for (i = 0; i < num.length; i++) {\n w = (this.words[i + shift] | 0) + carry;\n var right = (num.words[i] | 0) * mul;\n w -= right & 0x3ffffff;\n carry = (w >> 26) - ((right / 0x4000000) | 0);\n this.words[i + shift] = w & 0x3ffffff;\n }\n for (; i < this.length - shift; i++) {\n w = (this.words[i + shift] | 0) + carry;\n carry = w >> 26;\n this.words[i + shift] = w & 0x3ffffff;\n }\n\n if (carry === 0) return this.strip();\n\n // Subtraction overflow\n assert(carry === -1);\n carry = 0;\n for (i = 0; i < this.length; i++) {\n w = -(this.words[i] | 0) + carry;\n carry = w >> 26;\n this.words[i] = w & 0x3ffffff;\n }\n this.negative = 1;\n\n return this.strip();\n };\n\n BN.prototype._wordDiv = function _wordDiv (num, mode) {\n var shift = this.length - num.length;\n\n var a = this.clone();\n var b = num;\n\n // Normalize\n var bhi = b.words[b.length - 1] | 0;\n var bhiBits = this._countBits(bhi);\n shift = 26 - bhiBits;\n if (shift !== 0) {\n b = b.ushln(shift);\n a.iushln(shift);\n bhi = b.words[b.length - 1] | 0;\n }\n\n // Initialize quotient\n var m = a.length - b.length;\n var q;\n\n if (mode !== 'mod') {\n q = new BN(null);\n q.length = m + 1;\n q.words = new Array(q.length);\n for (var i = 0; i < q.length; i++) {\n q.words[i] = 0;\n }\n }\n\n var diff = a.clone()._ishlnsubmul(b, 1, m);\n if (diff.negative === 0) {\n a = diff;\n if (q) {\n q.words[m] = 1;\n }\n }\n\n for (var j = m - 1; j >= 0; j--) {\n var qj = (a.words[b.length + j] | 0) * 0x4000000 +\n (a.words[b.length + j - 1] | 0);\n\n // NOTE: (qj / bhi) is (0x3ffffff * 0x4000000 + 0x3ffffff) / 0x2000000 max\n // (0x7ffffff)\n qj = Math.min((qj / bhi) | 0, 0x3ffffff);\n\n a._ishlnsubmul(b, qj, j);\n while (a.negative !== 0) {\n qj--;\n a.negative = 0;\n a._ishlnsubmul(b, 1, j);\n if (!a.isZero()) {\n a.negative ^= 1;\n }\n }\n if (q) {\n q.words[j] = qj;\n }\n }\n if (q) {\n q.strip();\n }\n a.strip();\n\n // Denormalize\n if (mode !== 'div' && shift !== 0) {\n a.iushrn(shift);\n }\n\n return {\n div: q || null,\n mod: a\n };\n };\n\n // NOTE: 1) `mode` can be set to `mod` to request mod only,\n // to `div` to request div only, or be absent to\n // request both div & mod\n // 2) `positive` is true if unsigned mod is requested\n BN.prototype.divmod = function divmod (num, mode, positive) {\n assert(!num.isZero());\n\n if (this.isZero()) {\n return {\n div: new BN(0),\n mod: new BN(0)\n };\n }\n\n var div, mod, res;\n if (this.negative !== 0 && num.negative === 0) {\n res = this.neg().divmod(num, mode);\n\n if (mode !== 'mod') {\n div = res.div.neg();\n }\n\n if (mode !== 'div') {\n mod = res.mod.neg();\n if (positive && mod.negative !== 0) {\n mod.iadd(num);\n }\n }\n\n return {\n div: div,\n mod: mod\n };\n }\n\n if (this.negative === 0 && num.negative !== 0) {\n res = this.divmod(num.neg(), mode);\n\n if (mode !== 'mod') {\n div = res.div.neg();\n }\n\n return {\n div: div,\n mod: res.mod\n };\n }\n\n if ((this.negative & num.negative) !== 0) {\n res = this.neg().divmod(num.neg(), mode);\n\n if (mode !== 'div') {\n mod = res.mod.neg();\n if (positive && mod.negative !== 0) {\n mod.isub(num);\n }\n }\n\n return {\n div: res.div,\n mod: mod\n };\n }\n\n // Both numbers are positive at this point\n\n // Strip both numbers to approximate shift value\n if (num.length > this.length || this.cmp(num) < 0) {\n return {\n div: new BN(0),\n mod: this\n };\n }\n\n // Very short reduction\n if (num.length === 1) {\n if (mode === 'div') {\n return {\n div: this.divn(num.words[0]),\n mod: null\n };\n }\n\n if (mode === 'mod') {\n return {\n div: null,\n mod: new BN(this.modn(num.words[0]))\n };\n }\n\n return {\n div: this.divn(num.words[0]),\n mod: new BN(this.modn(num.words[0]))\n };\n }\n\n return this._wordDiv(num, mode);\n };\n\n // Find `this` / `num`\n BN.prototype.div = function div (num) {\n return this.divmod(num, 'div', false).div;\n };\n\n // Find `this` % `num`\n BN.prototype.mod = function mod (num) {\n return this.divmod(num, 'mod', false).mod;\n };\n\n BN.prototype.umod = function umod (num) {\n return this.divmod(num, 'mod', true).mod;\n };\n\n // Find Round(`this` / `num`)\n BN.prototype.divRound = function divRound (num) {\n var dm = this.divmod(num);\n\n // Fast case - exact division\n if (dm.mod.isZero()) return dm.div;\n\n var mod = dm.div.negative !== 0 ? dm.mod.isub(num) : dm.mod;\n\n var half = num.ushrn(1);\n var r2 = num.andln(1);\n var cmp = mod.cmp(half);\n\n // Round down\n if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;\n\n // Round up\n return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);\n };\n\n BN.prototype.modn = function modn (num) {\n assert(num <= 0x3ffffff);\n var p = (1 << 26) % num;\n\n var acc = 0;\n for (var i = this.length - 1; i >= 0; i--) {\n acc = (p * acc + (this.words[i] | 0)) % num;\n }\n\n return acc;\n };\n\n // In-place division by number\n BN.prototype.idivn = function idivn (num) {\n assert(num <= 0x3ffffff);\n\n var carry = 0;\n for (var i = this.length - 1; i >= 0; i--) {\n var w = (this.words[i] | 0) + carry * 0x4000000;\n this.words[i] = (w / num) | 0;\n carry = w % num;\n }\n\n return this.strip();\n };\n\n BN.prototype.divn = function divn (num) {\n return this.clone().idivn(num);\n };\n\n BN.prototype.egcd = function egcd (p) {\n assert(p.negative === 0);\n assert(!p.isZero());\n\n var x = this;\n var y = p.clone();\n\n if (x.negative !== 0) {\n x = x.umod(p);\n } else {\n x = x.clone();\n }\n\n // A * x + B * y = x\n var A = new BN(1);\n var B = new BN(0);\n\n // C * x + D * y = y\n var C = new BN(0);\n var D = new BN(1);\n\n var g = 0;\n\n while (x.isEven() && y.isEven()) {\n x.iushrn(1);\n y.iushrn(1);\n ++g;\n }\n\n var yp = y.clone();\n var xp = x.clone();\n\n while (!x.isZero()) {\n for (var i = 0, im = 1; (x.words[0] & im) === 0 && i < 26; ++i, im <<= 1);\n if (i > 0) {\n x.iushrn(i);\n while (i-- > 0) {\n if (A.isOdd() || B.isOdd()) {\n A.iadd(yp);\n B.isub(xp);\n }\n\n A.iushrn(1);\n B.iushrn(1);\n }\n }\n\n for (var j = 0, jm = 1; (y.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);\n if (j > 0) {\n y.iushrn(j);\n while (j-- > 0) {\n if (C.isOdd() || D.isOdd()) {\n C.iadd(yp);\n D.isub(xp);\n }\n\n C.iushrn(1);\n D.iushrn(1);\n }\n }\n\n if (x.cmp(y) >= 0) {\n x.isub(y);\n A.isub(C);\n B.isub(D);\n } else {\n y.isub(x);\n C.isub(A);\n D.isub(B);\n }\n }\n\n return {\n a: C,\n b: D,\n gcd: y.iushln(g)\n };\n };\n\n // This is reduced incarnation of the binary EEA\n // above, designated to invert members of the\n // _prime_ fields F(p) at a maximal speed\n BN.prototype._invmp = function _invmp (p) {\n assert(p.negative === 0);\n assert(!p.isZero());\n\n var a = this;\n var b = p.clone();\n\n if (a.negative !== 0) {\n a = a.umod(p);\n } else {\n a = a.clone();\n }\n\n var x1 = new BN(1);\n var x2 = new BN(0);\n\n var delta = b.clone();\n\n while (a.cmpn(1) > 0 && b.cmpn(1) > 0) {\n for (var i = 0, im = 1; (a.words[0] & im) === 0 && i < 26; ++i, im <<= 1);\n if (i > 0) {\n a.iushrn(i);\n while (i-- > 0) {\n if (x1.isOdd()) {\n x1.iadd(delta);\n }\n\n x1.iushrn(1);\n }\n }\n\n for (var j = 0, jm = 1; (b.words[0] & jm) === 0 && j < 26; ++j, jm <<= 1);\n if (j > 0) {\n b.iushrn(j);\n while (j-- > 0) {\n if (x2.isOdd()) {\n x2.iadd(delta);\n }\n\n x2.iushrn(1);\n }\n }\n\n if (a.cmp(b) >= 0) {\n a.isub(b);\n x1.isub(x2);\n } else {\n b.isub(a);\n x2.isub(x1);\n }\n }\n\n var res;\n if (a.cmpn(1) === 0) {\n res = x1;\n } else {\n res = x2;\n }\n\n if (res.cmpn(0) < 0) {\n res.iadd(p);\n }\n\n return res;\n };\n\n BN.prototype.gcd = function gcd (num) {\n if (this.isZero()) return num.abs();\n if (num.isZero()) return this.abs();\n\n var a = this.clone();\n var b = num.clone();\n a.negative = 0;\n b.negative = 0;\n\n // Remove common factor of two\n for (var shift = 0; a.isEven() && b.isEven(); shift++) {\n a.iushrn(1);\n b.iushrn(1);\n }\n\n do {\n while (a.isEven()) {\n a.iushrn(1);\n }\n while (b.isEven()) {\n b.iushrn(1);\n }\n\n var r = a.cmp(b);\n if (r < 0) {\n // Swap `a` and `b` to make `a` always bigger than `b`\n var t = a;\n a = b;\n b = t;\n } else if (r === 0 || b.cmpn(1) === 0) {\n break;\n }\n\n a.isub(b);\n } while (true);\n\n return b.iushln(shift);\n };\n\n // Invert number in the field F(num)\n BN.prototype.invm = function invm (num) {\n return this.egcd(num).a.umod(num);\n };\n\n BN.prototype.isEven = function isEven () {\n return (this.words[0] & 1) === 0;\n };\n\n BN.prototype.isOdd = function isOdd () {\n return (this.words[0] & 1) === 1;\n };\n\n // And first word and num\n BN.prototype.andln = function andln (num) {\n return this.words[0] & num;\n };\n\n // Increment at the bit position in-line\n BN.prototype.bincn = function bincn (bit) {\n assert(typeof bit === 'number');\n var r = bit % 26;\n var s = (bit - r) / 26;\n var q = 1 << r;\n\n // Fast case: bit is much higher than all existing words\n if (this.length <= s) {\n this._expand(s + 1);\n this.words[s] |= q;\n return this;\n }\n\n // Add bit and propagate, if needed\n var carry = q;\n for (var i = s; carry !== 0 && i < this.length; i++) {\n var w = this.words[i] | 0;\n w += carry;\n carry = w >>> 26;\n w &= 0x3ffffff;\n this.words[i] = w;\n }\n if (carry !== 0) {\n this.words[i] = carry;\n this.length++;\n }\n return this;\n };\n\n BN.prototype.isZero = function isZero () {\n return this.length === 1 && this.words[0] === 0;\n };\n\n BN.prototype.cmpn = function cmpn (num) {\n var negative = num < 0;\n\n if (this.negative !== 0 && !negative) return -1;\n if (this.negative === 0 && negative) return 1;\n\n this.strip();\n\n var res;\n if (this.length > 1) {\n res = 1;\n } else {\n if (negative) {\n num = -num;\n }\n\n assert(num <= 0x3ffffff, 'Number is too big');\n\n var w = this.words[0] | 0;\n res = w === num ? 0 : w < num ? -1 : 1;\n }\n if (this.negative !== 0) return -res | 0;\n return res;\n };\n\n // Compare two numbers and return:\n // 1 - if `this` > `num`\n // 0 - if `this` == `num`\n // -1 - if `this` < `num`\n BN.prototype.cmp = function cmp (num) {\n if (this.negative !== 0 && num.negative === 0) return -1;\n if (this.negative === 0 && num.negative !== 0) return 1;\n\n var res = this.ucmp(num);\n if (this.negative !== 0) return -res | 0;\n return res;\n };\n\n // Unsigned comparison\n BN.prototype.ucmp = function ucmp (num) {\n // At this point both numbers have the same sign\n if (this.length > num.length) return 1;\n if (this.length < num.length) return -1;\n\n var res = 0;\n for (var i = this.length - 1; i >= 0; i--) {\n var a = this.words[i] | 0;\n var b = num.words[i] | 0;\n\n if (a === b) continue;\n if (a < b) {\n res = -1;\n } else if (a > b) {\n res = 1;\n }\n break;\n }\n return res;\n };\n\n BN.prototype.gtn = function gtn (num) {\n return this.cmpn(num) === 1;\n };\n\n BN.prototype.gt = function gt (num) {\n return this.cmp(num) === 1;\n };\n\n BN.prototype.gten = function gten (num) {\n return this.cmpn(num) >= 0;\n };\n\n BN.prototype.gte = function gte (num) {\n return this.cmp(num) >= 0;\n };\n\n BN.prototype.ltn = function ltn (num) {\n return this.cmpn(num) === -1;\n };\n\n BN.prototype.lt = function lt (num) {\n return this.cmp(num) === -1;\n };\n\n BN.prototype.lten = function lten (num) {\n return this.cmpn(num) <= 0;\n };\n\n BN.prototype.lte = function lte (num) {\n return this.cmp(num) <= 0;\n };\n\n BN.prototype.eqn = function eqn (num) {\n return this.cmpn(num) === 0;\n };\n\n BN.prototype.eq = function eq (num) {\n return this.cmp(num) === 0;\n };\n\n //\n // A reduce context, could be using montgomery or something better, depending\n // on the `m` itself.\n //\n BN.red = function red (num) {\n return new Red(num);\n };\n\n BN.prototype.toRed = function toRed (ctx) {\n assert(!this.red, 'Already a number in reduction context');\n assert(this.negative === 0, 'red works only with positives');\n return ctx.convertTo(this)._forceRed(ctx);\n };\n\n BN.prototype.fromRed = function fromRed () {\n assert(this.red, 'fromRed works only with numbers in reduction context');\n return this.red.convertFrom(this);\n };\n\n BN.prototype._forceRed = function _forceRed (ctx) {\n this.red = ctx;\n return this;\n };\n\n BN.prototype.forceRed = function forceRed (ctx) {\n assert(!this.red, 'Already a number in reduction context');\n return this._forceRed(ctx);\n };\n\n BN.prototype.redAdd = function redAdd (num) {\n assert(this.red, 'redAdd works only with red numbers');\n return this.red.add(this, num);\n };\n\n BN.prototype.redIAdd = function redIAdd (num) {\n assert(this.red, 'redIAdd works only with red numbers');\n return this.red.iadd(this, num);\n };\n\n BN.prototype.redSub = function redSub (num) {\n assert(this.red, 'redSub works only with red numbers');\n return this.red.sub(this, num);\n };\n\n BN.prototype.redISub = function redISub (num) {\n assert(this.red, 'redISub works only with red numbers');\n return this.red.isub(this, num);\n };\n\n BN.prototype.redShl = function redShl (num) {\n assert(this.red, 'redShl works only with red numbers');\n return this.red.shl(this, num);\n };\n\n BN.prototype.redMul = function redMul (num) {\n assert(this.red, 'redMul works only with red numbers');\n this.red._verify2(this, num);\n return this.red.mul(this, num);\n };\n\n BN.prototype.redIMul = function redIMul (num) {\n assert(this.red, 'redMul works only with red numbers');\n this.red._verify2(this, num);\n return this.red.imul(this, num);\n };\n\n BN.prototype.redSqr = function redSqr () {\n assert(this.red, 'redSqr works only with red numbers');\n this.red._verify1(this);\n return this.red.sqr(this);\n };\n\n BN.prototype.redISqr = function redISqr () {\n assert(this.red, 'redISqr works only with red numbers');\n this.red._verify1(this);\n return this.red.isqr(this);\n };\n\n // Square root over p\n BN.prototype.redSqrt = function redSqrt () {\n assert(this.red, 'redSqrt works only with red numbers');\n this.red._verify1(this);\n return this.red.sqrt(this);\n };\n\n BN.prototype.redInvm = function redInvm () {\n assert(this.red, 'redInvm works only with red numbers');\n this.red._verify1(this);\n return this.red.invm(this);\n };\n\n // Return negative clone of `this` % `red modulo`\n BN.prototype.redNeg = function redNeg () {\n assert(this.red, 'redNeg works only with red numbers');\n this.red._verify1(this);\n return this.red.neg(this);\n };\n\n BN.prototype.redPow = function redPow (num) {\n assert(this.red && !num.red, 'redPow(normalNum)');\n this.red._verify1(this);\n return this.red.pow(this, num);\n };\n\n // Prime numbers with efficient reduction\n var primes = {\n k256: null,\n p224: null,\n p192: null,\n p25519: null\n };\n\n // Pseudo-Mersenne prime\n function MPrime (name, p) {\n // P = 2 ^ N - K\n this.name = name;\n this.p = new BN(p, 16);\n this.n = this.p.bitLength();\n this.k = new BN(1).iushln(this.n).isub(this.p);\n\n this.tmp = this._tmp();\n }\n\n MPrime.prototype._tmp = function _tmp () {\n var tmp = new BN(null);\n tmp.words = new Array(Math.ceil(this.n / 13));\n return tmp;\n };\n\n MPrime.prototype.ireduce = function ireduce (num) {\n // Assumes that `num` is less than `P^2`\n // num = HI * (2 ^ N - K) + HI * K + LO = HI * K + LO (mod P)\n var r = num;\n var rlen;\n\n do {\n this.split(r, this.tmp);\n r = this.imulK(r);\n r = r.iadd(this.tmp);\n rlen = r.bitLength();\n } while (rlen > this.n);\n\n var cmp = rlen < this.n ? -1 : r.ucmp(this.p);\n if (cmp === 0) {\n r.words[0] = 0;\n r.length = 1;\n } else if (cmp > 0) {\n r.isub(this.p);\n } else {\n if (r.strip !== undefined) {\n // r is BN v4 instance\n r.strip();\n } else {\n // r is BN v5 instance\n r._strip();\n }\n }\n\n return r;\n };\n\n MPrime.prototype.split = function split (input, out) {\n input.iushrn(this.n, 0, out);\n };\n\n MPrime.prototype.imulK = function imulK (num) {\n return num.imul(this.k);\n };\n\n function K256 () {\n MPrime.call(\n this,\n 'k256',\n 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f');\n }\n inherits(K256, MPrime);\n\n K256.prototype.split = function split (input, output) {\n // 256 = 9 * 26 + 22\n var mask = 0x3fffff;\n\n var outLen = Math.min(input.length, 9);\n for (var i = 0; i < outLen; i++) {\n output.words[i] = input.words[i];\n }\n output.length = outLen;\n\n if (input.length <= 9) {\n input.words[0] = 0;\n input.length = 1;\n return;\n }\n\n // Shift by 9 limbs\n var prev = input.words[9];\n output.words[output.length++] = prev & mask;\n\n for (i = 10; i < input.length; i++) {\n var next = input.words[i] | 0;\n input.words[i - 10] = ((next & mask) << 4) | (prev >>> 22);\n prev = next;\n }\n prev >>>= 22;\n input.words[i - 10] = prev;\n if (prev === 0 && input.length > 10) {\n input.length -= 10;\n } else {\n input.length -= 9;\n }\n };\n\n K256.prototype.imulK = function imulK (num) {\n // K = 0x1000003d1 = [ 0x40, 0x3d1 ]\n num.words[num.length] = 0;\n num.words[num.length + 1] = 0;\n num.length += 2;\n\n // bounded at: 0x40 * 0x3ffffff + 0x3d0 = 0x100000390\n var lo = 0;\n for (var i = 0; i < num.length; i++) {\n var w = num.words[i] | 0;\n lo += w * 0x3d1;\n num.words[i] = lo & 0x3ffffff;\n lo = w * 0x40 + ((lo / 0x4000000) | 0);\n }\n\n // Fast length reduction\n if (num.words[num.length - 1] === 0) {\n num.length--;\n if (num.words[num.length - 1] === 0) {\n num.length--;\n }\n }\n return num;\n };\n\n function P224 () {\n MPrime.call(\n this,\n 'p224',\n 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001');\n }\n inherits(P224, MPrime);\n\n function P192 () {\n MPrime.call(\n this,\n 'p192',\n 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff');\n }\n inherits(P192, MPrime);\n\n function P25519 () {\n // 2 ^ 255 - 19\n MPrime.call(\n this,\n '25519',\n '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed');\n }\n inherits(P25519, MPrime);\n\n P25519.prototype.imulK = function imulK (num) {\n // K = 0x13\n var carry = 0;\n for (var i = 0; i < num.length; i++) {\n var hi = (num.words[i] | 0) * 0x13 + carry;\n var lo = hi & 0x3ffffff;\n hi >>>= 26;\n\n num.words[i] = lo;\n carry = hi;\n }\n if (carry !== 0) {\n num.words[num.length++] = carry;\n }\n return num;\n };\n\n // Exported mostly for testing purposes, use plain name instead\n BN._prime = function prime (name) {\n // Cached version of prime\n if (primes[name]) return primes[name];\n\n var prime;\n if (name === 'k256') {\n prime = new K256();\n } else if (name === 'p224') {\n prime = new P224();\n } else if (name === 'p192') {\n prime = new P192();\n } else if (name === 'p25519') {\n prime = new P25519();\n } else {\n throw new Error('Unknown prime ' + name);\n }\n primes[name] = prime;\n\n return prime;\n };\n\n //\n // Base reduction engine\n //\n function Red (m) {\n if (typeof m === 'string') {\n var prime = BN._prime(m);\n this.m = prime.p;\n this.prime = prime;\n } else {\n assert(m.gtn(1), 'modulus must be greater than 1');\n this.m = m;\n this.prime = null;\n }\n }\n\n Red.prototype._verify1 = function _verify1 (a) {\n assert(a.negative === 0, 'red works only with positives');\n assert(a.red, 'red works only with red numbers');\n };\n\n Red.prototype._verify2 = function _verify2 (a, b) {\n assert((a.negative | b.negative) === 0, 'red works only with positives');\n assert(a.red && a.red === b.red,\n 'red works only with red numbers');\n };\n\n Red.prototype.imod = function imod (a) {\n if (this.prime) return this.prime.ireduce(a)._forceRed(this);\n return a.umod(this.m)._forceRed(this);\n };\n\n Red.prototype.neg = function neg (a) {\n if (a.isZero()) {\n return a.clone();\n }\n\n return this.m.sub(a)._forceRed(this);\n };\n\n Red.prototype.add = function add (a, b) {\n this._verify2(a, b);\n\n var res = a.add(b);\n if (res.cmp(this.m) >= 0) {\n res.isub(this.m);\n }\n return res._forceRed(this);\n };\n\n Red.prototype.iadd = function iadd (a, b) {\n this._verify2(a, b);\n\n var res = a.iadd(b);\n if (res.cmp(this.m) >= 0) {\n res.isub(this.m);\n }\n return res;\n };\n\n Red.prototype.sub = function sub (a, b) {\n this._verify2(a, b);\n\n var res = a.sub(b);\n if (res.cmpn(0) < 0) {\n res.iadd(this.m);\n }\n return res._forceRed(this);\n };\n\n Red.prototype.isub = function isub (a, b) {\n this._verify2(a, b);\n\n var res = a.isub(b);\n if (res.cmpn(0) < 0) {\n res.iadd(this.m);\n }\n return res;\n };\n\n Red.prototype.shl = function shl (a, num) {\n this._verify1(a);\n return this.imod(a.ushln(num));\n };\n\n Red.prototype.imul = function imul (a, b) {\n this._verify2(a, b);\n return this.imod(a.imul(b));\n };\n\n Red.prototype.mul = function mul (a, b) {\n this._verify2(a, b);\n return this.imod(a.mul(b));\n };\n\n Red.prototype.isqr = function isqr (a) {\n return this.imul(a, a.clone());\n };\n\n Red.prototype.sqr = function sqr (a) {\n return this.mul(a, a);\n };\n\n Red.prototype.sqrt = function sqrt (a) {\n if (a.isZero()) return a.clone();\n\n var mod3 = this.m.andln(3);\n assert(mod3 % 2 === 1);\n\n // Fast case\n if (mod3 === 3) {\n var pow = this.m.add(new BN(1)).iushrn(2);\n return this.pow(a, pow);\n }\n\n // Tonelli-Shanks algorithm (Totally unoptimized and slow)\n //\n // Find Q and S, that Q * 2 ^ S = (P - 1)\n var q = this.m.subn(1);\n var s = 0;\n while (!q.isZero() && q.andln(1) === 0) {\n s++;\n q.iushrn(1);\n }\n assert(!q.isZero());\n\n var one = new BN(1).toRed(this);\n var nOne = one.redNeg();\n\n // Find quadratic non-residue\n // NOTE: Max is such because of generalized Riemann hypothesis.\n var lpow = this.m.subn(1).iushrn(1);\n var z = this.m.bitLength();\n z = new BN(2 * z * z).toRed(this);\n\n while (this.pow(z, lpow).cmp(nOne) !== 0) {\n z.redIAdd(nOne);\n }\n\n var c = this.pow(z, q);\n var r = this.pow(a, q.addn(1).iushrn(1));\n var t = this.pow(a, q);\n var m = s;\n while (t.cmp(one) !== 0) {\n var tmp = t;\n for (var i = 0; tmp.cmp(one) !== 0; i++) {\n tmp = tmp.redSqr();\n }\n assert(i < m);\n var b = this.pow(c, new BN(1).iushln(m - i - 1));\n\n r = r.redMul(b);\n c = b.redSqr();\n t = t.redMul(c);\n m = i;\n }\n\n return r;\n };\n\n Red.prototype.invm = function invm (a) {\n var inv = a._invmp(this.m);\n if (inv.negative !== 0) {\n inv.negative = 0;\n return this.imod(inv).redNeg();\n } else {\n return this.imod(inv);\n }\n };\n\n Red.prototype.pow = function pow (a, num) {\n if (num.isZero()) return new BN(1).toRed(this);\n if (num.cmpn(1) === 0) return a.clone();\n\n var windowSize = 4;\n var wnd = new Array(1 << windowSize);\n wnd[0] = new BN(1).toRed(this);\n wnd[1] = a;\n for (var i = 2; i < wnd.length; i++) {\n wnd[i] = this.mul(wnd[i - 1], a);\n }\n\n var res = wnd[0];\n var current = 0;\n var currentLen = 0;\n var start = num.bitLength() % 26;\n if (start === 0) {\n start = 26;\n }\n\n for (i = num.length - 1; i >= 0; i--) {\n var word = num.words[i];\n for (var j = start - 1; j >= 0; j--) {\n var bit = (word >> j) & 1;\n if (res !== wnd[0]) {\n res = this.sqr(res);\n }\n\n if (bit === 0 && current === 0) {\n currentLen = 0;\n continue;\n }\n\n current <<= 1;\n current |= bit;\n currentLen++;\n if (currentLen !== windowSize && (i !== 0 || j !== 0)) continue;\n\n res = this.mul(res, wnd[current]);\n currentLen = 0;\n current = 0;\n }\n start = 26;\n }\n\n return res;\n };\n\n Red.prototype.convertTo = function convertTo (num) {\n var r = num.umod(this.m);\n\n return r === num ? r.clone() : r;\n };\n\n Red.prototype.convertFrom = function convertFrom (num) {\n var res = num.clone();\n res.red = null;\n return res;\n };\n\n //\n // Montgomery method engine\n //\n\n BN.mont = function mont (num) {\n return new Mont(num);\n };\n\n function Mont (m) {\n Red.call(this, m);\n\n this.shift = this.m.bitLength();\n if (this.shift % 26 !== 0) {\n this.shift += 26 - (this.shift % 26);\n }\n\n this.r = new BN(1).iushln(this.shift);\n this.r2 = this.imod(this.r.sqr());\n this.rinv = this.r._invmp(this.m);\n\n this.minv = this.rinv.mul(this.r).isubn(1).div(this.m);\n this.minv = this.minv.umod(this.r);\n this.minv = this.r.sub(this.minv);\n }\n inherits(Mont, Red);\n\n Mont.prototype.convertTo = function convertTo (num) {\n return this.imod(num.ushln(this.shift));\n };\n\n Mont.prototype.convertFrom = function convertFrom (num) {\n var r = this.imod(num.mul(this.rinv));\n r.red = null;\n return r;\n };\n\n Mont.prototype.imul = function imul (a, b) {\n if (a.isZero() || b.isZero()) {\n a.words[0] = 0;\n a.length = 1;\n return a;\n }\n\n var t = a.imul(b);\n var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);\n var u = t.isub(c).iushrn(this.shift);\n var res = u;\n\n if (u.cmp(this.m) >= 0) {\n res = u.isub(this.m);\n } else if (u.cmpn(0) < 0) {\n res = u.iadd(this.m);\n }\n\n return res._forceRed(this);\n };\n\n Mont.prototype.mul = function mul (a, b) {\n if (a.isZero() || b.isZero()) return new BN(0)._forceRed(this);\n\n var t = a.mul(b);\n var c = t.maskn(this.shift).mul(this.minv).imaskn(this.shift).mul(this.m);\n var u = t.isub(c).iushrn(this.shift);\n var res = u;\n if (u.cmp(this.m) >= 0) {\n res = u.isub(this.m);\n } else if (u.cmpn(0) < 0) {\n res = u.iadd(this.m);\n }\n\n return res._forceRed(this);\n };\n\n Mont.prototype.invm = function invm (a) {\n // (AR)^-1 * R^2 = (A^-1 * R^-1) * R^2 = A^-1 * R\n var res = this.imod(a._invmp(this.m).mul(this.r2));\n return res._forceRed(this);\n };\n})(typeof module === 'undefined' || module, this);\n","'use strict';\n\nvar elliptic = exports;\n\nelliptic.version = require('../package.json').version;\nelliptic.utils = require('./elliptic/utils');\nelliptic.rand = require('brorand');\nelliptic.curve = require('./elliptic/curve');\nelliptic.curves = require('./elliptic/curves');\n\n// Protocols\nelliptic.ec = require('./elliptic/ec');\nelliptic.eddsa = require('./elliptic/eddsa');\n","'use strict';\n\nvar BN = require('bn.js');\nvar utils = require('../utils');\nvar getNAF = utils.getNAF;\nvar getJSF = utils.getJSF;\nvar assert = utils.assert;\n\nfunction BaseCurve(type, conf) {\n this.type = type;\n this.p = new BN(conf.p, 16);\n\n // Use Montgomery, when there is no fast reduction for the prime\n this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p);\n\n // Useful for many curves\n this.zero = new BN(0).toRed(this.red);\n this.one = new BN(1).toRed(this.red);\n this.two = new BN(2).toRed(this.red);\n\n // Curve configuration, optional\n this.n = conf.n && new BN(conf.n, 16);\n this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed);\n\n // Temporary arrays\n this._wnafT1 = new Array(4);\n this._wnafT2 = new Array(4);\n this._wnafT3 = new Array(4);\n this._wnafT4 = new Array(4);\n\n this._bitLength = this.n ? this.n.bitLength() : 0;\n\n // Generalized Greg Maxwell's trick\n var adjustCount = this.n && this.p.div(this.n);\n if (!adjustCount || adjustCount.cmpn(100) > 0) {\n this.redN = null;\n } else {\n this._maxwellTrick = true;\n this.redN = this.n.toRed(this.red);\n }\n}\nmodule.exports = BaseCurve;\n\nBaseCurve.prototype.point = function point() {\n throw new Error('Not implemented');\n};\n\nBaseCurve.prototype.validate = function validate() {\n throw new Error('Not implemented');\n};\n\nBaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {\n assert(p.precomputed);\n var doubles = p._getDoubles();\n\n var naf = getNAF(k, 1, this._bitLength);\n var I = (1 << (doubles.step + 1)) - (doubles.step % 2 === 0 ? 2 : 1);\n I /= 3;\n\n // Translate into more windowed form\n var repr = [];\n var j;\n var nafW;\n for (j = 0; j < naf.length; j += doubles.step) {\n nafW = 0;\n for (var l = j + doubles.step - 1; l >= j; l--)\n nafW = (nafW << 1) + naf[l];\n repr.push(nafW);\n }\n\n var a = this.jpoint(null, null, null);\n var b = this.jpoint(null, null, null);\n for (var i = I; i > 0; i--) {\n for (j = 0; j < repr.length; j++) {\n nafW = repr[j];\n if (nafW === i)\n b = b.mixedAdd(doubles.points[j]);\n else if (nafW === -i)\n b = b.mixedAdd(doubles.points[j].neg());\n }\n a = a.add(b);\n }\n return a.toP();\n};\n\nBaseCurve.prototype._wnafMul = function _wnafMul(p, k) {\n var w = 4;\n\n // Precompute window\n var nafPoints = p._getNAFPoints(w);\n w = nafPoints.wnd;\n var wnd = nafPoints.points;\n\n // Get NAF form\n var naf = getNAF(k, w, this._bitLength);\n\n // Add `this`*(N+1) for every w-NAF index\n var acc = this.jpoint(null, null, null);\n for (var i = naf.length - 1; i >= 0; i--) {\n // Count zeroes\n for (var l = 0; i >= 0 && naf[i] === 0; i--)\n l++;\n if (i >= 0)\n l++;\n acc = acc.dblp(l);\n\n if (i < 0)\n break;\n var z = naf[i];\n assert(z !== 0);\n if (p.type === 'affine') {\n // J +- P\n if (z > 0)\n acc = acc.mixedAdd(wnd[(z - 1) >> 1]);\n else\n acc = acc.mixedAdd(wnd[(-z - 1) >> 1].neg());\n } else {\n // J +- J\n if (z > 0)\n acc = acc.add(wnd[(z - 1) >> 1]);\n else\n acc = acc.add(wnd[(-z - 1) >> 1].neg());\n }\n }\n return p.type === 'affine' ? acc.toP() : acc;\n};\n\nBaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW,\n points,\n coeffs,\n len,\n jacobianResult) {\n var wndWidth = this._wnafT1;\n var wnd = this._wnafT2;\n var naf = this._wnafT3;\n\n // Fill all arrays\n var max = 0;\n var i;\n var j;\n var p;\n for (i = 0; i < len; i++) {\n p = points[i];\n var nafPoints = p._getNAFPoints(defW);\n wndWidth[i] = nafPoints.wnd;\n wnd[i] = nafPoints.points;\n }\n\n // Comb small window NAFs\n for (i = len - 1; i >= 1; i -= 2) {\n var a = i - 1;\n var b = i;\n if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {\n naf[a] = getNAF(coeffs[a], wndWidth[a], this._bitLength);\n naf[b] = getNAF(coeffs[b], wndWidth[b], this._bitLength);\n max = Math.max(naf[a].length, max);\n max = Math.max(naf[b].length, max);\n continue;\n }\n\n var comb = [\n points[a], /* 1 */\n null, /* 3 */\n null, /* 5 */\n points[b], /* 7 */\n ];\n\n // Try to avoid Projective points, if possible\n if (points[a].y.cmp(points[b].y) === 0) {\n comb[1] = points[a].add(points[b]);\n comb[2] = points[a].toJ().mixedAdd(points[b].neg());\n } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {\n comb[1] = points[a].toJ().mixedAdd(points[b]);\n comb[2] = points[a].add(points[b].neg());\n } else {\n comb[1] = points[a].toJ().mixedAdd(points[b]);\n comb[2] = points[a].toJ().mixedAdd(points[b].neg());\n }\n\n var index = [\n -3, /* -1 -1 */\n -1, /* -1 0 */\n -5, /* -1 1 */\n -7, /* 0 -1 */\n 0, /* 0 0 */\n 7, /* 0 1 */\n 5, /* 1 -1 */\n 1, /* 1 0 */\n 3, /* 1 1 */\n ];\n\n var jsf = getJSF(coeffs[a], coeffs[b]);\n max = Math.max(jsf[0].length, max);\n naf[a] = new Array(max);\n naf[b] = new Array(max);\n for (j = 0; j < max; j++) {\n var ja = jsf[0][j] | 0;\n var jb = jsf[1][j] | 0;\n\n naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];\n naf[b][j] = 0;\n wnd[a] = comb;\n }\n }\n\n var acc = this.jpoint(null, null, null);\n var tmp = this._wnafT4;\n for (i = max; i >= 0; i--) {\n var k = 0;\n\n while (i >= 0) {\n var zero = true;\n for (j = 0; j < len; j++) {\n tmp[j] = naf[j][i] | 0;\n if (tmp[j] !== 0)\n zero = false;\n }\n if (!zero)\n break;\n k++;\n i--;\n }\n if (i >= 0)\n k++;\n acc = acc.dblp(k);\n if (i < 0)\n break;\n\n for (j = 0; j < len; j++) {\n var z = tmp[j];\n p;\n if (z === 0)\n continue;\n else if (z > 0)\n p = wnd[j][(z - 1) >> 1];\n else if (z < 0)\n p = wnd[j][(-z - 1) >> 1].neg();\n\n if (p.type === 'affine')\n acc = acc.mixedAdd(p);\n else\n acc = acc.add(p);\n }\n }\n // Zeroify references\n for (i = 0; i < len; i++)\n wnd[i] = null;\n\n if (jacobianResult)\n return acc;\n else\n return acc.toP();\n};\n\nfunction BasePoint(curve, type) {\n this.curve = curve;\n this.type = type;\n this.precomputed = null;\n}\nBaseCurve.BasePoint = BasePoint;\n\nBasePoint.prototype.eq = function eq(/*other*/) {\n throw new Error('Not implemented');\n};\n\nBasePoint.prototype.validate = function validate() {\n return this.curve.validate(this);\n};\n\nBaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {\n bytes = utils.toArray(bytes, enc);\n\n var len = this.p.byteLength();\n\n // uncompressed, hybrid-odd, hybrid-even\n if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) &&\n bytes.length - 1 === 2 * len) {\n if (bytes[0] === 0x06)\n assert(bytes[bytes.length - 1] % 2 === 0);\n else if (bytes[0] === 0x07)\n assert(bytes[bytes.length - 1] % 2 === 1);\n\n var res = this.point(bytes.slice(1, 1 + len),\n bytes.slice(1 + len, 1 + 2 * len));\n\n return res;\n } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) &&\n bytes.length - 1 === len) {\n return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 0x03);\n }\n throw new Error('Unknown point format');\n};\n\nBasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {\n return this.encode(enc, true);\n};\n\nBasePoint.prototype._encode = function _encode(compact) {\n var len = this.curve.p.byteLength();\n var x = this.getX().toArray('be', len);\n\n if (compact)\n return [ this.getY().isEven() ? 0x02 : 0x03 ].concat(x);\n\n return [ 0x04 ].concat(x, this.getY().toArray('be', len));\n};\n\nBasePoint.prototype.encode = function encode(enc, compact) {\n return utils.encode(this._encode(compact), enc);\n};\n\nBasePoint.prototype.precompute = function precompute(power) {\n if (this.precomputed)\n return this;\n\n var precomputed = {\n doubles: null,\n naf: null,\n beta: null,\n };\n precomputed.naf = this._getNAFPoints(8);\n precomputed.doubles = this._getDoubles(4, power);\n precomputed.beta = this._getBeta();\n this.precomputed = precomputed;\n\n return this;\n};\n\nBasePoint.prototype._hasDoubles = function _hasDoubles(k) {\n if (!this.precomputed)\n return false;\n\n var doubles = this.precomputed.doubles;\n if (!doubles)\n return false;\n\n return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step);\n};\n\nBasePoint.prototype._getDoubles = function _getDoubles(step, power) {\n if (this.precomputed && this.precomputed.doubles)\n return this.precomputed.doubles;\n\n var doubles = [ this ];\n var acc = this;\n for (var i = 0; i < power; i += step) {\n for (var j = 0; j < step; j++)\n acc = acc.dbl();\n doubles.push(acc);\n }\n return {\n step: step,\n points: doubles,\n };\n};\n\nBasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) {\n if (this.precomputed && this.precomputed.naf)\n return this.precomputed.naf;\n\n var res = [ this ];\n var max = (1 << wnd) - 1;\n var dbl = max === 1 ? null : this.dbl();\n for (var i = 1; i < max; i++)\n res[i] = res[i - 1].add(dbl);\n return {\n wnd: wnd,\n points: res,\n };\n};\n\nBasePoint.prototype._getBeta = function _getBeta() {\n return null;\n};\n\nBasePoint.prototype.dblp = function dblp(k) {\n var r = this;\n for (var i = 0; i < k; i++)\n r = r.dbl();\n return r;\n};\n","'use strict';\n\nvar utils = require('../utils');\nvar BN = require('bn.js');\nvar inherits = require('inherits');\nvar Base = require('./base');\n\nvar assert = utils.assert;\n\nfunction EdwardsCurve(conf) {\n // NOTE: Important as we are creating point in Base.call()\n this.twisted = (conf.a | 0) !== 1;\n this.mOneA = this.twisted && (conf.a | 0) === -1;\n this.extended = this.mOneA;\n\n Base.call(this, 'edwards', conf);\n\n this.a = new BN(conf.a, 16).umod(this.red.m);\n this.a = this.a.toRed(this.red);\n this.c = new BN(conf.c, 16).toRed(this.red);\n this.c2 = this.c.redSqr();\n this.d = new BN(conf.d, 16).toRed(this.red);\n this.dd = this.d.redAdd(this.d);\n\n assert(!this.twisted || this.c.fromRed().cmpn(1) === 0);\n this.oneC = (conf.c | 0) === 1;\n}\ninherits(EdwardsCurve, Base);\nmodule.exports = EdwardsCurve;\n\nEdwardsCurve.prototype._mulA = function _mulA(num) {\n if (this.mOneA)\n return num.redNeg();\n else\n return this.a.redMul(num);\n};\n\nEdwardsCurve.prototype._mulC = function _mulC(num) {\n if (this.oneC)\n return num;\n else\n return this.c.redMul(num);\n};\n\n// Just for compatibility with Short curve\nEdwardsCurve.prototype.jpoint = function jpoint(x, y, z, t) {\n return this.point(x, y, z, t);\n};\n\nEdwardsCurve.prototype.pointFromX = function pointFromX(x, odd) {\n x = new BN(x, 16);\n if (!x.red)\n x = x.toRed(this.red);\n\n var x2 = x.redSqr();\n var rhs = this.c2.redSub(this.a.redMul(x2));\n var lhs = this.one.redSub(this.c2.redMul(this.d).redMul(x2));\n\n var y2 = rhs.redMul(lhs.redInvm());\n var y = y2.redSqrt();\n if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)\n throw new Error('invalid point');\n\n var isOdd = y.fromRed().isOdd();\n if (odd && !isOdd || !odd && isOdd)\n y = y.redNeg();\n\n return this.point(x, y);\n};\n\nEdwardsCurve.prototype.pointFromY = function pointFromY(y, odd) {\n y = new BN(y, 16);\n if (!y.red)\n y = y.toRed(this.red);\n\n // x^2 = (y^2 - c^2) / (c^2 d y^2 - a)\n var y2 = y.redSqr();\n var lhs = y2.redSub(this.c2);\n var rhs = y2.redMul(this.d).redMul(this.c2).redSub(this.a);\n var x2 = lhs.redMul(rhs.redInvm());\n\n if (x2.cmp(this.zero) === 0) {\n if (odd)\n throw new Error('invalid point');\n else\n return this.point(this.zero, y);\n }\n\n var x = x2.redSqrt();\n if (x.redSqr().redSub(x2).cmp(this.zero) !== 0)\n throw new Error('invalid point');\n\n if (x.fromRed().isOdd() !== odd)\n x = x.redNeg();\n\n return this.point(x, y);\n};\n\nEdwardsCurve.prototype.validate = function validate(point) {\n if (point.isInfinity())\n return true;\n\n // Curve: A * X^2 + Y^2 = C^2 * (1 + D * X^2 * Y^2)\n point.normalize();\n\n var x2 = point.x.redSqr();\n var y2 = point.y.redSqr();\n var lhs = x2.redMul(this.a).redAdd(y2);\n var rhs = this.c2.redMul(this.one.redAdd(this.d.redMul(x2).redMul(y2)));\n\n return lhs.cmp(rhs) === 0;\n};\n\nfunction Point(curve, x, y, z, t) {\n Base.BasePoint.call(this, curve, 'projective');\n if (x === null && y === null && z === null) {\n this.x = this.curve.zero;\n this.y = this.curve.one;\n this.z = this.curve.one;\n this.t = this.curve.zero;\n this.zOne = true;\n } else {\n this.x = new BN(x, 16);\n this.y = new BN(y, 16);\n this.z = z ? new BN(z, 16) : this.curve.one;\n this.t = t && new BN(t, 16);\n if (!this.x.red)\n this.x = this.x.toRed(this.curve.red);\n if (!this.y.red)\n this.y = this.y.toRed(this.curve.red);\n if (!this.z.red)\n this.z = this.z.toRed(this.curve.red);\n if (this.t && !this.t.red)\n this.t = this.t.toRed(this.curve.red);\n this.zOne = this.z === this.curve.one;\n\n // Use extended coordinates\n if (this.curve.extended && !this.t) {\n this.t = this.x.redMul(this.y);\n if (!this.zOne)\n this.t = this.t.redMul(this.z.redInvm());\n }\n }\n}\ninherits(Point, Base.BasePoint);\n\nEdwardsCurve.prototype.pointFromJSON = function pointFromJSON(obj) {\n return Point.fromJSON(this, obj);\n};\n\nEdwardsCurve.prototype.point = function point(x, y, z, t) {\n return new Point(this, x, y, z, t);\n};\n\nPoint.fromJSON = function fromJSON(curve, obj) {\n return new Point(curve, obj[0], obj[1], obj[2]);\n};\n\nPoint.prototype.inspect = function inspect() {\n if (this.isInfinity())\n return '<EC Point Infinity>';\n return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +\n ' y: ' + this.y.fromRed().toString(16, 2) +\n ' z: ' + this.z.fromRed().toString(16, 2) + '>';\n};\n\nPoint.prototype.isInfinity = function isInfinity() {\n // XXX This code assumes that zero is always zero in red\n return this.x.cmpn(0) === 0 &&\n (this.y.cmp(this.z) === 0 ||\n (this.zOne && this.y.cmp(this.curve.c) === 0));\n};\n\nPoint.prototype._extDbl = function _extDbl() {\n // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html\n // #doubling-dbl-2008-hwcd\n // 4M + 4S\n\n // A = X1^2\n var a = this.x.redSqr();\n // B = Y1^2\n var b = this.y.redSqr();\n // C = 2 * Z1^2\n var c = this.z.redSqr();\n c = c.redIAdd(c);\n // D = a * A\n var d = this.curve._mulA(a);\n // E = (X1 + Y1)^2 - A - B\n var e = this.x.redAdd(this.y).redSqr().redISub(a).redISub(b);\n // G = D + B\n var g = d.redAdd(b);\n // F = G - C\n var f = g.redSub(c);\n // H = D - B\n var h = d.redSub(b);\n // X3 = E * F\n var nx = e.redMul(f);\n // Y3 = G * H\n var ny = g.redMul(h);\n // T3 = E * H\n var nt = e.redMul(h);\n // Z3 = F * G\n var nz = f.redMul(g);\n return this.curve.point(nx, ny, nz, nt);\n};\n\nPoint.prototype._projDbl = function _projDbl() {\n // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html\n // #doubling-dbl-2008-bbjlp\n // #doubling-dbl-2007-bl\n // and others\n // Generally 3M + 4S or 2M + 4S\n\n // B = (X1 + Y1)^2\n var b = this.x.redAdd(this.y).redSqr();\n // C = X1^2\n var c = this.x.redSqr();\n // D = Y1^2\n var d = this.y.redSqr();\n\n var nx;\n var ny;\n var nz;\n var e;\n var h;\n var j;\n if (this.curve.twisted) {\n // E = a * C\n e = this.curve._mulA(c);\n // F = E + D\n var f = e.redAdd(d);\n if (this.zOne) {\n // X3 = (B - C - D) * (F - 2)\n nx = b.redSub(c).redSub(d).redMul(f.redSub(this.curve.two));\n // Y3 = F * (E - D)\n ny = f.redMul(e.redSub(d));\n // Z3 = F^2 - 2 * F\n nz = f.redSqr().redSub(f).redSub(f);\n } else {\n // H = Z1^2\n h = this.z.redSqr();\n // J = F - 2 * H\n j = f.redSub(h).redISub(h);\n // X3 = (B-C-D)*J\n nx = b.redSub(c).redISub(d).redMul(j);\n // Y3 = F * (E - D)\n ny = f.redMul(e.redSub(d));\n // Z3 = F * J\n nz = f.redMul(j);\n }\n } else {\n // E = C + D\n e = c.redAdd(d);\n // H = (c * Z1)^2\n h = this.curve._mulC(this.z).redSqr();\n // J = E - 2 * H\n j = e.redSub(h).redSub(h);\n // X3 = c * (B - E) * J\n nx = this.curve._mulC(b.redISub(e)).redMul(j);\n // Y3 = c * E * (C - D)\n ny = this.curve._mulC(e).redMul(c.redISub(d));\n // Z3 = E * J\n nz = e.redMul(j);\n }\n return this.curve.point(nx, ny, nz);\n};\n\nPoint.prototype.dbl = function dbl() {\n if (this.isInfinity())\n return this;\n\n // Double in extended coordinates\n if (this.curve.extended)\n return this._extDbl();\n else\n return this._projDbl();\n};\n\nPoint.prototype._extAdd = function _extAdd(p) {\n // hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html\n // #addition-add-2008-hwcd-3\n // 8M\n\n // A = (Y1 - X1) * (Y2 - X2)\n var a = this.y.redSub(this.x).redMul(p.y.redSub(p.x));\n // B = (Y1 + X1) * (Y2 + X2)\n var b = this.y.redAdd(this.x).redMul(p.y.redAdd(p.x));\n // C = T1 * k * T2\n var c = this.t.redMul(this.curve.dd).redMul(p.t);\n // D = Z1 * 2 * Z2\n var d = this.z.redMul(p.z.redAdd(p.z));\n // E = B - A\n var e = b.redSub(a);\n // F = D - C\n var f = d.redSub(c);\n // G = D + C\n var g = d.redAdd(c);\n // H = B + A\n var h = b.redAdd(a);\n // X3 = E * F\n var nx = e.redMul(f);\n // Y3 = G * H\n var ny = g.redMul(h);\n // T3 = E * H\n var nt = e.redMul(h);\n // Z3 = F * G\n var nz = f.redMul(g);\n return this.curve.point(nx, ny, nz, nt);\n};\n\nPoint.prototype._projAdd = function _projAdd(p) {\n // hyperelliptic.org/EFD/g1p/auto-twisted-projective.html\n // #addition-add-2008-bbjlp\n // #addition-add-2007-bl\n // 10M + 1S\n\n // A = Z1 * Z2\n var a = this.z.redMul(p.z);\n // B = A^2\n var b = a.redSqr();\n // C = X1 * X2\n var c = this.x.redMul(p.x);\n // D = Y1 * Y2\n var d = this.y.redMul(p.y);\n // E = d * C * D\n var e = this.curve.d.redMul(c).redMul(d);\n // F = B - E\n var f = b.redSub(e);\n // G = B + E\n var g = b.redAdd(e);\n // X3 = A * F * ((X1 + Y1) * (X2 + Y2) - C - D)\n var tmp = this.x.redAdd(this.y).redMul(p.x.redAdd(p.y)).redISub(c).redISub(d);\n var nx = a.redMul(f).redMul(tmp);\n var ny;\n var nz;\n if (this.curve.twisted) {\n // Y3 = A * G * (D - a * C)\n ny = a.redMul(g).redMul(d.redSub(this.curve._mulA(c)));\n // Z3 = F * G\n nz = f.redMul(g);\n } else {\n // Y3 = A * G * (D - C)\n ny = a.redMul(g).redMul(d.redSub(c));\n // Z3 = c * F * G\n nz = this.curve._mulC(f).redMul(g);\n }\n return this.curve.point(nx, ny, nz);\n};\n\nPoint.prototype.add = function add(p) {\n if (this.isInfinity())\n return p;\n if (p.isInfinity())\n return this;\n\n if (this.curve.extended)\n return this._extAdd(p);\n else\n return this._projAdd(p);\n};\n\nPoint.prototype.mul = function mul(k) {\n if (this._hasDoubles(k))\n return this.curve._fixedNafMul(this, k);\n else\n return this.curve._wnafMul(this, k);\n};\n\nPoint.prototype.mulAdd = function mulAdd(k1, p, k2) {\n return this.curve._wnafMulAdd(1, [ this, p ], [ k1, k2 ], 2, false);\n};\n\nPoint.prototype.jmulAdd = function jmulAdd(k1, p, k2) {\n return this.curve._wnafMulAdd(1, [ this, p ], [ k1, k2 ], 2, true);\n};\n\nPoint.prototype.normalize = function normalize() {\n if (this.zOne)\n return this;\n\n // Normalize coordinates\n var zi = this.z.redInvm();\n this.x = this.x.redMul(zi);\n this.y = this.y.redMul(zi);\n if (this.t)\n this.t = this.t.redMul(zi);\n this.z = this.curve.one;\n this.zOne = true;\n return this;\n};\n\nPoint.prototype.neg = function neg() {\n return this.curve.point(this.x.redNeg(),\n this.y,\n this.z,\n this.t && this.t.redNeg());\n};\n\nPoint.prototype.getX = function getX() {\n this.normalize();\n return this.x.fromRed();\n};\n\nPoint.prototype.getY = function getY() {\n this.normalize();\n return this.y.fromRed();\n};\n\nPoint.prototype.eq = function eq(other) {\n return this === other ||\n this.getX().cmp(other.getX()) === 0 &&\n this.getY().cmp(other.getY()) === 0;\n};\n\nPoint.prototype.eqXToP = function eqXToP(x) {\n var rx = x.toRed(this.curve.red).redMul(this.z);\n if (this.x.cmp(rx) === 0)\n return true;\n\n var xc = x.clone();\n var t = this.curve.redN.redMul(this.z);\n for (;;) {\n xc.iadd(this.curve.n);\n if (xc.cmp(this.curve.p) >= 0)\n return false;\n\n rx.redIAdd(t);\n if (this.x.cmp(rx) === 0)\n return true;\n }\n};\n\n// Compatibility with BaseCurve\nPoint.prototype.toP = Point.prototype.normalize;\nPoint.prototype.mixedAdd = Point.prototype.add;\n","'use strict';\n\nvar curve = exports;\n\ncurve.base = require('./base');\ncurve.short = require('./short');\ncurve.mont = require('./mont');\ncurve.edwards = require('./edwards');\n","'use strict';\n\nvar BN = require('bn.js');\nvar inherits = require('inherits');\nvar Base = require('./base');\n\nvar utils = require('../utils');\n\nfunction MontCurve(conf) {\n Base.call(this, 'mont', conf);\n\n this.a = new BN(conf.a, 16).toRed(this.red);\n this.b = new BN(conf.b, 16).toRed(this.red);\n this.i4 = new BN(4).toRed(this.red).redInvm();\n this.two = new BN(2).toRed(this.red);\n this.a24 = this.i4.redMul(this.a.redAdd(this.two));\n}\ninherits(MontCurve, Base);\nmodule.exports = MontCurve;\n\nMontCurve.prototype.validate = function validate(point) {\n var x = point.normalize().x;\n var x2 = x.redSqr();\n var rhs = x2.redMul(x).redAdd(x2.redMul(this.a)).redAdd(x);\n var y = rhs.redSqrt();\n\n return y.redSqr().cmp(rhs) === 0;\n};\n\nfunction Point(curve, x, z) {\n Base.BasePoint.call(this, curve, 'projective');\n if (x === null && z === null) {\n this.x = this.curve.one;\n this.z = this.curve.zero;\n } else {\n this.x = new BN(x, 16);\n this.z = new BN(z, 16);\n if (!this.x.red)\n this.x = this.x.toRed(this.curve.red);\n if (!this.z.red)\n this.z = this.z.toRed(this.curve.red);\n }\n}\ninherits(Point, Base.BasePoint);\n\nMontCurve.prototype.decodePoint = function decodePoint(bytes, enc) {\n return this.point(utils.toArray(bytes, enc), 1);\n};\n\nMontCurve.prototype.point = function point(x, z) {\n return new Point(this, x, z);\n};\n\nMontCurve.prototype.pointFromJSON = function pointFromJSON(obj) {\n return Point.fromJSON(this, obj);\n};\n\nPoint.prototype.precompute = function precompute() {\n // No-op\n};\n\nPoint.prototype._encode = function _encode() {\n return this.getX().toArray('be', this.curve.p.byteLength());\n};\n\nPoint.fromJSON = function fromJSON(curve, obj) {\n return new Point(curve, obj[0], obj[1] || curve.one);\n};\n\nPoint.prototype.inspect = function inspect() {\n if (this.isInfinity())\n return '<EC Point Infinity>';\n return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +\n ' z: ' + this.z.fromRed().toString(16, 2) + '>';\n};\n\nPoint.prototype.isInfinity = function isInfinity() {\n // XXX This code assumes that zero is always zero in red\n return this.z.cmpn(0) === 0;\n};\n\nPoint.prototype.dbl = function dbl() {\n // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#doubling-dbl-1987-m-3\n // 2M + 2S + 4A\n\n // A = X1 + Z1\n var a = this.x.redAdd(this.z);\n // AA = A^2\n var aa = a.redSqr();\n // B = X1 - Z1\n var b = this.x.redSub(this.z);\n // BB = B^2\n var bb = b.redSqr();\n // C = AA - BB\n var c = aa.redSub(bb);\n // X3 = AA * BB\n var nx = aa.redMul(bb);\n // Z3 = C * (BB + A24 * C)\n var nz = c.redMul(bb.redAdd(this.curve.a24.redMul(c)));\n return this.curve.point(nx, nz);\n};\n\nPoint.prototype.add = function add() {\n throw new Error('Not supported on Montgomery curve');\n};\n\nPoint.prototype.diffAdd = function diffAdd(p, diff) {\n // http://hyperelliptic.org/EFD/g1p/auto-montgom-xz.html#diffadd-dadd-1987-m-3\n // 4M + 2S + 6A\n\n // A = X2 + Z2\n var a = this.x.redAdd(this.z);\n // B = X2 - Z2\n var b = this.x.redSub(this.z);\n // C = X3 + Z3\n var c = p.x.redAdd(p.z);\n // D = X3 - Z3\n var d = p.x.redSub(p.z);\n // DA = D * A\n var da = d.redMul(a);\n // CB = C * B\n var cb = c.redMul(b);\n // X5 = Z1 * (DA + CB)^2\n var nx = diff.z.redMul(da.redAdd(cb).redSqr());\n // Z5 = X1 * (DA - CB)^2\n var nz = diff.x.redMul(da.redISub(cb).redSqr());\n return this.curve.point(nx, nz);\n};\n\nPoint.prototype.mul = function mul(k) {\n var t = k.clone();\n var a = this; // (N / 2) * Q + Q\n var b = this.curve.point(null, null); // (N / 2) * Q\n var c = this; // Q\n\n for (var bits = []; t.cmpn(0) !== 0; t.iushrn(1))\n bits.push(t.andln(1));\n\n for (var i = bits.length - 1; i >= 0; i--) {\n if (bits[i] === 0) {\n // N * Q + Q = ((N / 2) * Q + Q)) + (N / 2) * Q\n a = a.diffAdd(b, c);\n // N * Q = 2 * ((N / 2) * Q + Q))\n b = b.dbl();\n } else {\n // N * Q = ((N / 2) * Q + Q) + ((N / 2) * Q)\n b = a.diffAdd(b, c);\n // N * Q + Q = 2 * ((N / 2) * Q + Q)\n a = a.dbl();\n }\n }\n return b;\n};\n\nPoint.prototype.mulAdd = function mulAdd() {\n throw new Error('Not supported on Montgomery curve');\n};\n\nPoint.prototype.jumlAdd = function jumlAdd() {\n throw new Error('Not supported on Montgomery curve');\n};\n\nPoint.prototype.eq = function eq(other) {\n return this.getX().cmp(other.getX()) === 0;\n};\n\nPoint.prototype.normalize = function normalize() {\n this.x = this.x.redMul(this.z.redInvm());\n this.z = this.curve.one;\n return this;\n};\n\nPoint.prototype.getX = function getX() {\n // Normalize coordinates\n this.normalize();\n\n return this.x.fromRed();\n};\n","'use strict';\n\nvar utils = require('../utils');\nvar BN = require('bn.js');\nvar inherits = require('inherits');\nvar Base = require('./base');\n\nvar assert = utils.assert;\n\nfunction ShortCurve(conf) {\n Base.call(this, 'short', conf);\n\n this.a = new BN(conf.a, 16).toRed(this.red);\n this.b = new BN(conf.b, 16).toRed(this.red);\n this.tinv = this.two.redInvm();\n\n this.zeroA = this.a.fromRed().cmpn(0) === 0;\n this.threeA = this.a.fromRed().sub(this.p).cmpn(-3) === 0;\n\n // If the curve is endomorphic, precalculate beta and lambda\n this.endo = this._getEndomorphism(conf);\n this._endoWnafT1 = new Array(4);\n this._endoWnafT2 = new Array(4);\n}\ninherits(ShortCurve, Base);\nmodule.exports = ShortCurve;\n\nShortCurve.prototype._getEndomorphism = function _getEndomorphism(conf) {\n // No efficient endomorphism\n if (!this.zeroA || !this.g || !this.n || this.p.modn(3) !== 1)\n return;\n\n // Compute beta and lambda, that lambda * P = (beta * Px; Py)\n var beta;\n var lambda;\n if (conf.beta) {\n beta = new BN(conf.beta, 16).toRed(this.red);\n } else {\n var betas = this._getEndoRoots(this.p);\n // Choose the smallest beta\n beta = betas[0].cmp(betas[1]) < 0 ? betas[0] : betas[1];\n beta = beta.toRed(this.red);\n }\n if (conf.lambda) {\n lambda = new BN(conf.lambda, 16);\n } else {\n // Choose the lambda that is matching selected beta\n var lambdas = this._getEndoRoots(this.n);\n if (this.g.mul(lambdas[0]).x.cmp(this.g.x.redMul(beta)) === 0) {\n lambda = lambdas[0];\n } else {\n lambda = lambdas[1];\n assert(this.g.mul(lambda).x.cmp(this.g.x.redMul(beta)) === 0);\n }\n }\n\n // Get basis vectors, used for balanced length-two representation\n var basis;\n if (conf.basis) {\n basis = conf.basis.map(function(vec) {\n return {\n a: new BN(vec.a, 16),\n b: new BN(vec.b, 16),\n };\n });\n } else {\n basis = this._getEndoBasis(lambda);\n }\n\n return {\n beta: beta,\n lambda: lambda,\n basis: basis,\n };\n};\n\nShortCurve.prototype._getEndoRoots = function _getEndoRoots(num) {\n // Find roots of for x^2 + x + 1 in F\n // Root = (-1 +- Sqrt(-3)) / 2\n //\n var red = num === this.p ? this.red : BN.mont(num);\n var tinv = new BN(2).toRed(red).redInvm();\n var ntinv = tinv.redNeg();\n\n var s = new BN(3).toRed(red).redNeg().redSqrt().redMul(tinv);\n\n var l1 = ntinv.redAdd(s).fromRed();\n var l2 = ntinv.redSub(s).fromRed();\n return [ l1, l2 ];\n};\n\nShortCurve.prototype._getEndoBasis = function _getEndoBasis(lambda) {\n // aprxSqrt >= sqrt(this.n)\n var aprxSqrt = this.n.ushrn(Math.floor(this.n.bitLength() / 2));\n\n // 3.74\n // Run EGCD, until r(L + 1) < aprxSqrt\n var u = lambda;\n var v = this.n.clone();\n var x1 = new BN(1);\n var y1 = new BN(0);\n var x2 = new BN(0);\n var y2 = new BN(1);\n\n // NOTE: all vectors are roots of: a + b * lambda = 0 (mod n)\n var a0;\n var b0;\n // First vector\n var a1;\n var b1;\n // Second vector\n var a2;\n var b2;\n\n var prevR;\n var i = 0;\n var r;\n var x;\n while (u.cmpn(0) !== 0) {\n var q = v.div(u);\n r = v.sub(q.mul(u));\n x = x2.sub(q.mul(x1));\n var y = y2.sub(q.mul(y1));\n\n if (!a1 && r.cmp(aprxSqrt) < 0) {\n a0 = prevR.neg();\n b0 = x1;\n a1 = r.neg();\n b1 = x;\n } else if (a1 && ++i === 2) {\n break;\n }\n prevR = r;\n\n v = u;\n u = r;\n x2 = x1;\n x1 = x;\n y2 = y1;\n y1 = y;\n }\n a2 = r.neg();\n b2 = x;\n\n var len1 = a1.sqr().add(b1.sqr());\n var len2 = a2.sqr().add(b2.sqr());\n if (len2.cmp(len1) >= 0) {\n a2 = a0;\n b2 = b0;\n }\n\n // Normalize signs\n if (a1.negative) {\n a1 = a1.neg();\n b1 = b1.neg();\n }\n if (a2.negative) {\n a2 = a2.neg();\n b2 = b2.neg();\n }\n\n return [\n { a: a1, b: b1 },\n { a: a2, b: b2 },\n ];\n};\n\nShortCurve.prototype._endoSplit = function _endoSplit(k) {\n var basis = this.endo.basis;\n var v1 = basis[0];\n var v2 = basis[1];\n\n var c1 = v2.b.mul(k).divRound(this.n);\n var c2 = v1.b.neg().mul(k).divRound(this.n);\n\n var p1 = c1.mul(v1.a);\n var p2 = c2.mul(v2.a);\n var q1 = c1.mul(v1.b);\n var q2 = c2.mul(v2.b);\n\n // Calculate answer\n var k1 = k.sub(p1).sub(p2);\n var k2 = q1.add(q2).neg();\n return { k1: k1, k2: k2 };\n};\n\nShortCurve.prototype.pointFromX = function pointFromX(x, odd) {\n x = new BN(x, 16);\n if (!x.red)\n x = x.toRed(this.red);\n\n var y2 = x.redSqr().redMul(x).redIAdd(x.redMul(this.a)).redIAdd(this.b);\n var y = y2.redSqrt();\n if (y.redSqr().redSub(y2).cmp(this.zero) !== 0)\n throw new Error('invalid point');\n\n // XXX Is there any way to tell if the number is odd without converting it\n // to non-red form?\n var isOdd = y.fromRed().isOdd();\n if (odd && !isOdd || !odd && isOdd)\n y = y.redNeg();\n\n return this.point(x, y);\n};\n\nShortCurve.prototype.validate = function validate(point) {\n if (point.inf)\n return true;\n\n var x = point.x;\n var y = point.y;\n\n var ax = this.a.redMul(x);\n var rhs = x.redSqr().redMul(x).redIAdd(ax).redIAdd(this.b);\n return y.redSqr().redISub(rhs).cmpn(0) === 0;\n};\n\nShortCurve.prototype._endoWnafMulAdd =\n function _endoWnafMulAdd(points, coeffs, jacobianResult) {\n var npoints = this._endoWnafT1;\n var ncoeffs = this._endoWnafT2;\n for (var i = 0; i < points.length; i++) {\n var split = this._endoSplit(coeffs[i]);\n var p = points[i];\n var beta = p._getBeta();\n\n if (split.k1.negative) {\n split.k1.ineg();\n p = p.neg(true);\n }\n if (split.k2.negative) {\n split.k2.ineg();\n beta = beta.neg(true);\n }\n\n npoints[i * 2] = p;\n npoints[i * 2 + 1] = beta;\n ncoeffs[i * 2] = split.k1;\n ncoeffs[i * 2 + 1] = split.k2;\n }\n var res = this._wnafMulAdd(1, npoints, ncoeffs, i * 2, jacobianResult);\n\n // Clean-up references to points and coefficients\n for (var j = 0; j < i * 2; j++) {\n npoints[j] = null;\n ncoeffs[j] = null;\n }\n return res;\n };\n\nfunction Point(curve, x, y, isRed) {\n Base.BasePoint.call(this, curve, 'affine');\n if (x === null && y === null) {\n this.x = null;\n this.y = null;\n this.inf = true;\n } else {\n this.x = new BN(x, 16);\n this.y = new BN(y, 16);\n // Force redgomery representation when loading from JSON\n if (isRed) {\n this.x.forceRed(this.curve.red);\n this.y.forceRed(this.curve.red);\n }\n if (!this.x.red)\n this.x = this.x.toRed(this.curve.red);\n if (!this.y.red)\n this.y = this.y.toRed(this.curve.red);\n this.inf = false;\n }\n}\ninherits(Point, Base.BasePoint);\n\nShortCurve.prototype.point = function point(x, y, isRed) {\n return new Point(this, x, y, isRed);\n};\n\nShortCurve.prototype.pointFromJSON = function pointFromJSON(obj, red) {\n return Point.fromJSON(this, obj, red);\n};\n\nPoint.prototype._getBeta = function _getBeta() {\n if (!this.curve.endo)\n return;\n\n var pre = this.precomputed;\n if (pre && pre.beta)\n return pre.beta;\n\n var beta = this.curve.point(this.x.redMul(this.curve.endo.beta), this.y);\n if (pre) {\n var curve = this.curve;\n var endoMul = function(p) {\n return curve.point(p.x.redMul(curve.endo.beta), p.y);\n };\n pre.beta = beta;\n beta.precomputed = {\n beta: null,\n naf: pre.naf && {\n wnd: pre.naf.wnd,\n points: pre.naf.points.map(endoMul),\n },\n doubles: pre.doubles && {\n step: pre.doubles.step,\n points: pre.doubles.points.map(endoMul),\n },\n };\n }\n return beta;\n};\n\nPoint.prototype.toJSON = function toJSON() {\n if (!this.precomputed)\n return [ this.x, this.y ];\n\n return [ this.x, this.y, this.precomputed && {\n doubles: this.precomputed.doubles && {\n step: this.precomputed.doubles.step,\n points: this.precomputed.doubles.points.slice(1),\n },\n naf: this.precomputed.naf && {\n wnd: this.precomputed.naf.wnd,\n points: this.precomputed.naf.points.slice(1),\n },\n } ];\n};\n\nPoint.fromJSON = function fromJSON(curve, obj, red) {\n if (typeof obj === 'string')\n obj = JSON.parse(obj);\n var res = curve.point(obj[0], obj[1], red);\n if (!obj[2])\n return res;\n\n function obj2point(obj) {\n return curve.point(obj[0], obj[1], red);\n }\n\n var pre = obj[2];\n res.precomputed = {\n beta: null,\n doubles: pre.doubles && {\n step: pre.doubles.step,\n points: [ res ].concat(pre.doubles.points.map(obj2point)),\n },\n naf: pre.naf && {\n wnd: pre.naf.wnd,\n points: [ res ].concat(pre.naf.points.map(obj2point)),\n },\n };\n return res;\n};\n\nPoint.prototype.inspect = function inspect() {\n if (this.isInfinity())\n return '<EC Point Infinity>';\n return '<EC Point x: ' + this.x.fromRed().toString(16, 2) +\n ' y: ' + this.y.fromRed().toString(16, 2) + '>';\n};\n\nPoint.prototype.isInfinity = function isInfinity() {\n return this.inf;\n};\n\nPoint.prototype.add = function add(p) {\n // O + P = P\n if (this.inf)\n return p;\n\n // P + O = P\n if (p.inf)\n return this;\n\n // P + P = 2P\n if (this.eq(p))\n return this.dbl();\n\n // P + (-P) = O\n if (this.neg().eq(p))\n return this.curve.point(null, null);\n\n // P + Q = O\n if (this.x.cmp(p.x) === 0)\n return this.curve.point(null, null);\n\n var c = this.y.redSub(p.y);\n if (c.cmpn(0) !== 0)\n c = c.redMul(this.x.redSub(p.x).redInvm());\n var nx = c.redSqr().redISub(this.x).redISub(p.x);\n var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);\n return this.curve.point(nx, ny);\n};\n\nPoint.prototype.dbl = function dbl() {\n if (this.inf)\n return this;\n\n // 2P = O\n var ys1 = this.y.redAdd(this.y);\n if (ys1.cmpn(0) === 0)\n return this.curve.point(null, null);\n\n var a = this.curve.a;\n\n var x2 = this.x.redSqr();\n var dyinv = ys1.redInvm();\n var c = x2.redAdd(x2).redIAdd(x2).redIAdd(a).redMul(dyinv);\n\n var nx = c.redSqr().redISub(this.x.redAdd(this.x));\n var ny = c.redMul(this.x.redSub(nx)).redISub(this.y);\n return this.curve.point(nx, ny);\n};\n\nPoint.prototype.getX = function getX() {\n return this.x.fromRed();\n};\n\nPoint.prototype.getY = function getY() {\n return this.y.fromRed();\n};\n\nPoint.prototype.mul = function mul(k) {\n k = new BN(k, 16);\n if (this.isInfinity())\n return this;\n else if (this._hasDoubles(k))\n return this.curve._fixedNafMul(this, k);\n else if (this.curve.endo)\n return this.curve._endoWnafMulAdd([ this ], [ k ]);\n else\n return this.curve._wnafMul(this, k);\n};\n\nPoint.prototype.mulAdd = function mulAdd(k1, p2, k2) {\n var points = [ this, p2 ];\n var coeffs = [ k1, k2 ];\n if (this.curve.endo)\n return this.curve._endoWnafMulAdd(points, coeffs);\n else\n return this.curve._wnafMulAdd(1, points, coeffs, 2);\n};\n\nPoint.prototype.jmulAdd = function jmulAdd(k1, p2, k2) {\n var points = [ this, p2 ];\n var coeffs = [ k1, k2 ];\n if (this.curve.endo)\n return this.curve._endoWnafMulAdd(points, coeffs, true);\n else\n return this.curve._wnafMulAdd(1, points, coeffs, 2, true);\n};\n\nPoint.prototype.eq = function eq(p) {\n return this === p ||\n this.inf === p.inf &&\n (this.inf || this.x.cmp(p.x) === 0 && this.y.cmp(p.y) === 0);\n};\n\nPoint.prototype.neg = function neg(_precompute) {\n if (this.inf)\n return this;\n\n var res = this.curve.point(this.x, this.y.redNeg());\n if (_precompute && this.precomputed) {\n var pre = this.precomputed;\n var negate = function(p) {\n return p.neg();\n };\n res.precomputed = {\n naf: pre.naf && {\n wnd: pre.naf.wnd,\n points: pre.naf.points.map(negate),\n },\n doubles: pre.doubles && {\n step: pre.doubles.step,\n points: pre.doubles.points.map(negate),\n },\n };\n }\n return res;\n};\n\nPoint.prototype.toJ = function toJ() {\n if (this.inf)\n return this.curve.jpoint(null, null, null);\n\n var res = this.curve.jpoint(this.x, this.y, this.curve.one);\n return res;\n};\n\nfunction JPoint(curve, x, y, z) {\n Base.BasePoint.call(this, curve, 'jacobian');\n if (x === null && y === null && z === null) {\n this.x = this.curve.one;\n this.y = this.curve.one;\n this.z = new BN(0);\n } else {\n this.x = new BN(x, 16);\n this.y = new BN(y, 16);\n this.z = new BN(z, 16);\n }\n if (!this.x.red)\n this.x = this.x.toRed(this.curve.red);\n if (!this.y.red)\n this.y = this.y.toRed(this.curve.red);\n if (!this.z.red)\n this.z = this.z.toRed(this.curve.red);\n\n this.zOne = this.z === this.curve.one;\n}\ninherits(JPoint, Base.BasePoint);\n\nShortCurve.prototype.jpoint = function jpoint(x, y, z) {\n return new JPoint(this, x, y, z);\n};\n\nJPoint.prototype.toP = function toP() {\n if (this.isInfinity())\n return this.curve.point(null, null);\n\n var zinv = this.z.redInvm();\n var zinv2 = zinv.redSqr();\n var ax = this.x.redMul(zinv2);\n var ay = this.y.redMul(zinv2).redMul(zinv);\n\n return this.curve.point(ax, ay);\n};\n\nJPoint.prototype.neg = function neg() {\n return this.curve.jpoint(this.x, this.y.redNeg(), this.z);\n};\n\nJPoint.prototype.add = function add(p) {\n // O + P = P\n if (this.isInfinity())\n return p;\n\n // P + O = P\n if (p.isInfinity())\n return this;\n\n // 12M + 4S + 7A\n var pz2 = p.z.redSqr();\n var z2 = this.z.redSqr();\n var u1 = this.x.redMul(pz2);\n var u2 = p.x.redMul(z2);\n var s1 = this.y.redMul(pz2.redMul(p.z));\n var s2 = p.y.redMul(z2.redMul(this.z));\n\n var h = u1.redSub(u2);\n var r = s1.redSub(s2);\n if (h.cmpn(0) === 0) {\n if (r.cmpn(0) !== 0)\n return this.curve.jpoint(null, null, null);\n else\n return this.dbl();\n }\n\n var h2 = h.redSqr();\n var h3 = h2.redMul(h);\n var v = u1.redMul(h2);\n\n var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);\n var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));\n var nz = this.z.redMul(p.z).redMul(h);\n\n return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.mixedAdd = function mixedAdd(p) {\n // O + P = P\n if (this.isInfinity())\n return p.toJ();\n\n // P + O = P\n if (p.isInfinity())\n return this;\n\n // 8M + 3S + 7A\n var z2 = this.z.redSqr();\n var u1 = this.x;\n var u2 = p.x.redMul(z2);\n var s1 = this.y;\n var s2 = p.y.redMul(z2).redMul(this.z);\n\n var h = u1.redSub(u2);\n var r = s1.redSub(s2);\n if (h.cmpn(0) === 0) {\n if (r.cmpn(0) !== 0)\n return this.curve.jpoint(null, null, null);\n else\n return this.dbl();\n }\n\n var h2 = h.redSqr();\n var h3 = h2.redMul(h);\n var v = u1.redMul(h2);\n\n var nx = r.redSqr().redIAdd(h3).redISub(v).redISub(v);\n var ny = r.redMul(v.redISub(nx)).redISub(s1.redMul(h3));\n var nz = this.z.redMul(h);\n\n return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.dblp = function dblp(pow) {\n if (pow === 0)\n return this;\n if (this.isInfinity())\n return this;\n if (!pow)\n return this.dbl();\n\n var i;\n if (this.curve.zeroA || this.curve.threeA) {\n var r = this;\n for (i = 0; i < pow; i++)\n r = r.dbl();\n return r;\n }\n\n // 1M + 2S + 1A + N * (4S + 5M + 8A)\n // N = 1 => 6M + 6S + 9A\n var a = this.curve.a;\n var tinv = this.curve.tinv;\n\n var jx = this.x;\n var jy = this.y;\n var jz = this.z;\n var jz4 = jz.redSqr().redSqr();\n\n // Reuse results\n var jyd = jy.redAdd(jy);\n for (i = 0; i < pow; i++) {\n var jx2 = jx.redSqr();\n var jyd2 = jyd.redSqr();\n var jyd4 = jyd2.redSqr();\n var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));\n\n var t1 = jx.redMul(jyd2);\n var nx = c.redSqr().redISub(t1.redAdd(t1));\n var t2 = t1.redISub(nx);\n var dny = c.redMul(t2);\n dny = dny.redIAdd(dny).redISub(jyd4);\n var nz = jyd.redMul(jz);\n if (i + 1 < pow)\n jz4 = jz4.redMul(jyd4);\n\n jx = nx;\n jz = nz;\n jyd = dny;\n }\n\n return this.curve.jpoint(jx, jyd.redMul(tinv), jz);\n};\n\nJPoint.prototype.dbl = function dbl() {\n if (this.isInfinity())\n return this;\n\n if (this.curve.zeroA)\n return this._zeroDbl();\n else if (this.curve.threeA)\n return this._threeDbl();\n else\n return this._dbl();\n};\n\nJPoint.prototype._zeroDbl = function _zeroDbl() {\n var nx;\n var ny;\n var nz;\n // Z = 1\n if (this.zOne) {\n // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html\n // #doubling-mdbl-2007-bl\n // 1M + 5S + 14A\n\n // XX = X1^2\n var xx = this.x.redSqr();\n // YY = Y1^2\n var yy = this.y.redSqr();\n // YYYY = YY^2\n var yyyy = yy.redSqr();\n // S = 2 * ((X1 + YY)^2 - XX - YYYY)\n var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);\n s = s.redIAdd(s);\n // M = 3 * XX + a; a = 0\n var m = xx.redAdd(xx).redIAdd(xx);\n // T = M ^ 2 - 2*S\n var t = m.redSqr().redISub(s).redISub(s);\n\n // 8 * YYYY\n var yyyy8 = yyyy.redIAdd(yyyy);\n yyyy8 = yyyy8.redIAdd(yyyy8);\n yyyy8 = yyyy8.redIAdd(yyyy8);\n\n // X3 = T\n nx = t;\n // Y3 = M * (S - T) - 8 * YYYY\n ny = m.redMul(s.redISub(t)).redISub(yyyy8);\n // Z3 = 2*Y1\n nz = this.y.redAdd(this.y);\n } else {\n // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html\n // #doubling-dbl-2009-l\n // 2M + 5S + 13A\n\n // A = X1^2\n var a = this.x.redSqr();\n // B = Y1^2\n var b = this.y.redSqr();\n // C = B^2\n var c = b.redSqr();\n // D = 2 * ((X1 + B)^2 - A - C)\n var d = this.x.redAdd(b).redSqr().redISub(a).redISub(c);\n d = d.redIAdd(d);\n // E = 3 * A\n var e = a.redAdd(a).redIAdd(a);\n // F = E^2\n var f = e.redSqr();\n\n // 8 * C\n var c8 = c.redIAdd(c);\n c8 = c8.redIAdd(c8);\n c8 = c8.redIAdd(c8);\n\n // X3 = F - 2 * D\n nx = f.redISub(d).redISub(d);\n // Y3 = E * (D - X3) - 8 * C\n ny = e.redMul(d.redISub(nx)).redISub(c8);\n // Z3 = 2 * Y1 * Z1\n nz = this.y.redMul(this.z);\n nz = nz.redIAdd(nz);\n }\n\n return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype._threeDbl = function _threeDbl() {\n var nx;\n var ny;\n var nz;\n // Z = 1\n if (this.zOne) {\n // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html\n // #doubling-mdbl-2007-bl\n // 1M + 5S + 15A\n\n // XX = X1^2\n var xx = this.x.redSqr();\n // YY = Y1^2\n var yy = this.y.redSqr();\n // YYYY = YY^2\n var yyyy = yy.redSqr();\n // S = 2 * ((X1 + YY)^2 - XX - YYYY)\n var s = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);\n s = s.redIAdd(s);\n // M = 3 * XX + a\n var m = xx.redAdd(xx).redIAdd(xx).redIAdd(this.curve.a);\n // T = M^2 - 2 * S\n var t = m.redSqr().redISub(s).redISub(s);\n // X3 = T\n nx = t;\n // Y3 = M * (S - T) - 8 * YYYY\n var yyyy8 = yyyy.redIAdd(yyyy);\n yyyy8 = yyyy8.redIAdd(yyyy8);\n yyyy8 = yyyy8.redIAdd(yyyy8);\n ny = m.redMul(s.redISub(t)).redISub(yyyy8);\n // Z3 = 2 * Y1\n nz = this.y.redAdd(this.y);\n } else {\n // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-3.html#doubling-dbl-2001-b\n // 3M + 5S\n\n // delta = Z1^2\n var delta = this.z.redSqr();\n // gamma = Y1^2\n var gamma = this.y.redSqr();\n // beta = X1 * gamma\n var beta = this.x.redMul(gamma);\n // alpha = 3 * (X1 - delta) * (X1 + delta)\n var alpha = this.x.redSub(delta).redMul(this.x.redAdd(delta));\n alpha = alpha.redAdd(alpha).redIAdd(alpha);\n // X3 = alpha^2 - 8 * beta\n var beta4 = beta.redIAdd(beta);\n beta4 = beta4.redIAdd(beta4);\n var beta8 = beta4.redAdd(beta4);\n nx = alpha.redSqr().redISub(beta8);\n // Z3 = (Y1 + Z1)^2 - gamma - delta\n nz = this.y.redAdd(this.z).redSqr().redISub(gamma).redISub(delta);\n // Y3 = alpha * (4 * beta - X3) - 8 * gamma^2\n var ggamma8 = gamma.redSqr();\n ggamma8 = ggamma8.redIAdd(ggamma8);\n ggamma8 = ggamma8.redIAdd(ggamma8);\n ggamma8 = ggamma8.redIAdd(ggamma8);\n ny = alpha.redMul(beta4.redISub(nx)).redISub(ggamma8);\n }\n\n return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype._dbl = function _dbl() {\n var a = this.curve.a;\n\n // 4M + 6S + 10A\n var jx = this.x;\n var jy = this.y;\n var jz = this.z;\n var jz4 = jz.redSqr().redSqr();\n\n var jx2 = jx.redSqr();\n var jy2 = jy.redSqr();\n\n var c = jx2.redAdd(jx2).redIAdd(jx2).redIAdd(a.redMul(jz4));\n\n var jxd4 = jx.redAdd(jx);\n jxd4 = jxd4.redIAdd(jxd4);\n var t1 = jxd4.redMul(jy2);\n var nx = c.redSqr().redISub(t1.redAdd(t1));\n var t2 = t1.redISub(nx);\n\n var jyd8 = jy2.redSqr();\n jyd8 = jyd8.redIAdd(jyd8);\n jyd8 = jyd8.redIAdd(jyd8);\n jyd8 = jyd8.redIAdd(jyd8);\n var ny = c.redMul(t2).redISub(jyd8);\n var nz = jy.redAdd(jy).redMul(jz);\n\n return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.trpl = function trpl() {\n if (!this.curve.zeroA)\n return this.dbl().add(this);\n\n // hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#tripling-tpl-2007-bl\n // 5M + 10S + ...\n\n // XX = X1^2\n var xx = this.x.redSqr();\n // YY = Y1^2\n var yy = this.y.redSqr();\n // ZZ = Z1^2\n var zz = this.z.redSqr();\n // YYYY = YY^2\n var yyyy = yy.redSqr();\n // M = 3 * XX + a * ZZ2; a = 0\n var m = xx.redAdd(xx).redIAdd(xx);\n // MM = M^2\n var mm = m.redSqr();\n // E = 6 * ((X1 + YY)^2 - XX - YYYY) - MM\n var e = this.x.redAdd(yy).redSqr().redISub(xx).redISub(yyyy);\n e = e.redIAdd(e);\n e = e.redAdd(e).redIAdd(e);\n e = e.redISub(mm);\n // EE = E^2\n var ee = e.redSqr();\n // T = 16*YYYY\n var t = yyyy.redIAdd(yyyy);\n t = t.redIAdd(t);\n t = t.redIAdd(t);\n t = t.redIAdd(t);\n // U = (M + E)^2 - MM - EE - T\n var u = m.redIAdd(e).redSqr().redISub(mm).redISub(ee).redISub(t);\n // X3 = 4 * (X1 * EE - 4 * YY * U)\n var yyu4 = yy.redMul(u);\n yyu4 = yyu4.redIAdd(yyu4);\n yyu4 = yyu4.redIAdd(yyu4);\n var nx = this.x.redMul(ee).redISub(yyu4);\n nx = nx.redIAdd(nx);\n nx = nx.redIAdd(nx);\n // Y3 = 8 * Y1 * (U * (T - U) - E * EE)\n var ny = this.y.redMul(u.redMul(t.redISub(u)).redISub(e.redMul(ee)));\n ny = ny.redIAdd(ny);\n ny = ny.redIAdd(ny);\n ny = ny.redIAdd(ny);\n // Z3 = (Z1 + E)^2 - ZZ - EE\n var nz = this.z.redAdd(e).redSqr().redISub(zz).redISub(ee);\n\n return this.curve.jpoint(nx, ny, nz);\n};\n\nJPoint.prototype.mul = function mul(k, kbase) {\n k = new BN(k, kbase);\n\n return this.curve._wnafMul(this, k);\n};\n\nJPoint.prototype.eq = function eq(p) {\n if (p.type === 'affine')\n return this.eq(p.toJ());\n\n if (this === p)\n return true;\n\n // x1 * z2^2 == x2 * z1^2\n var z2 = this.z.redSqr();\n var pz2 = p.z.redSqr();\n if (this.x.redMul(pz2).redISub(p.x.redMul(z2)).cmpn(0) !== 0)\n return false;\n\n // y1 * z2^3 == y2 * z1^3\n var z3 = z2.redMul(this.z);\n var pz3 = pz2.redMul(p.z);\n return this.y.redMul(pz3).redISub(p.y.redMul(z3)).cmpn(0) === 0;\n};\n\nJPoint.prototype.eqXToP = function eqXToP(x) {\n var zs = this.z.redSqr();\n var rx = x.toRed(this.curve.red).redMul(zs);\n if (this.x.cmp(rx) === 0)\n return true;\n\n var xc = x.clone();\n var t = this.curve.redN.redMul(zs);\n for (;;) {\n xc.iadd(this.curve.n);\n if (xc.cmp(this.curve.p) >= 0)\n return false;\n\n rx.redIAdd(t);\n if (this.x.cmp(rx) === 0)\n return true;\n }\n};\n\nJPoint.prototype.inspect = function inspect() {\n if (this.isInfinity())\n return '<EC JPoint Infinity>';\n return '<EC JPoint x: ' + this.x.toString(16, 2) +\n ' y: ' + this.y.toString(16, 2) +\n ' z: ' + this.z.toString(16, 2) + '>';\n};\n\nJPoint.prototype.isInfinity = function isInfinity() {\n // XXX This code assumes that zero is always zero in red\n return this.z.cmpn(0) === 0;\n};\n","'use strict';\n\nvar curves = exports;\n\nvar hash = require('hash.js');\nvar curve = require('./curve');\nvar utils = require('./utils');\n\nvar assert = utils.assert;\n\nfunction PresetCurve(options) {\n if (options.type === 'short')\n this.curve = new curve.short(options);\n else if (options.type === 'edwards')\n this.curve = new curve.edwards(options);\n else\n this.curve = new curve.mont(options);\n this.g = this.curve.g;\n this.n = this.curve.n;\n this.hash = options.hash;\n\n assert(this.g.validate(), 'Invalid curve');\n assert(this.g.mul(this.n).isInfinity(), 'Invalid curve, G*N != O');\n}\ncurves.PresetCurve = PresetCurve;\n\nfunction defineCurve(name, options) {\n Object.defineProperty(curves, name, {\n configurable: true,\n enumerable: true,\n get: function() {\n var curve = new PresetCurve(options);\n Object.defineProperty(curves, name, {\n configurable: true,\n enumerable: true,\n value: curve,\n });\n return curve;\n },\n });\n}\n\ndefineCurve('p192', {\n type: 'short',\n prime: 'p192',\n p: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff',\n a: 'ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc',\n b: '64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1',\n n: 'ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831',\n hash: hash.sha256,\n gRed: false,\n g: [\n '188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012',\n '07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811',\n ],\n});\n\ndefineCurve('p224', {\n type: 'short',\n prime: 'p224',\n p: 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001',\n a: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe',\n b: 'b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4',\n n: 'ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d',\n hash: hash.sha256,\n gRed: false,\n g: [\n 'b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21',\n 'bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34',\n ],\n});\n\ndefineCurve('p256', {\n type: 'short',\n prime: null,\n p: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff',\n a: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc',\n b: '5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b',\n n: 'ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551',\n hash: hash.sha256,\n gRed: false,\n g: [\n '6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296',\n '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5',\n ],\n});\n\ndefineCurve('p384', {\n type: 'short',\n prime: null,\n p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n 'fffffffe ffffffff 00000000 00000000 ffffffff',\n a: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n 'fffffffe ffffffff 00000000 00000000 fffffffc',\n b: 'b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f ' +\n '5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef',\n n: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 ' +\n 'f4372ddf 581a0db2 48b0a77a ecec196a ccc52973',\n hash: hash.sha384,\n gRed: false,\n g: [\n 'aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 ' +\n '5502f25d bf55296c 3a545e38 72760ab7',\n '3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 ' +\n '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f',\n ],\n});\n\ndefineCurve('p521', {\n type: 'short',\n prime: null,\n p: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n 'ffffffff ffffffff ffffffff ffffffff ffffffff',\n a: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n 'ffffffff ffffffff ffffffff ffffffff fffffffc',\n b: '00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b ' +\n '99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd ' +\n '3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00',\n n: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n 'ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 ' +\n 'f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409',\n hash: hash.sha512,\n gRed: false,\n g: [\n '000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 ' +\n '053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 ' +\n 'a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66',\n '00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 ' +\n '579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 ' +\n '3fad0761 353c7086 a272c240 88be9476 9fd16650',\n ],\n});\n\ndefineCurve('curve25519', {\n type: 'mont',\n prime: 'p25519',\n p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',\n a: '76d06',\n b: '1',\n n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',\n hash: hash.sha256,\n gRed: false,\n g: [\n '9',\n ],\n});\n\ndefineCurve('ed25519', {\n type: 'edwards',\n prime: 'p25519',\n p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',\n a: '-1',\n c: '1',\n // -121665 * (121666^(-1)) (mod P)\n d: '52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3',\n n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',\n hash: hash.sha256,\n gRed: false,\n g: [\n '216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a',\n\n // 4/5\n '6666666666666666666666666666666666666666666666666666666666666658',\n ],\n});\n\nvar pre;\ntry {\n pre = require('./precomputed/secp256k1');\n} catch (e) {\n pre = undefined;\n}\n\ndefineCurve('secp256k1', {\n type: 'short',\n prime: 'k256',\n p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f',\n a: '0',\n b: '7',\n n: 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141',\n h: '1',\n hash: hash.sha256,\n\n // Precomputed endomorphism\n beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee',\n lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72',\n basis: [\n {\n a: '3086d221a7d46bcde86c90e49284eb15',\n b: '-e4437ed6010e88286f547fa90abfe4c3',\n },\n {\n a: '114ca50f7a8e2f3f657c1108d9d44cfd8',\n b: '3086d221a7d46bcde86c90e49284eb15',\n },\n ],\n\n gRed: false,\n g: [\n '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',\n '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',\n pre,\n ],\n});\n","'use strict';\n\nvar BN = require('bn.js');\nvar HmacDRBG = require('hmac-drbg');\nvar utils = require('../utils');\nvar curves = require('../curves');\nvar rand = require('brorand');\nvar assert = utils.assert;\n\nvar KeyPair = require('./key');\nvar Signature = require('./signature');\n\nfunction EC(options) {\n if (!(this instanceof EC))\n return new EC(options);\n\n // Shortcut `elliptic.ec(curve-name)`\n if (typeof options === 'string') {\n assert(Object.prototype.hasOwnProperty.call(curves, options),\n 'Unknown curve ' + options);\n\n options = curves[options];\n }\n\n // Shortcut for `elliptic.ec(elliptic.curves.curveName)`\n if (options instanceof curves.PresetCurve)\n options = { curve: options };\n\n this.curve = options.curve.curve;\n this.n = this.curve.n;\n this.nh = this.n.ushrn(1);\n this.g = this.curve.g;\n\n // Point on curve\n this.g = options.curve.g;\n this.g.precompute(options.curve.n.bitLength() + 1);\n\n // Hash for function for DRBG\n this.hash = options.hash || options.curve.hash;\n}\nmodule.exports = EC;\n\nEC.prototype.keyPair = function keyPair(options) {\n return new KeyPair(this, options);\n};\n\nEC.prototype.keyFromPrivate = function keyFromPrivate(priv, enc) {\n return KeyPair.fromPrivate(this, priv, enc);\n};\n\nEC.prototype.keyFromPublic = function keyFromPublic(pub, enc) {\n return KeyPair.fromPublic(this, pub, enc);\n};\n\nEC.prototype.genKeyPair = function genKeyPair(options) {\n if (!options)\n options = {};\n\n // Instantiate Hmac_DRBG\n var drbg = new HmacDRBG({\n hash: this.hash,\n pers: options.pers,\n persEnc: options.persEnc || 'utf8',\n entropy: options.entropy || rand(this.hash.hmacStrength),\n entropyEnc: options.entropy && options.entropyEnc || 'utf8',\n nonce: this.n.toArray(),\n });\n\n var bytes = this.n.byteLength();\n var ns2 = this.n.sub(new BN(2));\n for (;;) {\n var priv = new BN(drbg.generate(bytes));\n if (priv.cmp(ns2) > 0)\n continue;\n\n priv.iaddn(1);\n return this.keyFromPrivate(priv);\n }\n};\n\nEC.prototype._truncateToN = function _truncateToN(msg, truncOnly) {\n var delta = msg.byteLength() * 8 - this.n.bitLength();\n if (delta > 0)\n msg = msg.ushrn(delta);\n if (!truncOnly && msg.cmp(this.n) >= 0)\n return msg.sub(this.n);\n else\n return msg;\n};\n\nEC.prototype.sign = function sign(msg, key, enc, options) {\n if (typeof enc === 'object') {\n options = enc;\n enc = null;\n }\n if (!options)\n options = {};\n\n key = this.keyFromPrivate(key, enc);\n msg = this._truncateToN(new BN(msg, 16));\n\n // Zero-extend key to provide enough entropy\n var bytes = this.n.byteLength();\n var bkey = key.getPrivate().toArray('be', bytes);\n\n // Zero-extend nonce to have the same byte size as N\n var nonce = msg.toArray('be', bytes);\n\n // Instantiate Hmac_DRBG\n var drbg = new HmacDRBG({\n hash: this.hash,\n entropy: bkey,\n nonce: nonce,\n pers: options.pers,\n persEnc: options.persEnc || 'utf8',\n });\n\n // Number of bytes to generate\n var ns1 = this.n.sub(new BN(1));\n\n for (var iter = 0; ; iter++) {\n var k = options.k ?\n options.k(iter) :\n new BN(drbg.generate(this.n.byteLength()));\n k = this._truncateToN(k, true);\n if (k.cmpn(1) <= 0 || k.cmp(ns1) >= 0)\n continue;\n\n var kp = this.g.mul(k);\n if (kp.isInfinity())\n continue;\n\n var kpX = kp.getX();\n var r = kpX.umod(this.n);\n if (r.cmpn(0) === 0)\n continue;\n\n var s = k.invm(this.n).mul(r.mul(key.getPrivate()).iadd(msg));\n s = s.umod(this.n);\n if (s.cmpn(0) === 0)\n continue;\n\n var recoveryParam = (kp.getY().isOdd() ? 1 : 0) |\n (kpX.cmp(r) !== 0 ? 2 : 0);\n\n // Use complement of `s`, if it is > `n / 2`\n if (options.canonical && s.cmp(this.nh) > 0) {\n s = this.n.sub(s);\n recoveryParam ^= 1;\n }\n\n return new Signature({ r: r, s: s, recoveryParam: recoveryParam });\n }\n};\n\nEC.prototype.verify = function verify(msg, signature, key, enc) {\n msg = this._truncateToN(new BN(msg, 16));\n key = this.keyFromPublic(key, enc);\n signature = new Signature(signature, 'hex');\n\n // Perform primitive values validation\n var r = signature.r;\n var s = signature.s;\n if (r.cmpn(1) < 0 || r.cmp(this.n) >= 0)\n return false;\n if (s.cmpn(1) < 0 || s.cmp(this.n) >= 0)\n return false;\n\n // Validate signature\n var sinv = s.invm(this.n);\n var u1 = sinv.mul(msg).umod(this.n);\n var u2 = sinv.mul(r).umod(this.n);\n var p;\n\n if (!this.curve._maxwellTrick) {\n p = this.g.mulAdd(u1, key.getPublic(), u2);\n if (p.isInfinity())\n return false;\n\n return p.getX().umod(this.n).cmp(r) === 0;\n }\n\n // NOTE: Greg Maxwell's trick, inspired by:\n // https://git.io/vad3K\n\n p = this.g.jmulAdd(u1, key.getPublic(), u2);\n if (p.isInfinity())\n return false;\n\n // Compare `p.x` of Jacobian point with `r`,\n // this will do `p.x == r * p.z^2` instead of multiplying `p.x` by the\n // inverse of `p.z^2`\n return p.eqXToP(r);\n};\n\nEC.prototype.recoverPubKey = function(msg, signature, j, enc) {\n assert((3 & j) === j, 'The recovery param is more than two bits');\n signature = new Signature(signature, enc);\n\n var n = this.n;\n var e = new BN(msg);\n var r = signature.r;\n var s = signature.s;\n\n // A set LSB signifies that the y-coordinate is odd\n var isYOdd = j & 1;\n var isSecondKey = j >> 1;\n if (r.cmp(this.curve.p.umod(this.curve.n)) >= 0 && isSecondKey)\n throw new Error('Unable to find sencond key candinate');\n\n // 1.1. Let x = r + jn.\n if (isSecondKey)\n r = this.curve.pointFromX(r.add(this.curve.n), isYOdd);\n else\n r = this.curve.pointFromX(r, isYOdd);\n\n var rInv = signature.r.invm(n);\n var s1 = n.sub(e).mul(rInv).umod(n);\n var s2 = s.mul(rInv).umod(n);\n\n // 1.6.1 Compute Q = r^-1 (sR - eG)\n // Q = r^-1 (sR + -eG)\n return this.g.mulAdd(s1, r, s2);\n};\n\nEC.prototype.getKeyRecoveryParam = function(e, signature, Q, enc) {\n signature = new Signature(signature, enc);\n if (signature.recoveryParam !== null)\n return signature.recoveryParam;\n\n for (var i = 0; i < 4; i++) {\n var Qprime;\n try {\n Qprime = this.recoverPubKey(e, signature, i);\n } catch (e) {\n continue;\n }\n\n if (Qprime.eq(Q))\n return i;\n }\n throw new Error('Unable to find valid recovery factor');\n};\n","'use strict';\n\nvar BN = require('bn.js');\nvar utils = require('../utils');\nvar assert = utils.assert;\n\nfunction KeyPair(ec, options) {\n this.ec = ec;\n this.priv = null;\n this.pub = null;\n\n // KeyPair(ec, { priv: ..., pub: ... })\n if (options.priv)\n this._importPrivate(options.priv, options.privEnc);\n if (options.pub)\n this._importPublic(options.pub, options.pubEnc);\n}\nmodule.exports = KeyPair;\n\nKeyPair.fromPublic = function fromPublic(ec, pub, enc) {\n if (pub instanceof KeyPair)\n return pub;\n\n return new KeyPair(ec, {\n pub: pub,\n pubEnc: enc,\n });\n};\n\nKeyPair.fromPrivate = function fromPrivate(ec, priv, enc) {\n if (priv instanceof KeyPair)\n return priv;\n\n return new KeyPair(ec, {\n priv: priv,\n privEnc: enc,\n });\n};\n\nKeyPair.prototype.validate = function validate() {\n var pub = this.getPublic();\n\n if (pub.isInfinity())\n return { result: false, reason: 'Invalid public key' };\n if (!pub.validate())\n return { result: false, reason: 'Public key is not a point' };\n if (!pub.mul(this.ec.curve.n).isInfinity())\n return { result: false, reason: 'Public key * N != O' };\n\n return { result: true, reason: null };\n};\n\nKeyPair.prototype.getPublic = function getPublic(compact, enc) {\n // compact is optional argument\n if (typeof compact === 'string') {\n enc = compact;\n compact = null;\n }\n\n if (!this.pub)\n this.pub = this.ec.g.mul(this.priv);\n\n if (!enc)\n return this.pub;\n\n return this.pub.encode(enc, compact);\n};\n\nKeyPair.prototype.getPrivate = function getPrivate(enc) {\n if (enc === 'hex')\n return this.priv.toString(16, 2);\n else\n return this.priv;\n};\n\nKeyPair.prototype._importPrivate = function _importPrivate(key, enc) {\n this.priv = new BN(key, enc || 16);\n\n // Ensure that the priv won't be bigger than n, otherwise we may fail\n // in fixed multiplication method\n this.priv = this.priv.umod(this.ec.curve.n);\n};\n\nKeyPair.prototype._importPublic = function _importPublic(key, enc) {\n if (key.x || key.y) {\n // Montgomery points only have an `x` coordinate.\n // Weierstrass/Edwards points on the other hand have both `x` and\n // `y` coordinates.\n if (this.ec.curve.type === 'mont') {\n assert(key.x, 'Need x coordinate');\n } else if (this.ec.curve.type === 'short' ||\n this.ec.curve.type === 'edwards') {\n assert(key.x && key.y, 'Need both x and y coordinate');\n }\n this.pub = this.ec.curve.point(key.x, key.y);\n return;\n }\n this.pub = this.ec.curve.decodePoint(key, enc);\n};\n\n// ECDH\nKeyPair.prototype.derive = function derive(pub) {\n if(!pub.validate()) {\n assert(pub.validate(), 'public point not validated');\n }\n return pub.mul(this.priv).getX();\n};\n\n// ECDSA\nKeyPair.prototype.sign = function sign(msg, enc, options) {\n return this.ec.sign(msg, this, enc, options);\n};\n\nKeyPair.prototype.verify = function verify(msg, signature) {\n return this.ec.verify(msg, signature, this);\n};\n\nKeyPair.prototype.inspect = function inspect() {\n return '<Key priv: ' + (this.priv && this.priv.toString(16, 2)) +\n ' pub: ' + (this.pub && this.pub.inspect()) + ' >';\n};\n","'use strict';\n\nvar BN = require('bn.js');\n\nvar utils = require('../utils');\nvar assert = utils.assert;\n\nfunction Signature(options, enc) {\n if (options instanceof Signature)\n return options;\n\n if (this._importDER(options, enc))\n return;\n\n assert(options.r && options.s, 'Signature without r or s');\n this.r = new BN(options.r, 16);\n this.s = new BN(options.s, 16);\n if (options.recoveryParam === undefined)\n this.recoveryParam = null;\n else\n this.recoveryParam = options.recoveryParam;\n}\nmodule.exports = Signature;\n\nfunction Position() {\n this.place = 0;\n}\n\nfunction getLength(buf, p) {\n var initial = buf[p.place++];\n if (!(initial & 0x80)) {\n return initial;\n }\n var octetLen = initial & 0xf;\n\n // Indefinite length or overflow\n if (octetLen === 0 || octetLen > 4) {\n return false;\n }\n\n var val = 0;\n for (var i = 0, off = p.place; i < octetLen; i++, off++) {\n val <<= 8;\n val |= buf[off];\n val >>>= 0;\n }\n\n // Leading zeroes\n if (val <= 0x7f) {\n return false;\n }\n\n p.place = off;\n return val;\n}\n\nfunction rmPadding(buf) {\n var i = 0;\n var len = buf.length - 1;\n while (!buf[i] && !(buf[i + 1] & 0x80) && i < len) {\n i++;\n }\n if (i === 0) {\n return buf;\n }\n return buf.slice(i);\n}\n\nSignature.prototype._importDER = function _importDER(data, enc) {\n data = utils.toArray(data, enc);\n var p = new Position();\n if (data[p.place++] !== 0x30) {\n return false;\n }\n var len = getLength(data, p);\n if (len === false) {\n return false;\n }\n if ((len + p.place) !== data.length) {\n return false;\n }\n if (data[p.place++] !== 0x02) {\n return false;\n }\n var rlen = getLength(data, p);\n if (rlen === false) {\n return false;\n }\n var r = data.slice(p.place, rlen + p.place);\n p.place += rlen;\n if (data[p.place++] !== 0x02) {\n return false;\n }\n var slen = getLength(data, p);\n if (slen === false) {\n return false;\n }\n if (data.length !== slen + p.place) {\n return false;\n }\n var s = data.slice(p.place, slen + p.place);\n if (r[0] === 0) {\n if (r[1] & 0x80) {\n r = r.slice(1);\n } else {\n // Leading zeroes\n return false;\n }\n }\n if (s[0] === 0) {\n if (s[1] & 0x80) {\n s = s.slice(1);\n } else {\n // Leading zeroes\n return false;\n }\n }\n\n this.r = new BN(r);\n this.s = new BN(s);\n this.recoveryParam = null;\n\n return true;\n};\n\nfunction constructLength(arr, len) {\n if (len < 0x80) {\n arr.push(len);\n return;\n }\n var octets = 1 + (Math.log(len) / Math.LN2 >>> 3);\n arr.push(octets | 0x80);\n while (--octets) {\n arr.push((len >>> (octets << 3)) & 0xff);\n }\n arr.push(len);\n}\n\nSignature.prototype.toDER = function toDER(enc) {\n var r = this.r.toArray();\n var s = this.s.toArray();\n\n // Pad values\n if (r[0] & 0x80)\n r = [ 0 ].concat(r);\n // Pad values\n if (s[0] & 0x80)\n s = [ 0 ].concat(s);\n\n r = rmPadding(r);\n s = rmPadding(s);\n\n while (!s[0] && !(s[1] & 0x80)) {\n s = s.slice(1);\n }\n var arr = [ 0x02 ];\n constructLength(arr, r.length);\n arr = arr.concat(r);\n arr.push(0x02);\n constructLength(arr, s.length);\n var backHalf = arr.concat(s);\n var res = [ 0x30 ];\n constructLength(res, backHalf.length);\n res = res.concat(backHalf);\n return utils.encode(res, enc);\n};\n","'use strict';\n\nvar hash = require('hash.js');\nvar curves = require('../curves');\nvar utils = require('../utils');\nvar assert = utils.assert;\nvar parseBytes = utils.parseBytes;\nvar KeyPair = require('./key');\nvar Signature = require('./signature');\n\nfunction EDDSA(curve) {\n assert(curve === 'ed25519', 'only tested with ed25519 so far');\n\n if (!(this instanceof EDDSA))\n return new EDDSA(curve);\n\n curve = curves[curve].curve;\n this.curve = curve;\n this.g = curve.g;\n this.g.precompute(curve.n.bitLength() + 1);\n\n this.pointClass = curve.point().constructor;\n this.encodingLength = Math.ceil(curve.n.bitLength() / 8);\n this.hash = hash.sha512;\n}\n\nmodule.exports = EDDSA;\n\n/**\n* @param {Array|String} message - message bytes\n* @param {Array|String|KeyPair} secret - secret bytes or a keypair\n* @returns {Signature} - signature\n*/\nEDDSA.prototype.sign = function sign(message, secret) {\n message = parseBytes(message);\n var key = this.keyFromSecret(secret);\n var r = this.hashInt(key.messagePrefix(), message);\n var R = this.g.mul(r);\n var Rencoded = this.encodePoint(R);\n var s_ = this.hashInt(Rencoded, key.pubBytes(), message)\n .mul(key.priv());\n var S = r.add(s_).umod(this.curve.n);\n return this.makeSignature({ R: R, S: S, Rencoded: Rencoded });\n};\n\n/**\n* @param {Array} message - message bytes\n* @param {Array|String|Signature} sig - sig bytes\n* @param {Array|String|Point|KeyPair} pub - public key\n* @returns {Boolean} - true if public key matches sig of message\n*/\nEDDSA.prototype.verify = function verify(message, sig, pub) {\n message = parseBytes(message);\n sig = this.makeSignature(sig);\n var key = this.keyFromPublic(pub);\n var h = this.hashInt(sig.Rencoded(), key.pubBytes(), message);\n var SG = this.g.mul(sig.S());\n var RplusAh = sig.R().add(key.pub().mul(h));\n return RplusAh.eq(SG);\n};\n\nEDDSA.prototype.hashInt = function hashInt() {\n var hash = this.hash();\n for (var i = 0; i < arguments.length; i++)\n hash.update(arguments[i]);\n return utils.intFromLE(hash.digest()).umod(this.curve.n);\n};\n\nEDDSA.prototype.keyFromPublic = function keyFromPublic(pub) {\n return KeyPair.fromPublic(this, pub);\n};\n\nEDDSA.prototype.keyFromSecret = function keyFromSecret(secret) {\n return KeyPair.fromSecret(this, secret);\n};\n\nEDDSA.prototype.makeSignature = function makeSignature(sig) {\n if (sig instanceof Signature)\n return sig;\n return new Signature(this, sig);\n};\n\n/**\n* * https://tools.ietf.org/html/draft-josefsson-eddsa-ed25519-03#section-5.2\n*\n* EDDSA defines methods for encoding and decoding points and integers. These are\n* helper convenience methods, that pass along to utility functions implied\n* parameters.\n*\n*/\nEDDSA.prototype.encodePoint = function encodePoint(point) {\n var enc = point.getY().toArray('le', this.encodingLength);\n enc[this.encodingLength - 1] |= point.getX().isOdd() ? 0x80 : 0;\n return enc;\n};\n\nEDDSA.prototype.decodePoint = function decodePoint(bytes) {\n bytes = utils.parseBytes(bytes);\n\n var lastIx = bytes.length - 1;\n var normed = bytes.slice(0, lastIx).concat(bytes[lastIx] & ~0x80);\n var xIsOdd = (bytes[lastIx] & 0x80) !== 0;\n\n var y = utils.intFromLE(normed);\n return this.curve.pointFromY(y, xIsOdd);\n};\n\nEDDSA.prototype.encodeInt = function encodeInt(num) {\n return num.toArray('le', this.encodingLength);\n};\n\nEDDSA.prototype.decodeInt = function decodeInt(bytes) {\n return utils.intFromLE(bytes);\n};\n\nEDDSA.prototype.isPoint = function isPoint(val) {\n return val instanceof this.pointClass;\n};\n","'use strict';\n\nvar utils = require('../utils');\nvar assert = utils.assert;\nvar parseBytes = utils.parseBytes;\nvar cachedProperty = utils.cachedProperty;\n\n/**\n* @param {EDDSA} eddsa - instance\n* @param {Object} params - public/private key parameters\n*\n* @param {Array<Byte>} [params.secret] - secret seed bytes\n* @param {Point} [params.pub] - public key point (aka `A` in eddsa terms)\n* @param {Array<Byte>} [params.pub] - public key point encoded as bytes\n*\n*/\nfunction KeyPair(eddsa, params) {\n this.eddsa = eddsa;\n this._secret = parseBytes(params.secret);\n if (eddsa.isPoint(params.pub))\n this._pub = params.pub;\n else\n this._pubBytes = parseBytes(params.pub);\n}\n\nKeyPair.fromPublic = function fromPublic(eddsa, pub) {\n if (pub instanceof KeyPair)\n return pub;\n return new KeyPair(eddsa, { pub: pub });\n};\n\nKeyPair.fromSecret = function fromSecret(eddsa, secret) {\n if (secret instanceof KeyPair)\n return secret;\n return new KeyPair(eddsa, { secret: secret });\n};\n\nKeyPair.prototype.secret = function secret() {\n return this._secret;\n};\n\ncachedProperty(KeyPair, 'pubBytes', function pubBytes() {\n return this.eddsa.encodePoint(this.pub());\n});\n\ncachedProperty(KeyPair, 'pub', function pub() {\n if (this._pubBytes)\n return this.eddsa.decodePoint(this._pubBytes);\n return this.eddsa.g.mul(this.priv());\n});\n\ncachedProperty(KeyPair, 'privBytes', function privBytes() {\n var eddsa = this.eddsa;\n var hash = this.hash();\n var lastIx = eddsa.encodingLength - 1;\n\n var a = hash.slice(0, eddsa.encodingLength);\n a[0] &= 248;\n a[lastIx] &= 127;\n a[lastIx] |= 64;\n\n return a;\n});\n\ncachedProperty(KeyPair, 'priv', function priv() {\n return this.eddsa.decodeInt(this.privBytes());\n});\n\ncachedProperty(KeyPair, 'hash', function hash() {\n return this.eddsa.hash().update(this.secret()).digest();\n});\n\ncachedProperty(KeyPair, 'messagePrefix', function messagePrefix() {\n return this.hash().slice(this.eddsa.encodingLength);\n});\n\nKeyPair.prototype.sign = function sign(message) {\n assert(this._secret, 'KeyPair can only verify');\n return this.eddsa.sign(message, this);\n};\n\nKeyPair.prototype.verify = function verify(message, sig) {\n return this.eddsa.verify(message, sig, this);\n};\n\nKeyPair.prototype.getSecret = function getSecret(enc) {\n assert(this._secret, 'KeyPair is public only');\n return utils.encode(this.secret(), enc);\n};\n\nKeyPair.prototype.getPublic = function getPublic(enc) {\n return utils.encode(this.pubBytes(), enc);\n};\n\nmodule.exports = KeyPair;\n","'use strict';\n\nvar BN = require('bn.js');\nvar utils = require('../utils');\nvar assert = utils.assert;\nvar cachedProperty = utils.cachedProperty;\nvar parseBytes = utils.parseBytes;\n\n/**\n* @param {EDDSA} eddsa - eddsa instance\n* @param {Array<Bytes>|Object} sig -\n* @param {Array<Bytes>|Point} [sig.R] - R point as Point or bytes\n* @param {Array<Bytes>|bn} [sig.S] - S scalar as bn or bytes\n* @param {Array<Bytes>} [sig.Rencoded] - R point encoded\n* @param {Array<Bytes>} [sig.Sencoded] - S scalar encoded\n*/\nfunction Signature(eddsa, sig) {\n this.eddsa = eddsa;\n\n if (typeof sig !== 'object')\n sig = parseBytes(sig);\n\n if (Array.isArray(sig)) {\n sig = {\n R: sig.slice(0, eddsa.encodingLength),\n S: sig.slice(eddsa.encodingLength),\n };\n }\n\n assert(sig.R && sig.S, 'Signature without R or S');\n\n if (eddsa.isPoint(sig.R))\n this._R = sig.R;\n if (sig.S instanceof BN)\n this._S = sig.S;\n\n this._Rencoded = Array.isArray(sig.R) ? sig.R : sig.Rencoded;\n this._Sencoded = Array.isArray(sig.S) ? sig.S : sig.Sencoded;\n}\n\ncachedProperty(Signature, 'S', function S() {\n return this.eddsa.decodeInt(this.Sencoded());\n});\n\ncachedProperty(Signature, 'R', function R() {\n return this.eddsa.decodePoint(this.Rencoded());\n});\n\ncachedProperty(Signature, 'Rencoded', function Rencoded() {\n return this.eddsa.encodePoint(this.R());\n});\n\ncachedProperty(Signature, 'Sencoded', function Sencoded() {\n return this.eddsa.encodeInt(this.S());\n});\n\nSignature.prototype.toBytes = function toBytes() {\n return this.Rencoded().concat(this.Sencoded());\n};\n\nSignature.prototype.toHex = function toHex() {\n return utils.encode(this.toBytes(), 'hex').toUpperCase();\n};\n\nmodule.exports = Signature;\n","module.exports = {\n doubles: {\n step: 4,\n points: [\n [\n 'e60fce93b59e9ec53011aabc21c23e97b2a31369b87a5ae9c44ee89e2a6dec0a',\n 'f7e3507399e595929db99f34f57937101296891e44d23f0be1f32cce69616821',\n ],\n [\n '8282263212c609d9ea2a6e3e172de238d8c39cabd5ac1ca10646e23fd5f51508',\n '11f8a8098557dfe45e8256e830b60ace62d613ac2f7b17bed31b6eaff6e26caf',\n ],\n [\n '175e159f728b865a72f99cc6c6fc846de0b93833fd2222ed73fce5b551e5b739',\n 'd3506e0d9e3c79eba4ef97a51ff71f5eacb5955add24345c6efa6ffee9fed695',\n ],\n [\n '363d90d447b00c9c99ceac05b6262ee053441c7e55552ffe526bad8f83ff4640',\n '4e273adfc732221953b445397f3363145b9a89008199ecb62003c7f3bee9de9',\n ],\n [\n '8b4b5f165df3c2be8c6244b5b745638843e4a781a15bcd1b69f79a55dffdf80c',\n '4aad0a6f68d308b4b3fbd7813ab0da04f9e336546162ee56b3eff0c65fd4fd36',\n ],\n [\n '723cbaa6e5db996d6bf771c00bd548c7b700dbffa6c0e77bcb6115925232fcda',\n '96e867b5595cc498a921137488824d6e2660a0653779494801dc069d9eb39f5f',\n ],\n [\n 'eebfa4d493bebf98ba5feec812c2d3b50947961237a919839a533eca0e7dd7fa',\n '5d9a8ca3970ef0f269ee7edaf178089d9ae4cdc3a711f712ddfd4fdae1de8999',\n ],\n [\n '100f44da696e71672791d0a09b7bde459f1215a29b3c03bfefd7835b39a48db0',\n 'cdd9e13192a00b772ec8f3300c090666b7ff4a18ff5195ac0fbd5cd62bc65a09',\n ],\n [\n 'e1031be262c7ed1b1dc9227a4a04c017a77f8d4464f3b3852c8acde6e534fd2d',\n '9d7061928940405e6bb6a4176597535af292dd419e1ced79a44f18f29456a00d',\n ],\n [\n 'feea6cae46d55b530ac2839f143bd7ec5cf8b266a41d6af52d5e688d9094696d',\n 'e57c6b6c97dce1bab06e4e12bf3ecd5c981c8957cc41442d3155debf18090088',\n ],\n [\n 'da67a91d91049cdcb367be4be6ffca3cfeed657d808583de33fa978bc1ec6cb1',\n '9bacaa35481642bc41f463f7ec9780e5dec7adc508f740a17e9ea8e27a68be1d',\n ],\n [\n '53904faa0b334cdda6e000935ef22151ec08d0f7bb11069f57545ccc1a37b7c0',\n '5bc087d0bc80106d88c9eccac20d3c1c13999981e14434699dcb096b022771c8',\n ],\n [\n '8e7bcd0bd35983a7719cca7764ca906779b53a043a9b8bcaeff959f43ad86047',\n '10b7770b2a3da4b3940310420ca9514579e88e2e47fd68b3ea10047e8460372a',\n ],\n [\n '385eed34c1cdff21e6d0818689b81bde71a7f4f18397e6690a841e1599c43862',\n '283bebc3e8ea23f56701de19e9ebf4576b304eec2086dc8cc0458fe5542e5453',\n ],\n [\n '6f9d9b803ecf191637c73a4413dfa180fddf84a5947fbc9c606ed86c3fac3a7',\n '7c80c68e603059ba69b8e2a30e45c4d47ea4dd2f5c281002d86890603a842160',\n ],\n [\n '3322d401243c4e2582a2147c104d6ecbf774d163db0f5e5313b7e0e742d0e6bd',\n '56e70797e9664ef5bfb019bc4ddaf9b72805f63ea2873af624f3a2e96c28b2a0',\n ],\n [\n '85672c7d2de0b7da2bd1770d89665868741b3f9af7643397721d74d28134ab83',\n '7c481b9b5b43b2eb6374049bfa62c2e5e77f17fcc5298f44c8e3094f790313a6',\n ],\n [\n '948bf809b1988a46b06c9f1919413b10f9226c60f668832ffd959af60c82a0a',\n '53a562856dcb6646dc6b74c5d1c3418c6d4dff08c97cd2bed4cb7f88d8c8e589',\n ],\n [\n '6260ce7f461801c34f067ce0f02873a8f1b0e44dfc69752accecd819f38fd8e8',\n 'bc2da82b6fa5b571a7f09049776a1ef7ecd292238051c198c1a84e95b2b4ae17',\n ],\n [\n 'e5037de0afc1d8d43d8348414bbf4103043ec8f575bfdc432953cc8d2037fa2d',\n '4571534baa94d3b5f9f98d09fb990bddbd5f5b03ec481f10e0e5dc841d755bda',\n ],\n [\n 'e06372b0f4a207adf5ea905e8f1771b4e7e8dbd1c6a6c5b725866a0ae4fce725',\n '7a908974bce18cfe12a27bb2ad5a488cd7484a7787104870b27034f94eee31dd',\n ],\n [\n '213c7a715cd5d45358d0bbf9dc0ce02204b10bdde2a3f58540ad6908d0559754',\n '4b6dad0b5ae462507013ad06245ba190bb4850f5f36a7eeddff2c27534b458f2',\n ],\n [\n '4e7c272a7af4b34e8dbb9352a5419a87e2838c70adc62cddf0cc3a3b08fbd53c',\n '17749c766c9d0b18e16fd09f6def681b530b9614bff7dd33e0b3941817dcaae6',\n ],\n [\n 'fea74e3dbe778b1b10f238ad61686aa5c76e3db2be43057632427e2840fb27b6',\n '6e0568db9b0b13297cf674deccb6af93126b596b973f7b77701d3db7f23cb96f',\n ],\n [\n '76e64113f677cf0e10a2570d599968d31544e179b760432952c02a4417bdde39',\n 'c90ddf8dee4e95cf577066d70681f0d35e2a33d2b56d2032b4b1752d1901ac01',\n ],\n [\n 'c738c56b03b2abe1e8281baa743f8f9a8f7cc643df26cbee3ab150242bcbb891',\n '893fb578951ad2537f718f2eacbfbbbb82314eef7880cfe917e735d9699a84c3',\n ],\n [\n 'd895626548b65b81e264c7637c972877d1d72e5f3a925014372e9f6588f6c14b',\n 'febfaa38f2bc7eae728ec60818c340eb03428d632bb067e179363ed75d7d991f',\n ],\n [\n 'b8da94032a957518eb0f6433571e8761ceffc73693e84edd49150a564f676e03',\n '2804dfa44805a1e4d7c99cc9762808b092cc584d95ff3b511488e4e74efdf6e7',\n ],\n [\n 'e80fea14441fb33a7d8adab9475d7fab2019effb5156a792f1a11778e3c0df5d',\n 'eed1de7f638e00771e89768ca3ca94472d155e80af322ea9fcb4291b6ac9ec78',\n ],\n [\n 'a301697bdfcd704313ba48e51d567543f2a182031efd6915ddc07bbcc4e16070',\n '7370f91cfb67e4f5081809fa25d40f9b1735dbf7c0a11a130c0d1a041e177ea1',\n ],\n [\n '90ad85b389d6b936463f9d0512678de208cc330b11307fffab7ac63e3fb04ed4',\n 'e507a3620a38261affdcbd9427222b839aefabe1582894d991d4d48cb6ef150',\n ],\n [\n '8f68b9d2f63b5f339239c1ad981f162ee88c5678723ea3351b7b444c9ec4c0da',\n '662a9f2dba063986de1d90c2b6be215dbbea2cfe95510bfdf23cbf79501fff82',\n ],\n [\n 'e4f3fb0176af85d65ff99ff9198c36091f48e86503681e3e6686fd5053231e11',\n '1e63633ad0ef4f1c1661a6d0ea02b7286cc7e74ec951d1c9822c38576feb73bc',\n ],\n [\n '8c00fa9b18ebf331eb961537a45a4266c7034f2f0d4e1d0716fb6eae20eae29e',\n 'efa47267fea521a1a9dc343a3736c974c2fadafa81e36c54e7d2a4c66702414b',\n ],\n [\n 'e7a26ce69dd4829f3e10cec0a9e98ed3143d084f308b92c0997fddfc60cb3e41',\n '2a758e300fa7984b471b006a1aafbb18d0a6b2c0420e83e20e8a9421cf2cfd51',\n ],\n [\n 'b6459e0ee3662ec8d23540c223bcbdc571cbcb967d79424f3cf29eb3de6b80ef',\n '67c876d06f3e06de1dadf16e5661db3c4b3ae6d48e35b2ff30bf0b61a71ba45',\n ],\n [\n 'd68a80c8280bb840793234aa118f06231d6f1fc67e73c5a5deda0f5b496943e8',\n 'db8ba9fff4b586d00c4b1f9177b0e28b5b0e7b8f7845295a294c84266b133120',\n ],\n [\n '324aed7df65c804252dc0270907a30b09612aeb973449cea4095980fc28d3d5d',\n '648a365774b61f2ff130c0c35aec1f4f19213b0c7e332843967224af96ab7c84',\n ],\n [\n '4df9c14919cde61f6d51dfdbe5fee5dceec4143ba8d1ca888e8bd373fd054c96',\n '35ec51092d8728050974c23a1d85d4b5d506cdc288490192ebac06cad10d5d',\n ],\n [\n '9c3919a84a474870faed8a9c1cc66021523489054d7f0308cbfc99c8ac1f98cd',\n 'ddb84f0f4a4ddd57584f044bf260e641905326f76c64c8e6be7e5e03d4fc599d',\n ],\n [\n '6057170b1dd12fdf8de05f281d8e06bb91e1493a8b91d4cc5a21382120a959e5',\n '9a1af0b26a6a4807add9a2daf71df262465152bc3ee24c65e899be932385a2a8',\n ],\n [\n 'a576df8e23a08411421439a4518da31880cef0fba7d4df12b1a6973eecb94266',\n '40a6bf20e76640b2c92b97afe58cd82c432e10a7f514d9f3ee8be11ae1b28ec8',\n ],\n [\n '7778a78c28dec3e30a05fe9629de8c38bb30d1f5cf9a3a208f763889be58ad71',\n '34626d9ab5a5b22ff7098e12f2ff580087b38411ff24ac563b513fc1fd9f43ac',\n ],\n [\n '928955ee637a84463729fd30e7afd2ed5f96274e5ad7e5cb09eda9c06d903ac',\n 'c25621003d3f42a827b78a13093a95eeac3d26efa8a8d83fc5180e935bcd091f',\n ],\n [\n '85d0fef3ec6db109399064f3a0e3b2855645b4a907ad354527aae75163d82751',\n '1f03648413a38c0be29d496e582cf5663e8751e96877331582c237a24eb1f962',\n ],\n [\n 'ff2b0dce97eece97c1c9b6041798b85dfdfb6d8882da20308f5404824526087e',\n '493d13fef524ba188af4c4dc54d07936c7b7ed6fb90e2ceb2c951e01f0c29907',\n ],\n [\n '827fbbe4b1e880ea9ed2b2e6301b212b57f1ee148cd6dd28780e5e2cf856e241',\n 'c60f9c923c727b0b71bef2c67d1d12687ff7a63186903166d605b68baec293ec',\n ],\n [\n 'eaa649f21f51bdbae7be4ae34ce6e5217a58fdce7f47f9aa7f3b58fa2120e2b3',\n 'be3279ed5bbbb03ac69a80f89879aa5a01a6b965f13f7e59d47a5305ba5ad93d',\n ],\n [\n 'e4a42d43c5cf169d9391df6decf42ee541b6d8f0c9a137401e23632dda34d24f',\n '4d9f92e716d1c73526fc99ccfb8ad34ce886eedfa8d8e4f13a7f7131deba9414',\n ],\n [\n '1ec80fef360cbdd954160fadab352b6b92b53576a88fea4947173b9d4300bf19',\n 'aeefe93756b5340d2f3a4958a7abbf5e0146e77f6295a07b671cdc1cc107cefd',\n ],\n [\n '146a778c04670c2f91b00af4680dfa8bce3490717d58ba889ddb5928366642be',\n 'b318e0ec3354028add669827f9d4b2870aaa971d2f7e5ed1d0b297483d83efd0',\n ],\n [\n 'fa50c0f61d22e5f07e3acebb1aa07b128d0012209a28b9776d76a8793180eef9',\n '6b84c6922397eba9b72cd2872281a68a5e683293a57a213b38cd8d7d3f4f2811',\n ],\n [\n 'da1d61d0ca721a11b1a5bf6b7d88e8421a288ab5d5bba5220e53d32b5f067ec2',\n '8157f55a7c99306c79c0766161c91e2966a73899d279b48a655fba0f1ad836f1',\n ],\n [\n 'a8e282ff0c9706907215ff98e8fd416615311de0446f1e062a73b0610d064e13',\n '7f97355b8db81c09abfb7f3c5b2515888b679a3e50dd6bd6cef7c73111f4cc0c',\n ],\n [\n '174a53b9c9a285872d39e56e6913cab15d59b1fa512508c022f382de8319497c',\n 'ccc9dc37abfc9c1657b4155f2c47f9e6646b3a1d8cb9854383da13ac079afa73',\n ],\n [\n '959396981943785c3d3e57edf5018cdbe039e730e4918b3d884fdff09475b7ba',\n '2e7e552888c331dd8ba0386a4b9cd6849c653f64c8709385e9b8abf87524f2fd',\n ],\n [\n 'd2a63a50ae401e56d645a1153b109a8fcca0a43d561fba2dbb51340c9d82b151',\n 'e82d86fb6443fcb7565aee58b2948220a70f750af484ca52d4142174dcf89405',\n ],\n [\n '64587e2335471eb890ee7896d7cfdc866bacbdbd3839317b3436f9b45617e073',\n 'd99fcdd5bf6902e2ae96dd6447c299a185b90a39133aeab358299e5e9faf6589',\n ],\n [\n '8481bde0e4e4d885b3a546d3e549de042f0aa6cea250e7fd358d6c86dd45e458',\n '38ee7b8cba5404dd84a25bf39cecb2ca900a79c42b262e556d64b1b59779057e',\n ],\n [\n '13464a57a78102aa62b6979ae817f4637ffcfed3c4b1ce30bcd6303f6caf666b',\n '69be159004614580ef7e433453ccb0ca48f300a81d0942e13f495a907f6ecc27',\n ],\n [\n 'bc4a9df5b713fe2e9aef430bcc1dc97a0cd9ccede2f28588cada3a0d2d83f366',\n 'd3a81ca6e785c06383937adf4b798caa6e8a9fbfa547b16d758d666581f33c1',\n ],\n [\n '8c28a97bf8298bc0d23d8c749452a32e694b65e30a9472a3954ab30fe5324caa',\n '40a30463a3305193378fedf31f7cc0eb7ae784f0451cb9459e71dc73cbef9482',\n ],\n [\n '8ea9666139527a8c1dd94ce4f071fd23c8b350c5a4bb33748c4ba111faccae0',\n '620efabbc8ee2782e24e7c0cfb95c5d735b783be9cf0f8e955af34a30e62b945',\n ],\n [\n 'dd3625faef5ba06074669716bbd3788d89bdde815959968092f76cc4eb9a9787',\n '7a188fa3520e30d461da2501045731ca941461982883395937f68d00c644a573',\n ],\n [\n 'f710d79d9eb962297e4f6232b40e8f7feb2bc63814614d692c12de752408221e',\n 'ea98e67232d3b3295d3b535532115ccac8612c721851617526ae47a9c77bfc82',\n ],\n ],\n },\n naf: {\n wnd: 7,\n points: [\n [\n 'f9308a019258c31049344f85f89d5229b531c845836f99b08601f113bce036f9',\n '388f7b0f632de8140fe337e62a37f3566500a99934c2231b6cb9fd7584b8e672',\n ],\n [\n '2f8bde4d1a07209355b4a7250a5c5128e88b84bddc619ab7cba8d569b240efe4',\n 'd8ac222636e5e3d6d4dba9dda6c9c426f788271bab0d6840dca87d3aa6ac62d6',\n ],\n [\n '5cbdf0646e5db4eaa398f365f2ea7a0e3d419b7e0330e39ce92bddedcac4f9bc',\n '6aebca40ba255960a3178d6d861a54dba813d0b813fde7b5a5082628087264da',\n ],\n [\n 'acd484e2f0c7f65309ad178a9f559abde09796974c57e714c35f110dfc27ccbe',\n 'cc338921b0a7d9fd64380971763b61e9add888a4375f8e0f05cc262ac64f9c37',\n ],\n [\n '774ae7f858a9411e5ef4246b70c65aac5649980be5c17891bbec17895da008cb',\n 'd984a032eb6b5e190243dd56d7b7b365372db1e2dff9d6a8301d74c9c953c61b',\n ],\n [\n 'f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8',\n 'ab0902e8d880a89758212eb65cdaf473a1a06da521fa91f29b5cb52db03ed81',\n ],\n [\n 'd7924d4f7d43ea965a465ae3095ff41131e5946f3c85f79e44adbcf8e27e080e',\n '581e2872a86c72a683842ec228cc6defea40af2bd896d3a5c504dc9ff6a26b58',\n ],\n [\n 'defdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34',\n '4211ab0694635168e997b0ead2a93daeced1f4a04a95c0f6cfb199f69e56eb77',\n ],\n [\n '2b4ea0a797a443d293ef5cff444f4979f06acfebd7e86d277475656138385b6c',\n '85e89bc037945d93b343083b5a1c86131a01f60c50269763b570c854e5c09b7a',\n ],\n [\n '352bbf4a4cdd12564f93fa332ce333301d9ad40271f8107181340aef25be59d5',\n '321eb4075348f534d59c18259dda3e1f4a1b3b2e71b1039c67bd3d8bcf81998c',\n ],\n [\n '2fa2104d6b38d11b0230010559879124e42ab8dfeff5ff29dc9cdadd4ecacc3f',\n '2de1068295dd865b64569335bd5dd80181d70ecfc882648423ba76b532b7d67',\n ],\n [\n '9248279b09b4d68dab21a9b066edda83263c3d84e09572e269ca0cd7f5453714',\n '73016f7bf234aade5d1aa71bdea2b1ff3fc0de2a887912ffe54a32ce97cb3402',\n ],\n [\n 'daed4f2be3a8bf278e70132fb0beb7522f570e144bf615c07e996d443dee8729',\n 'a69dce4a7d6c98e8d4a1aca87ef8d7003f83c230f3afa726ab40e52290be1c55',\n ],\n [\n 'c44d12c7065d812e8acf28d7cbb19f9011ecd9e9fdf281b0e6a3b5e87d22e7db',\n '2119a460ce326cdc76c45926c982fdac0e106e861edf61c5a039063f0e0e6482',\n ],\n [\n '6a245bf6dc698504c89a20cfded60853152b695336c28063b61c65cbd269e6b4',\n 'e022cf42c2bd4a708b3f5126f16a24ad8b33ba48d0423b6efd5e6348100d8a82',\n ],\n [\n '1697ffa6fd9de627c077e3d2fe541084ce13300b0bec1146f95ae57f0d0bd6a5',\n 'b9c398f186806f5d27561506e4557433a2cf15009e498ae7adee9d63d01b2396',\n ],\n [\n '605bdb019981718b986d0f07e834cb0d9deb8360ffb7f61df982345ef27a7479',\n '2972d2de4f8d20681a78d93ec96fe23c26bfae84fb14db43b01e1e9056b8c49',\n ],\n [\n '62d14dab4150bf497402fdc45a215e10dcb01c354959b10cfe31c7e9d87ff33d',\n '80fc06bd8cc5b01098088a1950eed0db01aa132967ab472235f5642483b25eaf',\n ],\n [\n '80c60ad0040f27dade5b4b06c408e56b2c50e9f56b9b8b425e555c2f86308b6f',\n '1c38303f1cc5c30f26e66bad7fe72f70a65eed4cbe7024eb1aa01f56430bd57a',\n ],\n [\n '7a9375ad6167ad54aa74c6348cc54d344cc5dc9487d847049d5eabb0fa03c8fb',\n 'd0e3fa9eca8726909559e0d79269046bdc59ea10c70ce2b02d499ec224dc7f7',\n ],\n [\n 'd528ecd9b696b54c907a9ed045447a79bb408ec39b68df504bb51f459bc3ffc9',\n 'eecf41253136e5f99966f21881fd656ebc4345405c520dbc063465b521409933',\n ],\n [\n '49370a4b5f43412ea25f514e8ecdad05266115e4a7ecb1387231808f8b45963',\n '758f3f41afd6ed428b3081b0512fd62a54c3f3afbb5b6764b653052a12949c9a',\n ],\n [\n '77f230936ee88cbbd73df930d64702ef881d811e0e1498e2f1c13eb1fc345d74',\n '958ef42a7886b6400a08266e9ba1b37896c95330d97077cbbe8eb3c7671c60d6',\n ],\n [\n 'f2dac991cc4ce4b9ea44887e5c7c0bce58c80074ab9d4dbaeb28531b7739f530',\n 'e0dedc9b3b2f8dad4da1f32dec2531df9eb5fbeb0598e4fd1a117dba703a3c37',\n ],\n [\n '463b3d9f662621fb1b4be8fbbe2520125a216cdfc9dae3debcba4850c690d45b',\n '5ed430d78c296c3543114306dd8622d7c622e27c970a1de31cb377b01af7307e',\n ],\n [\n 'f16f804244e46e2a09232d4aff3b59976b98fac14328a2d1a32496b49998f247',\n 'cedabd9b82203f7e13d206fcdf4e33d92a6c53c26e5cce26d6579962c4e31df6',\n ],\n [\n 'caf754272dc84563b0352b7a14311af55d245315ace27c65369e15f7151d41d1',\n 'cb474660ef35f5f2a41b643fa5e460575f4fa9b7962232a5c32f908318a04476',\n ],\n [\n '2600ca4b282cb986f85d0f1709979d8b44a09c07cb86d7c124497bc86f082120',\n '4119b88753c15bd6a693b03fcddbb45d5ac6be74ab5f0ef44b0be9475a7e4b40',\n ],\n [\n '7635ca72d7e8432c338ec53cd12220bc01c48685e24f7dc8c602a7746998e435',\n '91b649609489d613d1d5e590f78e6d74ecfc061d57048bad9e76f302c5b9c61',\n ],\n [\n '754e3239f325570cdbbf4a87deee8a66b7f2b33479d468fbc1a50743bf56cc18',\n '673fb86e5bda30fb3cd0ed304ea49a023ee33d0197a695d0c5d98093c536683',\n ],\n [\n 'e3e6bd1071a1e96aff57859c82d570f0330800661d1c952f9fe2694691d9b9e8',\n '59c9e0bba394e76f40c0aa58379a3cb6a5a2283993e90c4167002af4920e37f5',\n ],\n [\n '186b483d056a033826ae73d88f732985c4ccb1f32ba35f4b4cc47fdcf04aa6eb',\n '3b952d32c67cf77e2e17446e204180ab21fb8090895138b4a4a797f86e80888b',\n ],\n [\n 'df9d70a6b9876ce544c98561f4be4f725442e6d2b737d9c91a8321724ce0963f',\n '55eb2dafd84d6ccd5f862b785dc39d4ab157222720ef9da217b8c45cf2ba2417',\n ],\n [\n '5edd5cc23c51e87a497ca815d5dce0f8ab52554f849ed8995de64c5f34ce7143',\n 'efae9c8dbc14130661e8cec030c89ad0c13c66c0d17a2905cdc706ab7399a868',\n ],\n [\n '290798c2b6476830da12fe02287e9e777aa3fba1c355b17a722d362f84614fba',\n 'e38da76dcd440621988d00bcf79af25d5b29c094db2a23146d003afd41943e7a',\n ],\n [\n 'af3c423a95d9f5b3054754efa150ac39cd29552fe360257362dfdecef4053b45',\n 'f98a3fd831eb2b749a93b0e6f35cfb40c8cd5aa667a15581bc2feded498fd9c6',\n ],\n [\n '766dbb24d134e745cccaa28c99bf274906bb66b26dcf98df8d2fed50d884249a',\n '744b1152eacbe5e38dcc887980da38b897584a65fa06cedd2c924f97cbac5996',\n ],\n [\n '59dbf46f8c94759ba21277c33784f41645f7b44f6c596a58ce92e666191abe3e',\n 'c534ad44175fbc300f4ea6ce648309a042ce739a7919798cd85e216c4a307f6e',\n ],\n [\n 'f13ada95103c4537305e691e74e9a4a8dd647e711a95e73cb62dc6018cfd87b8',\n 'e13817b44ee14de663bf4bc808341f326949e21a6a75c2570778419bdaf5733d',\n ],\n [\n '7754b4fa0e8aced06d4167a2c59cca4cda1869c06ebadfb6488550015a88522c',\n '30e93e864e669d82224b967c3020b8fa8d1e4e350b6cbcc537a48b57841163a2',\n ],\n [\n '948dcadf5990e048aa3874d46abef9d701858f95de8041d2a6828c99e2262519',\n 'e491a42537f6e597d5d28a3224b1bc25df9154efbd2ef1d2cbba2cae5347d57e',\n ],\n [\n '7962414450c76c1689c7b48f8202ec37fb224cf5ac0bfa1570328a8a3d7c77ab',\n '100b610ec4ffb4760d5c1fc133ef6f6b12507a051f04ac5760afa5b29db83437',\n ],\n [\n '3514087834964b54b15b160644d915485a16977225b8847bb0dd085137ec47ca',\n 'ef0afbb2056205448e1652c48e8127fc6039e77c15c2378b7e7d15a0de293311',\n ],\n [\n 'd3cc30ad6b483e4bc79ce2c9dd8bc54993e947eb8df787b442943d3f7b527eaf',\n '8b378a22d827278d89c5e9be8f9508ae3c2ad46290358630afb34db04eede0a4',\n ],\n [\n '1624d84780732860ce1c78fcbfefe08b2b29823db913f6493975ba0ff4847610',\n '68651cf9b6da903e0914448c6cd9d4ca896878f5282be4c8cc06e2a404078575',\n ],\n [\n '733ce80da955a8a26902c95633e62a985192474b5af207da6df7b4fd5fc61cd4',\n 'f5435a2bd2badf7d485a4d8b8db9fcce3e1ef8e0201e4578c54673bc1dc5ea1d',\n ],\n [\n '15d9441254945064cf1a1c33bbd3b49f8966c5092171e699ef258dfab81c045c',\n 'd56eb30b69463e7234f5137b73b84177434800bacebfc685fc37bbe9efe4070d',\n ],\n [\n 'a1d0fcf2ec9de675b612136e5ce70d271c21417c9d2b8aaaac138599d0717940',\n 'edd77f50bcb5a3cab2e90737309667f2641462a54070f3d519212d39c197a629',\n ],\n [\n 'e22fbe15c0af8ccc5780c0735f84dbe9a790badee8245c06c7ca37331cb36980',\n 'a855babad5cd60c88b430a69f53a1a7a38289154964799be43d06d77d31da06',\n ],\n [\n '311091dd9860e8e20ee13473c1155f5f69635e394704eaa74009452246cfa9b3',\n '66db656f87d1f04fffd1f04788c06830871ec5a64feee685bd80f0b1286d8374',\n ],\n [\n '34c1fd04d301be89b31c0442d3e6ac24883928b45a9340781867d4232ec2dbdf',\n '9414685e97b1b5954bd46f730174136d57f1ceeb487443dc5321857ba73abee',\n ],\n [\n 'f219ea5d6b54701c1c14de5b557eb42a8d13f3abbcd08affcc2a5e6b049b8d63',\n '4cb95957e83d40b0f73af4544cccf6b1f4b08d3c07b27fb8d8c2962a400766d1',\n ],\n [\n 'd7b8740f74a8fbaab1f683db8f45de26543a5490bca627087236912469a0b448',\n 'fa77968128d9c92ee1010f337ad4717eff15db5ed3c049b3411e0315eaa4593b',\n ],\n [\n '32d31c222f8f6f0ef86f7c98d3a3335ead5bcd32abdd94289fe4d3091aa824bf',\n '5f3032f5892156e39ccd3d7915b9e1da2e6dac9e6f26e961118d14b8462e1661',\n ],\n [\n '7461f371914ab32671045a155d9831ea8793d77cd59592c4340f86cbc18347b5',\n '8ec0ba238b96bec0cbdddcae0aa442542eee1ff50c986ea6b39847b3cc092ff6',\n ],\n [\n 'ee079adb1df1860074356a25aa38206a6d716b2c3e67453d287698bad7b2b2d6',\n '8dc2412aafe3be5c4c5f37e0ecc5f9f6a446989af04c4e25ebaac479ec1c8c1e',\n ],\n [\n '16ec93e447ec83f0467b18302ee620f7e65de331874c9dc72bfd8616ba9da6b5',\n '5e4631150e62fb40d0e8c2a7ca5804a39d58186a50e497139626778e25b0674d',\n ],\n [\n 'eaa5f980c245f6f038978290afa70b6bd8855897f98b6aa485b96065d537bd99',\n 'f65f5d3e292c2e0819a528391c994624d784869d7e6ea67fb18041024edc07dc',\n ],\n [\n '78c9407544ac132692ee1910a02439958ae04877151342ea96c4b6b35a49f51',\n 'f3e0319169eb9b85d5404795539a5e68fa1fbd583c064d2462b675f194a3ddb4',\n ],\n [\n '494f4be219a1a77016dcd838431aea0001cdc8ae7a6fc688726578d9702857a5',\n '42242a969283a5f339ba7f075e36ba2af925ce30d767ed6e55f4b031880d562c',\n ],\n [\n 'a598a8030da6d86c6bc7f2f5144ea549d28211ea58faa70ebf4c1e665c1fe9b5',\n '204b5d6f84822c307e4b4a7140737aec23fc63b65b35f86a10026dbd2d864e6b',\n ],\n [\n 'c41916365abb2b5d09192f5f2dbeafec208f020f12570a184dbadc3e58595997',\n '4f14351d0087efa49d245b328984989d5caf9450f34bfc0ed16e96b58fa9913',\n ],\n [\n '841d6063a586fa475a724604da03bc5b92a2e0d2e0a36acfe4c73a5514742881',\n '73867f59c0659e81904f9a1c7543698e62562d6744c169ce7a36de01a8d6154',\n ],\n [\n '5e95bb399a6971d376026947f89bde2f282b33810928be4ded112ac4d70e20d5',\n '39f23f366809085beebfc71181313775a99c9aed7d8ba38b161384c746012865',\n ],\n [\n '36e4641a53948fd476c39f8a99fd974e5ec07564b5315d8bf99471bca0ef2f66',\n 'd2424b1b1abe4eb8164227b085c9aa9456ea13493fd563e06fd51cf5694c78fc',\n ],\n [\n '336581ea7bfbbb290c191a2f507a41cf5643842170e914faeab27c2c579f726',\n 'ead12168595fe1be99252129b6e56b3391f7ab1410cd1e0ef3dcdcabd2fda224',\n ],\n [\n '8ab89816dadfd6b6a1f2634fcf00ec8403781025ed6890c4849742706bd43ede',\n '6fdcef09f2f6d0a044e654aef624136f503d459c3e89845858a47a9129cdd24e',\n ],\n [\n '1e33f1a746c9c5778133344d9299fcaa20b0938e8acff2544bb40284b8c5fb94',\n '60660257dd11b3aa9c8ed618d24edff2306d320f1d03010e33a7d2057f3b3b6',\n ],\n [\n '85b7c1dcb3cec1b7ee7f30ded79dd20a0ed1f4cc18cbcfcfa410361fd8f08f31',\n '3d98a9cdd026dd43f39048f25a8847f4fcafad1895d7a633c6fed3c35e999511',\n ],\n [\n '29df9fbd8d9e46509275f4b125d6d45d7fbe9a3b878a7af872a2800661ac5f51',\n 'b4c4fe99c775a606e2d8862179139ffda61dc861c019e55cd2876eb2a27d84b',\n ],\n [\n 'a0b1cae06b0a847a3fea6e671aaf8adfdfe58ca2f768105c8082b2e449fce252',\n 'ae434102edde0958ec4b19d917a6a28e6b72da1834aff0e650f049503a296cf2',\n ],\n [\n '4e8ceafb9b3e9a136dc7ff67e840295b499dfb3b2133e4ba113f2e4c0e121e5',\n 'cf2174118c8b6d7a4b48f6d534ce5c79422c086a63460502b827ce62a326683c',\n ],\n [\n 'd24a44e047e19b6f5afb81c7ca2f69080a5076689a010919f42725c2b789a33b',\n '6fb8d5591b466f8fc63db50f1c0f1c69013f996887b8244d2cdec417afea8fa3',\n ],\n [\n 'ea01606a7a6c9cdd249fdfcfacb99584001edd28abbab77b5104e98e8e3b35d4',\n '322af4908c7312b0cfbfe369f7a7b3cdb7d4494bc2823700cfd652188a3ea98d',\n ],\n [\n 'af8addbf2b661c8a6c6328655eb96651252007d8c5ea31be4ad196de8ce2131f',\n '6749e67c029b85f52a034eafd096836b2520818680e26ac8f3dfbcdb71749700',\n ],\n [\n 'e3ae1974566ca06cc516d47e0fb165a674a3dabcfca15e722f0e3450f45889',\n '2aeabe7e4531510116217f07bf4d07300de97e4874f81f533420a72eeb0bd6a4',\n ],\n [\n '591ee355313d99721cf6993ffed1e3e301993ff3ed258802075ea8ced397e246',\n 'b0ea558a113c30bea60fc4775460c7901ff0b053d25ca2bdeee98f1a4be5d196',\n ],\n [\n '11396d55fda54c49f19aa97318d8da61fa8584e47b084945077cf03255b52984',\n '998c74a8cd45ac01289d5833a7beb4744ff536b01b257be4c5767bea93ea57a4',\n ],\n [\n '3c5d2a1ba39c5a1790000738c9e0c40b8dcdfd5468754b6405540157e017aa7a',\n 'b2284279995a34e2f9d4de7396fc18b80f9b8b9fdd270f6661f79ca4c81bd257',\n ],\n [\n 'cc8704b8a60a0defa3a99a7299f2e9c3fbc395afb04ac078425ef8a1793cc030',\n 'bdd46039feed17881d1e0862db347f8cf395b74fc4bcdc4e940b74e3ac1f1b13',\n ],\n [\n 'c533e4f7ea8555aacd9777ac5cad29b97dd4defccc53ee7ea204119b2889b197',\n '6f0a256bc5efdf429a2fb6242f1a43a2d9b925bb4a4b3a26bb8e0f45eb596096',\n ],\n [\n 'c14f8f2ccb27d6f109f6d08d03cc96a69ba8c34eec07bbcf566d48e33da6593',\n 'c359d6923bb398f7fd4473e16fe1c28475b740dd098075e6c0e8649113dc3a38',\n ],\n [\n 'a6cbc3046bc6a450bac24789fa17115a4c9739ed75f8f21ce441f72e0b90e6ef',\n '21ae7f4680e889bb130619e2c0f95a360ceb573c70603139862afd617fa9b9f',\n ],\n [\n '347d6d9a02c48927ebfb86c1359b1caf130a3c0267d11ce6344b39f99d43cc38',\n '60ea7f61a353524d1c987f6ecec92f086d565ab687870cb12689ff1e31c74448',\n ],\n [\n 'da6545d2181db8d983f7dcb375ef5866d47c67b1bf31c8cf855ef7437b72656a',\n '49b96715ab6878a79e78f07ce5680c5d6673051b4935bd897fea824b77dc208a',\n ],\n [\n 'c40747cc9d012cb1a13b8148309c6de7ec25d6945d657146b9d5994b8feb1111',\n '5ca560753be2a12fc6de6caf2cb489565db936156b9514e1bb5e83037e0fa2d4',\n ],\n [\n '4e42c8ec82c99798ccf3a610be870e78338c7f713348bd34c8203ef4037f3502',\n '7571d74ee5e0fb92a7a8b33a07783341a5492144cc54bcc40a94473693606437',\n ],\n [\n '3775ab7089bc6af823aba2e1af70b236d251cadb0c86743287522a1b3b0dedea',\n 'be52d107bcfa09d8bcb9736a828cfa7fac8db17bf7a76a2c42ad961409018cf7',\n ],\n [\n 'cee31cbf7e34ec379d94fb814d3d775ad954595d1314ba8846959e3e82f74e26',\n '8fd64a14c06b589c26b947ae2bcf6bfa0149ef0be14ed4d80f448a01c43b1c6d',\n ],\n [\n 'b4f9eaea09b6917619f6ea6a4eb5464efddb58fd45b1ebefcdc1a01d08b47986',\n '39e5c9925b5a54b07433a4f18c61726f8bb131c012ca542eb24a8ac07200682a',\n ],\n [\n 'd4263dfc3d2df923a0179a48966d30ce84e2515afc3dccc1b77907792ebcc60e',\n '62dfaf07a0f78feb30e30d6295853ce189e127760ad6cf7fae164e122a208d54',\n ],\n [\n '48457524820fa65a4f8d35eb6930857c0032acc0a4a2de422233eeda897612c4',\n '25a748ab367979d98733c38a1fa1c2e7dc6cc07db2d60a9ae7a76aaa49bd0f77',\n ],\n [\n 'dfeeef1881101f2cb11644f3a2afdfc2045e19919152923f367a1767c11cceda',\n 'ecfb7056cf1de042f9420bab396793c0c390bde74b4bbdff16a83ae09a9a7517',\n ],\n [\n '6d7ef6b17543f8373c573f44e1f389835d89bcbc6062ced36c82df83b8fae859',\n 'cd450ec335438986dfefa10c57fea9bcc521a0959b2d80bbf74b190dca712d10',\n ],\n [\n 'e75605d59102a5a2684500d3b991f2e3f3c88b93225547035af25af66e04541f',\n 'f5c54754a8f71ee540b9b48728473e314f729ac5308b06938360990e2bfad125',\n ],\n [\n 'eb98660f4c4dfaa06a2be453d5020bc99a0c2e60abe388457dd43fefb1ed620c',\n '6cb9a8876d9cb8520609af3add26cd20a0a7cd8a9411131ce85f44100099223e',\n ],\n [\n '13e87b027d8514d35939f2e6892b19922154596941888336dc3563e3b8dba942',\n 'fef5a3c68059a6dec5d624114bf1e91aac2b9da568d6abeb2570d55646b8adf1',\n ],\n [\n 'ee163026e9fd6fe017c38f06a5be6fc125424b371ce2708e7bf4491691e5764a',\n '1acb250f255dd61c43d94ccc670d0f58f49ae3fa15b96623e5430da0ad6c62b2',\n ],\n [\n 'b268f5ef9ad51e4d78de3a750c2dc89b1e626d43505867999932e5db33af3d80',\n '5f310d4b3c99b9ebb19f77d41c1dee018cf0d34fd4191614003e945a1216e423',\n ],\n [\n 'ff07f3118a9df035e9fad85eb6c7bfe42b02f01ca99ceea3bf7ffdba93c4750d',\n '438136d603e858a3a5c440c38eccbaddc1d2942114e2eddd4740d098ced1f0d8',\n ],\n [\n '8d8b9855c7c052a34146fd20ffb658bea4b9f69e0d825ebec16e8c3ce2b526a1',\n 'cdb559eedc2d79f926baf44fb84ea4d44bcf50fee51d7ceb30e2e7f463036758',\n ],\n [\n '52db0b5384dfbf05bfa9d472d7ae26dfe4b851ceca91b1eba54263180da32b63',\n 'c3b997d050ee5d423ebaf66a6db9f57b3180c902875679de924b69d84a7b375',\n ],\n [\n 'e62f9490d3d51da6395efd24e80919cc7d0f29c3f3fa48c6fff543becbd43352',\n '6d89ad7ba4876b0b22c2ca280c682862f342c8591f1daf5170e07bfd9ccafa7d',\n ],\n [\n '7f30ea2476b399b4957509c88f77d0191afa2ff5cb7b14fd6d8e7d65aaab1193',\n 'ca5ef7d4b231c94c3b15389a5f6311e9daff7bb67b103e9880ef4bff637acaec',\n ],\n [\n '5098ff1e1d9f14fb46a210fada6c903fef0fb7b4a1dd1d9ac60a0361800b7a00',\n '9731141d81fc8f8084d37c6e7542006b3ee1b40d60dfe5362a5b132fd17ddc0',\n ],\n [\n '32b78c7de9ee512a72895be6b9cbefa6e2f3c4ccce445c96b9f2c81e2778ad58',\n 'ee1849f513df71e32efc3896ee28260c73bb80547ae2275ba497237794c8753c',\n ],\n [\n 'e2cb74fddc8e9fbcd076eef2a7c72b0ce37d50f08269dfc074b581550547a4f7',\n 'd3aa2ed71c9dd2247a62df062736eb0baddea9e36122d2be8641abcb005cc4a4',\n ],\n [\n '8438447566d4d7bedadc299496ab357426009a35f235cb141be0d99cd10ae3a8',\n 'c4e1020916980a4da5d01ac5e6ad330734ef0d7906631c4f2390426b2edd791f',\n ],\n [\n '4162d488b89402039b584c6fc6c308870587d9c46f660b878ab65c82c711d67e',\n '67163e903236289f776f22c25fb8a3afc1732f2b84b4e95dbda47ae5a0852649',\n ],\n [\n '3fad3fa84caf0f34f0f89bfd2dcf54fc175d767aec3e50684f3ba4a4bf5f683d',\n 'cd1bc7cb6cc407bb2f0ca647c718a730cf71872e7d0d2a53fa20efcdfe61826',\n ],\n [\n '674f2600a3007a00568c1a7ce05d0816c1fb84bf1370798f1c69532faeb1a86b',\n '299d21f9413f33b3edf43b257004580b70db57da0b182259e09eecc69e0d38a5',\n ],\n [\n 'd32f4da54ade74abb81b815ad1fb3b263d82d6c692714bcff87d29bd5ee9f08f',\n 'f9429e738b8e53b968e99016c059707782e14f4535359d582fc416910b3eea87',\n ],\n [\n '30e4e670435385556e593657135845d36fbb6931f72b08cb1ed954f1e3ce3ff6',\n '462f9bce619898638499350113bbc9b10a878d35da70740dc695a559eb88db7b',\n ],\n [\n 'be2062003c51cc3004682904330e4dee7f3dcd10b01e580bf1971b04d4cad297',\n '62188bc49d61e5428573d48a74e1c655b1c61090905682a0d5558ed72dccb9bc',\n ],\n [\n '93144423ace3451ed29e0fb9ac2af211cb6e84a601df5993c419859fff5df04a',\n '7c10dfb164c3425f5c71a3f9d7992038f1065224f72bb9d1d902a6d13037b47c',\n ],\n [\n 'b015f8044f5fcbdcf21ca26d6c34fb8197829205c7b7d2a7cb66418c157b112c',\n 'ab8c1e086d04e813744a655b2df8d5f83b3cdc6faa3088c1d3aea1454e3a1d5f',\n ],\n [\n 'd5e9e1da649d97d89e4868117a465a3a4f8a18de57a140d36b3f2af341a21b52',\n '4cb04437f391ed73111a13cc1d4dd0db1693465c2240480d8955e8592f27447a',\n ],\n [\n 'd3ae41047dd7ca065dbf8ed77b992439983005cd72e16d6f996a5316d36966bb',\n 'bd1aeb21ad22ebb22a10f0303417c6d964f8cdd7df0aca614b10dc14d125ac46',\n ],\n [\n '463e2763d885f958fc66cdd22800f0a487197d0a82e377b49f80af87c897b065',\n 'bfefacdb0e5d0fd7df3a311a94de062b26b80c61fbc97508b79992671ef7ca7f',\n ],\n [\n '7985fdfd127c0567c6f53ec1bb63ec3158e597c40bfe747c83cddfc910641917',\n '603c12daf3d9862ef2b25fe1de289aed24ed291e0ec6708703a5bd567f32ed03',\n ],\n [\n '74a1ad6b5f76e39db2dd249410eac7f99e74c59cb83d2d0ed5ff1543da7703e9',\n 'cc6157ef18c9c63cd6193d83631bbea0093e0968942e8c33d5737fd790e0db08',\n ],\n [\n '30682a50703375f602d416664ba19b7fc9bab42c72747463a71d0896b22f6da3',\n '553e04f6b018b4fa6c8f39e7f311d3176290d0e0f19ca73f17714d9977a22ff8',\n ],\n [\n '9e2158f0d7c0d5f26c3791efefa79597654e7a2b2464f52b1ee6c1347769ef57',\n '712fcdd1b9053f09003a3481fa7762e9ffd7c8ef35a38509e2fbf2629008373',\n ],\n [\n '176e26989a43c9cfeba4029c202538c28172e566e3c4fce7322857f3be327d66',\n 'ed8cc9d04b29eb877d270b4878dc43c19aefd31f4eee09ee7b47834c1fa4b1c3',\n ],\n [\n '75d46efea3771e6e68abb89a13ad747ecf1892393dfc4f1b7004788c50374da8',\n '9852390a99507679fd0b86fd2b39a868d7efc22151346e1a3ca4726586a6bed8',\n ],\n [\n '809a20c67d64900ffb698c4c825f6d5f2310fb0451c869345b7319f645605721',\n '9e994980d9917e22b76b061927fa04143d096ccc54963e6a5ebfa5f3f8e286c1',\n ],\n [\n '1b38903a43f7f114ed4500b4eac7083fdefece1cf29c63528d563446f972c180',\n '4036edc931a60ae889353f77fd53de4a2708b26b6f5da72ad3394119daf408f9',\n ],\n ],\n },\n};\n","'use strict';\n\nvar utils = exports;\nvar BN = require('bn.js');\nvar minAssert = require('minimalistic-assert');\nvar minUtils = require('minimalistic-crypto-utils');\n\nutils.assert = minAssert;\nutils.toArray = minUtils.toArray;\nutils.zero2 = minUtils.zero2;\nutils.toHex = minUtils.toHex;\nutils.encode = minUtils.encode;\n\n// Represent num in a w-NAF form\nfunction getNAF(num, w, bits) {\n var naf = new Array(Math.max(num.bitLength(), bits) + 1);\n naf.fill(0);\n\n var ws = 1 << (w + 1);\n var k = num.clone();\n\n for (var i = 0; i < naf.length; i++) {\n var z;\n var mod = k.andln(ws - 1);\n if (k.isOdd()) {\n if (mod > (ws >> 1) - 1)\n z = (ws >> 1) - mod;\n else\n z = mod;\n k.isubn(z);\n } else {\n z = 0;\n }\n\n naf[i] = z;\n k.iushrn(1);\n }\n\n return naf;\n}\nutils.getNAF = getNAF;\n\n// Represent k1, k2 in a Joint Sparse Form\nfunction getJSF(k1, k2) {\n var jsf = [\n [],\n [],\n ];\n\n k1 = k1.clone();\n k2 = k2.clone();\n var d1 = 0;\n var d2 = 0;\n var m8;\n while (k1.cmpn(-d1) > 0 || k2.cmpn(-d2) > 0) {\n // First phase\n var m14 = (k1.andln(3) + d1) & 3;\n var m24 = (k2.andln(3) + d2) & 3;\n if (m14 === 3)\n m14 = -1;\n if (m24 === 3)\n m24 = -1;\n var u1;\n if ((m14 & 1) === 0) {\n u1 = 0;\n } else {\n m8 = (k1.andln(7) + d1) & 7;\n if ((m8 === 3 || m8 === 5) && m24 === 2)\n u1 = -m14;\n else\n u1 = m14;\n }\n jsf[0].push(u1);\n\n var u2;\n if ((m24 & 1) === 0) {\n u2 = 0;\n } else {\n m8 = (k2.andln(7) + d2) & 7;\n if ((m8 === 3 || m8 === 5) && m14 === 2)\n u2 = -m24;\n else\n u2 = m24;\n }\n jsf[1].push(u2);\n\n // Second phase\n if (2 * d1 === u1 + 1)\n d1 = 1 - d1;\n if (2 * d2 === u2 + 1)\n d2 = 1 - d2;\n k1.iushrn(1);\n k2.iushrn(1);\n }\n\n return jsf;\n}\nutils.getJSF = getJSF;\n\nfunction cachedProperty(obj, name, computer) {\n var key = '_' + name;\n obj.prototype[name] = function cachedProperty() {\n return this[key] !== undefined ? this[key] :\n this[key] = computer.call(this);\n };\n}\nutils.cachedProperty = cachedProperty;\n\nfunction parseBytes(bytes) {\n return typeof bytes === 'string' ? utils.toArray(bytes, 'hex') :\n bytes;\n}\nutils.parseBytes = parseBytes;\n\nfunction intFromLE(bytes) {\n return new BN(bytes, 'hex', 'le');\n}\nutils.intFromLE = intFromLE;\n\n","/**\n * Code refactored from Mozilla Developer Network:\n * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/assign\n */\n\n'use strict';\n\nfunction assign(target, firstSource) {\n if (target === undefined || target === null) {\n throw new TypeError('Cannot convert first argument to object');\n }\n\n var to = Object(target);\n for (var i = 1; i < arguments.length; i++) {\n var nextSource = arguments[i];\n if (nextSource === undefined || nextSource === null) {\n continue;\n }\n\n var keysArray = Object.keys(Object(nextSource));\n for (var nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex++) {\n var nextKey = keysArray[nextIndex];\n var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);\n if (desc !== undefined && desc.enumerable) {\n to[nextKey] = nextSource[nextKey];\n }\n }\n }\n return to;\n}\n\nfunction polyfill() {\n if (!Object.assign) {\n Object.defineProperty(Object, 'assign', {\n enumerable: false,\n configurable: true,\n writable: true,\n value: assign\n });\n }\n}\n\nmodule.exports = {\n assign: assign,\n polyfill: polyfill\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n ? R.apply\n : function ReflectApply(target, receiver, args) {\n return Function.prototype.apply.call(target, receiver, args);\n }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n ReflectOwnKeys = function ReflectOwnKeys(target) {\n return Object.getOwnPropertyNames(target)\n .concat(Object.getOwnPropertySymbols(target));\n };\n} else {\n ReflectOwnKeys = function ReflectOwnKeys(target) {\n return Object.getOwnPropertyNames(target);\n };\n}\n\nfunction ProcessEmitWarning(warning) {\n if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n return value !== value;\n}\n\nfunction EventEmitter() {\n EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n if (typeof listener !== 'function') {\n throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n enumerable: true,\n get: function() {\n return defaultMaxListeners;\n },\n set: function(arg) {\n if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n }\n defaultMaxListeners = arg;\n }\n});\n\nEventEmitter.init = function() {\n\n if (this._events === undefined ||\n this._events === Object.getPrototypeOf(this)._events) {\n this._events = Object.create(null);\n this._eventsCount = 0;\n }\n\n this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n }\n this._maxListeners = n;\n return this;\n};\n\nfunction _getMaxListeners(that) {\n if (that._maxListeners === undefined)\n return EventEmitter.defaultMaxListeners;\n return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n var args = [];\n for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n var doError = (type === 'error');\n\n var events = this._events;\n if (events !== undefined)\n doError = (doError && events.error === undefined);\n else if (!doError)\n return false;\n\n // If there is no 'error' event listener then throw.\n if (doError) {\n var er;\n if (args.length > 0)\n er = args[0];\n if (er instanceof Error) {\n // Note: The comments on the `throw` lines are intentional, they show\n // up in Node's output if this results in an unhandled exception.\n throw er; // Unhandled 'error' event\n }\n // At least give some kind of context to the user\n var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n err.context = er;\n throw err; // Unhandled 'error' event\n }\n\n var handler = events[type];\n\n if (handler === undefined)\n return false;\n\n if (typeof handler === 'function') {\n ReflectApply(handler, this, args);\n } else {\n var len = handler.length;\n var listeners = arrayClone(handler, len);\n for (var i = 0; i < len; ++i)\n ReflectApply(listeners[i], this, args);\n }\n\n return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n var m;\n var events;\n var existing;\n\n checkListener(listener);\n\n events = target._events;\n if (events === undefined) {\n events = target._events = Object.create(null);\n target._eventsCount = 0;\n } else {\n // To avoid recursion in the case that type === \"newListener\"! Before\n // adding it to the listeners, first emit \"newListener\".\n if (events.newListener !== undefined) {\n target.emit('newListener', type,\n listener.listener ? listener.listener : listener);\n\n // Re-assign `events` because a newListener handler could have caused the\n // this._events to be assigned to a new object\n events = target._events;\n }\n existing = events[type];\n }\n\n if (existing === undefined) {\n // Optimize the case of one listener. Don't need the extra array object.\n existing = events[type] = listener;\n ++target._eventsCount;\n } else {\n if (typeof existing === 'function') {\n // Adding the second element, need to change to array.\n existing = events[type] =\n prepend ? [listener, existing] : [existing, listener];\n // If we've already got an array, just append.\n } else if (prepend) {\n existing.unshift(listener);\n } else {\n existing.push(listener);\n }\n\n // Check for listener leak\n m = _getMaxListeners(target);\n if (m > 0 && existing.length > m && !existing.warned) {\n existing.warned = true;\n // No error code for this since it is a Warning\n // eslint-disable-next-line no-restricted-syntax\n var w = new Error('Possible EventEmitter memory leak detected. ' +\n existing.length + ' ' + String(type) + ' listeners ' +\n 'added. Use emitter.setMaxListeners() to ' +\n 'increase limit');\n w.name = 'MaxListenersExceededWarning';\n w.emitter = target;\n w.type = type;\n w.count = existing.length;\n ProcessEmitWarning(w);\n }\n }\n\n return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n function prependListener(type, listener) {\n return _addListener(this, type, listener, true);\n };\n\nfunction onceWrapper() {\n if (!this.fired) {\n this.target.removeListener(this.type, this.wrapFn);\n this.fired = true;\n if (arguments.length === 0)\n return this.listener.call(this.target);\n return this.listener.apply(this.target, arguments);\n }\n}\n\nfunction _onceWrap(target, type, listener) {\n var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n var wrapped = onceWrapper.bind(state);\n wrapped.listener = listener;\n state.wrapFn = wrapped;\n return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n checkListener(listener);\n this.on(type, _onceWrap(this, type, listener));\n return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n function prependOnceListener(type, listener) {\n checkListener(listener);\n this.prependListener(type, _onceWrap(this, type, listener));\n return this;\n };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n function removeListener(type, listener) {\n var list, events, position, i, originalListener;\n\n checkListener(listener);\n\n events = this._events;\n if (events === undefined)\n return this;\n\n list = events[type];\n if (list === undefined)\n return this;\n\n if (list === listener || list.listener === listener) {\n if (--this._eventsCount === 0)\n this._events = Object.create(null);\n else {\n delete events[type];\n if (events.removeListener)\n this.emit('removeListener', type, list.listener || listener);\n }\n } else if (typeof list !== 'function') {\n position = -1;\n\n for (i = list.length - 1; i >= 0; i--) {\n if (list[i] === listener || list[i].listener === listener) {\n originalListener = list[i].listener;\n position = i;\n break;\n }\n }\n\n if (position < 0)\n return this;\n\n if (position === 0)\n list.shift();\n else {\n spliceOne(list, position);\n }\n\n if (list.length === 1)\n events[type] = list[0];\n\n if (events.removeListener !== undefined)\n this.emit('removeListener', type, originalListener || listener);\n }\n\n return this;\n };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n function removeAllListeners(type) {\n var listeners, events, i;\n\n events = this._events;\n if (events === undefined)\n return this;\n\n // not listening for removeListener, no need to emit\n if (events.removeListener === undefined) {\n if (arguments.length === 0) {\n this._events = Object.create(null);\n this._eventsCount = 0;\n } else if (events[type] !== undefined) {\n if (--this._eventsCount === 0)\n this._events = Object.create(null);\n else\n delete events[type];\n }\n return this;\n }\n\n // emit removeListener for all listeners on all events\n if (arguments.length === 0) {\n var keys = Object.keys(events);\n var key;\n for (i = 0; i < keys.length; ++i) {\n key = keys[i];\n if (key === 'removeListener') continue;\n this.removeAllListeners(key);\n }\n this.removeAllListeners('removeListener');\n this._events = Object.create(null);\n this._eventsCount = 0;\n return this;\n }\n\n listeners = events[type];\n\n if (typeof listeners === 'function') {\n this.removeListener(type, listeners);\n } else if (listeners !== undefined) {\n // LIFO order\n for (i = listeners.length - 1; i >= 0; i--) {\n this.removeListener(type, listeners[i]);\n }\n }\n\n return this;\n };\n\nfunction _listeners(target, type, unwrap) {\n var events = target._events;\n\n if (events === undefined)\n return [];\n\n var evlistener = events[type];\n if (evlistener === undefined)\n return [];\n\n if (typeof evlistener === 'function')\n return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n return unwrap ?\n unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n if (typeof emitter.listenerCount === 'function') {\n return emitter.listenerCount(type);\n } else {\n return listenerCount.call(emitter, type);\n }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n var events = this._events;\n\n if (events !== undefined) {\n var evlistener = events[type];\n\n if (typeof evlistener === 'function') {\n return 1;\n } else if (evlistener !== undefined) {\n return evlistener.length;\n }\n }\n\n return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n var copy = new Array(n);\n for (var i = 0; i < n; ++i)\n copy[i] = arr[i];\n return copy;\n}\n\nfunction spliceOne(list, index) {\n for (; index + 1 < list.length; index++)\n list[index] = list[index + 1];\n list.pop();\n}\n\nfunction unwrapListeners(arr) {\n var ret = new Array(arr.length);\n for (var i = 0; i < ret.length; ++i) {\n ret[i] = arr[i].listener || arr[i];\n }\n return ret;\n}\n\nfunction once(emitter, name) {\n return new Promise(function (resolve, reject) {\n function errorListener(err) {\n emitter.removeListener(name, resolver);\n reject(err);\n }\n\n function resolver() {\n if (typeof emitter.removeListener === 'function') {\n emitter.removeListener('error', errorListener);\n }\n resolve([].slice.call(arguments));\n };\n\n eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n if (name !== 'error') {\n addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n }\n });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n if (typeof emitter.on === 'function') {\n eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n if (typeof emitter.on === 'function') {\n if (flags.once) {\n emitter.once(name, listener);\n } else {\n emitter.on(name, listener);\n }\n } else if (typeof emitter.addEventListener === 'function') {\n // EventTarget does not have `error` event semantics like Node\n // EventEmitters, we do not listen for `error` events here.\n emitter.addEventListener(name, function wrapListener(arg) {\n // IE does not have builtin `{ once: true }` support so we\n // have to do it manually.\n if (flags.once) {\n emitter.removeEventListener(name, wrapListener);\n }\n listener(arg);\n });\n } else {\n throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n }\n}\n","var Buffer = require('safe-buffer').Buffer\nvar MD5 = require('md5.js')\n\n/* eslint-disable camelcase */\nfunction EVP_BytesToKey (password, salt, keyBits, ivLen) {\n if (!Buffer.isBuffer(password)) password = Buffer.from(password, 'binary')\n if (salt) {\n if (!Buffer.isBuffer(salt)) salt = Buffer.from(salt, 'binary')\n if (salt.length !== 8) throw new RangeError('salt should be Buffer with 8 byte length')\n }\n\n var keyLen = keyBits / 8\n var key = Buffer.alloc(keyLen)\n var iv = Buffer.alloc(ivLen || 0)\n var tmp = Buffer.alloc(0)\n\n while (keyLen > 0 || ivLen > 0) {\n var hash = new MD5()\n hash.update(tmp)\n hash.update(password)\n if (salt) hash.update(salt)\n tmp = hash.digest()\n\n var used = 0\n\n if (keyLen > 0) {\n var keyStart = key.length - keyLen\n used = Math.min(keyLen, tmp.length)\n tmp.copy(key, keyStart, 0, used)\n keyLen -= used\n }\n\n if (used < tmp.length && ivLen > 0) {\n var ivStart = iv.length - ivLen\n var length = Math.min(ivLen, tmp.length - used)\n tmp.copy(iv, ivStart, used, used + length)\n ivLen -= length\n }\n }\n\n tmp.fill(0)\n return { key: key, iv: iv }\n}\n\nmodule.exports = EVP_BytesToKey\n","'use strict';\n\nvar isCallable = require('is-callable');\n\nvar toStr = Object.prototype.toString;\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nvar forEachArray = function forEachArray(array, iterator, receiver) {\n for (var i = 0, len = array.length; i < len; i++) {\n if (hasOwnProperty.call(array, i)) {\n if (receiver == null) {\n iterator(array[i], i, array);\n } else {\n iterator.call(receiver, array[i], i, array);\n }\n }\n }\n};\n\nvar forEachString = function forEachString(string, iterator, receiver) {\n for (var i = 0, len = string.length; i < len; i++) {\n // no such thing as a sparse string.\n if (receiver == null) {\n iterator(string.charAt(i), i, string);\n } else {\n iterator.call(receiver, string.charAt(i), i, string);\n }\n }\n};\n\nvar forEachObject = function forEachObject(object, iterator, receiver) {\n for (var k in object) {\n if (hasOwnProperty.call(object, k)) {\n if (receiver == null) {\n iterator(object[k], k, object);\n } else {\n iterator.call(receiver, object[k], k, object);\n }\n }\n }\n};\n\nvar forEach = function forEach(list, iterator, thisArg) {\n if (!isCallable(iterator)) {\n throw new TypeError('iterator must be a function');\n }\n\n var receiver;\n if (arguments.length >= 3) {\n receiver = thisArg;\n }\n\n if (toStr.call(list) === '[object Array]') {\n forEachArray(list, iterator, receiver);\n } else if (typeof list === 'string') {\n forEachString(list, iterator, receiver);\n } else {\n forEachObject(list, iterator, receiver);\n }\n};\n\nmodule.exports = forEach;\n","'use strict';\n\n/* eslint no-invalid-this: 1 */\n\nvar ERROR_MESSAGE = 'Function.prototype.bind called on incompatible ';\nvar slice = Array.prototype.slice;\nvar toStr = Object.prototype.toString;\nvar funcType = '[object Function]';\n\nmodule.exports = function bind(that) {\n var target = this;\n if (typeof target !== 'function' || toStr.call(target) !== funcType) {\n throw new TypeError(ERROR_MESSAGE + target);\n }\n var args = slice.call(arguments, 1);\n\n var bound;\n var binder = function () {\n if (this instanceof bound) {\n var result = target.apply(\n this,\n args.concat(slice.call(arguments))\n );\n if (Object(result) === result) {\n return result;\n }\n return this;\n } else {\n return target.apply(\n that,\n args.concat(slice.call(arguments))\n );\n }\n };\n\n var boundLength = Math.max(0, target.length - args.length);\n var boundArgs = [];\n for (var i = 0; i < boundLength; i++) {\n boundArgs.push('$' + i);\n }\n\n bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this,arguments); }')(binder);\n\n if (target.prototype) {\n var Empty = function Empty() {};\n Empty.prototype = target.prototype;\n bound.prototype = new Empty();\n Empty.prototype = null;\n }\n\n return bound;\n};\n","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = Function.prototype.bind || implementation;\n","'use strict';\n\nvar undefined;\n\nvar $SyntaxError = SyntaxError;\nvar $Function = Function;\nvar $TypeError = TypeError;\n\n// eslint-disable-next-line consistent-return\nvar getEvalledConstructor = function (expressionSyntax) {\n\ttry {\n\t\treturn $Function('\"use strict\"; return (' + expressionSyntax + ').constructor;')();\n\t} catch (e) {}\n};\n\nvar $gOPD = Object.getOwnPropertyDescriptor;\nif ($gOPD) {\n\ttry {\n\t\t$gOPD({}, '');\n\t} catch (e) {\n\t\t$gOPD = null; // this is IE 8, which has a broken gOPD\n\t}\n}\n\nvar throwTypeError = function () {\n\tthrow new $TypeError();\n};\nvar ThrowTypeError = $gOPD\n\t? (function () {\n\t\ttry {\n\t\t\t// eslint-disable-next-line no-unused-expressions, no-caller, no-restricted-properties\n\t\t\targuments.callee; // IE 8 does not throw here\n\t\t\treturn throwTypeError;\n\t\t} catch (calleeThrows) {\n\t\t\ttry {\n\t\t\t\t// IE 8 throws on Object.getOwnPropertyDescriptor(arguments, '')\n\t\t\t\treturn $gOPD(arguments, 'callee').get;\n\t\t\t} catch (gOPDthrows) {\n\t\t\t\treturn throwTypeError;\n\t\t\t}\n\t\t}\n\t}())\n\t: throwTypeError;\n\nvar hasSymbols = require('has-symbols')();\n\nvar getProto = Object.getPrototypeOf || function (x) { return x.__proto__; }; // eslint-disable-line no-proto\n\nvar needsEval = {};\n\nvar TypedArray = typeof Uint8Array === 'undefined' ? undefined : getProto(Uint8Array);\n\nvar INTRINSICS = {\n\t'%AggregateError%': typeof AggregateError === 'undefined' ? undefined : AggregateError,\n\t'%Array%': Array,\n\t'%ArrayBuffer%': typeof ArrayBuffer === 'undefined' ? undefined : ArrayBuffer,\n\t'%ArrayIteratorPrototype%': hasSymbols ? getProto([][Symbol.iterator]()) : undefined,\n\t'%AsyncFromSyncIteratorPrototype%': undefined,\n\t'%AsyncFunction%': needsEval,\n\t'%AsyncGenerator%': needsEval,\n\t'%AsyncGeneratorFunction%': needsEval,\n\t'%AsyncIteratorPrototype%': needsEval,\n\t'%Atomics%': typeof Atomics === 'undefined' ? undefined : Atomics,\n\t'%BigInt%': typeof BigInt === 'undefined' ? undefined : BigInt,\n\t'%BigInt64Array%': typeof BigInt64Array === 'undefined' ? undefined : BigInt64Array,\n\t'%BigUint64Array%': typeof BigUint64Array === 'undefined' ? undefined : BigUint64Array,\n\t'%Boolean%': Boolean,\n\t'%DataView%': typeof DataView === 'undefined' ? undefined : DataView,\n\t'%Date%': Date,\n\t'%decodeURI%': decodeURI,\n\t'%decodeURIComponent%': decodeURIComponent,\n\t'%encodeURI%': encodeURI,\n\t'%encodeURIComponent%': encodeURIComponent,\n\t'%Error%': Error,\n\t'%eval%': eval, // eslint-disable-line no-eval\n\t'%EvalError%': EvalError,\n\t'%Float32Array%': typeof Float32Array === 'undefined' ? undefined : Float32Array,\n\t'%Float64Array%': typeof Float64Array === 'undefined' ? undefined : Float64Array,\n\t'%FinalizationRegistry%': typeof FinalizationRegistry === 'undefined' ? undefined : FinalizationRegistry,\n\t'%Function%': $Function,\n\t'%GeneratorFunction%': needsEval,\n\t'%Int8Array%': typeof Int8Array === 'undefined' ? undefined : Int8Array,\n\t'%Int16Array%': typeof Int16Array === 'undefined' ? undefined : Int16Array,\n\t'%Int32Array%': typeof Int32Array === 'undefined' ? undefined : Int32Array,\n\t'%isFinite%': isFinite,\n\t'%isNaN%': isNaN,\n\t'%IteratorPrototype%': hasSymbols ? getProto(getProto([][Symbol.iterator]())) : undefined,\n\t'%JSON%': typeof JSON === 'object' ? JSON : undefined,\n\t'%Map%': typeof Map === 'undefined' ? undefined : Map,\n\t'%MapIteratorPrototype%': typeof Map === 'undefined' || !hasSymbols ? undefined : getProto(new Map()[Symbol.iterator]()),\n\t'%Math%': Math,\n\t'%Number%': Number,\n\t'%Object%': Object,\n\t'%parseFloat%': parseFloat,\n\t'%parseInt%': parseInt,\n\t'%Promise%': typeof Promise === 'undefined' ? undefined : Promise,\n\t'%Proxy%': typeof Proxy === 'undefined' ? undefined : Proxy,\n\t'%RangeError%': RangeError,\n\t'%ReferenceError%': ReferenceError,\n\t'%Reflect%': typeof Reflect === 'undefined' ? undefined : Reflect,\n\t'%RegExp%': RegExp,\n\t'%Set%': typeof Set === 'undefined' ? undefined : Set,\n\t'%SetIteratorPrototype%': typeof Set === 'undefined' || !hasSymbols ? undefined : getProto(new Set()[Symbol.iterator]()),\n\t'%SharedArrayBuffer%': typeof SharedArrayBuffer === 'undefined' ? undefined : SharedArrayBuffer,\n\t'%String%': String,\n\t'%StringIteratorPrototype%': hasSymbols ? getProto(''[Symbol.iterator]()) : undefined,\n\t'%Symbol%': hasSymbols ? Symbol : undefined,\n\t'%SyntaxError%': $SyntaxError,\n\t'%ThrowTypeError%': ThrowTypeError,\n\t'%TypedArray%': TypedArray,\n\t'%TypeError%': $TypeError,\n\t'%Uint8Array%': typeof Uint8Array === 'undefined' ? undefined : Uint8Array,\n\t'%Uint8ClampedArray%': typeof Uint8ClampedArray === 'undefined' ? undefined : Uint8ClampedArray,\n\t'%Uint16Array%': typeof Uint16Array === 'undefined' ? undefined : Uint16Array,\n\t'%Uint32Array%': typeof Uint32Array === 'undefined' ? undefined : Uint32Array,\n\t'%URIError%': URIError,\n\t'%WeakMap%': typeof WeakMap === 'undefined' ? undefined : WeakMap,\n\t'%WeakRef%': typeof WeakRef === 'undefined' ? undefined : WeakRef,\n\t'%WeakSet%': typeof WeakSet === 'undefined' ? undefined : WeakSet\n};\n\ntry {\n\tnull.error; // eslint-disable-line no-unused-expressions\n} catch (e) {\n\t// https://github.com/tc39/proposal-shadowrealm/pull/384#issuecomment-1364264229\n\tvar errorProto = getProto(getProto(e));\n\tINTRINSICS['%Error.prototype%'] = errorProto;\n}\n\nvar doEval = function doEval(name) {\n\tvar value;\n\tif (name === '%AsyncFunction%') {\n\t\tvalue = getEvalledConstructor('async function () {}');\n\t} else if (name === '%GeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('function* () {}');\n\t} else if (name === '%AsyncGeneratorFunction%') {\n\t\tvalue = getEvalledConstructor('async function* () {}');\n\t} else if (name === '%AsyncGenerator%') {\n\t\tvar fn = doEval('%AsyncGeneratorFunction%');\n\t\tif (fn) {\n\t\t\tvalue = fn.prototype;\n\t\t}\n\t} else if (name === '%AsyncIteratorPrototype%') {\n\t\tvar gen = doEval('%AsyncGenerator%');\n\t\tif (gen) {\n\t\t\tvalue = getProto(gen.prototype);\n\t\t}\n\t}\n\n\tINTRINSICS[name] = value;\n\n\treturn value;\n};\n\nvar LEGACY_ALIASES = {\n\t'%ArrayBufferPrototype%': ['ArrayBuffer', 'prototype'],\n\t'%ArrayPrototype%': ['Array', 'prototype'],\n\t'%ArrayProto_entries%': ['Array', 'prototype', 'entries'],\n\t'%ArrayProto_forEach%': ['Array', 'prototype', 'forEach'],\n\t'%ArrayProto_keys%': ['Array', 'prototype', 'keys'],\n\t'%ArrayProto_values%': ['Array', 'prototype', 'values'],\n\t'%AsyncFunctionPrototype%': ['AsyncFunction', 'prototype'],\n\t'%AsyncGenerator%': ['AsyncGeneratorFunction', 'prototype'],\n\t'%AsyncGeneratorPrototype%': ['AsyncGeneratorFunction', 'prototype', 'prototype'],\n\t'%BooleanPrototype%': ['Boolean', 'prototype'],\n\t'%DataViewPrototype%': ['DataView', 'prototype'],\n\t'%DatePrototype%': ['Date', 'prototype'],\n\t'%ErrorPrototype%': ['Error', 'prototype'],\n\t'%EvalErrorPrototype%': ['EvalError', 'prototype'],\n\t'%Float32ArrayPrototype%': ['Float32Array', 'prototype'],\n\t'%Float64ArrayPrototype%': ['Float64Array', 'prototype'],\n\t'%FunctionPrototype%': ['Function', 'prototype'],\n\t'%Generator%': ['GeneratorFunction', 'prototype'],\n\t'%GeneratorPrototype%': ['GeneratorFunction', 'prototype', 'prototype'],\n\t'%Int8ArrayPrototype%': ['Int8Array', 'prototype'],\n\t'%Int16ArrayPrototype%': ['Int16Array', 'prototype'],\n\t'%Int32ArrayPrototype%': ['Int32Array', 'prototype'],\n\t'%JSONParse%': ['JSON', 'parse'],\n\t'%JSONStringify%': ['JSON', 'stringify'],\n\t'%MapPrototype%': ['Map', 'prototype'],\n\t'%NumberPrototype%': ['Number', 'prototype'],\n\t'%ObjectPrototype%': ['Object', 'prototype'],\n\t'%ObjProto_toString%': ['Object', 'prototype', 'toString'],\n\t'%ObjProto_valueOf%': ['Object', 'prototype', 'valueOf'],\n\t'%PromisePrototype%': ['Promise', 'prototype'],\n\t'%PromiseProto_then%': ['Promise', 'prototype', 'then'],\n\t'%Promise_all%': ['Promise', 'all'],\n\t'%Promise_reject%': ['Promise', 'reject'],\n\t'%Promise_resolve%': ['Promise', 'resolve'],\n\t'%RangeErrorPrototype%': ['RangeError', 'prototype'],\n\t'%ReferenceErrorPrototype%': ['ReferenceError', 'prototype'],\n\t'%RegExpPrototype%': ['RegExp', 'prototype'],\n\t'%SetPrototype%': ['Set', 'prototype'],\n\t'%SharedArrayBufferPrototype%': ['SharedArrayBuffer', 'prototype'],\n\t'%StringPrototype%': ['String', 'prototype'],\n\t'%SymbolPrototype%': ['Symbol', 'prototype'],\n\t'%SyntaxErrorPrototype%': ['SyntaxError', 'prototype'],\n\t'%TypedArrayPrototype%': ['TypedArray', 'prototype'],\n\t'%TypeErrorPrototype%': ['TypeError', 'prototype'],\n\t'%Uint8ArrayPrototype%': ['Uint8Array', 'prototype'],\n\t'%Uint8ClampedArrayPrototype%': ['Uint8ClampedArray', 'prototype'],\n\t'%Uint16ArrayPrototype%': ['Uint16Array', 'prototype'],\n\t'%Uint32ArrayPrototype%': ['Uint32Array', 'prototype'],\n\t'%URIErrorPrototype%': ['URIError', 'prototype'],\n\t'%WeakMapPrototype%': ['WeakMap', 'prototype'],\n\t'%WeakSetPrototype%': ['WeakSet', 'prototype']\n};\n\nvar bind = require('function-bind');\nvar hasOwn = require('has');\nvar $concat = bind.call(Function.call, Array.prototype.concat);\nvar $spliceApply = bind.call(Function.apply, Array.prototype.splice);\nvar $replace = bind.call(Function.call, String.prototype.replace);\nvar $strSlice = bind.call(Function.call, String.prototype.slice);\nvar $exec = bind.call(Function.call, RegExp.prototype.exec);\n\n/* adapted from https://github.com/lodash/lodash/blob/4.17.15/dist/lodash.js#L6735-L6744 */\nvar rePropName = /[^%.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|%$))/g;\nvar reEscapeChar = /\\\\(\\\\)?/g; /** Used to match backslashes in property paths. */\nvar stringToPath = function stringToPath(string) {\n\tvar first = $strSlice(string, 0, 1);\n\tvar last = $strSlice(string, -1);\n\tif (first === '%' && last !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected closing `%`');\n\t} else if (last === '%' && first !== '%') {\n\t\tthrow new $SyntaxError('invalid intrinsic syntax, expected opening `%`');\n\t}\n\tvar result = [];\n\t$replace(string, rePropName, function (match, number, quote, subString) {\n\t\tresult[result.length] = quote ? $replace(subString, reEscapeChar, '$1') : number || match;\n\t});\n\treturn result;\n};\n/* end adaptation */\n\nvar getBaseIntrinsic = function getBaseIntrinsic(name, allowMissing) {\n\tvar intrinsicName = name;\n\tvar alias;\n\tif (hasOwn(LEGACY_ALIASES, intrinsicName)) {\n\t\talias = LEGACY_ALIASES[intrinsicName];\n\t\tintrinsicName = '%' + alias[0] + '%';\n\t}\n\n\tif (hasOwn(INTRINSICS, intrinsicName)) {\n\t\tvar value = INTRINSICS[intrinsicName];\n\t\tif (value === needsEval) {\n\t\t\tvalue = doEval(intrinsicName);\n\t\t}\n\t\tif (typeof value === 'undefined' && !allowMissing) {\n\t\t\tthrow new $TypeError('intrinsic ' + name + ' exists, but is not available. Please file an issue!');\n\t\t}\n\n\t\treturn {\n\t\t\talias: alias,\n\t\t\tname: intrinsicName,\n\t\t\tvalue: value\n\t\t};\n\t}\n\n\tthrow new $SyntaxError('intrinsic ' + name + ' does not exist!');\n};\n\nmodule.exports = function GetIntrinsic(name, allowMissing) {\n\tif (typeof name !== 'string' || name.length === 0) {\n\t\tthrow new $TypeError('intrinsic name must be a non-empty string');\n\t}\n\tif (arguments.length > 1 && typeof allowMissing !== 'boolean') {\n\t\tthrow new $TypeError('\"allowMissing\" argument must be a boolean');\n\t}\n\n\tif ($exec(/^%?[^%]*%?$/, name) === null) {\n\t\tthrow new $SyntaxError('`%` may not be present anywhere but at the beginning and end of the intrinsic name');\n\t}\n\tvar parts = stringToPath(name);\n\tvar intrinsicBaseName = parts.length > 0 ? parts[0] : '';\n\n\tvar intrinsic = getBaseIntrinsic('%' + intrinsicBaseName + '%', allowMissing);\n\tvar intrinsicRealName = intrinsic.name;\n\tvar value = intrinsic.value;\n\tvar skipFurtherCaching = false;\n\n\tvar alias = intrinsic.alias;\n\tif (alias) {\n\t\tintrinsicBaseName = alias[0];\n\t\t$spliceApply(parts, $concat([0, 1], alias));\n\t}\n\n\tfor (var i = 1, isOwn = true; i < parts.length; i += 1) {\n\t\tvar part = parts[i];\n\t\tvar first = $strSlice(part, 0, 1);\n\t\tvar last = $strSlice(part, -1);\n\t\tif (\n\t\t\t(\n\t\t\t\t(first === '\"' || first === \"'\" || first === '`')\n\t\t\t\t|| (last === '\"' || last === \"'\" || last === '`')\n\t\t\t)\n\t\t\t&& first !== last\n\t\t) {\n\t\t\tthrow new $SyntaxError('property names with quotes must have matching quotes');\n\t\t}\n\t\tif (part === 'constructor' || !isOwn) {\n\t\t\tskipFurtherCaching = true;\n\t\t}\n\n\t\tintrinsicBaseName += '.' + part;\n\t\tintrinsicRealName = '%' + intrinsicBaseName + '%';\n\n\t\tif (hasOwn(INTRINSICS, intrinsicRealName)) {\n\t\t\tvalue = INTRINSICS[intrinsicRealName];\n\t\t} else if (value != null) {\n\t\t\tif (!(part in value)) {\n\t\t\t\tif (!allowMissing) {\n\t\t\t\t\tthrow new $TypeError('base intrinsic for ' + name + ' exists, but the property is not available.');\n\t\t\t\t}\n\t\t\t\treturn void undefined;\n\t\t\t}\n\t\t\tif ($gOPD && (i + 1) >= parts.length) {\n\t\t\t\tvar desc = $gOPD(value, part);\n\t\t\t\tisOwn = !!desc;\n\n\t\t\t\t// By convention, when a data property is converted to an accessor\n\t\t\t\t// property to emulate a data property that does not suffer from\n\t\t\t\t// the override mistake, that accessor's getter is marked with\n\t\t\t\t// an `originalValue` property. Here, when we detect this, we\n\t\t\t\t// uphold the illusion by pretending to see that original data\n\t\t\t\t// property, i.e., returning the value rather than the getter\n\t\t\t\t// itself.\n\t\t\t\tif (isOwn && 'get' in desc && !('originalValue' in desc.get)) {\n\t\t\t\t\tvalue = desc.get;\n\t\t\t\t} else {\n\t\t\t\t\tvalue = value[part];\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tisOwn = hasOwn(value, part);\n\t\t\t\tvalue = value[part];\n\t\t\t}\n\n\t\t\tif (isOwn && !skipFurtherCaching) {\n\t\t\t\tINTRINSICS[intrinsicRealName] = value;\n\t\t\t}\n\t\t}\n\t}\n\treturn value;\n};\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $gOPD = GetIntrinsic('%Object.getOwnPropertyDescriptor%', true);\n\nif ($gOPD) {\n\ttry {\n\t\t$gOPD([], 'length');\n\t} catch (e) {\n\t\t// IE 8 has a broken gOPD\n\t\t$gOPD = null;\n\t}\n}\n\nmodule.exports = $gOPD;\n","'use strict';\n\nvar GetIntrinsic = require('get-intrinsic');\n\nvar $defineProperty = GetIntrinsic('%Object.defineProperty%', true);\n\nvar hasPropertyDescriptors = function hasPropertyDescriptors() {\n\tif ($defineProperty) {\n\t\ttry {\n\t\t\t$defineProperty({}, 'a', { value: 1 });\n\t\t\treturn true;\n\t\t} catch (e) {\n\t\t\t// IE 8 has a broken defineProperty\n\t\t\treturn false;\n\t\t}\n\t}\n\treturn false;\n};\n\nhasPropertyDescriptors.hasArrayLengthDefineBug = function hasArrayLengthDefineBug() {\n\t// node v0.6 has a bug where array lengths can be Set but not Defined\n\tif (!hasPropertyDescriptors()) {\n\t\treturn null;\n\t}\n\ttry {\n\t\treturn $defineProperty([], 'length', { value: 1 }).length !== 1;\n\t} catch (e) {\n\t\t// In Firefox 4-22, defining length on an array throws an exception.\n\t\treturn true;\n\t}\n};\n\nmodule.exports = hasPropertyDescriptors;\n","'use strict';\n\nvar origSymbol = typeof Symbol !== 'undefined' && Symbol;\nvar hasSymbolSham = require('./shams');\n\nmodule.exports = function hasNativeSymbols() {\n\tif (typeof origSymbol !== 'function') { return false; }\n\tif (typeof Symbol !== 'function') { return false; }\n\tif (typeof origSymbol('foo') !== 'symbol') { return false; }\n\tif (typeof Symbol('bar') !== 'symbol') { return false; }\n\n\treturn hasSymbolSham();\n};\n","'use strict';\n\n/* eslint complexity: [2, 18], max-statements: [2, 33] */\nmodule.exports = function hasSymbols() {\n\tif (typeof Symbol !== 'function' || typeof Object.getOwnPropertySymbols !== 'function') { return false; }\n\tif (typeof Symbol.iterator === 'symbol') { return true; }\n\n\tvar obj = {};\n\tvar sym = Symbol('test');\n\tvar symObj = Object(sym);\n\tif (typeof sym === 'string') { return false; }\n\n\tif (Object.prototype.toString.call(sym) !== '[object Symbol]') { return false; }\n\tif (Object.prototype.toString.call(symObj) !== '[object Symbol]') { return false; }\n\n\t// temp disabled per https://github.com/ljharb/object.assign/issues/17\n\t// if (sym instanceof Symbol) { return false; }\n\t// temp disabled per https://github.com/WebReflection/get-own-property-symbols/issues/4\n\t// if (!(symObj instanceof Symbol)) { return false; }\n\n\t// if (typeof Symbol.prototype.toString !== 'function') { return false; }\n\t// if (String(sym) !== Symbol.prototype.toString.call(sym)) { return false; }\n\n\tvar symVal = 42;\n\tobj[sym] = symVal;\n\tfor (sym in obj) { return false; } // eslint-disable-line no-restricted-syntax, no-unreachable-loop\n\tif (typeof Object.keys === 'function' && Object.keys(obj).length !== 0) { return false; }\n\n\tif (typeof Object.getOwnPropertyNames === 'function' && Object.getOwnPropertyNames(obj).length !== 0) { return false; }\n\n\tvar syms = Object.getOwnPropertySymbols(obj);\n\tif (syms.length !== 1 || syms[0] !== sym) { return false; }\n\n\tif (!Object.prototype.propertyIsEnumerable.call(obj, sym)) { return false; }\n\n\tif (typeof Object.getOwnPropertyDescriptor === 'function') {\n\t\tvar descriptor = Object.getOwnPropertyDescriptor(obj, sym);\n\t\tif (descriptor.value !== symVal || descriptor.enumerable !== true) { return false; }\n\t}\n\n\treturn true;\n};\n","'use strict';\n\nvar hasSymbols = require('has-symbols/shams');\n\nmodule.exports = function hasToStringTagShams() {\n\treturn hasSymbols() && !!Symbol.toStringTag;\n};\n","'use strict';\n\nvar bind = require('function-bind');\n\nmodule.exports = bind.call(Function.call, Object.prototype.hasOwnProperty);\n","'use strict'\nvar Buffer = require('safe-buffer').Buffer\nvar Transform = require('readable-stream').Transform\nvar inherits = require('inherits')\n\nfunction throwIfNotStringOrBuffer (val, prefix) {\n if (!Buffer.isBuffer(val) && typeof val !== 'string') {\n throw new TypeError(prefix + ' must be a string or a buffer')\n }\n}\n\nfunction HashBase (blockSize) {\n Transform.call(this)\n\n this._block = Buffer.allocUnsafe(blockSize)\n this._blockSize = blockSize\n this._blockOffset = 0\n this._length = [0, 0, 0, 0]\n\n this._finalized = false\n}\n\ninherits(HashBase, Transform)\n\nHashBase.prototype._transform = function (chunk, encoding, callback) {\n var error = null\n try {\n this.update(chunk, encoding)\n } catch (err) {\n error = err\n }\n\n callback(error)\n}\n\nHashBase.prototype._flush = function (callback) {\n var error = null\n try {\n this.push(this.digest())\n } catch (err) {\n error = err\n }\n\n callback(error)\n}\n\nHashBase.prototype.update = function (data, encoding) {\n throwIfNotStringOrBuffer(data, 'Data')\n if (this._finalized) throw new Error('Digest already called')\n if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding)\n\n // consume data\n var block = this._block\n var offset = 0\n while (this._blockOffset + data.length - offset >= this._blockSize) {\n for (var i = this._blockOffset; i < this._blockSize;) block[i++] = data[offset++]\n this._update()\n this._blockOffset = 0\n }\n while (offset < data.length) block[this._blockOffset++] = data[offset++]\n\n // update length\n for (var j = 0, carry = data.length * 8; carry > 0; ++j) {\n this._length[j] += carry\n carry = (this._length[j] / 0x0100000000) | 0\n if (carry > 0) this._length[j] -= 0x0100000000 * carry\n }\n\n return this\n}\n\nHashBase.prototype._update = function () {\n throw new Error('_update is not implemented')\n}\n\nHashBase.prototype.digest = function (encoding) {\n if (this._finalized) throw new Error('Digest already called')\n this._finalized = true\n\n var digest = this._digest()\n if (encoding !== undefined) digest = digest.toString(encoding)\n\n // reset state\n this._block.fill(0)\n this._blockOffset = 0\n for (var i = 0; i < 4; ++i) this._length[i] = 0\n\n return digest\n}\n\nHashBase.prototype._digest = function () {\n throw new Error('_digest is not implemented')\n}\n\nmodule.exports = HashBase\n","var hash = exports;\n\nhash.utils = require('./hash/utils');\nhash.common = require('./hash/common');\nhash.sha = require('./hash/sha');\nhash.ripemd = require('./hash/ripemd');\nhash.hmac = require('./hash/hmac');\n\n// Proxy hash functions to the main object\nhash.sha1 = hash.sha.sha1;\nhash.sha256 = hash.sha.sha256;\nhash.sha224 = hash.sha.sha224;\nhash.sha384 = hash.sha.sha384;\nhash.sha512 = hash.sha.sha512;\nhash.ripemd160 = hash.ripemd.ripemd160;\n","'use strict';\n\nvar utils = require('./utils');\nvar assert = require('minimalistic-assert');\n\nfunction BlockHash() {\n this.pending = null;\n this.pendingTotal = 0;\n this.blockSize = this.constructor.blockSize;\n this.outSize = this.constructor.outSize;\n this.hmacStrength = this.constructor.hmacStrength;\n this.padLength = this.constructor.padLength / 8;\n this.endian = 'big';\n\n this._delta8 = this.blockSize / 8;\n this._delta32 = this.blockSize / 32;\n}\nexports.BlockHash = BlockHash;\n\nBlockHash.prototype.update = function update(msg, enc) {\n // Convert message to array, pad it, and join into 32bit blocks\n msg = utils.toArray(msg, enc);\n if (!this.pending)\n this.pending = msg;\n else\n this.pending = this.pending.concat(msg);\n this.pendingTotal += msg.length;\n\n // Enough data, try updating\n if (this.pending.length >= this._delta8) {\n msg = this.pending;\n\n // Process pending data in blocks\n var r = msg.length % this._delta8;\n this.pending = msg.slice(msg.length - r, msg.length);\n if (this.pending.length === 0)\n this.pending = null;\n\n msg = utils.join32(msg, 0, msg.length - r, this.endian);\n for (var i = 0; i < msg.length; i += this._delta32)\n this._update(msg, i, i + this._delta32);\n }\n\n return this;\n};\n\nBlockHash.prototype.digest = function digest(enc) {\n this.update(this._pad());\n assert(this.pending === null);\n\n return this._digest(enc);\n};\n\nBlockHash.prototype._pad = function pad() {\n var len = this.pendingTotal;\n var bytes = this._delta8;\n var k = bytes - ((len + this.padLength) % bytes);\n var res = new Array(k + this.padLength);\n res[0] = 0x80;\n for (var i = 1; i < k; i++)\n res[i] = 0;\n\n // Append length\n len <<= 3;\n if (this.endian === 'big') {\n for (var t = 8; t < this.padLength; t++)\n res[i++] = 0;\n\n res[i++] = 0;\n res[i++] = 0;\n res[i++] = 0;\n res[i++] = 0;\n res[i++] = (len >>> 24) & 0xff;\n res[i++] = (len >>> 16) & 0xff;\n res[i++] = (len >>> 8) & 0xff;\n res[i++] = len & 0xff;\n } else {\n res[i++] = len & 0xff;\n res[i++] = (len >>> 8) & 0xff;\n res[i++] = (len >>> 16) & 0xff;\n res[i++] = (len >>> 24) & 0xff;\n res[i++] = 0;\n res[i++] = 0;\n res[i++] = 0;\n res[i++] = 0;\n\n for (t = 8; t < this.padLength; t++)\n res[i++] = 0;\n }\n\n return res;\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar assert = require('minimalistic-assert');\n\nfunction Hmac(hash, key, enc) {\n if (!(this instanceof Hmac))\n return new Hmac(hash, key, enc);\n this.Hash = hash;\n this.blockSize = hash.blockSize / 8;\n this.outSize = hash.outSize / 8;\n this.inner = null;\n this.outer = null;\n\n this._init(utils.toArray(key, enc));\n}\nmodule.exports = Hmac;\n\nHmac.prototype._init = function init(key) {\n // Shorten key, if needed\n if (key.length > this.blockSize)\n key = new this.Hash().update(key).digest();\n assert(key.length <= this.blockSize);\n\n // Add padding to key\n for (var i = key.length; i < this.blockSize; i++)\n key.push(0);\n\n for (i = 0; i < key.length; i++)\n key[i] ^= 0x36;\n this.inner = new this.Hash().update(key);\n\n // 0x36 ^ 0x5c = 0x6a\n for (i = 0; i < key.length; i++)\n key[i] ^= 0x6a;\n this.outer = new this.Hash().update(key);\n};\n\nHmac.prototype.update = function update(msg, enc) {\n this.inner.update(msg, enc);\n return this;\n};\n\nHmac.prototype.digest = function digest(enc) {\n this.outer.update(this.inner.digest());\n return this.outer.digest(enc);\n};\n","'use strict';\n\nvar utils = require('./utils');\nvar common = require('./common');\n\nvar rotl32 = utils.rotl32;\nvar sum32 = utils.sum32;\nvar sum32_3 = utils.sum32_3;\nvar sum32_4 = utils.sum32_4;\nvar BlockHash = common.BlockHash;\n\nfunction RIPEMD160() {\n if (!(this instanceof RIPEMD160))\n return new RIPEMD160();\n\n BlockHash.call(this);\n\n this.h = [ 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 ];\n this.endian = 'little';\n}\nutils.inherits(RIPEMD160, BlockHash);\nexports.ripemd160 = RIPEMD160;\n\nRIPEMD160.blockSize = 512;\nRIPEMD160.outSize = 160;\nRIPEMD160.hmacStrength = 192;\nRIPEMD160.padLength = 64;\n\nRIPEMD160.prototype._update = function update(msg, start) {\n var A = this.h[0];\n var B = this.h[1];\n var C = this.h[2];\n var D = this.h[3];\n var E = this.h[4];\n var Ah = A;\n var Bh = B;\n var Ch = C;\n var Dh = D;\n var Eh = E;\n for (var j = 0; j < 80; j++) {\n var T = sum32(\n rotl32(\n sum32_4(A, f(j, B, C, D), msg[r[j] + start], K(j)),\n s[j]),\n E);\n A = E;\n E = D;\n D = rotl32(C, 10);\n C = B;\n B = T;\n T = sum32(\n rotl32(\n sum32_4(Ah, f(79 - j, Bh, Ch, Dh), msg[rh[j] + start], Kh(j)),\n sh[j]),\n Eh);\n Ah = Eh;\n Eh = Dh;\n Dh = rotl32(Ch, 10);\n Ch = Bh;\n Bh = T;\n }\n T = sum32_3(this.h[1], C, Dh);\n this.h[1] = sum32_3(this.h[2], D, Eh);\n this.h[2] = sum32_3(this.h[3], E, Ah);\n this.h[3] = sum32_3(this.h[4], A, Bh);\n this.h[4] = sum32_3(this.h[0], B, Ch);\n this.h[0] = T;\n};\n\nRIPEMD160.prototype._digest = function digest(enc) {\n if (enc === 'hex')\n return utils.toHex32(this.h, 'little');\n else\n return utils.split32(this.h, 'little');\n};\n\nfunction f(j, x, y, z) {\n if (j <= 15)\n return x ^ y ^ z;\n else if (j <= 31)\n return (x & y) | ((~x) & z);\n else if (j <= 47)\n return (x | (~y)) ^ z;\n else if (j <= 63)\n return (x & z) | (y & (~z));\n else\n return x ^ (y | (~z));\n}\n\nfunction K(j) {\n if (j <= 15)\n return 0x00000000;\n else if (j <= 31)\n return 0x5a827999;\n else if (j <= 47)\n return 0x6ed9eba1;\n else if (j <= 63)\n return 0x8f1bbcdc;\n else\n return 0xa953fd4e;\n}\n\nfunction Kh(j) {\n if (j <= 15)\n return 0x50a28be6;\n else if (j <= 31)\n return 0x5c4dd124;\n else if (j <= 47)\n return 0x6d703ef3;\n else if (j <= 63)\n return 0x7a6d76e9;\n else\n return 0x00000000;\n}\n\nvar r = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,\n 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,\n 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,\n 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13\n];\n\nvar rh = [\n 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,\n 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,\n 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,\n 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,\n 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11\n];\n\nvar s = [\n 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,\n 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,\n 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,\n 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,\n 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6\n];\n\nvar sh = [\n 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,\n 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,\n 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,\n 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,\n 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11\n];\n","'use strict';\n\nexports.sha1 = require('./sha/1');\nexports.sha224 = require('./sha/224');\nexports.sha256 = require('./sha/256');\nexports.sha384 = require('./sha/384');\nexports.sha512 = require('./sha/512');\n","'use strict';\n\nvar utils = require('../utils');\nvar common = require('../common');\nvar shaCommon = require('./common');\n\nvar rotl32 = utils.rotl32;\nvar sum32 = utils.sum32;\nvar sum32_5 = utils.sum32_5;\nvar ft_1 = shaCommon.ft_1;\nvar BlockHash = common.BlockHash;\n\nvar sha1_K = [\n 0x5A827999, 0x6ED9EBA1,\n 0x8F1BBCDC, 0xCA62C1D6\n];\n\nfunction SHA1() {\n if (!(this instanceof SHA1))\n return new SHA1();\n\n BlockHash.call(this);\n this.h = [\n 0x67452301, 0xefcdab89, 0x98badcfe,\n 0x10325476, 0xc3d2e1f0 ];\n this.W = new Array(80);\n}\n\nutils.inherits(SHA1, BlockHash);\nmodule.exports = SHA1;\n\nSHA1.blockSize = 512;\nSHA1.outSize = 160;\nSHA1.hmacStrength = 80;\nSHA1.padLength = 64;\n\nSHA1.prototype._update = function _update(msg, start) {\n var W = this.W;\n\n for (var i = 0; i < 16; i++)\n W[i] = msg[start + i];\n\n for(; i < W.length; i++)\n W[i] = rotl32(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);\n\n var a = this.h[0];\n var b = this.h[1];\n var c = this.h[2];\n var d = this.h[3];\n var e = this.h[4];\n\n for (i = 0; i < W.length; i++) {\n var s = ~~(i / 20);\n var t = sum32_5(rotl32(a, 5), ft_1(s, b, c, d), e, W[i], sha1_K[s]);\n e = d;\n d = c;\n c = rotl32(b, 30);\n b = a;\n a = t;\n }\n\n this.h[0] = sum32(this.h[0], a);\n this.h[1] = sum32(this.h[1], b);\n this.h[2] = sum32(this.h[2], c);\n this.h[3] = sum32(this.h[3], d);\n this.h[4] = sum32(this.h[4], e);\n};\n\nSHA1.prototype._digest = function digest(enc) {\n if (enc === 'hex')\n return utils.toHex32(this.h, 'big');\n else\n return utils.split32(this.h, 'big');\n};\n","'use strict';\n\nvar utils = require('../utils');\nvar SHA256 = require('./256');\n\nfunction SHA224() {\n if (!(this instanceof SHA224))\n return new SHA224();\n\n SHA256.call(this);\n this.h = [\n 0xc1059ed8, 0x367cd507, 0x3070dd17, 0xf70e5939,\n 0xffc00b31, 0x68581511, 0x64f98fa7, 0xbefa4fa4 ];\n}\nutils.inherits(SHA224, SHA256);\nmodule.exports = SHA224;\n\nSHA224.blockSize = 512;\nSHA224.outSize = 224;\nSHA224.hmacStrength = 192;\nSHA224.padLength = 64;\n\nSHA224.prototype._digest = function digest(enc) {\n // Just truncate output\n if (enc === 'hex')\n return utils.toHex32(this.h.slice(0, 7), 'big');\n else\n return utils.split32(this.h.slice(0, 7), 'big');\n};\n\n","'use strict';\n\nvar utils = require('../utils');\nvar common = require('../common');\nvar shaCommon = require('./common');\nvar assert = require('minimalistic-assert');\n\nvar sum32 = utils.sum32;\nvar sum32_4 = utils.sum32_4;\nvar sum32_5 = utils.sum32_5;\nvar ch32 = shaCommon.ch32;\nvar maj32 = shaCommon.maj32;\nvar s0_256 = shaCommon.s0_256;\nvar s1_256 = shaCommon.s1_256;\nvar g0_256 = shaCommon.g0_256;\nvar g1_256 = shaCommon.g1_256;\n\nvar BlockHash = common.BlockHash;\n\nvar sha256_K = [\n 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,\n 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,\n 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,\n 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,\n 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,\n 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,\n 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,\n 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\n 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n];\n\nfunction SHA256() {\n if (!(this instanceof SHA256))\n return new SHA256();\n\n BlockHash.call(this);\n this.h = [\n 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,\n 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n ];\n this.k = sha256_K;\n this.W = new Array(64);\n}\nutils.inherits(SHA256, BlockHash);\nmodule.exports = SHA256;\n\nSHA256.blockSize = 512;\nSHA256.outSize = 256;\nSHA256.hmacStrength = 192;\nSHA256.padLength = 64;\n\nSHA256.prototype._update = function _update(msg, start) {\n var W = this.W;\n\n for (var i = 0; i < 16; i++)\n W[i] = msg[start + i];\n for (; i < W.length; i++)\n W[i] = sum32_4(g1_256(W[i - 2]), W[i - 7], g0_256(W[i - 15]), W[i - 16]);\n\n var a = this.h[0];\n var b = this.h[1];\n var c = this.h[2];\n var d = this.h[3];\n var e = this.h[4];\n var f = this.h[5];\n var g = this.h[6];\n var h = this.h[7];\n\n assert(this.k.length === W.length);\n for (i = 0; i < W.length; i++) {\n var T1 = sum32_5(h, s1_256(e), ch32(e, f, g), this.k[i], W[i]);\n var T2 = sum32(s0_256(a), maj32(a, b, c));\n h = g;\n g = f;\n f = e;\n e = sum32(d, T1);\n d = c;\n c = b;\n b = a;\n a = sum32(T1, T2);\n }\n\n this.h[0] = sum32(this.h[0], a);\n this.h[1] = sum32(this.h[1], b);\n this.h[2] = sum32(this.h[2], c);\n this.h[3] = sum32(this.h[3], d);\n this.h[4] = sum32(this.h[4], e);\n this.h[5] = sum32(this.h[5], f);\n this.h[6] = sum32(this.h[6], g);\n this.h[7] = sum32(this.h[7], h);\n};\n\nSHA256.prototype._digest = function digest(enc) {\n if (enc === 'hex')\n return utils.toHex32(this.h, 'big');\n else\n return utils.split32(this.h, 'big');\n};\n","'use strict';\n\nvar utils = require('../utils');\n\nvar SHA512 = require('./512');\n\nfunction SHA384() {\n if (!(this instanceof SHA384))\n return new SHA384();\n\n SHA512.call(this);\n this.h = [\n 0xcbbb9d5d, 0xc1059ed8,\n 0x629a292a, 0x367cd507,\n 0x9159015a, 0x3070dd17,\n 0x152fecd8, 0xf70e5939,\n 0x67332667, 0xffc00b31,\n 0x8eb44a87, 0x68581511,\n 0xdb0c2e0d, 0x64f98fa7,\n 0x47b5481d, 0xbefa4fa4 ];\n}\nutils.inherits(SHA384, SHA512);\nmodule.exports = SHA384;\n\nSHA384.blockSize = 1024;\nSHA384.outSize = 384;\nSHA384.hmacStrength = 192;\nSHA384.padLength = 128;\n\nSHA384.prototype._digest = function digest(enc) {\n if (enc === 'hex')\n return utils.toHex32(this.h.slice(0, 12), 'big');\n else\n return utils.split32(this.h.slice(0, 12), 'big');\n};\n","'use strict';\n\nvar utils = require('../utils');\nvar common = require('../common');\nvar assert = require('minimalistic-assert');\n\nvar rotr64_hi = utils.rotr64_hi;\nvar rotr64_lo = utils.rotr64_lo;\nvar shr64_hi = utils.shr64_hi;\nvar shr64_lo = utils.shr64_lo;\nvar sum64 = utils.sum64;\nvar sum64_hi = utils.sum64_hi;\nvar sum64_lo = utils.sum64_lo;\nvar sum64_4_hi = utils.sum64_4_hi;\nvar sum64_4_lo = utils.sum64_4_lo;\nvar sum64_5_hi = utils.sum64_5_hi;\nvar sum64_5_lo = utils.sum64_5_lo;\n\nvar BlockHash = common.BlockHash;\n\nvar sha512_K = [\n 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,\n 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,\n 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,\n 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,\n 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,\n 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,\n 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,\n 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,\n 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,\n 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,\n 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,\n 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,\n 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,\n 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,\n 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,\n 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,\n 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,\n 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,\n 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,\n 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,\n 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,\n 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,\n 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,\n 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,\n 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,\n 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,\n 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,\n 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,\n 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,\n 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,\n 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,\n 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,\n 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,\n 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,\n 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,\n 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,\n 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,\n 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,\n 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,\n 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817\n];\n\nfunction SHA512() {\n if (!(this instanceof SHA512))\n return new SHA512();\n\n BlockHash.call(this);\n this.h = [\n 0x6a09e667, 0xf3bcc908,\n 0xbb67ae85, 0x84caa73b,\n 0x3c6ef372, 0xfe94f82b,\n 0xa54ff53a, 0x5f1d36f1,\n 0x510e527f, 0xade682d1,\n 0x9b05688c, 0x2b3e6c1f,\n 0x1f83d9ab, 0xfb41bd6b,\n 0x5be0cd19, 0x137e2179 ];\n this.k = sha512_K;\n this.W = new Array(160);\n}\nutils.inherits(SHA512, BlockHash);\nmodule.exports = SHA512;\n\nSHA512.blockSize = 1024;\nSHA512.outSize = 512;\nSHA512.hmacStrength = 192;\nSHA512.padLength = 128;\n\nSHA512.prototype._prepareBlock = function _prepareBlock(msg, start) {\n var W = this.W;\n\n // 32 x 32bit words\n for (var i = 0; i < 32; i++)\n W[i] = msg[start + i];\n for (; i < W.length; i += 2) {\n var c0_hi = g1_512_hi(W[i - 4], W[i - 3]); // i - 2\n var c0_lo = g1_512_lo(W[i - 4], W[i - 3]);\n var c1_hi = W[i - 14]; // i - 7\n var c1_lo = W[i - 13];\n var c2_hi = g0_512_hi(W[i - 30], W[i - 29]); // i - 15\n var c2_lo = g0_512_lo(W[i - 30], W[i - 29]);\n var c3_hi = W[i - 32]; // i - 16\n var c3_lo = W[i - 31];\n\n W[i] = sum64_4_hi(\n c0_hi, c0_lo,\n c1_hi, c1_lo,\n c2_hi, c2_lo,\n c3_hi, c3_lo);\n W[i + 1] = sum64_4_lo(\n c0_hi, c0_lo,\n c1_hi, c1_lo,\n c2_hi, c2_lo,\n c3_hi, c3_lo);\n }\n};\n\nSHA512.prototype._update = function _update(msg, start) {\n this._prepareBlock(msg, start);\n\n var W = this.W;\n\n var ah = this.h[0];\n var al = this.h[1];\n var bh = this.h[2];\n var bl = this.h[3];\n var ch = this.h[4];\n var cl = this.h[5];\n var dh = this.h[6];\n var dl = this.h[7];\n var eh = this.h[8];\n var el = this.h[9];\n var fh = this.h[10];\n var fl = this.h[11];\n var gh = this.h[12];\n var gl = this.h[13];\n var hh = this.h[14];\n var hl = this.h[15];\n\n assert(this.k.length === W.length);\n for (var i = 0; i < W.length; i += 2) {\n var c0_hi = hh;\n var c0_lo = hl;\n var c1_hi = s1_512_hi(eh, el);\n var c1_lo = s1_512_lo(eh, el);\n var c2_hi = ch64_hi(eh, el, fh, fl, gh, gl);\n var c2_lo = ch64_lo(eh, el, fh, fl, gh, gl);\n var c3_hi = this.k[i];\n var c3_lo = this.k[i + 1];\n var c4_hi = W[i];\n var c4_lo = W[i + 1];\n\n var T1_hi = sum64_5_hi(\n c0_hi, c0_lo,\n c1_hi, c1_lo,\n c2_hi, c2_lo,\n c3_hi, c3_lo,\n c4_hi, c4_lo);\n var T1_lo = sum64_5_lo(\n c0_hi, c0_lo,\n c1_hi, c1_lo,\n c2_hi, c2_lo,\n c3_hi, c3_lo,\n c4_hi, c4_lo);\n\n c0_hi = s0_512_hi(ah, al);\n c0_lo = s0_512_lo(ah, al);\n c1_hi = maj64_hi(ah, al, bh, bl, ch, cl);\n c1_lo = maj64_lo(ah, al, bh, bl, ch, cl);\n\n var T2_hi = sum64_hi(c0_hi, c0_lo, c1_hi, c1_lo);\n var T2_lo = sum64_lo(c0_hi, c0_lo, c1_hi, c1_lo);\n\n hh = gh;\n hl = gl;\n\n gh = fh;\n gl = fl;\n\n fh = eh;\n fl = el;\n\n eh = sum64_hi(dh, dl, T1_hi, T1_lo);\n el = sum64_lo(dl, dl, T1_hi, T1_lo);\n\n dh = ch;\n dl = cl;\n\n ch = bh;\n cl = bl;\n\n bh = ah;\n bl = al;\n\n ah = sum64_hi(T1_hi, T1_lo, T2_hi, T2_lo);\n al = sum64_lo(T1_hi, T1_lo, T2_hi, T2_lo);\n }\n\n sum64(this.h, 0, ah, al);\n sum64(this.h, 2, bh, bl);\n sum64(this.h, 4, ch, cl);\n sum64(this.h, 6, dh, dl);\n sum64(this.h, 8, eh, el);\n sum64(this.h, 10, fh, fl);\n sum64(this.h, 12, gh, gl);\n sum64(this.h, 14, hh, hl);\n};\n\nSHA512.prototype._digest = function digest(enc) {\n if (enc === 'hex')\n return utils.toHex32(this.h, 'big');\n else\n return utils.split32(this.h, 'big');\n};\n\nfunction ch64_hi(xh, xl, yh, yl, zh) {\n var r = (xh & yh) ^ ((~xh) & zh);\n if (r < 0)\n r += 0x100000000;\n return r;\n}\n\nfunction ch64_lo(xh, xl, yh, yl, zh, zl) {\n var r = (xl & yl) ^ ((~xl) & zl);\n if (r < 0)\n r += 0x100000000;\n return r;\n}\n\nfunction maj64_hi(xh, xl, yh, yl, zh) {\n var r = (xh & yh) ^ (xh & zh) ^ (yh & zh);\n if (r < 0)\n r += 0x100000000;\n return r;\n}\n\nfunction maj64_lo(xh, xl, yh, yl, zh, zl) {\n var r = (xl & yl) ^ (xl & zl) ^ (yl & zl);\n if (r < 0)\n r += 0x100000000;\n return r;\n}\n\nfunction s0_512_hi(xh, xl) {\n var c0_hi = rotr64_hi(xh, xl, 28);\n var c1_hi = rotr64_hi(xl, xh, 2); // 34\n var c2_hi = rotr64_hi(xl, xh, 7); // 39\n\n var r = c0_hi ^ c1_hi ^ c2_hi;\n if (r < 0)\n r += 0x100000000;\n return r;\n}\n\nfunction s0_512_lo(xh, xl) {\n var c0_lo = rotr64_lo(xh, xl, 28);\n var c1_lo = rotr64_lo(xl, xh, 2); // 34\n var c2_lo = rotr64_lo(xl, xh, 7); // 39\n\n var r = c0_lo ^ c1_lo ^ c2_lo;\n if (r < 0)\n r += 0x100000000;\n return r;\n}\n\nfunction s1_512_hi(xh, xl) {\n var c0_hi = rotr64_hi(xh, xl, 14);\n var c1_hi = rotr64_hi(xh, xl, 18);\n var c2_hi = rotr64_hi(xl, xh, 9); // 41\n\n var r = c0_hi ^ c1_hi ^ c2_hi;\n if (r < 0)\n r += 0x100000000;\n return r;\n}\n\nfunction s1_512_lo(xh, xl) {\n var c0_lo = rotr64_lo(xh, xl, 14);\n var c1_lo = rotr64_lo(xh, xl, 18);\n var c2_lo = rotr64_lo(xl, xh, 9); // 41\n\n var r = c0_lo ^ c1_lo ^ c2_lo;\n if (r < 0)\n r += 0x100000000;\n return r;\n}\n\nfunction g0_512_hi(xh, xl) {\n var c0_hi = rotr64_hi(xh, xl, 1);\n var c1_hi = rotr64_hi(xh, xl, 8);\n var c2_hi = shr64_hi(xh, xl, 7);\n\n var r = c0_hi ^ c1_hi ^ c2_hi;\n if (r < 0)\n r += 0x100000000;\n return r;\n}\n\nfunction g0_512_lo(xh, xl) {\n var c0_lo = rotr64_lo(xh, xl, 1);\n var c1_lo = rotr64_lo(xh, xl, 8);\n var c2_lo = shr64_lo(xh, xl, 7);\n\n var r = c0_lo ^ c1_lo ^ c2_lo;\n if (r < 0)\n r += 0x100000000;\n return r;\n}\n\nfunction g1_512_hi(xh, xl) {\n var c0_hi = rotr64_hi(xh, xl, 19);\n var c1_hi = rotr64_hi(xl, xh, 29); // 61\n var c2_hi = shr64_hi(xh, xl, 6);\n\n var r = c0_hi ^ c1_hi ^ c2_hi;\n if (r < 0)\n r += 0x100000000;\n return r;\n}\n\nfunction g1_512_lo(xh, xl) {\n var c0_lo = rotr64_lo(xh, xl, 19);\n var c1_lo = rotr64_lo(xl, xh, 29); // 61\n var c2_lo = shr64_lo(xh, xl, 6);\n\n var r = c0_lo ^ c1_lo ^ c2_lo;\n if (r < 0)\n r += 0x100000000;\n return r;\n}\n","'use strict';\n\nvar utils = require('../utils');\nvar rotr32 = utils.rotr32;\n\nfunction ft_1(s, x, y, z) {\n if (s === 0)\n return ch32(x, y, z);\n if (s === 1 || s === 3)\n return p32(x, y, z);\n if (s === 2)\n return maj32(x, y, z);\n}\nexports.ft_1 = ft_1;\n\nfunction ch32(x, y, z) {\n return (x & y) ^ ((~x) & z);\n}\nexports.ch32 = ch32;\n\nfunction maj32(x, y, z) {\n return (x & y) ^ (x & z) ^ (y & z);\n}\nexports.maj32 = maj32;\n\nfunction p32(x, y, z) {\n return x ^ y ^ z;\n}\nexports.p32 = p32;\n\nfunction s0_256(x) {\n return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);\n}\nexports.s0_256 = s0_256;\n\nfunction s1_256(x) {\n return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);\n}\nexports.s1_256 = s1_256;\n\nfunction g0_256(x) {\n return rotr32(x, 7) ^ rotr32(x, 18) ^ (x >>> 3);\n}\nexports.g0_256 = g0_256;\n\nfunction g1_256(x) {\n return rotr32(x, 17) ^ rotr32(x, 19) ^ (x >>> 10);\n}\nexports.g1_256 = g1_256;\n","'use strict';\n\nvar assert = require('minimalistic-assert');\nvar inherits = require('inherits');\n\nexports.inherits = inherits;\n\nfunction isSurrogatePair(msg, i) {\n if ((msg.charCodeAt(i) & 0xFC00) !== 0xD800) {\n return false;\n }\n if (i < 0 || i + 1 >= msg.length) {\n return false;\n }\n return (msg.charCodeAt(i + 1) & 0xFC00) === 0xDC00;\n}\n\nfunction toArray(msg, enc) {\n if (Array.isArray(msg))\n return msg.slice();\n if (!msg)\n return [];\n var res = [];\n if (typeof msg === 'string') {\n if (!enc) {\n // Inspired by stringToUtf8ByteArray() in closure-library by Google\n // https://github.com/google/closure-library/blob/8598d87242af59aac233270742c8984e2b2bdbe0/closure/goog/crypt/crypt.js#L117-L143\n // Apache License 2.0\n // https://github.com/google/closure-library/blob/master/LICENSE\n var p = 0;\n for (var i = 0; i < msg.length; i++) {\n var c = msg.charCodeAt(i);\n if (c < 128) {\n res[p++] = c;\n } else if (c < 2048) {\n res[p++] = (c >> 6) | 192;\n res[p++] = (c & 63) | 128;\n } else if (isSurrogatePair(msg, i)) {\n c = 0x10000 + ((c & 0x03FF) << 10) + (msg.charCodeAt(++i) & 0x03FF);\n res[p++] = (c >> 18) | 240;\n res[p++] = ((c >> 12) & 63) | 128;\n res[p++] = ((c >> 6) & 63) | 128;\n res[p++] = (c & 63) | 128;\n } else {\n res[p++] = (c >> 12) | 224;\n res[p++] = ((c >> 6) & 63) | 128;\n res[p++] = (c & 63) | 128;\n }\n }\n } else if (enc === 'hex') {\n msg = msg.replace(/[^a-z0-9]+/ig, '');\n if (msg.length % 2 !== 0)\n msg = '0' + msg;\n for (i = 0; i < msg.length; i += 2)\n res.push(parseInt(msg[i] + msg[i + 1], 16));\n }\n } else {\n for (i = 0; i < msg.length; i++)\n res[i] = msg[i] | 0;\n }\n return res;\n}\nexports.toArray = toArray;\n\nfunction toHex(msg) {\n var res = '';\n for (var i = 0; i < msg.length; i++)\n res += zero2(msg[i].toString(16));\n return res;\n}\nexports.toHex = toHex;\n\nfunction htonl(w) {\n var res = (w >>> 24) |\n ((w >>> 8) & 0xff00) |\n ((w << 8) & 0xff0000) |\n ((w & 0xff) << 24);\n return res >>> 0;\n}\nexports.htonl = htonl;\n\nfunction toHex32(msg, endian) {\n var res = '';\n for (var i = 0; i < msg.length; i++) {\n var w = msg[i];\n if (endian === 'little')\n w = htonl(w);\n res += zero8(w.toString(16));\n }\n return res;\n}\nexports.toHex32 = toHex32;\n\nfunction zero2(word) {\n if (word.length === 1)\n return '0' + word;\n else\n return word;\n}\nexports.zero2 = zero2;\n\nfunction zero8(word) {\n if (word.length === 7)\n return '0' + word;\n else if (word.length === 6)\n return '00' + word;\n else if (word.length === 5)\n return '000' + word;\n else if (word.length === 4)\n return '0000' + word;\n else if (word.length === 3)\n return '00000' + word;\n else if (word.length === 2)\n return '000000' + word;\n else if (word.length === 1)\n return '0000000' + word;\n else\n return word;\n}\nexports.zero8 = zero8;\n\nfunction join32(msg, start, end, endian) {\n var len = end - start;\n assert(len % 4 === 0);\n var res = new Array(len / 4);\n for (var i = 0, k = start; i < res.length; i++, k += 4) {\n var w;\n if (endian === 'big')\n w = (msg[k] << 24) | (msg[k + 1] << 16) | (msg[k + 2] << 8) | msg[k + 3];\n else\n w = (msg[k + 3] << 24) | (msg[k + 2] << 16) | (msg[k + 1] << 8) | msg[k];\n res[i] = w >>> 0;\n }\n return res;\n}\nexports.join32 = join32;\n\nfunction split32(msg, endian) {\n var res = new Array(msg.length * 4);\n for (var i = 0, k = 0; i < msg.length; i++, k += 4) {\n var m = msg[i];\n if (endian === 'big') {\n res[k] = m >>> 24;\n res[k + 1] = (m >>> 16) & 0xff;\n res[k + 2] = (m >>> 8) & 0xff;\n res[k + 3] = m & 0xff;\n } else {\n res[k + 3] = m >>> 24;\n res[k + 2] = (m >>> 16) & 0xff;\n res[k + 1] = (m >>> 8) & 0xff;\n res[k] = m & 0xff;\n }\n }\n return res;\n}\nexports.split32 = split32;\n\nfunction rotr32(w, b) {\n return (w >>> b) | (w << (32 - b));\n}\nexports.rotr32 = rotr32;\n\nfunction rotl32(w, b) {\n return (w << b) | (w >>> (32 - b));\n}\nexports.rotl32 = rotl32;\n\nfunction sum32(a, b) {\n return (a + b) >>> 0;\n}\nexports.sum32 = sum32;\n\nfunction sum32_3(a, b, c) {\n return (a + b + c) >>> 0;\n}\nexports.sum32_3 = sum32_3;\n\nfunction sum32_4(a, b, c, d) {\n return (a + b + c + d) >>> 0;\n}\nexports.sum32_4 = sum32_4;\n\nfunction sum32_5(a, b, c, d, e) {\n return (a + b + c + d + e) >>> 0;\n}\nexports.sum32_5 = sum32_5;\n\nfunction sum64(buf, pos, ah, al) {\n var bh = buf[pos];\n var bl = buf[pos + 1];\n\n var lo = (al + bl) >>> 0;\n var hi = (lo < al ? 1 : 0) + ah + bh;\n buf[pos] = hi >>> 0;\n buf[pos + 1] = lo;\n}\nexports.sum64 = sum64;\n\nfunction sum64_hi(ah, al, bh, bl) {\n var lo = (al + bl) >>> 0;\n var hi = (lo < al ? 1 : 0) + ah + bh;\n return hi >>> 0;\n}\nexports.sum64_hi = sum64_hi;\n\nfunction sum64_lo(ah, al, bh, bl) {\n var lo = al + bl;\n return lo >>> 0;\n}\nexports.sum64_lo = sum64_lo;\n\nfunction sum64_4_hi(ah, al, bh, bl, ch, cl, dh, dl) {\n var carry = 0;\n var lo = al;\n lo = (lo + bl) >>> 0;\n carry += lo < al ? 1 : 0;\n lo = (lo + cl) >>> 0;\n carry += lo < cl ? 1 : 0;\n lo = (lo + dl) >>> 0;\n carry += lo < dl ? 1 : 0;\n\n var hi = ah + bh + ch + dh + carry;\n return hi >>> 0;\n}\nexports.sum64_4_hi = sum64_4_hi;\n\nfunction sum64_4_lo(ah, al, bh, bl, ch, cl, dh, dl) {\n var lo = al + bl + cl + dl;\n return lo >>> 0;\n}\nexports.sum64_4_lo = sum64_4_lo;\n\nfunction sum64_5_hi(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {\n var carry = 0;\n var lo = al;\n lo = (lo + bl) >>> 0;\n carry += lo < al ? 1 : 0;\n lo = (lo + cl) >>> 0;\n carry += lo < cl ? 1 : 0;\n lo = (lo + dl) >>> 0;\n carry += lo < dl ? 1 : 0;\n lo = (lo + el) >>> 0;\n carry += lo < el ? 1 : 0;\n\n var hi = ah + bh + ch + dh + eh + carry;\n return hi >>> 0;\n}\nexports.sum64_5_hi = sum64_5_hi;\n\nfunction sum64_5_lo(ah, al, bh, bl, ch, cl, dh, dl, eh, el) {\n var lo = al + bl + cl + dl + el;\n\n return lo >>> 0;\n}\nexports.sum64_5_lo = sum64_5_lo;\n\nfunction rotr64_hi(ah, al, num) {\n var r = (al << (32 - num)) | (ah >>> num);\n return r >>> 0;\n}\nexports.rotr64_hi = rotr64_hi;\n\nfunction rotr64_lo(ah, al, num) {\n var r = (ah << (32 - num)) | (al >>> num);\n return r >>> 0;\n}\nexports.rotr64_lo = rotr64_lo;\n\nfunction shr64_hi(ah, al, num) {\n return ah >>> num;\n}\nexports.shr64_hi = shr64_hi;\n\nfunction shr64_lo(ah, al, num) {\n var r = (ah << (32 - num)) | (al >>> num);\n return r >>> 0;\n}\nexports.shr64_lo = shr64_lo;\n","'use strict';\n\nvar hash = require('hash.js');\nvar utils = require('minimalistic-crypto-utils');\nvar assert = require('minimalistic-assert');\n\nfunction HmacDRBG(options) {\n if (!(this instanceof HmacDRBG))\n return new HmacDRBG(options);\n this.hash = options.hash;\n this.predResist = !!options.predResist;\n\n this.outLen = this.hash.outSize;\n this.minEntropy = options.minEntropy || this.hash.hmacStrength;\n\n this._reseed = null;\n this.reseedInterval = null;\n this.K = null;\n this.V = null;\n\n var entropy = utils.toArray(options.entropy, options.entropyEnc || 'hex');\n var nonce = utils.toArray(options.nonce, options.nonceEnc || 'hex');\n var pers = utils.toArray(options.pers, options.persEnc || 'hex');\n assert(entropy.length >= (this.minEntropy / 8),\n 'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');\n this._init(entropy, nonce, pers);\n}\nmodule.exports = HmacDRBG;\n\nHmacDRBG.prototype._init = function init(entropy, nonce, pers) {\n var seed = entropy.concat(nonce).concat(pers);\n\n this.K = new Array(this.outLen / 8);\n this.V = new Array(this.outLen / 8);\n for (var i = 0; i < this.V.length; i++) {\n this.K[i] = 0x00;\n this.V[i] = 0x01;\n }\n\n this._update(seed);\n this._reseed = 1;\n this.reseedInterval = 0x1000000000000; // 2^48\n};\n\nHmacDRBG.prototype._hmac = function hmac() {\n return new hash.hmac(this.hash, this.K);\n};\n\nHmacDRBG.prototype._update = function update(seed) {\n var kmac = this._hmac()\n .update(this.V)\n .update([ 0x00 ]);\n if (seed)\n kmac = kmac.update(seed);\n this.K = kmac.digest();\n this.V = this._hmac().update(this.V).digest();\n if (!seed)\n return;\n\n this.K = this._hmac()\n .update(this.V)\n .update([ 0x01 ])\n .update(seed)\n .digest();\n this.V = this._hmac().update(this.V).digest();\n};\n\nHmacDRBG.prototype.reseed = function reseed(entropy, entropyEnc, add, addEnc) {\n // Optional entropy enc\n if (typeof entropyEnc !== 'string') {\n addEnc = add;\n add = entropyEnc;\n entropyEnc = null;\n }\n\n entropy = utils.toArray(entropy, entropyEnc);\n add = utils.toArray(add, addEnc);\n\n assert(entropy.length >= (this.minEntropy / 8),\n 'Not enough entropy. Minimum is: ' + this.minEntropy + ' bits');\n\n this._update(entropy.concat(add || []));\n this._reseed = 1;\n};\n\nHmacDRBG.prototype.generate = function generate(len, enc, add, addEnc) {\n if (this._reseed > this.reseedInterval)\n throw new Error('Reseed is required');\n\n // Optional encoding\n if (typeof enc !== 'string') {\n addEnc = add;\n add = enc;\n enc = null;\n }\n\n // Optional additional data\n if (add) {\n add = utils.toArray(add, addEnc || 'hex');\n this._update(add);\n }\n\n var temp = [];\n while (temp.length < len) {\n this.V = this._hmac().update(this.V).digest();\n temp = temp.concat(this.V);\n }\n\n var res = temp.slice(0, len);\n this._update(add);\n this._reseed++;\n return utils.encode(res, enc);\n};\n","var http = require('http')\nvar url = require('url')\n\nvar https = module.exports\n\nfor (var key in http) {\n if (http.hasOwnProperty(key)) https[key] = http[key]\n}\n\nhttps.request = function (params, cb) {\n params = validateParams(params)\n return http.request.call(this, params, cb)\n}\n\nhttps.get = function (params, cb) {\n params = validateParams(params)\n return http.get.call(this, params, cb)\n}\n\nfunction validateParams (params) {\n if (typeof params === 'string') {\n params = url.parse(params)\n }\n if (!params.protocol) {\n params.protocol = 'https:'\n }\n if (params.protocol !== 'https:') {\n throw new Error('Protocol \"' + params.protocol + '\" not supported. Expected \"https:\"')\n }\n return params\n}\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","if (typeof Object.create === 'function') {\n // implementation from standard node.js 'util' module\n module.exports = function inherits(ctor, superCtor) {\n if (superCtor) {\n ctor.super_ = superCtor\n ctor.prototype = Object.create(superCtor.prototype, {\n constructor: {\n value: ctor,\n enumerable: false,\n writable: true,\n configurable: true\n }\n })\n }\n };\n} else {\n // old school shim for old browsers\n module.exports = function inherits(ctor, superCtor) {\n if (superCtor) {\n ctor.super_ = superCtor\n var TempCtor = function () {}\n TempCtor.prototype = superCtor.prototype\n ctor.prototype = new TempCtor()\n ctor.prototype.constructor = ctor\n }\n }\n}\n","'use strict';\n\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar callBound = require('call-bind/callBound');\n\nvar $toString = callBound('Object.prototype.toString');\n\nvar isStandardArguments = function isArguments(value) {\n\tif (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) {\n\t\treturn false;\n\t}\n\treturn $toString(value) === '[object Arguments]';\n};\n\nvar isLegacyArguments = function isArguments(value) {\n\tif (isStandardArguments(value)) {\n\t\treturn true;\n\t}\n\treturn value !== null &&\n\t\ttypeof value === 'object' &&\n\t\ttypeof value.length === 'number' &&\n\t\tvalue.length >= 0 &&\n\t\t$toString(value) !== '[object Array]' &&\n\t\t$toString(value.callee) === '[object Function]';\n};\n\nvar supportsStandardArguments = (function () {\n\treturn isStandardArguments(arguments);\n}());\n\nisStandardArguments.isLegacyArguments = isLegacyArguments; // for tests\n\nmodule.exports = supportsStandardArguments ? isStandardArguments : isLegacyArguments;\n","'use strict';\n\nvar fnToStr = Function.prototype.toString;\nvar reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;\nvar badArrayLike;\nvar isCallableMarker;\nif (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {\n\ttry {\n\t\tbadArrayLike = Object.defineProperty({}, 'length', {\n\t\t\tget: function () {\n\t\t\t\tthrow isCallableMarker;\n\t\t\t}\n\t\t});\n\t\tisCallableMarker = {};\n\t\t// eslint-disable-next-line no-throw-literal\n\t\treflectApply(function () { throw 42; }, null, badArrayLike);\n\t} catch (_) {\n\t\tif (_ !== isCallableMarker) {\n\t\t\treflectApply = null;\n\t\t}\n\t}\n} else {\n\treflectApply = null;\n}\n\nvar constructorRegex = /^\\s*class\\b/;\nvar isES6ClassFn = function isES6ClassFunction(value) {\n\ttry {\n\t\tvar fnStr = fnToStr.call(value);\n\t\treturn constructorRegex.test(fnStr);\n\t} catch (e) {\n\t\treturn false; // not a function\n\t}\n};\n\nvar tryFunctionObject = function tryFunctionToStr(value) {\n\ttry {\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tfnToStr.call(value);\n\t\treturn true;\n\t} catch (e) {\n\t\treturn false;\n\t}\n};\nvar toStr = Object.prototype.toString;\nvar objectClass = '[object Object]';\nvar fnClass = '[object Function]';\nvar genClass = '[object GeneratorFunction]';\nvar ddaClass = '[object HTMLAllCollection]'; // IE 11\nvar ddaClass2 = '[object HTML document.all class]';\nvar ddaClass3 = '[object HTMLCollection]'; // IE 9-10\nvar hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`\n\nvar isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing\n\nvar isDDA = function isDocumentDotAll() { return false; };\nif (typeof document === 'object') {\n\t// Firefox 3 canonicalizes DDA to undefined when it's not accessed directly\n\tvar all = document.all;\n\tif (toStr.call(all) === toStr.call(document.all)) {\n\t\tisDDA = function isDocumentDotAll(value) {\n\t\t\t/* globals document: false */\n\t\t\t// in IE 6-8, typeof document.all is \"object\" and it's truthy\n\t\t\tif ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {\n\t\t\t\ttry {\n\t\t\t\t\tvar str = toStr.call(value);\n\t\t\t\t\treturn (\n\t\t\t\t\t\tstr === ddaClass\n\t\t\t\t\t\t|| str === ddaClass2\n\t\t\t\t\t\t|| str === ddaClass3 // opera 12.16\n\t\t\t\t\t\t|| str === objectClass // IE 6-8\n\t\t\t\t\t) && value('') == null; // eslint-disable-line eqeqeq\n\t\t\t\t} catch (e) { /**/ }\n\t\t\t}\n\t\t\treturn false;\n\t\t};\n\t}\n}\n\nmodule.exports = reflectApply\n\t? function isCallable(value) {\n\t\tif (isDDA(value)) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\ttry {\n\t\t\treflectApply(value, null, badArrayLike);\n\t\t} catch (e) {\n\t\t\tif (e !== isCallableMarker) { return false; }\n\t\t}\n\t\treturn !isES6ClassFn(value) && tryFunctionObject(value);\n\t}\n\t: function isCallable(value) {\n\t\tif (isDDA(value)) { return true; }\n\t\tif (!value) { return false; }\n\t\tif (typeof value !== 'function' && typeof value !== 'object') { return false; }\n\t\tif (hasToStringTag) { return tryFunctionObject(value); }\n\t\tif (isES6ClassFn(value)) { return false; }\n\t\tvar strClass = toStr.call(value);\n\t\tif (strClass !== fnClass && strClass !== genClass && !(/^\\[object HTML/).test(strClass)) { return false; }\n\t\treturn tryFunctionObject(value);\n\t};\n","'use strict';\n\nvar toStr = Object.prototype.toString;\nvar fnToStr = Function.prototype.toString;\nvar isFnRegex = /^\\s*(?:function)?\\*/;\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar getProto = Object.getPrototypeOf;\nvar getGeneratorFunc = function () { // eslint-disable-line consistent-return\n\tif (!hasToStringTag) {\n\t\treturn false;\n\t}\n\ttry {\n\t\treturn Function('return function*() {}')();\n\t} catch (e) {\n\t}\n};\nvar GeneratorFunction;\n\nmodule.exports = function isGeneratorFunction(fn) {\n\tif (typeof fn !== 'function') {\n\t\treturn false;\n\t}\n\tif (isFnRegex.test(fnToStr.call(fn))) {\n\t\treturn true;\n\t}\n\tif (!hasToStringTag) {\n\t\tvar str = toStr.call(fn);\n\t\treturn str === '[object GeneratorFunction]';\n\t}\n\tif (!getProto) {\n\t\treturn false;\n\t}\n\tif (typeof GeneratorFunction === 'undefined') {\n\t\tvar generatorFunc = getGeneratorFunc();\n\t\tGeneratorFunction = generatorFunc ? getProto(generatorFunc) : false;\n\t}\n\treturn getProto(fn) === GeneratorFunction;\n};\n","'use strict';\n\n/* http://www.ecma-international.org/ecma-262/6.0/#sec-number.isnan */\n\nmodule.exports = function isNaN(value) {\n\treturn value !== value;\n};\n","'use strict';\n\nvar callBind = require('call-bind');\nvar define = require('define-properties');\n\nvar implementation = require('./implementation');\nvar getPolyfill = require('./polyfill');\nvar shim = require('./shim');\n\nvar polyfill = callBind(getPolyfill(), Number);\n\n/* http://www.ecma-international.org/ecma-262/6.0/#sec-number.isnan */\n\ndefine(polyfill, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = polyfill;\n","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = function getPolyfill() {\n\tif (Number.isNaN && Number.isNaN(NaN) && !Number.isNaN('a')) {\n\t\treturn Number.isNaN;\n\t}\n\treturn implementation;\n};\n","'use strict';\n\nvar define = require('define-properties');\nvar getPolyfill = require('./polyfill');\n\n/* http://www.ecma-international.org/ecma-262/6.0/#sec-number.isnan */\n\nmodule.exports = function shimNumberIsNaN() {\n\tvar polyfill = getPolyfill();\n\tdefine(Number, { isNaN: polyfill }, {\n\t\tisNaN: function testIsNaN() {\n\t\t\treturn Number.isNaN !== polyfill;\n\t\t}\n\t});\n\treturn polyfill;\n};\n","'use strict';\n\nvar forEach = require('for-each');\nvar availableTypedArrays = require('available-typed-arrays');\nvar callBound = require('call-bind/callBound');\n\nvar $toString = callBound('Object.prototype.toString');\nvar hasToStringTag = require('has-tostringtag/shams')();\nvar gOPD = require('gopd');\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\nvar typedArrays = availableTypedArrays();\n\nvar $indexOf = callBound('Array.prototype.indexOf', true) || function indexOf(array, value) {\n\tfor (var i = 0; i < array.length; i += 1) {\n\t\tif (array[i] === value) {\n\t\t\treturn i;\n\t\t}\n\t}\n\treturn -1;\n};\nvar $slice = callBound('String.prototype.slice');\nvar toStrTags = {};\nvar getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');\nif (hasToStringTag && gOPD && getPrototypeOf) {\n\tforEach(typedArrays, function (typedArray) {\n\t\tvar arr = new g[typedArray]();\n\t\tif (Symbol.toStringTag in arr) {\n\t\t\tvar proto = getPrototypeOf(arr);\n\t\t\tvar descriptor = gOPD(proto, Symbol.toStringTag);\n\t\t\tif (!descriptor) {\n\t\t\t\tvar superProto = getPrototypeOf(proto);\n\t\t\t\tdescriptor = gOPD(superProto, Symbol.toStringTag);\n\t\t\t}\n\t\t\ttoStrTags[typedArray] = descriptor.get;\n\t\t}\n\t});\n}\n\nvar tryTypedArrays = function tryAllTypedArrays(value) {\n\tvar anyTrue = false;\n\tforEach(toStrTags, function (getter, typedArray) {\n\t\tif (!anyTrue) {\n\t\t\ttry {\n\t\t\t\tanyTrue = getter.call(value) === typedArray;\n\t\t\t} catch (e) { /**/ }\n\t\t}\n\t});\n\treturn anyTrue;\n};\n\nmodule.exports = function isTypedArray(value) {\n\tif (!value || typeof value !== 'object') { return false; }\n\tif (!hasToStringTag || !(Symbol.toStringTag in value)) {\n\t\tvar tag = $slice($toString(value), 8, -1);\n\t\treturn $indexOf(typedArrays, tag) > -1;\n\t}\n\tif (!gOPD) { return false; }\n\treturn tryTypedArrays(value);\n};\n","var getNative = require('./_getNative'),\n root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView');\n\nmodule.exports = DataView;\n","var hashClear = require('./_hashClear'),\n hashDelete = require('./_hashDelete'),\n hashGet = require('./_hashGet'),\n hashHas = require('./_hashHas'),\n hashSet = require('./_hashSet');\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nmodule.exports = Hash;\n","var listCacheClear = require('./_listCacheClear'),\n listCacheDelete = require('./_listCacheDelete'),\n listCacheGet = require('./_listCacheGet'),\n listCacheHas = require('./_listCacheHas'),\n listCacheSet = require('./_listCacheSet');\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nmodule.exports = ListCache;\n","var getNative = require('./_getNative'),\n root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nmodule.exports = Map;\n","var mapCacheClear = require('./_mapCacheClear'),\n mapCacheDelete = require('./_mapCacheDelete'),\n mapCacheGet = require('./_mapCacheGet'),\n mapCacheHas = require('./_mapCacheHas'),\n mapCacheSet = require('./_mapCacheSet');\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nmodule.exports = MapCache;\n","var getNative = require('./_getNative'),\n root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Promise = getNative(root, 'Promise');\n\nmodule.exports = Promise;\n","var getNative = require('./_getNative'),\n root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar Set = getNative(root, 'Set');\n\nmodule.exports = Set;\n","var MapCache = require('./_MapCache'),\n setCacheAdd = require('./_setCacheAdd'),\n setCacheHas = require('./_setCacheHas');\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n var index = -1,\n length = values == null ? 0 : values.length;\n\n this.__data__ = new MapCache;\n while (++index < length) {\n this.add(values[index]);\n }\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\nmodule.exports = SetCache;\n","var ListCache = require('./_ListCache'),\n stackClear = require('./_stackClear'),\n stackDelete = require('./_stackDelete'),\n stackGet = require('./_stackGet'),\n stackHas = require('./_stackHas'),\n stackSet = require('./_stackSet');\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n var data = this.__data__ = new ListCache(entries);\n this.size = data.size;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\nmodule.exports = Stack;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nmodule.exports = Symbol;\n","var root = require('./_root');\n\n/** Built-in value references. */\nvar Uint8Array = root.Uint8Array;\n\nmodule.exports = Uint8Array;\n","var getNative = require('./_getNative'),\n root = require('./_root');\n\n/* Built-in method references that are verified to be native. */\nvar WeakMap = getNative(root, 'WeakMap');\n\nmodule.exports = WeakMap;\n","/**\n * A specialized version of `baseAggregator` for arrays.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} setter The function to set `accumulator` values.\n * @param {Function} iteratee The iteratee to transform keys.\n * @param {Object} accumulator The initial aggregated object.\n * @returns {Function} Returns `accumulator`.\n */\nfunction arrayAggregator(array, setter, iteratee, accumulator) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n var value = array[index];\n setter(accumulator, value, iteratee(value), array);\n }\n return accumulator;\n}\n\nmodule.exports = arrayAggregator;\n","/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length,\n resIndex = 0,\n result = [];\n\n while (++index < length) {\n var value = array[index];\n if (predicate(value, index, array)) {\n result[resIndex++] = value;\n }\n }\n return result;\n}\n\nmodule.exports = arrayFilter;\n","var baseTimes = require('./_baseTimes'),\n isArguments = require('./isArguments'),\n isArray = require('./isArray'),\n isBuffer = require('./isBuffer'),\n isIndex = require('./_isIndex'),\n isTypedArray = require('./isTypedArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n var isArr = isArray(value),\n isArg = !isArr && isArguments(value),\n isBuff = !isArr && !isArg && isBuffer(value),\n isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n skipIndexes = isArr || isArg || isBuff || isType,\n result = skipIndexes ? baseTimes(value.length, String) : [],\n length = result.length;\n\n for (var key in value) {\n if ((inherited || hasOwnProperty.call(value, key)) &&\n !(skipIndexes && (\n // Safari 9 has enumerable `arguments.length` in strict mode.\n key == 'length' ||\n // Node.js 0.10 has enumerable non-index properties on buffers.\n (isBuff && (key == 'offset' || key == 'parent')) ||\n // PhantomJS 2 has enumerable non-index properties on typed arrays.\n (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n // Skip index properties.\n isIndex(key, length)\n ))) {\n result.push(key);\n }\n }\n return result;\n}\n\nmodule.exports = arrayLikeKeys;\n","/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n var index = -1,\n length = array == null ? 0 : array.length,\n result = Array(length);\n\n while (++index < length) {\n result[index] = iteratee(array[index], index, array);\n }\n return result;\n}\n\nmodule.exports = arrayMap;\n","/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n var index = -1,\n length = values.length,\n offset = array.length;\n\n while (++index < length) {\n array[offset + index] = values[index];\n }\n return array;\n}\n\nmodule.exports = arrayPush;\n","/**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n * else `false`.\n */\nfunction arraySome(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (predicate(array[index], index, array)) {\n return true;\n }\n }\n return false;\n}\n\nmodule.exports = arraySome;\n","var baseAssignValue = require('./_baseAssignValue'),\n eq = require('./eq');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n var objValue = object[key];\n if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n (value === undefined && !(key in object))) {\n baseAssignValue(object, key, value);\n }\n}\n\nmodule.exports = assignValue;\n","var eq = require('./eq');\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n var length = array.length;\n while (length--) {\n if (eq(array[length][0], key)) {\n return length;\n }\n }\n return -1;\n}\n\nmodule.exports = assocIndexOf;\n","var baseEach = require('./_baseEach');\n\n/**\n * Aggregates elements of `collection` on `accumulator` with keys transformed\n * by `iteratee` and values set by `setter`.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} setter The function to set `accumulator` values.\n * @param {Function} iteratee The iteratee to transform keys.\n * @param {Object} accumulator The initial aggregated object.\n * @returns {Function} Returns `accumulator`.\n */\nfunction baseAggregator(collection, setter, iteratee, accumulator) {\n baseEach(collection, function(value, key, collection) {\n setter(accumulator, value, iteratee(value), collection);\n });\n return accumulator;\n}\n\nmodule.exports = baseAggregator;\n","var defineProperty = require('./_defineProperty');\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n if (key == '__proto__' && defineProperty) {\n defineProperty(object, key, {\n 'configurable': true,\n 'enumerable': true,\n 'value': value,\n 'writable': true\n });\n } else {\n object[key] = value;\n }\n}\n\nmodule.exports = baseAssignValue;\n","var baseForOwn = require('./_baseForOwn'),\n createBaseEach = require('./_createBaseEach');\n\n/**\n * The base implementation of `_.forEach` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array|Object} Returns `collection`.\n */\nvar baseEach = createBaseEach(baseForOwn);\n\nmodule.exports = baseEach;\n","var arrayPush = require('./_arrayPush'),\n isFlattenable = require('./_isFlattenable');\n\n/**\n * The base implementation of `_.flatten` with support for restricting flattening.\n *\n * @private\n * @param {Array} array The array to flatten.\n * @param {number} depth The maximum recursion depth.\n * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n * @param {Array} [result=[]] The initial result value.\n * @returns {Array} Returns the new flattened array.\n */\nfunction baseFlatten(array, depth, predicate, isStrict, result) {\n var index = -1,\n length = array.length;\n\n predicate || (predicate = isFlattenable);\n result || (result = []);\n\n while (++index < length) {\n var value = array[index];\n if (depth > 0 && predicate(value)) {\n if (depth > 1) {\n // Recursively flatten arrays (susceptible to call stack limits).\n baseFlatten(value, depth - 1, predicate, isStrict, result);\n } else {\n arrayPush(result, value);\n }\n } else if (!isStrict) {\n result[result.length] = value;\n }\n }\n return result;\n}\n\nmodule.exports = baseFlatten;\n","var createBaseFor = require('./_createBaseFor');\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\nmodule.exports = baseFor;\n","var baseFor = require('./_baseFor'),\n keys = require('./keys');\n\n/**\n * The base implementation of `_.forOwn` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Object} Returns `object`.\n */\nfunction baseForOwn(object, iteratee) {\n return object && baseFor(object, iteratee, keys);\n}\n\nmodule.exports = baseForOwn;\n","var castPath = require('./_castPath'),\n toKey = require('./_toKey');\n\n/**\n * The base implementation of `_.get` without support for default values.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @returns {*} Returns the resolved value.\n */\nfunction baseGet(object, path) {\n path = castPath(path, object);\n\n var index = 0,\n length = path.length;\n\n while (object != null && index < length) {\n object = object[toKey(path[index++])];\n }\n return (index && index == length) ? object : undefined;\n}\n\nmodule.exports = baseGet;\n","var arrayPush = require('./_arrayPush'),\n isArray = require('./isArray');\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n var result = keysFunc(object);\n return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\nmodule.exports = baseGetAllKeys;\n","var Symbol = require('./_Symbol'),\n getRawTag = require('./_getRawTag'),\n objectToString = require('./_objectToString');\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n if (value == null) {\n return value === undefined ? undefinedTag : nullTag;\n }\n return (symToStringTag && symToStringTag in Object(value))\n ? getRawTag(value)\n : objectToString(value);\n}\n\nmodule.exports = baseGetTag;\n","/**\n * The base implementation of `_.hasIn` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\nfunction baseHasIn(object, key) {\n return object != null && key in Object(object);\n}\n\nmodule.exports = baseHasIn;\n","var baseGetTag = require('./_baseGetTag'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nmodule.exports = baseIsArguments;\n","var baseIsEqualDeep = require('./_baseIsEqualDeep'),\n isObjectLike = require('./isObjectLike');\n\n/**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n * 1 - Unordered comparison\n * 2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, bitmask, customizer, stack) {\n if (value === other) {\n return true;\n }\n if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n return value !== value && other !== other;\n }\n return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n}\n\nmodule.exports = baseIsEqual;\n","var Stack = require('./_Stack'),\n equalArrays = require('./_equalArrays'),\n equalByTag = require('./_equalByTag'),\n equalObjects = require('./_equalObjects'),\n getTag = require('./_getTag'),\n isArray = require('./isArray'),\n isBuffer = require('./isBuffer'),\n isTypedArray = require('./isTypedArray');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n var objIsArr = isArray(object),\n othIsArr = isArray(other),\n objTag = objIsArr ? arrayTag : getTag(object),\n othTag = othIsArr ? arrayTag : getTag(other);\n\n objTag = objTag == argsTag ? objectTag : objTag;\n othTag = othTag == argsTag ? objectTag : othTag;\n\n var objIsObj = objTag == objectTag,\n othIsObj = othTag == objectTag,\n isSameTag = objTag == othTag;\n\n if (isSameTag && isBuffer(object)) {\n if (!isBuffer(other)) {\n return false;\n }\n objIsArr = true;\n objIsObj = false;\n }\n if (isSameTag && !objIsObj) {\n stack || (stack = new Stack);\n return (objIsArr || isTypedArray(object))\n ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n }\n if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n if (objIsWrapped || othIsWrapped) {\n var objUnwrapped = objIsWrapped ? object.value() : object,\n othUnwrapped = othIsWrapped ? other.value() : other;\n\n stack || (stack = new Stack);\n return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n }\n }\n if (!isSameTag) {\n return false;\n }\n stack || (stack = new Stack);\n return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n}\n\nmodule.exports = baseIsEqualDeep;\n","var Stack = require('./_Stack'),\n baseIsEqual = require('./_baseIsEqual');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * The base implementation of `_.isMatch` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property values to match.\n * @param {Array} matchData The property names, values, and compare flags to match.\n * @param {Function} [customizer] The function to customize comparisons.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n */\nfunction baseIsMatch(object, source, matchData, customizer) {\n var index = matchData.length,\n length = index,\n noCustomizer = !customizer;\n\n if (object == null) {\n return !length;\n }\n object = Object(object);\n while (index--) {\n var data = matchData[index];\n if ((noCustomizer && data[2])\n ? data[1] !== object[data[0]]\n : !(data[0] in object)\n ) {\n return false;\n }\n }\n while (++index < length) {\n data = matchData[index];\n var key = data[0],\n objValue = object[key],\n srcValue = data[1];\n\n if (noCustomizer && data[2]) {\n if (objValue === undefined && !(key in object)) {\n return false;\n }\n } else {\n var stack = new Stack;\n if (customizer) {\n var result = customizer(objValue, srcValue, key, object, source, stack);\n }\n if (!(result === undefined\n ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)\n : result\n )) {\n return false;\n }\n }\n }\n return true;\n}\n\nmodule.exports = baseIsMatch;\n","var isFunction = require('./isFunction'),\n isMasked = require('./_isMasked'),\n isObject = require('./isObject'),\n toSource = require('./_toSource');\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n */\nfunction baseIsNative(value) {\n if (!isObject(value) || isMasked(value)) {\n return false;\n }\n var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n}\n\nmodule.exports = baseIsNative;\n","var baseGetTag = require('./_baseGetTag'),\n isLength = require('./isLength'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n objectTag = '[object Object]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n return isObjectLike(value) &&\n isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\nmodule.exports = baseIsTypedArray;\n","var baseMatches = require('./_baseMatches'),\n baseMatchesProperty = require('./_baseMatchesProperty'),\n identity = require('./identity'),\n isArray = require('./isArray'),\n property = require('./property');\n\n/**\n * The base implementation of `_.iteratee`.\n *\n * @private\n * @param {*} [value=_.identity] The value to convert to an iteratee.\n * @returns {Function} Returns the iteratee.\n */\nfunction baseIteratee(value) {\n // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.\n // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.\n if (typeof value == 'function') {\n return value;\n }\n if (value == null) {\n return identity;\n }\n if (typeof value == 'object') {\n return isArray(value)\n ? baseMatchesProperty(value[0], value[1])\n : baseMatches(value);\n }\n return property(value);\n}\n\nmodule.exports = baseIteratee;\n","var isPrototype = require('./_isPrototype'),\n nativeKeys = require('./_nativeKeys');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n if (!isPrototype(object)) {\n return nativeKeys(object);\n }\n var result = [];\n for (var key in Object(object)) {\n if (hasOwnProperty.call(object, key) && key != 'constructor') {\n result.push(key);\n }\n }\n return result;\n}\n\nmodule.exports = baseKeys;\n","var isObject = require('./isObject'),\n isPrototype = require('./_isPrototype'),\n nativeKeysIn = require('./_nativeKeysIn');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n if (!isObject(object)) {\n return nativeKeysIn(object);\n }\n var isProto = isPrototype(object),\n result = [];\n\n for (var key in object) {\n if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n result.push(key);\n }\n }\n return result;\n}\n\nmodule.exports = baseKeysIn;\n","var baseEach = require('./_baseEach'),\n isArrayLike = require('./isArrayLike');\n\n/**\n * The base implementation of `_.map` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction baseMap(collection, iteratee) {\n var index = -1,\n result = isArrayLike(collection) ? Array(collection.length) : [];\n\n baseEach(collection, function(value, key, collection) {\n result[++index] = iteratee(value, key, collection);\n });\n return result;\n}\n\nmodule.exports = baseMap;\n","var baseIsMatch = require('./_baseIsMatch'),\n getMatchData = require('./_getMatchData'),\n matchesStrictComparable = require('./_matchesStrictComparable');\n\n/**\n * The base implementation of `_.matches` which doesn't clone `source`.\n *\n * @private\n * @param {Object} source The object of property values to match.\n * @returns {Function} Returns the new spec function.\n */\nfunction baseMatches(source) {\n var matchData = getMatchData(source);\n if (matchData.length == 1 && matchData[0][2]) {\n return matchesStrictComparable(matchData[0][0], matchData[0][1]);\n }\n return function(object) {\n return object === source || baseIsMatch(object, source, matchData);\n };\n}\n\nmodule.exports = baseMatches;\n","var baseIsEqual = require('./_baseIsEqual'),\n get = require('./get'),\n hasIn = require('./hasIn'),\n isKey = require('./_isKey'),\n isStrictComparable = require('./_isStrictComparable'),\n matchesStrictComparable = require('./_matchesStrictComparable'),\n toKey = require('./_toKey');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.\n *\n * @private\n * @param {string} path The path of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\nfunction baseMatchesProperty(path, srcValue) {\n if (isKey(path) && isStrictComparable(srcValue)) {\n return matchesStrictComparable(toKey(path), srcValue);\n }\n return function(object) {\n var objValue = get(object, path);\n return (objValue === undefined && objValue === srcValue)\n ? hasIn(object, path)\n : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);\n };\n}\n\nmodule.exports = baseMatchesProperty;\n","var baseGet = require('./_baseGet'),\n baseSet = require('./_baseSet'),\n castPath = require('./_castPath');\n\n/**\n * The base implementation of `_.pickBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @param {Function} predicate The function invoked per property.\n * @returns {Object} Returns the new object.\n */\nfunction basePickBy(object, paths, predicate) {\n var index = -1,\n length = paths.length,\n result = {};\n\n while (++index < length) {\n var path = paths[index],\n value = baseGet(object, path);\n\n if (predicate(value, path)) {\n baseSet(result, castPath(path, object), value);\n }\n }\n return result;\n}\n\nmodule.exports = basePickBy;\n","/**\n * The base implementation of `_.property` without support for deep paths.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\nfunction baseProperty(key) {\n return function(object) {\n return object == null ? undefined : object[key];\n };\n}\n\nmodule.exports = baseProperty;\n","var baseGet = require('./_baseGet');\n\n/**\n * A specialized version of `baseProperty` which supports deep paths.\n *\n * @private\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\nfunction basePropertyDeep(path) {\n return function(object) {\n return baseGet(object, path);\n };\n}\n\nmodule.exports = basePropertyDeep;\n","var assignValue = require('./_assignValue'),\n castPath = require('./_castPath'),\n isIndex = require('./_isIndex'),\n isObject = require('./isObject'),\n toKey = require('./_toKey');\n\n/**\n * The base implementation of `_.set`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @param {Function} [customizer] The function to customize path creation.\n * @returns {Object} Returns `object`.\n */\nfunction baseSet(object, path, value, customizer) {\n if (!isObject(object)) {\n return object;\n }\n path = castPath(path, object);\n\n var index = -1,\n length = path.length,\n lastIndex = length - 1,\n nested = object;\n\n while (nested != null && ++index < length) {\n var key = toKey(path[index]),\n newValue = value;\n\n if (key === '__proto__' || key === 'constructor' || key === 'prototype') {\n return object;\n }\n\n if (index != lastIndex) {\n var objValue = nested[key];\n newValue = customizer ? customizer(objValue, key, nested) : undefined;\n if (newValue === undefined) {\n newValue = isObject(objValue)\n ? objValue\n : (isIndex(path[index + 1]) ? [] : {});\n }\n }\n assignValue(nested, key, newValue);\n nested = nested[key];\n }\n return object;\n}\n\nmodule.exports = baseSet;\n","/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n var index = -1,\n result = Array(n);\n\n while (++index < n) {\n result[index] = iteratee(index);\n }\n return result;\n}\n\nmodule.exports = baseTimes;\n","var Symbol = require('./_Symbol'),\n arrayMap = require('./_arrayMap'),\n isArray = require('./isArray'),\n isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n // Exit early for strings to avoid a performance hit in some environments.\n if (typeof value == 'string') {\n return value;\n }\n if (isArray(value)) {\n // Recursively convert values (susceptible to call stack limits).\n return arrayMap(value, baseToString) + '';\n }\n if (isSymbol(value)) {\n return symbolToString ? symbolToString.call(value) : '';\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nmodule.exports = baseToString;\n","/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n return function(value) {\n return func(value);\n };\n}\n\nmodule.exports = baseUnary;\n","/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n return cache.has(key);\n}\n\nmodule.exports = cacheHas;\n","var isArray = require('./isArray'),\n isKey = require('./_isKey'),\n stringToPath = require('./_stringToPath'),\n toString = require('./toString');\n\n/**\n * Casts `value` to a path array if it's not one.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {Object} [object] The object to query keys on.\n * @returns {Array} Returns the cast property path array.\n */\nfunction castPath(value, object) {\n if (isArray(value)) {\n return value;\n }\n return isKey(value, object) ? [value] : stringToPath(toString(value));\n}\n\nmodule.exports = castPath;\n","var root = require('./_root');\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nmodule.exports = coreJsData;\n","var arrayAggregator = require('./_arrayAggregator'),\n baseAggregator = require('./_baseAggregator'),\n baseIteratee = require('./_baseIteratee'),\n isArray = require('./isArray');\n\n/**\n * Creates a function like `_.groupBy`.\n *\n * @private\n * @param {Function} setter The function to set accumulator values.\n * @param {Function} [initializer] The accumulator object initializer.\n * @returns {Function} Returns the new aggregator function.\n */\nfunction createAggregator(setter, initializer) {\n return function(collection, iteratee) {\n var func = isArray(collection) ? arrayAggregator : baseAggregator,\n accumulator = initializer ? initializer() : {};\n\n return func(collection, setter, baseIteratee(iteratee, 2), accumulator);\n };\n}\n\nmodule.exports = createAggregator;\n","var isArrayLike = require('./isArrayLike');\n\n/**\n * Creates a `baseEach` or `baseEachRight` function.\n *\n * @private\n * @param {Function} eachFunc The function to iterate over a collection.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseEach(eachFunc, fromRight) {\n return function(collection, iteratee) {\n if (collection == null) {\n return collection;\n }\n if (!isArrayLike(collection)) {\n return eachFunc(collection, iteratee);\n }\n var length = collection.length,\n index = fromRight ? length : -1,\n iterable = Object(collection);\n\n while ((fromRight ? index-- : ++index < length)) {\n if (iteratee(iterable[index], index, iterable) === false) {\n break;\n }\n }\n return collection;\n };\n}\n\nmodule.exports = createBaseEach;\n","/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n return function(object, iteratee, keysFunc) {\n var index = -1,\n iterable = Object(object),\n props = keysFunc(object),\n length = props.length;\n\n while (length--) {\n var key = props[fromRight ? length : ++index];\n if (iteratee(iterable[key], key, iterable) === false) {\n break;\n }\n }\n return object;\n };\n}\n\nmodule.exports = createBaseFor;\n","var getNative = require('./_getNative');\n\nvar defineProperty = (function() {\n try {\n var func = getNative(Object, 'defineProperty');\n func({}, '', {});\n return func;\n } catch (e) {}\n}());\n\nmodule.exports = defineProperty;\n","var SetCache = require('./_SetCache'),\n arraySome = require('./_arraySome'),\n cacheHas = require('./_cacheHas');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n arrLength = array.length,\n othLength = other.length;\n\n if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n return false;\n }\n // Check that cyclic values are equal.\n var arrStacked = stack.get(array);\n var othStacked = stack.get(other);\n if (arrStacked && othStacked) {\n return arrStacked == other && othStacked == array;\n }\n var index = -1,\n result = true,\n seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n stack.set(array, other);\n stack.set(other, array);\n\n // Ignore non-index properties.\n while (++index < arrLength) {\n var arrValue = array[index],\n othValue = other[index];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, arrValue, index, other, array, stack)\n : customizer(arrValue, othValue, index, array, other, stack);\n }\n if (compared !== undefined) {\n if (compared) {\n continue;\n }\n result = false;\n break;\n }\n // Recursively compare arrays (susceptible to call stack limits).\n if (seen) {\n if (!arraySome(other, function(othValue, othIndex) {\n if (!cacheHas(seen, othIndex) &&\n (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n return seen.push(othIndex);\n }\n })) {\n result = false;\n break;\n }\n } else if (!(\n arrValue === othValue ||\n equalFunc(arrValue, othValue, bitmask, customizer, stack)\n )) {\n result = false;\n break;\n }\n }\n stack['delete'](array);\n stack['delete'](other);\n return result;\n}\n\nmodule.exports = equalArrays;\n","var Symbol = require('./_Symbol'),\n Uint8Array = require('./_Uint8Array'),\n eq = require('./eq'),\n equalArrays = require('./_equalArrays'),\n mapToArray = require('./_mapToArray'),\n setToArray = require('./_setToArray');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]';\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n switch (tag) {\n case dataViewTag:\n if ((object.byteLength != other.byteLength) ||\n (object.byteOffset != other.byteOffset)) {\n return false;\n }\n object = object.buffer;\n other = other.buffer;\n\n case arrayBufferTag:\n if ((object.byteLength != other.byteLength) ||\n !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n return false;\n }\n return true;\n\n case boolTag:\n case dateTag:\n case numberTag:\n // Coerce booleans to `1` or `0` and dates to milliseconds.\n // Invalid dates are coerced to `NaN`.\n return eq(+object, +other);\n\n case errorTag:\n return object.name == other.name && object.message == other.message;\n\n case regexpTag:\n case stringTag:\n // Coerce regexes to strings and treat strings, primitives and objects,\n // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n // for more details.\n return object == (other + '');\n\n case mapTag:\n var convert = mapToArray;\n\n case setTag:\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n convert || (convert = setToArray);\n\n if (object.size != other.size && !isPartial) {\n return false;\n }\n // Assume cyclic values are equal.\n var stacked = stack.get(object);\n if (stacked) {\n return stacked == other;\n }\n bitmask |= COMPARE_UNORDERED_FLAG;\n\n // Recursively compare objects (susceptible to call stack limits).\n stack.set(object, other);\n var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n stack['delete'](object);\n return result;\n\n case symbolTag:\n if (symbolValueOf) {\n return symbolValueOf.call(object) == symbolValueOf.call(other);\n }\n }\n return false;\n}\n\nmodule.exports = equalByTag;\n","var getAllKeys = require('./_getAllKeys');\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n objProps = getAllKeys(object),\n objLength = objProps.length,\n othProps = getAllKeys(other),\n othLength = othProps.length;\n\n if (objLength != othLength && !isPartial) {\n return false;\n }\n var index = objLength;\n while (index--) {\n var key = objProps[index];\n if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n return false;\n }\n }\n // Check that cyclic values are equal.\n var objStacked = stack.get(object);\n var othStacked = stack.get(other);\n if (objStacked && othStacked) {\n return objStacked == other && othStacked == object;\n }\n var result = true;\n stack.set(object, other);\n stack.set(other, object);\n\n var skipCtor = isPartial;\n while (++index < objLength) {\n key = objProps[index];\n var objValue = object[key],\n othValue = other[key];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, objValue, key, other, object, stack)\n : customizer(objValue, othValue, key, object, other, stack);\n }\n // Recursively compare objects (susceptible to call stack limits).\n if (!(compared === undefined\n ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n : compared\n )) {\n result = false;\n break;\n }\n skipCtor || (skipCtor = key == 'constructor');\n }\n if (result && !skipCtor) {\n var objCtor = object.constructor,\n othCtor = other.constructor;\n\n // Non `Object` object instances with different constructors are not equal.\n if (objCtor != othCtor &&\n ('constructor' in object && 'constructor' in other) &&\n !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n result = false;\n }\n }\n stack['delete'](object);\n stack['delete'](other);\n return result;\n}\n\nmodule.exports = equalObjects;\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nmodule.exports = freeGlobal;\n","var baseGetAllKeys = require('./_baseGetAllKeys'),\n getSymbols = require('./_getSymbols'),\n keys = require('./keys');\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n return baseGetAllKeys(object, keys, getSymbols);\n}\n\nmodule.exports = getAllKeys;\n","var baseGetAllKeys = require('./_baseGetAllKeys'),\n getSymbolsIn = require('./_getSymbolsIn'),\n keysIn = require('./keysIn');\n\n/**\n * Creates an array of own and inherited enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeysIn(object) {\n return baseGetAllKeys(object, keysIn, getSymbolsIn);\n}\n\nmodule.exports = getAllKeysIn;\n","var isKeyable = require('./_isKeyable');\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n var data = map.__data__;\n return isKeyable(key)\n ? data[typeof key == 'string' ? 'string' : 'hash']\n : data.map;\n}\n\nmodule.exports = getMapData;\n","var isStrictComparable = require('./_isStrictComparable'),\n keys = require('./keys');\n\n/**\n * Gets the property names, values, and compare flags of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the match data of `object`.\n */\nfunction getMatchData(object) {\n var result = keys(object),\n length = result.length;\n\n while (length--) {\n var key = result[length],\n value = object[key];\n\n result[length] = [key, value, isStrictComparable(value)];\n }\n return result;\n}\n\nmodule.exports = getMatchData;\n","var baseIsNative = require('./_baseIsNative'),\n getValue = require('./_getValue');\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n}\n\nmodule.exports = getNative;\n","var overArg = require('./_overArg');\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nmodule.exports = getPrototype;\n","var Symbol = require('./_Symbol');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n var isOwn = hasOwnProperty.call(value, symToStringTag),\n tag = value[symToStringTag];\n\n try {\n value[symToStringTag] = undefined;\n var unmasked = true;\n } catch (e) {}\n\n var result = nativeObjectToString.call(value);\n if (unmasked) {\n if (isOwn) {\n value[symToStringTag] = tag;\n } else {\n delete value[symToStringTag];\n }\n }\n return result;\n}\n\nmodule.exports = getRawTag;\n","var arrayFilter = require('./_arrayFilter'),\n stubArray = require('./stubArray');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n if (object == null) {\n return [];\n }\n object = Object(object);\n return arrayFilter(nativeGetSymbols(object), function(symbol) {\n return propertyIsEnumerable.call(object, symbol);\n });\n};\n\nmodule.exports = getSymbols;\n","var arrayPush = require('./_arrayPush'),\n getPrototype = require('./_getPrototype'),\n getSymbols = require('./_getSymbols'),\n stubArray = require('./stubArray');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own and inherited enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n var result = [];\n while (object) {\n arrayPush(result, getSymbols(object));\n object = getPrototype(object);\n }\n return result;\n};\n\nmodule.exports = getSymbolsIn;\n","var DataView = require('./_DataView'),\n Map = require('./_Map'),\n Promise = require('./_Promise'),\n Set = require('./_Set'),\n WeakMap = require('./_WeakMap'),\n baseGetTag = require('./_baseGetTag'),\n toSource = require('./_toSource');\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]',\n objectTag = '[object Object]',\n promiseTag = '[object Promise]',\n setTag = '[object Set]',\n weakMapTag = '[object WeakMap]';\n\nvar dataViewTag = '[object DataView]';\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n mapCtorString = toSource(Map),\n promiseCtorString = toSource(Promise),\n setCtorString = toSource(Set),\n weakMapCtorString = toSource(WeakMap);\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n (Map && getTag(new Map) != mapTag) ||\n (Promise && getTag(Promise.resolve()) != promiseTag) ||\n (Set && getTag(new Set) != setTag) ||\n (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n getTag = function(value) {\n var result = baseGetTag(value),\n Ctor = result == objectTag ? value.constructor : undefined,\n ctorString = Ctor ? toSource(Ctor) : '';\n\n if (ctorString) {\n switch (ctorString) {\n case dataViewCtorString: return dataViewTag;\n case mapCtorString: return mapTag;\n case promiseCtorString: return promiseTag;\n case setCtorString: return setTag;\n case weakMapCtorString: return weakMapTag;\n }\n }\n return result;\n };\n}\n\nmodule.exports = getTag;\n","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n return object == null ? undefined : object[key];\n}\n\nmodule.exports = getValue;\n","var castPath = require('./_castPath'),\n isArguments = require('./isArguments'),\n isArray = require('./isArray'),\n isIndex = require('./_isIndex'),\n isLength = require('./isLength'),\n toKey = require('./_toKey');\n\n/**\n * Checks if `path` exists on `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @param {Function} hasFunc The function to check properties.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n */\nfunction hasPath(object, path, hasFunc) {\n path = castPath(path, object);\n\n var index = -1,\n length = path.length,\n result = false;\n\n while (++index < length) {\n var key = toKey(path[index]);\n if (!(result = object != null && hasFunc(object, key))) {\n break;\n }\n object = object[key];\n }\n if (result || ++index != length) {\n return result;\n }\n length = object == null ? 0 : object.length;\n return !!length && isLength(length) && isIndex(key, length) &&\n (isArray(object) || isArguments(object));\n}\n\nmodule.exports = hasPath;\n","var nativeCreate = require('./_nativeCreate');\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n this.__data__ = nativeCreate ? nativeCreate(null) : {};\n this.size = 0;\n}\n\nmodule.exports = hashClear;\n","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n var result = this.has(key) && delete this.__data__[key];\n this.size -= result ? 1 : 0;\n return result;\n}\n\nmodule.exports = hashDelete;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n var data = this.__data__;\n if (nativeCreate) {\n var result = data[key];\n return result === HASH_UNDEFINED ? undefined : result;\n }\n return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nmodule.exports = hashGet;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n var data = this.__data__;\n return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nmodule.exports = hashHas;\n","var nativeCreate = require('./_nativeCreate');\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n var data = this.__data__;\n this.size += this.has(key) ? 0 : 1;\n data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n return this;\n}\n\nmodule.exports = hashSet;\n","var Symbol = require('./_Symbol'),\n isArguments = require('./isArguments'),\n isArray = require('./isArray');\n\n/** Built-in value references. */\nvar spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined;\n\n/**\n * Checks if `value` is a flattenable `arguments` object or array.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n */\nfunction isFlattenable(value) {\n return isArray(value) || isArguments(value) ||\n !!(spreadableSymbol && value && value[spreadableSymbol]);\n}\n\nmodule.exports = isFlattenable;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n var type = typeof value;\n length = length == null ? MAX_SAFE_INTEGER : length;\n\n return !!length &&\n (type == 'number' ||\n (type != 'symbol' && reIsUint.test(value))) &&\n (value > -1 && value % 1 == 0 && value < length);\n}\n\nmodule.exports = isIndex;\n","var isArray = require('./isArray'),\n isSymbol = require('./isSymbol');\n\n/** Used to match property names within property paths. */\nvar reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n reIsPlainProp = /^\\w*$/;\n\n/**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\nfunction isKey(value, object) {\n if (isArray(value)) {\n return false;\n }\n var type = typeof value;\n if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n value == null || isSymbol(value)) {\n return true;\n }\n return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n (object != null && value in Object(object));\n}\n\nmodule.exports = isKey;\n","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n var type = typeof value;\n return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n ? (value !== '__proto__')\n : (value === null);\n}\n\nmodule.exports = isKeyable;\n","var coreJsData = require('./_coreJsData');\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n}\n\nmodule.exports = isMasked;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n return value === proto;\n}\n\nmodule.exports = isPrototype;\n","var isObject = require('./isObject');\n\n/**\n * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` if suitable for strict\n * equality comparisons, else `false`.\n */\nfunction isStrictComparable(value) {\n return value === value && !isObject(value);\n}\n\nmodule.exports = isStrictComparable;\n","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n this.__data__ = [];\n this.size = 0;\n}\n\nmodule.exports = listCacheClear;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n return false;\n }\n var lastIndex = data.length - 1;\n if (index == lastIndex) {\n data.pop();\n } else {\n splice.call(data, index, 1);\n }\n --this.size;\n return true;\n}\n\nmodule.exports = listCacheDelete;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n return index < 0 ? undefined : data[index][1];\n}\n\nmodule.exports = listCacheGet;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n return assocIndexOf(this.__data__, key) > -1;\n}\n\nmodule.exports = listCacheHas;\n","var assocIndexOf = require('./_assocIndexOf');\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n ++this.size;\n data.push([key, value]);\n } else {\n data[index][1] = value;\n }\n return this;\n}\n\nmodule.exports = listCacheSet;\n","var Hash = require('./_Hash'),\n ListCache = require('./_ListCache'),\n Map = require('./_Map');\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n this.size = 0;\n this.__data__ = {\n 'hash': new Hash,\n 'map': new (Map || ListCache),\n 'string': new Hash\n };\n}\n\nmodule.exports = mapCacheClear;\n","var getMapData = require('./_getMapData');\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n var result = getMapData(this, key)['delete'](key);\n this.size -= result ? 1 : 0;\n return result;\n}\n\nmodule.exports = mapCacheDelete;\n","var getMapData = require('./_getMapData');\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n return getMapData(this, key).get(key);\n}\n\nmodule.exports = mapCacheGet;\n","var getMapData = require('./_getMapData');\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n return getMapData(this, key).has(key);\n}\n\nmodule.exports = mapCacheHas;\n","var getMapData = require('./_getMapData');\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n var data = getMapData(this, key),\n size = data.size;\n\n data.set(key, value);\n this.size += data.size == size ? 0 : 1;\n return this;\n}\n\nmodule.exports = mapCacheSet;\n","/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n var index = -1,\n result = Array(map.size);\n\n map.forEach(function(value, key) {\n result[++index] = [key, value];\n });\n return result;\n}\n\nmodule.exports = mapToArray;\n","/**\n * A specialized version of `matchesProperty` for source values suitable\n * for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\nfunction matchesStrictComparable(key, srcValue) {\n return function(object) {\n if (object == null) {\n return false;\n }\n return object[key] === srcValue &&\n (srcValue !== undefined || (key in Object(object)));\n };\n}\n\nmodule.exports = matchesStrictComparable;\n","var memoize = require('./memoize');\n\n/** Used as the maximum memoize cache size. */\nvar MAX_MEMOIZE_SIZE = 500;\n\n/**\n * A specialized version of `_.memoize` which clears the memoized function's\n * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n *\n * @private\n * @param {Function} func The function to have its output memoized.\n * @returns {Function} Returns the new memoized function.\n */\nfunction memoizeCapped(func) {\n var result = memoize(func, function(key) {\n if (cache.size === MAX_MEMOIZE_SIZE) {\n cache.clear();\n }\n return key;\n });\n\n var cache = result.cache;\n return result;\n}\n\nmodule.exports = memoizeCapped;\n","var getNative = require('./_getNative');\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nmodule.exports = nativeCreate;\n","var overArg = require('./_overArg');\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object);\n\nmodule.exports = nativeKeys;\n","/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n var result = [];\n if (object != null) {\n for (var key in Object(object)) {\n result.push(key);\n }\n }\n return result;\n}\n\nmodule.exports = nativeKeysIn;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n try {\n // Use `util.types` for Node.js 10+.\n var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n if (types) {\n return types;\n }\n\n // Legacy `process.binding('util')` for Node.js < 10.\n return freeProcess && freeProcess.binding && freeProcess.binding('util');\n } catch (e) {}\n}());\n\nmodule.exports = nodeUtil;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n return nativeObjectToString.call(value);\n}\n\nmodule.exports = objectToString;\n","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n}\n\nmodule.exports = overArg;\n","var freeGlobal = require('./_freeGlobal');\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nmodule.exports = root;\n","/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n this.__data__.set(value, HASH_UNDEFINED);\n return this;\n}\n\nmodule.exports = setCacheAdd;\n","/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n return this.__data__.has(value);\n}\n\nmodule.exports = setCacheHas;\n","/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n var index = -1,\n result = Array(set.size);\n\n set.forEach(function(value) {\n result[++index] = value;\n });\n return result;\n}\n\nmodule.exports = setToArray;\n","var ListCache = require('./_ListCache');\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n this.__data__ = new ListCache;\n this.size = 0;\n}\n\nmodule.exports = stackClear;\n","/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n var data = this.__data__,\n result = data['delete'](key);\n\n this.size = data.size;\n return result;\n}\n\nmodule.exports = stackDelete;\n","/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n return this.__data__.get(key);\n}\n\nmodule.exports = stackGet;\n","/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n return this.__data__.has(key);\n}\n\nmodule.exports = stackHas;\n","var ListCache = require('./_ListCache'),\n Map = require('./_Map'),\n MapCache = require('./_MapCache');\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n var data = this.__data__;\n if (data instanceof ListCache) {\n var pairs = data.__data__;\n if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n pairs.push([key, value]);\n this.size = ++data.size;\n return this;\n }\n data = this.__data__ = new MapCache(pairs);\n }\n data.set(key, value);\n this.size = data.size;\n return this;\n}\n\nmodule.exports = stackSet;\n","var memoizeCapped = require('./_memoizeCapped');\n\n/** Used to match property names within property paths. */\nvar rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n/** Used to match backslashes in property paths. */\nvar reEscapeChar = /\\\\(\\\\)?/g;\n\n/**\n * Converts `string` to a property path array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the property path array.\n */\nvar stringToPath = memoizeCapped(function(string) {\n var result = [];\n if (string.charCodeAt(0) === 46 /* . */) {\n result.push('');\n }\n string.replace(rePropName, function(match, number, quote, subString) {\n result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));\n });\n return result;\n});\n\nmodule.exports = stringToPath;\n","var isSymbol = require('./isSymbol');\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n if (typeof value == 'string' || isSymbol(value)) {\n return value;\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nmodule.exports = toKey;\n","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n}\n\nmodule.exports = toSource;\n","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n return value === other || (value !== value && other !== other);\n}\n\nmodule.exports = eq;\n","var baseFlatten = require('./_baseFlatten'),\n map = require('./map');\n\n/**\n * Creates a flattened array of values by running each element in `collection`\n * thru `iteratee` and flattening the mapped results. The iteratee is invoked\n * with three arguments: (value, index|key, collection).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * function duplicate(n) {\n * return [n, n];\n * }\n *\n * _.flatMap([1, 2], duplicate);\n * // => [1, 1, 2, 2]\n */\nfunction flatMap(collection, iteratee) {\n return baseFlatten(map(collection, iteratee), 1);\n}\n\nmodule.exports = flatMap;\n","var baseFlatten = require('./_baseFlatten');\n\n/**\n * Flattens `array` a single level deep.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to flatten.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * _.flatten([1, [2, [3, [4]], 5]]);\n * // => [1, 2, [3, [4]], 5]\n */\nfunction flatten(array) {\n var length = array == null ? 0 : array.length;\n return length ? baseFlatten(array, 1) : [];\n}\n\nmodule.exports = flatten;\n","var baseGet = require('./_baseGet');\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is\n * `undefined`, the `defaultValue` is returned in its place.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.get(object, 'a[0].b.c');\n * // => 3\n *\n * _.get(object, ['a', '0', 'b', 'c']);\n * // => 3\n *\n * _.get(object, 'a.b.c', 'default');\n * // => 'default'\n */\nfunction get(object, path, defaultValue) {\n var result = object == null ? undefined : baseGet(object, path);\n return result === undefined ? defaultValue : result;\n}\n\nmodule.exports = get;\n","var baseAssignValue = require('./_baseAssignValue'),\n createAggregator = require('./_createAggregator');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an object composed of keys generated from the results of running\n * each element of `collection` thru `iteratee`. The order of grouped values\n * is determined by the order they occur in `collection`. The corresponding\n * value of each key is an array of elements responsible for generating the\n * key. The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n * @returns {Object} Returns the composed aggregate object.\n * @example\n *\n * _.groupBy([6.1, 4.2, 6.3], Math.floor);\n * // => { '4': [4.2], '6': [6.1, 6.3] }\n *\n * // The `_.property` iteratee shorthand.\n * _.groupBy(['one', 'two', 'three'], 'length');\n * // => { '3': ['one', 'two'], '5': ['three'] }\n */\nvar groupBy = createAggregator(function(result, value, key) {\n if (hasOwnProperty.call(result, key)) {\n result[key].push(value);\n } else {\n baseAssignValue(result, key, [value]);\n }\n});\n\nmodule.exports = groupBy;\n","var baseHasIn = require('./_baseHasIn'),\n hasPath = require('./_hasPath');\n\n/**\n * Checks if `path` is a direct or inherited property of `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.hasIn(object, 'a');\n * // => true\n *\n * _.hasIn(object, 'a.b');\n * // => true\n *\n * _.hasIn(object, ['a', 'b']);\n * // => true\n *\n * _.hasIn(object, 'b');\n * // => false\n */\nfunction hasIn(object, path) {\n return object != null && hasPath(object, path, baseHasIn);\n}\n\nmodule.exports = hasIn;\n","/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n return value;\n}\n\nmodule.exports = identity;\n","var baseIsArguments = require('./_baseIsArguments'),\n isObjectLike = require('./isObjectLike');\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n !propertyIsEnumerable.call(value, 'callee');\n};\n\nmodule.exports = isArguments;\n","/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nmodule.exports = isArray;\n","var isFunction = require('./isFunction'),\n isLength = require('./isLength');\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n}\n\nmodule.exports = isArrayLike;\n","var root = require('./_root'),\n stubFalse = require('./stubFalse');\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\nmodule.exports = isBuffer;\n","var baseIsEqual = require('./_baseIsEqual');\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n return baseIsEqual(value, other);\n}\n\nmodule.exports = isEqual;\n","var baseGetTag = require('./_baseGetTag'),\n isObject = require('./isObject');\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n if (!isObject(value)) {\n return false;\n }\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 9 which returns 'object' for typed arrays and other constructors.\n var tag = baseGetTag(value);\n return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nmodule.exports = isFunction;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nmodule.exports = isLength;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return value != null && (type == 'object' || type == 'function');\n}\n\nmodule.exports = isObject;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return value != null && typeof value == 'object';\n}\n\nmodule.exports = isObjectLike;\n","var baseGetTag = require('./_baseGetTag'),\n isObjectLike = require('./isObjectLike');\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n return typeof value == 'symbol' ||\n (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nmodule.exports = isSymbol;\n","var baseIsTypedArray = require('./_baseIsTypedArray'),\n baseUnary = require('./_baseUnary'),\n nodeUtil = require('./_nodeUtil');\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\nmodule.exports = isTypedArray;\n","var arrayLikeKeys = require('./_arrayLikeKeys'),\n baseKeys = require('./_baseKeys'),\n isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\nmodule.exports = keys;\n","var arrayLikeKeys = require('./_arrayLikeKeys'),\n baseKeysIn = require('./_baseKeysIn'),\n isArrayLike = require('./isArrayLike');\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\nmodule.exports = keysIn;\n","/**\n * @license\n * Lodash <https://lodash.com/>\n * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>\n * Released under MIT license <https://lodash.com/license>\n * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>\n * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n */\n;(function() {\n\n /** Used as a safe reference for `undefined` in pre-ES5 environments. */\n var undefined;\n\n /** Used as the semantic version number. */\n var VERSION = '4.17.21';\n\n /** Used as the size to enable large array optimizations. */\n var LARGE_ARRAY_SIZE = 200;\n\n /** Error message constants. */\n var CORE_ERROR_TEXT = 'Unsupported core-js use. Try https://npms.io/search?q=ponyfill.',\n FUNC_ERROR_TEXT = 'Expected a function',\n INVALID_TEMPL_VAR_ERROR_TEXT = 'Invalid `variable` option passed into `_.template`';\n\n /** Used to stand-in for `undefined` hash values. */\n var HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n /** Used as the maximum memoize cache size. */\n var MAX_MEMOIZE_SIZE = 500;\n\n /** Used as the internal argument placeholder. */\n var PLACEHOLDER = '__lodash_placeholder__';\n\n /** Used to compose bitmasks for cloning. */\n var CLONE_DEEP_FLAG = 1,\n CLONE_FLAT_FLAG = 2,\n CLONE_SYMBOLS_FLAG = 4;\n\n /** Used to compose bitmasks for value comparisons. */\n var COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n /** Used to compose bitmasks for function metadata. */\n var WRAP_BIND_FLAG = 1,\n WRAP_BIND_KEY_FLAG = 2,\n WRAP_CURRY_BOUND_FLAG = 4,\n WRAP_CURRY_FLAG = 8,\n WRAP_CURRY_RIGHT_FLAG = 16,\n WRAP_PARTIAL_FLAG = 32,\n WRAP_PARTIAL_RIGHT_FLAG = 64,\n WRAP_ARY_FLAG = 128,\n WRAP_REARG_FLAG = 256,\n WRAP_FLIP_FLAG = 512;\n\n /** Used as default options for `_.truncate`. */\n var DEFAULT_TRUNC_LENGTH = 30,\n DEFAULT_TRUNC_OMISSION = '...';\n\n /** Used to detect hot functions by number of calls within a span of milliseconds. */\n var HOT_COUNT = 800,\n HOT_SPAN = 16;\n\n /** Used to indicate the type of lazy iteratees. */\n var LAZY_FILTER_FLAG = 1,\n LAZY_MAP_FLAG = 2,\n LAZY_WHILE_FLAG = 3;\n\n /** Used as references for various `Number` constants. */\n var INFINITY = 1 / 0,\n MAX_SAFE_INTEGER = 9007199254740991,\n MAX_INTEGER = 1.7976931348623157e+308,\n NAN = 0 / 0;\n\n /** Used as references for the maximum length and index of an array. */\n var MAX_ARRAY_LENGTH = 4294967295,\n MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH - 1,\n HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH >>> 1;\n\n /** Used to associate wrap methods with their bit flags. */\n var wrapFlags = [\n ['ary', WRAP_ARY_FLAG],\n ['bind', WRAP_BIND_FLAG],\n ['bindKey', WRAP_BIND_KEY_FLAG],\n ['curry', WRAP_CURRY_FLAG],\n ['curryRight', WRAP_CURRY_RIGHT_FLAG],\n ['flip', WRAP_FLIP_FLAG],\n ['partial', WRAP_PARTIAL_FLAG],\n ['partialRight', WRAP_PARTIAL_RIGHT_FLAG],\n ['rearg', WRAP_REARG_FLAG]\n ];\n\n /** `Object#toString` result references. */\n var argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n asyncTag = '[object AsyncFunction]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n domExcTag = '[object DOMException]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n nullTag = '[object Null]',\n objectTag = '[object Object]',\n promiseTag = '[object Promise]',\n proxyTag = '[object Proxy]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n symbolTag = '[object Symbol]',\n undefinedTag = '[object Undefined]',\n weakMapTag = '[object WeakMap]',\n weakSetTag = '[object WeakSet]';\n\n var arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n /** Used to match empty string literals in compiled template source. */\n var reEmptyStringLeading = /\\b__p \\+= '';/g,\n reEmptyStringMiddle = /\\b(__p \\+=) '' \\+/g,\n reEmptyStringTrailing = /(__e\\(.*?\\)|\\b__t\\)) \\+\\n'';/g;\n\n /** Used to match HTML entities and HTML characters. */\n var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g,\n reUnescapedHtml = /[&<>\"']/g,\n reHasEscapedHtml = RegExp(reEscapedHtml.source),\n reHasUnescapedHtml = RegExp(reUnescapedHtml.source);\n\n /** Used to match template delimiters. */\n var reEscape = /<%-([\\s\\S]+?)%>/g,\n reEvaluate = /<%([\\s\\S]+?)%>/g,\n reInterpolate = /<%=([\\s\\S]+?)%>/g;\n\n /** Used to match property names within property paths. */\n var reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n reIsPlainProp = /^\\w*$/,\n rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n /**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\n var reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g,\n reHasRegExpChar = RegExp(reRegExpChar.source);\n\n /** Used to match leading whitespace. */\n var reTrimStart = /^\\s+/;\n\n /** Used to match a single whitespace character. */\n var reWhitespace = /\\s/;\n\n /** Used to match wrap detail comments. */\n var reWrapComment = /\\{(?:\\n\\/\\* \\[wrapped with .+\\] \\*\\/)?\\n?/,\n reWrapDetails = /\\{\\n\\/\\* \\[wrapped with (.+)\\] \\*/,\n reSplitDetails = /,? & /;\n\n /** Used to match words composed of alphanumeric characters. */\n var reAsciiWord = /[^\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\x7f]+/g;\n\n /**\n * Used to validate the `validate` option in `_.template` variable.\n *\n * Forbids characters which could potentially change the meaning of the function argument definition:\n * - \"(),\" (modification of function parameters)\n * - \"=\" (default value)\n * - \"[]{}\" (destructuring of function parameters)\n * - \"/\" (beginning of a comment)\n * - whitespace\n */\n var reForbiddenIdentifierChars = /[()=,{}\\[\\]\\/\\s]/;\n\n /** Used to match backslashes in property paths. */\n var reEscapeChar = /\\\\(\\\\)?/g;\n\n /**\n * Used to match\n * [ES template delimiters](http://ecma-international.org/ecma-262/7.0/#sec-template-literal-lexical-components).\n */\n var reEsTemplate = /\\$\\{([^\\\\}]*(?:\\\\.[^\\\\}]*)*)\\}/g;\n\n /** Used to match `RegExp` flags from their coerced string values. */\n var reFlags = /\\w*$/;\n\n /** Used to detect bad signed hexadecimal string values. */\n var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;\n\n /** Used to detect binary string values. */\n var reIsBinary = /^0b[01]+$/i;\n\n /** Used to detect host constructors (Safari). */\n var reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n /** Used to detect octal string values. */\n var reIsOctal = /^0o[0-7]+$/i;\n\n /** Used to detect unsigned integer values. */\n var reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n /** Used to match Latin Unicode letters (excluding mathematical operators). */\n var reLatin = /[\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\xff\\u0100-\\u017f]/g;\n\n /** Used to ensure capturing order of template delimiters. */\n var reNoMatch = /($^)/;\n\n /** Used to match unescaped characters in compiled string literals. */\n var reUnescapedString = /['\\n\\r\\u2028\\u2029\\\\]/g;\n\n /** Used to compose unicode character classes. */\n var rsAstralRange = '\\\\ud800-\\\\udfff',\n rsComboMarksRange = '\\\\u0300-\\\\u036f',\n reComboHalfMarksRange = '\\\\ufe20-\\\\ufe2f',\n rsComboSymbolsRange = '\\\\u20d0-\\\\u20ff',\n rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange,\n rsDingbatRange = '\\\\u2700-\\\\u27bf',\n rsLowerRange = 'a-z\\\\xdf-\\\\xf6\\\\xf8-\\\\xff',\n rsMathOpRange = '\\\\xac\\\\xb1\\\\xd7\\\\xf7',\n rsNonCharRange = '\\\\x00-\\\\x2f\\\\x3a-\\\\x40\\\\x5b-\\\\x60\\\\x7b-\\\\xbf',\n rsPunctuationRange = '\\\\u2000-\\\\u206f',\n rsSpaceRange = ' \\\\t\\\\x0b\\\\f\\\\xa0\\\\ufeff\\\\n\\\\r\\\\u2028\\\\u2029\\\\u1680\\\\u180e\\\\u2000\\\\u2001\\\\u2002\\\\u2003\\\\u2004\\\\u2005\\\\u2006\\\\u2007\\\\u2008\\\\u2009\\\\u200a\\\\u202f\\\\u205f\\\\u3000',\n rsUpperRange = 'A-Z\\\\xc0-\\\\xd6\\\\xd8-\\\\xde',\n rsVarRange = '\\\\ufe0e\\\\ufe0f',\n rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;\n\n /** Used to compose unicode capture groups. */\n var rsApos = \"['\\u2019]\",\n rsAstral = '[' + rsAstralRange + ']',\n rsBreak = '[' + rsBreakRange + ']',\n rsCombo = '[' + rsComboRange + ']',\n rsDigits = '\\\\d+',\n rsDingbat = '[' + rsDingbatRange + ']',\n rsLower = '[' + rsLowerRange + ']',\n rsMisc = '[^' + rsAstralRange + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + ']',\n rsFitz = '\\\\ud83c[\\\\udffb-\\\\udfff]',\n rsModifier = '(?:' + rsCombo + '|' + rsFitz + ')',\n rsNonAstral = '[^' + rsAstralRange + ']',\n rsRegional = '(?:\\\\ud83c[\\\\udde6-\\\\uddff]){2}',\n rsSurrPair = '[\\\\ud800-\\\\udbff][\\\\udc00-\\\\udfff]',\n rsUpper = '[' + rsUpperRange + ']',\n rsZWJ = '\\\\u200d';\n\n /** Used to compose unicode regexes. */\n var rsMiscLower = '(?:' + rsLower + '|' + rsMisc + ')',\n rsMiscUpper = '(?:' + rsUpper + '|' + rsMisc + ')',\n rsOptContrLower = '(?:' + rsApos + '(?:d|ll|m|re|s|t|ve))?',\n rsOptContrUpper = '(?:' + rsApos + '(?:D|LL|M|RE|S|T|VE))?',\n reOptMod = rsModifier + '?',\n rsOptVar = '[' + rsVarRange + ']?',\n rsOptJoin = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVar + reOptMod + ')*',\n rsOrdLower = '\\\\d*(?:1st|2nd|3rd|(?![123])\\\\dth)(?=\\\\b|[A-Z_])',\n rsOrdUpper = '\\\\d*(?:1ST|2ND|3RD|(?![123])\\\\dTH)(?=\\\\b|[a-z_])',\n rsSeq = rsOptVar + reOptMod + rsOptJoin,\n rsEmoji = '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,\n rsSymbol = '(?:' + [rsNonAstral + rsCombo + '?', rsCombo, rsRegional, rsSurrPair, rsAstral].join('|') + ')';\n\n /** Used to match apostrophes. */\n var reApos = RegExp(rsApos, 'g');\n\n /**\n * Used to match [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks) and\n * [combining diacritical marks for symbols](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks_for_Symbols).\n */\n var reComboMark = RegExp(rsCombo, 'g');\n\n /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */\n var reUnicode = RegExp(rsFitz + '(?=' + rsFitz + ')|' + rsSymbol + rsSeq, 'g');\n\n /** Used to match complex or compound words. */\n var reUnicodeWord = RegExp([\n rsUpper + '?' + rsLower + '+' + rsOptContrLower + '(?=' + [rsBreak, rsUpper, '$'].join('|') + ')',\n rsMiscUpper + '+' + rsOptContrUpper + '(?=' + [rsBreak, rsUpper + rsMiscLower, '$'].join('|') + ')',\n rsUpper + '?' + rsMiscLower + '+' + rsOptContrLower,\n rsUpper + '+' + rsOptContrUpper,\n rsOrdUpper,\n rsOrdLower,\n rsDigits,\n rsEmoji\n ].join('|'), 'g');\n\n /** Used to detect strings with [zero-width joiners or code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */\n var reHasUnicode = RegExp('[' + rsZWJ + rsAstralRange + rsComboRange + rsVarRange + ']');\n\n /** Used to detect strings that need a more robust regexp to match words. */\n var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;\n\n /** Used to assign default `context` object properties. */\n var contextProps = [\n 'Array', 'Buffer', 'DataView', 'Date', 'Error', 'Float32Array', 'Float64Array',\n 'Function', 'Int8Array', 'Int16Array', 'Int32Array', 'Map', 'Math', 'Object',\n 'Promise', 'RegExp', 'Set', 'String', 'Symbol', 'TypeError', 'Uint8Array',\n 'Uint8ClampedArray', 'Uint16Array', 'Uint32Array', 'WeakMap',\n '_', 'clearTimeout', 'isFinite', 'parseInt', 'setTimeout'\n ];\n\n /** Used to make template sourceURLs easier to identify. */\n var templateCounter = -1;\n\n /** Used to identify `toStringTag` values of typed arrays. */\n var typedArrayTags = {};\n typedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\n typedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\n typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\n typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\n typedArrayTags[uint32Tag] = true;\n typedArrayTags[argsTag] = typedArrayTags[arrayTag] =\n typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\n typedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\n typedArrayTags[errorTag] = typedArrayTags[funcTag] =\n typedArrayTags[mapTag] = typedArrayTags[numberTag] =\n typedArrayTags[objectTag] = typedArrayTags[regexpTag] =\n typedArrayTags[setTag] = typedArrayTags[stringTag] =\n typedArrayTags[weakMapTag] = false;\n\n /** Used to identify `toStringTag` values supported by `_.clone`. */\n var cloneableTags = {};\n cloneableTags[argsTag] = cloneableTags[arrayTag] =\n cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =\n cloneableTags[boolTag] = cloneableTags[dateTag] =\n cloneableTags[float32Tag] = cloneableTags[float64Tag] =\n cloneableTags[int8Tag] = cloneableTags[int16Tag] =\n cloneableTags[int32Tag] = cloneableTags[mapTag] =\n cloneableTags[numberTag] = cloneableTags[objectTag] =\n cloneableTags[regexpTag] = cloneableTags[setTag] =\n cloneableTags[stringTag] = cloneableTags[symbolTag] =\n cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =\n cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;\n cloneableTags[errorTag] = cloneableTags[funcTag] =\n cloneableTags[weakMapTag] = false;\n\n /** Used to map Latin Unicode letters to basic Latin letters. */\n var deburredLetters = {\n // Latin-1 Supplement block.\n '\\xc0': 'A', '\\xc1': 'A', '\\xc2': 'A', '\\xc3': 'A', '\\xc4': 'A', '\\xc5': 'A',\n '\\xe0': 'a', '\\xe1': 'a', '\\xe2': 'a', '\\xe3': 'a', '\\xe4': 'a', '\\xe5': 'a',\n '\\xc7': 'C', '\\xe7': 'c',\n '\\xd0': 'D', '\\xf0': 'd',\n '\\xc8': 'E', '\\xc9': 'E', '\\xca': 'E', '\\xcb': 'E',\n '\\xe8': 'e', '\\xe9': 'e', '\\xea': 'e', '\\xeb': 'e',\n '\\xcc': 'I', '\\xcd': 'I', '\\xce': 'I', '\\xcf': 'I',\n '\\xec': 'i', '\\xed': 'i', '\\xee': 'i', '\\xef': 'i',\n '\\xd1': 'N', '\\xf1': 'n',\n '\\xd2': 'O', '\\xd3': 'O', '\\xd4': 'O', '\\xd5': 'O', '\\xd6': 'O', '\\xd8': 'O',\n '\\xf2': 'o', '\\xf3': 'o', '\\xf4': 'o', '\\xf5': 'o', '\\xf6': 'o', '\\xf8': 'o',\n '\\xd9': 'U', '\\xda': 'U', '\\xdb': 'U', '\\xdc': 'U',\n '\\xf9': 'u', '\\xfa': 'u', '\\xfb': 'u', '\\xfc': 'u',\n '\\xdd': 'Y', '\\xfd': 'y', '\\xff': 'y',\n '\\xc6': 'Ae', '\\xe6': 'ae',\n '\\xde': 'Th', '\\xfe': 'th',\n '\\xdf': 'ss',\n // Latin Extended-A block.\n '\\u0100': 'A', '\\u0102': 'A', '\\u0104': 'A',\n '\\u0101': 'a', '\\u0103': 'a', '\\u0105': 'a',\n '\\u0106': 'C', '\\u0108': 'C', '\\u010a': 'C', '\\u010c': 'C',\n '\\u0107': 'c', '\\u0109': 'c', '\\u010b': 'c', '\\u010d': 'c',\n '\\u010e': 'D', '\\u0110': 'D', '\\u010f': 'd', '\\u0111': 'd',\n '\\u0112': 'E', '\\u0114': 'E', '\\u0116': 'E', '\\u0118': 'E', '\\u011a': 'E',\n '\\u0113': 'e', '\\u0115': 'e', '\\u0117': 'e', '\\u0119': 'e', '\\u011b': 'e',\n '\\u011c': 'G', '\\u011e': 'G', '\\u0120': 'G', '\\u0122': 'G',\n '\\u011d': 'g', '\\u011f': 'g', '\\u0121': 'g', '\\u0123': 'g',\n '\\u0124': 'H', '\\u0126': 'H', '\\u0125': 'h', '\\u0127': 'h',\n '\\u0128': 'I', '\\u012a': 'I', '\\u012c': 'I', '\\u012e': 'I', '\\u0130': 'I',\n '\\u0129': 'i', '\\u012b': 'i', '\\u012d': 'i', '\\u012f': 'i', '\\u0131': 'i',\n '\\u0134': 'J', '\\u0135': 'j',\n '\\u0136': 'K', '\\u0137': 'k', '\\u0138': 'k',\n '\\u0139': 'L', '\\u013b': 'L', '\\u013d': 'L', '\\u013f': 'L', '\\u0141': 'L',\n '\\u013a': 'l', '\\u013c': 'l', '\\u013e': 'l', '\\u0140': 'l', '\\u0142': 'l',\n '\\u0143': 'N', '\\u0145': 'N', '\\u0147': 'N', '\\u014a': 'N',\n '\\u0144': 'n', '\\u0146': 'n', '\\u0148': 'n', '\\u014b': 'n',\n '\\u014c': 'O', '\\u014e': 'O', '\\u0150': 'O',\n '\\u014d': 'o', '\\u014f': 'o', '\\u0151': 'o',\n '\\u0154': 'R', '\\u0156': 'R', '\\u0158': 'R',\n '\\u0155': 'r', '\\u0157': 'r', '\\u0159': 'r',\n '\\u015a': 'S', '\\u015c': 'S', '\\u015e': 'S', '\\u0160': 'S',\n '\\u015b': 's', '\\u015d': 's', '\\u015f': 's', '\\u0161': 's',\n '\\u0162': 'T', '\\u0164': 'T', '\\u0166': 'T',\n '\\u0163': 't', '\\u0165': 't', '\\u0167': 't',\n '\\u0168': 'U', '\\u016a': 'U', '\\u016c': 'U', '\\u016e': 'U', '\\u0170': 'U', '\\u0172': 'U',\n '\\u0169': 'u', '\\u016b': 'u', '\\u016d': 'u', '\\u016f': 'u', '\\u0171': 'u', '\\u0173': 'u',\n '\\u0174': 'W', '\\u0175': 'w',\n '\\u0176': 'Y', '\\u0177': 'y', '\\u0178': 'Y',\n '\\u0179': 'Z', '\\u017b': 'Z', '\\u017d': 'Z',\n '\\u017a': 'z', '\\u017c': 'z', '\\u017e': 'z',\n '\\u0132': 'IJ', '\\u0133': 'ij',\n '\\u0152': 'Oe', '\\u0153': 'oe',\n '\\u0149': \"'n\", '\\u017f': 's'\n };\n\n /** Used to map characters to HTML entities. */\n var htmlEscapes = {\n '&': '&',\n '<': '<',\n '>': '>',\n '\"': '"',\n \"'\": '''\n };\n\n /** Used to map HTML entities to characters. */\n var htmlUnescapes = {\n '&': '&',\n '<': '<',\n '>': '>',\n '"': '\"',\n ''': \"'\"\n };\n\n /** Used to escape characters for inclusion in compiled string literals. */\n var stringEscapes = {\n '\\\\': '\\\\',\n \"'\": \"'\",\n '\\n': 'n',\n '\\r': 'r',\n '\\u2028': 'u2028',\n '\\u2029': 'u2029'\n };\n\n /** Built-in method references without a dependency on `root`. */\n var freeParseFloat = parseFloat,\n freeParseInt = parseInt;\n\n /** Detect free variable `global` from Node.js. */\n var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\n /** Detect free variable `self`. */\n var freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n /** Used as a reference to the global object. */\n var root = freeGlobal || freeSelf || Function('return this')();\n\n /** Detect free variable `exports`. */\n var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n /** Detect free variable `module`. */\n var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n /** Detect the popular CommonJS extension `module.exports`. */\n var moduleExports = freeModule && freeModule.exports === freeExports;\n\n /** Detect free variable `process` from Node.js. */\n var freeProcess = moduleExports && freeGlobal.process;\n\n /** Used to access faster Node.js helpers. */\n var nodeUtil = (function() {\n try {\n // Use `util.types` for Node.js 10+.\n var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n if (types) {\n return types;\n }\n\n // Legacy `process.binding('util')` for Node.js < 10.\n return freeProcess && freeProcess.binding && freeProcess.binding('util');\n } catch (e) {}\n }());\n\n /* Node.js helper references. */\n var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer,\n nodeIsDate = nodeUtil && nodeUtil.isDate,\n nodeIsMap = nodeUtil && nodeUtil.isMap,\n nodeIsRegExp = nodeUtil && nodeUtil.isRegExp,\n nodeIsSet = nodeUtil && nodeUtil.isSet,\n nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n /*--------------------------------------------------------------------------*/\n\n /**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\n function apply(func, thisArg, args) {\n switch (args.length) {\n case 0: return func.call(thisArg);\n case 1: return func.call(thisArg, args[0]);\n case 2: return func.call(thisArg, args[0], args[1]);\n case 3: return func.call(thisArg, args[0], args[1], args[2]);\n }\n return func.apply(thisArg, args);\n }\n\n /**\n * A specialized version of `baseAggregator` for arrays.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} setter The function to set `accumulator` values.\n * @param {Function} iteratee The iteratee to transform keys.\n * @param {Object} accumulator The initial aggregated object.\n * @returns {Function} Returns `accumulator`.\n */\n function arrayAggregator(array, setter, iteratee, accumulator) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n var value = array[index];\n setter(accumulator, value, iteratee(value), array);\n }\n return accumulator;\n }\n\n /**\n * A specialized version of `_.forEach` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\n function arrayEach(array, iteratee) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (iteratee(array[index], index, array) === false) {\n break;\n }\n }\n return array;\n }\n\n /**\n * A specialized version of `_.forEachRight` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns `array`.\n */\n function arrayEachRight(array, iteratee) {\n var length = array == null ? 0 : array.length;\n\n while (length--) {\n if (iteratee(array[length], length, array) === false) {\n break;\n }\n }\n return array;\n }\n\n /**\n * A specialized version of `_.every` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if all elements pass the predicate check,\n * else `false`.\n */\n function arrayEvery(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (!predicate(array[index], index, array)) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\n function arrayFilter(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length,\n resIndex = 0,\n result = [];\n\n while (++index < length) {\n var value = array[index];\n if (predicate(value, index, array)) {\n result[resIndex++] = value;\n }\n }\n return result;\n }\n\n /**\n * A specialized version of `_.includes` for arrays without support for\n * specifying an index to search from.\n *\n * @private\n * @param {Array} [array] The array to inspect.\n * @param {*} target The value to search for.\n * @returns {boolean} Returns `true` if `target` is found, else `false`.\n */\n function arrayIncludes(array, value) {\n var length = array == null ? 0 : array.length;\n return !!length && baseIndexOf(array, value, 0) > -1;\n }\n\n /**\n * This function is like `arrayIncludes` except that it accepts a comparator.\n *\n * @private\n * @param {Array} [array] The array to inspect.\n * @param {*} target The value to search for.\n * @param {Function} comparator The comparator invoked per element.\n * @returns {boolean} Returns `true` if `target` is found, else `false`.\n */\n function arrayIncludesWith(array, value, comparator) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (comparator(value, array[index])) {\n return true;\n }\n }\n return false;\n }\n\n /**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\n function arrayMap(array, iteratee) {\n var index = -1,\n length = array == null ? 0 : array.length,\n result = Array(length);\n\n while (++index < length) {\n result[index] = iteratee(array[index], index, array);\n }\n return result;\n }\n\n /**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\n function arrayPush(array, values) {\n var index = -1,\n length = values.length,\n offset = array.length;\n\n while (++index < length) {\n array[offset + index] = values[index];\n }\n return array;\n }\n\n /**\n * A specialized version of `_.reduce` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @param {boolean} [initAccum] Specify using the first element of `array` as\n * the initial value.\n * @returns {*} Returns the accumulated value.\n */\n function arrayReduce(array, iteratee, accumulator, initAccum) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n if (initAccum && length) {\n accumulator = array[++index];\n }\n while (++index < length) {\n accumulator = iteratee(accumulator, array[index], index, array);\n }\n return accumulator;\n }\n\n /**\n * A specialized version of `_.reduceRight` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @param {boolean} [initAccum] Specify using the last element of `array` as\n * the initial value.\n * @returns {*} Returns the accumulated value.\n */\n function arrayReduceRight(array, iteratee, accumulator, initAccum) {\n var length = array == null ? 0 : array.length;\n if (initAccum && length) {\n accumulator = array[--length];\n }\n while (length--) {\n accumulator = iteratee(accumulator, array[length], length, array);\n }\n return accumulator;\n }\n\n /**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n * else `false`.\n */\n function arraySome(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (predicate(array[index], index, array)) {\n return true;\n }\n }\n return false;\n }\n\n /**\n * Gets the size of an ASCII `string`.\n *\n * @private\n * @param {string} string The string inspect.\n * @returns {number} Returns the string size.\n */\n var asciiSize = baseProperty('length');\n\n /**\n * Converts an ASCII `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\n function asciiToArray(string) {\n return string.split('');\n }\n\n /**\n * Splits an ASCII `string` into an array of its words.\n *\n * @private\n * @param {string} The string to inspect.\n * @returns {Array} Returns the words of `string`.\n */\n function asciiWords(string) {\n return string.match(reAsciiWord) || [];\n }\n\n /**\n * The base implementation of methods like `_.findKey` and `_.findLastKey`,\n * without support for iteratee shorthands, which iterates over `collection`\n * using `eachFunc`.\n *\n * @private\n * @param {Array|Object} collection The collection to inspect.\n * @param {Function} predicate The function invoked per iteration.\n * @param {Function} eachFunc The function to iterate over `collection`.\n * @returns {*} Returns the found element or its key, else `undefined`.\n */\n function baseFindKey(collection, predicate, eachFunc) {\n var result;\n eachFunc(collection, function(value, key, collection) {\n if (predicate(value, key, collection)) {\n result = key;\n return false;\n }\n });\n return result;\n }\n\n /**\n * The base implementation of `_.findIndex` and `_.findLastIndex` without\n * support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} predicate The function invoked per iteration.\n * @param {number} fromIndex The index to search from.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n function baseFindIndex(array, predicate, fromIndex, fromRight) {\n var length = array.length,\n index = fromIndex + (fromRight ? 1 : -1);\n\n while ((fromRight ? index-- : ++index < length)) {\n if (predicate(array[index], index, array)) {\n return index;\n }\n }\n return -1;\n }\n\n /**\n * The base implementation of `_.indexOf` without `fromIndex` bounds checks.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n function baseIndexOf(array, value, fromIndex) {\n return value === value\n ? strictIndexOf(array, value, fromIndex)\n : baseFindIndex(array, baseIsNaN, fromIndex);\n }\n\n /**\n * This function is like `baseIndexOf` except that it accepts a comparator.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @param {Function} comparator The comparator invoked per element.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n function baseIndexOfWith(array, value, fromIndex, comparator) {\n var index = fromIndex - 1,\n length = array.length;\n\n while (++index < length) {\n if (comparator(array[index], value)) {\n return index;\n }\n }\n return -1;\n }\n\n /**\n * The base implementation of `_.isNaN` without support for number objects.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n */\n function baseIsNaN(value) {\n return value !== value;\n }\n\n /**\n * The base implementation of `_.mean` and `_.meanBy` without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {number} Returns the mean.\n */\n function baseMean(array, iteratee) {\n var length = array == null ? 0 : array.length;\n return length ? (baseSum(array, iteratee) / length) : NAN;\n }\n\n /**\n * The base implementation of `_.property` without support for deep paths.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\n function baseProperty(key) {\n return function(object) {\n return object == null ? undefined : object[key];\n };\n }\n\n /**\n * The base implementation of `_.propertyOf` without support for deep paths.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Function} Returns the new accessor function.\n */\n function basePropertyOf(object) {\n return function(key) {\n return object == null ? undefined : object[key];\n };\n }\n\n /**\n * The base implementation of `_.reduce` and `_.reduceRight`, without support\n * for iteratee shorthands, which iterates over `collection` using `eachFunc`.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {*} accumulator The initial value.\n * @param {boolean} initAccum Specify using the first or last element of\n * `collection` as the initial value.\n * @param {Function} eachFunc The function to iterate over `collection`.\n * @returns {*} Returns the accumulated value.\n */\n function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {\n eachFunc(collection, function(value, index, collection) {\n accumulator = initAccum\n ? (initAccum = false, value)\n : iteratee(accumulator, value, index, collection);\n });\n return accumulator;\n }\n\n /**\n * The base implementation of `_.sortBy` which uses `comparer` to define the\n * sort order of `array` and replaces criteria objects with their corresponding\n * values.\n *\n * @private\n * @param {Array} array The array to sort.\n * @param {Function} comparer The function to define sort order.\n * @returns {Array} Returns `array`.\n */\n function baseSortBy(array, comparer) {\n var length = array.length;\n\n array.sort(comparer);\n while (length--) {\n array[length] = array[length].value;\n }\n return array;\n }\n\n /**\n * The base implementation of `_.sum` and `_.sumBy` without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {number} Returns the sum.\n */\n function baseSum(array, iteratee) {\n var result,\n index = -1,\n length = array.length;\n\n while (++index < length) {\n var current = iteratee(array[index]);\n if (current !== undefined) {\n result = result === undefined ? current : (result + current);\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\n function baseTimes(n, iteratee) {\n var index = -1,\n result = Array(n);\n\n while (++index < n) {\n result[index] = iteratee(index);\n }\n return result;\n }\n\n /**\n * The base implementation of `_.toPairs` and `_.toPairsIn` which creates an array\n * of key-value pairs for `object` corresponding to the property names of `props`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array} props The property names to get values for.\n * @returns {Object} Returns the key-value pairs.\n */\n function baseToPairs(object, props) {\n return arrayMap(props, function(key) {\n return [key, object[key]];\n });\n }\n\n /**\n * The base implementation of `_.trim`.\n *\n * @private\n * @param {string} string The string to trim.\n * @returns {string} Returns the trimmed string.\n */\n function baseTrim(string) {\n return string\n ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, '')\n : string;\n }\n\n /**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\n function baseUnary(func) {\n return function(value) {\n return func(value);\n };\n }\n\n /**\n * The base implementation of `_.values` and `_.valuesIn` which creates an\n * array of `object` property values corresponding to the property names\n * of `props`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array} props The property names to get values for.\n * @returns {Object} Returns the array of property values.\n */\n function baseValues(object, props) {\n return arrayMap(props, function(key) {\n return object[key];\n });\n }\n\n /**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n function cacheHas(cache, key) {\n return cache.has(key);\n }\n\n /**\n * Used by `_.trim` and `_.trimStart` to get the index of the first string symbol\n * that is not found in the character symbols.\n *\n * @private\n * @param {Array} strSymbols The string symbols to inspect.\n * @param {Array} chrSymbols The character symbols to find.\n * @returns {number} Returns the index of the first unmatched string symbol.\n */\n function charsStartIndex(strSymbols, chrSymbols) {\n var index = -1,\n length = strSymbols.length;\n\n while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n return index;\n }\n\n /**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last string symbol\n * that is not found in the character symbols.\n *\n * @private\n * @param {Array} strSymbols The string symbols to inspect.\n * @param {Array} chrSymbols The character symbols to find.\n * @returns {number} Returns the index of the last unmatched string symbol.\n */\n function charsEndIndex(strSymbols, chrSymbols) {\n var index = strSymbols.length;\n\n while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {}\n return index;\n }\n\n /**\n * Gets the number of `placeholder` occurrences in `array`.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} placeholder The placeholder to search for.\n * @returns {number} Returns the placeholder count.\n */\n function countHolders(array, placeholder) {\n var length = array.length,\n result = 0;\n\n while (length--) {\n if (array[length] === placeholder) {\n ++result;\n }\n }\n return result;\n }\n\n /**\n * Used by `_.deburr` to convert Latin-1 Supplement and Latin Extended-A\n * letters to basic Latin letters.\n *\n * @private\n * @param {string} letter The matched letter to deburr.\n * @returns {string} Returns the deburred letter.\n */\n var deburrLetter = basePropertyOf(deburredLetters);\n\n /**\n * Used by `_.escape` to convert characters to HTML entities.\n *\n * @private\n * @param {string} chr The matched character to escape.\n * @returns {string} Returns the escaped character.\n */\n var escapeHtmlChar = basePropertyOf(htmlEscapes);\n\n /**\n * Used by `_.template` to escape characters for inclusion in compiled string literals.\n *\n * @private\n * @param {string} chr The matched character to escape.\n * @returns {string} Returns the escaped character.\n */\n function escapeStringChar(chr) {\n return '\\\\' + stringEscapes[chr];\n }\n\n /**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\n function getValue(object, key) {\n return object == null ? undefined : object[key];\n }\n\n /**\n * Checks if `string` contains Unicode symbols.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {boolean} Returns `true` if a symbol is found, else `false`.\n */\n function hasUnicode(string) {\n return reHasUnicode.test(string);\n }\n\n /**\n * Checks if `string` contains a word composed of Unicode symbols.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {boolean} Returns `true` if a word is found, else `false`.\n */\n function hasUnicodeWord(string) {\n return reHasUnicodeWord.test(string);\n }\n\n /**\n * Converts `iterator` to an array.\n *\n * @private\n * @param {Object} iterator The iterator to convert.\n * @returns {Array} Returns the converted array.\n */\n function iteratorToArray(iterator) {\n var data,\n result = [];\n\n while (!(data = iterator.next()).done) {\n result.push(data.value);\n }\n return result;\n }\n\n /**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\n function mapToArray(map) {\n var index = -1,\n result = Array(map.size);\n\n map.forEach(function(value, key) {\n result[++index] = [key, value];\n });\n return result;\n }\n\n /**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\n function overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n }\n\n /**\n * Replaces all `placeholder` elements in `array` with an internal placeholder\n * and returns an array of their indexes.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {*} placeholder The placeholder to replace.\n * @returns {Array} Returns the new array of placeholder indexes.\n */\n function replaceHolders(array, placeholder) {\n var index = -1,\n length = array.length,\n resIndex = 0,\n result = [];\n\n while (++index < length) {\n var value = array[index];\n if (value === placeholder || value === PLACEHOLDER) {\n array[index] = PLACEHOLDER;\n result[resIndex++] = index;\n }\n }\n return result;\n }\n\n /**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\n function setToArray(set) {\n var index = -1,\n result = Array(set.size);\n\n set.forEach(function(value) {\n result[++index] = value;\n });\n return result;\n }\n\n /**\n * Converts `set` to its value-value pairs.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the value-value pairs.\n */\n function setToPairs(set) {\n var index = -1,\n result = Array(set.size);\n\n set.forEach(function(value) {\n result[++index] = [value, value];\n });\n return result;\n }\n\n /**\n * A specialized version of `_.indexOf` which performs strict equality\n * comparisons of values, i.e. `===`.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n function strictIndexOf(array, value, fromIndex) {\n var index = fromIndex - 1,\n length = array.length;\n\n while (++index < length) {\n if (array[index] === value) {\n return index;\n }\n }\n return -1;\n }\n\n /**\n * A specialized version of `_.lastIndexOf` which performs strict equality\n * comparisons of values, i.e. `===`.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} fromIndex The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n function strictLastIndexOf(array, value, fromIndex) {\n var index = fromIndex + 1;\n while (index--) {\n if (array[index] === value) {\n return index;\n }\n }\n return index;\n }\n\n /**\n * Gets the number of symbols in `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the string size.\n */\n function stringSize(string) {\n return hasUnicode(string)\n ? unicodeSize(string)\n : asciiSize(string);\n }\n\n /**\n * Converts `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\n function stringToArray(string) {\n return hasUnicode(string)\n ? unicodeToArray(string)\n : asciiToArray(string);\n }\n\n /**\n * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace\n * character of `string`.\n *\n * @private\n * @param {string} string The string to inspect.\n * @returns {number} Returns the index of the last non-whitespace character.\n */\n function trimmedEndIndex(string) {\n var index = string.length;\n\n while (index-- && reWhitespace.test(string.charAt(index))) {}\n return index;\n }\n\n /**\n * Used by `_.unescape` to convert HTML entities to characters.\n *\n * @private\n * @param {string} chr The matched character to unescape.\n * @returns {string} Returns the unescaped character.\n */\n var unescapeHtmlChar = basePropertyOf(htmlUnescapes);\n\n /**\n * Gets the size of a Unicode `string`.\n *\n * @private\n * @param {string} string The string inspect.\n * @returns {number} Returns the string size.\n */\n function unicodeSize(string) {\n var result = reUnicode.lastIndex = 0;\n while (reUnicode.test(string)) {\n ++result;\n }\n return result;\n }\n\n /**\n * Converts a Unicode `string` to an array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the converted array.\n */\n function unicodeToArray(string) {\n return string.match(reUnicode) || [];\n }\n\n /**\n * Splits a Unicode `string` into an array of its words.\n *\n * @private\n * @param {string} The string to inspect.\n * @returns {Array} Returns the words of `string`.\n */\n function unicodeWords(string) {\n return string.match(reUnicodeWord) || [];\n }\n\n /*--------------------------------------------------------------------------*/\n\n /**\n * Create a new pristine `lodash` function using the `context` object.\n *\n * @static\n * @memberOf _\n * @since 1.1.0\n * @category Util\n * @param {Object} [context=root] The context object.\n * @returns {Function} Returns a new `lodash` function.\n * @example\n *\n * _.mixin({ 'foo': _.constant('foo') });\n *\n * var lodash = _.runInContext();\n * lodash.mixin({ 'bar': lodash.constant('bar') });\n *\n * _.isFunction(_.foo);\n * // => true\n * _.isFunction(_.bar);\n * // => false\n *\n * lodash.isFunction(lodash.foo);\n * // => false\n * lodash.isFunction(lodash.bar);\n * // => true\n *\n * // Create a suped-up `defer` in Node.js.\n * var defer = _.runInContext({ 'setTimeout': setImmediate }).defer;\n */\n var runInContext = (function runInContext(context) {\n context = context == null ? root : _.defaults(root.Object(), context, _.pick(root, contextProps));\n\n /** Built-in constructor references. */\n var Array = context.Array,\n Date = context.Date,\n Error = context.Error,\n Function = context.Function,\n Math = context.Math,\n Object = context.Object,\n RegExp = context.RegExp,\n String = context.String,\n TypeError = context.TypeError;\n\n /** Used for built-in method references. */\n var arrayProto = Array.prototype,\n funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n /** Used to detect overreaching core-js shims. */\n var coreJsData = context['__core-js_shared__'];\n\n /** Used to resolve the decompiled source of functions. */\n var funcToString = funcProto.toString;\n\n /** Used to check objects for own properties. */\n var hasOwnProperty = objectProto.hasOwnProperty;\n\n /** Used to generate unique IDs. */\n var idCounter = 0;\n\n /** Used to detect methods masquerading as native. */\n var maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n }());\n\n /**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\n var nativeObjectToString = objectProto.toString;\n\n /** Used to infer the `Object` constructor. */\n var objectCtorString = funcToString.call(Object);\n\n /** Used to restore the original `_` reference in `_.noConflict`. */\n var oldDash = root._;\n\n /** Used to detect if a method is native. */\n var reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n );\n\n /** Built-in value references. */\n var Buffer = moduleExports ? context.Buffer : undefined,\n Symbol = context.Symbol,\n Uint8Array = context.Uint8Array,\n allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined,\n getPrototype = overArg(Object.getPrototypeOf, Object),\n objectCreate = Object.create,\n propertyIsEnumerable = objectProto.propertyIsEnumerable,\n splice = arrayProto.splice,\n spreadableSymbol = Symbol ? Symbol.isConcatSpreadable : undefined,\n symIterator = Symbol ? Symbol.iterator : undefined,\n symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n var defineProperty = (function() {\n try {\n var func = getNative(Object, 'defineProperty');\n func({}, '', {});\n return func;\n } catch (e) {}\n }());\n\n /** Mocked built-ins. */\n var ctxClearTimeout = context.clearTimeout !== root.clearTimeout && context.clearTimeout,\n ctxNow = Date && Date.now !== root.Date.now && Date.now,\n ctxSetTimeout = context.setTimeout !== root.setTimeout && context.setTimeout;\n\n /* Built-in method references for those with the same name as other `lodash` methods. */\n var nativeCeil = Math.ceil,\n nativeFloor = Math.floor,\n nativeGetSymbols = Object.getOwnPropertySymbols,\n nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined,\n nativeIsFinite = context.isFinite,\n nativeJoin = arrayProto.join,\n nativeKeys = overArg(Object.keys, Object),\n nativeMax = Math.max,\n nativeMin = Math.min,\n nativeNow = Date.now,\n nativeParseInt = context.parseInt,\n nativeRandom = Math.random,\n nativeReverse = arrayProto.reverse;\n\n /* Built-in method references that are verified to be native. */\n var DataView = getNative(context, 'DataView'),\n Map = getNative(context, 'Map'),\n Promise = getNative(context, 'Promise'),\n Set = getNative(context, 'Set'),\n WeakMap = getNative(context, 'WeakMap'),\n nativeCreate = getNative(Object, 'create');\n\n /** Used to store function metadata. */\n var metaMap = WeakMap && new WeakMap;\n\n /** Used to lookup unminified function names. */\n var realNames = {};\n\n /** Used to detect maps, sets, and weakmaps. */\n var dataViewCtorString = toSource(DataView),\n mapCtorString = toSource(Map),\n promiseCtorString = toSource(Promise),\n setCtorString = toSource(Set),\n weakMapCtorString = toSource(WeakMap);\n\n /** Used to convert symbols to primitives and strings. */\n var symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolValueOf = symbolProto ? symbolProto.valueOf : undefined,\n symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates a `lodash` object which wraps `value` to enable implicit method\n * chain sequences. Methods that operate on and return arrays, collections,\n * and functions can be chained together. Methods that retrieve a single value\n * or may return a primitive value will automatically end the chain sequence\n * and return the unwrapped value. Otherwise, the value must be unwrapped\n * with `_#value`.\n *\n * Explicit chain sequences, which must be unwrapped with `_#value`, may be\n * enabled using `_.chain`.\n *\n * The execution of chained methods is lazy, that is, it's deferred until\n * `_#value` is implicitly or explicitly called.\n *\n * Lazy evaluation allows several methods to support shortcut fusion.\n * Shortcut fusion is an optimization to merge iteratee calls; this avoids\n * the creation of intermediate arrays and can greatly reduce the number of\n * iteratee executions. Sections of a chain sequence qualify for shortcut\n * fusion if the section is applied to an array and iteratees accept only\n * one argument. The heuristic for whether a section qualifies for shortcut\n * fusion is subject to change.\n *\n * Chaining is supported in custom builds as long as the `_#value` method is\n * directly or indirectly included in the build.\n *\n * In addition to lodash methods, wrappers have `Array` and `String` methods.\n *\n * The wrapper `Array` methods are:\n * `concat`, `join`, `pop`, `push`, `shift`, `sort`, `splice`, and `unshift`\n *\n * The wrapper `String` methods are:\n * `replace` and `split`\n *\n * The wrapper methods that support shortcut fusion are:\n * `at`, `compact`, `drop`, `dropRight`, `dropWhile`, `filter`, `find`,\n * `findLast`, `head`, `initial`, `last`, `map`, `reject`, `reverse`, `slice`,\n * `tail`, `take`, `takeRight`, `takeRightWhile`, `takeWhile`, and `toArray`\n *\n * The chainable wrapper methods are:\n * `after`, `ary`, `assign`, `assignIn`, `assignInWith`, `assignWith`, `at`,\n * `before`, `bind`, `bindAll`, `bindKey`, `castArray`, `chain`, `chunk`,\n * `commit`, `compact`, `concat`, `conforms`, `constant`, `countBy`, `create`,\n * `curry`, `debounce`, `defaults`, `defaultsDeep`, `defer`, `delay`,\n * `difference`, `differenceBy`, `differenceWith`, `drop`, `dropRight`,\n * `dropRightWhile`, `dropWhile`, `extend`, `extendWith`, `fill`, `filter`,\n * `flatMap`, `flatMapDeep`, `flatMapDepth`, `flatten`, `flattenDeep`,\n * `flattenDepth`, `flip`, `flow`, `flowRight`, `fromPairs`, `functions`,\n * `functionsIn`, `groupBy`, `initial`, `intersection`, `intersectionBy`,\n * `intersectionWith`, `invert`, `invertBy`, `invokeMap`, `iteratee`, `keyBy`,\n * `keys`, `keysIn`, `map`, `mapKeys`, `mapValues`, `matches`, `matchesProperty`,\n * `memoize`, `merge`, `mergeWith`, `method`, `methodOf`, `mixin`, `negate`,\n * `nthArg`, `omit`, `omitBy`, `once`, `orderBy`, `over`, `overArgs`,\n * `overEvery`, `overSome`, `partial`, `partialRight`, `partition`, `pick`,\n * `pickBy`, `plant`, `property`, `propertyOf`, `pull`, `pullAll`, `pullAllBy`,\n * `pullAllWith`, `pullAt`, `push`, `range`, `rangeRight`, `rearg`, `reject`,\n * `remove`, `rest`, `reverse`, `sampleSize`, `set`, `setWith`, `shuffle`,\n * `slice`, `sort`, `sortBy`, `splice`, `spread`, `tail`, `take`, `takeRight`,\n * `takeRightWhile`, `takeWhile`, `tap`, `throttle`, `thru`, `toArray`,\n * `toPairs`, `toPairsIn`, `toPath`, `toPlainObject`, `transform`, `unary`,\n * `union`, `unionBy`, `unionWith`, `uniq`, `uniqBy`, `uniqWith`, `unset`,\n * `unshift`, `unzip`, `unzipWith`, `update`, `updateWith`, `values`,\n * `valuesIn`, `without`, `wrap`, `xor`, `xorBy`, `xorWith`, `zip`,\n * `zipObject`, `zipObjectDeep`, and `zipWith`\n *\n * The wrapper methods that are **not** chainable by default are:\n * `add`, `attempt`, `camelCase`, `capitalize`, `ceil`, `clamp`, `clone`,\n * `cloneDeep`, `cloneDeepWith`, `cloneWith`, `conformsTo`, `deburr`,\n * `defaultTo`, `divide`, `each`, `eachRight`, `endsWith`, `eq`, `escape`,\n * `escapeRegExp`, `every`, `find`, `findIndex`, `findKey`, `findLast`,\n * `findLastIndex`, `findLastKey`, `first`, `floor`, `forEach`, `forEachRight`,\n * `forIn`, `forInRight`, `forOwn`, `forOwnRight`, `get`, `gt`, `gte`, `has`,\n * `hasIn`, `head`, `identity`, `includes`, `indexOf`, `inRange`, `invoke`,\n * `isArguments`, `isArray`, `isArrayBuffer`, `isArrayLike`, `isArrayLikeObject`,\n * `isBoolean`, `isBuffer`, `isDate`, `isElement`, `isEmpty`, `isEqual`,\n * `isEqualWith`, `isError`, `isFinite`, `isFunction`, `isInteger`, `isLength`,\n * `isMap`, `isMatch`, `isMatchWith`, `isNaN`, `isNative`, `isNil`, `isNull`,\n * `isNumber`, `isObject`, `isObjectLike`, `isPlainObject`, `isRegExp`,\n * `isSafeInteger`, `isSet`, `isString`, `isUndefined`, `isTypedArray`,\n * `isWeakMap`, `isWeakSet`, `join`, `kebabCase`, `last`, `lastIndexOf`,\n * `lowerCase`, `lowerFirst`, `lt`, `lte`, `max`, `maxBy`, `mean`, `meanBy`,\n * `min`, `minBy`, `multiply`, `noConflict`, `noop`, `now`, `nth`, `pad`,\n * `padEnd`, `padStart`, `parseInt`, `pop`, `random`, `reduce`, `reduceRight`,\n * `repeat`, `result`, `round`, `runInContext`, `sample`, `shift`, `size`,\n * `snakeCase`, `some`, `sortedIndex`, `sortedIndexBy`, `sortedLastIndex`,\n * `sortedLastIndexBy`, `startCase`, `startsWith`, `stubArray`, `stubFalse`,\n * `stubObject`, `stubString`, `stubTrue`, `subtract`, `sum`, `sumBy`,\n * `template`, `times`, `toFinite`, `toInteger`, `toJSON`, `toLength`,\n * `toLower`, `toNumber`, `toSafeInteger`, `toString`, `toUpper`, `trim`,\n * `trimEnd`, `trimStart`, `truncate`, `unescape`, `uniqueId`, `upperCase`,\n * `upperFirst`, `value`, and `words`\n *\n * @name _\n * @constructor\n * @category Seq\n * @param {*} value The value to wrap in a `lodash` instance.\n * @returns {Object} Returns the new `lodash` wrapper instance.\n * @example\n *\n * function square(n) {\n * return n * n;\n * }\n *\n * var wrapped = _([1, 2, 3]);\n *\n * // Returns an unwrapped value.\n * wrapped.reduce(_.add);\n * // => 6\n *\n * // Returns a wrapped value.\n * var squares = wrapped.map(square);\n *\n * _.isArray(squares);\n * // => false\n *\n * _.isArray(squares.value());\n * // => true\n */\n function lodash(value) {\n if (isObjectLike(value) && !isArray(value) && !(value instanceof LazyWrapper)) {\n if (value instanceof LodashWrapper) {\n return value;\n }\n if (hasOwnProperty.call(value, '__wrapped__')) {\n return wrapperClone(value);\n }\n }\n return new LodashWrapper(value);\n }\n\n /**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\n var baseCreate = (function() {\n function object() {}\n return function(proto) {\n if (!isObject(proto)) {\n return {};\n }\n if (objectCreate) {\n return objectCreate(proto);\n }\n object.prototype = proto;\n var result = new object;\n object.prototype = undefined;\n return result;\n };\n }());\n\n /**\n * The function whose prototype chain sequence wrappers inherit from.\n *\n * @private\n */\n function baseLodash() {\n // No operation performed.\n }\n\n /**\n * The base constructor for creating `lodash` wrapper objects.\n *\n * @private\n * @param {*} value The value to wrap.\n * @param {boolean} [chainAll] Enable explicit method chain sequences.\n */\n function LodashWrapper(value, chainAll) {\n this.__wrapped__ = value;\n this.__actions__ = [];\n this.__chain__ = !!chainAll;\n this.__index__ = 0;\n this.__values__ = undefined;\n }\n\n /**\n * By default, the template delimiters used by lodash are like those in\n * embedded Ruby (ERB) as well as ES2015 template strings. Change the\n * following template settings to use alternative delimiters.\n *\n * @static\n * @memberOf _\n * @type {Object}\n */\n lodash.templateSettings = {\n\n /**\n * Used to detect `data` property values to be HTML-escaped.\n *\n * @memberOf _.templateSettings\n * @type {RegExp}\n */\n 'escape': reEscape,\n\n /**\n * Used to detect code to be evaluated.\n *\n * @memberOf _.templateSettings\n * @type {RegExp}\n */\n 'evaluate': reEvaluate,\n\n /**\n * Used to detect `data` property values to inject.\n *\n * @memberOf _.templateSettings\n * @type {RegExp}\n */\n 'interpolate': reInterpolate,\n\n /**\n * Used to reference the data object in the template text.\n *\n * @memberOf _.templateSettings\n * @type {string}\n */\n 'variable': '',\n\n /**\n * Used to import variables into the compiled template.\n *\n * @memberOf _.templateSettings\n * @type {Object}\n */\n 'imports': {\n\n /**\n * A reference to the `lodash` function.\n *\n * @memberOf _.templateSettings.imports\n * @type {Function}\n */\n '_': lodash\n }\n };\n\n // Ensure wrappers are instances of `baseLodash`.\n lodash.prototype = baseLodash.prototype;\n lodash.prototype.constructor = lodash;\n\n LodashWrapper.prototype = baseCreate(baseLodash.prototype);\n LodashWrapper.prototype.constructor = LodashWrapper;\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.\n *\n * @private\n * @constructor\n * @param {*} value The value to wrap.\n */\n function LazyWrapper(value) {\n this.__wrapped__ = value;\n this.__actions__ = [];\n this.__dir__ = 1;\n this.__filtered__ = false;\n this.__iteratees__ = [];\n this.__takeCount__ = MAX_ARRAY_LENGTH;\n this.__views__ = [];\n }\n\n /**\n * Creates a clone of the lazy wrapper object.\n *\n * @private\n * @name clone\n * @memberOf LazyWrapper\n * @returns {Object} Returns the cloned `LazyWrapper` object.\n */\n function lazyClone() {\n var result = new LazyWrapper(this.__wrapped__);\n result.__actions__ = copyArray(this.__actions__);\n result.__dir__ = this.__dir__;\n result.__filtered__ = this.__filtered__;\n result.__iteratees__ = copyArray(this.__iteratees__);\n result.__takeCount__ = this.__takeCount__;\n result.__views__ = copyArray(this.__views__);\n return result;\n }\n\n /**\n * Reverses the direction of lazy iteration.\n *\n * @private\n * @name reverse\n * @memberOf LazyWrapper\n * @returns {Object} Returns the new reversed `LazyWrapper` object.\n */\n function lazyReverse() {\n if (this.__filtered__) {\n var result = new LazyWrapper(this);\n result.__dir__ = -1;\n result.__filtered__ = true;\n } else {\n result = this.clone();\n result.__dir__ *= -1;\n }\n return result;\n }\n\n /**\n * Extracts the unwrapped value from its lazy wrapper.\n *\n * @private\n * @name value\n * @memberOf LazyWrapper\n * @returns {*} Returns the unwrapped value.\n */\n function lazyValue() {\n var array = this.__wrapped__.value(),\n dir = this.__dir__,\n isArr = isArray(array),\n isRight = dir < 0,\n arrLength = isArr ? array.length : 0,\n view = getView(0, arrLength, this.__views__),\n start = view.start,\n end = view.end,\n length = end - start,\n index = isRight ? end : (start - 1),\n iteratees = this.__iteratees__,\n iterLength = iteratees.length,\n resIndex = 0,\n takeCount = nativeMin(length, this.__takeCount__);\n\n if (!isArr || (!isRight && arrLength == length && takeCount == length)) {\n return baseWrapperValue(array, this.__actions__);\n }\n var result = [];\n\n outer:\n while (length-- && resIndex < takeCount) {\n index += dir;\n\n var iterIndex = -1,\n value = array[index];\n\n while (++iterIndex < iterLength) {\n var data = iteratees[iterIndex],\n iteratee = data.iteratee,\n type = data.type,\n computed = iteratee(value);\n\n if (type == LAZY_MAP_FLAG) {\n value = computed;\n } else if (!computed) {\n if (type == LAZY_FILTER_FLAG) {\n continue outer;\n } else {\n break outer;\n }\n }\n }\n result[resIndex++] = value;\n }\n return result;\n }\n\n // Ensure `LazyWrapper` is an instance of `baseLodash`.\n LazyWrapper.prototype = baseCreate(baseLodash.prototype);\n LazyWrapper.prototype.constructor = LazyWrapper;\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\n function Hash(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n }\n\n /**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\n function hashClear() {\n this.__data__ = nativeCreate ? nativeCreate(null) : {};\n this.size = 0;\n }\n\n /**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\n function hashDelete(key) {\n var result = this.has(key) && delete this.__data__[key];\n this.size -= result ? 1 : 0;\n return result;\n }\n\n /**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\n function hashGet(key) {\n var data = this.__data__;\n if (nativeCreate) {\n var result = data[key];\n return result === HASH_UNDEFINED ? undefined : result;\n }\n return hasOwnProperty.call(data, key) ? data[key] : undefined;\n }\n\n /**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n function hashHas(key) {\n var data = this.__data__;\n return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n }\n\n /**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\n function hashSet(key, value) {\n var data = this.__data__;\n this.size += this.has(key) ? 0 : 1;\n data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n return this;\n }\n\n // Add methods to `Hash`.\n Hash.prototype.clear = hashClear;\n Hash.prototype['delete'] = hashDelete;\n Hash.prototype.get = hashGet;\n Hash.prototype.has = hashHas;\n Hash.prototype.set = hashSet;\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\n function ListCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n }\n\n /**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\n function listCacheClear() {\n this.__data__ = [];\n this.size = 0;\n }\n\n /**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\n function listCacheDelete(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n return false;\n }\n var lastIndex = data.length - 1;\n if (index == lastIndex) {\n data.pop();\n } else {\n splice.call(data, index, 1);\n }\n --this.size;\n return true;\n }\n\n /**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\n function listCacheGet(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n return index < 0 ? undefined : data[index][1];\n }\n\n /**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n function listCacheHas(key) {\n return assocIndexOf(this.__data__, key) > -1;\n }\n\n /**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\n function listCacheSet(key, value) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n ++this.size;\n data.push([key, value]);\n } else {\n data[index][1] = value;\n }\n return this;\n }\n\n // Add methods to `ListCache`.\n ListCache.prototype.clear = listCacheClear;\n ListCache.prototype['delete'] = listCacheDelete;\n ListCache.prototype.get = listCacheGet;\n ListCache.prototype.has = listCacheHas;\n ListCache.prototype.set = listCacheSet;\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\n function MapCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n }\n\n /**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\n function mapCacheClear() {\n this.size = 0;\n this.__data__ = {\n 'hash': new Hash,\n 'map': new (Map || ListCache),\n 'string': new Hash\n };\n }\n\n /**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\n function mapCacheDelete(key) {\n var result = getMapData(this, key)['delete'](key);\n this.size -= result ? 1 : 0;\n return result;\n }\n\n /**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\n function mapCacheGet(key) {\n return getMapData(this, key).get(key);\n }\n\n /**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n function mapCacheHas(key) {\n return getMapData(this, key).has(key);\n }\n\n /**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\n function mapCacheSet(key, value) {\n var data = getMapData(this, key),\n size = data.size;\n\n data.set(key, value);\n this.size += data.size == size ? 0 : 1;\n return this;\n }\n\n // Add methods to `MapCache`.\n MapCache.prototype.clear = mapCacheClear;\n MapCache.prototype['delete'] = mapCacheDelete;\n MapCache.prototype.get = mapCacheGet;\n MapCache.prototype.has = mapCacheHas;\n MapCache.prototype.set = mapCacheSet;\n\n /*------------------------------------------------------------------------*/\n\n /**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\n function SetCache(values) {\n var index = -1,\n length = values == null ? 0 : values.length;\n\n this.__data__ = new MapCache;\n while (++index < length) {\n this.add(values[index]);\n }\n }\n\n /**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\n function setCacheAdd(value) {\n this.__data__.set(value, HASH_UNDEFINED);\n return this;\n }\n\n /**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\n function setCacheHas(value) {\n return this.__data__.has(value);\n }\n\n // Add methods to `SetCache`.\n SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\n SetCache.prototype.has = setCacheHas;\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\n function Stack(entries) {\n var data = this.__data__ = new ListCache(entries);\n this.size = data.size;\n }\n\n /**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\n function stackClear() {\n this.__data__ = new ListCache;\n this.size = 0;\n }\n\n /**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\n function stackDelete(key) {\n var data = this.__data__,\n result = data['delete'](key);\n\n this.size = data.size;\n return result;\n }\n\n /**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\n function stackGet(key) {\n return this.__data__.get(key);\n }\n\n /**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\n function stackHas(key) {\n return this.__data__.has(key);\n }\n\n /**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\n function stackSet(key, value) {\n var data = this.__data__;\n if (data instanceof ListCache) {\n var pairs = data.__data__;\n if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n pairs.push([key, value]);\n this.size = ++data.size;\n return this;\n }\n data = this.__data__ = new MapCache(pairs);\n }\n data.set(key, value);\n this.size = data.size;\n return this;\n }\n\n // Add methods to `Stack`.\n Stack.prototype.clear = stackClear;\n Stack.prototype['delete'] = stackDelete;\n Stack.prototype.get = stackGet;\n Stack.prototype.has = stackHas;\n Stack.prototype.set = stackSet;\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\n function arrayLikeKeys(value, inherited) {\n var isArr = isArray(value),\n isArg = !isArr && isArguments(value),\n isBuff = !isArr && !isArg && isBuffer(value),\n isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n skipIndexes = isArr || isArg || isBuff || isType,\n result = skipIndexes ? baseTimes(value.length, String) : [],\n length = result.length;\n\n for (var key in value) {\n if ((inherited || hasOwnProperty.call(value, key)) &&\n !(skipIndexes && (\n // Safari 9 has enumerable `arguments.length` in strict mode.\n key == 'length' ||\n // Node.js 0.10 has enumerable non-index properties on buffers.\n (isBuff && (key == 'offset' || key == 'parent')) ||\n // PhantomJS 2 has enumerable non-index properties on typed arrays.\n (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n // Skip index properties.\n isIndex(key, length)\n ))) {\n result.push(key);\n }\n }\n return result;\n }\n\n /**\n * A specialized version of `_.sample` for arrays.\n *\n * @private\n * @param {Array} array The array to sample.\n * @returns {*} Returns the random element.\n */\n function arraySample(array) {\n var length = array.length;\n return length ? array[baseRandom(0, length - 1)] : undefined;\n }\n\n /**\n * A specialized version of `_.sampleSize` for arrays.\n *\n * @private\n * @param {Array} array The array to sample.\n * @param {number} n The number of elements to sample.\n * @returns {Array} Returns the random elements.\n */\n function arraySampleSize(array, n) {\n return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));\n }\n\n /**\n * A specialized version of `_.shuffle` for arrays.\n *\n * @private\n * @param {Array} array The array to shuffle.\n * @returns {Array} Returns the new shuffled array.\n */\n function arrayShuffle(array) {\n return shuffleSelf(copyArray(array));\n }\n\n /**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\n function assignMergeValue(object, key, value) {\n if ((value !== undefined && !eq(object[key], value)) ||\n (value === undefined && !(key in object))) {\n baseAssignValue(object, key, value);\n }\n }\n\n /**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\n function assignValue(object, key, value) {\n var objValue = object[key];\n if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n (value === undefined && !(key in object))) {\n baseAssignValue(object, key, value);\n }\n }\n\n /**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\n function assocIndexOf(array, key) {\n var length = array.length;\n while (length--) {\n if (eq(array[length][0], key)) {\n return length;\n }\n }\n return -1;\n }\n\n /**\n * Aggregates elements of `collection` on `accumulator` with keys transformed\n * by `iteratee` and values set by `setter`.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} setter The function to set `accumulator` values.\n * @param {Function} iteratee The iteratee to transform keys.\n * @param {Object} accumulator The initial aggregated object.\n * @returns {Function} Returns `accumulator`.\n */\n function baseAggregator(collection, setter, iteratee, accumulator) {\n baseEach(collection, function(value, key, collection) {\n setter(accumulator, value, iteratee(value), collection);\n });\n return accumulator;\n }\n\n /**\n * The base implementation of `_.assign` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\n function baseAssign(object, source) {\n return object && copyObject(source, keys(source), object);\n }\n\n /**\n * The base implementation of `_.assignIn` without support for multiple sources\n * or `customizer` functions.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @returns {Object} Returns `object`.\n */\n function baseAssignIn(object, source) {\n return object && copyObject(source, keysIn(source), object);\n }\n\n /**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\n function baseAssignValue(object, key, value) {\n if (key == '__proto__' && defineProperty) {\n defineProperty(object, key, {\n 'configurable': true,\n 'enumerable': true,\n 'value': value,\n 'writable': true\n });\n } else {\n object[key] = value;\n }\n }\n\n /**\n * The base implementation of `_.at` without support for individual paths.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {string[]} paths The property paths to pick.\n * @returns {Array} Returns the picked elements.\n */\n function baseAt(object, paths) {\n var index = -1,\n length = paths.length,\n result = Array(length),\n skip = object == null;\n\n while (++index < length) {\n result[index] = skip ? undefined : get(object, paths[index]);\n }\n return result;\n }\n\n /**\n * The base implementation of `_.clamp` which doesn't coerce arguments.\n *\n * @private\n * @param {number} number The number to clamp.\n * @param {number} [lower] The lower bound.\n * @param {number} upper The upper bound.\n * @returns {number} Returns the clamped number.\n */\n function baseClamp(number, lower, upper) {\n if (number === number) {\n if (upper !== undefined) {\n number = number <= upper ? number : upper;\n }\n if (lower !== undefined) {\n number = number >= lower ? number : lower;\n }\n }\n return number;\n }\n\n /**\n * The base implementation of `_.clone` and `_.cloneDeep` which tracks\n * traversed objects.\n *\n * @private\n * @param {*} value The value to clone.\n * @param {boolean} bitmask The bitmask flags.\n * 1 - Deep clone\n * 2 - Flatten inherited properties\n * 4 - Clone symbols\n * @param {Function} [customizer] The function to customize cloning.\n * @param {string} [key] The key of `value`.\n * @param {Object} [object] The parent object of `value`.\n * @param {Object} [stack] Tracks traversed objects and their clone counterparts.\n * @returns {*} Returns the cloned value.\n */\n function baseClone(value, bitmask, customizer, key, object, stack) {\n var result,\n isDeep = bitmask & CLONE_DEEP_FLAG,\n isFlat = bitmask & CLONE_FLAT_FLAG,\n isFull = bitmask & CLONE_SYMBOLS_FLAG;\n\n if (customizer) {\n result = object ? customizer(value, key, object, stack) : customizer(value);\n }\n if (result !== undefined) {\n return result;\n }\n if (!isObject(value)) {\n return value;\n }\n var isArr = isArray(value);\n if (isArr) {\n result = initCloneArray(value);\n if (!isDeep) {\n return copyArray(value, result);\n }\n } else {\n var tag = getTag(value),\n isFunc = tag == funcTag || tag == genTag;\n\n if (isBuffer(value)) {\n return cloneBuffer(value, isDeep);\n }\n if (tag == objectTag || tag == argsTag || (isFunc && !object)) {\n result = (isFlat || isFunc) ? {} : initCloneObject(value);\n if (!isDeep) {\n return isFlat\n ? copySymbolsIn(value, baseAssignIn(result, value))\n : copySymbols(value, baseAssign(result, value));\n }\n } else {\n if (!cloneableTags[tag]) {\n return object ? value : {};\n }\n result = initCloneByTag(value, tag, isDeep);\n }\n }\n // Check for circular references and return its corresponding clone.\n stack || (stack = new Stack);\n var stacked = stack.get(value);\n if (stacked) {\n return stacked;\n }\n stack.set(value, result);\n\n if (isSet(value)) {\n value.forEach(function(subValue) {\n result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));\n });\n } else if (isMap(value)) {\n value.forEach(function(subValue, key) {\n result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));\n });\n }\n\n var keysFunc = isFull\n ? (isFlat ? getAllKeysIn : getAllKeys)\n : (isFlat ? keysIn : keys);\n\n var props = isArr ? undefined : keysFunc(value);\n arrayEach(props || value, function(subValue, key) {\n if (props) {\n key = subValue;\n subValue = value[key];\n }\n // Recursively populate clone (susceptible to call stack limits).\n assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));\n });\n return result;\n }\n\n /**\n * The base implementation of `_.conforms` which doesn't clone `source`.\n *\n * @private\n * @param {Object} source The object of property predicates to conform to.\n * @returns {Function} Returns the new spec function.\n */\n function baseConforms(source) {\n var props = keys(source);\n return function(object) {\n return baseConformsTo(object, source, props);\n };\n }\n\n /**\n * The base implementation of `_.conformsTo` which accepts `props` to check.\n *\n * @private\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property predicates to conform to.\n * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n */\n function baseConformsTo(object, source, props) {\n var length = props.length;\n if (object == null) {\n return !length;\n }\n object = Object(object);\n while (length--) {\n var key = props[length],\n predicate = source[key],\n value = object[key];\n\n if ((value === undefined && !(key in object)) || !predicate(value)) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * The base implementation of `_.delay` and `_.defer` which accepts `args`\n * to provide to `func`.\n *\n * @private\n * @param {Function} func The function to delay.\n * @param {number} wait The number of milliseconds to delay invocation.\n * @param {Array} args The arguments to provide to `func`.\n * @returns {number|Object} Returns the timer id or timeout object.\n */\n function baseDelay(func, wait, args) {\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n return setTimeout(function() { func.apply(undefined, args); }, wait);\n }\n\n /**\n * The base implementation of methods like `_.difference` without support\n * for excluding multiple arrays or iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Array} values The values to exclude.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of filtered values.\n */\n function baseDifference(array, values, iteratee, comparator) {\n var index = -1,\n includes = arrayIncludes,\n isCommon = true,\n length = array.length,\n result = [],\n valuesLength = values.length;\n\n if (!length) {\n return result;\n }\n if (iteratee) {\n values = arrayMap(values, baseUnary(iteratee));\n }\n if (comparator) {\n includes = arrayIncludesWith;\n isCommon = false;\n }\n else if (values.length >= LARGE_ARRAY_SIZE) {\n includes = cacheHas;\n isCommon = false;\n values = new SetCache(values);\n }\n outer:\n while (++index < length) {\n var value = array[index],\n computed = iteratee == null ? value : iteratee(value);\n\n value = (comparator || value !== 0) ? value : 0;\n if (isCommon && computed === computed) {\n var valuesIndex = valuesLength;\n while (valuesIndex--) {\n if (values[valuesIndex] === computed) {\n continue outer;\n }\n }\n result.push(value);\n }\n else if (!includes(values, computed, comparator)) {\n result.push(value);\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.forEach` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array|Object} Returns `collection`.\n */\n var baseEach = createBaseEach(baseForOwn);\n\n /**\n * The base implementation of `_.forEachRight` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array|Object} Returns `collection`.\n */\n var baseEachRight = createBaseEach(baseForOwnRight, true);\n\n /**\n * The base implementation of `_.every` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if all elements pass the predicate check,\n * else `false`\n */\n function baseEvery(collection, predicate) {\n var result = true;\n baseEach(collection, function(value, index, collection) {\n result = !!predicate(value, index, collection);\n return result;\n });\n return result;\n }\n\n /**\n * The base implementation of methods like `_.max` and `_.min` which accepts a\n * `comparator` to determine the extremum value.\n *\n * @private\n * @param {Array} array The array to iterate over.\n * @param {Function} iteratee The iteratee invoked per iteration.\n * @param {Function} comparator The comparator used to compare values.\n * @returns {*} Returns the extremum value.\n */\n function baseExtremum(array, iteratee, comparator) {\n var index = -1,\n length = array.length;\n\n while (++index < length) {\n var value = array[index],\n current = iteratee(value);\n\n if (current != null && (computed === undefined\n ? (current === current && !isSymbol(current))\n : comparator(current, computed)\n )) {\n var computed = current,\n result = value;\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.fill` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to fill.\n * @param {*} value The value to fill `array` with.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns `array`.\n */\n function baseFill(array, value, start, end) {\n var length = array.length;\n\n start = toInteger(start);\n if (start < 0) {\n start = -start > length ? 0 : (length + start);\n }\n end = (end === undefined || end > length) ? length : toInteger(end);\n if (end < 0) {\n end += length;\n }\n end = start > end ? 0 : toLength(end);\n while (start < end) {\n array[start++] = value;\n }\n return array;\n }\n\n /**\n * The base implementation of `_.filter` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\n function baseFilter(collection, predicate) {\n var result = [];\n baseEach(collection, function(value, index, collection) {\n if (predicate(value, index, collection)) {\n result.push(value);\n }\n });\n return result;\n }\n\n /**\n * The base implementation of `_.flatten` with support for restricting flattening.\n *\n * @private\n * @param {Array} array The array to flatten.\n * @param {number} depth The maximum recursion depth.\n * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.\n * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.\n * @param {Array} [result=[]] The initial result value.\n * @returns {Array} Returns the new flattened array.\n */\n function baseFlatten(array, depth, predicate, isStrict, result) {\n var index = -1,\n length = array.length;\n\n predicate || (predicate = isFlattenable);\n result || (result = []);\n\n while (++index < length) {\n var value = array[index];\n if (depth > 0 && predicate(value)) {\n if (depth > 1) {\n // Recursively flatten arrays (susceptible to call stack limits).\n baseFlatten(value, depth - 1, predicate, isStrict, result);\n } else {\n arrayPush(result, value);\n }\n } else if (!isStrict) {\n result[result.length] = value;\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\n var baseFor = createBaseFor();\n\n /**\n * This function is like `baseFor` except that it iterates over properties\n * in the opposite order.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\n var baseForRight = createBaseFor(true);\n\n /**\n * The base implementation of `_.forOwn` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Object} Returns `object`.\n */\n function baseForOwn(object, iteratee) {\n return object && baseFor(object, iteratee, keys);\n }\n\n /**\n * The base implementation of `_.forOwnRight` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Object} Returns `object`.\n */\n function baseForOwnRight(object, iteratee) {\n return object && baseForRight(object, iteratee, keys);\n }\n\n /**\n * The base implementation of `_.functions` which creates an array of\n * `object` function property names filtered from `props`.\n *\n * @private\n * @param {Object} object The object to inspect.\n * @param {Array} props The property names to filter.\n * @returns {Array} Returns the function names.\n */\n function baseFunctions(object, props) {\n return arrayFilter(props, function(key) {\n return isFunction(object[key]);\n });\n }\n\n /**\n * The base implementation of `_.get` without support for default values.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @returns {*} Returns the resolved value.\n */\n function baseGet(object, path) {\n path = castPath(path, object);\n\n var index = 0,\n length = path.length;\n\n while (object != null && index < length) {\n object = object[toKey(path[index++])];\n }\n return (index && index == length) ? object : undefined;\n }\n\n /**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\n function baseGetAllKeys(object, keysFunc, symbolsFunc) {\n var result = keysFunc(object);\n return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n }\n\n /**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\n function baseGetTag(value) {\n if (value == null) {\n return value === undefined ? undefinedTag : nullTag;\n }\n return (symToStringTag && symToStringTag in Object(value))\n ? getRawTag(value)\n : objectToString(value);\n }\n\n /**\n * The base implementation of `_.gt` which doesn't coerce arguments.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if `value` is greater than `other`,\n * else `false`.\n */\n function baseGt(value, other) {\n return value > other;\n }\n\n /**\n * The base implementation of `_.has` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\n function baseHas(object, key) {\n return object != null && hasOwnProperty.call(object, key);\n }\n\n /**\n * The base implementation of `_.hasIn` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\n function baseHasIn(object, key) {\n return object != null && key in Object(object);\n }\n\n /**\n * The base implementation of `_.inRange` which doesn't coerce arguments.\n *\n * @private\n * @param {number} number The number to check.\n * @param {number} start The start of the range.\n * @param {number} end The end of the range.\n * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n */\n function baseInRange(number, start, end) {\n return number >= nativeMin(start, end) && number < nativeMax(start, end);\n }\n\n /**\n * The base implementation of methods like `_.intersection`, without support\n * for iteratee shorthands, that accepts an array of arrays to inspect.\n *\n * @private\n * @param {Array} arrays The arrays to inspect.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of shared values.\n */\n function baseIntersection(arrays, iteratee, comparator) {\n var includes = comparator ? arrayIncludesWith : arrayIncludes,\n length = arrays[0].length,\n othLength = arrays.length,\n othIndex = othLength,\n caches = Array(othLength),\n maxLength = Infinity,\n result = [];\n\n while (othIndex--) {\n var array = arrays[othIndex];\n if (othIndex && iteratee) {\n array = arrayMap(array, baseUnary(iteratee));\n }\n maxLength = nativeMin(array.length, maxLength);\n caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))\n ? new SetCache(othIndex && array)\n : undefined;\n }\n array = arrays[0];\n\n var index = -1,\n seen = caches[0];\n\n outer:\n while (++index < length && result.length < maxLength) {\n var value = array[index],\n computed = iteratee ? iteratee(value) : value;\n\n value = (comparator || value !== 0) ? value : 0;\n if (!(seen\n ? cacheHas(seen, computed)\n : includes(result, computed, comparator)\n )) {\n othIndex = othLength;\n while (--othIndex) {\n var cache = caches[othIndex];\n if (!(cache\n ? cacheHas(cache, computed)\n : includes(arrays[othIndex], computed, comparator))\n ) {\n continue outer;\n }\n }\n if (seen) {\n seen.push(computed);\n }\n result.push(value);\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.invert` and `_.invertBy` which inverts\n * `object` with values transformed by `iteratee` and set by `setter`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} setter The function to set `accumulator` values.\n * @param {Function} iteratee The iteratee to transform values.\n * @param {Object} accumulator The initial inverted object.\n * @returns {Function} Returns `accumulator`.\n */\n function baseInverter(object, setter, iteratee, accumulator) {\n baseForOwn(object, function(value, key, object) {\n setter(accumulator, iteratee(value), key, object);\n });\n return accumulator;\n }\n\n /**\n * The base implementation of `_.invoke` without support for individual\n * method arguments.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the method to invoke.\n * @param {Array} args The arguments to invoke the method with.\n * @returns {*} Returns the result of the invoked method.\n */\n function baseInvoke(object, path, args) {\n path = castPath(path, object);\n object = parent(object, path);\n var func = object == null ? object : object[toKey(last(path))];\n return func == null ? undefined : apply(func, object, args);\n }\n\n /**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\n function baseIsArguments(value) {\n return isObjectLike(value) && baseGetTag(value) == argsTag;\n }\n\n /**\n * The base implementation of `_.isArrayBuffer` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n */\n function baseIsArrayBuffer(value) {\n return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;\n }\n\n /**\n * The base implementation of `_.isDate` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n */\n function baseIsDate(value) {\n return isObjectLike(value) && baseGetTag(value) == dateTag;\n }\n\n /**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n * 1 - Unordered comparison\n * 2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\n function baseIsEqual(value, other, bitmask, customizer, stack) {\n if (value === other) {\n return true;\n }\n if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n return value !== value && other !== other;\n }\n return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n }\n\n /**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\n function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n var objIsArr = isArray(object),\n othIsArr = isArray(other),\n objTag = objIsArr ? arrayTag : getTag(object),\n othTag = othIsArr ? arrayTag : getTag(other);\n\n objTag = objTag == argsTag ? objectTag : objTag;\n othTag = othTag == argsTag ? objectTag : othTag;\n\n var objIsObj = objTag == objectTag,\n othIsObj = othTag == objectTag,\n isSameTag = objTag == othTag;\n\n if (isSameTag && isBuffer(object)) {\n if (!isBuffer(other)) {\n return false;\n }\n objIsArr = true;\n objIsObj = false;\n }\n if (isSameTag && !objIsObj) {\n stack || (stack = new Stack);\n return (objIsArr || isTypedArray(object))\n ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n }\n if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n if (objIsWrapped || othIsWrapped) {\n var objUnwrapped = objIsWrapped ? object.value() : object,\n othUnwrapped = othIsWrapped ? other.value() : other;\n\n stack || (stack = new Stack);\n return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n }\n }\n if (!isSameTag) {\n return false;\n }\n stack || (stack = new Stack);\n return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n }\n\n /**\n * The base implementation of `_.isMap` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n */\n function baseIsMap(value) {\n return isObjectLike(value) && getTag(value) == mapTag;\n }\n\n /**\n * The base implementation of `_.isMatch` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property values to match.\n * @param {Array} matchData The property names, values, and compare flags to match.\n * @param {Function} [customizer] The function to customize comparisons.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n */\n function baseIsMatch(object, source, matchData, customizer) {\n var index = matchData.length,\n length = index,\n noCustomizer = !customizer;\n\n if (object == null) {\n return !length;\n }\n object = Object(object);\n while (index--) {\n var data = matchData[index];\n if ((noCustomizer && data[2])\n ? data[1] !== object[data[0]]\n : !(data[0] in object)\n ) {\n return false;\n }\n }\n while (++index < length) {\n data = matchData[index];\n var key = data[0],\n objValue = object[key],\n srcValue = data[1];\n\n if (noCustomizer && data[2]) {\n if (objValue === undefined && !(key in object)) {\n return false;\n }\n } else {\n var stack = new Stack;\n if (customizer) {\n var result = customizer(objValue, srcValue, key, object, source, stack);\n }\n if (!(result === undefined\n ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG, customizer, stack)\n : result\n )) {\n return false;\n }\n }\n }\n return true;\n }\n\n /**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n */\n function baseIsNative(value) {\n if (!isObject(value) || isMasked(value)) {\n return false;\n }\n var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n }\n\n /**\n * The base implementation of `_.isRegExp` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n */\n function baseIsRegExp(value) {\n return isObjectLike(value) && baseGetTag(value) == regexpTag;\n }\n\n /**\n * The base implementation of `_.isSet` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n */\n function baseIsSet(value) {\n return isObjectLike(value) && getTag(value) == setTag;\n }\n\n /**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\n function baseIsTypedArray(value) {\n return isObjectLike(value) &&\n isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n }\n\n /**\n * The base implementation of `_.iteratee`.\n *\n * @private\n * @param {*} [value=_.identity] The value to convert to an iteratee.\n * @returns {Function} Returns the iteratee.\n */\n function baseIteratee(value) {\n // Don't store the `typeof` result in a variable to avoid a JIT bug in Safari 9.\n // See https://bugs.webkit.org/show_bug.cgi?id=156034 for more details.\n if (typeof value == 'function') {\n return value;\n }\n if (value == null) {\n return identity;\n }\n if (typeof value == 'object') {\n return isArray(value)\n ? baseMatchesProperty(value[0], value[1])\n : baseMatches(value);\n }\n return property(value);\n }\n\n /**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\n function baseKeys(object) {\n if (!isPrototype(object)) {\n return nativeKeys(object);\n }\n var result = [];\n for (var key in Object(object)) {\n if (hasOwnProperty.call(object, key) && key != 'constructor') {\n result.push(key);\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\n function baseKeysIn(object) {\n if (!isObject(object)) {\n return nativeKeysIn(object);\n }\n var isProto = isPrototype(object),\n result = [];\n\n for (var key in object) {\n if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n result.push(key);\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.lt` which doesn't coerce arguments.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if `value` is less than `other`,\n * else `false`.\n */\n function baseLt(value, other) {\n return value < other;\n }\n\n /**\n * The base implementation of `_.map` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\n function baseMap(collection, iteratee) {\n var index = -1,\n result = isArrayLike(collection) ? Array(collection.length) : [];\n\n baseEach(collection, function(value, key, collection) {\n result[++index] = iteratee(value, key, collection);\n });\n return result;\n }\n\n /**\n * The base implementation of `_.matches` which doesn't clone `source`.\n *\n * @private\n * @param {Object} source The object of property values to match.\n * @returns {Function} Returns the new spec function.\n */\n function baseMatches(source) {\n var matchData = getMatchData(source);\n if (matchData.length == 1 && matchData[0][2]) {\n return matchesStrictComparable(matchData[0][0], matchData[0][1]);\n }\n return function(object) {\n return object === source || baseIsMatch(object, source, matchData);\n };\n }\n\n /**\n * The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.\n *\n * @private\n * @param {string} path The path of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\n function baseMatchesProperty(path, srcValue) {\n if (isKey(path) && isStrictComparable(srcValue)) {\n return matchesStrictComparable(toKey(path), srcValue);\n }\n return function(object) {\n var objValue = get(object, path);\n return (objValue === undefined && objValue === srcValue)\n ? hasIn(object, path)\n : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);\n };\n }\n\n /**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n */\n function baseMerge(object, source, srcIndex, customizer, stack) {\n if (object === source) {\n return;\n }\n baseFor(source, function(srcValue, key) {\n stack || (stack = new Stack);\n if (isObject(srcValue)) {\n baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n }\n else {\n var newValue = customizer\n ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n : undefined;\n\n if (newValue === undefined) {\n newValue = srcValue;\n }\n assignMergeValue(object, key, newValue);\n }\n }, keysIn);\n }\n\n /**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n */\n function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n var objValue = safeGet(object, key),\n srcValue = safeGet(source, key),\n stacked = stack.get(srcValue);\n\n if (stacked) {\n assignMergeValue(object, key, stacked);\n return;\n }\n var newValue = customizer\n ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n : undefined;\n\n var isCommon = newValue === undefined;\n\n if (isCommon) {\n var isArr = isArray(srcValue),\n isBuff = !isArr && isBuffer(srcValue),\n isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n newValue = srcValue;\n if (isArr || isBuff || isTyped) {\n if (isArray(objValue)) {\n newValue = objValue;\n }\n else if (isArrayLikeObject(objValue)) {\n newValue = copyArray(objValue);\n }\n else if (isBuff) {\n isCommon = false;\n newValue = cloneBuffer(srcValue, true);\n }\n else if (isTyped) {\n isCommon = false;\n newValue = cloneTypedArray(srcValue, true);\n }\n else {\n newValue = [];\n }\n }\n else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n newValue = objValue;\n if (isArguments(objValue)) {\n newValue = toPlainObject(objValue);\n }\n else if (!isObject(objValue) || isFunction(objValue)) {\n newValue = initCloneObject(srcValue);\n }\n }\n else {\n isCommon = false;\n }\n }\n if (isCommon) {\n // Recursively merge objects and arrays (susceptible to call stack limits).\n stack.set(srcValue, newValue);\n mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n stack['delete'](srcValue);\n }\n assignMergeValue(object, key, newValue);\n }\n\n /**\n * The base implementation of `_.nth` which doesn't coerce arguments.\n *\n * @private\n * @param {Array} array The array to query.\n * @param {number} n The index of the element to return.\n * @returns {*} Returns the nth element of `array`.\n */\n function baseNth(array, n) {\n var length = array.length;\n if (!length) {\n return;\n }\n n += n < 0 ? length : 0;\n return isIndex(n, length) ? array[n] : undefined;\n }\n\n /**\n * The base implementation of `_.orderBy` without param guards.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function[]|Object[]|string[]} iteratees The iteratees to sort by.\n * @param {string[]} orders The sort orders of `iteratees`.\n * @returns {Array} Returns the new sorted array.\n */\n function baseOrderBy(collection, iteratees, orders) {\n if (iteratees.length) {\n iteratees = arrayMap(iteratees, function(iteratee) {\n if (isArray(iteratee)) {\n return function(value) {\n return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);\n }\n }\n return iteratee;\n });\n } else {\n iteratees = [identity];\n }\n\n var index = -1;\n iteratees = arrayMap(iteratees, baseUnary(getIteratee()));\n\n var result = baseMap(collection, function(value, key, collection) {\n var criteria = arrayMap(iteratees, function(iteratee) {\n return iteratee(value);\n });\n return { 'criteria': criteria, 'index': ++index, 'value': value };\n });\n\n return baseSortBy(result, function(object, other) {\n return compareMultiple(object, other, orders);\n });\n }\n\n /**\n * The base implementation of `_.pick` without support for individual\n * property identifiers.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @returns {Object} Returns the new object.\n */\n function basePick(object, paths) {\n return basePickBy(object, paths, function(value, path) {\n return hasIn(object, path);\n });\n }\n\n /**\n * The base implementation of `_.pickBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Object} object The source object.\n * @param {string[]} paths The property paths to pick.\n * @param {Function} predicate The function invoked per property.\n * @returns {Object} Returns the new object.\n */\n function basePickBy(object, paths, predicate) {\n var index = -1,\n length = paths.length,\n result = {};\n\n while (++index < length) {\n var path = paths[index],\n value = baseGet(object, path);\n\n if (predicate(value, path)) {\n baseSet(result, castPath(path, object), value);\n }\n }\n return result;\n }\n\n /**\n * A specialized version of `baseProperty` which supports deep paths.\n *\n * @private\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new accessor function.\n */\n function basePropertyDeep(path) {\n return function(object) {\n return baseGet(object, path);\n };\n }\n\n /**\n * The base implementation of `_.pullAllBy` without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to remove.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns `array`.\n */\n function basePullAll(array, values, iteratee, comparator) {\n var indexOf = comparator ? baseIndexOfWith : baseIndexOf,\n index = -1,\n length = values.length,\n seen = array;\n\n if (array === values) {\n values = copyArray(values);\n }\n if (iteratee) {\n seen = arrayMap(array, baseUnary(iteratee));\n }\n while (++index < length) {\n var fromIndex = 0,\n value = values[index],\n computed = iteratee ? iteratee(value) : value;\n\n while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {\n if (seen !== array) {\n splice.call(seen, fromIndex, 1);\n }\n splice.call(array, fromIndex, 1);\n }\n }\n return array;\n }\n\n /**\n * The base implementation of `_.pullAt` without support for individual\n * indexes or capturing the removed elements.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {number[]} indexes The indexes of elements to remove.\n * @returns {Array} Returns `array`.\n */\n function basePullAt(array, indexes) {\n var length = array ? indexes.length : 0,\n lastIndex = length - 1;\n\n while (length--) {\n var index = indexes[length];\n if (length == lastIndex || index !== previous) {\n var previous = index;\n if (isIndex(index)) {\n splice.call(array, index, 1);\n } else {\n baseUnset(array, index);\n }\n }\n }\n return array;\n }\n\n /**\n * The base implementation of `_.random` without support for returning\n * floating-point numbers.\n *\n * @private\n * @param {number} lower The lower bound.\n * @param {number} upper The upper bound.\n * @returns {number} Returns the random number.\n */\n function baseRandom(lower, upper) {\n return lower + nativeFloor(nativeRandom() * (upper - lower + 1));\n }\n\n /**\n * The base implementation of `_.range` and `_.rangeRight` which doesn't\n * coerce arguments.\n *\n * @private\n * @param {number} start The start of the range.\n * @param {number} end The end of the range.\n * @param {number} step The value to increment or decrement by.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Array} Returns the range of numbers.\n */\n function baseRange(start, end, step, fromRight) {\n var index = -1,\n length = nativeMax(nativeCeil((end - start) / (step || 1)), 0),\n result = Array(length);\n\n while (length--) {\n result[fromRight ? length : ++index] = start;\n start += step;\n }\n return result;\n }\n\n /**\n * The base implementation of `_.repeat` which doesn't coerce arguments.\n *\n * @private\n * @param {string} string The string to repeat.\n * @param {number} n The number of times to repeat the string.\n * @returns {string} Returns the repeated string.\n */\n function baseRepeat(string, n) {\n var result = '';\n if (!string || n < 1 || n > MAX_SAFE_INTEGER) {\n return result;\n }\n // Leverage the exponentiation by squaring algorithm for a faster repeat.\n // See https://en.wikipedia.org/wiki/Exponentiation_by_squaring for more details.\n do {\n if (n % 2) {\n result += string;\n }\n n = nativeFloor(n / 2);\n if (n) {\n string += string;\n }\n } while (n);\n\n return result;\n }\n\n /**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\n function baseRest(func, start) {\n return setToString(overRest(func, start, identity), func + '');\n }\n\n /**\n * The base implementation of `_.sample`.\n *\n * @private\n * @param {Array|Object} collection The collection to sample.\n * @returns {*} Returns the random element.\n */\n function baseSample(collection) {\n return arraySample(values(collection));\n }\n\n /**\n * The base implementation of `_.sampleSize` without param guards.\n *\n * @private\n * @param {Array|Object} collection The collection to sample.\n * @param {number} n The number of elements to sample.\n * @returns {Array} Returns the random elements.\n */\n function baseSampleSize(collection, n) {\n var array = values(collection);\n return shuffleSelf(array, baseClamp(n, 0, array.length));\n }\n\n /**\n * The base implementation of `_.set`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @param {Function} [customizer] The function to customize path creation.\n * @returns {Object} Returns `object`.\n */\n function baseSet(object, path, value, customizer) {\n if (!isObject(object)) {\n return object;\n }\n path = castPath(path, object);\n\n var index = -1,\n length = path.length,\n lastIndex = length - 1,\n nested = object;\n\n while (nested != null && ++index < length) {\n var key = toKey(path[index]),\n newValue = value;\n\n if (key === '__proto__' || key === 'constructor' || key === 'prototype') {\n return object;\n }\n\n if (index != lastIndex) {\n var objValue = nested[key];\n newValue = customizer ? customizer(objValue, key, nested) : undefined;\n if (newValue === undefined) {\n newValue = isObject(objValue)\n ? objValue\n : (isIndex(path[index + 1]) ? [] : {});\n }\n }\n assignValue(nested, key, newValue);\n nested = nested[key];\n }\n return object;\n }\n\n /**\n * The base implementation of `setData` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to associate metadata with.\n * @param {*} data The metadata.\n * @returns {Function} Returns `func`.\n */\n var baseSetData = !metaMap ? identity : function(func, data) {\n metaMap.set(func, data);\n return func;\n };\n\n /**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\n var baseSetToString = !defineProperty ? identity : function(func, string) {\n return defineProperty(func, 'toString', {\n 'configurable': true,\n 'enumerable': false,\n 'value': constant(string),\n 'writable': true\n });\n };\n\n /**\n * The base implementation of `_.shuffle`.\n *\n * @private\n * @param {Array|Object} collection The collection to shuffle.\n * @returns {Array} Returns the new shuffled array.\n */\n function baseShuffle(collection) {\n return shuffleSelf(values(collection));\n }\n\n /**\n * The base implementation of `_.slice` without an iteratee call guard.\n *\n * @private\n * @param {Array} array The array to slice.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the slice of `array`.\n */\n function baseSlice(array, start, end) {\n var index = -1,\n length = array.length;\n\n if (start < 0) {\n start = -start > length ? 0 : (length + start);\n }\n end = end > length ? length : end;\n if (end < 0) {\n end += length;\n }\n length = start > end ? 0 : ((end - start) >>> 0);\n start >>>= 0;\n\n var result = Array(length);\n while (++index < length) {\n result[index] = array[index + start];\n }\n return result;\n }\n\n /**\n * The base implementation of `_.some` without support for iteratee shorthands.\n *\n * @private\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n * else `false`.\n */\n function baseSome(collection, predicate) {\n var result;\n\n baseEach(collection, function(value, index, collection) {\n result = predicate(value, index, collection);\n return !result;\n });\n return !!result;\n }\n\n /**\n * The base implementation of `_.sortedIndex` and `_.sortedLastIndex` which\n * performs a binary search of `array` to determine the index at which `value`\n * should be inserted into `array` in order to maintain its sort order.\n *\n * @private\n * @param {Array} array The sorted array to inspect.\n * @param {*} value The value to evaluate.\n * @param {boolean} [retHighest] Specify returning the highest qualified index.\n * @returns {number} Returns the index at which `value` should be inserted\n * into `array`.\n */\n function baseSortedIndex(array, value, retHighest) {\n var low = 0,\n high = array == null ? low : array.length;\n\n if (typeof value == 'number' && value === value && high <= HALF_MAX_ARRAY_LENGTH) {\n while (low < high) {\n var mid = (low + high) >>> 1,\n computed = array[mid];\n\n if (computed !== null && !isSymbol(computed) &&\n (retHighest ? (computed <= value) : (computed < value))) {\n low = mid + 1;\n } else {\n high = mid;\n }\n }\n return high;\n }\n return baseSortedIndexBy(array, value, identity, retHighest);\n }\n\n /**\n * The base implementation of `_.sortedIndexBy` and `_.sortedLastIndexBy`\n * which invokes `iteratee` for `value` and each element of `array` to compute\n * their sort ranking. The iteratee is invoked with one argument; (value).\n *\n * @private\n * @param {Array} array The sorted array to inspect.\n * @param {*} value The value to evaluate.\n * @param {Function} iteratee The iteratee invoked per element.\n * @param {boolean} [retHighest] Specify returning the highest qualified index.\n * @returns {number} Returns the index at which `value` should be inserted\n * into `array`.\n */\n function baseSortedIndexBy(array, value, iteratee, retHighest) {\n var low = 0,\n high = array == null ? 0 : array.length;\n if (high === 0) {\n return 0;\n }\n\n value = iteratee(value);\n var valIsNaN = value !== value,\n valIsNull = value === null,\n valIsSymbol = isSymbol(value),\n valIsUndefined = value === undefined;\n\n while (low < high) {\n var mid = nativeFloor((low + high) / 2),\n computed = iteratee(array[mid]),\n othIsDefined = computed !== undefined,\n othIsNull = computed === null,\n othIsReflexive = computed === computed,\n othIsSymbol = isSymbol(computed);\n\n if (valIsNaN) {\n var setLow = retHighest || othIsReflexive;\n } else if (valIsUndefined) {\n setLow = othIsReflexive && (retHighest || othIsDefined);\n } else if (valIsNull) {\n setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);\n } else if (valIsSymbol) {\n setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);\n } else if (othIsNull || othIsSymbol) {\n setLow = false;\n } else {\n setLow = retHighest ? (computed <= value) : (computed < value);\n }\n if (setLow) {\n low = mid + 1;\n } else {\n high = mid;\n }\n }\n return nativeMin(high, MAX_ARRAY_INDEX);\n }\n\n /**\n * The base implementation of `_.sortedUniq` and `_.sortedUniqBy` without\n * support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n */\n function baseSortedUniq(array, iteratee) {\n var index = -1,\n length = array.length,\n resIndex = 0,\n result = [];\n\n while (++index < length) {\n var value = array[index],\n computed = iteratee ? iteratee(value) : value;\n\n if (!index || !eq(computed, seen)) {\n var seen = computed;\n result[resIndex++] = value === 0 ? 0 : value;\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.toNumber` which doesn't ensure correct\n * conversions of binary, hexadecimal, or octal string values.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n */\n function baseToNumber(value) {\n if (typeof value == 'number') {\n return value;\n }\n if (isSymbol(value)) {\n return NAN;\n }\n return +value;\n }\n\n /**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\n function baseToString(value) {\n // Exit early for strings to avoid a performance hit in some environments.\n if (typeof value == 'string') {\n return value;\n }\n if (isArray(value)) {\n // Recursively convert values (susceptible to call stack limits).\n return arrayMap(value, baseToString) + '';\n }\n if (isSymbol(value)) {\n return symbolToString ? symbolToString.call(value) : '';\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n }\n\n /**\n * The base implementation of `_.uniqBy` without support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n */\n function baseUniq(array, iteratee, comparator) {\n var index = -1,\n includes = arrayIncludes,\n length = array.length,\n isCommon = true,\n result = [],\n seen = result;\n\n if (comparator) {\n isCommon = false;\n includes = arrayIncludesWith;\n }\n else if (length >= LARGE_ARRAY_SIZE) {\n var set = iteratee ? null : createSet(array);\n if (set) {\n return setToArray(set);\n }\n isCommon = false;\n includes = cacheHas;\n seen = new SetCache;\n }\n else {\n seen = iteratee ? [] : result;\n }\n outer:\n while (++index < length) {\n var value = array[index],\n computed = iteratee ? iteratee(value) : value;\n\n value = (comparator || value !== 0) ? value : 0;\n if (isCommon && computed === computed) {\n var seenIndex = seen.length;\n while (seenIndex--) {\n if (seen[seenIndex] === computed) {\n continue outer;\n }\n }\n if (iteratee) {\n seen.push(computed);\n }\n result.push(value);\n }\n else if (!includes(seen, computed, comparator)) {\n if (seen !== result) {\n seen.push(computed);\n }\n result.push(value);\n }\n }\n return result;\n }\n\n /**\n * The base implementation of `_.unset`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The property path to unset.\n * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n */\n function baseUnset(object, path) {\n path = castPath(path, object);\n object = parent(object, path);\n return object == null || delete object[toKey(last(path))];\n }\n\n /**\n * The base implementation of `_.update`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to update.\n * @param {Function} updater The function to produce the updated value.\n * @param {Function} [customizer] The function to customize path creation.\n * @returns {Object} Returns `object`.\n */\n function baseUpdate(object, path, updater, customizer) {\n return baseSet(object, path, updater(baseGet(object, path)), customizer);\n }\n\n /**\n * The base implementation of methods like `_.dropWhile` and `_.takeWhile`\n * without support for iteratee shorthands.\n *\n * @private\n * @param {Array} array The array to query.\n * @param {Function} predicate The function invoked per iteration.\n * @param {boolean} [isDrop] Specify dropping elements instead of taking them.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Array} Returns the slice of `array`.\n */\n function baseWhile(array, predicate, isDrop, fromRight) {\n var length = array.length,\n index = fromRight ? length : -1;\n\n while ((fromRight ? index-- : ++index < length) &&\n predicate(array[index], index, array)) {}\n\n return isDrop\n ? baseSlice(array, (fromRight ? 0 : index), (fromRight ? index + 1 : length))\n : baseSlice(array, (fromRight ? index + 1 : 0), (fromRight ? length : index));\n }\n\n /**\n * The base implementation of `wrapperValue` which returns the result of\n * performing a sequence of actions on the unwrapped `value`, where each\n * successive action is supplied the return value of the previous.\n *\n * @private\n * @param {*} value The unwrapped value.\n * @param {Array} actions Actions to perform to resolve the unwrapped value.\n * @returns {*} Returns the resolved value.\n */\n function baseWrapperValue(value, actions) {\n var result = value;\n if (result instanceof LazyWrapper) {\n result = result.value();\n }\n return arrayReduce(actions, function(result, action) {\n return action.func.apply(action.thisArg, arrayPush([result], action.args));\n }, result);\n }\n\n /**\n * The base implementation of methods like `_.xor`, without support for\n * iteratee shorthands, that accepts an array of arrays to inspect.\n *\n * @private\n * @param {Array} arrays The arrays to inspect.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of values.\n */\n function baseXor(arrays, iteratee, comparator) {\n var length = arrays.length;\n if (length < 2) {\n return length ? baseUniq(arrays[0]) : [];\n }\n var index = -1,\n result = Array(length);\n\n while (++index < length) {\n var array = arrays[index],\n othIndex = -1;\n\n while (++othIndex < length) {\n if (othIndex != index) {\n result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);\n }\n }\n }\n return baseUniq(baseFlatten(result, 1), iteratee, comparator);\n }\n\n /**\n * This base implementation of `_.zipObject` which assigns values using `assignFunc`.\n *\n * @private\n * @param {Array} props The property identifiers.\n * @param {Array} values The property values.\n * @param {Function} assignFunc The function to assign values.\n * @returns {Object} Returns the new object.\n */\n function baseZipObject(props, values, assignFunc) {\n var index = -1,\n length = props.length,\n valsLength = values.length,\n result = {};\n\n while (++index < length) {\n var value = index < valsLength ? values[index] : undefined;\n assignFunc(result, props[index], value);\n }\n return result;\n }\n\n /**\n * Casts `value` to an empty array if it's not an array like object.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {Array|Object} Returns the cast array-like object.\n */\n function castArrayLikeObject(value) {\n return isArrayLikeObject(value) ? value : [];\n }\n\n /**\n * Casts `value` to `identity` if it's not a function.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {Function} Returns cast function.\n */\n function castFunction(value) {\n return typeof value == 'function' ? value : identity;\n }\n\n /**\n * Casts `value` to a path array if it's not one.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {Object} [object] The object to query keys on.\n * @returns {Array} Returns the cast property path array.\n */\n function castPath(value, object) {\n if (isArray(value)) {\n return value;\n }\n return isKey(value, object) ? [value] : stringToPath(toString(value));\n }\n\n /**\n * A `baseRest` alias which can be replaced with `identity` by module\n * replacement plugins.\n *\n * @private\n * @type {Function}\n * @param {Function} func The function to apply a rest parameter to.\n * @returns {Function} Returns the new function.\n */\n var castRest = baseRest;\n\n /**\n * Casts `array` to a slice if it's needed.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {number} start The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the cast slice.\n */\n function castSlice(array, start, end) {\n var length = array.length;\n end = end === undefined ? length : end;\n return (!start && end >= length) ? array : baseSlice(array, start, end);\n }\n\n /**\n * A simple wrapper around the global [`clearTimeout`](https://mdn.io/clearTimeout).\n *\n * @private\n * @param {number|Object} id The timer id or timeout object of the timer to clear.\n */\n var clearTimeout = ctxClearTimeout || function(id) {\n return root.clearTimeout(id);\n };\n\n /**\n * Creates a clone of `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\n function cloneBuffer(buffer, isDeep) {\n if (isDeep) {\n return buffer.slice();\n }\n var length = buffer.length,\n result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n buffer.copy(result);\n return result;\n }\n\n /**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\n function cloneArrayBuffer(arrayBuffer) {\n var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n return result;\n }\n\n /**\n * Creates a clone of `dataView`.\n *\n * @private\n * @param {Object} dataView The data view to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned data view.\n */\n function cloneDataView(dataView, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;\n return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);\n }\n\n /**\n * Creates a clone of `regexp`.\n *\n * @private\n * @param {Object} regexp The regexp to clone.\n * @returns {Object} Returns the cloned regexp.\n */\n function cloneRegExp(regexp) {\n var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));\n result.lastIndex = regexp.lastIndex;\n return result;\n }\n\n /**\n * Creates a clone of the `symbol` object.\n *\n * @private\n * @param {Object} symbol The symbol object to clone.\n * @returns {Object} Returns the cloned symbol object.\n */\n function cloneSymbol(symbol) {\n return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};\n }\n\n /**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\n function cloneTypedArray(typedArray, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n }\n\n /**\n * Compares values to sort them in ascending order.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {number} Returns the sort order indicator for `value`.\n */\n function compareAscending(value, other) {\n if (value !== other) {\n var valIsDefined = value !== undefined,\n valIsNull = value === null,\n valIsReflexive = value === value,\n valIsSymbol = isSymbol(value);\n\n var othIsDefined = other !== undefined,\n othIsNull = other === null,\n othIsReflexive = other === other,\n othIsSymbol = isSymbol(other);\n\n if ((!othIsNull && !othIsSymbol && !valIsSymbol && value > other) ||\n (valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol) ||\n (valIsNull && othIsDefined && othIsReflexive) ||\n (!valIsDefined && othIsReflexive) ||\n !valIsReflexive) {\n return 1;\n }\n if ((!valIsNull && !valIsSymbol && !othIsSymbol && value < other) ||\n (othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol) ||\n (othIsNull && valIsDefined && valIsReflexive) ||\n (!othIsDefined && valIsReflexive) ||\n !othIsReflexive) {\n return -1;\n }\n }\n return 0;\n }\n\n /**\n * Used by `_.orderBy` to compare multiple properties of a value to another\n * and stable sort them.\n *\n * If `orders` is unspecified, all values are sorted in ascending order. Otherwise,\n * specify an order of \"desc\" for descending or \"asc\" for ascending sort order\n * of corresponding values.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {boolean[]|string[]} orders The order to sort by for each property.\n * @returns {number} Returns the sort order indicator for `object`.\n */\n function compareMultiple(object, other, orders) {\n var index = -1,\n objCriteria = object.criteria,\n othCriteria = other.criteria,\n length = objCriteria.length,\n ordersLength = orders.length;\n\n while (++index < length) {\n var result = compareAscending(objCriteria[index], othCriteria[index]);\n if (result) {\n if (index >= ordersLength) {\n return result;\n }\n var order = orders[index];\n return result * (order == 'desc' ? -1 : 1);\n }\n }\n // Fixes an `Array#sort` bug in the JS engine embedded in Adobe applications\n // that causes it, under certain circumstances, to provide the same value for\n // `object` and `other`. See https://github.com/jashkenas/underscore/pull/1247\n // for more details.\n //\n // This also ensures a stable sort in V8 and other engines.\n // See https://bugs.chromium.org/p/v8/issues/detail?id=90 for more details.\n return object.index - other.index;\n }\n\n /**\n * Creates an array that is the composition of partially applied arguments,\n * placeholders, and provided arguments into a single array of arguments.\n *\n * @private\n * @param {Array} args The provided arguments.\n * @param {Array} partials The arguments to prepend to those provided.\n * @param {Array} holders The `partials` placeholder indexes.\n * @params {boolean} [isCurried] Specify composing for a curried function.\n * @returns {Array} Returns the new array of composed arguments.\n */\n function composeArgs(args, partials, holders, isCurried) {\n var argsIndex = -1,\n argsLength = args.length,\n holdersLength = holders.length,\n leftIndex = -1,\n leftLength = partials.length,\n rangeLength = nativeMax(argsLength - holdersLength, 0),\n result = Array(leftLength + rangeLength),\n isUncurried = !isCurried;\n\n while (++leftIndex < leftLength) {\n result[leftIndex] = partials[leftIndex];\n }\n while (++argsIndex < holdersLength) {\n if (isUncurried || argsIndex < argsLength) {\n result[holders[argsIndex]] = args[argsIndex];\n }\n }\n while (rangeLength--) {\n result[leftIndex++] = args[argsIndex++];\n }\n return result;\n }\n\n /**\n * This function is like `composeArgs` except that the arguments composition\n * is tailored for `_.partialRight`.\n *\n * @private\n * @param {Array} args The provided arguments.\n * @param {Array} partials The arguments to append to those provided.\n * @param {Array} holders The `partials` placeholder indexes.\n * @params {boolean} [isCurried] Specify composing for a curried function.\n * @returns {Array} Returns the new array of composed arguments.\n */\n function composeArgsRight(args, partials, holders, isCurried) {\n var argsIndex = -1,\n argsLength = args.length,\n holdersIndex = -1,\n holdersLength = holders.length,\n rightIndex = -1,\n rightLength = partials.length,\n rangeLength = nativeMax(argsLength - holdersLength, 0),\n result = Array(rangeLength + rightLength),\n isUncurried = !isCurried;\n\n while (++argsIndex < rangeLength) {\n result[argsIndex] = args[argsIndex];\n }\n var offset = argsIndex;\n while (++rightIndex < rightLength) {\n result[offset + rightIndex] = partials[rightIndex];\n }\n while (++holdersIndex < holdersLength) {\n if (isUncurried || argsIndex < argsLength) {\n result[offset + holders[holdersIndex]] = args[argsIndex++];\n }\n }\n return result;\n }\n\n /**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\n function copyArray(source, array) {\n var index = -1,\n length = source.length;\n\n array || (array = Array(length));\n while (++index < length) {\n array[index] = source[index];\n }\n return array;\n }\n\n /**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\n function copyObject(source, props, object, customizer) {\n var isNew = !object;\n object || (object = {});\n\n var index = -1,\n length = props.length;\n\n while (++index < length) {\n var key = props[index];\n\n var newValue = customizer\n ? customizer(object[key], source[key], key, object, source)\n : undefined;\n\n if (newValue === undefined) {\n newValue = source[key];\n }\n if (isNew) {\n baseAssignValue(object, key, newValue);\n } else {\n assignValue(object, key, newValue);\n }\n }\n return object;\n }\n\n /**\n * Copies own symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\n function copySymbols(source, object) {\n return copyObject(source, getSymbols(source), object);\n }\n\n /**\n * Copies own and inherited symbols of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy symbols from.\n * @param {Object} [object={}] The object to copy symbols to.\n * @returns {Object} Returns `object`.\n */\n function copySymbolsIn(source, object) {\n return copyObject(source, getSymbolsIn(source), object);\n }\n\n /**\n * Creates a function like `_.groupBy`.\n *\n * @private\n * @param {Function} setter The function to set accumulator values.\n * @param {Function} [initializer] The accumulator object initializer.\n * @returns {Function} Returns the new aggregator function.\n */\n function createAggregator(setter, initializer) {\n return function(collection, iteratee) {\n var func = isArray(collection) ? arrayAggregator : baseAggregator,\n accumulator = initializer ? initializer() : {};\n\n return func(collection, setter, getIteratee(iteratee, 2), accumulator);\n };\n }\n\n /**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\n function createAssigner(assigner) {\n return baseRest(function(object, sources) {\n var index = -1,\n length = sources.length,\n customizer = length > 1 ? sources[length - 1] : undefined,\n guard = length > 2 ? sources[2] : undefined;\n\n customizer = (assigner.length > 3 && typeof customizer == 'function')\n ? (length--, customizer)\n : undefined;\n\n if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n customizer = length < 3 ? undefined : customizer;\n length = 1;\n }\n object = Object(object);\n while (++index < length) {\n var source = sources[index];\n if (source) {\n assigner(object, source, index, customizer);\n }\n }\n return object;\n });\n }\n\n /**\n * Creates a `baseEach` or `baseEachRight` function.\n *\n * @private\n * @param {Function} eachFunc The function to iterate over a collection.\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\n function createBaseEach(eachFunc, fromRight) {\n return function(collection, iteratee) {\n if (collection == null) {\n return collection;\n }\n if (!isArrayLike(collection)) {\n return eachFunc(collection, iteratee);\n }\n var length = collection.length,\n index = fromRight ? length : -1,\n iterable = Object(collection);\n\n while ((fromRight ? index-- : ++index < length)) {\n if (iteratee(iterable[index], index, iterable) === false) {\n break;\n }\n }\n return collection;\n };\n }\n\n /**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\n function createBaseFor(fromRight) {\n return function(object, iteratee, keysFunc) {\n var index = -1,\n iterable = Object(object),\n props = keysFunc(object),\n length = props.length;\n\n while (length--) {\n var key = props[fromRight ? length : ++index];\n if (iteratee(iterable[key], key, iterable) === false) {\n break;\n }\n }\n return object;\n };\n }\n\n /**\n * Creates a function that wraps `func` to invoke it with the optional `this`\n * binding of `thisArg`.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n * @param {*} [thisArg] The `this` binding of `func`.\n * @returns {Function} Returns the new wrapped function.\n */\n function createBind(func, bitmask, thisArg) {\n var isBind = bitmask & WRAP_BIND_FLAG,\n Ctor = createCtor(func);\n\n function wrapper() {\n var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n return fn.apply(isBind ? thisArg : this, arguments);\n }\n return wrapper;\n }\n\n /**\n * Creates a function like `_.lowerFirst`.\n *\n * @private\n * @param {string} methodName The name of the `String` case method to use.\n * @returns {Function} Returns the new case function.\n */\n function createCaseFirst(methodName) {\n return function(string) {\n string = toString(string);\n\n var strSymbols = hasUnicode(string)\n ? stringToArray(string)\n : undefined;\n\n var chr = strSymbols\n ? strSymbols[0]\n : string.charAt(0);\n\n var trailing = strSymbols\n ? castSlice(strSymbols, 1).join('')\n : string.slice(1);\n\n return chr[methodName]() + trailing;\n };\n }\n\n /**\n * Creates a function like `_.camelCase`.\n *\n * @private\n * @param {Function} callback The function to combine each word.\n * @returns {Function} Returns the new compounder function.\n */\n function createCompounder(callback) {\n return function(string) {\n return arrayReduce(words(deburr(string).replace(reApos, '')), callback, '');\n };\n }\n\n /**\n * Creates a function that produces an instance of `Ctor` regardless of\n * whether it was invoked as part of a `new` expression or by `call` or `apply`.\n *\n * @private\n * @param {Function} Ctor The constructor to wrap.\n * @returns {Function} Returns the new wrapped function.\n */\n function createCtor(Ctor) {\n return function() {\n // Use a `switch` statement to work with class constructors. See\n // http://ecma-international.org/ecma-262/7.0/#sec-ecmascript-function-objects-call-thisargument-argumentslist\n // for more details.\n var args = arguments;\n switch (args.length) {\n case 0: return new Ctor;\n case 1: return new Ctor(args[0]);\n case 2: return new Ctor(args[0], args[1]);\n case 3: return new Ctor(args[0], args[1], args[2]);\n case 4: return new Ctor(args[0], args[1], args[2], args[3]);\n case 5: return new Ctor(args[0], args[1], args[2], args[3], args[4]);\n case 6: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);\n case 7: return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);\n }\n var thisBinding = baseCreate(Ctor.prototype),\n result = Ctor.apply(thisBinding, args);\n\n // Mimic the constructor's `return` behavior.\n // See https://es5.github.io/#x13.2.2 for more details.\n return isObject(result) ? result : thisBinding;\n };\n }\n\n /**\n * Creates a function that wraps `func` to enable currying.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n * @param {number} arity The arity of `func`.\n * @returns {Function} Returns the new wrapped function.\n */\n function createCurry(func, bitmask, arity) {\n var Ctor = createCtor(func);\n\n function wrapper() {\n var length = arguments.length,\n args = Array(length),\n index = length,\n placeholder = getHolder(wrapper);\n\n while (index--) {\n args[index] = arguments[index];\n }\n var holders = (length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder)\n ? []\n : replaceHolders(args, placeholder);\n\n length -= holders.length;\n if (length < arity) {\n return createRecurry(\n func, bitmask, createHybrid, wrapper.placeholder, undefined,\n args, holders, undefined, undefined, arity - length);\n }\n var fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n return apply(fn, this, args);\n }\n return wrapper;\n }\n\n /**\n * Creates a `_.find` or `_.findLast` function.\n *\n * @private\n * @param {Function} findIndexFunc The function to find the collection index.\n * @returns {Function} Returns the new find function.\n */\n function createFind(findIndexFunc) {\n return function(collection, predicate, fromIndex) {\n var iterable = Object(collection);\n if (!isArrayLike(collection)) {\n var iteratee = getIteratee(predicate, 3);\n collection = keys(collection);\n predicate = function(key) { return iteratee(iterable[key], key, iterable); };\n }\n var index = findIndexFunc(collection, predicate, fromIndex);\n return index > -1 ? iterable[iteratee ? collection[index] : index] : undefined;\n };\n }\n\n /**\n * Creates a `_.flow` or `_.flowRight` function.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new flow function.\n */\n function createFlow(fromRight) {\n return flatRest(function(funcs) {\n var length = funcs.length,\n index = length,\n prereq = LodashWrapper.prototype.thru;\n\n if (fromRight) {\n funcs.reverse();\n }\n while (index--) {\n var func = funcs[index];\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n if (prereq && !wrapper && getFuncName(func) == 'wrapper') {\n var wrapper = new LodashWrapper([], true);\n }\n }\n index = wrapper ? index : length;\n while (++index < length) {\n func = funcs[index];\n\n var funcName = getFuncName(func),\n data = funcName == 'wrapper' ? getData(func) : undefined;\n\n if (data && isLaziable(data[0]) &&\n data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG | WRAP_REARG_FLAG) &&\n !data[4].length && data[9] == 1\n ) {\n wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);\n } else {\n wrapper = (func.length == 1 && isLaziable(func))\n ? wrapper[funcName]()\n : wrapper.thru(func);\n }\n }\n return function() {\n var args = arguments,\n value = args[0];\n\n if (wrapper && args.length == 1 && isArray(value)) {\n return wrapper.plant(value).value();\n }\n var index = 0,\n result = length ? funcs[index].apply(this, args) : value;\n\n while (++index < length) {\n result = funcs[index].call(this, result);\n }\n return result;\n };\n });\n }\n\n /**\n * Creates a function that wraps `func` to invoke it with optional `this`\n * binding of `thisArg`, partial application, and currying.\n *\n * @private\n * @param {Function|string} func The function or method name to wrap.\n * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n * @param {*} [thisArg] The `this` binding of `func`.\n * @param {Array} [partials] The arguments to prepend to those provided to\n * the new function.\n * @param {Array} [holders] The `partials` placeholder indexes.\n * @param {Array} [partialsRight] The arguments to append to those provided\n * to the new function.\n * @param {Array} [holdersRight] The `partialsRight` placeholder indexes.\n * @param {Array} [argPos] The argument positions of the new function.\n * @param {number} [ary] The arity cap of `func`.\n * @param {number} [arity] The arity of `func`.\n * @returns {Function} Returns the new wrapped function.\n */\n function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {\n var isAry = bitmask & WRAP_ARY_FLAG,\n isBind = bitmask & WRAP_BIND_FLAG,\n isBindKey = bitmask & WRAP_BIND_KEY_FLAG,\n isCurried = bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG),\n isFlip = bitmask & WRAP_FLIP_FLAG,\n Ctor = isBindKey ? undefined : createCtor(func);\n\n function wrapper() {\n var length = arguments.length,\n args = Array(length),\n index = length;\n\n while (index--) {\n args[index] = arguments[index];\n }\n if (isCurried) {\n var placeholder = getHolder(wrapper),\n holdersCount = countHolders(args, placeholder);\n }\n if (partials) {\n args = composeArgs(args, partials, holders, isCurried);\n }\n if (partialsRight) {\n args = composeArgsRight(args, partialsRight, holdersRight, isCurried);\n }\n length -= holdersCount;\n if (isCurried && length < arity) {\n var newHolders = replaceHolders(args, placeholder);\n return createRecurry(\n func, bitmask, createHybrid, wrapper.placeholder, thisArg,\n args, newHolders, argPos, ary, arity - length\n );\n }\n var thisBinding = isBind ? thisArg : this,\n fn = isBindKey ? thisBinding[func] : func;\n\n length = args.length;\n if (argPos) {\n args = reorder(args, argPos);\n } else if (isFlip && length > 1) {\n args.reverse();\n }\n if (isAry && ary < length) {\n args.length = ary;\n }\n if (this && this !== root && this instanceof wrapper) {\n fn = Ctor || createCtor(fn);\n }\n return fn.apply(thisBinding, args);\n }\n return wrapper;\n }\n\n /**\n * Creates a function like `_.invertBy`.\n *\n * @private\n * @param {Function} setter The function to set accumulator values.\n * @param {Function} toIteratee The function to resolve iteratees.\n * @returns {Function} Returns the new inverter function.\n */\n function createInverter(setter, toIteratee) {\n return function(object, iteratee) {\n return baseInverter(object, setter, toIteratee(iteratee), {});\n };\n }\n\n /**\n * Creates a function that performs a mathematical operation on two values.\n *\n * @private\n * @param {Function} operator The function to perform the operation.\n * @param {number} [defaultValue] The value used for `undefined` arguments.\n * @returns {Function} Returns the new mathematical operation function.\n */\n function createMathOperation(operator, defaultValue) {\n return function(value, other) {\n var result;\n if (value === undefined && other === undefined) {\n return defaultValue;\n }\n if (value !== undefined) {\n result = value;\n }\n if (other !== undefined) {\n if (result === undefined) {\n return other;\n }\n if (typeof value == 'string' || typeof other == 'string') {\n value = baseToString(value);\n other = baseToString(other);\n } else {\n value = baseToNumber(value);\n other = baseToNumber(other);\n }\n result = operator(value, other);\n }\n return result;\n };\n }\n\n /**\n * Creates a function like `_.over`.\n *\n * @private\n * @param {Function} arrayFunc The function to iterate over iteratees.\n * @returns {Function} Returns the new over function.\n */\n function createOver(arrayFunc) {\n return flatRest(function(iteratees) {\n iteratees = arrayMap(iteratees, baseUnary(getIteratee()));\n return baseRest(function(args) {\n var thisArg = this;\n return arrayFunc(iteratees, function(iteratee) {\n return apply(iteratee, thisArg, args);\n });\n });\n });\n }\n\n /**\n * Creates the padding for `string` based on `length`. The `chars` string\n * is truncated if the number of characters exceeds `length`.\n *\n * @private\n * @param {number} length The padding length.\n * @param {string} [chars=' '] The string used as padding.\n * @returns {string} Returns the padding for `string`.\n */\n function createPadding(length, chars) {\n chars = chars === undefined ? ' ' : baseToString(chars);\n\n var charsLength = chars.length;\n if (charsLength < 2) {\n return charsLength ? baseRepeat(chars, length) : chars;\n }\n var result = baseRepeat(chars, nativeCeil(length / stringSize(chars)));\n return hasUnicode(chars)\n ? castSlice(stringToArray(result), 0, length).join('')\n : result.slice(0, length);\n }\n\n /**\n * Creates a function that wraps `func` to invoke it with the `this` binding\n * of `thisArg` and `partials` prepended to the arguments it receives.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} partials The arguments to prepend to those provided to\n * the new function.\n * @returns {Function} Returns the new wrapped function.\n */\n function createPartial(func, bitmask, thisArg, partials) {\n var isBind = bitmask & WRAP_BIND_FLAG,\n Ctor = createCtor(func);\n\n function wrapper() {\n var argsIndex = -1,\n argsLength = arguments.length,\n leftIndex = -1,\n leftLength = partials.length,\n args = Array(leftLength + argsLength),\n fn = (this && this !== root && this instanceof wrapper) ? Ctor : func;\n\n while (++leftIndex < leftLength) {\n args[leftIndex] = partials[leftIndex];\n }\n while (argsLength--) {\n args[leftIndex++] = arguments[++argsIndex];\n }\n return apply(fn, isBind ? thisArg : this, args);\n }\n return wrapper;\n }\n\n /**\n * Creates a `_.range` or `_.rangeRight` function.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new range function.\n */\n function createRange(fromRight) {\n return function(start, end, step) {\n if (step && typeof step != 'number' && isIterateeCall(start, end, step)) {\n end = step = undefined;\n }\n // Ensure the sign of `-0` is preserved.\n start = toFinite(start);\n if (end === undefined) {\n end = start;\n start = 0;\n } else {\n end = toFinite(end);\n }\n step = step === undefined ? (start < end ? 1 : -1) : toFinite(step);\n return baseRange(start, end, step, fromRight);\n };\n }\n\n /**\n * Creates a function that performs a relational operation on two values.\n *\n * @private\n * @param {Function} operator The function to perform the operation.\n * @returns {Function} Returns the new relational operation function.\n */\n function createRelationalOperation(operator) {\n return function(value, other) {\n if (!(typeof value == 'string' && typeof other == 'string')) {\n value = toNumber(value);\n other = toNumber(other);\n }\n return operator(value, other);\n };\n }\n\n /**\n * Creates a function that wraps `func` to continue currying.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n * @param {Function} wrapFunc The function to create the `func` wrapper.\n * @param {*} placeholder The placeholder value.\n * @param {*} [thisArg] The `this` binding of `func`.\n * @param {Array} [partials] The arguments to prepend to those provided to\n * the new function.\n * @param {Array} [holders] The `partials` placeholder indexes.\n * @param {Array} [argPos] The argument positions of the new function.\n * @param {number} [ary] The arity cap of `func`.\n * @param {number} [arity] The arity of `func`.\n * @returns {Function} Returns the new wrapped function.\n */\n function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {\n var isCurry = bitmask & WRAP_CURRY_FLAG,\n newHolders = isCurry ? holders : undefined,\n newHoldersRight = isCurry ? undefined : holders,\n newPartials = isCurry ? partials : undefined,\n newPartialsRight = isCurry ? undefined : partials;\n\n bitmask |= (isCurry ? WRAP_PARTIAL_FLAG : WRAP_PARTIAL_RIGHT_FLAG);\n bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG : WRAP_PARTIAL_FLAG);\n\n if (!(bitmask & WRAP_CURRY_BOUND_FLAG)) {\n bitmask &= ~(WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG);\n }\n var newData = [\n func, bitmask, thisArg, newPartials, newHolders, newPartialsRight,\n newHoldersRight, argPos, ary, arity\n ];\n\n var result = wrapFunc.apply(undefined, newData);\n if (isLaziable(func)) {\n setData(result, newData);\n }\n result.placeholder = placeholder;\n return setWrapToString(result, func, bitmask);\n }\n\n /**\n * Creates a function like `_.round`.\n *\n * @private\n * @param {string} methodName The name of the `Math` method to use when rounding.\n * @returns {Function} Returns the new round function.\n */\n function createRound(methodName) {\n var func = Math[methodName];\n return function(number, precision) {\n number = toNumber(number);\n precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);\n if (precision && nativeIsFinite(number)) {\n // Shift with exponential notation to avoid floating-point issues.\n // See [MDN](https://mdn.io/round#Examples) for more details.\n var pair = (toString(number) + 'e').split('e'),\n value = func(pair[0] + 'e' + (+pair[1] + precision));\n\n pair = (toString(value) + 'e').split('e');\n return +(pair[0] + 'e' + (+pair[1] - precision));\n }\n return func(number);\n };\n }\n\n /**\n * Creates a set object of `values`.\n *\n * @private\n * @param {Array} values The values to add to the set.\n * @returns {Object} Returns the new set.\n */\n var createSet = !(Set && (1 / setToArray(new Set([,-0]))[1]) == INFINITY) ? noop : function(values) {\n return new Set(values);\n };\n\n /**\n * Creates a `_.toPairs` or `_.toPairsIn` function.\n *\n * @private\n * @param {Function} keysFunc The function to get the keys of a given object.\n * @returns {Function} Returns the new pairs function.\n */\n function createToPairs(keysFunc) {\n return function(object) {\n var tag = getTag(object);\n if (tag == mapTag) {\n return mapToArray(object);\n }\n if (tag == setTag) {\n return setToPairs(object);\n }\n return baseToPairs(object, keysFunc(object));\n };\n }\n\n /**\n * Creates a function that either curries or invokes `func` with optional\n * `this` binding and partially applied arguments.\n *\n * @private\n * @param {Function|string} func The function or method name to wrap.\n * @param {number} bitmask The bitmask flags.\n * 1 - `_.bind`\n * 2 - `_.bindKey`\n * 4 - `_.curry` or `_.curryRight` of a bound function\n * 8 - `_.curry`\n * 16 - `_.curryRight`\n * 32 - `_.partial`\n * 64 - `_.partialRight`\n * 128 - `_.rearg`\n * 256 - `_.ary`\n * 512 - `_.flip`\n * @param {*} [thisArg] The `this` binding of `func`.\n * @param {Array} [partials] The arguments to be partially applied.\n * @param {Array} [holders] The `partials` placeholder indexes.\n * @param {Array} [argPos] The argument positions of the new function.\n * @param {number} [ary] The arity cap of `func`.\n * @param {number} [arity] The arity of `func`.\n * @returns {Function} Returns the new wrapped function.\n */\n function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {\n var isBindKey = bitmask & WRAP_BIND_KEY_FLAG;\n if (!isBindKey && typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n var length = partials ? partials.length : 0;\n if (!length) {\n bitmask &= ~(WRAP_PARTIAL_FLAG | WRAP_PARTIAL_RIGHT_FLAG);\n partials = holders = undefined;\n }\n ary = ary === undefined ? ary : nativeMax(toInteger(ary), 0);\n arity = arity === undefined ? arity : toInteger(arity);\n length -= holders ? holders.length : 0;\n\n if (bitmask & WRAP_PARTIAL_RIGHT_FLAG) {\n var partialsRight = partials,\n holdersRight = holders;\n\n partials = holders = undefined;\n }\n var data = isBindKey ? undefined : getData(func);\n\n var newData = [\n func, bitmask, thisArg, partials, holders, partialsRight, holdersRight,\n argPos, ary, arity\n ];\n\n if (data) {\n mergeData(newData, data);\n }\n func = newData[0];\n bitmask = newData[1];\n thisArg = newData[2];\n partials = newData[3];\n holders = newData[4];\n arity = newData[9] = newData[9] === undefined\n ? (isBindKey ? 0 : func.length)\n : nativeMax(newData[9] - length, 0);\n\n if (!arity && bitmask & (WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG)) {\n bitmask &= ~(WRAP_CURRY_FLAG | WRAP_CURRY_RIGHT_FLAG);\n }\n if (!bitmask || bitmask == WRAP_BIND_FLAG) {\n var result = createBind(func, bitmask, thisArg);\n } else if (bitmask == WRAP_CURRY_FLAG || bitmask == WRAP_CURRY_RIGHT_FLAG) {\n result = createCurry(func, bitmask, arity);\n } else if ((bitmask == WRAP_PARTIAL_FLAG || bitmask == (WRAP_BIND_FLAG | WRAP_PARTIAL_FLAG)) && !holders.length) {\n result = createPartial(func, bitmask, thisArg, partials);\n } else {\n result = createHybrid.apply(undefined, newData);\n }\n var setter = data ? baseSetData : setData;\n return setWrapToString(setter(result, newData), func, bitmask);\n }\n\n /**\n * Used by `_.defaults` to customize its `_.assignIn` use to assign properties\n * of source objects to the destination object for all destination properties\n * that resolve to `undefined`.\n *\n * @private\n * @param {*} objValue The destination value.\n * @param {*} srcValue The source value.\n * @param {string} key The key of the property to assign.\n * @param {Object} object The parent object of `objValue`.\n * @returns {*} Returns the value to assign.\n */\n function customDefaultsAssignIn(objValue, srcValue, key, object) {\n if (objValue === undefined ||\n (eq(objValue, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n return srcValue;\n }\n return objValue;\n }\n\n /**\n * Used by `_.defaultsDeep` to customize its `_.merge` use to merge source\n * objects into destination objects that are passed thru.\n *\n * @private\n * @param {*} objValue The destination value.\n * @param {*} srcValue The source value.\n * @param {string} key The key of the property to merge.\n * @param {Object} object The parent object of `objValue`.\n * @param {Object} source The parent object of `srcValue`.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n * @returns {*} Returns the value to assign.\n */\n function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {\n if (isObject(objValue) && isObject(srcValue)) {\n // Recursively merge objects and arrays (susceptible to call stack limits).\n stack.set(srcValue, objValue);\n baseMerge(objValue, srcValue, undefined, customDefaultsMerge, stack);\n stack['delete'](srcValue);\n }\n return objValue;\n }\n\n /**\n * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain\n * objects.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {string} key The key of the property to inspect.\n * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.\n */\n function customOmitClone(value) {\n return isPlainObject(value) ? undefined : value;\n }\n\n /**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\n function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n arrLength = array.length,\n othLength = other.length;\n\n if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n return false;\n }\n // Check that cyclic values are equal.\n var arrStacked = stack.get(array);\n var othStacked = stack.get(other);\n if (arrStacked && othStacked) {\n return arrStacked == other && othStacked == array;\n }\n var index = -1,\n result = true,\n seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n stack.set(array, other);\n stack.set(other, array);\n\n // Ignore non-index properties.\n while (++index < arrLength) {\n var arrValue = array[index],\n othValue = other[index];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, arrValue, index, other, array, stack)\n : customizer(arrValue, othValue, index, array, other, stack);\n }\n if (compared !== undefined) {\n if (compared) {\n continue;\n }\n result = false;\n break;\n }\n // Recursively compare arrays (susceptible to call stack limits).\n if (seen) {\n if (!arraySome(other, function(othValue, othIndex) {\n if (!cacheHas(seen, othIndex) &&\n (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n return seen.push(othIndex);\n }\n })) {\n result = false;\n break;\n }\n } else if (!(\n arrValue === othValue ||\n equalFunc(arrValue, othValue, bitmask, customizer, stack)\n )) {\n result = false;\n break;\n }\n }\n stack['delete'](array);\n stack['delete'](other);\n return result;\n }\n\n /**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\n function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n switch (tag) {\n case dataViewTag:\n if ((object.byteLength != other.byteLength) ||\n (object.byteOffset != other.byteOffset)) {\n return false;\n }\n object = object.buffer;\n other = other.buffer;\n\n case arrayBufferTag:\n if ((object.byteLength != other.byteLength) ||\n !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n return false;\n }\n return true;\n\n case boolTag:\n case dateTag:\n case numberTag:\n // Coerce booleans to `1` or `0` and dates to milliseconds.\n // Invalid dates are coerced to `NaN`.\n return eq(+object, +other);\n\n case errorTag:\n return object.name == other.name && object.message == other.message;\n\n case regexpTag:\n case stringTag:\n // Coerce regexes to strings and treat strings, primitives and objects,\n // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n // for more details.\n return object == (other + '');\n\n case mapTag:\n var convert = mapToArray;\n\n case setTag:\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n convert || (convert = setToArray);\n\n if (object.size != other.size && !isPartial) {\n return false;\n }\n // Assume cyclic values are equal.\n var stacked = stack.get(object);\n if (stacked) {\n return stacked == other;\n }\n bitmask |= COMPARE_UNORDERED_FLAG;\n\n // Recursively compare objects (susceptible to call stack limits).\n stack.set(object, other);\n var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n stack['delete'](object);\n return result;\n\n case symbolTag:\n if (symbolValueOf) {\n return symbolValueOf.call(object) == symbolValueOf.call(other);\n }\n }\n return false;\n }\n\n /**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\n function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n objProps = getAllKeys(object),\n objLength = objProps.length,\n othProps = getAllKeys(other),\n othLength = othProps.length;\n\n if (objLength != othLength && !isPartial) {\n return false;\n }\n var index = objLength;\n while (index--) {\n var key = objProps[index];\n if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n return false;\n }\n }\n // Check that cyclic values are equal.\n var objStacked = stack.get(object);\n var othStacked = stack.get(other);\n if (objStacked && othStacked) {\n return objStacked == other && othStacked == object;\n }\n var result = true;\n stack.set(object, other);\n stack.set(other, object);\n\n var skipCtor = isPartial;\n while (++index < objLength) {\n key = objProps[index];\n var objValue = object[key],\n othValue = other[key];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, objValue, key, other, object, stack)\n : customizer(objValue, othValue, key, object, other, stack);\n }\n // Recursively compare objects (susceptible to call stack limits).\n if (!(compared === undefined\n ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n : compared\n )) {\n result = false;\n break;\n }\n skipCtor || (skipCtor = key == 'constructor');\n }\n if (result && !skipCtor) {\n var objCtor = object.constructor,\n othCtor = other.constructor;\n\n // Non `Object` object instances with different constructors are not equal.\n if (objCtor != othCtor &&\n ('constructor' in object && 'constructor' in other) &&\n !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n result = false;\n }\n }\n stack['delete'](object);\n stack['delete'](other);\n return result;\n }\n\n /**\n * A specialized version of `baseRest` which flattens the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @returns {Function} Returns the new function.\n */\n function flatRest(func) {\n return setToString(overRest(func, undefined, flatten), func + '');\n }\n\n /**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\n function getAllKeys(object) {\n return baseGetAllKeys(object, keys, getSymbols);\n }\n\n /**\n * Creates an array of own and inherited enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\n function getAllKeysIn(object) {\n return baseGetAllKeys(object, keysIn, getSymbolsIn);\n }\n\n /**\n * Gets metadata for `func`.\n *\n * @private\n * @param {Function} func The function to query.\n * @returns {*} Returns the metadata for `func`.\n */\n var getData = !metaMap ? noop : function(func) {\n return metaMap.get(func);\n };\n\n /**\n * Gets the name of `func`.\n *\n * @private\n * @param {Function} func The function to query.\n * @returns {string} Returns the function name.\n */\n function getFuncName(func) {\n var result = (func.name + ''),\n array = realNames[result],\n length = hasOwnProperty.call(realNames, result) ? array.length : 0;\n\n while (length--) {\n var data = array[length],\n otherFunc = data.func;\n if (otherFunc == null || otherFunc == func) {\n return data.name;\n }\n }\n return result;\n }\n\n /**\n * Gets the argument placeholder value for `func`.\n *\n * @private\n * @param {Function} func The function to inspect.\n * @returns {*} Returns the placeholder value.\n */\n function getHolder(func) {\n var object = hasOwnProperty.call(lodash, 'placeholder') ? lodash : func;\n return object.placeholder;\n }\n\n /**\n * Gets the appropriate \"iteratee\" function. If `_.iteratee` is customized,\n * this function returns the custom method, otherwise it returns `baseIteratee`.\n * If arguments are provided, the chosen function is invoked with them and\n * its result is returned.\n *\n * @private\n * @param {*} [value] The value to convert to an iteratee.\n * @param {number} [arity] The arity of the created iteratee.\n * @returns {Function} Returns the chosen function or its result.\n */\n function getIteratee() {\n var result = lodash.iteratee || iteratee;\n result = result === iteratee ? baseIteratee : result;\n return arguments.length ? result(arguments[0], arguments[1]) : result;\n }\n\n /**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\n function getMapData(map, key) {\n var data = map.__data__;\n return isKeyable(key)\n ? data[typeof key == 'string' ? 'string' : 'hash']\n : data.map;\n }\n\n /**\n * Gets the property names, values, and compare flags of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the match data of `object`.\n */\n function getMatchData(object) {\n var result = keys(object),\n length = result.length;\n\n while (length--) {\n var key = result[length],\n value = object[key];\n\n result[length] = [key, value, isStrictComparable(value)];\n }\n return result;\n }\n\n /**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\n function getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n }\n\n /**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\n function getRawTag(value) {\n var isOwn = hasOwnProperty.call(value, symToStringTag),\n tag = value[symToStringTag];\n\n try {\n value[symToStringTag] = undefined;\n var unmasked = true;\n } catch (e) {}\n\n var result = nativeObjectToString.call(value);\n if (unmasked) {\n if (isOwn) {\n value[symToStringTag] = tag;\n } else {\n delete value[symToStringTag];\n }\n }\n return result;\n }\n\n /**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\n var getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n if (object == null) {\n return [];\n }\n object = Object(object);\n return arrayFilter(nativeGetSymbols(object), function(symbol) {\n return propertyIsEnumerable.call(object, symbol);\n });\n };\n\n /**\n * Creates an array of the own and inherited enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\n var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {\n var result = [];\n while (object) {\n arrayPush(result, getSymbols(object));\n object = getPrototype(object);\n }\n return result;\n };\n\n /**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\n var getTag = baseGetTag;\n\n // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\n if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n (Map && getTag(new Map) != mapTag) ||\n (Promise && getTag(Promise.resolve()) != promiseTag) ||\n (Set && getTag(new Set) != setTag) ||\n (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n getTag = function(value) {\n var result = baseGetTag(value),\n Ctor = result == objectTag ? value.constructor : undefined,\n ctorString = Ctor ? toSource(Ctor) : '';\n\n if (ctorString) {\n switch (ctorString) {\n case dataViewCtorString: return dataViewTag;\n case mapCtorString: return mapTag;\n case promiseCtorString: return promiseTag;\n case setCtorString: return setTag;\n case weakMapCtorString: return weakMapTag;\n }\n }\n return result;\n };\n }\n\n /**\n * Gets the view, applying any `transforms` to the `start` and `end` positions.\n *\n * @private\n * @param {number} start The start of the view.\n * @param {number} end The end of the view.\n * @param {Array} transforms The transformations to apply to the view.\n * @returns {Object} Returns an object containing the `start` and `end`\n * positions of the view.\n */\n function getView(start, end, transforms) {\n var index = -1,\n length = transforms.length;\n\n while (++index < length) {\n var data = transforms[index],\n size = data.size;\n\n switch (data.type) {\n case 'drop': start += size; break;\n case 'dropRight': end -= size; break;\n case 'take': end = nativeMin(end, start + size); break;\n case 'takeRight': start = nativeMax(start, end - size); break;\n }\n }\n return { 'start': start, 'end': end };\n }\n\n /**\n * Extracts wrapper details from the `source` body comment.\n *\n * @private\n * @param {string} source The source to inspect.\n * @returns {Array} Returns the wrapper details.\n */\n function getWrapDetails(source) {\n var match = source.match(reWrapDetails);\n return match ? match[1].split(reSplitDetails) : [];\n }\n\n /**\n * Checks if `path` exists on `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @param {Function} hasFunc The function to check properties.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n */\n function hasPath(object, path, hasFunc) {\n path = castPath(path, object);\n\n var index = -1,\n length = path.length,\n result = false;\n\n while (++index < length) {\n var key = toKey(path[index]);\n if (!(result = object != null && hasFunc(object, key))) {\n break;\n }\n object = object[key];\n }\n if (result || ++index != length) {\n return result;\n }\n length = object == null ? 0 : object.length;\n return !!length && isLength(length) && isIndex(key, length) &&\n (isArray(object) || isArguments(object));\n }\n\n /**\n * Initializes an array clone.\n *\n * @private\n * @param {Array} array The array to clone.\n * @returns {Array} Returns the initialized clone.\n */\n function initCloneArray(array) {\n var length = array.length,\n result = new array.constructor(length);\n\n // Add properties assigned by `RegExp#exec`.\n if (length && typeof array[0] == 'string' && hasOwnProperty.call(array, 'index')) {\n result.index = array.index;\n result.input = array.input;\n }\n return result;\n }\n\n /**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\n function initCloneObject(object) {\n return (typeof object.constructor == 'function' && !isPrototype(object))\n ? baseCreate(getPrototype(object))\n : {};\n }\n\n /**\n * Initializes an object clone based on its `toStringTag`.\n *\n * **Note:** This function only supports cloning values with tags of\n * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.\n *\n * @private\n * @param {Object} object The object to clone.\n * @param {string} tag The `toStringTag` of the object to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the initialized clone.\n */\n function initCloneByTag(object, tag, isDeep) {\n var Ctor = object.constructor;\n switch (tag) {\n case arrayBufferTag:\n return cloneArrayBuffer(object);\n\n case boolTag:\n case dateTag:\n return new Ctor(+object);\n\n case dataViewTag:\n return cloneDataView(object, isDeep);\n\n case float32Tag: case float64Tag:\n case int8Tag: case int16Tag: case int32Tag:\n case uint8Tag: case uint8ClampedTag: case uint16Tag: case uint32Tag:\n return cloneTypedArray(object, isDeep);\n\n case mapTag:\n return new Ctor;\n\n case numberTag:\n case stringTag:\n return new Ctor(object);\n\n case regexpTag:\n return cloneRegExp(object);\n\n case setTag:\n return new Ctor;\n\n case symbolTag:\n return cloneSymbol(object);\n }\n }\n\n /**\n * Inserts wrapper `details` in a comment at the top of the `source` body.\n *\n * @private\n * @param {string} source The source to modify.\n * @returns {Array} details The details to insert.\n * @returns {string} Returns the modified source.\n */\n function insertWrapDetails(source, details) {\n var length = details.length;\n if (!length) {\n return source;\n }\n var lastIndex = length - 1;\n details[lastIndex] = (length > 1 ? '& ' : '') + details[lastIndex];\n details = details.join(length > 2 ? ', ' : ' ');\n return source.replace(reWrapComment, '{\\n/* [wrapped with ' + details + '] */\\n');\n }\n\n /**\n * Checks if `value` is a flattenable `arguments` object or array.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.\n */\n function isFlattenable(value) {\n return isArray(value) || isArguments(value) ||\n !!(spreadableSymbol && value && value[spreadableSymbol]);\n }\n\n /**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\n function isIndex(value, length) {\n var type = typeof value;\n length = length == null ? MAX_SAFE_INTEGER : length;\n\n return !!length &&\n (type == 'number' ||\n (type != 'symbol' && reIsUint.test(value))) &&\n (value > -1 && value % 1 == 0 && value < length);\n }\n\n /**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n * else `false`.\n */\n function isIterateeCall(value, index, object) {\n if (!isObject(object)) {\n return false;\n }\n var type = typeof index;\n if (type == 'number'\n ? (isArrayLike(object) && isIndex(index, object.length))\n : (type == 'string' && index in object)\n ) {\n return eq(object[index], value);\n }\n return false;\n }\n\n /**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\n function isKey(value, object) {\n if (isArray(value)) {\n return false;\n }\n var type = typeof value;\n if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n value == null || isSymbol(value)) {\n return true;\n }\n return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n (object != null && value in Object(object));\n }\n\n /**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\n function isKeyable(value) {\n var type = typeof value;\n return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n ? (value !== '__proto__')\n : (value === null);\n }\n\n /**\n * Checks if `func` has a lazy counterpart.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` has a lazy counterpart,\n * else `false`.\n */\n function isLaziable(func) {\n var funcName = getFuncName(func),\n other = lodash[funcName];\n\n if (typeof other != 'function' || !(funcName in LazyWrapper.prototype)) {\n return false;\n }\n if (func === other) {\n return true;\n }\n var data = getData(other);\n return !!data && func === data[0];\n }\n\n /**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\n function isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n }\n\n /**\n * Checks if `func` is capable of being masked.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `func` is maskable, else `false`.\n */\n var isMaskable = coreJsData ? isFunction : stubFalse;\n\n /**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\n function isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n return value === proto;\n }\n\n /**\n * Checks if `value` is suitable for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` if suitable for strict\n * equality comparisons, else `false`.\n */\n function isStrictComparable(value) {\n return value === value && !isObject(value);\n }\n\n /**\n * A specialized version of `matchesProperty` for source values suitable\n * for strict equality comparisons, i.e. `===`.\n *\n * @private\n * @param {string} key The key of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n */\n function matchesStrictComparable(key, srcValue) {\n return function(object) {\n if (object == null) {\n return false;\n }\n return object[key] === srcValue &&\n (srcValue !== undefined || (key in Object(object)));\n };\n }\n\n /**\n * A specialized version of `_.memoize` which clears the memoized function's\n * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n *\n * @private\n * @param {Function} func The function to have its output memoized.\n * @returns {Function} Returns the new memoized function.\n */\n function memoizeCapped(func) {\n var result = memoize(func, function(key) {\n if (cache.size === MAX_MEMOIZE_SIZE) {\n cache.clear();\n }\n return key;\n });\n\n var cache = result.cache;\n return result;\n }\n\n /**\n * Merges the function metadata of `source` into `data`.\n *\n * Merging metadata reduces the number of wrappers used to invoke a function.\n * This is possible because methods like `_.bind`, `_.curry`, and `_.partial`\n * may be applied regardless of execution order. Methods like `_.ary` and\n * `_.rearg` modify function arguments, making the order in which they are\n * executed important, preventing the merging of metadata. However, we make\n * an exception for a safe combined case where curried functions have `_.ary`\n * and or `_.rearg` applied.\n *\n * @private\n * @param {Array} data The destination metadata.\n * @param {Array} source The source metadata.\n * @returns {Array} Returns `data`.\n */\n function mergeData(data, source) {\n var bitmask = data[1],\n srcBitmask = source[1],\n newBitmask = bitmask | srcBitmask,\n isCommon = newBitmask < (WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG | WRAP_ARY_FLAG);\n\n var isCombo =\n ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_CURRY_FLAG)) ||\n ((srcBitmask == WRAP_ARY_FLAG) && (bitmask == WRAP_REARG_FLAG) && (data[7].length <= source[8])) ||\n ((srcBitmask == (WRAP_ARY_FLAG | WRAP_REARG_FLAG)) && (source[7].length <= source[8]) && (bitmask == WRAP_CURRY_FLAG));\n\n // Exit early if metadata can't be merged.\n if (!(isCommon || isCombo)) {\n return data;\n }\n // Use source `thisArg` if available.\n if (srcBitmask & WRAP_BIND_FLAG) {\n data[2] = source[2];\n // Set when currying a bound function.\n newBitmask |= bitmask & WRAP_BIND_FLAG ? 0 : WRAP_CURRY_BOUND_FLAG;\n }\n // Compose partial arguments.\n var value = source[3];\n if (value) {\n var partials = data[3];\n data[3] = partials ? composeArgs(partials, value, source[4]) : value;\n data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];\n }\n // Compose partial right arguments.\n value = source[5];\n if (value) {\n partials = data[5];\n data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;\n data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];\n }\n // Use source `argPos` if available.\n value = source[7];\n if (value) {\n data[7] = value;\n }\n // Use source `ary` if it's smaller.\n if (srcBitmask & WRAP_ARY_FLAG) {\n data[8] = data[8] == null ? source[8] : nativeMin(data[8], source[8]);\n }\n // Use source `arity` if one is not provided.\n if (data[9] == null) {\n data[9] = source[9];\n }\n // Use source `func` and merge bitmasks.\n data[0] = source[0];\n data[1] = newBitmask;\n\n return data;\n }\n\n /**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\n function nativeKeysIn(object) {\n var result = [];\n if (object != null) {\n for (var key in Object(object)) {\n result.push(key);\n }\n }\n return result;\n }\n\n /**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\n function objectToString(value) {\n return nativeObjectToString.call(value);\n }\n\n /**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\n function overRest(func, start, transform) {\n start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n return function() {\n var args = arguments,\n index = -1,\n length = nativeMax(args.length - start, 0),\n array = Array(length);\n\n while (++index < length) {\n array[index] = args[start + index];\n }\n index = -1;\n var otherArgs = Array(start + 1);\n while (++index < start) {\n otherArgs[index] = args[index];\n }\n otherArgs[start] = transform(array);\n return apply(func, this, otherArgs);\n };\n }\n\n /**\n * Gets the parent value at `path` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array} path The path to get the parent value of.\n * @returns {*} Returns the parent value.\n */\n function parent(object, path) {\n return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));\n }\n\n /**\n * Reorder `array` according to the specified indexes where the element at\n * the first index is assigned as the first element, the element at\n * the second index is assigned as the second element, and so on.\n *\n * @private\n * @param {Array} array The array to reorder.\n * @param {Array} indexes The arranged array indexes.\n * @returns {Array} Returns `array`.\n */\n function reorder(array, indexes) {\n var arrLength = array.length,\n length = nativeMin(indexes.length, arrLength),\n oldArray = copyArray(array);\n\n while (length--) {\n var index = indexes[length];\n array[length] = isIndex(index, arrLength) ? oldArray[index] : undefined;\n }\n return array;\n }\n\n /**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\n function safeGet(object, key) {\n if (key === 'constructor' && typeof object[key] === 'function') {\n return;\n }\n\n if (key == '__proto__') {\n return;\n }\n\n return object[key];\n }\n\n /**\n * Sets metadata for `func`.\n *\n * **Note:** If this function becomes hot, i.e. is invoked a lot in a short\n * period of time, it will trip its breaker and transition to an identity\n * function to avoid garbage collection pauses in V8. See\n * [V8 issue 2070](https://bugs.chromium.org/p/v8/issues/detail?id=2070)\n * for more details.\n *\n * @private\n * @param {Function} func The function to associate metadata with.\n * @param {*} data The metadata.\n * @returns {Function} Returns `func`.\n */\n var setData = shortOut(baseSetData);\n\n /**\n * A simple wrapper around the global [`setTimeout`](https://mdn.io/setTimeout).\n *\n * @private\n * @param {Function} func The function to delay.\n * @param {number} wait The number of milliseconds to delay invocation.\n * @returns {number|Object} Returns the timer id or timeout object.\n */\n var setTimeout = ctxSetTimeout || function(func, wait) {\n return root.setTimeout(func, wait);\n };\n\n /**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\n var setToString = shortOut(baseSetToString);\n\n /**\n * Sets the `toString` method of `wrapper` to mimic the source of `reference`\n * with wrapper details in a comment at the top of the source body.\n *\n * @private\n * @param {Function} wrapper The function to modify.\n * @param {Function} reference The reference function.\n * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n * @returns {Function} Returns `wrapper`.\n */\n function setWrapToString(wrapper, reference, bitmask) {\n var source = (reference + '');\n return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));\n }\n\n /**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\n function shortOut(func) {\n var count = 0,\n lastCalled = 0;\n\n return function() {\n var stamp = nativeNow(),\n remaining = HOT_SPAN - (stamp - lastCalled);\n\n lastCalled = stamp;\n if (remaining > 0) {\n if (++count >= HOT_COUNT) {\n return arguments[0];\n }\n } else {\n count = 0;\n }\n return func.apply(undefined, arguments);\n };\n }\n\n /**\n * A specialized version of `_.shuffle` which mutates and sets the size of `array`.\n *\n * @private\n * @param {Array} array The array to shuffle.\n * @param {number} [size=array.length] The size of `array`.\n * @returns {Array} Returns `array`.\n */\n function shuffleSelf(array, size) {\n var index = -1,\n length = array.length,\n lastIndex = length - 1;\n\n size = size === undefined ? length : size;\n while (++index < size) {\n var rand = baseRandom(index, lastIndex),\n value = array[rand];\n\n array[rand] = array[index];\n array[index] = value;\n }\n array.length = size;\n return array;\n }\n\n /**\n * Converts `string` to a property path array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the property path array.\n */\n var stringToPath = memoizeCapped(function(string) {\n var result = [];\n if (string.charCodeAt(0) === 46 /* . */) {\n result.push('');\n }\n string.replace(rePropName, function(match, number, quote, subString) {\n result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));\n });\n return result;\n });\n\n /**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\n function toKey(value) {\n if (typeof value == 'string' || isSymbol(value)) {\n return value;\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n }\n\n /**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\n function toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n }\n\n /**\n * Updates wrapper `details` based on `bitmask` flags.\n *\n * @private\n * @returns {Array} details The details to modify.\n * @param {number} bitmask The bitmask flags. See `createWrap` for more details.\n * @returns {Array} Returns `details`.\n */\n function updateWrapDetails(details, bitmask) {\n arrayEach(wrapFlags, function(pair) {\n var value = '_.' + pair[0];\n if ((bitmask & pair[1]) && !arrayIncludes(details, value)) {\n details.push(value);\n }\n });\n return details.sort();\n }\n\n /**\n * Creates a clone of `wrapper`.\n *\n * @private\n * @param {Object} wrapper The wrapper to clone.\n * @returns {Object} Returns the cloned wrapper.\n */\n function wrapperClone(wrapper) {\n if (wrapper instanceof LazyWrapper) {\n return wrapper.clone();\n }\n var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);\n result.__actions__ = copyArray(wrapper.__actions__);\n result.__index__ = wrapper.__index__;\n result.__values__ = wrapper.__values__;\n return result;\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates an array of elements split into groups the length of `size`.\n * If `array` can't be split evenly, the final chunk will be the remaining\n * elements.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to process.\n * @param {number} [size=1] The length of each chunk\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the new array of chunks.\n * @example\n *\n * _.chunk(['a', 'b', 'c', 'd'], 2);\n * // => [['a', 'b'], ['c', 'd']]\n *\n * _.chunk(['a', 'b', 'c', 'd'], 3);\n * // => [['a', 'b', 'c'], ['d']]\n */\n function chunk(array, size, guard) {\n if ((guard ? isIterateeCall(array, size, guard) : size === undefined)) {\n size = 1;\n } else {\n size = nativeMax(toInteger(size), 0);\n }\n var length = array == null ? 0 : array.length;\n if (!length || size < 1) {\n return [];\n }\n var index = 0,\n resIndex = 0,\n result = Array(nativeCeil(length / size));\n\n while (index < length) {\n result[resIndex++] = baseSlice(array, index, (index += size));\n }\n return result;\n }\n\n /**\n * Creates an array with all falsey values removed. The values `false`, `null`,\n * `0`, `\"\"`, `undefined`, and `NaN` are falsey.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to compact.\n * @returns {Array} Returns the new array of filtered values.\n * @example\n *\n * _.compact([0, 1, false, 2, '', 3]);\n * // => [1, 2, 3]\n */\n function compact(array) {\n var index = -1,\n length = array == null ? 0 : array.length,\n resIndex = 0,\n result = [];\n\n while (++index < length) {\n var value = array[index];\n if (value) {\n result[resIndex++] = value;\n }\n }\n return result;\n }\n\n /**\n * Creates a new array concatenating `array` with any additional arrays\n * and/or values.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to concatenate.\n * @param {...*} [values] The values to concatenate.\n * @returns {Array} Returns the new concatenated array.\n * @example\n *\n * var array = [1];\n * var other = _.concat(array, 2, [3], [[4]]);\n *\n * console.log(other);\n * // => [1, 2, 3, [4]]\n *\n * console.log(array);\n * // => [1]\n */\n function concat() {\n var length = arguments.length;\n if (!length) {\n return [];\n }\n var args = Array(length - 1),\n array = arguments[0],\n index = length;\n\n while (index--) {\n args[index - 1] = arguments[index];\n }\n return arrayPush(isArray(array) ? copyArray(array) : [array], baseFlatten(args, 1));\n }\n\n /**\n * Creates an array of `array` values not included in the other given arrays\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons. The order and references of result values are\n * determined by the first array.\n *\n * **Note:** Unlike `_.pullAll`, this method returns a new array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {...Array} [values] The values to exclude.\n * @returns {Array} Returns the new array of filtered values.\n * @see _.without, _.xor\n * @example\n *\n * _.difference([2, 1], [2, 3]);\n * // => [1]\n */\n var difference = baseRest(function(array, values) {\n return isArrayLikeObject(array)\n ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true))\n : [];\n });\n\n /**\n * This method is like `_.difference` except that it accepts `iteratee` which\n * is invoked for each element of `array` and `values` to generate the criterion\n * by which they're compared. The order and references of result values are\n * determined by the first array. The iteratee is invoked with one argument:\n * (value).\n *\n * **Note:** Unlike `_.pullAllBy`, this method returns a new array.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {...Array} [values] The values to exclude.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns the new array of filtered values.\n * @example\n *\n * _.differenceBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n * // => [1.2]\n *\n * // The `_.property` iteratee shorthand.\n * _.differenceBy([{ 'x': 2 }, { 'x': 1 }], [{ 'x': 1 }], 'x');\n * // => [{ 'x': 2 }]\n */\n var differenceBy = baseRest(function(array, values) {\n var iteratee = last(values);\n if (isArrayLikeObject(iteratee)) {\n iteratee = undefined;\n }\n return isArrayLikeObject(array)\n ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), getIteratee(iteratee, 2))\n : [];\n });\n\n /**\n * This method is like `_.difference` except that it accepts `comparator`\n * which is invoked to compare elements of `array` to `values`. The order and\n * references of result values are determined by the first array. The comparator\n * is invoked with two arguments: (arrVal, othVal).\n *\n * **Note:** Unlike `_.pullAllWith`, this method returns a new array.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {...Array} [values] The values to exclude.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of filtered values.\n * @example\n *\n * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n *\n * _.differenceWith(objects, [{ 'x': 1, 'y': 2 }], _.isEqual);\n * // => [{ 'x': 2, 'y': 1 }]\n */\n var differenceWith = baseRest(function(array, values) {\n var comparator = last(values);\n if (isArrayLikeObject(comparator)) {\n comparator = undefined;\n }\n return isArrayLikeObject(array)\n ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), undefined, comparator)\n : [];\n });\n\n /**\n * Creates a slice of `array` with `n` elements dropped from the beginning.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {number} [n=1] The number of elements to drop.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.drop([1, 2, 3]);\n * // => [2, 3]\n *\n * _.drop([1, 2, 3], 2);\n * // => [3]\n *\n * _.drop([1, 2, 3], 5);\n * // => []\n *\n * _.drop([1, 2, 3], 0);\n * // => [1, 2, 3]\n */\n function drop(array, n, guard) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return [];\n }\n n = (guard || n === undefined) ? 1 : toInteger(n);\n return baseSlice(array, n < 0 ? 0 : n, length);\n }\n\n /**\n * Creates a slice of `array` with `n` elements dropped from the end.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {number} [n=1] The number of elements to drop.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.dropRight([1, 2, 3]);\n * // => [1, 2]\n *\n * _.dropRight([1, 2, 3], 2);\n * // => [1]\n *\n * _.dropRight([1, 2, 3], 5);\n * // => []\n *\n * _.dropRight([1, 2, 3], 0);\n * // => [1, 2, 3]\n */\n function dropRight(array, n, guard) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return [];\n }\n n = (guard || n === undefined) ? 1 : toInteger(n);\n n = length - n;\n return baseSlice(array, 0, n < 0 ? 0 : n);\n }\n\n /**\n * Creates a slice of `array` excluding elements dropped from the end.\n * Elements are dropped until `predicate` returns falsey. The predicate is\n * invoked with three arguments: (value, index, array).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'active': true },\n * { 'user': 'fred', 'active': false },\n * { 'user': 'pebbles', 'active': false }\n * ];\n *\n * _.dropRightWhile(users, function(o) { return !o.active; });\n * // => objects for ['barney']\n *\n * // The `_.matches` iteratee shorthand.\n * _.dropRightWhile(users, { 'user': 'pebbles', 'active': false });\n * // => objects for ['barney', 'fred']\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.dropRightWhile(users, ['active', false]);\n * // => objects for ['barney']\n *\n * // The `_.property` iteratee shorthand.\n * _.dropRightWhile(users, 'active');\n * // => objects for ['barney', 'fred', 'pebbles']\n */\n function dropRightWhile(array, predicate) {\n return (array && array.length)\n ? baseWhile(array, getIteratee(predicate, 3), true, true)\n : [];\n }\n\n /**\n * Creates a slice of `array` excluding elements dropped from the beginning.\n * Elements are dropped until `predicate` returns falsey. The predicate is\n * invoked with three arguments: (value, index, array).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'active': false },\n * { 'user': 'fred', 'active': false },\n * { 'user': 'pebbles', 'active': true }\n * ];\n *\n * _.dropWhile(users, function(o) { return !o.active; });\n * // => objects for ['pebbles']\n *\n * // The `_.matches` iteratee shorthand.\n * _.dropWhile(users, { 'user': 'barney', 'active': false });\n * // => objects for ['fred', 'pebbles']\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.dropWhile(users, ['active', false]);\n * // => objects for ['pebbles']\n *\n * // The `_.property` iteratee shorthand.\n * _.dropWhile(users, 'active');\n * // => objects for ['barney', 'fred', 'pebbles']\n */\n function dropWhile(array, predicate) {\n return (array && array.length)\n ? baseWhile(array, getIteratee(predicate, 3), true)\n : [];\n }\n\n /**\n * Fills elements of `array` with `value` from `start` up to, but not\n * including, `end`.\n *\n * **Note:** This method mutates `array`.\n *\n * @static\n * @memberOf _\n * @since 3.2.0\n * @category Array\n * @param {Array} array The array to fill.\n * @param {*} value The value to fill `array` with.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns `array`.\n * @example\n *\n * var array = [1, 2, 3];\n *\n * _.fill(array, 'a');\n * console.log(array);\n * // => ['a', 'a', 'a']\n *\n * _.fill(Array(3), 2);\n * // => [2, 2, 2]\n *\n * _.fill([4, 6, 8, 10], '*', 1, 3);\n * // => [4, '*', '*', 10]\n */\n function fill(array, value, start, end) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return [];\n }\n if (start && typeof start != 'number' && isIterateeCall(array, value, start)) {\n start = 0;\n end = length;\n }\n return baseFill(array, value, start, end);\n }\n\n /**\n * This method is like `_.find` except that it returns the index of the first\n * element `predicate` returns truthy for instead of the element itself.\n *\n * @static\n * @memberOf _\n * @since 1.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param {number} [fromIndex=0] The index to search from.\n * @returns {number} Returns the index of the found element, else `-1`.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'active': false },\n * { 'user': 'fred', 'active': false },\n * { 'user': 'pebbles', 'active': true }\n * ];\n *\n * _.findIndex(users, function(o) { return o.user == 'barney'; });\n * // => 0\n *\n * // The `_.matches` iteratee shorthand.\n * _.findIndex(users, { 'user': 'fred', 'active': false });\n * // => 1\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.findIndex(users, ['active', false]);\n * // => 0\n *\n * // The `_.property` iteratee shorthand.\n * _.findIndex(users, 'active');\n * // => 2\n */\n function findIndex(array, predicate, fromIndex) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return -1;\n }\n var index = fromIndex == null ? 0 : toInteger(fromIndex);\n if (index < 0) {\n index = nativeMax(length + index, 0);\n }\n return baseFindIndex(array, getIteratee(predicate, 3), index);\n }\n\n /**\n * This method is like `_.findIndex` except that it iterates over elements\n * of `collection` from right to left.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param {number} [fromIndex=array.length-1] The index to search from.\n * @returns {number} Returns the index of the found element, else `-1`.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'active': true },\n * { 'user': 'fred', 'active': false },\n * { 'user': 'pebbles', 'active': false }\n * ];\n *\n * _.findLastIndex(users, function(o) { return o.user == 'pebbles'; });\n * // => 2\n *\n * // The `_.matches` iteratee shorthand.\n * _.findLastIndex(users, { 'user': 'barney', 'active': true });\n * // => 0\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.findLastIndex(users, ['active', false]);\n * // => 2\n *\n * // The `_.property` iteratee shorthand.\n * _.findLastIndex(users, 'active');\n * // => 0\n */\n function findLastIndex(array, predicate, fromIndex) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return -1;\n }\n var index = length - 1;\n if (fromIndex !== undefined) {\n index = toInteger(fromIndex);\n index = fromIndex < 0\n ? nativeMax(length + index, 0)\n : nativeMin(index, length - 1);\n }\n return baseFindIndex(array, getIteratee(predicate, 3), index, true);\n }\n\n /**\n * Flattens `array` a single level deep.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to flatten.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * _.flatten([1, [2, [3, [4]], 5]]);\n * // => [1, 2, [3, [4]], 5]\n */\n function flatten(array) {\n var length = array == null ? 0 : array.length;\n return length ? baseFlatten(array, 1) : [];\n }\n\n /**\n * Recursively flattens `array`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to flatten.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * _.flattenDeep([1, [2, [3, [4]], 5]]);\n * // => [1, 2, 3, 4, 5]\n */\n function flattenDeep(array) {\n var length = array == null ? 0 : array.length;\n return length ? baseFlatten(array, INFINITY) : [];\n }\n\n /**\n * Recursively flatten `array` up to `depth` times.\n *\n * @static\n * @memberOf _\n * @since 4.4.0\n * @category Array\n * @param {Array} array The array to flatten.\n * @param {number} [depth=1] The maximum recursion depth.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * var array = [1, [2, [3, [4]], 5]];\n *\n * _.flattenDepth(array, 1);\n * // => [1, 2, [3, [4]], 5]\n *\n * _.flattenDepth(array, 2);\n * // => [1, 2, 3, [4], 5]\n */\n function flattenDepth(array, depth) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return [];\n }\n depth = depth === undefined ? 1 : toInteger(depth);\n return baseFlatten(array, depth);\n }\n\n /**\n * The inverse of `_.toPairs`; this method returns an object composed\n * from key-value `pairs`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} pairs The key-value pairs.\n * @returns {Object} Returns the new object.\n * @example\n *\n * _.fromPairs([['a', 1], ['b', 2]]);\n * // => { 'a': 1, 'b': 2 }\n */\n function fromPairs(pairs) {\n var index = -1,\n length = pairs == null ? 0 : pairs.length,\n result = {};\n\n while (++index < length) {\n var pair = pairs[index];\n result[pair[0]] = pair[1];\n }\n return result;\n }\n\n /**\n * Gets the first element of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @alias first\n * @category Array\n * @param {Array} array The array to query.\n * @returns {*} Returns the first element of `array`.\n * @example\n *\n * _.head([1, 2, 3]);\n * // => 1\n *\n * _.head([]);\n * // => undefined\n */\n function head(array) {\n return (array && array.length) ? array[0] : undefined;\n }\n\n /**\n * Gets the index at which the first occurrence of `value` is found in `array`\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons. If `fromIndex` is negative, it's used as the\n * offset from the end of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} [fromIndex=0] The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n * @example\n *\n * _.indexOf([1, 2, 1, 2], 2);\n * // => 1\n *\n * // Search from the `fromIndex`.\n * _.indexOf([1, 2, 1, 2], 2, 2);\n * // => 3\n */\n function indexOf(array, value, fromIndex) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return -1;\n }\n var index = fromIndex == null ? 0 : toInteger(fromIndex);\n if (index < 0) {\n index = nativeMax(length + index, 0);\n }\n return baseIndexOf(array, value, index);\n }\n\n /**\n * Gets all but the last element of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to query.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.initial([1, 2, 3]);\n * // => [1, 2]\n */\n function initial(array) {\n var length = array == null ? 0 : array.length;\n return length ? baseSlice(array, 0, -1) : [];\n }\n\n /**\n * Creates an array of unique values that are included in all given arrays\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons. The order and references of result values are\n * determined by the first array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @returns {Array} Returns the new array of intersecting values.\n * @example\n *\n * _.intersection([2, 1], [2, 3]);\n * // => [2]\n */\n var intersection = baseRest(function(arrays) {\n var mapped = arrayMap(arrays, castArrayLikeObject);\n return (mapped.length && mapped[0] === arrays[0])\n ? baseIntersection(mapped)\n : [];\n });\n\n /**\n * This method is like `_.intersection` except that it accepts `iteratee`\n * which is invoked for each element of each `arrays` to generate the criterion\n * by which they're compared. The order and references of result values are\n * determined by the first array. The iteratee is invoked with one argument:\n * (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns the new array of intersecting values.\n * @example\n *\n * _.intersectionBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n * // => [2.1]\n *\n * // The `_.property` iteratee shorthand.\n * _.intersectionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n * // => [{ 'x': 1 }]\n */\n var intersectionBy = baseRest(function(arrays) {\n var iteratee = last(arrays),\n mapped = arrayMap(arrays, castArrayLikeObject);\n\n if (iteratee === last(mapped)) {\n iteratee = undefined;\n } else {\n mapped.pop();\n }\n return (mapped.length && mapped[0] === arrays[0])\n ? baseIntersection(mapped, getIteratee(iteratee, 2))\n : [];\n });\n\n /**\n * This method is like `_.intersection` except that it accepts `comparator`\n * which is invoked to compare elements of `arrays`. The order and references\n * of result values are determined by the first array. The comparator is\n * invoked with two arguments: (arrVal, othVal).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of intersecting values.\n * @example\n *\n * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n *\n * _.intersectionWith(objects, others, _.isEqual);\n * // => [{ 'x': 1, 'y': 2 }]\n */\n var intersectionWith = baseRest(function(arrays) {\n var comparator = last(arrays),\n mapped = arrayMap(arrays, castArrayLikeObject);\n\n comparator = typeof comparator == 'function' ? comparator : undefined;\n if (comparator) {\n mapped.pop();\n }\n return (mapped.length && mapped[0] === arrays[0])\n ? baseIntersection(mapped, undefined, comparator)\n : [];\n });\n\n /**\n * Converts all elements in `array` into a string separated by `separator`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to convert.\n * @param {string} [separator=','] The element separator.\n * @returns {string} Returns the joined string.\n * @example\n *\n * _.join(['a', 'b', 'c'], '~');\n * // => 'a~b~c'\n */\n function join(array, separator) {\n return array == null ? '' : nativeJoin.call(array, separator);\n }\n\n /**\n * Gets the last element of `array`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to query.\n * @returns {*} Returns the last element of `array`.\n * @example\n *\n * _.last([1, 2, 3]);\n * // => 3\n */\n function last(array) {\n var length = array == null ? 0 : array.length;\n return length ? array[length - 1] : undefined;\n }\n\n /**\n * This method is like `_.indexOf` except that it iterates over elements of\n * `array` from right to left.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @param {number} [fromIndex=array.length-1] The index to search from.\n * @returns {number} Returns the index of the matched value, else `-1`.\n * @example\n *\n * _.lastIndexOf([1, 2, 1, 2], 2);\n * // => 3\n *\n * // Search from the `fromIndex`.\n * _.lastIndexOf([1, 2, 1, 2], 2, 2);\n * // => 1\n */\n function lastIndexOf(array, value, fromIndex) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return -1;\n }\n var index = length;\n if (fromIndex !== undefined) {\n index = toInteger(fromIndex);\n index = index < 0 ? nativeMax(length + index, 0) : nativeMin(index, length - 1);\n }\n return value === value\n ? strictLastIndexOf(array, value, index)\n : baseFindIndex(array, baseIsNaN, index, true);\n }\n\n /**\n * Gets the element at index `n` of `array`. If `n` is negative, the nth\n * element from the end is returned.\n *\n * @static\n * @memberOf _\n * @since 4.11.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {number} [n=0] The index of the element to return.\n * @returns {*} Returns the nth element of `array`.\n * @example\n *\n * var array = ['a', 'b', 'c', 'd'];\n *\n * _.nth(array, 1);\n * // => 'b'\n *\n * _.nth(array, -2);\n * // => 'c';\n */\n function nth(array, n) {\n return (array && array.length) ? baseNth(array, toInteger(n)) : undefined;\n }\n\n /**\n * Removes all given values from `array` using\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * **Note:** Unlike `_.without`, this method mutates `array`. Use `_.remove`\n * to remove elements from an array by predicate.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Array\n * @param {Array} array The array to modify.\n * @param {...*} [values] The values to remove.\n * @returns {Array} Returns `array`.\n * @example\n *\n * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n *\n * _.pull(array, 'a', 'c');\n * console.log(array);\n * // => ['b', 'b']\n */\n var pull = baseRest(pullAll);\n\n /**\n * This method is like `_.pull` except that it accepts an array of values to remove.\n *\n * **Note:** Unlike `_.difference`, this method mutates `array`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to modify.\n * @param {Array} values The values to remove.\n * @returns {Array} Returns `array`.\n * @example\n *\n * var array = ['a', 'b', 'c', 'a', 'b', 'c'];\n *\n * _.pullAll(array, ['a', 'c']);\n * console.log(array);\n * // => ['b', 'b']\n */\n function pullAll(array, values) {\n return (array && array.length && values && values.length)\n ? basePullAll(array, values)\n : array;\n }\n\n /**\n * This method is like `_.pullAll` except that it accepts `iteratee` which is\n * invoked for each element of `array` and `values` to generate the criterion\n * by which they're compared. The iteratee is invoked with one argument: (value).\n *\n * **Note:** Unlike `_.differenceBy`, this method mutates `array`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to modify.\n * @param {Array} values The values to remove.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns `array`.\n * @example\n *\n * var array = [{ 'x': 1 }, { 'x': 2 }, { 'x': 3 }, { 'x': 1 }];\n *\n * _.pullAllBy(array, [{ 'x': 1 }, { 'x': 3 }], 'x');\n * console.log(array);\n * // => [{ 'x': 2 }]\n */\n function pullAllBy(array, values, iteratee) {\n return (array && array.length && values && values.length)\n ? basePullAll(array, values, getIteratee(iteratee, 2))\n : array;\n }\n\n /**\n * This method is like `_.pullAll` except that it accepts `comparator` which\n * is invoked to compare elements of `array` to `values`. The comparator is\n * invoked with two arguments: (arrVal, othVal).\n *\n * **Note:** Unlike `_.differenceWith`, this method mutates `array`.\n *\n * @static\n * @memberOf _\n * @since 4.6.0\n * @category Array\n * @param {Array} array The array to modify.\n * @param {Array} values The values to remove.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns `array`.\n * @example\n *\n * var array = [{ 'x': 1, 'y': 2 }, { 'x': 3, 'y': 4 }, { 'x': 5, 'y': 6 }];\n *\n * _.pullAllWith(array, [{ 'x': 3, 'y': 4 }], _.isEqual);\n * console.log(array);\n * // => [{ 'x': 1, 'y': 2 }, { 'x': 5, 'y': 6 }]\n */\n function pullAllWith(array, values, comparator) {\n return (array && array.length && values && values.length)\n ? basePullAll(array, values, undefined, comparator)\n : array;\n }\n\n /**\n * Removes elements from `array` corresponding to `indexes` and returns an\n * array of removed elements.\n *\n * **Note:** Unlike `_.at`, this method mutates `array`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to modify.\n * @param {...(number|number[])} [indexes] The indexes of elements to remove.\n * @returns {Array} Returns the new array of removed elements.\n * @example\n *\n * var array = ['a', 'b', 'c', 'd'];\n * var pulled = _.pullAt(array, [1, 3]);\n *\n * console.log(array);\n * // => ['a', 'c']\n *\n * console.log(pulled);\n * // => ['b', 'd']\n */\n var pullAt = flatRest(function(array, indexes) {\n var length = array == null ? 0 : array.length,\n result = baseAt(array, indexes);\n\n basePullAt(array, arrayMap(indexes, function(index) {\n return isIndex(index, length) ? +index : index;\n }).sort(compareAscending));\n\n return result;\n });\n\n /**\n * Removes all elements from `array` that `predicate` returns truthy for\n * and returns an array of the removed elements. The predicate is invoked\n * with three arguments: (value, index, array).\n *\n * **Note:** Unlike `_.filter`, this method mutates `array`. Use `_.pull`\n * to pull elements from an array by value.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Array\n * @param {Array} array The array to modify.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new array of removed elements.\n * @example\n *\n * var array = [1, 2, 3, 4];\n * var evens = _.remove(array, function(n) {\n * return n % 2 == 0;\n * });\n *\n * console.log(array);\n * // => [1, 3]\n *\n * console.log(evens);\n * // => [2, 4]\n */\n function remove(array, predicate) {\n var result = [];\n if (!(array && array.length)) {\n return result;\n }\n var index = -1,\n indexes = [],\n length = array.length;\n\n predicate = getIteratee(predicate, 3);\n while (++index < length) {\n var value = array[index];\n if (predicate(value, index, array)) {\n result.push(value);\n indexes.push(index);\n }\n }\n basePullAt(array, indexes);\n return result;\n }\n\n /**\n * Reverses `array` so that the first element becomes the last, the second\n * element becomes the second to last, and so on.\n *\n * **Note:** This method mutates `array` and is based on\n * [`Array#reverse`](https://mdn.io/Array/reverse).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to modify.\n * @returns {Array} Returns `array`.\n * @example\n *\n * var array = [1, 2, 3];\n *\n * _.reverse(array);\n * // => [3, 2, 1]\n *\n * console.log(array);\n * // => [3, 2, 1]\n */\n function reverse(array) {\n return array == null ? array : nativeReverse.call(array);\n }\n\n /**\n * Creates a slice of `array` from `start` up to, but not including, `end`.\n *\n * **Note:** This method is used instead of\n * [`Array#slice`](https://mdn.io/Array/slice) to ensure dense arrays are\n * returned.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to slice.\n * @param {number} [start=0] The start position.\n * @param {number} [end=array.length] The end position.\n * @returns {Array} Returns the slice of `array`.\n */\n function slice(array, start, end) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return [];\n }\n if (end && typeof end != 'number' && isIterateeCall(array, start, end)) {\n start = 0;\n end = length;\n }\n else {\n start = start == null ? 0 : toInteger(start);\n end = end === undefined ? length : toInteger(end);\n }\n return baseSlice(array, start, end);\n }\n\n /**\n * Uses a binary search to determine the lowest index at which `value`\n * should be inserted into `array` in order to maintain its sort order.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The sorted array to inspect.\n * @param {*} value The value to evaluate.\n * @returns {number} Returns the index at which `value` should be inserted\n * into `array`.\n * @example\n *\n * _.sortedIndex([30, 50], 40);\n * // => 1\n */\n function sortedIndex(array, value) {\n return baseSortedIndex(array, value);\n }\n\n /**\n * This method is like `_.sortedIndex` except that it accepts `iteratee`\n * which is invoked for `value` and each element of `array` to compute their\n * sort ranking. The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The sorted array to inspect.\n * @param {*} value The value to evaluate.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {number} Returns the index at which `value` should be inserted\n * into `array`.\n * @example\n *\n * var objects = [{ 'x': 4 }, { 'x': 5 }];\n *\n * _.sortedIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n * // => 0\n *\n * // The `_.property` iteratee shorthand.\n * _.sortedIndexBy(objects, { 'x': 4 }, 'x');\n * // => 0\n */\n function sortedIndexBy(array, value, iteratee) {\n return baseSortedIndexBy(array, value, getIteratee(iteratee, 2));\n }\n\n /**\n * This method is like `_.indexOf` except that it performs a binary\n * search on a sorted `array`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n * @example\n *\n * _.sortedIndexOf([4, 5, 5, 5, 6], 5);\n * // => 1\n */\n function sortedIndexOf(array, value) {\n var length = array == null ? 0 : array.length;\n if (length) {\n var index = baseSortedIndex(array, value);\n if (index < length && eq(array[index], value)) {\n return index;\n }\n }\n return -1;\n }\n\n /**\n * This method is like `_.sortedIndex` except that it returns the highest\n * index at which `value` should be inserted into `array` in order to\n * maintain its sort order.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The sorted array to inspect.\n * @param {*} value The value to evaluate.\n * @returns {number} Returns the index at which `value` should be inserted\n * into `array`.\n * @example\n *\n * _.sortedLastIndex([4, 5, 5, 5, 6], 5);\n * // => 4\n */\n function sortedLastIndex(array, value) {\n return baseSortedIndex(array, value, true);\n }\n\n /**\n * This method is like `_.sortedLastIndex` except that it accepts `iteratee`\n * which is invoked for `value` and each element of `array` to compute their\n * sort ranking. The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The sorted array to inspect.\n * @param {*} value The value to evaluate.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {number} Returns the index at which `value` should be inserted\n * into `array`.\n * @example\n *\n * var objects = [{ 'x': 4 }, { 'x': 5 }];\n *\n * _.sortedLastIndexBy(objects, { 'x': 4 }, function(o) { return o.x; });\n * // => 1\n *\n * // The `_.property` iteratee shorthand.\n * _.sortedLastIndexBy(objects, { 'x': 4 }, 'x');\n * // => 1\n */\n function sortedLastIndexBy(array, value, iteratee) {\n return baseSortedIndexBy(array, value, getIteratee(iteratee, 2), true);\n }\n\n /**\n * This method is like `_.lastIndexOf` except that it performs a binary\n * search on a sorted `array`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {*} value The value to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n * @example\n *\n * _.sortedLastIndexOf([4, 5, 5, 5, 6], 5);\n * // => 3\n */\n function sortedLastIndexOf(array, value) {\n var length = array == null ? 0 : array.length;\n if (length) {\n var index = baseSortedIndex(array, value, true) - 1;\n if (eq(array[index], value)) {\n return index;\n }\n }\n return -1;\n }\n\n /**\n * This method is like `_.uniq` except that it's designed and optimized\n * for sorted arrays.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * _.sortedUniq([1, 1, 2]);\n * // => [1, 2]\n */\n function sortedUniq(array) {\n return (array && array.length)\n ? baseSortedUniq(array)\n : [];\n }\n\n /**\n * This method is like `_.uniqBy` except that it's designed and optimized\n * for sorted arrays.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee] The iteratee invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * _.sortedUniqBy([1.1, 1.2, 2.3, 2.4], Math.floor);\n * // => [1.1, 2.3]\n */\n function sortedUniqBy(array, iteratee) {\n return (array && array.length)\n ? baseSortedUniq(array, getIteratee(iteratee, 2))\n : [];\n }\n\n /**\n * Gets all but the first element of `array`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.tail([1, 2, 3]);\n * // => [2, 3]\n */\n function tail(array) {\n var length = array == null ? 0 : array.length;\n return length ? baseSlice(array, 1, length) : [];\n }\n\n /**\n * Creates a slice of `array` with `n` elements taken from the beginning.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {number} [n=1] The number of elements to take.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.take([1, 2, 3]);\n * // => [1]\n *\n * _.take([1, 2, 3], 2);\n * // => [1, 2]\n *\n * _.take([1, 2, 3], 5);\n * // => [1, 2, 3]\n *\n * _.take([1, 2, 3], 0);\n * // => []\n */\n function take(array, n, guard) {\n if (!(array && array.length)) {\n return [];\n }\n n = (guard || n === undefined) ? 1 : toInteger(n);\n return baseSlice(array, 0, n < 0 ? 0 : n);\n }\n\n /**\n * Creates a slice of `array` with `n` elements taken from the end.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {number} [n=1] The number of elements to take.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * _.takeRight([1, 2, 3]);\n * // => [3]\n *\n * _.takeRight([1, 2, 3], 2);\n * // => [2, 3]\n *\n * _.takeRight([1, 2, 3], 5);\n * // => [1, 2, 3]\n *\n * _.takeRight([1, 2, 3], 0);\n * // => []\n */\n function takeRight(array, n, guard) {\n var length = array == null ? 0 : array.length;\n if (!length) {\n return [];\n }\n n = (guard || n === undefined) ? 1 : toInteger(n);\n n = length - n;\n return baseSlice(array, n < 0 ? 0 : n, length);\n }\n\n /**\n * Creates a slice of `array` with elements taken from the end. Elements are\n * taken until `predicate` returns falsey. The predicate is invoked with\n * three arguments: (value, index, array).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'active': true },\n * { 'user': 'fred', 'active': false },\n * { 'user': 'pebbles', 'active': false }\n * ];\n *\n * _.takeRightWhile(users, function(o) { return !o.active; });\n * // => objects for ['fred', 'pebbles']\n *\n * // The `_.matches` iteratee shorthand.\n * _.takeRightWhile(users, { 'user': 'pebbles', 'active': false });\n * // => objects for ['pebbles']\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.takeRightWhile(users, ['active', false]);\n * // => objects for ['fred', 'pebbles']\n *\n * // The `_.property` iteratee shorthand.\n * _.takeRightWhile(users, 'active');\n * // => []\n */\n function takeRightWhile(array, predicate) {\n return (array && array.length)\n ? baseWhile(array, getIteratee(predicate, 3), false, true)\n : [];\n }\n\n /**\n * Creates a slice of `array` with elements taken from the beginning. Elements\n * are taken until `predicate` returns falsey. The predicate is invoked with\n * three arguments: (value, index, array).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Array\n * @param {Array} array The array to query.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the slice of `array`.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'active': false },\n * { 'user': 'fred', 'active': false },\n * { 'user': 'pebbles', 'active': true }\n * ];\n *\n * _.takeWhile(users, function(o) { return !o.active; });\n * // => objects for ['barney', 'fred']\n *\n * // The `_.matches` iteratee shorthand.\n * _.takeWhile(users, { 'user': 'barney', 'active': false });\n * // => objects for ['barney']\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.takeWhile(users, ['active', false]);\n * // => objects for ['barney', 'fred']\n *\n * // The `_.property` iteratee shorthand.\n * _.takeWhile(users, 'active');\n * // => []\n */\n function takeWhile(array, predicate) {\n return (array && array.length)\n ? baseWhile(array, getIteratee(predicate, 3))\n : [];\n }\n\n /**\n * Creates an array of unique values, in order, from all given arrays using\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @returns {Array} Returns the new array of combined values.\n * @example\n *\n * _.union([2], [1, 2]);\n * // => [2, 1]\n */\n var union = baseRest(function(arrays) {\n return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));\n });\n\n /**\n * This method is like `_.union` except that it accepts `iteratee` which is\n * invoked for each element of each `arrays` to generate the criterion by\n * which uniqueness is computed. Result values are chosen from the first\n * array in which the value occurs. The iteratee is invoked with one argument:\n * (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns the new array of combined values.\n * @example\n *\n * _.unionBy([2.1], [1.2, 2.3], Math.floor);\n * // => [2.1, 1.2]\n *\n * // The `_.property` iteratee shorthand.\n * _.unionBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n * // => [{ 'x': 1 }, { 'x': 2 }]\n */\n var unionBy = baseRest(function(arrays) {\n var iteratee = last(arrays);\n if (isArrayLikeObject(iteratee)) {\n iteratee = undefined;\n }\n return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), getIteratee(iteratee, 2));\n });\n\n /**\n * This method is like `_.union` except that it accepts `comparator` which\n * is invoked to compare elements of `arrays`. Result values are chosen from\n * the first array in which the value occurs. The comparator is invoked\n * with two arguments: (arrVal, othVal).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of combined values.\n * @example\n *\n * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n *\n * _.unionWith(objects, others, _.isEqual);\n * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n */\n var unionWith = baseRest(function(arrays) {\n var comparator = last(arrays);\n comparator = typeof comparator == 'function' ? comparator : undefined;\n return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), undefined, comparator);\n });\n\n /**\n * Creates a duplicate-free version of an array, using\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons, in which only the first occurrence of each element\n * is kept. The order of result values is determined by the order they occur\n * in the array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * _.uniq([2, 1, 2]);\n * // => [2, 1]\n */\n function uniq(array) {\n return (array && array.length) ? baseUniq(array) : [];\n }\n\n /**\n * This method is like `_.uniq` except that it accepts `iteratee` which is\n * invoked for each element in `array` to generate the criterion by which\n * uniqueness is computed. The order of result values is determined by the\n * order they occur in the array. The iteratee is invoked with one argument:\n * (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * _.uniqBy([2.1, 1.2, 2.3], Math.floor);\n * // => [2.1, 1.2]\n *\n * // The `_.property` iteratee shorthand.\n * _.uniqBy([{ 'x': 1 }, { 'x': 2 }, { 'x': 1 }], 'x');\n * // => [{ 'x': 1 }, { 'x': 2 }]\n */\n function uniqBy(array, iteratee) {\n return (array && array.length) ? baseUniq(array, getIteratee(iteratee, 2)) : [];\n }\n\n /**\n * This method is like `_.uniq` except that it accepts `comparator` which\n * is invoked to compare elements of `array`. The order of result values is\n * determined by the order they occur in the array.The comparator is invoked\n * with two arguments: (arrVal, othVal).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new duplicate free array.\n * @example\n *\n * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }, { 'x': 1, 'y': 2 }];\n *\n * _.uniqWith(objects, _.isEqual);\n * // => [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }]\n */\n function uniqWith(array, comparator) {\n comparator = typeof comparator == 'function' ? comparator : undefined;\n return (array && array.length) ? baseUniq(array, undefined, comparator) : [];\n }\n\n /**\n * This method is like `_.zip` except that it accepts an array of grouped\n * elements and creates an array regrouping the elements to their pre-zip\n * configuration.\n *\n * @static\n * @memberOf _\n * @since 1.2.0\n * @category Array\n * @param {Array} array The array of grouped elements to process.\n * @returns {Array} Returns the new array of regrouped elements.\n * @example\n *\n * var zipped = _.zip(['a', 'b'], [1, 2], [true, false]);\n * // => [['a', 1, true], ['b', 2, false]]\n *\n * _.unzip(zipped);\n * // => [['a', 'b'], [1, 2], [true, false]]\n */\n function unzip(array) {\n if (!(array && array.length)) {\n return [];\n }\n var length = 0;\n array = arrayFilter(array, function(group) {\n if (isArrayLikeObject(group)) {\n length = nativeMax(group.length, length);\n return true;\n }\n });\n return baseTimes(length, function(index) {\n return arrayMap(array, baseProperty(index));\n });\n }\n\n /**\n * This method is like `_.unzip` except that it accepts `iteratee` to specify\n * how regrouped values should be combined. The iteratee is invoked with the\n * elements of each group: (...group).\n *\n * @static\n * @memberOf _\n * @since 3.8.0\n * @category Array\n * @param {Array} array The array of grouped elements to process.\n * @param {Function} [iteratee=_.identity] The function to combine\n * regrouped values.\n * @returns {Array} Returns the new array of regrouped elements.\n * @example\n *\n * var zipped = _.zip([1, 2], [10, 20], [100, 200]);\n * // => [[1, 10, 100], [2, 20, 200]]\n *\n * _.unzipWith(zipped, _.add);\n * // => [3, 30, 300]\n */\n function unzipWith(array, iteratee) {\n if (!(array && array.length)) {\n return [];\n }\n var result = unzip(array);\n if (iteratee == null) {\n return result;\n }\n return arrayMap(result, function(group) {\n return apply(iteratee, undefined, group);\n });\n }\n\n /**\n * Creates an array excluding all given values using\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * **Note:** Unlike `_.pull`, this method returns a new array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {Array} array The array to inspect.\n * @param {...*} [values] The values to exclude.\n * @returns {Array} Returns the new array of filtered values.\n * @see _.difference, _.xor\n * @example\n *\n * _.without([2, 1, 2, 3], 1, 2);\n * // => [3]\n */\n var without = baseRest(function(array, values) {\n return isArrayLikeObject(array)\n ? baseDifference(array, values)\n : [];\n });\n\n /**\n * Creates an array of unique values that is the\n * [symmetric difference](https://en.wikipedia.org/wiki/Symmetric_difference)\n * of the given arrays. The order of result values is determined by the order\n * they occur in the arrays.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @returns {Array} Returns the new array of filtered values.\n * @see _.difference, _.without\n * @example\n *\n * _.xor([2, 1], [2, 3]);\n * // => [1, 3]\n */\n var xor = baseRest(function(arrays) {\n return baseXor(arrayFilter(arrays, isArrayLikeObject));\n });\n\n /**\n * This method is like `_.xor` except that it accepts `iteratee` which is\n * invoked for each element of each `arrays` to generate the criterion by\n * which by which they're compared. The order of result values is determined\n * by the order they occur in the arrays. The iteratee is invoked with one\n * argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Array} Returns the new array of filtered values.\n * @example\n *\n * _.xorBy([2.1, 1.2], [2.3, 3.4], Math.floor);\n * // => [1.2, 3.4]\n *\n * // The `_.property` iteratee shorthand.\n * _.xorBy([{ 'x': 1 }], [{ 'x': 2 }, { 'x': 1 }], 'x');\n * // => [{ 'x': 2 }]\n */\n var xorBy = baseRest(function(arrays) {\n var iteratee = last(arrays);\n if (isArrayLikeObject(iteratee)) {\n iteratee = undefined;\n }\n return baseXor(arrayFilter(arrays, isArrayLikeObject), getIteratee(iteratee, 2));\n });\n\n /**\n * This method is like `_.xor` except that it accepts `comparator` which is\n * invoked to compare elements of `arrays`. The order of result values is\n * determined by the order they occur in the arrays. The comparator is invoked\n * with two arguments: (arrVal, othVal).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Array\n * @param {...Array} [arrays] The arrays to inspect.\n * @param {Function} [comparator] The comparator invoked per element.\n * @returns {Array} Returns the new array of filtered values.\n * @example\n *\n * var objects = [{ 'x': 1, 'y': 2 }, { 'x': 2, 'y': 1 }];\n * var others = [{ 'x': 1, 'y': 1 }, { 'x': 1, 'y': 2 }];\n *\n * _.xorWith(objects, others, _.isEqual);\n * // => [{ 'x': 2, 'y': 1 }, { 'x': 1, 'y': 1 }]\n */\n var xorWith = baseRest(function(arrays) {\n var comparator = last(arrays);\n comparator = typeof comparator == 'function' ? comparator : undefined;\n return baseXor(arrayFilter(arrays, isArrayLikeObject), undefined, comparator);\n });\n\n /**\n * Creates an array of grouped elements, the first of which contains the\n * first elements of the given arrays, the second of which contains the\n * second elements of the given arrays, and so on.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Array\n * @param {...Array} [arrays] The arrays to process.\n * @returns {Array} Returns the new array of grouped elements.\n * @example\n *\n * _.zip(['a', 'b'], [1, 2], [true, false]);\n * // => [['a', 1, true], ['b', 2, false]]\n */\n var zip = baseRest(unzip);\n\n /**\n * This method is like `_.fromPairs` except that it accepts two arrays,\n * one of property identifiers and one of corresponding values.\n *\n * @static\n * @memberOf _\n * @since 0.4.0\n * @category Array\n * @param {Array} [props=[]] The property identifiers.\n * @param {Array} [values=[]] The property values.\n * @returns {Object} Returns the new object.\n * @example\n *\n * _.zipObject(['a', 'b'], [1, 2]);\n * // => { 'a': 1, 'b': 2 }\n */\n function zipObject(props, values) {\n return baseZipObject(props || [], values || [], assignValue);\n }\n\n /**\n * This method is like `_.zipObject` except that it supports property paths.\n *\n * @static\n * @memberOf _\n * @since 4.1.0\n * @category Array\n * @param {Array} [props=[]] The property identifiers.\n * @param {Array} [values=[]] The property values.\n * @returns {Object} Returns the new object.\n * @example\n *\n * _.zipObjectDeep(['a.b[0].c', 'a.b[1].d'], [1, 2]);\n * // => { 'a': { 'b': [{ 'c': 1 }, { 'd': 2 }] } }\n */\n function zipObjectDeep(props, values) {\n return baseZipObject(props || [], values || [], baseSet);\n }\n\n /**\n * This method is like `_.zip` except that it accepts `iteratee` to specify\n * how grouped values should be combined. The iteratee is invoked with the\n * elements of each group: (...group).\n *\n * @static\n * @memberOf _\n * @since 3.8.0\n * @category Array\n * @param {...Array} [arrays] The arrays to process.\n * @param {Function} [iteratee=_.identity] The function to combine\n * grouped values.\n * @returns {Array} Returns the new array of grouped elements.\n * @example\n *\n * _.zipWith([1, 2], [10, 20], [100, 200], function(a, b, c) {\n * return a + b + c;\n * });\n * // => [111, 222]\n */\n var zipWith = baseRest(function(arrays) {\n var length = arrays.length,\n iteratee = length > 1 ? arrays[length - 1] : undefined;\n\n iteratee = typeof iteratee == 'function' ? (arrays.pop(), iteratee) : undefined;\n return unzipWith(arrays, iteratee);\n });\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates a `lodash` wrapper instance that wraps `value` with explicit method\n * chain sequences enabled. The result of such sequences must be unwrapped\n * with `_#value`.\n *\n * @static\n * @memberOf _\n * @since 1.3.0\n * @category Seq\n * @param {*} value The value to wrap.\n * @returns {Object} Returns the new `lodash` wrapper instance.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36 },\n * { 'user': 'fred', 'age': 40 },\n * { 'user': 'pebbles', 'age': 1 }\n * ];\n *\n * var youngest = _\n * .chain(users)\n * .sortBy('age')\n * .map(function(o) {\n * return o.user + ' is ' + o.age;\n * })\n * .head()\n * .value();\n * // => 'pebbles is 1'\n */\n function chain(value) {\n var result = lodash(value);\n result.__chain__ = true;\n return result;\n }\n\n /**\n * This method invokes `interceptor` and returns `value`. The interceptor\n * is invoked with one argument; (value). The purpose of this method is to\n * \"tap into\" a method chain sequence in order to modify intermediate results.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Seq\n * @param {*} value The value to provide to `interceptor`.\n * @param {Function} interceptor The function to invoke.\n * @returns {*} Returns `value`.\n * @example\n *\n * _([1, 2, 3])\n * .tap(function(array) {\n * // Mutate input array.\n * array.pop();\n * })\n * .reverse()\n * .value();\n * // => [2, 1]\n */\n function tap(value, interceptor) {\n interceptor(value);\n return value;\n }\n\n /**\n * This method is like `_.tap` except that it returns the result of `interceptor`.\n * The purpose of this method is to \"pass thru\" values replacing intermediate\n * results in a method chain sequence.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Seq\n * @param {*} value The value to provide to `interceptor`.\n * @param {Function} interceptor The function to invoke.\n * @returns {*} Returns the result of `interceptor`.\n * @example\n *\n * _(' abc ')\n * .chain()\n * .trim()\n * .thru(function(value) {\n * return [value];\n * })\n * .value();\n * // => ['abc']\n */\n function thru(value, interceptor) {\n return interceptor(value);\n }\n\n /**\n * This method is the wrapper version of `_.at`.\n *\n * @name at\n * @memberOf _\n * @since 1.0.0\n * @category Seq\n * @param {...(string|string[])} [paths] The property paths to pick.\n * @returns {Object} Returns the new `lodash` wrapper instance.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n *\n * _(object).at(['a[0].b.c', 'a[1]']).value();\n * // => [3, 4]\n */\n var wrapperAt = flatRest(function(paths) {\n var length = paths.length,\n start = length ? paths[0] : 0,\n value = this.__wrapped__,\n interceptor = function(object) { return baseAt(object, paths); };\n\n if (length > 1 || this.__actions__.length ||\n !(value instanceof LazyWrapper) || !isIndex(start)) {\n return this.thru(interceptor);\n }\n value = value.slice(start, +start + (length ? 1 : 0));\n value.__actions__.push({\n 'func': thru,\n 'args': [interceptor],\n 'thisArg': undefined\n });\n return new LodashWrapper(value, this.__chain__).thru(function(array) {\n if (length && !array.length) {\n array.push(undefined);\n }\n return array;\n });\n });\n\n /**\n * Creates a `lodash` wrapper instance with explicit method chain sequences enabled.\n *\n * @name chain\n * @memberOf _\n * @since 0.1.0\n * @category Seq\n * @returns {Object} Returns the new `lodash` wrapper instance.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36 },\n * { 'user': 'fred', 'age': 40 }\n * ];\n *\n * // A sequence without explicit chaining.\n * _(users).head();\n * // => { 'user': 'barney', 'age': 36 }\n *\n * // A sequence with explicit chaining.\n * _(users)\n * .chain()\n * .head()\n * .pick('user')\n * .value();\n * // => { 'user': 'barney' }\n */\n function wrapperChain() {\n return chain(this);\n }\n\n /**\n * Executes the chain sequence and returns the wrapped result.\n *\n * @name commit\n * @memberOf _\n * @since 3.2.0\n * @category Seq\n * @returns {Object} Returns the new `lodash` wrapper instance.\n * @example\n *\n * var array = [1, 2];\n * var wrapped = _(array).push(3);\n *\n * console.log(array);\n * // => [1, 2]\n *\n * wrapped = wrapped.commit();\n * console.log(array);\n * // => [1, 2, 3]\n *\n * wrapped.last();\n * // => 3\n *\n * console.log(array);\n * // => [1, 2, 3]\n */\n function wrapperCommit() {\n return new LodashWrapper(this.value(), this.__chain__);\n }\n\n /**\n * Gets the next value on a wrapped object following the\n * [iterator protocol](https://mdn.io/iteration_protocols#iterator).\n *\n * @name next\n * @memberOf _\n * @since 4.0.0\n * @category Seq\n * @returns {Object} Returns the next iterator value.\n * @example\n *\n * var wrapped = _([1, 2]);\n *\n * wrapped.next();\n * // => { 'done': false, 'value': 1 }\n *\n * wrapped.next();\n * // => { 'done': false, 'value': 2 }\n *\n * wrapped.next();\n * // => { 'done': true, 'value': undefined }\n */\n function wrapperNext() {\n if (this.__values__ === undefined) {\n this.__values__ = toArray(this.value());\n }\n var done = this.__index__ >= this.__values__.length,\n value = done ? undefined : this.__values__[this.__index__++];\n\n return { 'done': done, 'value': value };\n }\n\n /**\n * Enables the wrapper to be iterable.\n *\n * @name Symbol.iterator\n * @memberOf _\n * @since 4.0.0\n * @category Seq\n * @returns {Object} Returns the wrapper object.\n * @example\n *\n * var wrapped = _([1, 2]);\n *\n * wrapped[Symbol.iterator]() === wrapped;\n * // => true\n *\n * Array.from(wrapped);\n * // => [1, 2]\n */\n function wrapperToIterator() {\n return this;\n }\n\n /**\n * Creates a clone of the chain sequence planting `value` as the wrapped value.\n *\n * @name plant\n * @memberOf _\n * @since 3.2.0\n * @category Seq\n * @param {*} value The value to plant.\n * @returns {Object} Returns the new `lodash` wrapper instance.\n * @example\n *\n * function square(n) {\n * return n * n;\n * }\n *\n * var wrapped = _([1, 2]).map(square);\n * var other = wrapped.plant([3, 4]);\n *\n * other.value();\n * // => [9, 16]\n *\n * wrapped.value();\n * // => [1, 4]\n */\n function wrapperPlant(value) {\n var result,\n parent = this;\n\n while (parent instanceof baseLodash) {\n var clone = wrapperClone(parent);\n clone.__index__ = 0;\n clone.__values__ = undefined;\n if (result) {\n previous.__wrapped__ = clone;\n } else {\n result = clone;\n }\n var previous = clone;\n parent = parent.__wrapped__;\n }\n previous.__wrapped__ = value;\n return result;\n }\n\n /**\n * This method is the wrapper version of `_.reverse`.\n *\n * **Note:** This method mutates the wrapped array.\n *\n * @name reverse\n * @memberOf _\n * @since 0.1.0\n * @category Seq\n * @returns {Object} Returns the new `lodash` wrapper instance.\n * @example\n *\n * var array = [1, 2, 3];\n *\n * _(array).reverse().value()\n * // => [3, 2, 1]\n *\n * console.log(array);\n * // => [3, 2, 1]\n */\n function wrapperReverse() {\n var value = this.__wrapped__;\n if (value instanceof LazyWrapper) {\n var wrapped = value;\n if (this.__actions__.length) {\n wrapped = new LazyWrapper(this);\n }\n wrapped = wrapped.reverse();\n wrapped.__actions__.push({\n 'func': thru,\n 'args': [reverse],\n 'thisArg': undefined\n });\n return new LodashWrapper(wrapped, this.__chain__);\n }\n return this.thru(reverse);\n }\n\n /**\n * Executes the chain sequence to resolve the unwrapped value.\n *\n * @name value\n * @memberOf _\n * @since 0.1.0\n * @alias toJSON, valueOf\n * @category Seq\n * @returns {*} Returns the resolved unwrapped value.\n * @example\n *\n * _([1, 2, 3]).value();\n * // => [1, 2, 3]\n */\n function wrapperValue() {\n return baseWrapperValue(this.__wrapped__, this.__actions__);\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Creates an object composed of keys generated from the results of running\n * each element of `collection` thru `iteratee`. The corresponding value of\n * each key is the number of times the key was returned by `iteratee`. The\n * iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n * @returns {Object} Returns the composed aggregate object.\n * @example\n *\n * _.countBy([6.1, 4.2, 6.3], Math.floor);\n * // => { '4': 1, '6': 2 }\n *\n * // The `_.property` iteratee shorthand.\n * _.countBy(['one', 'two', 'three'], 'length');\n * // => { '3': 2, '5': 1 }\n */\n var countBy = createAggregator(function(result, value, key) {\n if (hasOwnProperty.call(result, key)) {\n ++result[key];\n } else {\n baseAssignValue(result, key, 1);\n }\n });\n\n /**\n * Checks if `predicate` returns truthy for **all** elements of `collection`.\n * Iteration is stopped once `predicate` returns falsey. The predicate is\n * invoked with three arguments: (value, index|key, collection).\n *\n * **Note:** This method returns `true` for\n * [empty collections](https://en.wikipedia.org/wiki/Empty_set) because\n * [everything is true](https://en.wikipedia.org/wiki/Vacuous_truth) of\n * elements of empty collections.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {boolean} Returns `true` if all elements pass the predicate check,\n * else `false`.\n * @example\n *\n * _.every([true, 1, null, 'yes'], Boolean);\n * // => false\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': false },\n * { 'user': 'fred', 'age': 40, 'active': false }\n * ];\n *\n * // The `_.matches` iteratee shorthand.\n * _.every(users, { 'user': 'barney', 'active': false });\n * // => false\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.every(users, ['active', false]);\n * // => true\n *\n * // The `_.property` iteratee shorthand.\n * _.every(users, 'active');\n * // => false\n */\n function every(collection, predicate, guard) {\n var func = isArray(collection) ? arrayEvery : baseEvery;\n if (guard && isIterateeCall(collection, predicate, guard)) {\n predicate = undefined;\n }\n return func(collection, getIteratee(predicate, 3));\n }\n\n /**\n * Iterates over elements of `collection`, returning an array of all elements\n * `predicate` returns truthy for. The predicate is invoked with three\n * arguments: (value, index|key, collection).\n *\n * **Note:** Unlike `_.remove`, this method returns a new array.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n * @see _.reject\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': true },\n * { 'user': 'fred', 'age': 40, 'active': false }\n * ];\n *\n * _.filter(users, function(o) { return !o.active; });\n * // => objects for ['fred']\n *\n * // The `_.matches` iteratee shorthand.\n * _.filter(users, { 'age': 36, 'active': true });\n * // => objects for ['barney']\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.filter(users, ['active', false]);\n * // => objects for ['fred']\n *\n * // The `_.property` iteratee shorthand.\n * _.filter(users, 'active');\n * // => objects for ['barney']\n *\n * // Combining several predicates using `_.overEvery` or `_.overSome`.\n * _.filter(users, _.overSome([{ 'age': 36 }, ['age', 40]]));\n * // => objects for ['fred', 'barney']\n */\n function filter(collection, predicate) {\n var func = isArray(collection) ? arrayFilter : baseFilter;\n return func(collection, getIteratee(predicate, 3));\n }\n\n /**\n * Iterates over elements of `collection`, returning the first element\n * `predicate` returns truthy for. The predicate is invoked with three\n * arguments: (value, index|key, collection).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param {number} [fromIndex=0] The index to search from.\n * @returns {*} Returns the matched element, else `undefined`.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': true },\n * { 'user': 'fred', 'age': 40, 'active': false },\n * { 'user': 'pebbles', 'age': 1, 'active': true }\n * ];\n *\n * _.find(users, function(o) { return o.age < 40; });\n * // => object for 'barney'\n *\n * // The `_.matches` iteratee shorthand.\n * _.find(users, { 'age': 1, 'active': true });\n * // => object for 'pebbles'\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.find(users, ['active', false]);\n * // => object for 'fred'\n *\n * // The `_.property` iteratee shorthand.\n * _.find(users, 'active');\n * // => object for 'barney'\n */\n var find = createFind(findIndex);\n\n /**\n * This method is like `_.find` except that it iterates over elements of\n * `collection` from right to left.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param {number} [fromIndex=collection.length-1] The index to search from.\n * @returns {*} Returns the matched element, else `undefined`.\n * @example\n *\n * _.findLast([1, 2, 3, 4], function(n) {\n * return n % 2 == 1;\n * });\n * // => 3\n */\n var findLast = createFind(findLastIndex);\n\n /**\n * Creates a flattened array of values by running each element in `collection`\n * thru `iteratee` and flattening the mapped results. The iteratee is invoked\n * with three arguments: (value, index|key, collection).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * function duplicate(n) {\n * return [n, n];\n * }\n *\n * _.flatMap([1, 2], duplicate);\n * // => [1, 1, 2, 2]\n */\n function flatMap(collection, iteratee) {\n return baseFlatten(map(collection, iteratee), 1);\n }\n\n /**\n * This method is like `_.flatMap` except that it recursively flattens the\n * mapped results.\n *\n * @static\n * @memberOf _\n * @since 4.7.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * function duplicate(n) {\n * return [[[n, n]]];\n * }\n *\n * _.flatMapDeep([1, 2], duplicate);\n * // => [1, 1, 2, 2]\n */\n function flatMapDeep(collection, iteratee) {\n return baseFlatten(map(collection, iteratee), INFINITY);\n }\n\n /**\n * This method is like `_.flatMap` except that it recursively flattens the\n * mapped results up to `depth` times.\n *\n * @static\n * @memberOf _\n * @since 4.7.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @param {number} [depth=1] The maximum recursion depth.\n * @returns {Array} Returns the new flattened array.\n * @example\n *\n * function duplicate(n) {\n * return [[[n, n]]];\n * }\n *\n * _.flatMapDepth([1, 2], duplicate, 2);\n * // => [[1, 1], [2, 2]]\n */\n function flatMapDepth(collection, iteratee, depth) {\n depth = depth === undefined ? 1 : toInteger(depth);\n return baseFlatten(map(collection, iteratee), depth);\n }\n\n /**\n * Iterates over elements of `collection` and invokes `iteratee` for each element.\n * The iteratee is invoked with three arguments: (value, index|key, collection).\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * **Note:** As with other \"Collections\" methods, objects with a \"length\"\n * property are iterated like arrays. To avoid this behavior use `_.forIn`\n * or `_.forOwn` for object iteration.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @alias each\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array|Object} Returns `collection`.\n * @see _.forEachRight\n * @example\n *\n * _.forEach([1, 2], function(value) {\n * console.log(value);\n * });\n * // => Logs `1` then `2`.\n *\n * _.forEach({ 'a': 1, 'b': 2 }, function(value, key) {\n * console.log(key);\n * });\n * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n */\n function forEach(collection, iteratee) {\n var func = isArray(collection) ? arrayEach : baseEach;\n return func(collection, getIteratee(iteratee, 3));\n }\n\n /**\n * This method is like `_.forEach` except that it iterates over elements of\n * `collection` from right to left.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @alias eachRight\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array|Object} Returns `collection`.\n * @see _.forEach\n * @example\n *\n * _.forEachRight([1, 2], function(value) {\n * console.log(value);\n * });\n * // => Logs `2` then `1`.\n */\n function forEachRight(collection, iteratee) {\n var func = isArray(collection) ? arrayEachRight : baseEachRight;\n return func(collection, getIteratee(iteratee, 3));\n }\n\n /**\n * Creates an object composed of keys generated from the results of running\n * each element of `collection` thru `iteratee`. The order of grouped values\n * is determined by the order they occur in `collection`. The corresponding\n * value of each key is an array of elements responsible for generating the\n * key. The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n * @returns {Object} Returns the composed aggregate object.\n * @example\n *\n * _.groupBy([6.1, 4.2, 6.3], Math.floor);\n * // => { '4': [4.2], '6': [6.1, 6.3] }\n *\n * // The `_.property` iteratee shorthand.\n * _.groupBy(['one', 'two', 'three'], 'length');\n * // => { '3': ['one', 'two'], '5': ['three'] }\n */\n var groupBy = createAggregator(function(result, value, key) {\n if (hasOwnProperty.call(result, key)) {\n result[key].push(value);\n } else {\n baseAssignValue(result, key, [value]);\n }\n });\n\n /**\n * Checks if `value` is in `collection`. If `collection` is a string, it's\n * checked for a substring of `value`, otherwise\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * is used for equality comparisons. If `fromIndex` is negative, it's used as\n * the offset from the end of `collection`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object|string} collection The collection to inspect.\n * @param {*} value The value to search for.\n * @param {number} [fromIndex=0] The index to search from.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n * @returns {boolean} Returns `true` if `value` is found, else `false`.\n * @example\n *\n * _.includes([1, 2, 3], 1);\n * // => true\n *\n * _.includes([1, 2, 3], 1, 2);\n * // => false\n *\n * _.includes({ 'a': 1, 'b': 2 }, 1);\n * // => true\n *\n * _.includes('abcd', 'bc');\n * // => true\n */\n function includes(collection, value, fromIndex, guard) {\n collection = isArrayLike(collection) ? collection : values(collection);\n fromIndex = (fromIndex && !guard) ? toInteger(fromIndex) : 0;\n\n var length = collection.length;\n if (fromIndex < 0) {\n fromIndex = nativeMax(length + fromIndex, 0);\n }\n return isString(collection)\n ? (fromIndex <= length && collection.indexOf(value, fromIndex) > -1)\n : (!!length && baseIndexOf(collection, value, fromIndex) > -1);\n }\n\n /**\n * Invokes the method at `path` of each element in `collection`, returning\n * an array of the results of each invoked method. Any additional arguments\n * are provided to each invoked method. If `path` is a function, it's invoked\n * for, and `this` bound to, each element in `collection`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Array|Function|string} path The path of the method to invoke or\n * the function invoked per iteration.\n * @param {...*} [args] The arguments to invoke each method with.\n * @returns {Array} Returns the array of results.\n * @example\n *\n * _.invokeMap([[5, 1, 7], [3, 2, 1]], 'sort');\n * // => [[1, 5, 7], [1, 2, 3]]\n *\n * _.invokeMap([123, 456], String.prototype.split, '');\n * // => [['1', '2', '3'], ['4', '5', '6']]\n */\n var invokeMap = baseRest(function(collection, path, args) {\n var index = -1,\n isFunc = typeof path == 'function',\n result = isArrayLike(collection) ? Array(collection.length) : [];\n\n baseEach(collection, function(value) {\n result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);\n });\n return result;\n });\n\n /**\n * Creates an object composed of keys generated from the results of running\n * each element of `collection` thru `iteratee`. The corresponding value of\n * each key is the last element responsible for generating the key. The\n * iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee to transform keys.\n * @returns {Object} Returns the composed aggregate object.\n * @example\n *\n * var array = [\n * { 'dir': 'left', 'code': 97 },\n * { 'dir': 'right', 'code': 100 }\n * ];\n *\n * _.keyBy(array, function(o) {\n * return String.fromCharCode(o.code);\n * });\n * // => { 'a': { 'dir': 'left', 'code': 97 }, 'd': { 'dir': 'right', 'code': 100 } }\n *\n * _.keyBy(array, 'dir');\n * // => { 'left': { 'dir': 'left', 'code': 97 }, 'right': { 'dir': 'right', 'code': 100 } }\n */\n var keyBy = createAggregator(function(result, value, key) {\n baseAssignValue(result, key, value);\n });\n\n /**\n * Creates an array of values by running each element in `collection` thru\n * `iteratee`. The iteratee is invoked with three arguments:\n * (value, index|key, collection).\n *\n * Many lodash methods are guarded to work as iteratees for methods like\n * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.\n *\n * The guarded methods are:\n * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,\n * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,\n * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,\n * `template`, `trim`, `trimEnd`, `trimStart`, and `words`\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n * @example\n *\n * function square(n) {\n * return n * n;\n * }\n *\n * _.map([4, 8], square);\n * // => [16, 64]\n *\n * _.map({ 'a': 4, 'b': 8 }, square);\n * // => [16, 64] (iteration order is not guaranteed)\n *\n * var users = [\n * { 'user': 'barney' },\n * { 'user': 'fred' }\n * ];\n *\n * // The `_.property` iteratee shorthand.\n * _.map(users, 'user');\n * // => ['barney', 'fred']\n */\n function map(collection, iteratee) {\n var func = isArray(collection) ? arrayMap : baseMap;\n return func(collection, getIteratee(iteratee, 3));\n }\n\n /**\n * This method is like `_.sortBy` except that it allows specifying the sort\n * orders of the iteratees to sort by. If `orders` is unspecified, all values\n * are sorted in ascending order. Otherwise, specify an order of \"desc\" for\n * descending or \"asc\" for ascending sort order of corresponding values.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Array[]|Function[]|Object[]|string[]} [iteratees=[_.identity]]\n * The iteratees to sort by.\n * @param {string[]} [orders] The sort orders of `iteratees`.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.reduce`.\n * @returns {Array} Returns the new sorted array.\n * @example\n *\n * var users = [\n * { 'user': 'fred', 'age': 48 },\n * { 'user': 'barney', 'age': 34 },\n * { 'user': 'fred', 'age': 40 },\n * { 'user': 'barney', 'age': 36 }\n * ];\n *\n * // Sort by `user` in ascending order and by `age` in descending order.\n * _.orderBy(users, ['user', 'age'], ['asc', 'desc']);\n * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 40]]\n */\n function orderBy(collection, iteratees, orders, guard) {\n if (collection == null) {\n return [];\n }\n if (!isArray(iteratees)) {\n iteratees = iteratees == null ? [] : [iteratees];\n }\n orders = guard ? undefined : orders;\n if (!isArray(orders)) {\n orders = orders == null ? [] : [orders];\n }\n return baseOrderBy(collection, iteratees, orders);\n }\n\n /**\n * Creates an array of elements split into two groups, the first of which\n * contains elements `predicate` returns truthy for, the second of which\n * contains elements `predicate` returns falsey for. The predicate is\n * invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the array of grouped elements.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': false },\n * { 'user': 'fred', 'age': 40, 'active': true },\n * { 'user': 'pebbles', 'age': 1, 'active': false }\n * ];\n *\n * _.partition(users, function(o) { return o.active; });\n * // => objects for [['fred'], ['barney', 'pebbles']]\n *\n * // The `_.matches` iteratee shorthand.\n * _.partition(users, { 'age': 1, 'active': false });\n * // => objects for [['pebbles'], ['barney', 'fred']]\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.partition(users, ['active', false]);\n * // => objects for [['barney', 'pebbles'], ['fred']]\n *\n * // The `_.property` iteratee shorthand.\n * _.partition(users, 'active');\n * // => objects for [['fred'], ['barney', 'pebbles']]\n */\n var partition = createAggregator(function(result, value, key) {\n result[key ? 0 : 1].push(value);\n }, function() { return [[], []]; });\n\n /**\n * Reduces `collection` to a value which is the accumulated result of running\n * each element in `collection` thru `iteratee`, where each successive\n * invocation is supplied the return value of the previous. If `accumulator`\n * is not given, the first element of `collection` is used as the initial\n * value. The iteratee is invoked with four arguments:\n * (accumulator, value, index|key, collection).\n *\n * Many lodash methods are guarded to work as iteratees for methods like\n * `_.reduce`, `_.reduceRight`, and `_.transform`.\n *\n * The guarded methods are:\n * `assign`, `defaults`, `defaultsDeep`, `includes`, `merge`, `orderBy`,\n * and `sortBy`\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @returns {*} Returns the accumulated value.\n * @see _.reduceRight\n * @example\n *\n * _.reduce([1, 2], function(sum, n) {\n * return sum + n;\n * }, 0);\n * // => 3\n *\n * _.reduce({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n * (result[value] || (result[value] = [])).push(key);\n * return result;\n * }, {});\n * // => { '1': ['a', 'c'], '2': ['b'] } (iteration order is not guaranteed)\n */\n function reduce(collection, iteratee, accumulator) {\n var func = isArray(collection) ? arrayReduce : baseReduce,\n initAccum = arguments.length < 3;\n\n return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEach);\n }\n\n /**\n * This method is like `_.reduce` except that it iterates over elements of\n * `collection` from right to left.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @param {*} [accumulator] The initial value.\n * @returns {*} Returns the accumulated value.\n * @see _.reduce\n * @example\n *\n * var array = [[0, 1], [2, 3], [4, 5]];\n *\n * _.reduceRight(array, function(flattened, other) {\n * return flattened.concat(other);\n * }, []);\n * // => [4, 5, 2, 3, 0, 1]\n */\n function reduceRight(collection, iteratee, accumulator) {\n var func = isArray(collection) ? arrayReduceRight : baseReduce,\n initAccum = arguments.length < 3;\n\n return func(collection, getIteratee(iteratee, 4), accumulator, initAccum, baseEachRight);\n }\n\n /**\n * The opposite of `_.filter`; this method returns the elements of `collection`\n * that `predicate` does **not** return truthy for.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n * @see _.filter\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': false },\n * { 'user': 'fred', 'age': 40, 'active': true }\n * ];\n *\n * _.reject(users, function(o) { return !o.active; });\n * // => objects for ['fred']\n *\n * // The `_.matches` iteratee shorthand.\n * _.reject(users, { 'age': 40, 'active': true });\n * // => objects for ['barney']\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.reject(users, ['active', false]);\n * // => objects for ['fred']\n *\n * // The `_.property` iteratee shorthand.\n * _.reject(users, 'active');\n * // => objects for ['barney']\n */\n function reject(collection, predicate) {\n var func = isArray(collection) ? arrayFilter : baseFilter;\n return func(collection, negate(getIteratee(predicate, 3)));\n }\n\n /**\n * Gets a random element from `collection`.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to sample.\n * @returns {*} Returns the random element.\n * @example\n *\n * _.sample([1, 2, 3, 4]);\n * // => 2\n */\n function sample(collection) {\n var func = isArray(collection) ? arraySample : baseSample;\n return func(collection);\n }\n\n /**\n * Gets `n` random elements at unique keys from `collection` up to the\n * size of `collection`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Collection\n * @param {Array|Object} collection The collection to sample.\n * @param {number} [n=1] The number of elements to sample.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the random elements.\n * @example\n *\n * _.sampleSize([1, 2, 3], 2);\n * // => [3, 1]\n *\n * _.sampleSize([1, 2, 3], 4);\n * // => [2, 3, 1]\n */\n function sampleSize(collection, n, guard) {\n if ((guard ? isIterateeCall(collection, n, guard) : n === undefined)) {\n n = 1;\n } else {\n n = toInteger(n);\n }\n var func = isArray(collection) ? arraySampleSize : baseSampleSize;\n return func(collection, n);\n }\n\n /**\n * Creates an array of shuffled values, using a version of the\n * [Fisher-Yates shuffle](https://en.wikipedia.org/wiki/Fisher-Yates_shuffle).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to shuffle.\n * @returns {Array} Returns the new shuffled array.\n * @example\n *\n * _.shuffle([1, 2, 3, 4]);\n * // => [4, 1, 3, 2]\n */\n function shuffle(collection) {\n var func = isArray(collection) ? arrayShuffle : baseShuffle;\n return func(collection);\n }\n\n /**\n * Gets the size of `collection` by returning its length for array-like\n * values or the number of own enumerable string keyed properties for objects.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object|string} collection The collection to inspect.\n * @returns {number} Returns the collection size.\n * @example\n *\n * _.size([1, 2, 3]);\n * // => 3\n *\n * _.size({ 'a': 1, 'b': 2 });\n * // => 2\n *\n * _.size('pebbles');\n * // => 7\n */\n function size(collection) {\n if (collection == null) {\n return 0;\n }\n if (isArrayLike(collection)) {\n return isString(collection) ? stringSize(collection) : collection.length;\n }\n var tag = getTag(collection);\n if (tag == mapTag || tag == setTag) {\n return collection.size;\n }\n return baseKeys(collection).length;\n }\n\n /**\n * Checks if `predicate` returns truthy for **any** element of `collection`.\n * Iteration is stopped once `predicate` returns truthy. The predicate is\n * invoked with three arguments: (value, index|key, collection).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n * else `false`.\n * @example\n *\n * _.some([null, 0, 'yes', false], Boolean);\n * // => true\n *\n * var users = [\n * { 'user': 'barney', 'active': true },\n * { 'user': 'fred', 'active': false }\n * ];\n *\n * // The `_.matches` iteratee shorthand.\n * _.some(users, { 'user': 'barney', 'active': false });\n * // => false\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.some(users, ['active', false]);\n * // => true\n *\n * // The `_.property` iteratee shorthand.\n * _.some(users, 'active');\n * // => true\n */\n function some(collection, predicate, guard) {\n var func = isArray(collection) ? arraySome : baseSome;\n if (guard && isIterateeCall(collection, predicate, guard)) {\n predicate = undefined;\n }\n return func(collection, getIteratee(predicate, 3));\n }\n\n /**\n * Creates an array of elements, sorted in ascending order by the results of\n * running each element in a collection thru each iteratee. This method\n * performs a stable sort, that is, it preserves the original sort order of\n * equal elements. The iteratees are invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {...(Function|Function[])} [iteratees=[_.identity]]\n * The iteratees to sort by.\n * @returns {Array} Returns the new sorted array.\n * @example\n *\n * var users = [\n * { 'user': 'fred', 'age': 48 },\n * { 'user': 'barney', 'age': 36 },\n * { 'user': 'fred', 'age': 30 },\n * { 'user': 'barney', 'age': 34 }\n * ];\n *\n * _.sortBy(users, [function(o) { return o.user; }]);\n * // => objects for [['barney', 36], ['barney', 34], ['fred', 48], ['fred', 30]]\n *\n * _.sortBy(users, ['user', 'age']);\n * // => objects for [['barney', 34], ['barney', 36], ['fred', 30], ['fred', 48]]\n */\n var sortBy = baseRest(function(collection, iteratees) {\n if (collection == null) {\n return [];\n }\n var length = iteratees.length;\n if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {\n iteratees = [];\n } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {\n iteratees = [iteratees[0]];\n }\n return baseOrderBy(collection, baseFlatten(iteratees, 1), []);\n });\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Gets the timestamp of the number of milliseconds that have elapsed since\n * the Unix epoch (1 January 1970 00:00:00 UTC).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Date\n * @returns {number} Returns the timestamp.\n * @example\n *\n * _.defer(function(stamp) {\n * console.log(_.now() - stamp);\n * }, _.now());\n * // => Logs the number of milliseconds it took for the deferred invocation.\n */\n var now = ctxNow || function() {\n return root.Date.now();\n };\n\n /*------------------------------------------------------------------------*/\n\n /**\n * The opposite of `_.before`; this method creates a function that invokes\n * `func` once it's called `n` or more times.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {number} n The number of calls before `func` is invoked.\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new restricted function.\n * @example\n *\n * var saves = ['profile', 'settings'];\n *\n * var done = _.after(saves.length, function() {\n * console.log('done saving!');\n * });\n *\n * _.forEach(saves, function(type) {\n * asyncSave({ 'type': type, 'complete': done });\n * });\n * // => Logs 'done saving!' after the two async saves have completed.\n */\n function after(n, func) {\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n n = toInteger(n);\n return function() {\n if (--n < 1) {\n return func.apply(this, arguments);\n }\n };\n }\n\n /**\n * Creates a function that invokes `func`, with up to `n` arguments,\n * ignoring any additional arguments.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {Function} func The function to cap arguments for.\n * @param {number} [n=func.length] The arity cap.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Function} Returns the new capped function.\n * @example\n *\n * _.map(['6', '8', '10'], _.ary(parseInt, 1));\n * // => [6, 8, 10]\n */\n function ary(func, n, guard) {\n n = guard ? undefined : n;\n n = (func && n == null) ? func.length : n;\n return createWrap(func, WRAP_ARY_FLAG, undefined, undefined, undefined, undefined, n);\n }\n\n /**\n * Creates a function that invokes `func`, with the `this` binding and arguments\n * of the created function, while it's called less than `n` times. Subsequent\n * calls to the created function return the result of the last `func` invocation.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {number} n The number of calls at which `func` is no longer invoked.\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new restricted function.\n * @example\n *\n * jQuery(element).on('click', _.before(5, addContactToList));\n * // => Allows adding up to 4 contacts to the list.\n */\n function before(n, func) {\n var result;\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n n = toInteger(n);\n return function() {\n if (--n > 0) {\n result = func.apply(this, arguments);\n }\n if (n <= 1) {\n func = undefined;\n }\n return result;\n };\n }\n\n /**\n * Creates a function that invokes `func` with the `this` binding of `thisArg`\n * and `partials` prepended to the arguments it receives.\n *\n * The `_.bind.placeholder` value, which defaults to `_` in monolithic builds,\n * may be used as a placeholder for partially applied arguments.\n *\n * **Note:** Unlike native `Function#bind`, this method doesn't set the \"length\"\n * property of bound functions.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to bind.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {...*} [partials] The arguments to be partially applied.\n * @returns {Function} Returns the new bound function.\n * @example\n *\n * function greet(greeting, punctuation) {\n * return greeting + ' ' + this.user + punctuation;\n * }\n *\n * var object = { 'user': 'fred' };\n *\n * var bound = _.bind(greet, object, 'hi');\n * bound('!');\n * // => 'hi fred!'\n *\n * // Bound with placeholders.\n * var bound = _.bind(greet, object, _, '!');\n * bound('hi');\n * // => 'hi fred!'\n */\n var bind = baseRest(function(func, thisArg, partials) {\n var bitmask = WRAP_BIND_FLAG;\n if (partials.length) {\n var holders = replaceHolders(partials, getHolder(bind));\n bitmask |= WRAP_PARTIAL_FLAG;\n }\n return createWrap(func, bitmask, thisArg, partials, holders);\n });\n\n /**\n * Creates a function that invokes the method at `object[key]` with `partials`\n * prepended to the arguments it receives.\n *\n * This method differs from `_.bind` by allowing bound functions to reference\n * methods that may be redefined or don't yet exist. See\n * [Peter Michaux's article](http://peter.michaux.ca/articles/lazy-function-definition-pattern)\n * for more details.\n *\n * The `_.bindKey.placeholder` value, which defaults to `_` in monolithic\n * builds, may be used as a placeholder for partially applied arguments.\n *\n * @static\n * @memberOf _\n * @since 0.10.0\n * @category Function\n * @param {Object} object The object to invoke the method on.\n * @param {string} key The key of the method.\n * @param {...*} [partials] The arguments to be partially applied.\n * @returns {Function} Returns the new bound function.\n * @example\n *\n * var object = {\n * 'user': 'fred',\n * 'greet': function(greeting, punctuation) {\n * return greeting + ' ' + this.user + punctuation;\n * }\n * };\n *\n * var bound = _.bindKey(object, 'greet', 'hi');\n * bound('!');\n * // => 'hi fred!'\n *\n * object.greet = function(greeting, punctuation) {\n * return greeting + 'ya ' + this.user + punctuation;\n * };\n *\n * bound('!');\n * // => 'hiya fred!'\n *\n * // Bound with placeholders.\n * var bound = _.bindKey(object, 'greet', _, '!');\n * bound('hi');\n * // => 'hiya fred!'\n */\n var bindKey = baseRest(function(object, key, partials) {\n var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG;\n if (partials.length) {\n var holders = replaceHolders(partials, getHolder(bindKey));\n bitmask |= WRAP_PARTIAL_FLAG;\n }\n return createWrap(key, bitmask, object, partials, holders);\n });\n\n /**\n * Creates a function that accepts arguments of `func` and either invokes\n * `func` returning its result, if at least `arity` number of arguments have\n * been provided, or returns a function that accepts the remaining `func`\n * arguments, and so on. The arity of `func` may be specified if `func.length`\n * is not sufficient.\n *\n * The `_.curry.placeholder` value, which defaults to `_` in monolithic builds,\n * may be used as a placeholder for provided arguments.\n *\n * **Note:** This method doesn't set the \"length\" property of curried functions.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Function\n * @param {Function} func The function to curry.\n * @param {number} [arity=func.length] The arity of `func`.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Function} Returns the new curried function.\n * @example\n *\n * var abc = function(a, b, c) {\n * return [a, b, c];\n * };\n *\n * var curried = _.curry(abc);\n *\n * curried(1)(2)(3);\n * // => [1, 2, 3]\n *\n * curried(1, 2)(3);\n * // => [1, 2, 3]\n *\n * curried(1, 2, 3);\n * // => [1, 2, 3]\n *\n * // Curried with placeholders.\n * curried(1)(_, 3)(2);\n * // => [1, 2, 3]\n */\n function curry(func, arity, guard) {\n arity = guard ? undefined : arity;\n var result = createWrap(func, WRAP_CURRY_FLAG, undefined, undefined, undefined, undefined, undefined, arity);\n result.placeholder = curry.placeholder;\n return result;\n }\n\n /**\n * This method is like `_.curry` except that arguments are applied to `func`\n * in the manner of `_.partialRight` instead of `_.partial`.\n *\n * The `_.curryRight.placeholder` value, which defaults to `_` in monolithic\n * builds, may be used as a placeholder for provided arguments.\n *\n * **Note:** This method doesn't set the \"length\" property of curried functions.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {Function} func The function to curry.\n * @param {number} [arity=func.length] The arity of `func`.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Function} Returns the new curried function.\n * @example\n *\n * var abc = function(a, b, c) {\n * return [a, b, c];\n * };\n *\n * var curried = _.curryRight(abc);\n *\n * curried(3)(2)(1);\n * // => [1, 2, 3]\n *\n * curried(2, 3)(1);\n * // => [1, 2, 3]\n *\n * curried(1, 2, 3);\n * // => [1, 2, 3]\n *\n * // Curried with placeholders.\n * curried(3)(1, _)(2);\n * // => [1, 2, 3]\n */\n function curryRight(func, arity, guard) {\n arity = guard ? undefined : arity;\n var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, undefined, undefined, undefined, undefined, undefined, arity);\n result.placeholder = curryRight.placeholder;\n return result;\n }\n\n /**\n * Creates a debounced function that delays invoking `func` until after `wait`\n * milliseconds have elapsed since the last time the debounced function was\n * invoked. The debounced function comes with a `cancel` method to cancel\n * delayed `func` invocations and a `flush` method to immediately invoke them.\n * Provide `options` to indicate whether `func` should be invoked on the\n * leading and/or trailing edge of the `wait` timeout. The `func` is invoked\n * with the last arguments provided to the debounced function. Subsequent\n * calls to the debounced function return the result of the last `func`\n * invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the debounced function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.debounce` and `_.throttle`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to debounce.\n * @param {number} [wait=0] The number of milliseconds to delay.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=false]\n * Specify invoking on the leading edge of the timeout.\n * @param {number} [options.maxWait]\n * The maximum time `func` is allowed to be delayed before it's invoked.\n * @param {boolean} [options.trailing=true]\n * Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new debounced function.\n * @example\n *\n * // Avoid costly calculations while the window size is in flux.\n * jQuery(window).on('resize', _.debounce(calculateLayout, 150));\n *\n * // Invoke `sendMail` when clicked, debouncing subsequent calls.\n * jQuery(element).on('click', _.debounce(sendMail, 300, {\n * 'leading': true,\n * 'trailing': false\n * }));\n *\n * // Ensure `batchLog` is invoked once after 1 second of debounced calls.\n * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 });\n * var source = new EventSource('/stream');\n * jQuery(source).on('message', debounced);\n *\n * // Cancel the trailing debounced invocation.\n * jQuery(window).on('popstate', debounced.cancel);\n */\n function debounce(func, wait, options) {\n var lastArgs,\n lastThis,\n maxWait,\n result,\n timerId,\n lastCallTime,\n lastInvokeTime = 0,\n leading = false,\n maxing = false,\n trailing = true;\n\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n wait = toNumber(wait) || 0;\n if (isObject(options)) {\n leading = !!options.leading;\n maxing = 'maxWait' in options;\n maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;\n trailing = 'trailing' in options ? !!options.trailing : trailing;\n }\n\n function invokeFunc(time) {\n var args = lastArgs,\n thisArg = lastThis;\n\n lastArgs = lastThis = undefined;\n lastInvokeTime = time;\n result = func.apply(thisArg, args);\n return result;\n }\n\n function leadingEdge(time) {\n // Reset any `maxWait` timer.\n lastInvokeTime = time;\n // Start the timer for the trailing edge.\n timerId = setTimeout(timerExpired, wait);\n // Invoke the leading edge.\n return leading ? invokeFunc(time) : result;\n }\n\n function remainingWait(time) {\n var timeSinceLastCall = time - lastCallTime,\n timeSinceLastInvoke = time - lastInvokeTime,\n timeWaiting = wait - timeSinceLastCall;\n\n return maxing\n ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke)\n : timeWaiting;\n }\n\n function shouldInvoke(time) {\n var timeSinceLastCall = time - lastCallTime,\n timeSinceLastInvoke = time - lastInvokeTime;\n\n // Either this is the first call, activity has stopped and we're at the\n // trailing edge, the system time has gone backwards and we're treating\n // it as the trailing edge, or we've hit the `maxWait` limit.\n return (lastCallTime === undefined || (timeSinceLastCall >= wait) ||\n (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait));\n }\n\n function timerExpired() {\n var time = now();\n if (shouldInvoke(time)) {\n return trailingEdge(time);\n }\n // Restart the timer.\n timerId = setTimeout(timerExpired, remainingWait(time));\n }\n\n function trailingEdge(time) {\n timerId = undefined;\n\n // Only invoke if we have `lastArgs` which means `func` has been\n // debounced at least once.\n if (trailing && lastArgs) {\n return invokeFunc(time);\n }\n lastArgs = lastThis = undefined;\n return result;\n }\n\n function cancel() {\n if (timerId !== undefined) {\n clearTimeout(timerId);\n }\n lastInvokeTime = 0;\n lastArgs = lastCallTime = lastThis = timerId = undefined;\n }\n\n function flush() {\n return timerId === undefined ? result : trailingEdge(now());\n }\n\n function debounced() {\n var time = now(),\n isInvoking = shouldInvoke(time);\n\n lastArgs = arguments;\n lastThis = this;\n lastCallTime = time;\n\n if (isInvoking) {\n if (timerId === undefined) {\n return leadingEdge(lastCallTime);\n }\n if (maxing) {\n // Handle invocations in a tight loop.\n clearTimeout(timerId);\n timerId = setTimeout(timerExpired, wait);\n return invokeFunc(lastCallTime);\n }\n }\n if (timerId === undefined) {\n timerId = setTimeout(timerExpired, wait);\n }\n return result;\n }\n debounced.cancel = cancel;\n debounced.flush = flush;\n return debounced;\n }\n\n /**\n * Defers invoking the `func` until the current call stack has cleared. Any\n * additional arguments are provided to `func` when it's invoked.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to defer.\n * @param {...*} [args] The arguments to invoke `func` with.\n * @returns {number} Returns the timer id.\n * @example\n *\n * _.defer(function(text) {\n * console.log(text);\n * }, 'deferred');\n * // => Logs 'deferred' after one millisecond.\n */\n var defer = baseRest(function(func, args) {\n return baseDelay(func, 1, args);\n });\n\n /**\n * Invokes `func` after `wait` milliseconds. Any additional arguments are\n * provided to `func` when it's invoked.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to delay.\n * @param {number} wait The number of milliseconds to delay invocation.\n * @param {...*} [args] The arguments to invoke `func` with.\n * @returns {number} Returns the timer id.\n * @example\n *\n * _.delay(function(text) {\n * console.log(text);\n * }, 1000, 'later');\n * // => Logs 'later' after one second.\n */\n var delay = baseRest(function(func, wait, args) {\n return baseDelay(func, toNumber(wait) || 0, args);\n });\n\n /**\n * Creates a function that invokes `func` with arguments reversed.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Function\n * @param {Function} func The function to flip arguments for.\n * @returns {Function} Returns the new flipped function.\n * @example\n *\n * var flipped = _.flip(function() {\n * return _.toArray(arguments);\n * });\n *\n * flipped('a', 'b', 'c', 'd');\n * // => ['d', 'c', 'b', 'a']\n */\n function flip(func) {\n return createWrap(func, WRAP_FLIP_FLAG);\n }\n\n /**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\n function memoize(func, resolver) {\n if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n var memoized = function() {\n var args = arguments,\n key = resolver ? resolver.apply(this, args) : args[0],\n cache = memoized.cache;\n\n if (cache.has(key)) {\n return cache.get(key);\n }\n var result = func.apply(this, args);\n memoized.cache = cache.set(key, result) || cache;\n return result;\n };\n memoized.cache = new (memoize.Cache || MapCache);\n return memoized;\n }\n\n // Expose `MapCache`.\n memoize.Cache = MapCache;\n\n /**\n * Creates a function that negates the result of the predicate `func`. The\n * `func` predicate is invoked with the `this` binding and arguments of the\n * created function.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {Function} predicate The predicate to negate.\n * @returns {Function} Returns the new negated function.\n * @example\n *\n * function isEven(n) {\n * return n % 2 == 0;\n * }\n *\n * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));\n * // => [1, 3, 5]\n */\n function negate(predicate) {\n if (typeof predicate != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n return function() {\n var args = arguments;\n switch (args.length) {\n case 0: return !predicate.call(this);\n case 1: return !predicate.call(this, args[0]);\n case 2: return !predicate.call(this, args[0], args[1]);\n case 3: return !predicate.call(this, args[0], args[1], args[2]);\n }\n return !predicate.apply(this, args);\n };\n }\n\n /**\n * Creates a function that is restricted to invoking `func` once. Repeat calls\n * to the function return the value of the first invocation. The `func` is\n * invoked with the `this` binding and arguments of the created function.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new restricted function.\n * @example\n *\n * var initialize = _.once(createApplication);\n * initialize();\n * initialize();\n * // => `createApplication` is invoked once\n */\n function once(func) {\n return before(2, func);\n }\n\n /**\n * Creates a function that invokes `func` with its arguments transformed.\n *\n * @static\n * @since 4.0.0\n * @memberOf _\n * @category Function\n * @param {Function} func The function to wrap.\n * @param {...(Function|Function[])} [transforms=[_.identity]]\n * The argument transforms.\n * @returns {Function} Returns the new function.\n * @example\n *\n * function doubled(n) {\n * return n * 2;\n * }\n *\n * function square(n) {\n * return n * n;\n * }\n *\n * var func = _.overArgs(function(x, y) {\n * return [x, y];\n * }, [square, doubled]);\n *\n * func(9, 3);\n * // => [81, 6]\n *\n * func(10, 5);\n * // => [100, 10]\n */\n var overArgs = castRest(function(func, transforms) {\n transforms = (transforms.length == 1 && isArray(transforms[0]))\n ? arrayMap(transforms[0], baseUnary(getIteratee()))\n : arrayMap(baseFlatten(transforms, 1), baseUnary(getIteratee()));\n\n var funcsLength = transforms.length;\n return baseRest(function(args) {\n var index = -1,\n length = nativeMin(args.length, funcsLength);\n\n while (++index < length) {\n args[index] = transforms[index].call(this, args[index]);\n }\n return apply(func, this, args);\n });\n });\n\n /**\n * Creates a function that invokes `func` with `partials` prepended to the\n * arguments it receives. This method is like `_.bind` except it does **not**\n * alter the `this` binding.\n *\n * The `_.partial.placeholder` value, which defaults to `_` in monolithic\n * builds, may be used as a placeholder for partially applied arguments.\n *\n * **Note:** This method doesn't set the \"length\" property of partially\n * applied functions.\n *\n * @static\n * @memberOf _\n * @since 0.2.0\n * @category Function\n * @param {Function} func The function to partially apply arguments to.\n * @param {...*} [partials] The arguments to be partially applied.\n * @returns {Function} Returns the new partially applied function.\n * @example\n *\n * function greet(greeting, name) {\n * return greeting + ' ' + name;\n * }\n *\n * var sayHelloTo = _.partial(greet, 'hello');\n * sayHelloTo('fred');\n * // => 'hello fred'\n *\n * // Partially applied with placeholders.\n * var greetFred = _.partial(greet, _, 'fred');\n * greetFred('hi');\n * // => 'hi fred'\n */\n var partial = baseRest(function(func, partials) {\n var holders = replaceHolders(partials, getHolder(partial));\n return createWrap(func, WRAP_PARTIAL_FLAG, undefined, partials, holders);\n });\n\n /**\n * This method is like `_.partial` except that partially applied arguments\n * are appended to the arguments it receives.\n *\n * The `_.partialRight.placeholder` value, which defaults to `_` in monolithic\n * builds, may be used as a placeholder for partially applied arguments.\n *\n * **Note:** This method doesn't set the \"length\" property of partially\n * applied functions.\n *\n * @static\n * @memberOf _\n * @since 1.0.0\n * @category Function\n * @param {Function} func The function to partially apply arguments to.\n * @param {...*} [partials] The arguments to be partially applied.\n * @returns {Function} Returns the new partially applied function.\n * @example\n *\n * function greet(greeting, name) {\n * return greeting + ' ' + name;\n * }\n *\n * var greetFred = _.partialRight(greet, 'fred');\n * greetFred('hi');\n * // => 'hi fred'\n *\n * // Partially applied with placeholders.\n * var sayHelloTo = _.partialRight(greet, 'hello', _);\n * sayHelloTo('fred');\n * // => 'hello fred'\n */\n var partialRight = baseRest(function(func, partials) {\n var holders = replaceHolders(partials, getHolder(partialRight));\n return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, undefined, partials, holders);\n });\n\n /**\n * Creates a function that invokes `func` with arguments arranged according\n * to the specified `indexes` where the argument value at the first index is\n * provided as the first argument, the argument value at the second index is\n * provided as the second argument, and so on.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {Function} func The function to rearrange arguments for.\n * @param {...(number|number[])} indexes The arranged argument indexes.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var rearged = _.rearg(function(a, b, c) {\n * return [a, b, c];\n * }, [2, 0, 1]);\n *\n * rearged('b', 'c', 'a')\n * // => ['a', 'b', 'c']\n */\n var rearg = flatRest(function(func, indexes) {\n return createWrap(func, WRAP_REARG_FLAG, undefined, undefined, undefined, indexes);\n });\n\n /**\n * Creates a function that invokes `func` with the `this` binding of the\n * created function and arguments from `start` and beyond provided as\n * an array.\n *\n * **Note:** This method is based on the\n * [rest parameter](https://mdn.io/rest_parameters).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Function\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var say = _.rest(function(what, names) {\n * return what + ' ' + _.initial(names).join(', ') +\n * (_.size(names) > 1 ? ', & ' : '') + _.last(names);\n * });\n *\n * say('hello', 'fred', 'barney', 'pebbles');\n * // => 'hello fred, barney, & pebbles'\n */\n function rest(func, start) {\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n start = start === undefined ? start : toInteger(start);\n return baseRest(func, start);\n }\n\n /**\n * Creates a function that invokes `func` with the `this` binding of the\n * create function and an array of arguments much like\n * [`Function#apply`](http://www.ecma-international.org/ecma-262/7.0/#sec-function.prototype.apply).\n *\n * **Note:** This method is based on the\n * [spread operator](https://mdn.io/spread_operator).\n *\n * @static\n * @memberOf _\n * @since 3.2.0\n * @category Function\n * @param {Function} func The function to spread arguments over.\n * @param {number} [start=0] The start position of the spread.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var say = _.spread(function(who, what) {\n * return who + ' says ' + what;\n * });\n *\n * say(['fred', 'hello']);\n * // => 'fred says hello'\n *\n * var numbers = Promise.all([\n * Promise.resolve(40),\n * Promise.resolve(36)\n * ]);\n *\n * numbers.then(_.spread(function(x, y) {\n * return x + y;\n * }));\n * // => a Promise of 76\n */\n function spread(func, start) {\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n start = start == null ? 0 : nativeMax(toInteger(start), 0);\n return baseRest(function(args) {\n var array = args[start],\n otherArgs = castSlice(args, 0, start);\n\n if (array) {\n arrayPush(otherArgs, array);\n }\n return apply(func, this, otherArgs);\n });\n }\n\n /**\n * Creates a throttled function that only invokes `func` at most once per\n * every `wait` milliseconds. The throttled function comes with a `cancel`\n * method to cancel delayed `func` invocations and a `flush` method to\n * immediately invoke them. Provide `options` to indicate whether `func`\n * should be invoked on the leading and/or trailing edge of the `wait`\n * timeout. The `func` is invoked with the last arguments provided to the\n * throttled function. Subsequent calls to the throttled function return the\n * result of the last `func` invocation.\n *\n * **Note:** If `leading` and `trailing` options are `true`, `func` is\n * invoked on the trailing edge of the timeout only if the throttled function\n * is invoked more than once during the `wait` timeout.\n *\n * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred\n * until to the next tick, similar to `setTimeout` with a timeout of `0`.\n *\n * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)\n * for details over the differences between `_.throttle` and `_.debounce`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to throttle.\n * @param {number} [wait=0] The number of milliseconds to throttle invocations to.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.leading=true]\n * Specify invoking on the leading edge of the timeout.\n * @param {boolean} [options.trailing=true]\n * Specify invoking on the trailing edge of the timeout.\n * @returns {Function} Returns the new throttled function.\n * @example\n *\n * // Avoid excessively updating the position while scrolling.\n * jQuery(window).on('scroll', _.throttle(updatePosition, 100));\n *\n * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes.\n * var throttled = _.throttle(renewToken, 300000, { 'trailing': false });\n * jQuery(element).on('click', throttled);\n *\n * // Cancel the trailing throttled invocation.\n * jQuery(window).on('popstate', throttled.cancel);\n */\n function throttle(func, wait, options) {\n var leading = true,\n trailing = true;\n\n if (typeof func != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n if (isObject(options)) {\n leading = 'leading' in options ? !!options.leading : leading;\n trailing = 'trailing' in options ? !!options.trailing : trailing;\n }\n return debounce(func, wait, {\n 'leading': leading,\n 'maxWait': wait,\n 'trailing': trailing\n });\n }\n\n /**\n * Creates a function that accepts up to one argument, ignoring any\n * additional arguments.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Function\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n * @example\n *\n * _.map(['6', '8', '10'], _.unary(parseInt));\n * // => [6, 8, 10]\n */\n function unary(func) {\n return ary(func, 1);\n }\n\n /**\n * Creates a function that provides `value` to `wrapper` as its first\n * argument. Any additional arguments provided to the function are appended\n * to those provided to the `wrapper`. The wrapper is invoked with the `this`\n * binding of the created function.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {*} value The value to wrap.\n * @param {Function} [wrapper=identity] The wrapper function.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var p = _.wrap(_.escape, function(func, text) {\n * return '<p>' + func(text) + '</p>';\n * });\n *\n * p('fred, barney, & pebbles');\n * // => '<p>fred, barney, & pebbles</p>'\n */\n function wrap(value, wrapper) {\n return partial(castFunction(wrapper), value);\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Casts `value` as an array if it's not one.\n *\n * @static\n * @memberOf _\n * @since 4.4.0\n * @category Lang\n * @param {*} value The value to inspect.\n * @returns {Array} Returns the cast array.\n * @example\n *\n * _.castArray(1);\n * // => [1]\n *\n * _.castArray({ 'a': 1 });\n * // => [{ 'a': 1 }]\n *\n * _.castArray('abc');\n * // => ['abc']\n *\n * _.castArray(null);\n * // => [null]\n *\n * _.castArray(undefined);\n * // => [undefined]\n *\n * _.castArray();\n * // => []\n *\n * var array = [1, 2, 3];\n * console.log(_.castArray(array) === array);\n * // => true\n */\n function castArray() {\n if (!arguments.length) {\n return [];\n }\n var value = arguments[0];\n return isArray(value) ? value : [value];\n }\n\n /**\n * Creates a shallow clone of `value`.\n *\n * **Note:** This method is loosely based on the\n * [structured clone algorithm](https://mdn.io/Structured_clone_algorithm)\n * and supports cloning arrays, array buffers, booleans, date objects, maps,\n * numbers, `Object` objects, regexes, sets, strings, symbols, and typed\n * arrays. The own enumerable properties of `arguments` objects are cloned\n * as plain objects. An empty object is returned for uncloneable values such\n * as error objects, functions, DOM nodes, and WeakMaps.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to clone.\n * @returns {*} Returns the cloned value.\n * @see _.cloneDeep\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var shallow = _.clone(objects);\n * console.log(shallow[0] === objects[0]);\n * // => true\n */\n function clone(value) {\n return baseClone(value, CLONE_SYMBOLS_FLAG);\n }\n\n /**\n * This method is like `_.clone` except that it accepts `customizer` which\n * is invoked to produce the cloned value. If `customizer` returns `undefined`,\n * cloning is handled by the method instead. The `customizer` is invoked with\n * up to four arguments; (value [, index|key, object, stack]).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to clone.\n * @param {Function} [customizer] The function to customize cloning.\n * @returns {*} Returns the cloned value.\n * @see _.cloneDeepWith\n * @example\n *\n * function customizer(value) {\n * if (_.isElement(value)) {\n * return value.cloneNode(false);\n * }\n * }\n *\n * var el = _.cloneWith(document.body, customizer);\n *\n * console.log(el === document.body);\n * // => false\n * console.log(el.nodeName);\n * // => 'BODY'\n * console.log(el.childNodes.length);\n * // => 0\n */\n function cloneWith(value, customizer) {\n customizer = typeof customizer == 'function' ? customizer : undefined;\n return baseClone(value, CLONE_SYMBOLS_FLAG, customizer);\n }\n\n /**\n * This method is like `_.clone` except that it recursively clones `value`.\n *\n * @static\n * @memberOf _\n * @since 1.0.0\n * @category Lang\n * @param {*} value The value to recursively clone.\n * @returns {*} Returns the deep cloned value.\n * @see _.clone\n * @example\n *\n * var objects = [{ 'a': 1 }, { 'b': 2 }];\n *\n * var deep = _.cloneDeep(objects);\n * console.log(deep[0] === objects[0]);\n * // => false\n */\n function cloneDeep(value) {\n return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);\n }\n\n /**\n * This method is like `_.cloneWith` except that it recursively clones `value`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to recursively clone.\n * @param {Function} [customizer] The function to customize cloning.\n * @returns {*} Returns the deep cloned value.\n * @see _.cloneWith\n * @example\n *\n * function customizer(value) {\n * if (_.isElement(value)) {\n * return value.cloneNode(true);\n * }\n * }\n *\n * var el = _.cloneDeepWith(document.body, customizer);\n *\n * console.log(el === document.body);\n * // => false\n * console.log(el.nodeName);\n * // => 'BODY'\n * console.log(el.childNodes.length);\n * // => 20\n */\n function cloneDeepWith(value, customizer) {\n customizer = typeof customizer == 'function' ? customizer : undefined;\n return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);\n }\n\n /**\n * Checks if `object` conforms to `source` by invoking the predicate\n * properties of `source` with the corresponding property values of `object`.\n *\n * **Note:** This method is equivalent to `_.conforms` when `source` is\n * partially applied.\n *\n * @static\n * @memberOf _\n * @since 4.14.0\n * @category Lang\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property predicates to conform to.\n * @returns {boolean} Returns `true` if `object` conforms, else `false`.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n *\n * _.conformsTo(object, { 'b': function(n) { return n > 1; } });\n * // => true\n *\n * _.conformsTo(object, { 'b': function(n) { return n > 2; } });\n * // => false\n */\n function conformsTo(object, source) {\n return source == null || baseConformsTo(object, source, keys(source));\n }\n\n /**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\n function eq(value, other) {\n return value === other || (value !== value && other !== other);\n }\n\n /**\n * Checks if `value` is greater than `other`.\n *\n * @static\n * @memberOf _\n * @since 3.9.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if `value` is greater than `other`,\n * else `false`.\n * @see _.lt\n * @example\n *\n * _.gt(3, 1);\n * // => true\n *\n * _.gt(3, 3);\n * // => false\n *\n * _.gt(1, 3);\n * // => false\n */\n var gt = createRelationalOperation(baseGt);\n\n /**\n * Checks if `value` is greater than or equal to `other`.\n *\n * @static\n * @memberOf _\n * @since 3.9.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if `value` is greater than or equal to\n * `other`, else `false`.\n * @see _.lte\n * @example\n *\n * _.gte(3, 1);\n * // => true\n *\n * _.gte(3, 3);\n * // => true\n *\n * _.gte(1, 3);\n * // => false\n */\n var gte = createRelationalOperation(function(value, other) {\n return value >= other;\n });\n\n /**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\n var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n !propertyIsEnumerable.call(value, 'callee');\n };\n\n /**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\n var isArray = Array.isArray;\n\n /**\n * Checks if `value` is classified as an `ArrayBuffer` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.\n * @example\n *\n * _.isArrayBuffer(new ArrayBuffer(2));\n * // => true\n *\n * _.isArrayBuffer(new Array(2));\n * // => false\n */\n var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;\n\n /**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\n function isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n }\n\n /**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n * else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\n function isArrayLikeObject(value) {\n return isObjectLike(value) && isArrayLike(value);\n }\n\n /**\n * Checks if `value` is classified as a boolean primitive or object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a boolean, else `false`.\n * @example\n *\n * _.isBoolean(false);\n * // => true\n *\n * _.isBoolean(null);\n * // => false\n */\n function isBoolean(value) {\n return value === true || value === false ||\n (isObjectLike(value) && baseGetTag(value) == boolTag);\n }\n\n /**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\n var isBuffer = nativeIsBuffer || stubFalse;\n\n /**\n * Checks if `value` is classified as a `Date` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a date object, else `false`.\n * @example\n *\n * _.isDate(new Date);\n * // => true\n *\n * _.isDate('Mon April 23 2012');\n * // => false\n */\n var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;\n\n /**\n * Checks if `value` is likely a DOM element.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.\n * @example\n *\n * _.isElement(document.body);\n * // => true\n *\n * _.isElement('<body>');\n * // => false\n */\n function isElement(value) {\n return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);\n }\n\n /**\n * Checks if `value` is an empty object, collection, map, or set.\n *\n * Objects are considered empty if they have no own enumerable string keyed\n * properties.\n *\n * Array-like values such as `arguments` objects, arrays, buffers, strings, or\n * jQuery-like collections are considered empty if they have a `length` of `0`.\n * Similarly, maps and sets are considered empty if they have a `size` of `0`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is empty, else `false`.\n * @example\n *\n * _.isEmpty(null);\n * // => true\n *\n * _.isEmpty(true);\n * // => true\n *\n * _.isEmpty(1);\n * // => true\n *\n * _.isEmpty([1, 2, 3]);\n * // => false\n *\n * _.isEmpty({ 'a': 1 });\n * // => false\n */\n function isEmpty(value) {\n if (value == null) {\n return true;\n }\n if (isArrayLike(value) &&\n (isArray(value) || typeof value == 'string' || typeof value.splice == 'function' ||\n isBuffer(value) || isTypedArray(value) || isArguments(value))) {\n return !value.length;\n }\n var tag = getTag(value);\n if (tag == mapTag || tag == setTag) {\n return !value.size;\n }\n if (isPrototype(value)) {\n return !baseKeys(value).length;\n }\n for (var key in value) {\n if (hasOwnProperty.call(value, key)) {\n return false;\n }\n }\n return true;\n }\n\n /**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\n function isEqual(value, other) {\n return baseIsEqual(value, other);\n }\n\n /**\n * This method is like `_.isEqual` except that it accepts `customizer` which\n * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n * are handled by the method instead. The `customizer` is invoked with up to\n * six arguments: (objValue, othValue [, index|key, object, other, stack]).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {Function} [customizer] The function to customize comparisons.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * function isGreeting(value) {\n * return /^h(?:i|ello)$/.test(value);\n * }\n *\n * function customizer(objValue, othValue) {\n * if (isGreeting(objValue) && isGreeting(othValue)) {\n * return true;\n * }\n * }\n *\n * var array = ['hello', 'goodbye'];\n * var other = ['hi', 'goodbye'];\n *\n * _.isEqualWith(array, other, customizer);\n * // => true\n */\n function isEqualWith(value, other, customizer) {\n customizer = typeof customizer == 'function' ? customizer : undefined;\n var result = customizer ? customizer(value, other) : undefined;\n return result === undefined ? baseIsEqual(value, other, undefined, customizer) : !!result;\n }\n\n /**\n * Checks if `value` is an `Error`, `EvalError`, `RangeError`, `ReferenceError`,\n * `SyntaxError`, `TypeError`, or `URIError` object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an error object, else `false`.\n * @example\n *\n * _.isError(new Error);\n * // => true\n *\n * _.isError(Error);\n * // => false\n */\n function isError(value) {\n if (!isObjectLike(value)) {\n return false;\n }\n var tag = baseGetTag(value);\n return tag == errorTag || tag == domExcTag ||\n (typeof value.message == 'string' && typeof value.name == 'string' && !isPlainObject(value));\n }\n\n /**\n * Checks if `value` is a finite primitive number.\n *\n * **Note:** This method is based on\n * [`Number.isFinite`](https://mdn.io/Number/isFinite).\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a finite number, else `false`.\n * @example\n *\n * _.isFinite(3);\n * // => true\n *\n * _.isFinite(Number.MIN_VALUE);\n * // => true\n *\n * _.isFinite(Infinity);\n * // => false\n *\n * _.isFinite('3');\n * // => false\n */\n function isFinite(value) {\n return typeof value == 'number' && nativeIsFinite(value);\n }\n\n /**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\n function isFunction(value) {\n if (!isObject(value)) {\n return false;\n }\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 9 which returns 'object' for typed arrays and other constructors.\n var tag = baseGetTag(value);\n return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n }\n\n /**\n * Checks if `value` is an integer.\n *\n * **Note:** This method is based on\n * [`Number.isInteger`](https://mdn.io/Number/isInteger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an integer, else `false`.\n * @example\n *\n * _.isInteger(3);\n * // => true\n *\n * _.isInteger(Number.MIN_VALUE);\n * // => false\n *\n * _.isInteger(Infinity);\n * // => false\n *\n * _.isInteger('3');\n * // => false\n */\n function isInteger(value) {\n return typeof value == 'number' && value == toInteger(value);\n }\n\n /**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\n function isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n }\n\n /**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\n function isObject(value) {\n var type = typeof value;\n return value != null && (type == 'object' || type == 'function');\n }\n\n /**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\n function isObjectLike(value) {\n return value != null && typeof value == 'object';\n }\n\n /**\n * Checks if `value` is classified as a `Map` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a map, else `false`.\n * @example\n *\n * _.isMap(new Map);\n * // => true\n *\n * _.isMap(new WeakMap);\n * // => false\n */\n var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;\n\n /**\n * Performs a partial deep comparison between `object` and `source` to\n * determine if `object` contains equivalent property values.\n *\n * **Note:** This method is equivalent to `_.matches` when `source` is\n * partially applied.\n *\n * Partial comparisons will match empty array and empty object `source`\n * values against any array or object value, respectively. See `_.isEqual`\n * for a list of supported value comparisons.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property values to match.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n *\n * _.isMatch(object, { 'b': 2 });\n * // => true\n *\n * _.isMatch(object, { 'b': 1 });\n * // => false\n */\n function isMatch(object, source) {\n return object === source || baseIsMatch(object, source, getMatchData(source));\n }\n\n /**\n * This method is like `_.isMatch` except that it accepts `customizer` which\n * is invoked to compare values. If `customizer` returns `undefined`, comparisons\n * are handled by the method instead. The `customizer` is invoked with five\n * arguments: (objValue, srcValue, index|key, object, source).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {Object} object The object to inspect.\n * @param {Object} source The object of property values to match.\n * @param {Function} [customizer] The function to customize comparisons.\n * @returns {boolean} Returns `true` if `object` is a match, else `false`.\n * @example\n *\n * function isGreeting(value) {\n * return /^h(?:i|ello)$/.test(value);\n * }\n *\n * function customizer(objValue, srcValue) {\n * if (isGreeting(objValue) && isGreeting(srcValue)) {\n * return true;\n * }\n * }\n *\n * var object = { 'greeting': 'hello' };\n * var source = { 'greeting': 'hi' };\n *\n * _.isMatchWith(object, source, customizer);\n * // => true\n */\n function isMatchWith(object, source, customizer) {\n customizer = typeof customizer == 'function' ? customizer : undefined;\n return baseIsMatch(object, source, getMatchData(source), customizer);\n }\n\n /**\n * Checks if `value` is `NaN`.\n *\n * **Note:** This method is based on\n * [`Number.isNaN`](https://mdn.io/Number/isNaN) and is not the same as\n * global [`isNaN`](https://mdn.io/isNaN) which returns `true` for\n * `undefined` and other non-number values.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `NaN`, else `false`.\n * @example\n *\n * _.isNaN(NaN);\n * // => true\n *\n * _.isNaN(new Number(NaN));\n * // => true\n *\n * isNaN(undefined);\n * // => true\n *\n * _.isNaN(undefined);\n * // => false\n */\n function isNaN(value) {\n // An `NaN` primitive is the only value that is not equal to itself.\n // Perform the `toStringTag` check first to avoid errors with some\n // ActiveX objects in IE.\n return isNumber(value) && value != +value;\n }\n\n /**\n * Checks if `value` is a pristine native function.\n *\n * **Note:** This method can't reliably detect native functions in the presence\n * of the core-js package because core-js circumvents this kind of detection.\n * Despite multiple requests, the core-js maintainer has made it clear: any\n * attempt to fix the detection will be obstructed. As a result, we're left\n * with little choice but to throw an error. Unfortunately, this also affects\n * packages, like [babel-polyfill](https://www.npmjs.com/package/babel-polyfill),\n * which rely on core-js.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n * @example\n *\n * _.isNative(Array.prototype.push);\n * // => true\n *\n * _.isNative(_);\n * // => false\n */\n function isNative(value) {\n if (isMaskable(value)) {\n throw new Error(CORE_ERROR_TEXT);\n }\n return baseIsNative(value);\n }\n\n /**\n * Checks if `value` is `null`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `null`, else `false`.\n * @example\n *\n * _.isNull(null);\n * // => true\n *\n * _.isNull(void 0);\n * // => false\n */\n function isNull(value) {\n return value === null;\n }\n\n /**\n * Checks if `value` is `null` or `undefined`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is nullish, else `false`.\n * @example\n *\n * _.isNil(null);\n * // => true\n *\n * _.isNil(void 0);\n * // => true\n *\n * _.isNil(NaN);\n * // => false\n */\n function isNil(value) {\n return value == null;\n }\n\n /**\n * Checks if `value` is classified as a `Number` primitive or object.\n *\n * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are\n * classified as numbers, use the `_.isFinite` method.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a number, else `false`.\n * @example\n *\n * _.isNumber(3);\n * // => true\n *\n * _.isNumber(Number.MIN_VALUE);\n * // => true\n *\n * _.isNumber(Infinity);\n * // => true\n *\n * _.isNumber('3');\n * // => false\n */\n function isNumber(value) {\n return typeof value == 'number' ||\n (isObjectLike(value) && baseGetTag(value) == numberTag);\n }\n\n /**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\n function isPlainObject(value) {\n if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n return false;\n }\n var proto = getPrototype(value);\n if (proto === null) {\n return true;\n }\n var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n funcToString.call(Ctor) == objectCtorString;\n }\n\n /**\n * Checks if `value` is classified as a `RegExp` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a regexp, else `false`.\n * @example\n *\n * _.isRegExp(/abc/);\n * // => true\n *\n * _.isRegExp('/abc/');\n * // => false\n */\n var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;\n\n /**\n * Checks if `value` is a safe integer. An integer is safe if it's an IEEE-754\n * double precision number which isn't the result of a rounded unsafe integer.\n *\n * **Note:** This method is based on\n * [`Number.isSafeInteger`](https://mdn.io/Number/isSafeInteger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a safe integer, else `false`.\n * @example\n *\n * _.isSafeInteger(3);\n * // => true\n *\n * _.isSafeInteger(Number.MIN_VALUE);\n * // => false\n *\n * _.isSafeInteger(Infinity);\n * // => false\n *\n * _.isSafeInteger('3');\n * // => false\n */\n function isSafeInteger(value) {\n return isInteger(value) && value >= -MAX_SAFE_INTEGER && value <= MAX_SAFE_INTEGER;\n }\n\n /**\n * Checks if `value` is classified as a `Set` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a set, else `false`.\n * @example\n *\n * _.isSet(new Set);\n * // => true\n *\n * _.isSet(new WeakSet);\n * // => false\n */\n var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;\n\n /**\n * Checks if `value` is classified as a `String` primitive or object.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n * @example\n *\n * _.isString('abc');\n * // => true\n *\n * _.isString(1);\n * // => false\n */\n function isString(value) {\n return typeof value == 'string' ||\n (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n }\n\n /**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\n function isSymbol(value) {\n return typeof value == 'symbol' ||\n (isObjectLike(value) && baseGetTag(value) == symbolTag);\n }\n\n /**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\n var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\n /**\n * Checks if `value` is `undefined`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is `undefined`, else `false`.\n * @example\n *\n * _.isUndefined(void 0);\n * // => true\n *\n * _.isUndefined(null);\n * // => false\n */\n function isUndefined(value) {\n return value === undefined;\n }\n\n /**\n * Checks if `value` is classified as a `WeakMap` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a weak map, else `false`.\n * @example\n *\n * _.isWeakMap(new WeakMap);\n * // => true\n *\n * _.isWeakMap(new Map);\n * // => false\n */\n function isWeakMap(value) {\n return isObjectLike(value) && getTag(value) == weakMapTag;\n }\n\n /**\n * Checks if `value` is classified as a `WeakSet` object.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a weak set, else `false`.\n * @example\n *\n * _.isWeakSet(new WeakSet);\n * // => true\n *\n * _.isWeakSet(new Set);\n * // => false\n */\n function isWeakSet(value) {\n return isObjectLike(value) && baseGetTag(value) == weakSetTag;\n }\n\n /**\n * Checks if `value` is less than `other`.\n *\n * @static\n * @memberOf _\n * @since 3.9.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if `value` is less than `other`,\n * else `false`.\n * @see _.gt\n * @example\n *\n * _.lt(1, 3);\n * // => true\n *\n * _.lt(3, 3);\n * // => false\n *\n * _.lt(3, 1);\n * // => false\n */\n var lt = createRelationalOperation(baseLt);\n\n /**\n * Checks if `value` is less than or equal to `other`.\n *\n * @static\n * @memberOf _\n * @since 3.9.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if `value` is less than or equal to\n * `other`, else `false`.\n * @see _.gte\n * @example\n *\n * _.lte(1, 3);\n * // => true\n *\n * _.lte(3, 3);\n * // => true\n *\n * _.lte(3, 1);\n * // => false\n */\n var lte = createRelationalOperation(function(value, other) {\n return value <= other;\n });\n\n /**\n * Converts `value` to an array.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Array} Returns the converted array.\n * @example\n *\n * _.toArray({ 'a': 1, 'b': 2 });\n * // => [1, 2]\n *\n * _.toArray('abc');\n * // => ['a', 'b', 'c']\n *\n * _.toArray(1);\n * // => []\n *\n * _.toArray(null);\n * // => []\n */\n function toArray(value) {\n if (!value) {\n return [];\n }\n if (isArrayLike(value)) {\n return isString(value) ? stringToArray(value) : copyArray(value);\n }\n if (symIterator && value[symIterator]) {\n return iteratorToArray(value[symIterator]());\n }\n var tag = getTag(value),\n func = tag == mapTag ? mapToArray : (tag == setTag ? setToArray : values);\n\n return func(value);\n }\n\n /**\n * Converts `value` to a finite number.\n *\n * @static\n * @memberOf _\n * @since 4.12.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted number.\n * @example\n *\n * _.toFinite(3.2);\n * // => 3.2\n *\n * _.toFinite(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toFinite(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toFinite('3.2');\n * // => 3.2\n */\n function toFinite(value) {\n if (!value) {\n return value === 0 ? value : 0;\n }\n value = toNumber(value);\n if (value === INFINITY || value === -INFINITY) {\n var sign = (value < 0 ? -1 : 1);\n return sign * MAX_INTEGER;\n }\n return value === value ? value : 0;\n }\n\n /**\n * Converts `value` to an integer.\n *\n * **Note:** This method is loosely based on\n * [`ToInteger`](http://www.ecma-international.org/ecma-262/7.0/#sec-tointeger).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toInteger(3.2);\n * // => 3\n *\n * _.toInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toInteger(Infinity);\n * // => 1.7976931348623157e+308\n *\n * _.toInteger('3.2');\n * // => 3\n */\n function toInteger(value) {\n var result = toFinite(value),\n remainder = result % 1;\n\n return result === result ? (remainder ? result - remainder : result) : 0;\n }\n\n /**\n * Converts `value` to an integer suitable for use as the length of an\n * array-like object.\n *\n * **Note:** This method is based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toLength(3.2);\n * // => 3\n *\n * _.toLength(Number.MIN_VALUE);\n * // => 0\n *\n * _.toLength(Infinity);\n * // => 4294967295\n *\n * _.toLength('3.2');\n * // => 3\n */\n function toLength(value) {\n return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH) : 0;\n }\n\n /**\n * Converts `value` to a number.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to process.\n * @returns {number} Returns the number.\n * @example\n *\n * _.toNumber(3.2);\n * // => 3.2\n *\n * _.toNumber(Number.MIN_VALUE);\n * // => 5e-324\n *\n * _.toNumber(Infinity);\n * // => Infinity\n *\n * _.toNumber('3.2');\n * // => 3.2\n */\n function toNumber(value) {\n if (typeof value == 'number') {\n return value;\n }\n if (isSymbol(value)) {\n return NAN;\n }\n if (isObject(value)) {\n var other = typeof value.valueOf == 'function' ? value.valueOf() : value;\n value = isObject(other) ? (other + '') : other;\n }\n if (typeof value != 'string') {\n return value === 0 ? value : +value;\n }\n value = baseTrim(value);\n var isBinary = reIsBinary.test(value);\n return (isBinary || reIsOctal.test(value))\n ? freeParseInt(value.slice(2), isBinary ? 2 : 8)\n : (reIsBadHex.test(value) ? NAN : +value);\n }\n\n /**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\n function toPlainObject(value) {\n return copyObject(value, keysIn(value));\n }\n\n /**\n * Converts `value` to a safe integer. A safe integer can be compared and\n * represented correctly.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.toSafeInteger(3.2);\n * // => 3\n *\n * _.toSafeInteger(Number.MIN_VALUE);\n * // => 0\n *\n * _.toSafeInteger(Infinity);\n * // => 9007199254740991\n *\n * _.toSafeInteger('3.2');\n * // => 3\n */\n function toSafeInteger(value) {\n return value\n ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER)\n : (value === 0 ? value : 0);\n }\n\n /**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\n function toString(value) {\n return value == null ? '' : baseToString(value);\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Assigns own enumerable string keyed properties of source objects to the\n * destination object. Source objects are applied from left to right.\n * Subsequent sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object` and is loosely based on\n * [`Object.assign`](https://mdn.io/Object/assign).\n *\n * @static\n * @memberOf _\n * @since 0.10.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @see _.assignIn\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * }\n *\n * function Bar() {\n * this.c = 3;\n * }\n *\n * Foo.prototype.b = 2;\n * Bar.prototype.d = 4;\n *\n * _.assign({ 'a': 0 }, new Foo, new Bar);\n * // => { 'a': 1, 'c': 3 }\n */\n var assign = createAssigner(function(object, source) {\n if (isPrototype(source) || isArrayLike(source)) {\n copyObject(source, keys(source), object);\n return;\n }\n for (var key in source) {\n if (hasOwnProperty.call(source, key)) {\n assignValue(object, key, source[key]);\n }\n }\n });\n\n /**\n * This method is like `_.assign` except that it iterates over own and\n * inherited source properties.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @alias extend\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @see _.assign\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * }\n *\n * function Bar() {\n * this.c = 3;\n * }\n *\n * Foo.prototype.b = 2;\n * Bar.prototype.d = 4;\n *\n * _.assignIn({ 'a': 0 }, new Foo, new Bar);\n * // => { 'a': 1, 'b': 2, 'c': 3, 'd': 4 }\n */\n var assignIn = createAssigner(function(object, source) {\n copyObject(source, keysIn(source), object);\n });\n\n /**\n * This method is like `_.assignIn` except that it accepts `customizer`\n * which is invoked to produce the assigned values. If `customizer` returns\n * `undefined`, assignment is handled by the method instead. The `customizer`\n * is invoked with five arguments: (objValue, srcValue, key, object, source).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @alias extendWith\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} sources The source objects.\n * @param {Function} [customizer] The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @see _.assignWith\n * @example\n *\n * function customizer(objValue, srcValue) {\n * return _.isUndefined(objValue) ? srcValue : objValue;\n * }\n *\n * var defaults = _.partialRight(_.assignInWith, customizer);\n *\n * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n * // => { 'a': 1, 'b': 2 }\n */\n var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {\n copyObject(source, keysIn(source), object, customizer);\n });\n\n /**\n * This method is like `_.assign` except that it accepts `customizer`\n * which is invoked to produce the assigned values. If `customizer` returns\n * `undefined`, assignment is handled by the method instead. The `customizer`\n * is invoked with five arguments: (objValue, srcValue, key, object, source).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} sources The source objects.\n * @param {Function} [customizer] The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @see _.assignInWith\n * @example\n *\n * function customizer(objValue, srcValue) {\n * return _.isUndefined(objValue) ? srcValue : objValue;\n * }\n *\n * var defaults = _.partialRight(_.assignWith, customizer);\n *\n * defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n * // => { 'a': 1, 'b': 2 }\n */\n var assignWith = createAssigner(function(object, source, srcIndex, customizer) {\n copyObject(source, keys(source), object, customizer);\n });\n\n /**\n * Creates an array of values corresponding to `paths` of `object`.\n *\n * @static\n * @memberOf _\n * @since 1.0.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {...(string|string[])} [paths] The property paths to pick.\n * @returns {Array} Returns the picked values.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }, 4] };\n *\n * _.at(object, ['a[0].b.c', 'a[1]']);\n * // => [3, 4]\n */\n var at = flatRest(baseAt);\n\n /**\n * Creates an object that inherits from the `prototype` object. If a\n * `properties` object is given, its own enumerable string keyed properties\n * are assigned to the created object.\n *\n * @static\n * @memberOf _\n * @since 2.3.0\n * @category Object\n * @param {Object} prototype The object to inherit from.\n * @param {Object} [properties] The properties to assign to the object.\n * @returns {Object} Returns the new object.\n * @example\n *\n * function Shape() {\n * this.x = 0;\n * this.y = 0;\n * }\n *\n * function Circle() {\n * Shape.call(this);\n * }\n *\n * Circle.prototype = _.create(Shape.prototype, {\n * 'constructor': Circle\n * });\n *\n * var circle = new Circle;\n * circle instanceof Circle;\n * // => true\n *\n * circle instanceof Shape;\n * // => true\n */\n function create(prototype, properties) {\n var result = baseCreate(prototype);\n return properties == null ? result : baseAssign(result, properties);\n }\n\n /**\n * Assigns own and inherited enumerable string keyed properties of source\n * objects to the destination object for all destination properties that\n * resolve to `undefined`. Source objects are applied from left to right.\n * Once a property is set, additional values of the same property are ignored.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @see _.defaultsDeep\n * @example\n *\n * _.defaults({ 'a': 1 }, { 'b': 2 }, { 'a': 3 });\n * // => { 'a': 1, 'b': 2 }\n */\n var defaults = baseRest(function(object, sources) {\n object = Object(object);\n\n var index = -1;\n var length = sources.length;\n var guard = length > 2 ? sources[2] : undefined;\n\n if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n length = 1;\n }\n\n while (++index < length) {\n var source = sources[index];\n var props = keysIn(source);\n var propsIndex = -1;\n var propsLength = props.length;\n\n while (++propsIndex < propsLength) {\n var key = props[propsIndex];\n var value = object[key];\n\n if (value === undefined ||\n (eq(value, objectProto[key]) && !hasOwnProperty.call(object, key))) {\n object[key] = source[key];\n }\n }\n }\n\n return object;\n });\n\n /**\n * This method is like `_.defaults` except that it recursively assigns\n * default properties.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 3.10.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @see _.defaults\n * @example\n *\n * _.defaultsDeep({ 'a': { 'b': 2 } }, { 'a': { 'b': 1, 'c': 3 } });\n * // => { 'a': { 'b': 2, 'c': 3 } }\n */\n var defaultsDeep = baseRest(function(args) {\n args.push(undefined, customDefaultsMerge);\n return apply(mergeWith, undefined, args);\n });\n\n /**\n * This method is like `_.find` except that it returns the key of the first\n * element `predicate` returns truthy for instead of the element itself.\n *\n * @static\n * @memberOf _\n * @since 1.1.0\n * @category Object\n * @param {Object} object The object to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {string|undefined} Returns the key of the matched element,\n * else `undefined`.\n * @example\n *\n * var users = {\n * 'barney': { 'age': 36, 'active': true },\n * 'fred': { 'age': 40, 'active': false },\n * 'pebbles': { 'age': 1, 'active': true }\n * };\n *\n * _.findKey(users, function(o) { return o.age < 40; });\n * // => 'barney' (iteration order is not guaranteed)\n *\n * // The `_.matches` iteratee shorthand.\n * _.findKey(users, { 'age': 1, 'active': true });\n * // => 'pebbles'\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.findKey(users, ['active', false]);\n * // => 'fred'\n *\n * // The `_.property` iteratee shorthand.\n * _.findKey(users, 'active');\n * // => 'barney'\n */\n function findKey(object, predicate) {\n return baseFindKey(object, getIteratee(predicate, 3), baseForOwn);\n }\n\n /**\n * This method is like `_.findKey` except that it iterates over elements of\n * a collection in the opposite order.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Object\n * @param {Object} object The object to inspect.\n * @param {Function} [predicate=_.identity] The function invoked per iteration.\n * @returns {string|undefined} Returns the key of the matched element,\n * else `undefined`.\n * @example\n *\n * var users = {\n * 'barney': { 'age': 36, 'active': true },\n * 'fred': { 'age': 40, 'active': false },\n * 'pebbles': { 'age': 1, 'active': true }\n * };\n *\n * _.findLastKey(users, function(o) { return o.age < 40; });\n * // => returns 'pebbles' assuming `_.findKey` returns 'barney'\n *\n * // The `_.matches` iteratee shorthand.\n * _.findLastKey(users, { 'age': 36, 'active': true });\n * // => 'barney'\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.findLastKey(users, ['active', false]);\n * // => 'fred'\n *\n * // The `_.property` iteratee shorthand.\n * _.findLastKey(users, 'active');\n * // => 'pebbles'\n */\n function findLastKey(object, predicate) {\n return baseFindKey(object, getIteratee(predicate, 3), baseForOwnRight);\n }\n\n /**\n * Iterates over own and inherited enumerable string keyed properties of an\n * object and invokes `iteratee` for each property. The iteratee is invoked\n * with three arguments: (value, key, object). Iteratee functions may exit\n * iteration early by explicitly returning `false`.\n *\n * @static\n * @memberOf _\n * @since 0.3.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Object} Returns `object`.\n * @see _.forInRight\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.forIn(new Foo, function(value, key) {\n * console.log(key);\n * });\n * // => Logs 'a', 'b', then 'c' (iteration order is not guaranteed).\n */\n function forIn(object, iteratee) {\n return object == null\n ? object\n : baseFor(object, getIteratee(iteratee, 3), keysIn);\n }\n\n /**\n * This method is like `_.forIn` except that it iterates over properties of\n * `object` in the opposite order.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Object} Returns `object`.\n * @see _.forIn\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.forInRight(new Foo, function(value, key) {\n * console.log(key);\n * });\n * // => Logs 'c', 'b', then 'a' assuming `_.forIn` logs 'a', 'b', then 'c'.\n */\n function forInRight(object, iteratee) {\n return object == null\n ? object\n : baseForRight(object, getIteratee(iteratee, 3), keysIn);\n }\n\n /**\n * Iterates over own enumerable string keyed properties of an object and\n * invokes `iteratee` for each property. The iteratee is invoked with three\n * arguments: (value, key, object). Iteratee functions may exit iteration\n * early by explicitly returning `false`.\n *\n * @static\n * @memberOf _\n * @since 0.3.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Object} Returns `object`.\n * @see _.forOwnRight\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.forOwn(new Foo, function(value, key) {\n * console.log(key);\n * });\n * // => Logs 'a' then 'b' (iteration order is not guaranteed).\n */\n function forOwn(object, iteratee) {\n return object && baseForOwn(object, getIteratee(iteratee, 3));\n }\n\n /**\n * This method is like `_.forOwn` except that it iterates over properties of\n * `object` in the opposite order.\n *\n * @static\n * @memberOf _\n * @since 2.0.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Object} Returns `object`.\n * @see _.forOwn\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.forOwnRight(new Foo, function(value, key) {\n * console.log(key);\n * });\n * // => Logs 'b' then 'a' assuming `_.forOwn` logs 'a' then 'b'.\n */\n function forOwnRight(object, iteratee) {\n return object && baseForOwnRight(object, getIteratee(iteratee, 3));\n }\n\n /**\n * Creates an array of function property names from own enumerable properties\n * of `object`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to inspect.\n * @returns {Array} Returns the function names.\n * @see _.functionsIn\n * @example\n *\n * function Foo() {\n * this.a = _.constant('a');\n * this.b = _.constant('b');\n * }\n *\n * Foo.prototype.c = _.constant('c');\n *\n * _.functions(new Foo);\n * // => ['a', 'b']\n */\n function functions(object) {\n return object == null ? [] : baseFunctions(object, keys(object));\n }\n\n /**\n * Creates an array of function property names from own and inherited\n * enumerable properties of `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to inspect.\n * @returns {Array} Returns the function names.\n * @see _.functions\n * @example\n *\n * function Foo() {\n * this.a = _.constant('a');\n * this.b = _.constant('b');\n * }\n *\n * Foo.prototype.c = _.constant('c');\n *\n * _.functionsIn(new Foo);\n * // => ['a', 'b', 'c']\n */\n function functionsIn(object) {\n return object == null ? [] : baseFunctions(object, keysIn(object));\n }\n\n /**\n * Gets the value at `path` of `object`. If the resolved value is\n * `undefined`, the `defaultValue` is returned in its place.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.get(object, 'a[0].b.c');\n * // => 3\n *\n * _.get(object, ['a', '0', 'b', 'c']);\n * // => 3\n *\n * _.get(object, 'a.b.c', 'default');\n * // => 'default'\n */\n function get(object, path, defaultValue) {\n var result = object == null ? undefined : baseGet(object, path);\n return result === undefined ? defaultValue : result;\n }\n\n /**\n * Checks if `path` is a direct property of `object`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = { 'a': { 'b': 2 } };\n * var other = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.has(object, 'a');\n * // => true\n *\n * _.has(object, 'a.b');\n * // => true\n *\n * _.has(object, ['a', 'b']);\n * // => true\n *\n * _.has(other, 'a');\n * // => false\n */\n function has(object, path) {\n return object != null && hasPath(object, path, baseHas);\n }\n\n /**\n * Checks if `path` is a direct or inherited property of `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.hasIn(object, 'a');\n * // => true\n *\n * _.hasIn(object, 'a.b');\n * // => true\n *\n * _.hasIn(object, ['a', 'b']);\n * // => true\n *\n * _.hasIn(object, 'b');\n * // => false\n */\n function hasIn(object, path) {\n return object != null && hasPath(object, path, baseHasIn);\n }\n\n /**\n * Creates an object composed of the inverted keys and values of `object`.\n * If `object` contains duplicate values, subsequent values overwrite\n * property assignments of previous values.\n *\n * @static\n * @memberOf _\n * @since 0.7.0\n * @category Object\n * @param {Object} object The object to invert.\n * @returns {Object} Returns the new inverted object.\n * @example\n *\n * var object = { 'a': 1, 'b': 2, 'c': 1 };\n *\n * _.invert(object);\n * // => { '1': 'c', '2': 'b' }\n */\n var invert = createInverter(function(result, value, key) {\n if (value != null &&\n typeof value.toString != 'function') {\n value = nativeObjectToString.call(value);\n }\n\n result[value] = key;\n }, constant(identity));\n\n /**\n * This method is like `_.invert` except that the inverted object is generated\n * from the results of running each element of `object` thru `iteratee`. The\n * corresponding inverted value of each inverted key is an array of keys\n * responsible for generating the inverted value. The iteratee is invoked\n * with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.1.0\n * @category Object\n * @param {Object} object The object to invert.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {Object} Returns the new inverted object.\n * @example\n *\n * var object = { 'a': 1, 'b': 2, 'c': 1 };\n *\n * _.invertBy(object);\n * // => { '1': ['a', 'c'], '2': ['b'] }\n *\n * _.invertBy(object, function(value) {\n * return 'group' + value;\n * });\n * // => { 'group1': ['a', 'c'], 'group2': ['b'] }\n */\n var invertBy = createInverter(function(result, value, key) {\n if (value != null &&\n typeof value.toString != 'function') {\n value = nativeObjectToString.call(value);\n }\n\n if (hasOwnProperty.call(result, value)) {\n result[value].push(key);\n } else {\n result[value] = [key];\n }\n }, getIteratee);\n\n /**\n * Invokes the method at `path` of `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the method to invoke.\n * @param {...*} [args] The arguments to invoke the method with.\n * @returns {*} Returns the result of the invoked method.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': [1, 2, 3, 4] } }] };\n *\n * _.invoke(object, 'a[0].b.c.slice', 1, 3);\n * // => [2, 3]\n */\n var invoke = baseRest(baseInvoke);\n\n /**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\n function keys(object) {\n return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n }\n\n /**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\n function keysIn(object) {\n return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n }\n\n /**\n * The opposite of `_.mapValues`; this method creates an object with the\n * same values as `object` and keys generated by running each own enumerable\n * string keyed property of `object` thru `iteratee`. The iteratee is invoked\n * with three arguments: (value, key, object).\n *\n * @static\n * @memberOf _\n * @since 3.8.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Object} Returns the new mapped object.\n * @see _.mapValues\n * @example\n *\n * _.mapKeys({ 'a': 1, 'b': 2 }, function(value, key) {\n * return key + value;\n * });\n * // => { 'a1': 1, 'b2': 2 }\n */\n function mapKeys(object, iteratee) {\n var result = {};\n iteratee = getIteratee(iteratee, 3);\n\n baseForOwn(object, function(value, key, object) {\n baseAssignValue(result, iteratee(value, key, object), value);\n });\n return result;\n }\n\n /**\n * Creates an object with the same keys as `object` and values generated\n * by running each own enumerable string keyed property of `object` thru\n * `iteratee`. The iteratee is invoked with three arguments:\n * (value, key, object).\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Object} Returns the new mapped object.\n * @see _.mapKeys\n * @example\n *\n * var users = {\n * 'fred': { 'user': 'fred', 'age': 40 },\n * 'pebbles': { 'user': 'pebbles', 'age': 1 }\n * };\n *\n * _.mapValues(users, function(o) { return o.age; });\n * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n *\n * // The `_.property` iteratee shorthand.\n * _.mapValues(users, 'age');\n * // => { 'fred': 40, 'pebbles': 1 } (iteration order is not guaranteed)\n */\n function mapValues(object, iteratee) {\n var result = {};\n iteratee = getIteratee(iteratee, 3);\n\n baseForOwn(object, function(value, key, object) {\n baseAssignValue(result, key, iteratee(value, key, object));\n });\n return result;\n }\n\n /**\n * This method is like `_.assign` except that it recursively merges own and\n * inherited enumerable string keyed properties of source objects into the\n * destination object. Source properties that resolve to `undefined` are\n * skipped if a destination value exists. Array and plain object properties\n * are merged recursively. Other objects and value types are overridden by\n * assignment. Source objects are applied from left to right. Subsequent\n * sources overwrite property assignments of previous sources.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 0.5.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} [sources] The source objects.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {\n * 'a': [{ 'b': 2 }, { 'd': 4 }]\n * };\n *\n * var other = {\n * 'a': [{ 'c': 3 }, { 'e': 5 }]\n * };\n *\n * _.merge(object, other);\n * // => { 'a': [{ 'b': 2, 'c': 3 }, { 'd': 4, 'e': 5 }] }\n */\n var merge = createAssigner(function(object, source, srcIndex) {\n baseMerge(object, source, srcIndex);\n });\n\n /**\n * This method is like `_.merge` except that it accepts `customizer` which\n * is invoked to produce the merged values of the destination and source\n * properties. If `customizer` returns `undefined`, merging is handled by the\n * method instead. The `customizer` is invoked with six arguments:\n * (objValue, srcValue, key, object, source, stack).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} sources The source objects.\n * @param {Function} customizer The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @example\n *\n * function customizer(objValue, srcValue) {\n * if (_.isArray(objValue)) {\n * return objValue.concat(srcValue);\n * }\n * }\n *\n * var object = { 'a': [1], 'b': [2] };\n * var other = { 'a': [3], 'b': [4] };\n *\n * _.mergeWith(object, other, customizer);\n * // => { 'a': [1, 3], 'b': [2, 4] }\n */\n var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {\n baseMerge(object, source, srcIndex, customizer);\n });\n\n /**\n * The opposite of `_.pick`; this method creates an object composed of the\n * own and inherited enumerable property paths of `object` that are not omitted.\n *\n * **Note:** This method is considerably slower than `_.pick`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The source object.\n * @param {...(string|string[])} [paths] The property paths to omit.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.omit(object, ['a', 'c']);\n * // => { 'b': '2' }\n */\n var omit = flatRest(function(object, paths) {\n var result = {};\n if (object == null) {\n return result;\n }\n var isDeep = false;\n paths = arrayMap(paths, function(path) {\n path = castPath(path, object);\n isDeep || (isDeep = path.length > 1);\n return path;\n });\n copyObject(object, getAllKeysIn(object), result);\n if (isDeep) {\n result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);\n }\n var length = paths.length;\n while (length--) {\n baseUnset(result, paths[length]);\n }\n return result;\n });\n\n /**\n * The opposite of `_.pickBy`; this method creates an object composed of\n * the own and inherited enumerable string keyed properties of `object` that\n * `predicate` doesn't return truthy for. The predicate is invoked with two\n * arguments: (value, key).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The source object.\n * @param {Function} [predicate=_.identity] The function invoked per property.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.omitBy(object, _.isNumber);\n * // => { 'b': '2' }\n */\n function omitBy(object, predicate) {\n return pickBy(object, negate(getIteratee(predicate)));\n }\n\n /**\n * Creates an object composed of the picked `object` properties.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The source object.\n * @param {...(string|string[])} [paths] The property paths to pick.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.pick(object, ['a', 'c']);\n * // => { 'a': 1, 'c': 3 }\n */\n var pick = flatRest(function(object, paths) {\n return object == null ? {} : basePick(object, paths);\n });\n\n /**\n * Creates an object composed of the `object` properties `predicate` returns\n * truthy for. The predicate is invoked with two arguments: (value, key).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The source object.\n * @param {Function} [predicate=_.identity] The function invoked per property.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.pickBy(object, _.isNumber);\n * // => { 'a': 1, 'c': 3 }\n */\n function pickBy(object, predicate) {\n if (object == null) {\n return {};\n }\n var props = arrayMap(getAllKeysIn(object), function(prop) {\n return [prop];\n });\n predicate = getIteratee(predicate);\n return basePickBy(object, props, function(value, path) {\n return predicate(value, path[0]);\n });\n }\n\n /**\n * This method is like `_.get` except that if the resolved value is a\n * function it's invoked with the `this` binding of its parent object and\n * its result is returned.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to resolve.\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c1': 3, 'c2': _.constant(4) } }] };\n *\n * _.result(object, 'a[0].b.c1');\n * // => 3\n *\n * _.result(object, 'a[0].b.c2');\n * // => 4\n *\n * _.result(object, 'a[0].b.c3', 'default');\n * // => 'default'\n *\n * _.result(object, 'a[0].b.c3', _.constant('default'));\n * // => 'default'\n */\n function result(object, path, defaultValue) {\n path = castPath(path, object);\n\n var index = -1,\n length = path.length;\n\n // Ensure the loop is entered when path is empty.\n if (!length) {\n length = 1;\n object = undefined;\n }\n while (++index < length) {\n var value = object == null ? undefined : object[toKey(path[index])];\n if (value === undefined) {\n index = length;\n value = defaultValue;\n }\n object = isFunction(value) ? value.call(object) : value;\n }\n return object;\n }\n\n /**\n * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,\n * it's created. Arrays are created for missing index properties while objects\n * are created for all other missing properties. Use `_.setWith` to customize\n * `path` creation.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.set(object, 'a[0].b.c', 4);\n * console.log(object.a[0].b.c);\n * // => 4\n *\n * _.set(object, ['x', '0', 'y', 'z'], 5);\n * console.log(object.x[0].y.z);\n * // => 5\n */\n function set(object, path, value) {\n return object == null ? object : baseSet(object, path, value);\n }\n\n /**\n * This method is like `_.set` except that it accepts `customizer` which is\n * invoked to produce the objects of `path`. If `customizer` returns `undefined`\n * path creation is handled by the method instead. The `customizer` is invoked\n * with three arguments: (nsValue, key, nsObject).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @param {Function} [customizer] The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {};\n *\n * _.setWith(object, '[0][1]', 'a', Object);\n * // => { '0': { '1': 'a' } }\n */\n function setWith(object, path, value, customizer) {\n customizer = typeof customizer == 'function' ? customizer : undefined;\n return object == null ? object : baseSet(object, path, value, customizer);\n }\n\n /**\n * Creates an array of own enumerable string keyed-value pairs for `object`\n * which can be consumed by `_.fromPairs`. If `object` is a map or set, its\n * entries are returned.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @alias entries\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the key-value pairs.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.toPairs(new Foo);\n * // => [['a', 1], ['b', 2]] (iteration order is not guaranteed)\n */\n var toPairs = createToPairs(keys);\n\n /**\n * Creates an array of own and inherited enumerable string keyed-value pairs\n * for `object` which can be consumed by `_.fromPairs`. If `object` is a map\n * or set, its entries are returned.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @alias entriesIn\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the key-value pairs.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.toPairsIn(new Foo);\n * // => [['a', 1], ['b', 2], ['c', 3]] (iteration order is not guaranteed)\n */\n var toPairsIn = createToPairs(keysIn);\n\n /**\n * An alternative to `_.reduce`; this method transforms `object` to a new\n * `accumulator` object which is the result of running each of its own\n * enumerable string keyed properties thru `iteratee`, with each invocation\n * potentially mutating the `accumulator` object. If `accumulator` is not\n * provided, a new object with the same `[[Prototype]]` will be used. The\n * iteratee is invoked with four arguments: (accumulator, value, key, object).\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @static\n * @memberOf _\n * @since 1.3.0\n * @category Object\n * @param {Object} object The object to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @param {*} [accumulator] The custom accumulator value.\n * @returns {*} Returns the accumulated value.\n * @example\n *\n * _.transform([2, 3, 4], function(result, n) {\n * result.push(n *= n);\n * return n % 2 == 0;\n * }, []);\n * // => [4, 9]\n *\n * _.transform({ 'a': 1, 'b': 2, 'c': 1 }, function(result, value, key) {\n * (result[value] || (result[value] = [])).push(key);\n * }, {});\n * // => { '1': ['a', 'c'], '2': ['b'] }\n */\n function transform(object, iteratee, accumulator) {\n var isArr = isArray(object),\n isArrLike = isArr || isBuffer(object) || isTypedArray(object);\n\n iteratee = getIteratee(iteratee, 4);\n if (accumulator == null) {\n var Ctor = object && object.constructor;\n if (isArrLike) {\n accumulator = isArr ? new Ctor : [];\n }\n else if (isObject(object)) {\n accumulator = isFunction(Ctor) ? baseCreate(getPrototype(object)) : {};\n }\n else {\n accumulator = {};\n }\n }\n (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object) {\n return iteratee(accumulator, value, index, object);\n });\n return accumulator;\n }\n\n /**\n * Removes the property at `path` of `object`.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to unset.\n * @returns {boolean} Returns `true` if the property is deleted, else `false`.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 7 } }] };\n * _.unset(object, 'a[0].b.c');\n * // => true\n *\n * console.log(object);\n * // => { 'a': [{ 'b': {} }] };\n *\n * _.unset(object, ['a', '0', 'b', 'c']);\n * // => true\n *\n * console.log(object);\n * // => { 'a': [{ 'b': {} }] };\n */\n function unset(object, path) {\n return object == null ? true : baseUnset(object, path);\n }\n\n /**\n * This method is like `_.set` except that accepts `updater` to produce the\n * value to set. Use `_.updateWith` to customize `path` creation. The `updater`\n * is invoked with one argument: (value).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.6.0\n * @category Object\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {Function} updater The function to produce the updated value.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.update(object, 'a[0].b.c', function(n) { return n * n; });\n * console.log(object.a[0].b.c);\n * // => 9\n *\n * _.update(object, 'x[0].y.z', function(n) { return n ? n + 1 : 0; });\n * console.log(object.x[0].y.z);\n * // => 0\n */\n function update(object, path, updater) {\n return object == null ? object : baseUpdate(object, path, castFunction(updater));\n }\n\n /**\n * This method is like `_.update` except that it accepts `customizer` which is\n * invoked to produce the objects of `path`. If `customizer` returns `undefined`\n * path creation is handled by the method instead. The `customizer` is invoked\n * with three arguments: (nsValue, key, nsObject).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.6.0\n * @category Object\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {Function} updater The function to produce the updated value.\n * @param {Function} [customizer] The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = {};\n *\n * _.updateWith(object, '[0][1]', _.constant('a'), Object);\n * // => { '0': { '1': 'a' } }\n */\n function updateWith(object, path, updater, customizer) {\n customizer = typeof customizer == 'function' ? customizer : undefined;\n return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);\n }\n\n /**\n * Creates an array of the own enumerable string keyed property values of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property values.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.values(new Foo);\n * // => [1, 2] (iteration order is not guaranteed)\n *\n * _.values('hi');\n * // => ['h', 'i']\n */\n function values(object) {\n return object == null ? [] : baseValues(object, keys(object));\n }\n\n /**\n * Creates an array of the own and inherited enumerable string keyed property\n * values of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property values.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.valuesIn(new Foo);\n * // => [1, 2, 3] (iteration order is not guaranteed)\n */\n function valuesIn(object) {\n return object == null ? [] : baseValues(object, keysIn(object));\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Clamps `number` within the inclusive `lower` and `upper` bounds.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Number\n * @param {number} number The number to clamp.\n * @param {number} [lower] The lower bound.\n * @param {number} upper The upper bound.\n * @returns {number} Returns the clamped number.\n * @example\n *\n * _.clamp(-10, -5, 5);\n * // => -5\n *\n * _.clamp(10, -5, 5);\n * // => 5\n */\n function clamp(number, lower, upper) {\n if (upper === undefined) {\n upper = lower;\n lower = undefined;\n }\n if (upper !== undefined) {\n upper = toNumber(upper);\n upper = upper === upper ? upper : 0;\n }\n if (lower !== undefined) {\n lower = toNumber(lower);\n lower = lower === lower ? lower : 0;\n }\n return baseClamp(toNumber(number), lower, upper);\n }\n\n /**\n * Checks if `n` is between `start` and up to, but not including, `end`. If\n * `end` is not specified, it's set to `start` with `start` then set to `0`.\n * If `start` is greater than `end` the params are swapped to support\n * negative ranges.\n *\n * @static\n * @memberOf _\n * @since 3.3.0\n * @category Number\n * @param {number} number The number to check.\n * @param {number} [start=0] The start of the range.\n * @param {number} end The end of the range.\n * @returns {boolean} Returns `true` if `number` is in the range, else `false`.\n * @see _.range, _.rangeRight\n * @example\n *\n * _.inRange(3, 2, 4);\n * // => true\n *\n * _.inRange(4, 8);\n * // => true\n *\n * _.inRange(4, 2);\n * // => false\n *\n * _.inRange(2, 2);\n * // => false\n *\n * _.inRange(1.2, 2);\n * // => true\n *\n * _.inRange(5.2, 4);\n * // => false\n *\n * _.inRange(-3, -2, -6);\n * // => true\n */\n function inRange(number, start, end) {\n start = toFinite(start);\n if (end === undefined) {\n end = start;\n start = 0;\n } else {\n end = toFinite(end);\n }\n number = toNumber(number);\n return baseInRange(number, start, end);\n }\n\n /**\n * Produces a random number between the inclusive `lower` and `upper` bounds.\n * If only one argument is provided a number between `0` and the given number\n * is returned. If `floating` is `true`, or either `lower` or `upper` are\n * floats, a floating-point number is returned instead of an integer.\n *\n * **Note:** JavaScript follows the IEEE-754 standard for resolving\n * floating-point values which can produce unexpected results.\n *\n * @static\n * @memberOf _\n * @since 0.7.0\n * @category Number\n * @param {number} [lower=0] The lower bound.\n * @param {number} [upper=1] The upper bound.\n * @param {boolean} [floating] Specify returning a floating-point number.\n * @returns {number} Returns the random number.\n * @example\n *\n * _.random(0, 5);\n * // => an integer between 0 and 5\n *\n * _.random(5);\n * // => also an integer between 0 and 5\n *\n * _.random(5, true);\n * // => a floating-point number between 0 and 5\n *\n * _.random(1.2, 5.2);\n * // => a floating-point number between 1.2 and 5.2\n */\n function random(lower, upper, floating) {\n if (floating && typeof floating != 'boolean' && isIterateeCall(lower, upper, floating)) {\n upper = floating = undefined;\n }\n if (floating === undefined) {\n if (typeof upper == 'boolean') {\n floating = upper;\n upper = undefined;\n }\n else if (typeof lower == 'boolean') {\n floating = lower;\n lower = undefined;\n }\n }\n if (lower === undefined && upper === undefined) {\n lower = 0;\n upper = 1;\n }\n else {\n lower = toFinite(lower);\n if (upper === undefined) {\n upper = lower;\n lower = 0;\n } else {\n upper = toFinite(upper);\n }\n }\n if (lower > upper) {\n var temp = lower;\n lower = upper;\n upper = temp;\n }\n if (floating || lower % 1 || upper % 1) {\n var rand = nativeRandom();\n return nativeMin(lower + (rand * (upper - lower + freeParseFloat('1e-' + ((rand + '').length - 1)))), upper);\n }\n return baseRandom(lower, upper);\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Converts `string` to [camel case](https://en.wikipedia.org/wiki/CamelCase).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the camel cased string.\n * @example\n *\n * _.camelCase('Foo Bar');\n * // => 'fooBar'\n *\n * _.camelCase('--foo-bar--');\n * // => 'fooBar'\n *\n * _.camelCase('__FOO_BAR__');\n * // => 'fooBar'\n */\n var camelCase = createCompounder(function(result, word, index) {\n word = word.toLowerCase();\n return result + (index ? capitalize(word) : word);\n });\n\n /**\n * Converts the first character of `string` to upper case and the remaining\n * to lower case.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to capitalize.\n * @returns {string} Returns the capitalized string.\n * @example\n *\n * _.capitalize('FRED');\n * // => 'Fred'\n */\n function capitalize(string) {\n return upperFirst(toString(string).toLowerCase());\n }\n\n /**\n * Deburrs `string` by converting\n * [Latin-1 Supplement](https://en.wikipedia.org/wiki/Latin-1_Supplement_(Unicode_block)#Character_table)\n * and [Latin Extended-A](https://en.wikipedia.org/wiki/Latin_Extended-A)\n * letters to basic Latin letters and removing\n * [combining diacritical marks](https://en.wikipedia.org/wiki/Combining_Diacritical_Marks).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to deburr.\n * @returns {string} Returns the deburred string.\n * @example\n *\n * _.deburr('déjà vu');\n * // => 'deja vu'\n */\n function deburr(string) {\n string = toString(string);\n return string && string.replace(reLatin, deburrLetter).replace(reComboMark, '');\n }\n\n /**\n * Checks if `string` ends with the given target string.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to inspect.\n * @param {string} [target] The string to search for.\n * @param {number} [position=string.length] The position to search up to.\n * @returns {boolean} Returns `true` if `string` ends with `target`,\n * else `false`.\n * @example\n *\n * _.endsWith('abc', 'c');\n * // => true\n *\n * _.endsWith('abc', 'b');\n * // => false\n *\n * _.endsWith('abc', 'b', 2);\n * // => true\n */\n function endsWith(string, target, position) {\n string = toString(string);\n target = baseToString(target);\n\n var length = string.length;\n position = position === undefined\n ? length\n : baseClamp(toInteger(position), 0, length);\n\n var end = position;\n position -= target.length;\n return position >= 0 && string.slice(position, end) == target;\n }\n\n /**\n * Converts the characters \"&\", \"<\", \">\", '\"', and \"'\" in `string` to their\n * corresponding HTML entities.\n *\n * **Note:** No other characters are escaped. To escape additional\n * characters use a third-party library like [_he_](https://mths.be/he).\n *\n * Though the \">\" character is escaped for symmetry, characters like\n * \">\" and \"/\" don't need escaping in HTML and have no special meaning\n * unless they're part of a tag or unquoted attribute value. See\n * [Mathias Bynens's article](https://mathiasbynens.be/notes/ambiguous-ampersands)\n * (under \"semi-related fun fact\") for more details.\n *\n * When working with HTML you should always\n * [quote attribute values](http://wonko.com/post/html-escaping) to reduce\n * XSS vectors.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category String\n * @param {string} [string=''] The string to escape.\n * @returns {string} Returns the escaped string.\n * @example\n *\n * _.escape('fred, barney, & pebbles');\n * // => 'fred, barney, & pebbles'\n */\n function escape(string) {\n string = toString(string);\n return (string && reHasUnescapedHtml.test(string))\n ? string.replace(reUnescapedHtml, escapeHtmlChar)\n : string;\n }\n\n /**\n * Escapes the `RegExp` special characters \"^\", \"$\", \"\\\", \".\", \"*\", \"+\",\n * \"?\", \"(\", \")\", \"[\", \"]\", \"{\", \"}\", and \"|\" in `string`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to escape.\n * @returns {string} Returns the escaped string.\n * @example\n *\n * _.escapeRegExp('[lodash](https://lodash.com/)');\n * // => '\\[lodash\\]\\(https://lodash\\.com/\\)'\n */\n function escapeRegExp(string) {\n string = toString(string);\n return (string && reHasRegExpChar.test(string))\n ? string.replace(reRegExpChar, '\\\\$&')\n : string;\n }\n\n /**\n * Converts `string` to\n * [kebab case](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the kebab cased string.\n * @example\n *\n * _.kebabCase('Foo Bar');\n * // => 'foo-bar'\n *\n * _.kebabCase('fooBar');\n * // => 'foo-bar'\n *\n * _.kebabCase('__FOO_BAR__');\n * // => 'foo-bar'\n */\n var kebabCase = createCompounder(function(result, word, index) {\n return result + (index ? '-' : '') + word.toLowerCase();\n });\n\n /**\n * Converts `string`, as space separated words, to lower case.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the lower cased string.\n * @example\n *\n * _.lowerCase('--Foo-Bar--');\n * // => 'foo bar'\n *\n * _.lowerCase('fooBar');\n * // => 'foo bar'\n *\n * _.lowerCase('__FOO_BAR__');\n * // => 'foo bar'\n */\n var lowerCase = createCompounder(function(result, word, index) {\n return result + (index ? ' ' : '') + word.toLowerCase();\n });\n\n /**\n * Converts the first character of `string` to lower case.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.lowerFirst('Fred');\n * // => 'fred'\n *\n * _.lowerFirst('FRED');\n * // => 'fRED'\n */\n var lowerFirst = createCaseFirst('toLowerCase');\n\n /**\n * Pads `string` on the left and right sides if it's shorter than `length`.\n * Padding characters are truncated if they can't be evenly divided by `length`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to pad.\n * @param {number} [length=0] The padding length.\n * @param {string} [chars=' '] The string used as padding.\n * @returns {string} Returns the padded string.\n * @example\n *\n * _.pad('abc', 8);\n * // => ' abc '\n *\n * _.pad('abc', 8, '_-');\n * // => '_-abc_-_'\n *\n * _.pad('abc', 3);\n * // => 'abc'\n */\n function pad(string, length, chars) {\n string = toString(string);\n length = toInteger(length);\n\n var strLength = length ? stringSize(string) : 0;\n if (!length || strLength >= length) {\n return string;\n }\n var mid = (length - strLength) / 2;\n return (\n createPadding(nativeFloor(mid), chars) +\n string +\n createPadding(nativeCeil(mid), chars)\n );\n }\n\n /**\n * Pads `string` on the right side if it's shorter than `length`. Padding\n * characters are truncated if they exceed `length`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to pad.\n * @param {number} [length=0] The padding length.\n * @param {string} [chars=' '] The string used as padding.\n * @returns {string} Returns the padded string.\n * @example\n *\n * _.padEnd('abc', 6);\n * // => 'abc '\n *\n * _.padEnd('abc', 6, '_-');\n * // => 'abc_-_'\n *\n * _.padEnd('abc', 3);\n * // => 'abc'\n */\n function padEnd(string, length, chars) {\n string = toString(string);\n length = toInteger(length);\n\n var strLength = length ? stringSize(string) : 0;\n return (length && strLength < length)\n ? (string + createPadding(length - strLength, chars))\n : string;\n }\n\n /**\n * Pads `string` on the left side if it's shorter than `length`. Padding\n * characters are truncated if they exceed `length`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to pad.\n * @param {number} [length=0] The padding length.\n * @param {string} [chars=' '] The string used as padding.\n * @returns {string} Returns the padded string.\n * @example\n *\n * _.padStart('abc', 6);\n * // => ' abc'\n *\n * _.padStart('abc', 6, '_-');\n * // => '_-_abc'\n *\n * _.padStart('abc', 3);\n * // => 'abc'\n */\n function padStart(string, length, chars) {\n string = toString(string);\n length = toInteger(length);\n\n var strLength = length ? stringSize(string) : 0;\n return (length && strLength < length)\n ? (createPadding(length - strLength, chars) + string)\n : string;\n }\n\n /**\n * Converts `string` to an integer of the specified radix. If `radix` is\n * `undefined` or `0`, a `radix` of `10` is used unless `value` is a\n * hexadecimal, in which case a `radix` of `16` is used.\n *\n * **Note:** This method aligns with the\n * [ES5 implementation](https://es5.github.io/#x15.1.2.2) of `parseInt`.\n *\n * @static\n * @memberOf _\n * @since 1.1.0\n * @category String\n * @param {string} string The string to convert.\n * @param {number} [radix=10] The radix to interpret `value` by.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {number} Returns the converted integer.\n * @example\n *\n * _.parseInt('08');\n * // => 8\n *\n * _.map(['6', '08', '10'], _.parseInt);\n * // => [6, 8, 10]\n */\n function parseInt(string, radix, guard) {\n if (guard || radix == null) {\n radix = 0;\n } else if (radix) {\n radix = +radix;\n }\n return nativeParseInt(toString(string).replace(reTrimStart, ''), radix || 0);\n }\n\n /**\n * Repeats the given string `n` times.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to repeat.\n * @param {number} [n=1] The number of times to repeat the string.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {string} Returns the repeated string.\n * @example\n *\n * _.repeat('*', 3);\n * // => '***'\n *\n * _.repeat('abc', 2);\n * // => 'abcabc'\n *\n * _.repeat('abc', 0);\n * // => ''\n */\n function repeat(string, n, guard) {\n if ((guard ? isIterateeCall(string, n, guard) : n === undefined)) {\n n = 1;\n } else {\n n = toInteger(n);\n }\n return baseRepeat(toString(string), n);\n }\n\n /**\n * Replaces matches for `pattern` in `string` with `replacement`.\n *\n * **Note:** This method is based on\n * [`String#replace`](https://mdn.io/String/replace).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to modify.\n * @param {RegExp|string} pattern The pattern to replace.\n * @param {Function|string} replacement The match replacement.\n * @returns {string} Returns the modified string.\n * @example\n *\n * _.replace('Hi Fred', 'Fred', 'Barney');\n * // => 'Hi Barney'\n */\n function replace() {\n var args = arguments,\n string = toString(args[0]);\n\n return args.length < 3 ? string : string.replace(args[1], args[2]);\n }\n\n /**\n * Converts `string` to\n * [snake case](https://en.wikipedia.org/wiki/Snake_case).\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the snake cased string.\n * @example\n *\n * _.snakeCase('Foo Bar');\n * // => 'foo_bar'\n *\n * _.snakeCase('fooBar');\n * // => 'foo_bar'\n *\n * _.snakeCase('--FOO-BAR--');\n * // => 'foo_bar'\n */\n var snakeCase = createCompounder(function(result, word, index) {\n return result + (index ? '_' : '') + word.toLowerCase();\n });\n\n /**\n * Splits `string` by `separator`.\n *\n * **Note:** This method is based on\n * [`String#split`](https://mdn.io/String/split).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to split.\n * @param {RegExp|string} separator The separator pattern to split by.\n * @param {number} [limit] The length to truncate results to.\n * @returns {Array} Returns the string segments.\n * @example\n *\n * _.split('a-b-c', '-', 2);\n * // => ['a', 'b']\n */\n function split(string, separator, limit) {\n if (limit && typeof limit != 'number' && isIterateeCall(string, separator, limit)) {\n separator = limit = undefined;\n }\n limit = limit === undefined ? MAX_ARRAY_LENGTH : limit >>> 0;\n if (!limit) {\n return [];\n }\n string = toString(string);\n if (string && (\n typeof separator == 'string' ||\n (separator != null && !isRegExp(separator))\n )) {\n separator = baseToString(separator);\n if (!separator && hasUnicode(string)) {\n return castSlice(stringToArray(string), 0, limit);\n }\n }\n return string.split(separator, limit);\n }\n\n /**\n * Converts `string` to\n * [start case](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage).\n *\n * @static\n * @memberOf _\n * @since 3.1.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the start cased string.\n * @example\n *\n * _.startCase('--foo-bar--');\n * // => 'Foo Bar'\n *\n * _.startCase('fooBar');\n * // => 'Foo Bar'\n *\n * _.startCase('__FOO_BAR__');\n * // => 'FOO BAR'\n */\n var startCase = createCompounder(function(result, word, index) {\n return result + (index ? ' ' : '') + upperFirst(word);\n });\n\n /**\n * Checks if `string` starts with the given target string.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to inspect.\n * @param {string} [target] The string to search for.\n * @param {number} [position=0] The position to search from.\n * @returns {boolean} Returns `true` if `string` starts with `target`,\n * else `false`.\n * @example\n *\n * _.startsWith('abc', 'a');\n * // => true\n *\n * _.startsWith('abc', 'b');\n * // => false\n *\n * _.startsWith('abc', 'b', 1);\n * // => true\n */\n function startsWith(string, target, position) {\n string = toString(string);\n position = position == null\n ? 0\n : baseClamp(toInteger(position), 0, string.length);\n\n target = baseToString(target);\n return string.slice(position, position + target.length) == target;\n }\n\n /**\n * Creates a compiled template function that can interpolate data properties\n * in \"interpolate\" delimiters, HTML-escape interpolated data properties in\n * \"escape\" delimiters, and execute JavaScript in \"evaluate\" delimiters. Data\n * properties may be accessed as free variables in the template. If a setting\n * object is given, it takes precedence over `_.templateSettings` values.\n *\n * **Note:** In the development build `_.template` utilizes\n * [sourceURLs](http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl)\n * for easier debugging.\n *\n * For more information on precompiling templates see\n * [lodash's custom builds documentation](https://lodash.com/custom-builds).\n *\n * For more information on Chrome extension sandboxes see\n * [Chrome's extensions documentation](https://developer.chrome.com/extensions/sandboxingEval).\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category String\n * @param {string} [string=''] The template string.\n * @param {Object} [options={}] The options object.\n * @param {RegExp} [options.escape=_.templateSettings.escape]\n * The HTML \"escape\" delimiter.\n * @param {RegExp} [options.evaluate=_.templateSettings.evaluate]\n * The \"evaluate\" delimiter.\n * @param {Object} [options.imports=_.templateSettings.imports]\n * An object to import into the template as free variables.\n * @param {RegExp} [options.interpolate=_.templateSettings.interpolate]\n * The \"interpolate\" delimiter.\n * @param {string} [options.sourceURL='lodash.templateSources[n]']\n * The sourceURL of the compiled template.\n * @param {string} [options.variable='obj']\n * The data object variable name.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Function} Returns the compiled template function.\n * @example\n *\n * // Use the \"interpolate\" delimiter to create a compiled template.\n * var compiled = _.template('hello <%= user %>!');\n * compiled({ 'user': 'fred' });\n * // => 'hello fred!'\n *\n * // Use the HTML \"escape\" delimiter to escape data property values.\n * var compiled = _.template('<b><%- value %></b>');\n * compiled({ 'value': '<script>' });\n * // => '<b><script></b>'\n *\n * // Use the \"evaluate\" delimiter to execute JavaScript and generate HTML.\n * var compiled = _.template('<% _.forEach(users, function(user) { %><li><%- user %></li><% }); %>');\n * compiled({ 'users': ['fred', 'barney'] });\n * // => '<li>fred</li><li>barney</li>'\n *\n * // Use the internal `print` function in \"evaluate\" delimiters.\n * var compiled = _.template('<% print(\"hello \" + user); %>!');\n * compiled({ 'user': 'barney' });\n * // => 'hello barney!'\n *\n * // Use the ES template literal delimiter as an \"interpolate\" delimiter.\n * // Disable support by replacing the \"interpolate\" delimiter.\n * var compiled = _.template('hello ${ user }!');\n * compiled({ 'user': 'pebbles' });\n * // => 'hello pebbles!'\n *\n * // Use backslashes to treat delimiters as plain text.\n * var compiled = _.template('<%= \"\\\\<%- value %\\\\>\" %>');\n * compiled({ 'value': 'ignored' });\n * // => '<%- value %>'\n *\n * // Use the `imports` option to import `jQuery` as `jq`.\n * var text = '<% jq.each(users, function(user) { %><li><%- user %></li><% }); %>';\n * var compiled = _.template(text, { 'imports': { 'jq': jQuery } });\n * compiled({ 'users': ['fred', 'barney'] });\n * // => '<li>fred</li><li>barney</li>'\n *\n * // Use the `sourceURL` option to specify a custom sourceURL for the template.\n * var compiled = _.template('hello <%= user %>!', { 'sourceURL': '/basic/greeting.jst' });\n * compiled(data);\n * // => Find the source of \"greeting.jst\" under the Sources tab or Resources panel of the web inspector.\n *\n * // Use the `variable` option to ensure a with-statement isn't used in the compiled template.\n * var compiled = _.template('hi <%= data.user %>!', { 'variable': 'data' });\n * compiled.source;\n * // => function(data) {\n * // var __t, __p = '';\n * // __p += 'hi ' + ((__t = ( data.user )) == null ? '' : __t) + '!';\n * // return __p;\n * // }\n *\n * // Use custom template delimiters.\n * _.templateSettings.interpolate = /{{([\\s\\S]+?)}}/g;\n * var compiled = _.template('hello {{ user }}!');\n * compiled({ 'user': 'mustache' });\n * // => 'hello mustache!'\n *\n * // Use the `source` property to inline compiled templates for meaningful\n * // line numbers in error messages and stack traces.\n * fs.writeFileSync(path.join(process.cwd(), 'jst.js'), '\\\n * var JST = {\\\n * \"main\": ' + _.template(mainText).source + '\\\n * };\\\n * ');\n */\n function template(string, options, guard) {\n // Based on John Resig's `tmpl` implementation\n // (http://ejohn.org/blog/javascript-micro-templating/)\n // and Laura Doktorova's doT.js (https://github.com/olado/doT).\n var settings = lodash.templateSettings;\n\n if (guard && isIterateeCall(string, options, guard)) {\n options = undefined;\n }\n string = toString(string);\n options = assignInWith({}, options, settings, customDefaultsAssignIn);\n\n var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn),\n importsKeys = keys(imports),\n importsValues = baseValues(imports, importsKeys);\n\n var isEscaping,\n isEvaluating,\n index = 0,\n interpolate = options.interpolate || reNoMatch,\n source = \"__p += '\";\n\n // Compile the regexp to match each delimiter.\n var reDelimiters = RegExp(\n (options.escape || reNoMatch).source + '|' +\n interpolate.source + '|' +\n (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + '|' +\n (options.evaluate || reNoMatch).source + '|$'\n , 'g');\n\n // Use a sourceURL for easier debugging.\n // The sourceURL gets injected into the source that's eval-ed, so be careful\n // to normalize all kinds of whitespace, so e.g. newlines (and unicode versions of it) can't sneak in\n // and escape the comment, thus injecting code that gets evaled.\n var sourceURL = '//# sourceURL=' +\n (hasOwnProperty.call(options, 'sourceURL')\n ? (options.sourceURL + '').replace(/\\s/g, ' ')\n : ('lodash.templateSources[' + (++templateCounter) + ']')\n ) + '\\n';\n\n string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {\n interpolateValue || (interpolateValue = esTemplateValue);\n\n // Escape characters that can't be included in string literals.\n source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);\n\n // Replace delimiters with snippets.\n if (escapeValue) {\n isEscaping = true;\n source += \"' +\\n__e(\" + escapeValue + \") +\\n'\";\n }\n if (evaluateValue) {\n isEvaluating = true;\n source += \"';\\n\" + evaluateValue + \";\\n__p += '\";\n }\n if (interpolateValue) {\n source += \"' +\\n((__t = (\" + interpolateValue + \")) == null ? '' : __t) +\\n'\";\n }\n index = offset + match.length;\n\n // The JS engine embedded in Adobe products needs `match` returned in\n // order to produce the correct `offset` value.\n return match;\n });\n\n source += \"';\\n\";\n\n // If `variable` is not specified wrap a with-statement around the generated\n // code to add the data object to the top of the scope chain.\n var variable = hasOwnProperty.call(options, 'variable') && options.variable;\n if (!variable) {\n source = 'with (obj) {\\n' + source + '\\n}\\n';\n }\n // Throw an error if a forbidden character was found in `variable`, to prevent\n // potential command injection attacks.\n else if (reForbiddenIdentifierChars.test(variable)) {\n throw new Error(INVALID_TEMPL_VAR_ERROR_TEXT);\n }\n\n // Cleanup code by stripping empty strings.\n source = (isEvaluating ? source.replace(reEmptyStringLeading, '') : source)\n .replace(reEmptyStringMiddle, '$1')\n .replace(reEmptyStringTrailing, '$1;');\n\n // Frame code as the function body.\n source = 'function(' + (variable || 'obj') + ') {\\n' +\n (variable\n ? ''\n : 'obj || (obj = {});\\n'\n ) +\n \"var __t, __p = ''\" +\n (isEscaping\n ? ', __e = _.escape'\n : ''\n ) +\n (isEvaluating\n ? ', __j = Array.prototype.join;\\n' +\n \"function print() { __p += __j.call(arguments, '') }\\n\"\n : ';\\n'\n ) +\n source +\n 'return __p\\n}';\n\n var result = attempt(function() {\n return Function(importsKeys, sourceURL + 'return ' + source)\n .apply(undefined, importsValues);\n });\n\n // Provide the compiled function's source by its `toString` method or\n // the `source` property as a convenience for inlining compiled templates.\n result.source = source;\n if (isError(result)) {\n throw result;\n }\n return result;\n }\n\n /**\n * Converts `string`, as a whole, to lower case just like\n * [String#toLowerCase](https://mdn.io/toLowerCase).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the lower cased string.\n * @example\n *\n * _.toLower('--Foo-Bar--');\n * // => '--foo-bar--'\n *\n * _.toLower('fooBar');\n * // => 'foobar'\n *\n * _.toLower('__FOO_BAR__');\n * // => '__foo_bar__'\n */\n function toLower(value) {\n return toString(value).toLowerCase();\n }\n\n /**\n * Converts `string`, as a whole, to upper case just like\n * [String#toUpperCase](https://mdn.io/toUpperCase).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the upper cased string.\n * @example\n *\n * _.toUpper('--foo-bar--');\n * // => '--FOO-BAR--'\n *\n * _.toUpper('fooBar');\n * // => 'FOOBAR'\n *\n * _.toUpper('__foo_bar__');\n * // => '__FOO_BAR__'\n */\n function toUpper(value) {\n return toString(value).toUpperCase();\n }\n\n /**\n * Removes leading and trailing whitespace or specified characters from `string`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to trim.\n * @param {string} [chars=whitespace] The characters to trim.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {string} Returns the trimmed string.\n * @example\n *\n * _.trim(' abc ');\n * // => 'abc'\n *\n * _.trim('-_-abc-_-', '_-');\n * // => 'abc'\n *\n * _.map([' foo ', ' bar '], _.trim);\n * // => ['foo', 'bar']\n */\n function trim(string, chars, guard) {\n string = toString(string);\n if (string && (guard || chars === undefined)) {\n return baseTrim(string);\n }\n if (!string || !(chars = baseToString(chars))) {\n return string;\n }\n var strSymbols = stringToArray(string),\n chrSymbols = stringToArray(chars),\n start = charsStartIndex(strSymbols, chrSymbols),\n end = charsEndIndex(strSymbols, chrSymbols) + 1;\n\n return castSlice(strSymbols, start, end).join('');\n }\n\n /**\n * Removes trailing whitespace or specified characters from `string`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to trim.\n * @param {string} [chars=whitespace] The characters to trim.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {string} Returns the trimmed string.\n * @example\n *\n * _.trimEnd(' abc ');\n * // => ' abc'\n *\n * _.trimEnd('-_-abc-_-', '_-');\n * // => '-_-abc'\n */\n function trimEnd(string, chars, guard) {\n string = toString(string);\n if (string && (guard || chars === undefined)) {\n return string.slice(0, trimmedEndIndex(string) + 1);\n }\n if (!string || !(chars = baseToString(chars))) {\n return string;\n }\n var strSymbols = stringToArray(string),\n end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;\n\n return castSlice(strSymbols, 0, end).join('');\n }\n\n /**\n * Removes leading whitespace or specified characters from `string`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to trim.\n * @param {string} [chars=whitespace] The characters to trim.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {string} Returns the trimmed string.\n * @example\n *\n * _.trimStart(' abc ');\n * // => 'abc '\n *\n * _.trimStart('-_-abc-_-', '_-');\n * // => 'abc-_-'\n */\n function trimStart(string, chars, guard) {\n string = toString(string);\n if (string && (guard || chars === undefined)) {\n return string.replace(reTrimStart, '');\n }\n if (!string || !(chars = baseToString(chars))) {\n return string;\n }\n var strSymbols = stringToArray(string),\n start = charsStartIndex(strSymbols, stringToArray(chars));\n\n return castSlice(strSymbols, start).join('');\n }\n\n /**\n * Truncates `string` if it's longer than the given maximum string length.\n * The last characters of the truncated string are replaced with the omission\n * string which defaults to \"...\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to truncate.\n * @param {Object} [options={}] The options object.\n * @param {number} [options.length=30] The maximum string length.\n * @param {string} [options.omission='...'] The string to indicate text is omitted.\n * @param {RegExp|string} [options.separator] The separator pattern to truncate to.\n * @returns {string} Returns the truncated string.\n * @example\n *\n * _.truncate('hi-diddly-ho there, neighborino');\n * // => 'hi-diddly-ho there, neighbo...'\n *\n * _.truncate('hi-diddly-ho there, neighborino', {\n * 'length': 24,\n * 'separator': ' '\n * });\n * // => 'hi-diddly-ho there,...'\n *\n * _.truncate('hi-diddly-ho there, neighborino', {\n * 'length': 24,\n * 'separator': /,? +/\n * });\n * // => 'hi-diddly-ho there...'\n *\n * _.truncate('hi-diddly-ho there, neighborino', {\n * 'omission': ' [...]'\n * });\n * // => 'hi-diddly-ho there, neig [...]'\n */\n function truncate(string, options) {\n var length = DEFAULT_TRUNC_LENGTH,\n omission = DEFAULT_TRUNC_OMISSION;\n\n if (isObject(options)) {\n var separator = 'separator' in options ? options.separator : separator;\n length = 'length' in options ? toInteger(options.length) : length;\n omission = 'omission' in options ? baseToString(options.omission) : omission;\n }\n string = toString(string);\n\n var strLength = string.length;\n if (hasUnicode(string)) {\n var strSymbols = stringToArray(string);\n strLength = strSymbols.length;\n }\n if (length >= strLength) {\n return string;\n }\n var end = length - stringSize(omission);\n if (end < 1) {\n return omission;\n }\n var result = strSymbols\n ? castSlice(strSymbols, 0, end).join('')\n : string.slice(0, end);\n\n if (separator === undefined) {\n return result + omission;\n }\n if (strSymbols) {\n end += (result.length - end);\n }\n if (isRegExp(separator)) {\n if (string.slice(end).search(separator)) {\n var match,\n substring = result;\n\n if (!separator.global) {\n separator = RegExp(separator.source, toString(reFlags.exec(separator)) + 'g');\n }\n separator.lastIndex = 0;\n while ((match = separator.exec(substring))) {\n var newEnd = match.index;\n }\n result = result.slice(0, newEnd === undefined ? end : newEnd);\n }\n } else if (string.indexOf(baseToString(separator), end) != end) {\n var index = result.lastIndexOf(separator);\n if (index > -1) {\n result = result.slice(0, index);\n }\n }\n return result + omission;\n }\n\n /**\n * The inverse of `_.escape`; this method converts the HTML entities\n * `&`, `<`, `>`, `"`, and `'` in `string` to\n * their corresponding characters.\n *\n * **Note:** No other HTML entities are unescaped. To unescape additional\n * HTML entities use a third-party library like [_he_](https://mths.be/he).\n *\n * @static\n * @memberOf _\n * @since 0.6.0\n * @category String\n * @param {string} [string=''] The string to unescape.\n * @returns {string} Returns the unescaped string.\n * @example\n *\n * _.unescape('fred, barney, & pebbles');\n * // => 'fred, barney, & pebbles'\n */\n function unescape(string) {\n string = toString(string);\n return (string && reHasEscapedHtml.test(string))\n ? string.replace(reEscapedHtml, unescapeHtmlChar)\n : string;\n }\n\n /**\n * Converts `string`, as space separated words, to upper case.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the upper cased string.\n * @example\n *\n * _.upperCase('--foo-bar');\n * // => 'FOO BAR'\n *\n * _.upperCase('fooBar');\n * // => 'FOO BAR'\n *\n * _.upperCase('__foo_bar__');\n * // => 'FOO BAR'\n */\n var upperCase = createCompounder(function(result, word, index) {\n return result + (index ? ' ' : '') + word.toUpperCase();\n });\n\n /**\n * Converts the first character of `string` to upper case.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category String\n * @param {string} [string=''] The string to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.upperFirst('fred');\n * // => 'Fred'\n *\n * _.upperFirst('FRED');\n * // => 'FRED'\n */\n var upperFirst = createCaseFirst('toUpperCase');\n\n /**\n * Splits `string` into an array of its words.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category String\n * @param {string} [string=''] The string to inspect.\n * @param {RegExp|string} [pattern] The pattern to match words.\n * @param- {Object} [guard] Enables use as an iteratee for methods like `_.map`.\n * @returns {Array} Returns the words of `string`.\n * @example\n *\n * _.words('fred, barney, & pebbles');\n * // => ['fred', 'barney', 'pebbles']\n *\n * _.words('fred, barney, & pebbles', /[^, ]+/g);\n * // => ['fred', 'barney', '&', 'pebbles']\n */\n function words(string, pattern, guard) {\n string = toString(string);\n pattern = guard ? undefined : pattern;\n\n if (pattern === undefined) {\n return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);\n }\n return string.match(pattern) || [];\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Attempts to invoke `func`, returning either the result or the caught error\n * object. Any additional arguments are provided to `func` when it's invoked.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Util\n * @param {Function} func The function to attempt.\n * @param {...*} [args] The arguments to invoke `func` with.\n * @returns {*} Returns the `func` result or error object.\n * @example\n *\n * // Avoid throwing errors for invalid selectors.\n * var elements = _.attempt(function(selector) {\n * return document.querySelectorAll(selector);\n * }, '>_>');\n *\n * if (_.isError(elements)) {\n * elements = [];\n * }\n */\n var attempt = baseRest(function(func, args) {\n try {\n return apply(func, undefined, args);\n } catch (e) {\n return isError(e) ? e : new Error(e);\n }\n });\n\n /**\n * Binds methods of an object to the object itself, overwriting the existing\n * method.\n *\n * **Note:** This method doesn't set the \"length\" property of bound functions.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {Object} object The object to bind and assign the bound methods to.\n * @param {...(string|string[])} methodNames The object method names to bind.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var view = {\n * 'label': 'docs',\n * 'click': function() {\n * console.log('clicked ' + this.label);\n * }\n * };\n *\n * _.bindAll(view, ['click']);\n * jQuery(element).on('click', view.click);\n * // => Logs 'clicked docs' when clicked.\n */\n var bindAll = flatRest(function(object, methodNames) {\n arrayEach(methodNames, function(key) {\n key = toKey(key);\n baseAssignValue(object, key, bind(object[key], object));\n });\n return object;\n });\n\n /**\n * Creates a function that iterates over `pairs` and invokes the corresponding\n * function of the first predicate to return truthy. The predicate-function\n * pairs are invoked with the `this` binding and arguments of the created\n * function.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {Array} pairs The predicate-function pairs.\n * @returns {Function} Returns the new composite function.\n * @example\n *\n * var func = _.cond([\n * [_.matches({ 'a': 1 }), _.constant('matches A')],\n * [_.conforms({ 'b': _.isNumber }), _.constant('matches B')],\n * [_.stubTrue, _.constant('no match')]\n * ]);\n *\n * func({ 'a': 1, 'b': 2 });\n * // => 'matches A'\n *\n * func({ 'a': 0, 'b': 1 });\n * // => 'matches B'\n *\n * func({ 'a': '1', 'b': '2' });\n * // => 'no match'\n */\n function cond(pairs) {\n var length = pairs == null ? 0 : pairs.length,\n toIteratee = getIteratee();\n\n pairs = !length ? [] : arrayMap(pairs, function(pair) {\n if (typeof pair[1] != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n return [toIteratee(pair[0]), pair[1]];\n });\n\n return baseRest(function(args) {\n var index = -1;\n while (++index < length) {\n var pair = pairs[index];\n if (apply(pair[0], this, args)) {\n return apply(pair[1], this, args);\n }\n }\n });\n }\n\n /**\n * Creates a function that invokes the predicate properties of `source` with\n * the corresponding property values of a given object, returning `true` if\n * all predicates return truthy, else `false`.\n *\n * **Note:** The created function is equivalent to `_.conformsTo` with\n * `source` partially applied.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {Object} source The object of property predicates to conform to.\n * @returns {Function} Returns the new spec function.\n * @example\n *\n * var objects = [\n * { 'a': 2, 'b': 1 },\n * { 'a': 1, 'b': 2 }\n * ];\n *\n * _.filter(objects, _.conforms({ 'b': function(n) { return n > 1; } }));\n * // => [{ 'a': 1, 'b': 2 }]\n */\n function conforms(source) {\n return baseConforms(baseClone(source, CLONE_DEEP_FLAG));\n }\n\n /**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\n function constant(value) {\n return function() {\n return value;\n };\n }\n\n /**\n * Checks `value` to determine whether a default value should be returned in\n * its place. The `defaultValue` is returned if `value` is `NaN`, `null`,\n * or `undefined`.\n *\n * @static\n * @memberOf _\n * @since 4.14.0\n * @category Util\n * @param {*} value The value to check.\n * @param {*} defaultValue The default value.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * _.defaultTo(1, 10);\n * // => 1\n *\n * _.defaultTo(undefined, 10);\n * // => 10\n */\n function defaultTo(value, defaultValue) {\n return (value == null || value !== value) ? defaultValue : value;\n }\n\n /**\n * Creates a function that returns the result of invoking the given functions\n * with the `this` binding of the created function, where each successive\n * invocation is supplied the return value of the previous.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Util\n * @param {...(Function|Function[])} [funcs] The functions to invoke.\n * @returns {Function} Returns the new composite function.\n * @see _.flowRight\n * @example\n *\n * function square(n) {\n * return n * n;\n * }\n *\n * var addSquare = _.flow([_.add, square]);\n * addSquare(1, 2);\n * // => 9\n */\n var flow = createFlow();\n\n /**\n * This method is like `_.flow` except that it creates a function that\n * invokes the given functions from right to left.\n *\n * @static\n * @since 3.0.0\n * @memberOf _\n * @category Util\n * @param {...(Function|Function[])} [funcs] The functions to invoke.\n * @returns {Function} Returns the new composite function.\n * @see _.flow\n * @example\n *\n * function square(n) {\n * return n * n;\n * }\n *\n * var addSquare = _.flowRight([square, _.add]);\n * addSquare(1, 2);\n * // => 9\n */\n var flowRight = createFlow(true);\n\n /**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\n function identity(value) {\n return value;\n }\n\n /**\n * Creates a function that invokes `func` with the arguments of the created\n * function. If `func` is a property name, the created function returns the\n * property value for a given element. If `func` is an array or object, the\n * created function returns `true` for elements that contain the equivalent\n * source properties, otherwise it returns `false`.\n *\n * @static\n * @since 4.0.0\n * @memberOf _\n * @category Util\n * @param {*} [func=_.identity] The value to convert to a callback.\n * @returns {Function} Returns the callback.\n * @example\n *\n * var users = [\n * { 'user': 'barney', 'age': 36, 'active': true },\n * { 'user': 'fred', 'age': 40, 'active': false }\n * ];\n *\n * // The `_.matches` iteratee shorthand.\n * _.filter(users, _.iteratee({ 'user': 'barney', 'active': true }));\n * // => [{ 'user': 'barney', 'age': 36, 'active': true }]\n *\n * // The `_.matchesProperty` iteratee shorthand.\n * _.filter(users, _.iteratee(['user', 'fred']));\n * // => [{ 'user': 'fred', 'age': 40 }]\n *\n * // The `_.property` iteratee shorthand.\n * _.map(users, _.iteratee('user'));\n * // => ['barney', 'fred']\n *\n * // Create custom iteratee shorthands.\n * _.iteratee = _.wrap(_.iteratee, function(iteratee, func) {\n * return !_.isRegExp(func) ? iteratee(func) : function(string) {\n * return func.test(string);\n * };\n * });\n *\n * _.filter(['abc', 'def'], /ef/);\n * // => ['def']\n */\n function iteratee(func) {\n return baseIteratee(typeof func == 'function' ? func : baseClone(func, CLONE_DEEP_FLAG));\n }\n\n /**\n * Creates a function that performs a partial deep comparison between a given\n * object and `source`, returning `true` if the given object has equivalent\n * property values, else `false`.\n *\n * **Note:** The created function is equivalent to `_.isMatch` with `source`\n * partially applied.\n *\n * Partial comparisons will match empty array and empty object `source`\n * values against any array or object value, respectively. See `_.isEqual`\n * for a list of supported value comparisons.\n *\n * **Note:** Multiple values can be checked by combining several matchers\n * using `_.overSome`\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Util\n * @param {Object} source The object of property values to match.\n * @returns {Function} Returns the new spec function.\n * @example\n *\n * var objects = [\n * { 'a': 1, 'b': 2, 'c': 3 },\n * { 'a': 4, 'b': 5, 'c': 6 }\n * ];\n *\n * _.filter(objects, _.matches({ 'a': 4, 'c': 6 }));\n * // => [{ 'a': 4, 'b': 5, 'c': 6 }]\n *\n * // Checking for several possible values\n * _.filter(objects, _.overSome([_.matches({ 'a': 1 }), _.matches({ 'a': 4 })]));\n * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]\n */\n function matches(source) {\n return baseMatches(baseClone(source, CLONE_DEEP_FLAG));\n }\n\n /**\n * Creates a function that performs a partial deep comparison between the\n * value at `path` of a given object to `srcValue`, returning `true` if the\n * object value is equivalent, else `false`.\n *\n * **Note:** Partial comparisons will match empty array and empty object\n * `srcValue` values against any array or object value, respectively. See\n * `_.isEqual` for a list of supported value comparisons.\n *\n * **Note:** Multiple values can be checked by combining several matchers\n * using `_.overSome`\n *\n * @static\n * @memberOf _\n * @since 3.2.0\n * @category Util\n * @param {Array|string} path The path of the property to get.\n * @param {*} srcValue The value to match.\n * @returns {Function} Returns the new spec function.\n * @example\n *\n * var objects = [\n * { 'a': 1, 'b': 2, 'c': 3 },\n * { 'a': 4, 'b': 5, 'c': 6 }\n * ];\n *\n * _.find(objects, _.matchesProperty('a', 4));\n * // => { 'a': 4, 'b': 5, 'c': 6 }\n *\n * // Checking for several possible values\n * _.filter(objects, _.overSome([_.matchesProperty('a', 1), _.matchesProperty('a', 4)]));\n * // => [{ 'a': 1, 'b': 2, 'c': 3 }, { 'a': 4, 'b': 5, 'c': 6 }]\n */\n function matchesProperty(path, srcValue) {\n return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));\n }\n\n /**\n * Creates a function that invokes the method at `path` of a given object.\n * Any additional arguments are provided to the invoked method.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Util\n * @param {Array|string} path The path of the method to invoke.\n * @param {...*} [args] The arguments to invoke the method with.\n * @returns {Function} Returns the new invoker function.\n * @example\n *\n * var objects = [\n * { 'a': { 'b': _.constant(2) } },\n * { 'a': { 'b': _.constant(1) } }\n * ];\n *\n * _.map(objects, _.method('a.b'));\n * // => [2, 1]\n *\n * _.map(objects, _.method(['a', 'b']));\n * // => [2, 1]\n */\n var method = baseRest(function(path, args) {\n return function(object) {\n return baseInvoke(object, path, args);\n };\n });\n\n /**\n * The opposite of `_.method`; this method creates a function that invokes\n * the method at a given path of `object`. Any additional arguments are\n * provided to the invoked method.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Util\n * @param {Object} object The object to query.\n * @param {...*} [args] The arguments to invoke the method with.\n * @returns {Function} Returns the new invoker function.\n * @example\n *\n * var array = _.times(3, _.constant),\n * object = { 'a': array, 'b': array, 'c': array };\n *\n * _.map(['a[2]', 'c[0]'], _.methodOf(object));\n * // => [2, 0]\n *\n * _.map([['a', '2'], ['c', '0']], _.methodOf(object));\n * // => [2, 0]\n */\n var methodOf = baseRest(function(object, args) {\n return function(path) {\n return baseInvoke(object, path, args);\n };\n });\n\n /**\n * Adds all own enumerable string keyed function properties of a source\n * object to the destination object. If `object` is a function, then methods\n * are added to its prototype as well.\n *\n * **Note:** Use `_.runInContext` to create a pristine `lodash` function to\n * avoid conflicts caused by modifying the original.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {Function|Object} [object=lodash] The destination object.\n * @param {Object} source The object of functions to add.\n * @param {Object} [options={}] The options object.\n * @param {boolean} [options.chain=true] Specify whether mixins are chainable.\n * @returns {Function|Object} Returns `object`.\n * @example\n *\n * function vowels(string) {\n * return _.filter(string, function(v) {\n * return /[aeiou]/i.test(v);\n * });\n * }\n *\n * _.mixin({ 'vowels': vowels });\n * _.vowels('fred');\n * // => ['e']\n *\n * _('fred').vowels().value();\n * // => ['e']\n *\n * _.mixin({ 'vowels': vowels }, { 'chain': false });\n * _('fred').vowels();\n * // => ['e']\n */\n function mixin(object, source, options) {\n var props = keys(source),\n methodNames = baseFunctions(source, props);\n\n if (options == null &&\n !(isObject(source) && (methodNames.length || !props.length))) {\n options = source;\n source = object;\n object = this;\n methodNames = baseFunctions(source, keys(source));\n }\n var chain = !(isObject(options) && 'chain' in options) || !!options.chain,\n isFunc = isFunction(object);\n\n arrayEach(methodNames, function(methodName) {\n var func = source[methodName];\n object[methodName] = func;\n if (isFunc) {\n object.prototype[methodName] = function() {\n var chainAll = this.__chain__;\n if (chain || chainAll) {\n var result = object(this.__wrapped__),\n actions = result.__actions__ = copyArray(this.__actions__);\n\n actions.push({ 'func': func, 'args': arguments, 'thisArg': object });\n result.__chain__ = chainAll;\n return result;\n }\n return func.apply(object, arrayPush([this.value()], arguments));\n };\n }\n });\n\n return object;\n }\n\n /**\n * Reverts the `_` variable to its previous value and returns a reference to\n * the `lodash` function.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @returns {Function} Returns the `lodash` function.\n * @example\n *\n * var lodash = _.noConflict();\n */\n function noConflict() {\n if (root._ === this) {\n root._ = oldDash;\n }\n return this;\n }\n\n /**\n * This method returns `undefined`.\n *\n * @static\n * @memberOf _\n * @since 2.3.0\n * @category Util\n * @example\n *\n * _.times(2, _.noop);\n * // => [undefined, undefined]\n */\n function noop() {\n // No operation performed.\n }\n\n /**\n * Creates a function that gets the argument at index `n`. If `n` is negative,\n * the nth argument from the end is returned.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {number} [n=0] The index of the argument to return.\n * @returns {Function} Returns the new pass-thru function.\n * @example\n *\n * var func = _.nthArg(1);\n * func('a', 'b', 'c', 'd');\n * // => 'b'\n *\n * var func = _.nthArg(-2);\n * func('a', 'b', 'c', 'd');\n * // => 'c'\n */\n function nthArg(n) {\n n = toInteger(n);\n return baseRest(function(args) {\n return baseNth(args, n);\n });\n }\n\n /**\n * Creates a function that invokes `iteratees` with the arguments it receives\n * and returns their results.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {...(Function|Function[])} [iteratees=[_.identity]]\n * The iteratees to invoke.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var func = _.over([Math.max, Math.min]);\n *\n * func(1, 2, 3, 4);\n * // => [4, 1]\n */\n var over = createOver(arrayMap);\n\n /**\n * Creates a function that checks if **all** of the `predicates` return\n * truthy when invoked with the arguments it receives.\n *\n * Following shorthands are possible for providing predicates.\n * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.\n * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {...(Function|Function[])} [predicates=[_.identity]]\n * The predicates to check.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var func = _.overEvery([Boolean, isFinite]);\n *\n * func('1');\n * // => true\n *\n * func(null);\n * // => false\n *\n * func(NaN);\n * // => false\n */\n var overEvery = createOver(arrayEvery);\n\n /**\n * Creates a function that checks if **any** of the `predicates` return\n * truthy when invoked with the arguments it receives.\n *\n * Following shorthands are possible for providing predicates.\n * Pass an `Object` and it will be used as an parameter for `_.matches` to create the predicate.\n * Pass an `Array` of parameters for `_.matchesProperty` and the predicate will be created using them.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {...(Function|Function[])} [predicates=[_.identity]]\n * The predicates to check.\n * @returns {Function} Returns the new function.\n * @example\n *\n * var func = _.overSome([Boolean, isFinite]);\n *\n * func('1');\n * // => true\n *\n * func(null);\n * // => true\n *\n * func(NaN);\n * // => false\n *\n * var matchesFunc = _.overSome([{ 'a': 1 }, { 'a': 2 }])\n * var matchesPropertyFunc = _.overSome([['a', 1], ['a', 2]])\n */\n var overSome = createOver(arraySome);\n\n /**\n * Creates a function that returns the value at `path` of a given object.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new accessor function.\n * @example\n *\n * var objects = [\n * { 'a': { 'b': 2 } },\n * { 'a': { 'b': 1 } }\n * ];\n *\n * _.map(objects, _.property('a.b'));\n * // => [2, 1]\n *\n * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');\n * // => [1, 2]\n */\n function property(path) {\n return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);\n }\n\n /**\n * The opposite of `_.property`; this method creates a function that returns\n * the value at a given path of `object`.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Util\n * @param {Object} object The object to query.\n * @returns {Function} Returns the new accessor function.\n * @example\n *\n * var array = [0, 1, 2],\n * object = { 'a': array, 'b': array, 'c': array };\n *\n * _.map(['a[2]', 'c[0]'], _.propertyOf(object));\n * // => [2, 0]\n *\n * _.map([['a', '2'], ['c', '0']], _.propertyOf(object));\n * // => [2, 0]\n */\n function propertyOf(object) {\n return function(path) {\n return object == null ? undefined : baseGet(object, path);\n };\n }\n\n /**\n * Creates an array of numbers (positive and/or negative) progressing from\n * `start` up to, but not including, `end`. A step of `-1` is used if a negative\n * `start` is specified without an `end` or `step`. If `end` is not specified,\n * it's set to `start` with `start` then set to `0`.\n *\n * **Note:** JavaScript follows the IEEE-754 standard for resolving\n * floating-point values which can produce unexpected results.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {number} [start=0] The start of the range.\n * @param {number} end The end of the range.\n * @param {number} [step=1] The value to increment or decrement by.\n * @returns {Array} Returns the range of numbers.\n * @see _.inRange, _.rangeRight\n * @example\n *\n * _.range(4);\n * // => [0, 1, 2, 3]\n *\n * _.range(-4);\n * // => [0, -1, -2, -3]\n *\n * _.range(1, 5);\n * // => [1, 2, 3, 4]\n *\n * _.range(0, 20, 5);\n * // => [0, 5, 10, 15]\n *\n * _.range(0, -4, -1);\n * // => [0, -1, -2, -3]\n *\n * _.range(1, 4, 0);\n * // => [1, 1, 1]\n *\n * _.range(0);\n * // => []\n */\n var range = createRange();\n\n /**\n * This method is like `_.range` except that it populates values in\n * descending order.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {number} [start=0] The start of the range.\n * @param {number} end The end of the range.\n * @param {number} [step=1] The value to increment or decrement by.\n * @returns {Array} Returns the range of numbers.\n * @see _.inRange, _.range\n * @example\n *\n * _.rangeRight(4);\n * // => [3, 2, 1, 0]\n *\n * _.rangeRight(-4);\n * // => [-3, -2, -1, 0]\n *\n * _.rangeRight(1, 5);\n * // => [4, 3, 2, 1]\n *\n * _.rangeRight(0, 20, 5);\n * // => [15, 10, 5, 0]\n *\n * _.rangeRight(0, -4, -1);\n * // => [-3, -2, -1, 0]\n *\n * _.rangeRight(1, 4, 0);\n * // => [1, 1, 1]\n *\n * _.rangeRight(0);\n * // => []\n */\n var rangeRight = createRange(true);\n\n /**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\n function stubArray() {\n return [];\n }\n\n /**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\n function stubFalse() {\n return false;\n }\n\n /**\n * This method returns a new empty object.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Object} Returns the new empty object.\n * @example\n *\n * var objects = _.times(2, _.stubObject);\n *\n * console.log(objects);\n * // => [{}, {}]\n *\n * console.log(objects[0] === objects[1]);\n * // => false\n */\n function stubObject() {\n return {};\n }\n\n /**\n * This method returns an empty string.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {string} Returns the empty string.\n * @example\n *\n * _.times(2, _.stubString);\n * // => ['', '']\n */\n function stubString() {\n return '';\n }\n\n /**\n * This method returns `true`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `true`.\n * @example\n *\n * _.times(2, _.stubTrue);\n * // => [true, true]\n */\n function stubTrue() {\n return true;\n }\n\n /**\n * Invokes the iteratee `n` times, returning an array of the results of\n * each invocation. The iteratee is invoked with one argument; (index).\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n * @example\n *\n * _.times(3, String);\n * // => ['0', '1', '2']\n *\n * _.times(4, _.constant(0));\n * // => [0, 0, 0, 0]\n */\n function times(n, iteratee) {\n n = toInteger(n);\n if (n < 1 || n > MAX_SAFE_INTEGER) {\n return [];\n }\n var index = MAX_ARRAY_LENGTH,\n length = nativeMin(n, MAX_ARRAY_LENGTH);\n\n iteratee = getIteratee(iteratee);\n n -= MAX_ARRAY_LENGTH;\n\n var result = baseTimes(length, iteratee);\n while (++index < n) {\n iteratee(index);\n }\n return result;\n }\n\n /**\n * Converts `value` to a property path array.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Util\n * @param {*} value The value to convert.\n * @returns {Array} Returns the new property path array.\n * @example\n *\n * _.toPath('a.b.c');\n * // => ['a', 'b', 'c']\n *\n * _.toPath('a[0].b.c');\n * // => ['a', '0', 'b', 'c']\n */\n function toPath(value) {\n if (isArray(value)) {\n return arrayMap(value, toKey);\n }\n return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));\n }\n\n /**\n * Generates a unique ID. If `prefix` is given, the ID is appended to it.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {string} [prefix=''] The value to prefix the ID with.\n * @returns {string} Returns the unique ID.\n * @example\n *\n * _.uniqueId('contact_');\n * // => 'contact_104'\n *\n * _.uniqueId();\n * // => '105'\n */\n function uniqueId(prefix) {\n var id = ++idCounter;\n return toString(prefix) + id;\n }\n\n /*------------------------------------------------------------------------*/\n\n /**\n * Adds two numbers.\n *\n * @static\n * @memberOf _\n * @since 3.4.0\n * @category Math\n * @param {number} augend The first number in an addition.\n * @param {number} addend The second number in an addition.\n * @returns {number} Returns the total.\n * @example\n *\n * _.add(6, 4);\n * // => 10\n */\n var add = createMathOperation(function(augend, addend) {\n return augend + addend;\n }, 0);\n\n /**\n * Computes `number` rounded up to `precision`.\n *\n * @static\n * @memberOf _\n * @since 3.10.0\n * @category Math\n * @param {number} number The number to round up.\n * @param {number} [precision=0] The precision to round up to.\n * @returns {number} Returns the rounded up number.\n * @example\n *\n * _.ceil(4.006);\n * // => 5\n *\n * _.ceil(6.004, 2);\n * // => 6.01\n *\n * _.ceil(6040, -2);\n * // => 6100\n */\n var ceil = createRound('ceil');\n\n /**\n * Divide two numbers.\n *\n * @static\n * @memberOf _\n * @since 4.7.0\n * @category Math\n * @param {number} dividend The first number in a division.\n * @param {number} divisor The second number in a division.\n * @returns {number} Returns the quotient.\n * @example\n *\n * _.divide(6, 4);\n * // => 1.5\n */\n var divide = createMathOperation(function(dividend, divisor) {\n return dividend / divisor;\n }, 1);\n\n /**\n * Computes `number` rounded down to `precision`.\n *\n * @static\n * @memberOf _\n * @since 3.10.0\n * @category Math\n * @param {number} number The number to round down.\n * @param {number} [precision=0] The precision to round down to.\n * @returns {number} Returns the rounded down number.\n * @example\n *\n * _.floor(4.006);\n * // => 4\n *\n * _.floor(0.046, 2);\n * // => 0.04\n *\n * _.floor(4060, -2);\n * // => 4000\n */\n var floor = createRound('floor');\n\n /**\n * Computes the maximum value of `array`. If `array` is empty or falsey,\n * `undefined` is returned.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Math\n * @param {Array} array The array to iterate over.\n * @returns {*} Returns the maximum value.\n * @example\n *\n * _.max([4, 2, 8, 6]);\n * // => 8\n *\n * _.max([]);\n * // => undefined\n */\n function max(array) {\n return (array && array.length)\n ? baseExtremum(array, identity, baseGt)\n : undefined;\n }\n\n /**\n * This method is like `_.max` except that it accepts `iteratee` which is\n * invoked for each element in `array` to generate the criterion by which\n * the value is ranked. The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Math\n * @param {Array} array The array to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {*} Returns the maximum value.\n * @example\n *\n * var objects = [{ 'n': 1 }, { 'n': 2 }];\n *\n * _.maxBy(objects, function(o) { return o.n; });\n * // => { 'n': 2 }\n *\n * // The `_.property` iteratee shorthand.\n * _.maxBy(objects, 'n');\n * // => { 'n': 2 }\n */\n function maxBy(array, iteratee) {\n return (array && array.length)\n ? baseExtremum(array, getIteratee(iteratee, 2), baseGt)\n : undefined;\n }\n\n /**\n * Computes the mean of the values in `array`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Math\n * @param {Array} array The array to iterate over.\n * @returns {number} Returns the mean.\n * @example\n *\n * _.mean([4, 2, 8, 6]);\n * // => 5\n */\n function mean(array) {\n return baseMean(array, identity);\n }\n\n /**\n * This method is like `_.mean` except that it accepts `iteratee` which is\n * invoked for each element in `array` to generate the value to be averaged.\n * The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.7.0\n * @category Math\n * @param {Array} array The array to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {number} Returns the mean.\n * @example\n *\n * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n *\n * _.meanBy(objects, function(o) { return o.n; });\n * // => 5\n *\n * // The `_.property` iteratee shorthand.\n * _.meanBy(objects, 'n');\n * // => 5\n */\n function meanBy(array, iteratee) {\n return baseMean(array, getIteratee(iteratee, 2));\n }\n\n /**\n * Computes the minimum value of `array`. If `array` is empty or falsey,\n * `undefined` is returned.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Math\n * @param {Array} array The array to iterate over.\n * @returns {*} Returns the minimum value.\n * @example\n *\n * _.min([4, 2, 8, 6]);\n * // => 2\n *\n * _.min([]);\n * // => undefined\n */\n function min(array) {\n return (array && array.length)\n ? baseExtremum(array, identity, baseLt)\n : undefined;\n }\n\n /**\n * This method is like `_.min` except that it accepts `iteratee` which is\n * invoked for each element in `array` to generate the criterion by which\n * the value is ranked. The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Math\n * @param {Array} array The array to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {*} Returns the minimum value.\n * @example\n *\n * var objects = [{ 'n': 1 }, { 'n': 2 }];\n *\n * _.minBy(objects, function(o) { return o.n; });\n * // => { 'n': 1 }\n *\n * // The `_.property` iteratee shorthand.\n * _.minBy(objects, 'n');\n * // => { 'n': 1 }\n */\n function minBy(array, iteratee) {\n return (array && array.length)\n ? baseExtremum(array, getIteratee(iteratee, 2), baseLt)\n : undefined;\n }\n\n /**\n * Multiply two numbers.\n *\n * @static\n * @memberOf _\n * @since 4.7.0\n * @category Math\n * @param {number} multiplier The first number in a multiplication.\n * @param {number} multiplicand The second number in a multiplication.\n * @returns {number} Returns the product.\n * @example\n *\n * _.multiply(6, 4);\n * // => 24\n */\n var multiply = createMathOperation(function(multiplier, multiplicand) {\n return multiplier * multiplicand;\n }, 1);\n\n /**\n * Computes `number` rounded to `precision`.\n *\n * @static\n * @memberOf _\n * @since 3.10.0\n * @category Math\n * @param {number} number The number to round.\n * @param {number} [precision=0] The precision to round to.\n * @returns {number} Returns the rounded number.\n * @example\n *\n * _.round(4.006);\n * // => 4\n *\n * _.round(4.006, 2);\n * // => 4.01\n *\n * _.round(4060, -2);\n * // => 4100\n */\n var round = createRound('round');\n\n /**\n * Subtract two numbers.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Math\n * @param {number} minuend The first number in a subtraction.\n * @param {number} subtrahend The second number in a subtraction.\n * @returns {number} Returns the difference.\n * @example\n *\n * _.subtract(6, 4);\n * // => 2\n */\n var subtract = createMathOperation(function(minuend, subtrahend) {\n return minuend - subtrahend;\n }, 0);\n\n /**\n * Computes the sum of the values in `array`.\n *\n * @static\n * @memberOf _\n * @since 3.4.0\n * @category Math\n * @param {Array} array The array to iterate over.\n * @returns {number} Returns the sum.\n * @example\n *\n * _.sum([4, 2, 8, 6]);\n * // => 20\n */\n function sum(array) {\n return (array && array.length)\n ? baseSum(array, identity)\n : 0;\n }\n\n /**\n * This method is like `_.sum` except that it accepts `iteratee` which is\n * invoked for each element in `array` to generate the value to be summed.\n * The iteratee is invoked with one argument: (value).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Math\n * @param {Array} array The array to iterate over.\n * @param {Function} [iteratee=_.identity] The iteratee invoked per element.\n * @returns {number} Returns the sum.\n * @example\n *\n * var objects = [{ 'n': 4 }, { 'n': 2 }, { 'n': 8 }, { 'n': 6 }];\n *\n * _.sumBy(objects, function(o) { return o.n; });\n * // => 20\n *\n * // The `_.property` iteratee shorthand.\n * _.sumBy(objects, 'n');\n * // => 20\n */\n function sumBy(array, iteratee) {\n return (array && array.length)\n ? baseSum(array, getIteratee(iteratee, 2))\n : 0;\n }\n\n /*------------------------------------------------------------------------*/\n\n // Add methods that return wrapped values in chain sequences.\n lodash.after = after;\n lodash.ary = ary;\n lodash.assign = assign;\n lodash.assignIn = assignIn;\n lodash.assignInWith = assignInWith;\n lodash.assignWith = assignWith;\n lodash.at = at;\n lodash.before = before;\n lodash.bind = bind;\n lodash.bindAll = bindAll;\n lodash.bindKey = bindKey;\n lodash.castArray = castArray;\n lodash.chain = chain;\n lodash.chunk = chunk;\n lodash.compact = compact;\n lodash.concat = concat;\n lodash.cond = cond;\n lodash.conforms = conforms;\n lodash.constant = constant;\n lodash.countBy = countBy;\n lodash.create = create;\n lodash.curry = curry;\n lodash.curryRight = curryRight;\n lodash.debounce = debounce;\n lodash.defaults = defaults;\n lodash.defaultsDeep = defaultsDeep;\n lodash.defer = defer;\n lodash.delay = delay;\n lodash.difference = difference;\n lodash.differenceBy = differenceBy;\n lodash.differenceWith = differenceWith;\n lodash.drop = drop;\n lodash.dropRight = dropRight;\n lodash.dropRightWhile = dropRightWhile;\n lodash.dropWhile = dropWhile;\n lodash.fill = fill;\n lodash.filter = filter;\n lodash.flatMap = flatMap;\n lodash.flatMapDeep = flatMapDeep;\n lodash.flatMapDepth = flatMapDepth;\n lodash.flatten = flatten;\n lodash.flattenDeep = flattenDeep;\n lodash.flattenDepth = flattenDepth;\n lodash.flip = flip;\n lodash.flow = flow;\n lodash.flowRight = flowRight;\n lodash.fromPairs = fromPairs;\n lodash.functions = functions;\n lodash.functionsIn = functionsIn;\n lodash.groupBy = groupBy;\n lodash.initial = initial;\n lodash.intersection = intersection;\n lodash.intersectionBy = intersectionBy;\n lodash.intersectionWith = intersectionWith;\n lodash.invert = invert;\n lodash.invertBy = invertBy;\n lodash.invokeMap = invokeMap;\n lodash.iteratee = iteratee;\n lodash.keyBy = keyBy;\n lodash.keys = keys;\n lodash.keysIn = keysIn;\n lodash.map = map;\n lodash.mapKeys = mapKeys;\n lodash.mapValues = mapValues;\n lodash.matches = matches;\n lodash.matchesProperty = matchesProperty;\n lodash.memoize = memoize;\n lodash.merge = merge;\n lodash.mergeWith = mergeWith;\n lodash.method = method;\n lodash.methodOf = methodOf;\n lodash.mixin = mixin;\n lodash.negate = negate;\n lodash.nthArg = nthArg;\n lodash.omit = omit;\n lodash.omitBy = omitBy;\n lodash.once = once;\n lodash.orderBy = orderBy;\n lodash.over = over;\n lodash.overArgs = overArgs;\n lodash.overEvery = overEvery;\n lodash.overSome = overSome;\n lodash.partial = partial;\n lodash.partialRight = partialRight;\n lodash.partition = partition;\n lodash.pick = pick;\n lodash.pickBy = pickBy;\n lodash.property = property;\n lodash.propertyOf = propertyOf;\n lodash.pull = pull;\n lodash.pullAll = pullAll;\n lodash.pullAllBy = pullAllBy;\n lodash.pullAllWith = pullAllWith;\n lodash.pullAt = pullAt;\n lodash.range = range;\n lodash.rangeRight = rangeRight;\n lodash.rearg = rearg;\n lodash.reject = reject;\n lodash.remove = remove;\n lodash.rest = rest;\n lodash.reverse = reverse;\n lodash.sampleSize = sampleSize;\n lodash.set = set;\n lodash.setWith = setWith;\n lodash.shuffle = shuffle;\n lodash.slice = slice;\n lodash.sortBy = sortBy;\n lodash.sortedUniq = sortedUniq;\n lodash.sortedUniqBy = sortedUniqBy;\n lodash.split = split;\n lodash.spread = spread;\n lodash.tail = tail;\n lodash.take = take;\n lodash.takeRight = takeRight;\n lodash.takeRightWhile = takeRightWhile;\n lodash.takeWhile = takeWhile;\n lodash.tap = tap;\n lodash.throttle = throttle;\n lodash.thru = thru;\n lodash.toArray = toArray;\n lodash.toPairs = toPairs;\n lodash.toPairsIn = toPairsIn;\n lodash.toPath = toPath;\n lodash.toPlainObject = toPlainObject;\n lodash.transform = transform;\n lodash.unary = unary;\n lodash.union = union;\n lodash.unionBy = unionBy;\n lodash.unionWith = unionWith;\n lodash.uniq = uniq;\n lodash.uniqBy = uniqBy;\n lodash.uniqWith = uniqWith;\n lodash.unset = unset;\n lodash.unzip = unzip;\n lodash.unzipWith = unzipWith;\n lodash.update = update;\n lodash.updateWith = updateWith;\n lodash.values = values;\n lodash.valuesIn = valuesIn;\n lodash.without = without;\n lodash.words = words;\n lodash.wrap = wrap;\n lodash.xor = xor;\n lodash.xorBy = xorBy;\n lodash.xorWith = xorWith;\n lodash.zip = zip;\n lodash.zipObject = zipObject;\n lodash.zipObjectDeep = zipObjectDeep;\n lodash.zipWith = zipWith;\n\n // Add aliases.\n lodash.entries = toPairs;\n lodash.entriesIn = toPairsIn;\n lodash.extend = assignIn;\n lodash.extendWith = assignInWith;\n\n // Add methods to `lodash.prototype`.\n mixin(lodash, lodash);\n\n /*------------------------------------------------------------------------*/\n\n // Add methods that return unwrapped values in chain sequences.\n lodash.add = add;\n lodash.attempt = attempt;\n lodash.camelCase = camelCase;\n lodash.capitalize = capitalize;\n lodash.ceil = ceil;\n lodash.clamp = clamp;\n lodash.clone = clone;\n lodash.cloneDeep = cloneDeep;\n lodash.cloneDeepWith = cloneDeepWith;\n lodash.cloneWith = cloneWith;\n lodash.conformsTo = conformsTo;\n lodash.deburr = deburr;\n lodash.defaultTo = defaultTo;\n lodash.divide = divide;\n lodash.endsWith = endsWith;\n lodash.eq = eq;\n lodash.escape = escape;\n lodash.escapeRegExp = escapeRegExp;\n lodash.every = every;\n lodash.find = find;\n lodash.findIndex = findIndex;\n lodash.findKey = findKey;\n lodash.findLast = findLast;\n lodash.findLastIndex = findLastIndex;\n lodash.findLastKey = findLastKey;\n lodash.floor = floor;\n lodash.forEach = forEach;\n lodash.forEachRight = forEachRight;\n lodash.forIn = forIn;\n lodash.forInRight = forInRight;\n lodash.forOwn = forOwn;\n lodash.forOwnRight = forOwnRight;\n lodash.get = get;\n lodash.gt = gt;\n lodash.gte = gte;\n lodash.has = has;\n lodash.hasIn = hasIn;\n lodash.head = head;\n lodash.identity = identity;\n lodash.includes = includes;\n lodash.indexOf = indexOf;\n lodash.inRange = inRange;\n lodash.invoke = invoke;\n lodash.isArguments = isArguments;\n lodash.isArray = isArray;\n lodash.isArrayBuffer = isArrayBuffer;\n lodash.isArrayLike = isArrayLike;\n lodash.isArrayLikeObject = isArrayLikeObject;\n lodash.isBoolean = isBoolean;\n lodash.isBuffer = isBuffer;\n lodash.isDate = isDate;\n lodash.isElement = isElement;\n lodash.isEmpty = isEmpty;\n lodash.isEqual = isEqual;\n lodash.isEqualWith = isEqualWith;\n lodash.isError = isError;\n lodash.isFinite = isFinite;\n lodash.isFunction = isFunction;\n lodash.isInteger = isInteger;\n lodash.isLength = isLength;\n lodash.isMap = isMap;\n lodash.isMatch = isMatch;\n lodash.isMatchWith = isMatchWith;\n lodash.isNaN = isNaN;\n lodash.isNative = isNative;\n lodash.isNil = isNil;\n lodash.isNull = isNull;\n lodash.isNumber = isNumber;\n lodash.isObject = isObject;\n lodash.isObjectLike = isObjectLike;\n lodash.isPlainObject = isPlainObject;\n lodash.isRegExp = isRegExp;\n lodash.isSafeInteger = isSafeInteger;\n lodash.isSet = isSet;\n lodash.isString = isString;\n lodash.isSymbol = isSymbol;\n lodash.isTypedArray = isTypedArray;\n lodash.isUndefined = isUndefined;\n lodash.isWeakMap = isWeakMap;\n lodash.isWeakSet = isWeakSet;\n lodash.join = join;\n lodash.kebabCase = kebabCase;\n lodash.last = last;\n lodash.lastIndexOf = lastIndexOf;\n lodash.lowerCase = lowerCase;\n lodash.lowerFirst = lowerFirst;\n lodash.lt = lt;\n lodash.lte = lte;\n lodash.max = max;\n lodash.maxBy = maxBy;\n lodash.mean = mean;\n lodash.meanBy = meanBy;\n lodash.min = min;\n lodash.minBy = minBy;\n lodash.stubArray = stubArray;\n lodash.stubFalse = stubFalse;\n lodash.stubObject = stubObject;\n lodash.stubString = stubString;\n lodash.stubTrue = stubTrue;\n lodash.multiply = multiply;\n lodash.nth = nth;\n lodash.noConflict = noConflict;\n lodash.noop = noop;\n lodash.now = now;\n lodash.pad = pad;\n lodash.padEnd = padEnd;\n lodash.padStart = padStart;\n lodash.parseInt = parseInt;\n lodash.random = random;\n lodash.reduce = reduce;\n lodash.reduceRight = reduceRight;\n lodash.repeat = repeat;\n lodash.replace = replace;\n lodash.result = result;\n lodash.round = round;\n lodash.runInContext = runInContext;\n lodash.sample = sample;\n lodash.size = size;\n lodash.snakeCase = snakeCase;\n lodash.some = some;\n lodash.sortedIndex = sortedIndex;\n lodash.sortedIndexBy = sortedIndexBy;\n lodash.sortedIndexOf = sortedIndexOf;\n lodash.sortedLastIndex = sortedLastIndex;\n lodash.sortedLastIndexBy = sortedLastIndexBy;\n lodash.sortedLastIndexOf = sortedLastIndexOf;\n lodash.startCase = startCase;\n lodash.startsWith = startsWith;\n lodash.subtract = subtract;\n lodash.sum = sum;\n lodash.sumBy = sumBy;\n lodash.template = template;\n lodash.times = times;\n lodash.toFinite = toFinite;\n lodash.toInteger = toInteger;\n lodash.toLength = toLength;\n lodash.toLower = toLower;\n lodash.toNumber = toNumber;\n lodash.toSafeInteger = toSafeInteger;\n lodash.toString = toString;\n lodash.toUpper = toUpper;\n lodash.trim = trim;\n lodash.trimEnd = trimEnd;\n lodash.trimStart = trimStart;\n lodash.truncate = truncate;\n lodash.unescape = unescape;\n lodash.uniqueId = uniqueId;\n lodash.upperCase = upperCase;\n lodash.upperFirst = upperFirst;\n\n // Add aliases.\n lodash.each = forEach;\n lodash.eachRight = forEachRight;\n lodash.first = head;\n\n mixin(lodash, (function() {\n var source = {};\n baseForOwn(lodash, function(func, methodName) {\n if (!hasOwnProperty.call(lodash.prototype, methodName)) {\n source[methodName] = func;\n }\n });\n return source;\n }()), { 'chain': false });\n\n /*------------------------------------------------------------------------*/\n\n /**\n * The semantic version number.\n *\n * @static\n * @memberOf _\n * @type {string}\n */\n lodash.VERSION = VERSION;\n\n // Assign default placeholders.\n arrayEach(['bind', 'bindKey', 'curry', 'curryRight', 'partial', 'partialRight'], function(methodName) {\n lodash[methodName].placeholder = lodash;\n });\n\n // Add `LazyWrapper` methods for `_.drop` and `_.take` variants.\n arrayEach(['drop', 'take'], function(methodName, index) {\n LazyWrapper.prototype[methodName] = function(n) {\n n = n === undefined ? 1 : nativeMax(toInteger(n), 0);\n\n var result = (this.__filtered__ && !index)\n ? new LazyWrapper(this)\n : this.clone();\n\n if (result.__filtered__) {\n result.__takeCount__ = nativeMin(n, result.__takeCount__);\n } else {\n result.__views__.push({\n 'size': nativeMin(n, MAX_ARRAY_LENGTH),\n 'type': methodName + (result.__dir__ < 0 ? 'Right' : '')\n });\n }\n return result;\n };\n\n LazyWrapper.prototype[methodName + 'Right'] = function(n) {\n return this.reverse()[methodName](n).reverse();\n };\n });\n\n // Add `LazyWrapper` methods that accept an `iteratee` value.\n arrayEach(['filter', 'map', 'takeWhile'], function(methodName, index) {\n var type = index + 1,\n isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;\n\n LazyWrapper.prototype[methodName] = function(iteratee) {\n var result = this.clone();\n result.__iteratees__.push({\n 'iteratee': getIteratee(iteratee, 3),\n 'type': type\n });\n result.__filtered__ = result.__filtered__ || isFilter;\n return result;\n };\n });\n\n // Add `LazyWrapper` methods for `_.head` and `_.last`.\n arrayEach(['head', 'last'], function(methodName, index) {\n var takeName = 'take' + (index ? 'Right' : '');\n\n LazyWrapper.prototype[methodName] = function() {\n return this[takeName](1).value()[0];\n };\n });\n\n // Add `LazyWrapper` methods for `_.initial` and `_.tail`.\n arrayEach(['initial', 'tail'], function(methodName, index) {\n var dropName = 'drop' + (index ? '' : 'Right');\n\n LazyWrapper.prototype[methodName] = function() {\n return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);\n };\n });\n\n LazyWrapper.prototype.compact = function() {\n return this.filter(identity);\n };\n\n LazyWrapper.prototype.find = function(predicate) {\n return this.filter(predicate).head();\n };\n\n LazyWrapper.prototype.findLast = function(predicate) {\n return this.reverse().find(predicate);\n };\n\n LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {\n if (typeof path == 'function') {\n return new LazyWrapper(this);\n }\n return this.map(function(value) {\n return baseInvoke(value, path, args);\n });\n });\n\n LazyWrapper.prototype.reject = function(predicate) {\n return this.filter(negate(getIteratee(predicate)));\n };\n\n LazyWrapper.prototype.slice = function(start, end) {\n start = toInteger(start);\n\n var result = this;\n if (result.__filtered__ && (start > 0 || end < 0)) {\n return new LazyWrapper(result);\n }\n if (start < 0) {\n result = result.takeRight(-start);\n } else if (start) {\n result = result.drop(start);\n }\n if (end !== undefined) {\n end = toInteger(end);\n result = end < 0 ? result.dropRight(-end) : result.take(end - start);\n }\n return result;\n };\n\n LazyWrapper.prototype.takeRightWhile = function(predicate) {\n return this.reverse().takeWhile(predicate).reverse();\n };\n\n LazyWrapper.prototype.toArray = function() {\n return this.take(MAX_ARRAY_LENGTH);\n };\n\n // Add `LazyWrapper` methods to `lodash.prototype`.\n baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName),\n isTaker = /^(?:head|last)$/.test(methodName),\n lodashFunc = lodash[isTaker ? ('take' + (methodName == 'last' ? 'Right' : '')) : methodName],\n retUnwrapped = isTaker || /^find/.test(methodName);\n\n if (!lodashFunc) {\n return;\n }\n lodash.prototype[methodName] = function() {\n var value = this.__wrapped__,\n args = isTaker ? [1] : arguments,\n isLazy = value instanceof LazyWrapper,\n iteratee = args[0],\n useLazy = isLazy || isArray(value);\n\n var interceptor = function(value) {\n var result = lodashFunc.apply(lodash, arrayPush([value], args));\n return (isTaker && chainAll) ? result[0] : result;\n };\n\n if (useLazy && checkIteratee && typeof iteratee == 'function' && iteratee.length != 1) {\n // Avoid lazy use if the iteratee has a \"length\" value other than `1`.\n isLazy = useLazy = false;\n }\n var chainAll = this.__chain__,\n isHybrid = !!this.__actions__.length,\n isUnwrapped = retUnwrapped && !chainAll,\n onlyLazy = isLazy && !isHybrid;\n\n if (!retUnwrapped && useLazy) {\n value = onlyLazy ? value : new LazyWrapper(this);\n var result = func.apply(value, args);\n result.__actions__.push({ 'func': thru, 'args': [interceptor], 'thisArg': undefined });\n return new LodashWrapper(result, chainAll);\n }\n if (isUnwrapped && onlyLazy) {\n return func.apply(this, args);\n }\n result = this.thru(interceptor);\n return isUnwrapped ? (isTaker ? result.value()[0] : result.value()) : result;\n };\n });\n\n // Add `Array` methods to `lodash.prototype`.\n arrayEach(['pop', 'push', 'shift', 'sort', 'splice', 'unshift'], function(methodName) {\n var func = arrayProto[methodName],\n chainName = /^(?:push|sort|unshift)$/.test(methodName) ? 'tap' : 'thru',\n retUnwrapped = /^(?:pop|shift)$/.test(methodName);\n\n lodash.prototype[methodName] = function() {\n var args = arguments;\n if (retUnwrapped && !this.__chain__) {\n var value = this.value();\n return func.apply(isArray(value) ? value : [], args);\n }\n return this[chainName](function(value) {\n return func.apply(isArray(value) ? value : [], args);\n });\n };\n });\n\n // Map minified method names to their real names.\n baseForOwn(LazyWrapper.prototype, function(func, methodName) {\n var lodashFunc = lodash[methodName];\n if (lodashFunc) {\n var key = lodashFunc.name + '';\n if (!hasOwnProperty.call(realNames, key)) {\n realNames[key] = [];\n }\n realNames[key].push({ 'name': methodName, 'func': lodashFunc });\n }\n });\n\n realNames[createHybrid(undefined, WRAP_BIND_KEY_FLAG).name] = [{\n 'name': 'wrapper',\n 'func': undefined\n }];\n\n // Add methods to `LazyWrapper`.\n LazyWrapper.prototype.clone = lazyClone;\n LazyWrapper.prototype.reverse = lazyReverse;\n LazyWrapper.prototype.value = lazyValue;\n\n // Add chain sequence methods to the `lodash` wrapper.\n lodash.prototype.at = wrapperAt;\n lodash.prototype.chain = wrapperChain;\n lodash.prototype.commit = wrapperCommit;\n lodash.prototype.next = wrapperNext;\n lodash.prototype.plant = wrapperPlant;\n lodash.prototype.reverse = wrapperReverse;\n lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;\n\n // Add lazy aliases.\n lodash.prototype.first = lodash.prototype.head;\n\n if (symIterator) {\n lodash.prototype[symIterator] = wrapperToIterator;\n }\n return lodash;\n });\n\n /*--------------------------------------------------------------------------*/\n\n // Export lodash.\n var _ = runInContext();\n\n // Some AMD build optimizers, like r.js, check for condition patterns like:\n if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {\n // Expose Lodash on the global object to prevent errors when Lodash is\n // loaded by a script tag in the presence of an AMD loader.\n // See http://requirejs.org/docs/errors.html#mismatch for more details.\n // Use `_.noConflict` to remove Lodash from the global object.\n root._ = _;\n\n // Define as an anonymous module so, through path mapping, it can be\n // referenced as the \"underscore\" module.\n define(function() {\n return _;\n });\n }\n // Check for `exports` after `define` in case a build optimizer adds it.\n else if (freeModule) {\n // Export for Node.js.\n (freeModule.exports = _)._ = _;\n // Export for CommonJS support.\n freeExports._ = _;\n }\n else {\n // Export to the global object.\n root._ = _;\n }\n}.call(this));\n","var arrayMap = require('./_arrayMap'),\n baseIteratee = require('./_baseIteratee'),\n baseMap = require('./_baseMap'),\n isArray = require('./isArray');\n\n/**\n * Creates an array of values by running each element in `collection` thru\n * `iteratee`. The iteratee is invoked with three arguments:\n * (value, index|key, collection).\n *\n * Many lodash methods are guarded to work as iteratees for methods like\n * `_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.\n *\n * The guarded methods are:\n * `ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,\n * `fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,\n * `sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,\n * `template`, `trim`, `trimEnd`, `trimStart`, and `words`\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Collection\n * @param {Array|Object} collection The collection to iterate over.\n * @param {Function} [iteratee=_.identity] The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n * @example\n *\n * function square(n) {\n * return n * n;\n * }\n *\n * _.map([4, 8], square);\n * // => [16, 64]\n *\n * _.map({ 'a': 4, 'b': 8 }, square);\n * // => [16, 64] (iteration order is not guaranteed)\n *\n * var users = [\n * { 'user': 'barney' },\n * { 'user': 'fred' }\n * ];\n *\n * // The `_.property` iteratee shorthand.\n * _.map(users, 'user');\n * // => ['barney', 'fred']\n */\nfunction map(collection, iteratee) {\n var func = isArray(collection) ? arrayMap : baseMap;\n return func(collection, baseIteratee(iteratee, 3));\n}\n\nmodule.exports = map;\n","var MapCache = require('./_MapCache');\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\nfunction memoize(func, resolver) {\n if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n var memoized = function() {\n var args = arguments,\n key = resolver ? resolver.apply(this, args) : args[0],\n cache = memoized.cache;\n\n if (cache.has(key)) {\n return cache.get(key);\n }\n var result = func.apply(this, args);\n memoized.cache = cache.set(key, result) || cache;\n return result;\n };\n memoized.cache = new (memoize.Cache || MapCache);\n return memoized;\n}\n\n// Expose `MapCache`.\nmemoize.Cache = MapCache;\n\nmodule.exports = memoize;\n","/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that negates the result of the predicate `func`. The\n * `func` predicate is invoked with the `this` binding and arguments of the\n * created function.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Function\n * @param {Function} predicate The predicate to negate.\n * @returns {Function} Returns the new negated function.\n * @example\n *\n * function isEven(n) {\n * return n % 2 == 0;\n * }\n *\n * _.filter([1, 2, 3, 4, 5, 6], _.negate(isEven));\n * // => [1, 3, 5]\n */\nfunction negate(predicate) {\n if (typeof predicate != 'function') {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n return function() {\n var args = arguments;\n switch (args.length) {\n case 0: return !predicate.call(this);\n case 1: return !predicate.call(this, args[0]);\n case 2: return !predicate.call(this, args[0], args[1]);\n case 3: return !predicate.call(this, args[0], args[1], args[2]);\n }\n return !predicate.apply(this, args);\n };\n}\n\nmodule.exports = negate;\n","var baseIteratee = require('./_baseIteratee'),\n negate = require('./negate'),\n pickBy = require('./pickBy');\n\n/**\n * The opposite of `_.pickBy`; this method creates an object composed of\n * the own and inherited enumerable string keyed properties of `object` that\n * `predicate` doesn't return truthy for. The predicate is invoked with two\n * arguments: (value, key).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The source object.\n * @param {Function} [predicate=_.identity] The function invoked per property.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.omitBy(object, _.isNumber);\n * // => { 'b': '2' }\n */\nfunction omitBy(object, predicate) {\n return pickBy(object, negate(baseIteratee(predicate)));\n}\n\nmodule.exports = omitBy;\n","var arrayMap = require('./_arrayMap'),\n baseIteratee = require('./_baseIteratee'),\n basePickBy = require('./_basePickBy'),\n getAllKeysIn = require('./_getAllKeysIn');\n\n/**\n * Creates an object composed of the `object` properties `predicate` returns\n * truthy for. The predicate is invoked with two arguments: (value, key).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The source object.\n * @param {Function} [predicate=_.identity] The function invoked per property.\n * @returns {Object} Returns the new object.\n * @example\n *\n * var object = { 'a': 1, 'b': '2', 'c': 3 };\n *\n * _.pickBy(object, _.isNumber);\n * // => { 'a': 1, 'c': 3 }\n */\nfunction pickBy(object, predicate) {\n if (object == null) {\n return {};\n }\n var props = arrayMap(getAllKeysIn(object), function(prop) {\n return [prop];\n });\n predicate = baseIteratee(predicate);\n return basePickBy(object, props, function(value, path) {\n return predicate(value, path[0]);\n });\n}\n\nmodule.exports = pickBy;\n","var baseProperty = require('./_baseProperty'),\n basePropertyDeep = require('./_basePropertyDeep'),\n isKey = require('./_isKey'),\n toKey = require('./_toKey');\n\n/**\n * Creates a function that returns the value at `path` of a given object.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {Array|string} path The path of the property to get.\n * @returns {Function} Returns the new accessor function.\n * @example\n *\n * var objects = [\n * { 'a': { 'b': 2 } },\n * { 'a': { 'b': 1 } }\n * ];\n *\n * _.map(objects, _.property('a.b'));\n * // => [2, 1]\n *\n * _.map(_.sortBy(objects, _.property(['a', 'b'])), 'a.b');\n * // => [1, 2]\n */\nfunction property(path) {\n return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);\n}\n\nmodule.exports = property;\n","/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n return [];\n}\n\nmodule.exports = stubArray;\n","/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n return false;\n}\n\nmodule.exports = stubFalse;\n","var baseToString = require('./_baseToString');\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n return value == null ? '' : baseToString(value);\n}\n\nmodule.exports = toString;\n","'use strict'\nvar inherits = require('inherits')\nvar HashBase = require('hash-base')\nvar Buffer = require('safe-buffer').Buffer\n\nvar ARRAY16 = new Array(16)\n\nfunction MD5 () {\n HashBase.call(this, 64)\n\n // state\n this._a = 0x67452301\n this._b = 0xefcdab89\n this._c = 0x98badcfe\n this._d = 0x10325476\n}\n\ninherits(MD5, HashBase)\n\nMD5.prototype._update = function () {\n var M = ARRAY16\n for (var i = 0; i < 16; ++i) M[i] = this._block.readInt32LE(i * 4)\n\n var a = this._a\n var b = this._b\n var c = this._c\n var d = this._d\n\n a = fnF(a, b, c, d, M[0], 0xd76aa478, 7)\n d = fnF(d, a, b, c, M[1], 0xe8c7b756, 12)\n c = fnF(c, d, a, b, M[2], 0x242070db, 17)\n b = fnF(b, c, d, a, M[3], 0xc1bdceee, 22)\n a = fnF(a, b, c, d, M[4], 0xf57c0faf, 7)\n d = fnF(d, a, b, c, M[5], 0x4787c62a, 12)\n c = fnF(c, d, a, b, M[6], 0xa8304613, 17)\n b = fnF(b, c, d, a, M[7], 0xfd469501, 22)\n a = fnF(a, b, c, d, M[8], 0x698098d8, 7)\n d = fnF(d, a, b, c, M[9], 0x8b44f7af, 12)\n c = fnF(c, d, a, b, M[10], 0xffff5bb1, 17)\n b = fnF(b, c, d, a, M[11], 0x895cd7be, 22)\n a = fnF(a, b, c, d, M[12], 0x6b901122, 7)\n d = fnF(d, a, b, c, M[13], 0xfd987193, 12)\n c = fnF(c, d, a, b, M[14], 0xa679438e, 17)\n b = fnF(b, c, d, a, M[15], 0x49b40821, 22)\n\n a = fnG(a, b, c, d, M[1], 0xf61e2562, 5)\n d = fnG(d, a, b, c, M[6], 0xc040b340, 9)\n c = fnG(c, d, a, b, M[11], 0x265e5a51, 14)\n b = fnG(b, c, d, a, M[0], 0xe9b6c7aa, 20)\n a = fnG(a, b, c, d, M[5], 0xd62f105d, 5)\n d = fnG(d, a, b, c, M[10], 0x02441453, 9)\n c = fnG(c, d, a, b, M[15], 0xd8a1e681, 14)\n b = fnG(b, c, d, a, M[4], 0xe7d3fbc8, 20)\n a = fnG(a, b, c, d, M[9], 0x21e1cde6, 5)\n d = fnG(d, a, b, c, M[14], 0xc33707d6, 9)\n c = fnG(c, d, a, b, M[3], 0xf4d50d87, 14)\n b = fnG(b, c, d, a, M[8], 0x455a14ed, 20)\n a = fnG(a, b, c, d, M[13], 0xa9e3e905, 5)\n d = fnG(d, a, b, c, M[2], 0xfcefa3f8, 9)\n c = fnG(c, d, a, b, M[7], 0x676f02d9, 14)\n b = fnG(b, c, d, a, M[12], 0x8d2a4c8a, 20)\n\n a = fnH(a, b, c, d, M[5], 0xfffa3942, 4)\n d = fnH(d, a, b, c, M[8], 0x8771f681, 11)\n c = fnH(c, d, a, b, M[11], 0x6d9d6122, 16)\n b = fnH(b, c, d, a, M[14], 0xfde5380c, 23)\n a = fnH(a, b, c, d, M[1], 0xa4beea44, 4)\n d = fnH(d, a, b, c, M[4], 0x4bdecfa9, 11)\n c = fnH(c, d, a, b, M[7], 0xf6bb4b60, 16)\n b = fnH(b, c, d, a, M[10], 0xbebfbc70, 23)\n a = fnH(a, b, c, d, M[13], 0x289b7ec6, 4)\n d = fnH(d, a, b, c, M[0], 0xeaa127fa, 11)\n c = fnH(c, d, a, b, M[3], 0xd4ef3085, 16)\n b = fnH(b, c, d, a, M[6], 0x04881d05, 23)\n a = fnH(a, b, c, d, M[9], 0xd9d4d039, 4)\n d = fnH(d, a, b, c, M[12], 0xe6db99e5, 11)\n c = fnH(c, d, a, b, M[15], 0x1fa27cf8, 16)\n b = fnH(b, c, d, a, M[2], 0xc4ac5665, 23)\n\n a = fnI(a, b, c, d, M[0], 0xf4292244, 6)\n d = fnI(d, a, b, c, M[7], 0x432aff97, 10)\n c = fnI(c, d, a, b, M[14], 0xab9423a7, 15)\n b = fnI(b, c, d, a, M[5], 0xfc93a039, 21)\n a = fnI(a, b, c, d, M[12], 0x655b59c3, 6)\n d = fnI(d, a, b, c, M[3], 0x8f0ccc92, 10)\n c = fnI(c, d, a, b, M[10], 0xffeff47d, 15)\n b = fnI(b, c, d, a, M[1], 0x85845dd1, 21)\n a = fnI(a, b, c, d, M[8], 0x6fa87e4f, 6)\n d = fnI(d, a, b, c, M[15], 0xfe2ce6e0, 10)\n c = fnI(c, d, a, b, M[6], 0xa3014314, 15)\n b = fnI(b, c, d, a, M[13], 0x4e0811a1, 21)\n a = fnI(a, b, c, d, M[4], 0xf7537e82, 6)\n d = fnI(d, a, b, c, M[11], 0xbd3af235, 10)\n c = fnI(c, d, a, b, M[2], 0x2ad7d2bb, 15)\n b = fnI(b, c, d, a, M[9], 0xeb86d391, 21)\n\n this._a = (this._a + a) | 0\n this._b = (this._b + b) | 0\n this._c = (this._c + c) | 0\n this._d = (this._d + d) | 0\n}\n\nMD5.prototype._digest = function () {\n // create padding and handle blocks\n this._block[this._blockOffset++] = 0x80\n if (this._blockOffset > 56) {\n this._block.fill(0, this._blockOffset, 64)\n this._update()\n this._blockOffset = 0\n }\n\n this._block.fill(0, this._blockOffset, 56)\n this._block.writeUInt32LE(this._length[0], 56)\n this._block.writeUInt32LE(this._length[1], 60)\n this._update()\n\n // produce result\n var buffer = Buffer.allocUnsafe(16)\n buffer.writeInt32LE(this._a, 0)\n buffer.writeInt32LE(this._b, 4)\n buffer.writeInt32LE(this._c, 8)\n buffer.writeInt32LE(this._d, 12)\n return buffer\n}\n\nfunction rotl (x, n) {\n return (x << n) | (x >>> (32 - n))\n}\n\nfunction fnF (a, b, c, d, m, k, s) {\n return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnG (a, b, c, d, m, k, s) {\n return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnH (a, b, c, d, m, k, s) {\n return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + b) | 0\n}\n\nfunction fnI (a, b, c, d, m, k, s) {\n return (rotl((a + ((c ^ (b | (~d)))) + m + k) | 0, s) + b) | 0\n}\n\nmodule.exports = MD5\n","var bn = require('bn.js');\nvar brorand = require('brorand');\n\nfunction MillerRabin(rand) {\n this.rand = rand || new brorand.Rand();\n}\nmodule.exports = MillerRabin;\n\nMillerRabin.create = function create(rand) {\n return new MillerRabin(rand);\n};\n\nMillerRabin.prototype._randbelow = function _randbelow(n) {\n var len = n.bitLength();\n var min_bytes = Math.ceil(len / 8);\n\n // Generage random bytes until a number less than n is found.\n // This ensures that 0..n-1 have an equal probability of being selected.\n do\n var a = new bn(this.rand.generate(min_bytes));\n while (a.cmp(n) >= 0);\n\n return a;\n};\n\nMillerRabin.prototype._randrange = function _randrange(start, stop) {\n // Generate a random number greater than or equal to start and less than stop.\n var size = stop.sub(start);\n return start.add(this._randbelow(size));\n};\n\nMillerRabin.prototype.test = function test(n, k, cb) {\n var len = n.bitLength();\n var red = bn.mont(n);\n var rone = new bn(1).toRed(red);\n\n if (!k)\n k = Math.max(1, (len / 48) | 0);\n\n // Find d and s, (n - 1) = (2 ^ s) * d;\n var n1 = n.subn(1);\n for (var s = 0; !n1.testn(s); s++) {}\n var d = n.shrn(s);\n\n var rn1 = n1.toRed(red);\n\n var prime = true;\n for (; k > 0; k--) {\n var a = this._randrange(new bn(2), n1);\n if (cb)\n cb(a);\n\n var x = a.toRed(red).redPow(d);\n if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)\n continue;\n\n for (var i = 1; i < s; i++) {\n x = x.redSqr();\n\n if (x.cmp(rone) === 0)\n return false;\n if (x.cmp(rn1) === 0)\n break;\n }\n\n if (i === s)\n return false;\n }\n\n return prime;\n};\n\nMillerRabin.prototype.getDivisor = function getDivisor(n, k) {\n var len = n.bitLength();\n var red = bn.mont(n);\n var rone = new bn(1).toRed(red);\n\n if (!k)\n k = Math.max(1, (len / 48) | 0);\n\n // Find d and s, (n - 1) = (2 ^ s) * d;\n var n1 = n.subn(1);\n for (var s = 0; !n1.testn(s); s++) {}\n var d = n.shrn(s);\n\n var rn1 = n1.toRed(red);\n\n for (; k > 0; k--) {\n var a = this._randrange(new bn(2), n1);\n\n var g = n.gcd(a);\n if (g.cmpn(1) !== 0)\n return g;\n\n var x = a.toRed(red).redPow(d);\n if (x.cmp(rone) === 0 || x.cmp(rn1) === 0)\n continue;\n\n for (var i = 1; i < s; i++) {\n x = x.redSqr();\n\n if (x.cmp(rone) === 0)\n return x.fromRed().subn(1).gcd(n);\n if (x.cmp(rn1) === 0)\n break;\n }\n\n if (i === s) {\n x = x.redSqr();\n return x.fromRed().subn(1).gcd(n);\n }\n }\n\n return false;\n};\n","module.exports = assert;\n\nfunction assert(val, msg) {\n if (!val)\n throw new Error(msg || 'Assertion failed');\n}\n\nassert.equal = function assertEqual(l, r, msg) {\n if (l != r)\n throw new Error(msg || ('Assertion failed: ' + l + ' != ' + r));\n};\n","'use strict';\n\nvar utils = exports;\n\nfunction toArray(msg, enc) {\n if (Array.isArray(msg))\n return msg.slice();\n if (!msg)\n return [];\n var res = [];\n if (typeof msg !== 'string') {\n for (var i = 0; i < msg.length; i++)\n res[i] = msg[i] | 0;\n return res;\n }\n if (enc === 'hex') {\n msg = msg.replace(/[^a-z0-9]+/ig, '');\n if (msg.length % 2 !== 0)\n msg = '0' + msg;\n for (var i = 0; i < msg.length; i += 2)\n res.push(parseInt(msg[i] + msg[i + 1], 16));\n } else {\n for (var i = 0; i < msg.length; i++) {\n var c = msg.charCodeAt(i);\n var hi = c >> 8;\n var lo = c & 0xff;\n if (hi)\n res.push(hi, lo);\n else\n res.push(lo);\n }\n }\n return res;\n}\nutils.toArray = toArray;\n\nfunction zero2(word) {\n if (word.length === 1)\n return '0' + word;\n else\n return word;\n}\nutils.zero2 = zero2;\n\nfunction toHex(msg) {\n var res = '';\n for (var i = 0; i < msg.length; i++)\n res += zero2(msg[i].toString(16));\n return res;\n}\nutils.toHex = toHex;\n\nutils.encode = function encode(arr, enc) {\n if (enc === 'hex')\n return toHex(arr);\n else\n return arr;\n};\n","'use strict';\n\nvar numberIsNaN = function (value) {\n\treturn value !== value;\n};\n\nmodule.exports = function is(a, b) {\n\tif (a === 0 && b === 0) {\n\t\treturn 1 / a === 1 / b;\n\t}\n\tif (a === b) {\n\t\treturn true;\n\t}\n\tif (numberIsNaN(a) && numberIsNaN(b)) {\n\t\treturn true;\n\t}\n\treturn false;\n};\n\n","'use strict';\n\nvar define = require('define-properties');\nvar callBind = require('call-bind');\n\nvar implementation = require('./implementation');\nvar getPolyfill = require('./polyfill');\nvar shim = require('./shim');\n\nvar polyfill = callBind(getPolyfill(), Object);\n\ndefine(polyfill, {\n\tgetPolyfill: getPolyfill,\n\timplementation: implementation,\n\tshim: shim\n});\n\nmodule.exports = polyfill;\n","'use strict';\n\nvar implementation = require('./implementation');\n\nmodule.exports = function getPolyfill() {\n\treturn typeof Object.is === 'function' ? Object.is : implementation;\n};\n","'use strict';\n\nvar getPolyfill = require('./polyfill');\nvar define = require('define-properties');\n\nmodule.exports = function shimObjectIs() {\n\tvar polyfill = getPolyfill();\n\tdefine(Object, { is: polyfill }, {\n\t\tis: function testObjectIs() {\n\t\t\treturn Object.is !== polyfill;\n\t\t}\n\t});\n\treturn polyfill;\n};\n","'use strict';\n\nvar keysShim;\nif (!Object.keys) {\n\t// modified from https://github.com/es-shims/es5-shim\n\tvar has = Object.prototype.hasOwnProperty;\n\tvar toStr = Object.prototype.toString;\n\tvar isArgs = require('./isArguments'); // eslint-disable-line global-require\n\tvar isEnumerable = Object.prototype.propertyIsEnumerable;\n\tvar hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');\n\tvar hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');\n\tvar dontEnums = [\n\t\t'toString',\n\t\t'toLocaleString',\n\t\t'valueOf',\n\t\t'hasOwnProperty',\n\t\t'isPrototypeOf',\n\t\t'propertyIsEnumerable',\n\t\t'constructor'\n\t];\n\tvar equalsConstructorPrototype = function (o) {\n\t\tvar ctor = o.constructor;\n\t\treturn ctor && ctor.prototype === o;\n\t};\n\tvar excludedKeys = {\n\t\t$applicationCache: true,\n\t\t$console: true,\n\t\t$external: true,\n\t\t$frame: true,\n\t\t$frameElement: true,\n\t\t$frames: true,\n\t\t$innerHeight: true,\n\t\t$innerWidth: true,\n\t\t$onmozfullscreenchange: true,\n\t\t$onmozfullscreenerror: true,\n\t\t$outerHeight: true,\n\t\t$outerWidth: true,\n\t\t$pageXOffset: true,\n\t\t$pageYOffset: true,\n\t\t$parent: true,\n\t\t$scrollLeft: true,\n\t\t$scrollTop: true,\n\t\t$scrollX: true,\n\t\t$scrollY: true,\n\t\t$self: true,\n\t\t$webkitIndexedDB: true,\n\t\t$webkitStorageInfo: true,\n\t\t$window: true\n\t};\n\tvar hasAutomationEqualityBug = (function () {\n\t\t/* global window */\n\t\tif (typeof window === 'undefined') { return false; }\n\t\tfor (var k in window) {\n\t\t\ttry {\n\t\t\t\tif (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tequalsConstructorPrototype(window[k]);\n\t\t\t\t\t} catch (e) {\n\t\t\t\t\t\treturn true;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} catch (e) {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}());\n\tvar equalsConstructorPrototypeIfNotBuggy = function (o) {\n\t\t/* global window */\n\t\tif (typeof window === 'undefined' || !hasAutomationEqualityBug) {\n\t\t\treturn equalsConstructorPrototype(o);\n\t\t}\n\t\ttry {\n\t\t\treturn equalsConstructorPrototype(o);\n\t\t} catch (e) {\n\t\t\treturn false;\n\t\t}\n\t};\n\n\tkeysShim = function keys(object) {\n\t\tvar isObject = object !== null && typeof object === 'object';\n\t\tvar isFunction = toStr.call(object) === '[object Function]';\n\t\tvar isArguments = isArgs(object);\n\t\tvar isString = isObject && toStr.call(object) === '[object String]';\n\t\tvar theKeys = [];\n\n\t\tif (!isObject && !isFunction && !isArguments) {\n\t\t\tthrow new TypeError('Object.keys called on a non-object');\n\t\t}\n\n\t\tvar skipProto = hasProtoEnumBug && isFunction;\n\t\tif (isString && object.length > 0 && !has.call(object, 0)) {\n\t\t\tfor (var i = 0; i < object.length; ++i) {\n\t\t\t\ttheKeys.push(String(i));\n\t\t\t}\n\t\t}\n\n\t\tif (isArguments && object.length > 0) {\n\t\t\tfor (var j = 0; j < object.length; ++j) {\n\t\t\t\ttheKeys.push(String(j));\n\t\t\t}\n\t\t} else {\n\t\t\tfor (var name in object) {\n\t\t\t\tif (!(skipProto && name === 'prototype') && has.call(object, name)) {\n\t\t\t\t\ttheKeys.push(String(name));\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (hasDontEnumBug) {\n\t\t\tvar skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);\n\n\t\t\tfor (var k = 0; k < dontEnums.length; ++k) {\n\t\t\t\tif (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {\n\t\t\t\t\ttheKeys.push(dontEnums[k]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn theKeys;\n\t};\n}\nmodule.exports = keysShim;\n","'use strict';\n\nvar slice = Array.prototype.slice;\nvar isArgs = require('./isArguments');\n\nvar origKeys = Object.keys;\nvar keysShim = origKeys ? function keys(o) { return origKeys(o); } : require('./implementation');\n\nvar originalKeys = Object.keys;\n\nkeysShim.shim = function shimObjectKeys() {\n\tif (Object.keys) {\n\t\tvar keysWorksWithArguments = (function () {\n\t\t\t// Safari 5.0 bug\n\t\t\tvar args = Object.keys(arguments);\n\t\t\treturn args && args.length === arguments.length;\n\t\t}(1, 2));\n\t\tif (!keysWorksWithArguments) {\n\t\t\tObject.keys = function keys(object) { // eslint-disable-line func-name-matching\n\t\t\t\tif (isArgs(object)) {\n\t\t\t\t\treturn originalKeys(slice.call(object));\n\t\t\t\t}\n\t\t\t\treturn originalKeys(object);\n\t\t\t};\n\t\t}\n\t} else {\n\t\tObject.keys = keysShim;\n\t}\n\treturn Object.keys || keysShim;\n};\n\nmodule.exports = keysShim;\n","'use strict';\n\nvar toStr = Object.prototype.toString;\n\nmodule.exports = function isArguments(value) {\n\tvar str = toStr.call(value);\n\tvar isArgs = str === '[object Arguments]';\n\tif (!isArgs) {\n\t\tisArgs = str !== '[object Array]' &&\n\t\t\tvalue !== null &&\n\t\t\ttypeof value === 'object' &&\n\t\t\ttypeof value.length === 'number' &&\n\t\t\tvalue.length >= 0 &&\n\t\t\ttoStr.call(value.callee) === '[object Function]';\n\t}\n\treturn isArgs;\n};\n","// from https://github.com/indutny/self-signed/blob/gh-pages/lib/asn1.js\n// Fedor, you are amazing.\n'use strict'\n\nvar asn1 = require('asn1.js')\n\nexports.certificate = require('./certificate')\n\nvar RSAPrivateKey = asn1.define('RSAPrivateKey', function () {\n this.seq().obj(\n this.key('version').int(),\n this.key('modulus').int(),\n this.key('publicExponent').int(),\n this.key('privateExponent').int(),\n this.key('prime1').int(),\n this.key('prime2').int(),\n this.key('exponent1').int(),\n this.key('exponent2').int(),\n this.key('coefficient').int()\n )\n})\nexports.RSAPrivateKey = RSAPrivateKey\n\nvar RSAPublicKey = asn1.define('RSAPublicKey', function () {\n this.seq().obj(\n this.key('modulus').int(),\n this.key('publicExponent').int()\n )\n})\nexports.RSAPublicKey = RSAPublicKey\n\nvar PublicKey = asn1.define('SubjectPublicKeyInfo', function () {\n this.seq().obj(\n this.key('algorithm').use(AlgorithmIdentifier),\n this.key('subjectPublicKey').bitstr()\n )\n})\nexports.PublicKey = PublicKey\n\nvar AlgorithmIdentifier = asn1.define('AlgorithmIdentifier', function () {\n this.seq().obj(\n this.key('algorithm').objid(),\n this.key('none').null_().optional(),\n this.key('curve').objid().optional(),\n this.key('params').seq().obj(\n this.key('p').int(),\n this.key('q').int(),\n this.key('g').int()\n ).optional()\n )\n})\n\nvar PrivateKeyInfo = asn1.define('PrivateKeyInfo', function () {\n this.seq().obj(\n this.key('version').int(),\n this.key('algorithm').use(AlgorithmIdentifier),\n this.key('subjectPrivateKey').octstr()\n )\n})\nexports.PrivateKey = PrivateKeyInfo\nvar EncryptedPrivateKeyInfo = asn1.define('EncryptedPrivateKeyInfo', function () {\n this.seq().obj(\n this.key('algorithm').seq().obj(\n this.key('id').objid(),\n this.key('decrypt').seq().obj(\n this.key('kde').seq().obj(\n this.key('id').objid(),\n this.key('kdeparams').seq().obj(\n this.key('salt').octstr(),\n this.key('iters').int()\n )\n ),\n this.key('cipher').seq().obj(\n this.key('algo').objid(),\n this.key('iv').octstr()\n )\n )\n ),\n this.key('subjectPrivateKey').octstr()\n )\n})\n\nexports.EncryptedPrivateKey = EncryptedPrivateKeyInfo\n\nvar DSAPrivateKey = asn1.define('DSAPrivateKey', function () {\n this.seq().obj(\n this.key('version').int(),\n this.key('p').int(),\n this.key('q').int(),\n this.key('g').int(),\n this.key('pub_key').int(),\n this.key('priv_key').int()\n )\n})\nexports.DSAPrivateKey = DSAPrivateKey\n\nexports.DSAparam = asn1.define('DSAparam', function () {\n this.int()\n})\n\nvar ECPrivateKey = asn1.define('ECPrivateKey', function () {\n this.seq().obj(\n this.key('version').int(),\n this.key('privateKey').octstr(),\n this.key('parameters').optional().explicit(0).use(ECParameters),\n this.key('publicKey').optional().explicit(1).bitstr()\n )\n})\nexports.ECPrivateKey = ECPrivateKey\n\nvar ECParameters = asn1.define('ECParameters', function () {\n this.choice({\n namedCurve: this.objid()\n })\n})\n\nexports.signature = asn1.define('signature', function () {\n this.seq().obj(\n this.key('r').int(),\n this.key('s').int()\n )\n})\n","// from https://github.com/Rantanen/node-dtls/blob/25a7dc861bda38cfeac93a723500eea4f0ac2e86/Certificate.js\n// thanks to @Rantanen\n\n'use strict'\n\nvar asn = require('asn1.js')\n\nvar Time = asn.define('Time', function () {\n this.choice({\n utcTime: this.utctime(),\n generalTime: this.gentime()\n })\n})\n\nvar AttributeTypeValue = asn.define('AttributeTypeValue', function () {\n this.seq().obj(\n this.key('type').objid(),\n this.key('value').any()\n )\n})\n\nvar AlgorithmIdentifier = asn.define('AlgorithmIdentifier', function () {\n this.seq().obj(\n this.key('algorithm').objid(),\n this.key('parameters').optional(),\n this.key('curve').objid().optional()\n )\n})\n\nvar SubjectPublicKeyInfo = asn.define('SubjectPublicKeyInfo', function () {\n this.seq().obj(\n this.key('algorithm').use(AlgorithmIdentifier),\n this.key('subjectPublicKey').bitstr()\n )\n})\n\nvar RelativeDistinguishedName = asn.define('RelativeDistinguishedName', function () {\n this.setof(AttributeTypeValue)\n})\n\nvar RDNSequence = asn.define('RDNSequence', function () {\n this.seqof(RelativeDistinguishedName)\n})\n\nvar Name = asn.define('Name', function () {\n this.choice({\n rdnSequence: this.use(RDNSequence)\n })\n})\n\nvar Validity = asn.define('Validity', function () {\n this.seq().obj(\n this.key('notBefore').use(Time),\n this.key('notAfter').use(Time)\n )\n})\n\nvar Extension = asn.define('Extension', function () {\n this.seq().obj(\n this.key('extnID').objid(),\n this.key('critical').bool().def(false),\n this.key('extnValue').octstr()\n )\n})\n\nvar TBSCertificate = asn.define('TBSCertificate', function () {\n this.seq().obj(\n this.key('version').explicit(0).int().optional(),\n this.key('serialNumber').int(),\n this.key('signature').use(AlgorithmIdentifier),\n this.key('issuer').use(Name),\n this.key('validity').use(Validity),\n this.key('subject').use(Name),\n this.key('subjectPublicKeyInfo').use(SubjectPublicKeyInfo),\n this.key('issuerUniqueID').implicit(1).bitstr().optional(),\n this.key('subjectUniqueID').implicit(2).bitstr().optional(),\n this.key('extensions').explicit(3).seqof(Extension).optional()\n )\n})\n\nvar X509Certificate = asn.define('X509Certificate', function () {\n this.seq().obj(\n this.key('tbsCertificate').use(TBSCertificate),\n this.key('signatureAlgorithm').use(AlgorithmIdentifier),\n this.key('signatureValue').bitstr()\n )\n})\n\nmodule.exports = X509Certificate\n","// adapted from https://github.com/apatil/pemstrip\nvar findProc = /Proc-Type: 4,ENCRYPTED[\\n\\r]+DEK-Info: AES-((?:128)|(?:192)|(?:256))-CBC,([0-9A-H]+)[\\n\\r]+([0-9A-z\\n\\r+/=]+)[\\n\\r]+/m\nvar startRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----/m\nvar fullRegex = /^-----BEGIN ((?:.*? KEY)|CERTIFICATE)-----([0-9A-z\\n\\r+/=]+)-----END \\1-----$/m\nvar evp = require('evp_bytestokey')\nvar ciphers = require('browserify-aes')\nvar Buffer = require('safe-buffer').Buffer\nmodule.exports = function (okey, password) {\n var key = okey.toString()\n var match = key.match(findProc)\n var decrypted\n if (!match) {\n var match2 = key.match(fullRegex)\n decrypted = Buffer.from(match2[2].replace(/[\\r\\n]/g, ''), 'base64')\n } else {\n var suite = 'aes' + match[1]\n var iv = Buffer.from(match[2], 'hex')\n var cipherText = Buffer.from(match[3].replace(/[\\r\\n]/g, ''), 'base64')\n var cipherKey = evp(password, iv.slice(0, 8), parseInt(match[1], 10)).key\n var out = []\n var cipher = ciphers.createDecipheriv(suite, cipherKey, iv)\n out.push(cipher.update(cipherText))\n out.push(cipher.final())\n decrypted = Buffer.concat(out)\n }\n var tag = key.match(startRegex)[1]\n return {\n tag: tag,\n data: decrypted\n }\n}\n","var asn1 = require('./asn1')\nvar aesid = require('./aesid.json')\nvar fixProc = require('./fixProc')\nvar ciphers = require('browserify-aes')\nvar compat = require('pbkdf2')\nvar Buffer = require('safe-buffer').Buffer\nmodule.exports = parseKeys\n\nfunction parseKeys (buffer) {\n var password\n if (typeof buffer === 'object' && !Buffer.isBuffer(buffer)) {\n password = buffer.passphrase\n buffer = buffer.key\n }\n if (typeof buffer === 'string') {\n buffer = Buffer.from(buffer)\n }\n\n var stripped = fixProc(buffer, password)\n\n var type = stripped.tag\n var data = stripped.data\n var subtype, ndata\n switch (type) {\n case 'CERTIFICATE':\n ndata = asn1.certificate.decode(data, 'der').tbsCertificate.subjectPublicKeyInfo\n // falls through\n case 'PUBLIC KEY':\n if (!ndata) {\n ndata = asn1.PublicKey.decode(data, 'der')\n }\n subtype = ndata.algorithm.algorithm.join('.')\n switch (subtype) {\n case '1.2.840.113549.1.1.1':\n return asn1.RSAPublicKey.decode(ndata.subjectPublicKey.data, 'der')\n case '1.2.840.10045.2.1':\n ndata.subjectPrivateKey = ndata.subjectPublicKey\n return {\n type: 'ec',\n data: ndata\n }\n case '1.2.840.10040.4.1':\n ndata.algorithm.params.pub_key = asn1.DSAparam.decode(ndata.subjectPublicKey.data, 'der')\n return {\n type: 'dsa',\n data: ndata.algorithm.params\n }\n default: throw new Error('unknown key id ' + subtype)\n }\n // throw new Error('unknown key type ' + type)\n case 'ENCRYPTED PRIVATE KEY':\n data = asn1.EncryptedPrivateKey.decode(data, 'der')\n data = decrypt(data, password)\n // falls through\n case 'PRIVATE KEY':\n ndata = asn1.PrivateKey.decode(data, 'der')\n subtype = ndata.algorithm.algorithm.join('.')\n switch (subtype) {\n case '1.2.840.113549.1.1.1':\n return asn1.RSAPrivateKey.decode(ndata.subjectPrivateKey, 'der')\n case '1.2.840.10045.2.1':\n return {\n curve: ndata.algorithm.curve,\n privateKey: asn1.ECPrivateKey.decode(ndata.subjectPrivateKey, 'der').privateKey\n }\n case '1.2.840.10040.4.1':\n ndata.algorithm.params.priv_key = asn1.DSAparam.decode(ndata.subjectPrivateKey, 'der')\n return {\n type: 'dsa',\n params: ndata.algorithm.params\n }\n default: throw new Error('unknown key id ' + subtype)\n }\n // throw new Error('unknown key type ' + type)\n case 'RSA PUBLIC KEY':\n return asn1.RSAPublicKey.decode(data, 'der')\n case 'RSA PRIVATE KEY':\n return asn1.RSAPrivateKey.decode(data, 'der')\n case 'DSA PRIVATE KEY':\n return {\n type: 'dsa',\n params: asn1.DSAPrivateKey.decode(data, 'der')\n }\n case 'EC PRIVATE KEY':\n data = asn1.ECPrivateKey.decode(data, 'der')\n return {\n curve: data.parameters.value,\n privateKey: data.privateKey\n }\n default: throw new Error('unknown key type ' + type)\n }\n}\nparseKeys.signature = asn1.signature\nfunction decrypt (data, password) {\n var salt = data.algorithm.decrypt.kde.kdeparams.salt\n var iters = parseInt(data.algorithm.decrypt.kde.kdeparams.iters.toString(), 10)\n var algo = aesid[data.algorithm.decrypt.cipher.algo.join('.')]\n var iv = data.algorithm.decrypt.cipher.iv\n var cipherText = data.subjectPrivateKey\n var keylen = parseInt(algo.split('-')[1], 10) / 8\n var key = compat.pbkdf2Sync(password, salt, iters, keylen, 'sha1')\n var cipher = ciphers.createDecipheriv(algo, key, iv)\n var out = []\n out.push(cipher.update(cipherText))\n out.push(cipher.final())\n return Buffer.concat(out)\n}\n","exports.pbkdf2 = require('./lib/async')\nexports.pbkdf2Sync = require('./lib/sync')\n","var Buffer = require('safe-buffer').Buffer\n\nvar checkParameters = require('./precondition')\nvar defaultEncoding = require('./default-encoding')\nvar sync = require('./sync')\nvar toBuffer = require('./to-buffer')\n\nvar ZERO_BUF\nvar subtle = global.crypto && global.crypto.subtle\nvar toBrowser = {\n sha: 'SHA-1',\n 'sha-1': 'SHA-1',\n sha1: 'SHA-1',\n sha256: 'SHA-256',\n 'sha-256': 'SHA-256',\n sha384: 'SHA-384',\n 'sha-384': 'SHA-384',\n 'sha-512': 'SHA-512',\n sha512: 'SHA-512'\n}\nvar checks = []\nfunction checkNative (algo) {\n if (global.process && !global.process.browser) {\n return Promise.resolve(false)\n }\n if (!subtle || !subtle.importKey || !subtle.deriveBits) {\n return Promise.resolve(false)\n }\n if (checks[algo] !== undefined) {\n return checks[algo]\n }\n ZERO_BUF = ZERO_BUF || Buffer.alloc(8)\n var prom = browserPbkdf2(ZERO_BUF, ZERO_BUF, 10, 128, algo)\n .then(function () {\n return true\n }).catch(function () {\n return false\n })\n checks[algo] = prom\n return prom\n}\nvar nextTick\nfunction getNextTick () {\n if (nextTick) {\n return nextTick\n }\n if (global.process && global.process.nextTick) {\n nextTick = global.process.nextTick\n } else if (global.queueMicrotask) {\n nextTick = global.queueMicrotask\n } else if (global.setImmediate) {\n nextTick = global.setImmediate\n } else {\n nextTick = global.setTimeout\n }\n return nextTick\n}\nfunction browserPbkdf2 (password, salt, iterations, length, algo) {\n return subtle.importKey(\n 'raw', password, { name: 'PBKDF2' }, false, ['deriveBits']\n ).then(function (key) {\n return subtle.deriveBits({\n name: 'PBKDF2',\n salt: salt,\n iterations: iterations,\n hash: {\n name: algo\n }\n }, key, length << 3)\n }).then(function (res) {\n return Buffer.from(res)\n })\n}\n\nfunction resolvePromise (promise, callback) {\n promise.then(function (out) {\n getNextTick()(function () {\n callback(null, out)\n })\n }, function (e) {\n getNextTick()(function () {\n callback(e)\n })\n })\n}\nmodule.exports = function (password, salt, iterations, keylen, digest, callback) {\n if (typeof digest === 'function') {\n callback = digest\n digest = undefined\n }\n\n digest = digest || 'sha1'\n var algo = toBrowser[digest.toLowerCase()]\n\n if (!algo || typeof global.Promise !== 'function') {\n getNextTick()(function () {\n var out\n try {\n out = sync(password, salt, iterations, keylen, digest)\n } catch (e) {\n return callback(e)\n }\n callback(null, out)\n })\n return\n }\n\n checkParameters(iterations, keylen)\n password = toBuffer(password, defaultEncoding, 'Password')\n salt = toBuffer(salt, defaultEncoding, 'Salt')\n if (typeof callback !== 'function') throw new Error('No callback provided to pbkdf2')\n\n resolvePromise(checkNative(algo).then(function (resp) {\n if (resp) return browserPbkdf2(password, salt, iterations, keylen, algo)\n\n return sync(password, salt, iterations, keylen, digest)\n }), callback)\n}\n","var defaultEncoding\n/* istanbul ignore next */\nif (global.process && global.process.browser) {\n defaultEncoding = 'utf-8'\n} else if (global.process && global.process.version) {\n var pVersionMajor = parseInt(process.version.split('.')[0].slice(1), 10)\n\n defaultEncoding = pVersionMajor >= 6 ? 'utf-8' : 'binary'\n} else {\n defaultEncoding = 'utf-8'\n}\nmodule.exports = defaultEncoding\n","var MAX_ALLOC = Math.pow(2, 30) - 1 // default in iojs\n\nmodule.exports = function (iterations, keylen) {\n if (typeof iterations !== 'number') {\n throw new TypeError('Iterations not a number')\n }\n\n if (iterations < 0) {\n throw new TypeError('Bad iterations')\n }\n\n if (typeof keylen !== 'number') {\n throw new TypeError('Key length not a number')\n }\n\n if (keylen < 0 || keylen > MAX_ALLOC || keylen !== keylen) { /* eslint no-self-compare: 0 */\n throw new TypeError('Bad key length')\n }\n}\n","var md5 = require('create-hash/md5')\nvar RIPEMD160 = require('ripemd160')\nvar sha = require('sha.js')\nvar Buffer = require('safe-buffer').Buffer\n\nvar checkParameters = require('./precondition')\nvar defaultEncoding = require('./default-encoding')\nvar toBuffer = require('./to-buffer')\n\nvar ZEROS = Buffer.alloc(128)\nvar sizes = {\n md5: 16,\n sha1: 20,\n sha224: 28,\n sha256: 32,\n sha384: 48,\n sha512: 64,\n rmd160: 20,\n ripemd160: 20\n}\n\nfunction Hmac (alg, key, saltLen) {\n var hash = getDigest(alg)\n var blocksize = (alg === 'sha512' || alg === 'sha384') ? 128 : 64\n\n if (key.length > blocksize) {\n key = hash(key)\n } else if (key.length < blocksize) {\n key = Buffer.concat([key, ZEROS], blocksize)\n }\n\n var ipad = Buffer.allocUnsafe(blocksize + sizes[alg])\n var opad = Buffer.allocUnsafe(blocksize + sizes[alg])\n for (var i = 0; i < blocksize; i++) {\n ipad[i] = key[i] ^ 0x36\n opad[i] = key[i] ^ 0x5C\n }\n\n var ipad1 = Buffer.allocUnsafe(blocksize + saltLen + 4)\n ipad.copy(ipad1, 0, 0, blocksize)\n this.ipad1 = ipad1\n this.ipad2 = ipad\n this.opad = opad\n this.alg = alg\n this.blocksize = blocksize\n this.hash = hash\n this.size = sizes[alg]\n}\n\nHmac.prototype.run = function (data, ipad) {\n data.copy(ipad, this.blocksize)\n var h = this.hash(ipad)\n h.copy(this.opad, this.blocksize)\n return this.hash(this.opad)\n}\n\nfunction getDigest (alg) {\n function shaFunc (data) {\n return sha(alg).update(data).digest()\n }\n function rmd160Func (data) {\n return new RIPEMD160().update(data).digest()\n }\n\n if (alg === 'rmd160' || alg === 'ripemd160') return rmd160Func\n if (alg === 'md5') return md5\n return shaFunc\n}\n\nfunction pbkdf2 (password, salt, iterations, keylen, digest) {\n checkParameters(iterations, keylen)\n password = toBuffer(password, defaultEncoding, 'Password')\n salt = toBuffer(salt, defaultEncoding, 'Salt')\n\n digest = digest || 'sha1'\n\n var hmac = new Hmac(digest, password, salt.length)\n\n var DK = Buffer.allocUnsafe(keylen)\n var block1 = Buffer.allocUnsafe(salt.length + 4)\n salt.copy(block1, 0, 0, salt.length)\n\n var destPos = 0\n var hLen = sizes[digest]\n var l = Math.ceil(keylen / hLen)\n\n for (var i = 1; i <= l; i++) {\n block1.writeUInt32BE(i, salt.length)\n\n var T = hmac.run(block1, hmac.ipad1)\n var U = T\n\n for (var j = 1; j < iterations; j++) {\n U = hmac.run(U, hmac.ipad2)\n for (var k = 0; k < hLen; k++) T[k] ^= U[k]\n }\n\n T.copy(DK, destPos)\n destPos += hLen\n }\n\n return DK\n}\n\nmodule.exports = pbkdf2\n","var Buffer = require('safe-buffer').Buffer\n\nmodule.exports = function (thing, encoding, name) {\n if (Buffer.isBuffer(thing)) {\n return thing\n } else if (typeof thing === 'string') {\n return Buffer.from(thing, encoding)\n } else if (ArrayBuffer.isView(thing)) {\n return Buffer.from(thing.buffer)\n } else {\n throw new TypeError(name + ' must be a string, a Buffer, a typed array or a DataView')\n }\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","exports.publicEncrypt = require('./publicEncrypt')\nexports.privateDecrypt = require('./privateDecrypt')\n\nexports.privateEncrypt = function privateEncrypt (key, buf) {\n return exports.publicEncrypt(key, buf, true)\n}\n\nexports.publicDecrypt = function publicDecrypt (key, buf) {\n return exports.privateDecrypt(key, buf, true)\n}\n","var createHash = require('create-hash')\nvar Buffer = require('safe-buffer').Buffer\n\nmodule.exports = function (seed, len) {\n var t = Buffer.alloc(0)\n var i = 0\n var c\n while (t.length < len) {\n c = i2ops(i++)\n t = Buffer.concat([t, createHash('sha1').update(seed).update(c).digest()])\n }\n return t.slice(0, len)\n}\n\nfunction i2ops (c) {\n var out = Buffer.allocUnsafe(4)\n out.writeUInt32BE(c, 0)\n return out\n}\n","var parseKeys = require('parse-asn1')\nvar mgf = require('./mgf')\nvar xor = require('./xor')\nvar BN = require('bn.js')\nvar crt = require('browserify-rsa')\nvar createHash = require('create-hash')\nvar withPublic = require('./withPublic')\nvar Buffer = require('safe-buffer').Buffer\n\nmodule.exports = function privateDecrypt (privateKey, enc, reverse) {\n var padding\n if (privateKey.padding) {\n padding = privateKey.padding\n } else if (reverse) {\n padding = 1\n } else {\n padding = 4\n }\n\n var key = parseKeys(privateKey)\n var k = key.modulus.byteLength()\n if (enc.length > k || new BN(enc).cmp(key.modulus) >= 0) {\n throw new Error('decryption error')\n }\n var msg\n if (reverse) {\n msg = withPublic(new BN(enc), key)\n } else {\n msg = crt(enc, key)\n }\n var zBuffer = Buffer.alloc(k - msg.length)\n msg = Buffer.concat([zBuffer, msg], k)\n if (padding === 4) {\n return oaep(key, msg)\n } else if (padding === 1) {\n return pkcs1(key, msg, reverse)\n } else if (padding === 3) {\n return msg\n } else {\n throw new Error('unknown padding')\n }\n}\n\nfunction oaep (key, msg) {\n var k = key.modulus.byteLength()\n var iHash = createHash('sha1').update(Buffer.alloc(0)).digest()\n var hLen = iHash.length\n if (msg[0] !== 0) {\n throw new Error('decryption error')\n }\n var maskedSeed = msg.slice(1, hLen + 1)\n var maskedDb = msg.slice(hLen + 1)\n var seed = xor(maskedSeed, mgf(maskedDb, hLen))\n var db = xor(maskedDb, mgf(seed, k - hLen - 1))\n if (compare(iHash, db.slice(0, hLen))) {\n throw new Error('decryption error')\n }\n var i = hLen\n while (db[i] === 0) {\n i++\n }\n if (db[i++] !== 1) {\n throw new Error('decryption error')\n }\n return db.slice(i)\n}\n\nfunction pkcs1 (key, msg, reverse) {\n var p1 = msg.slice(0, 2)\n var i = 2\n var status = 0\n while (msg[i++] !== 0) {\n if (i >= msg.length) {\n status++\n break\n }\n }\n var ps = msg.slice(2, i - 1)\n\n if ((p1.toString('hex') !== '0002' && !reverse) || (p1.toString('hex') !== '0001' && reverse)) {\n status++\n }\n if (ps.length < 8) {\n status++\n }\n if (status) {\n throw new Error('decryption error')\n }\n return msg.slice(i)\n}\nfunction compare (a, b) {\n a = Buffer.from(a)\n b = Buffer.from(b)\n var dif = 0\n var len = a.length\n if (a.length !== b.length) {\n dif++\n len = Math.min(a.length, b.length)\n }\n var i = -1\n while (++i < len) {\n dif += (a[i] ^ b[i])\n }\n return dif\n}\n","var parseKeys = require('parse-asn1')\nvar randomBytes = require('randombytes')\nvar createHash = require('create-hash')\nvar mgf = require('./mgf')\nvar xor = require('./xor')\nvar BN = require('bn.js')\nvar withPublic = require('./withPublic')\nvar crt = require('browserify-rsa')\nvar Buffer = require('safe-buffer').Buffer\n\nmodule.exports = function publicEncrypt (publicKey, msg, reverse) {\n var padding\n if (publicKey.padding) {\n padding = publicKey.padding\n } else if (reverse) {\n padding = 1\n } else {\n padding = 4\n }\n var key = parseKeys(publicKey)\n var paddedMsg\n if (padding === 4) {\n paddedMsg = oaep(key, msg)\n } else if (padding === 1) {\n paddedMsg = pkcs1(key, msg, reverse)\n } else if (padding === 3) {\n paddedMsg = new BN(msg)\n if (paddedMsg.cmp(key.modulus) >= 0) {\n throw new Error('data too long for modulus')\n }\n } else {\n throw new Error('unknown padding')\n }\n if (reverse) {\n return crt(paddedMsg, key)\n } else {\n return withPublic(paddedMsg, key)\n }\n}\n\nfunction oaep (key, msg) {\n var k = key.modulus.byteLength()\n var mLen = msg.length\n var iHash = createHash('sha1').update(Buffer.alloc(0)).digest()\n var hLen = iHash.length\n var hLen2 = 2 * hLen\n if (mLen > k - hLen2 - 2) {\n throw new Error('message too long')\n }\n var ps = Buffer.alloc(k - mLen - hLen2 - 2)\n var dblen = k - hLen - 1\n var seed = randomBytes(hLen)\n var maskedDb = xor(Buffer.concat([iHash, ps, Buffer.alloc(1, 1), msg], dblen), mgf(seed, dblen))\n var maskedSeed = xor(seed, mgf(maskedDb, hLen))\n return new BN(Buffer.concat([Buffer.alloc(1), maskedSeed, maskedDb], k))\n}\nfunction pkcs1 (key, msg, reverse) {\n var mLen = msg.length\n var k = key.modulus.byteLength()\n if (mLen > k - 11) {\n throw new Error('message too long')\n }\n var ps\n if (reverse) {\n ps = Buffer.alloc(k - mLen - 3, 0xff)\n } else {\n ps = nonZero(k - mLen - 3)\n }\n return new BN(Buffer.concat([Buffer.from([0, reverse ? 1 : 2]), ps, Buffer.alloc(1), msg], k))\n}\nfunction nonZero (len) {\n var out = Buffer.allocUnsafe(len)\n var i = 0\n var cache = randomBytes(len * 2)\n var cur = 0\n var num\n while (i < len) {\n if (cur === cache.length) {\n cache = randomBytes(len * 2)\n cur = 0\n }\n num = cache[cur++]\n if (num) {\n out[i++] = num\n }\n }\n return out\n}\n","var BN = require('bn.js')\nvar Buffer = require('safe-buffer').Buffer\n\nfunction withPublic (paddedMsg, key) {\n return Buffer.from(paddedMsg\n .toRed(BN.mont(key.modulus))\n .redPow(new BN(key.publicExponent))\n .fromRed()\n .toArray())\n}\n\nmodule.exports = withPublic\n","module.exports = function xor (a, b) {\n var len = a.length\n var i = -1\n while (++i < len) {\n a[i] ^= b[i]\n }\n return a\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n// If obj.hasOwnProperty has been overridden, then calling\n// obj.hasOwnProperty(prop) will break.\n// See: https://github.com/joyent/node/issues/1707\nfunction hasOwnProperty(obj, prop) {\n return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nmodule.exports = function(qs, sep, eq, options) {\n sep = sep || '&';\n eq = eq || '=';\n var obj = {};\n\n if (typeof qs !== 'string' || qs.length === 0) {\n return obj;\n }\n\n var regexp = /\\+/g;\n qs = qs.split(sep);\n\n var maxKeys = 1000;\n if (options && typeof options.maxKeys === 'number') {\n maxKeys = options.maxKeys;\n }\n\n var len = qs.length;\n // maxKeys <= 0 means that we should not limit keys count\n if (maxKeys > 0 && len > maxKeys) {\n len = maxKeys;\n }\n\n for (var i = 0; i < len; ++i) {\n var x = qs[i].replace(regexp, '%20'),\n idx = x.indexOf(eq),\n kstr, vstr, k, v;\n\n if (idx >= 0) {\n kstr = x.substr(0, idx);\n vstr = x.substr(idx + 1);\n } else {\n kstr = x;\n vstr = '';\n }\n\n k = decodeURIComponent(kstr);\n v = decodeURIComponent(vstr);\n\n if (!hasOwnProperty(obj, k)) {\n obj[k] = v;\n } else if (Array.isArray(obj[k])) {\n obj[k].push(v);\n } else {\n obj[k] = [obj[k], v];\n }\n }\n\n return obj;\n};\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar stringifyPrimitive = function(v) {\n switch (typeof v) {\n case 'string':\n return v;\n\n case 'boolean':\n return v ? 'true' : 'false';\n\n case 'number':\n return isFinite(v) ? v : '';\n\n default:\n return '';\n }\n};\n\nmodule.exports = function(obj, sep, eq, name) {\n sep = sep || '&';\n eq = eq || '=';\n if (obj === null) {\n obj = undefined;\n }\n\n if (typeof obj === 'object') {\n return Object.keys(obj).map(function(k) {\n var ks = encodeURIComponent(stringifyPrimitive(k)) + eq;\n if (Array.isArray(obj[k])) {\n return obj[k].map(function(v) {\n return ks + encodeURIComponent(stringifyPrimitive(v));\n }).join(sep);\n } else {\n return ks + encodeURIComponent(stringifyPrimitive(obj[k]));\n }\n }).join(sep);\n\n }\n\n if (!name) return '';\n return encodeURIComponent(stringifyPrimitive(name)) + eq +\n encodeURIComponent(stringifyPrimitive(obj));\n};\n","'use strict';\n\nexports.decode = exports.parse = require('./decode');\nexports.encode = exports.stringify = require('./encode');\n","'use strict'\n\n// limit of Crypto.getRandomValues()\n// https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues\nvar MAX_BYTES = 65536\n\n// Node supports requesting up to this number of bytes\n// https://github.com/nodejs/node/blob/master/lib/internal/crypto/random.js#L48\nvar MAX_UINT32 = 4294967295\n\nfunction oldBrowser () {\n throw new Error('Secure random number generation is not supported by this browser.\\nUse Chrome, Firefox or Internet Explorer 11')\n}\n\nvar Buffer = require('safe-buffer').Buffer\nvar crypto = global.crypto || global.msCrypto\n\nif (crypto && crypto.getRandomValues) {\n module.exports = randomBytes\n} else {\n module.exports = oldBrowser\n}\n\nfunction randomBytes (size, cb) {\n // phantomjs needs to throw\n if (size > MAX_UINT32) throw new RangeError('requested too many random bytes')\n\n var bytes = Buffer.allocUnsafe(size)\n\n if (size > 0) { // getRandomValues fails on IE if size == 0\n if (size > MAX_BYTES) { // this is the max bytes crypto.getRandomValues\n // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues\n for (var generated = 0; generated < size; generated += MAX_BYTES) {\n // buffer.slice automatically checks if the end is past the end of\n // the buffer so we don't have to here\n crypto.getRandomValues(bytes.slice(generated, generated + MAX_BYTES))\n }\n } else {\n crypto.getRandomValues(bytes)\n }\n }\n\n if (typeof cb === 'function') {\n return process.nextTick(function () {\n cb(null, bytes)\n })\n }\n\n return bytes\n}\n","'use strict'\n\nfunction oldBrowser () {\n throw new Error('secure random number generation not supported by this browser\\nuse chrome, FireFox or Internet Explorer 11')\n}\nvar safeBuffer = require('safe-buffer')\nvar randombytes = require('randombytes')\nvar Buffer = safeBuffer.Buffer\nvar kBufferMaxLength = safeBuffer.kMaxLength\nvar crypto = global.crypto || global.msCrypto\nvar kMaxUint32 = Math.pow(2, 32) - 1\nfunction assertOffset (offset, length) {\n if (typeof offset !== 'number' || offset !== offset) { // eslint-disable-line no-self-compare\n throw new TypeError('offset must be a number')\n }\n\n if (offset > kMaxUint32 || offset < 0) {\n throw new TypeError('offset must be a uint32')\n }\n\n if (offset > kBufferMaxLength || offset > length) {\n throw new RangeError('offset out of range')\n }\n}\n\nfunction assertSize (size, offset, length) {\n if (typeof size !== 'number' || size !== size) { // eslint-disable-line no-self-compare\n throw new TypeError('size must be a number')\n }\n\n if (size > kMaxUint32 || size < 0) {\n throw new TypeError('size must be a uint32')\n }\n\n if (size + offset > length || size > kBufferMaxLength) {\n throw new RangeError('buffer too small')\n }\n}\nif ((crypto && crypto.getRandomValues) || !process.browser) {\n exports.randomFill = randomFill\n exports.randomFillSync = randomFillSync\n} else {\n exports.randomFill = oldBrowser\n exports.randomFillSync = oldBrowser\n}\nfunction randomFill (buf, offset, size, cb) {\n if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {\n throw new TypeError('\"buf\" argument must be a Buffer or Uint8Array')\n }\n\n if (typeof offset === 'function') {\n cb = offset\n offset = 0\n size = buf.length\n } else if (typeof size === 'function') {\n cb = size\n size = buf.length - offset\n } else if (typeof cb !== 'function') {\n throw new TypeError('\"cb\" argument must be a function')\n }\n assertOffset(offset, buf.length)\n assertSize(size, offset, buf.length)\n return actualFill(buf, offset, size, cb)\n}\n\nfunction actualFill (buf, offset, size, cb) {\n if (process.browser) {\n var ourBuf = buf.buffer\n var uint = new Uint8Array(ourBuf, offset, size)\n crypto.getRandomValues(uint)\n if (cb) {\n process.nextTick(function () {\n cb(null, buf)\n })\n return\n }\n return buf\n }\n if (cb) {\n randombytes(size, function (err, bytes) {\n if (err) {\n return cb(err)\n }\n bytes.copy(buf, offset)\n cb(null, buf)\n })\n return\n }\n var bytes = randombytes(size)\n bytes.copy(buf, offset)\n return buf\n}\nfunction randomFillSync (buf, offset, size) {\n if (typeof offset === 'undefined') {\n offset = 0\n }\n if (!Buffer.isBuffer(buf) && !(buf instanceof global.Uint8Array)) {\n throw new TypeError('\"buf\" argument must be a Buffer or Uint8Array')\n }\n\n assertOffset(offset, buf.length)\n\n if (size === undefined) size = buf.length - offset\n\n assertSize(size, offset, buf.length)\n\n return actualFill(buf, offset, size)\n}\n","'use strict';\n\nfunction _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }\n\nvar codes = {};\n\nfunction createErrorType(code, message, Base) {\n if (!Base) {\n Base = Error;\n }\n\n function getMessage(arg1, arg2, arg3) {\n if (typeof message === 'string') {\n return message;\n } else {\n return message(arg1, arg2, arg3);\n }\n }\n\n var NodeError =\n /*#__PURE__*/\n function (_Base) {\n _inheritsLoose(NodeError, _Base);\n\n function NodeError(arg1, arg2, arg3) {\n return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;\n }\n\n return NodeError;\n }(Base);\n\n NodeError.prototype.name = Base.name;\n NodeError.prototype.code = code;\n codes[code] = NodeError;\n} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js\n\n\nfunction oneOf(expected, thing) {\n if (Array.isArray(expected)) {\n var len = expected.length;\n expected = expected.map(function (i) {\n return String(i);\n });\n\n if (len > 2) {\n return \"one of \".concat(thing, \" \").concat(expected.slice(0, len - 1).join(', '), \", or \") + expected[len - 1];\n } else if (len === 2) {\n return \"one of \".concat(thing, \" \").concat(expected[0], \" or \").concat(expected[1]);\n } else {\n return \"of \".concat(thing, \" \").concat(expected[0]);\n }\n } else {\n return \"of \".concat(thing, \" \").concat(String(expected));\n }\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith\n\n\nfunction startsWith(str, search, pos) {\n return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith\n\n\nfunction endsWith(str, search, this_len) {\n if (this_len === undefined || this_len > str.length) {\n this_len = str.length;\n }\n\n return str.substring(this_len - search.length, this_len) === search;\n} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes\n\n\nfunction includes(str, search, start) {\n if (typeof start !== 'number') {\n start = 0;\n }\n\n if (start + search.length > str.length) {\n return false;\n } else {\n return str.indexOf(search, start) !== -1;\n }\n}\n\ncreateErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {\n return 'The value \"' + value + '\" is invalid for option \"' + name + '\"';\n}, TypeError);\ncreateErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {\n // determiner: 'must be' or 'must not be'\n var determiner;\n\n if (typeof expected === 'string' && startsWith(expected, 'not ')) {\n determiner = 'must not be';\n expected = expected.replace(/^not /, '');\n } else {\n determiner = 'must be';\n }\n\n var msg;\n\n if (endsWith(name, ' argument')) {\n // For cases like 'first argument'\n msg = \"The \".concat(name, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n } else {\n var type = includes(name, '.') ? 'property' : 'argument';\n msg = \"The \\\"\".concat(name, \"\\\" \").concat(type, \" \").concat(determiner, \" \").concat(oneOf(expected, 'type'));\n }\n\n msg += \". Received type \".concat(typeof actual);\n return msg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');\ncreateErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {\n return 'The ' + name + ' method is not implemented';\n});\ncreateErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');\ncreateErrorType('ERR_STREAM_DESTROYED', function (name) {\n return 'Cannot call ' + name + ' after a stream was destroyed';\n});\ncreateErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');\ncreateErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');\ncreateErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');\ncreateErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);\ncreateErrorType('ERR_UNKNOWN_ENCODING', function (arg) {\n return 'Unknown encoding: ' + arg;\n}, TypeError);\ncreateErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');\nmodule.exports.codes = codes;\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// a duplex stream is just a stream that is both readable and writable.\n// Since JS doesn't have multiple prototypal inheritance, this class\n// prototypally inherits from Readable, and then parasitically from\n// Writable.\n'use strict';\n/*<replacement>*/\n\nvar objectKeys = Object.keys || function (obj) {\n var keys = [];\n\n for (var key in obj) {\n keys.push(key);\n }\n\n return keys;\n};\n/*</replacement>*/\n\n\nmodule.exports = Duplex;\n\nvar Readable = require('./_stream_readable');\n\nvar Writable = require('./_stream_writable');\n\nrequire('inherits')(Duplex, Readable);\n\n{\n // Allow the keys array to be GC'ed.\n var keys = objectKeys(Writable.prototype);\n\n for (var v = 0; v < keys.length; v++) {\n var method = keys[v];\n if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];\n }\n}\n\nfunction Duplex(options) {\n if (!(this instanceof Duplex)) return new Duplex(options);\n Readable.call(this, options);\n Writable.call(this, options);\n this.allowHalfOpen = true;\n\n if (options) {\n if (options.readable === false) this.readable = false;\n if (options.writable === false) this.writable = false;\n\n if (options.allowHalfOpen === false) {\n this.allowHalfOpen = false;\n this.once('end', onend);\n }\n }\n}\n\nObject.defineProperty(Duplex.prototype, 'writableHighWaterMark', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.highWaterMark;\n }\n});\nObject.defineProperty(Duplex.prototype, 'writableBuffer', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState && this._writableState.getBuffer();\n }\n});\nObject.defineProperty(Duplex.prototype, 'writableLength', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.length;\n }\n}); // the no-half-open enforcer\n\nfunction onend() {\n // If the writable side ended, then we're ok.\n if (this._writableState.ended) return; // no more data can be written.\n // But allow more writes to happen in this tick.\n\n process.nextTick(onEndNT, this);\n}\n\nfunction onEndNT(self) {\n self.end();\n}\n\nObject.defineProperty(Duplex.prototype, 'destroyed', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n if (this._readableState === undefined || this._writableState === undefined) {\n return false;\n }\n\n return this._readableState.destroyed && this._writableState.destroyed;\n },\n set: function set(value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (this._readableState === undefined || this._writableState === undefined) {\n return;\n } // backward compatibility, the user is explicitly\n // managing destroyed\n\n\n this._readableState.destroyed = value;\n this._writableState.destroyed = value;\n }\n});","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// a passthrough stream.\n// basically just the most minimal sort of Transform stream.\n// Every written chunk gets output as-is.\n'use strict';\n\nmodule.exports = PassThrough;\n\nvar Transform = require('./_stream_transform');\n\nrequire('inherits')(PassThrough, Transform);\n\nfunction PassThrough(options) {\n if (!(this instanceof PassThrough)) return new PassThrough(options);\n Transform.call(this, options);\n}\n\nPassThrough.prototype._transform = function (chunk, encoding, cb) {\n cb(null, chunk);\n};","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n'use strict';\n\nmodule.exports = Readable;\n/*<replacement>*/\n\nvar Duplex;\n/*</replacement>*/\n\nReadable.ReadableState = ReadableState;\n/*<replacement>*/\n\nvar EE = require('events').EventEmitter;\n\nvar EElistenerCount = function EElistenerCount(emitter, type) {\n return emitter.listeners(type).length;\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n/*<replacement>*/\n\n\nvar debugUtil = require('util');\n\nvar debug;\n\nif (debugUtil && debugUtil.debuglog) {\n debug = debugUtil.debuglog('stream');\n} else {\n debug = function debug() {};\n}\n/*</replacement>*/\n\n\nvar BufferList = require('./internal/streams/buffer_list');\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,\n ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; // Lazy loaded to improve the startup performance.\n\n\nvar StringDecoder;\nvar createReadableStreamAsyncIterator;\nvar from;\n\nrequire('inherits')(Readable, Stream);\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\nvar kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];\n\nfunction prependListener(emitter, event, fn) {\n // Sadly this is not cacheable as some libraries bundle their own\n // event emitter implementation with them.\n if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any\n // userland ones. NEVER DO THIS. This is here only because this code needs\n // to continue to work with older versions of Node.js that do not include\n // the prependListener() method. The goal is to eventually remove this hack.\n\n if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];\n}\n\nfunction ReadableState(options, stream, isDuplex) {\n Duplex = Duplex || require('./_stream_duplex');\n options = options || {}; // Duplex streams are both readable and writable, but share\n // the same options object.\n // However, some cases require setting options to different\n // values for the readable and the writable sides of the duplex stream.\n // These options can be provided separately as readableXXX and writableXXX.\n\n if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to\n // make all the buffer merging and length checks go away\n\n this.objectMode = !!options.objectMode;\n if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer\n // Note: 0 is a valid value, means \"don't call _read preemptively ever\"\n\n this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the\n // linked list can remove elements from the beginning faster than\n // array.shift()\n\n this.buffer = new BufferList();\n this.length = 0;\n this.pipes = null;\n this.pipesCount = 0;\n this.flowing = null;\n this.ended = false;\n this.endEmitted = false;\n this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted\n // immediately, or on a later tick. We set this to true at first, because\n // any actions that shouldn't happen until \"later\" should generally also\n // not happen before the first read call.\n\n this.sync = true; // whenever we return null, then we set a flag to say\n // that we're awaiting a 'readable' event emission.\n\n this.needReadable = false;\n this.emittedReadable = false;\n this.readableListening = false;\n this.resumeScheduled = false;\n this.paused = true; // Should close be emitted on destroy. Defaults to true.\n\n this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish')\n\n this.autoDestroy = !!options.autoDestroy; // has it been destroyed\n\n this.destroyed = false; // Crypto is kind of old and crusty. Historically, its default string\n // encoding is 'binary' so we have to make this configurable.\n // Everything else in the universe uses 'utf8', though.\n\n this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s\n\n this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled\n\n this.readingMore = false;\n this.decoder = null;\n this.encoding = null;\n\n if (options.encoding) {\n if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n this.decoder = new StringDecoder(options.encoding);\n this.encoding = options.encoding;\n }\n}\n\nfunction Readable(options) {\n Duplex = Duplex || require('./_stream_duplex');\n if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside\n // the ReadableState constructor, at least with V8 6.5\n\n var isDuplex = this instanceof Duplex;\n this._readableState = new ReadableState(options, this, isDuplex); // legacy\n\n this.readable = true;\n\n if (options) {\n if (typeof options.read === 'function') this._read = options.read;\n if (typeof options.destroy === 'function') this._destroy = options.destroy;\n }\n\n Stream.call(this);\n}\n\nObject.defineProperty(Readable.prototype, 'destroyed', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n if (this._readableState === undefined) {\n return false;\n }\n\n return this._readableState.destroyed;\n },\n set: function set(value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._readableState) {\n return;\n } // backward compatibility, the user is explicitly\n // managing destroyed\n\n\n this._readableState.destroyed = value;\n }\n});\nReadable.prototype.destroy = destroyImpl.destroy;\nReadable.prototype._undestroy = destroyImpl.undestroy;\n\nReadable.prototype._destroy = function (err, cb) {\n cb(err);\n}; // Manually shove something into the read() buffer.\n// This returns true if the highWaterMark has not been hit yet,\n// similar to how Writable.write() returns true if you should\n// write() some more.\n\n\nReadable.prototype.push = function (chunk, encoding) {\n var state = this._readableState;\n var skipChunkCheck;\n\n if (!state.objectMode) {\n if (typeof chunk === 'string') {\n encoding = encoding || state.defaultEncoding;\n\n if (encoding !== state.encoding) {\n chunk = Buffer.from(chunk, encoding);\n encoding = '';\n }\n\n skipChunkCheck = true;\n }\n } else {\n skipChunkCheck = true;\n }\n\n return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);\n}; // Unshift should *always* be something directly out of read()\n\n\nReadable.prototype.unshift = function (chunk) {\n return readableAddChunk(this, chunk, null, true, false);\n};\n\nfunction readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {\n debug('readableAddChunk', chunk);\n var state = stream._readableState;\n\n if (chunk === null) {\n state.reading = false;\n onEofChunk(stream, state);\n } else {\n var er;\n if (!skipChunkCheck) er = chunkInvalid(state, chunk);\n\n if (er) {\n errorOrDestroy(stream, er);\n } else if (state.objectMode || chunk && chunk.length > 0) {\n if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n\n if (addToFront) {\n if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);\n } else if (state.ended) {\n errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());\n } else if (state.destroyed) {\n return false;\n } else {\n state.reading = false;\n\n if (state.decoder && !encoding) {\n chunk = state.decoder.write(chunk);\n if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);\n } else {\n addChunk(stream, state, chunk, false);\n }\n }\n } else if (!addToFront) {\n state.reading = false;\n maybeReadMore(stream, state);\n }\n } // We can push more data if we are below the highWaterMark.\n // Also, if we have no data yet, we can stand some more bytes.\n // This is to work around cases where hwm=0, such as the repl.\n\n\n return !state.ended && (state.length < state.highWaterMark || state.length === 0);\n}\n\nfunction addChunk(stream, state, chunk, addToFront) {\n if (state.flowing && state.length === 0 && !state.sync) {\n state.awaitDrain = 0;\n stream.emit('data', chunk);\n } else {\n // update the buffer info.\n state.length += state.objectMode ? 1 : chunk.length;\n if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);\n if (state.needReadable) emitReadable(stream);\n }\n\n maybeReadMore(stream, state);\n}\n\nfunction chunkInvalid(state, chunk) {\n var er;\n\n if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);\n }\n\n return er;\n}\n\nReadable.prototype.isPaused = function () {\n return this._readableState.flowing === false;\n}; // backwards compatibility.\n\n\nReadable.prototype.setEncoding = function (enc) {\n if (!StringDecoder) StringDecoder = require('string_decoder/').StringDecoder;\n var decoder = new StringDecoder(enc);\n this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8\n\n this._readableState.encoding = this._readableState.decoder.encoding; // Iterate over current buffer to convert already stored Buffers:\n\n var p = this._readableState.buffer.head;\n var content = '';\n\n while (p !== null) {\n content += decoder.write(p.data);\n p = p.next;\n }\n\n this._readableState.buffer.clear();\n\n if (content !== '') this._readableState.buffer.push(content);\n this._readableState.length = content.length;\n return this;\n}; // Don't raise the hwm > 1GB\n\n\nvar MAX_HWM = 0x40000000;\n\nfunction computeNewHighWaterMark(n) {\n if (n >= MAX_HWM) {\n // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.\n n = MAX_HWM;\n } else {\n // Get the next highest power of 2 to prevent increasing hwm excessively in\n // tiny amounts\n n--;\n n |= n >>> 1;\n n |= n >>> 2;\n n |= n >>> 4;\n n |= n >>> 8;\n n |= n >>> 16;\n n++;\n }\n\n return n;\n} // This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\n\nfunction howMuchToRead(n, state) {\n if (n <= 0 || state.length === 0 && state.ended) return 0;\n if (state.objectMode) return 1;\n\n if (n !== n) {\n // Only flow one buffer at a time\n if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;\n } // If we're asking for more than the current hwm, then raise the hwm.\n\n\n if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);\n if (n <= state.length) return n; // Don't have enough\n\n if (!state.ended) {\n state.needReadable = true;\n return 0;\n }\n\n return state.length;\n} // you can override either this method, or the async _read(n) below.\n\n\nReadable.prototype.read = function (n) {\n debug('read', n);\n n = parseInt(n, 10);\n var state = this._readableState;\n var nOrig = n;\n if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we\n // already have a bunch of data in the buffer, then just trigger\n // the 'readable' event and move on.\n\n if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {\n debug('read: emitReadable', state.length, state.ended);\n if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);\n return null;\n }\n\n n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.\n\n if (n === 0 && state.ended) {\n if (state.length === 0) endReadable(this);\n return null;\n } // All the actual chunk generation logic needs to be\n // *below* the call to _read. The reason is that in certain\n // synthetic stream cases, such as passthrough streams, _read\n // may be a completely synchronous operation which may change\n // the state of the read buffer, providing enough data when\n // before there was *not* enough.\n //\n // So, the steps are:\n // 1. Figure out what the state of things will be after we do\n // a read from the buffer.\n //\n // 2. If that resulting state will trigger a _read, then call _read.\n // Note that this may be asynchronous, or synchronous. Yes, it is\n // deeply ugly to write APIs this way, but that still doesn't mean\n // that the Readable class should behave improperly, as streams are\n // designed to be sync/async agnostic.\n // Take note if the _read call is sync or async (ie, if the read call\n // has returned yet), so that we know whether or not it's safe to emit\n // 'readable' etc.\n //\n // 3. Actually pull the requested chunks out of the buffer and return.\n // if we need a readable event, then we need to do some reading.\n\n\n var doRead = state.needReadable;\n debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some\n\n if (state.length === 0 || state.length - n < state.highWaterMark) {\n doRead = true;\n debug('length less than watermark', doRead);\n } // however, if we've ended, then there's no point, and if we're already\n // reading, then it's unnecessary.\n\n\n if (state.ended || state.reading) {\n doRead = false;\n debug('reading or ended', doRead);\n } else if (doRead) {\n debug('do read');\n state.reading = true;\n state.sync = true; // if the length is currently zero, then we *need* a readable event.\n\n if (state.length === 0) state.needReadable = true; // call internal read method\n\n this._read(state.highWaterMark);\n\n state.sync = false; // If _read pushed data synchronously, then `reading` will be false,\n // and we need to re-evaluate how much data we can return to the user.\n\n if (!state.reading) n = howMuchToRead(nOrig, state);\n }\n\n var ret;\n if (n > 0) ret = fromList(n, state);else ret = null;\n\n if (ret === null) {\n state.needReadable = state.length <= state.highWaterMark;\n n = 0;\n } else {\n state.length -= n;\n state.awaitDrain = 0;\n }\n\n if (state.length === 0) {\n // If we have nothing in the buffer, then we want to know\n // as soon as we *do* get something into the buffer.\n if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick.\n\n if (nOrig !== n && state.ended) endReadable(this);\n }\n\n if (ret !== null) this.emit('data', ret);\n return ret;\n};\n\nfunction onEofChunk(stream, state) {\n debug('onEofChunk');\n if (state.ended) return;\n\n if (state.decoder) {\n var chunk = state.decoder.end();\n\n if (chunk && chunk.length) {\n state.buffer.push(chunk);\n state.length += state.objectMode ? 1 : chunk.length;\n }\n }\n\n state.ended = true;\n\n if (state.sync) {\n // if we are sync, wait until next tick to emit the data.\n // Otherwise we risk emitting data in the flow()\n // the readable code triggers during a read() call\n emitReadable(stream);\n } else {\n // emit 'readable' now to make sure it gets picked up.\n state.needReadable = false;\n\n if (!state.emittedReadable) {\n state.emittedReadable = true;\n emitReadable_(stream);\n }\n }\n} // Don't emit readable right away in sync mode, because this can trigger\n// another read() call => stack overflow. This way, it might trigger\n// a nextTick recursion warning, but that's not so bad.\n\n\nfunction emitReadable(stream) {\n var state = stream._readableState;\n debug('emitReadable', state.needReadable, state.emittedReadable);\n state.needReadable = false;\n\n if (!state.emittedReadable) {\n debug('emitReadable', state.flowing);\n state.emittedReadable = true;\n process.nextTick(emitReadable_, stream);\n }\n}\n\nfunction emitReadable_(stream) {\n var state = stream._readableState;\n debug('emitReadable_', state.destroyed, state.length, state.ended);\n\n if (!state.destroyed && (state.length || state.ended)) {\n stream.emit('readable');\n state.emittedReadable = false;\n } // The stream needs another readable event if\n // 1. It is not flowing, as the flow mechanism will take\n // care of it.\n // 2. It is not ended.\n // 3. It is below the highWaterMark, so we can schedule\n // another readable later.\n\n\n state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;\n flow(stream);\n} // at this point, the user has presumably seen the 'readable' event,\n// and called read() to consume some data. that may have triggered\n// in turn another _read(n) call, in which case reading = true if\n// it's in progress.\n// However, if we're not ended, or reading, and the length < hwm,\n// then go ahead and try to read some more preemptively.\n\n\nfunction maybeReadMore(stream, state) {\n if (!state.readingMore) {\n state.readingMore = true;\n process.nextTick(maybeReadMore_, stream, state);\n }\n}\n\nfunction maybeReadMore_(stream, state) {\n // Attempt to read more data if we should.\n //\n // The conditions for reading more data are (one of):\n // - Not enough data buffered (state.length < state.highWaterMark). The loop\n // is responsible for filling the buffer with enough data if such data\n // is available. If highWaterMark is 0 and we are not in the flowing mode\n // we should _not_ attempt to buffer any extra data. We'll get more data\n // when the stream consumer calls read() instead.\n // - No data in the buffer, and the stream is in flowing mode. In this mode\n // the loop below is responsible for ensuring read() is called. Failing to\n // call read here would abort the flow and there's no other mechanism for\n // continuing the flow if the stream consumer has just subscribed to the\n // 'data' event.\n //\n // In addition to the above conditions to keep reading data, the following\n // conditions prevent the data from being read:\n // - The stream has ended (state.ended).\n // - There is already a pending 'read' operation (state.reading). This is a\n // case where the the stream has called the implementation defined _read()\n // method, but they are processing the call asynchronously and have _not_\n // called push() with new data. In this case we skip performing more\n // read()s. The execution ends in this method again after the _read() ends\n // up calling push() with more data.\n while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {\n var len = state.length;\n debug('maybeReadMore read 0');\n stream.read(0);\n if (len === state.length) // didn't get any data, stop spinning.\n break;\n }\n\n state.readingMore = false;\n} // abstract method. to be overridden in specific implementation classes.\n// call cb(er, data) where data is <= n in length.\n// for virtual (non-string, non-buffer) streams, \"length\" is somewhat\n// arbitrary, and perhaps not very meaningful.\n\n\nReadable.prototype._read = function (n) {\n errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));\n};\n\nReadable.prototype.pipe = function (dest, pipeOpts) {\n var src = this;\n var state = this._readableState;\n\n switch (state.pipesCount) {\n case 0:\n state.pipes = dest;\n break;\n\n case 1:\n state.pipes = [state.pipes, dest];\n break;\n\n default:\n state.pipes.push(dest);\n break;\n }\n\n state.pipesCount += 1;\n debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);\n var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;\n var endFn = doEnd ? onend : unpipe;\n if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);\n dest.on('unpipe', onunpipe);\n\n function onunpipe(readable, unpipeInfo) {\n debug('onunpipe');\n\n if (readable === src) {\n if (unpipeInfo && unpipeInfo.hasUnpiped === false) {\n unpipeInfo.hasUnpiped = true;\n cleanup();\n }\n }\n }\n\n function onend() {\n debug('onend');\n dest.end();\n } // when the dest drains, it reduces the awaitDrain counter\n // on the source. This would be more elegant with a .once()\n // handler in flow(), but adding and removing repeatedly is\n // too slow.\n\n\n var ondrain = pipeOnDrain(src);\n dest.on('drain', ondrain);\n var cleanedUp = false;\n\n function cleanup() {\n debug('cleanup'); // cleanup event handlers once the pipe is broken\n\n dest.removeListener('close', onclose);\n dest.removeListener('finish', onfinish);\n dest.removeListener('drain', ondrain);\n dest.removeListener('error', onerror);\n dest.removeListener('unpipe', onunpipe);\n src.removeListener('end', onend);\n src.removeListener('end', unpipe);\n src.removeListener('data', ondata);\n cleanedUp = true; // if the reader is waiting for a drain event from this\n // specific writer, then it would cause it to never start\n // flowing again.\n // So, if this is awaiting a drain, then we just call it now.\n // If we don't know, then assume that we are waiting for one.\n\n if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();\n }\n\n src.on('data', ondata);\n\n function ondata(chunk) {\n debug('ondata');\n var ret = dest.write(chunk);\n debug('dest.write', ret);\n\n if (ret === false) {\n // If the user unpiped during `dest.write()`, it is possible\n // to get stuck in a permanently paused state if that write\n // also returned false.\n // => Check whether `dest` is still a piping destination.\n if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {\n debug('false write response, pause', state.awaitDrain);\n state.awaitDrain++;\n }\n\n src.pause();\n }\n } // if the dest has an error, then stop piping into it.\n // however, don't suppress the throwing behavior for this.\n\n\n function onerror(er) {\n debug('onerror', er);\n unpipe();\n dest.removeListener('error', onerror);\n if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er);\n } // Make sure our error handler is attached before userland ones.\n\n\n prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.\n\n function onclose() {\n dest.removeListener('finish', onfinish);\n unpipe();\n }\n\n dest.once('close', onclose);\n\n function onfinish() {\n debug('onfinish');\n dest.removeListener('close', onclose);\n unpipe();\n }\n\n dest.once('finish', onfinish);\n\n function unpipe() {\n debug('unpipe');\n src.unpipe(dest);\n } // tell the dest that it's being piped to\n\n\n dest.emit('pipe', src); // start the flow if it hasn't been started already.\n\n if (!state.flowing) {\n debug('pipe resume');\n src.resume();\n }\n\n return dest;\n};\n\nfunction pipeOnDrain(src) {\n return function pipeOnDrainFunctionResult() {\n var state = src._readableState;\n debug('pipeOnDrain', state.awaitDrain);\n if (state.awaitDrain) state.awaitDrain--;\n\n if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {\n state.flowing = true;\n flow(src);\n }\n };\n}\n\nReadable.prototype.unpipe = function (dest) {\n var state = this._readableState;\n var unpipeInfo = {\n hasUnpiped: false\n }; // if we're not piping anywhere, then do nothing.\n\n if (state.pipesCount === 0) return this; // just one destination. most common case.\n\n if (state.pipesCount === 1) {\n // passed in one, but it's not the right one.\n if (dest && dest !== state.pipes) return this;\n if (!dest) dest = state.pipes; // got a match.\n\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n if (dest) dest.emit('unpipe', this, unpipeInfo);\n return this;\n } // slow case. multiple pipe destinations.\n\n\n if (!dest) {\n // remove all.\n var dests = state.pipes;\n var len = state.pipesCount;\n state.pipes = null;\n state.pipesCount = 0;\n state.flowing = false;\n\n for (var i = 0; i < len; i++) {\n dests[i].emit('unpipe', this, {\n hasUnpiped: false\n });\n }\n\n return this;\n } // try to find the right one.\n\n\n var index = indexOf(state.pipes, dest);\n if (index === -1) return this;\n state.pipes.splice(index, 1);\n state.pipesCount -= 1;\n if (state.pipesCount === 1) state.pipes = state.pipes[0];\n dest.emit('unpipe', this, unpipeInfo);\n return this;\n}; // set up data events if they are asked for\n// Ensure readable listeners eventually get something\n\n\nReadable.prototype.on = function (ev, fn) {\n var res = Stream.prototype.on.call(this, ev, fn);\n var state = this._readableState;\n\n if (ev === 'data') {\n // update readableListening so that resume() may be a no-op\n // a few lines down. This is needed to support once('readable').\n state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused\n\n if (state.flowing !== false) this.resume();\n } else if (ev === 'readable') {\n if (!state.endEmitted && !state.readableListening) {\n state.readableListening = state.needReadable = true;\n state.flowing = false;\n state.emittedReadable = false;\n debug('on readable', state.length, state.reading);\n\n if (state.length) {\n emitReadable(this);\n } else if (!state.reading) {\n process.nextTick(nReadingNextTick, this);\n }\n }\n }\n\n return res;\n};\n\nReadable.prototype.addListener = Readable.prototype.on;\n\nReadable.prototype.removeListener = function (ev, fn) {\n var res = Stream.prototype.removeListener.call(this, ev, fn);\n\n if (ev === 'readable') {\n // We need to check if there is someone still listening to\n // readable and reset the state. However this needs to happen\n // after readable has been emitted but before I/O (nextTick) to\n // support once('readable', fn) cycles. This means that calling\n // resume within the same tick will have no\n // effect.\n process.nextTick(updateReadableListening, this);\n }\n\n return res;\n};\n\nReadable.prototype.removeAllListeners = function (ev) {\n var res = Stream.prototype.removeAllListeners.apply(this, arguments);\n\n if (ev === 'readable' || ev === undefined) {\n // We need to check if there is someone still listening to\n // readable and reset the state. However this needs to happen\n // after readable has been emitted but before I/O (nextTick) to\n // support once('readable', fn) cycles. This means that calling\n // resume within the same tick will have no\n // effect.\n process.nextTick(updateReadableListening, this);\n }\n\n return res;\n};\n\nfunction updateReadableListening(self) {\n var state = self._readableState;\n state.readableListening = self.listenerCount('readable') > 0;\n\n if (state.resumeScheduled && !state.paused) {\n // flowing needs to be set to true now, otherwise\n // the upcoming resume will not flow.\n state.flowing = true; // crude way to check if we should resume\n } else if (self.listenerCount('data') > 0) {\n self.resume();\n }\n}\n\nfunction nReadingNextTick(self) {\n debug('readable nexttick read 0');\n self.read(0);\n} // pause() and resume() are remnants of the legacy readable stream API\n// If the user uses them, then switch into old mode.\n\n\nReadable.prototype.resume = function () {\n var state = this._readableState;\n\n if (!state.flowing) {\n debug('resume'); // we flow only if there is no one listening\n // for readable, but we still have to call\n // resume()\n\n state.flowing = !state.readableListening;\n resume(this, state);\n }\n\n state.paused = false;\n return this;\n};\n\nfunction resume(stream, state) {\n if (!state.resumeScheduled) {\n state.resumeScheduled = true;\n process.nextTick(resume_, stream, state);\n }\n}\n\nfunction resume_(stream, state) {\n debug('resume', state.reading);\n\n if (!state.reading) {\n stream.read(0);\n }\n\n state.resumeScheduled = false;\n stream.emit('resume');\n flow(stream);\n if (state.flowing && !state.reading) stream.read(0);\n}\n\nReadable.prototype.pause = function () {\n debug('call pause flowing=%j', this._readableState.flowing);\n\n if (this._readableState.flowing !== false) {\n debug('pause');\n this._readableState.flowing = false;\n this.emit('pause');\n }\n\n this._readableState.paused = true;\n return this;\n};\n\nfunction flow(stream) {\n var state = stream._readableState;\n debug('flow', state.flowing);\n\n while (state.flowing && stream.read() !== null) {\n ;\n }\n} // wrap an old-style stream as the async data source.\n// This is *not* part of the readable stream interface.\n// It is an ugly unfortunate mess of history.\n\n\nReadable.prototype.wrap = function (stream) {\n var _this = this;\n\n var state = this._readableState;\n var paused = false;\n stream.on('end', function () {\n debug('wrapped end');\n\n if (state.decoder && !state.ended) {\n var chunk = state.decoder.end();\n if (chunk && chunk.length) _this.push(chunk);\n }\n\n _this.push(null);\n });\n stream.on('data', function (chunk) {\n debug('wrapped data');\n if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode\n\n if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;\n\n var ret = _this.push(chunk);\n\n if (!ret) {\n paused = true;\n stream.pause();\n }\n }); // proxy all the other methods.\n // important when wrapping filters and duplexes.\n\n for (var i in stream) {\n if (this[i] === undefined && typeof stream[i] === 'function') {\n this[i] = function methodWrap(method) {\n return function methodWrapReturnFunction() {\n return stream[method].apply(stream, arguments);\n };\n }(i);\n }\n } // proxy certain important events.\n\n\n for (var n = 0; n < kProxyEvents.length; n++) {\n stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));\n } // when we try to consume some more bytes, simply unpause the\n // underlying stream.\n\n\n this._read = function (n) {\n debug('wrapped _read', n);\n\n if (paused) {\n paused = false;\n stream.resume();\n }\n };\n\n return this;\n};\n\nif (typeof Symbol === 'function') {\n Readable.prototype[Symbol.asyncIterator] = function () {\n if (createReadableStreamAsyncIterator === undefined) {\n createReadableStreamAsyncIterator = require('./internal/streams/async_iterator');\n }\n\n return createReadableStreamAsyncIterator(this);\n };\n}\n\nObject.defineProperty(Readable.prototype, 'readableHighWaterMark', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState.highWaterMark;\n }\n});\nObject.defineProperty(Readable.prototype, 'readableBuffer', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState && this._readableState.buffer;\n }\n});\nObject.defineProperty(Readable.prototype, 'readableFlowing', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState.flowing;\n },\n set: function set(state) {\n if (this._readableState) {\n this._readableState.flowing = state;\n }\n }\n}); // exposed for testing purposes only.\n\nReadable._fromList = fromList;\nObject.defineProperty(Readable.prototype, 'readableLength', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._readableState.length;\n }\n}); // Pluck off n bytes from an array of buffers.\n// Length is the combined lengths of all the buffers in the list.\n// This function is designed to be inlinable, so please take care when making\n// changes to the function body.\n\nfunction fromList(n, state) {\n // nothing buffered\n if (state.length === 0) return null;\n var ret;\n if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {\n // read it all, truncate the list\n if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);\n state.buffer.clear();\n } else {\n // read part of list\n ret = state.buffer.consume(n, state.decoder);\n }\n return ret;\n}\n\nfunction endReadable(stream) {\n var state = stream._readableState;\n debug('endReadable', state.endEmitted);\n\n if (!state.endEmitted) {\n state.ended = true;\n process.nextTick(endReadableNT, state, stream);\n }\n}\n\nfunction endReadableNT(state, stream) {\n debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.\n\n if (!state.endEmitted && state.length === 0) {\n state.endEmitted = true;\n stream.readable = false;\n stream.emit('end');\n\n if (state.autoDestroy) {\n // In case of duplex streams we need a way to detect\n // if the writable side is ready for autoDestroy as well\n var wState = stream._writableState;\n\n if (!wState || wState.autoDestroy && wState.finished) {\n stream.destroy();\n }\n }\n }\n}\n\nif (typeof Symbol === 'function') {\n Readable.from = function (iterable, opts) {\n if (from === undefined) {\n from = require('./internal/streams/from');\n }\n\n return from(Readable, iterable, opts);\n };\n}\n\nfunction indexOf(xs, x) {\n for (var i = 0, l = xs.length; i < l; i++) {\n if (xs[i] === x) return i;\n }\n\n return -1;\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// a transform stream is a readable/writable stream where you do\n// something with the data. Sometimes it's called a \"filter\",\n// but that's not a great name for it, since that implies a thing where\n// some bits pass through, and others are simply ignored. (That would\n// be a valid example of a transform, of course.)\n//\n// While the output is causally related to the input, it's not a\n// necessarily symmetric or synchronous transformation. For example,\n// a zlib stream might take multiple plain-text writes(), and then\n// emit a single compressed chunk some time in the future.\n//\n// Here's how this works:\n//\n// The Transform stream has all the aspects of the readable and writable\n// stream classes. When you write(chunk), that calls _write(chunk,cb)\n// internally, and returns false if there's a lot of pending writes\n// buffered up. When you call read(), that calls _read(n) until\n// there's enough pending readable data buffered up.\n//\n// In a transform stream, the written data is placed in a buffer. When\n// _read(n) is called, it transforms the queued up data, calling the\n// buffered _write cb's as it consumes chunks. If consuming a single\n// written chunk would result in multiple output chunks, then the first\n// outputted bit calls the readcb, and subsequent chunks just go into\n// the read buffer, and will cause it to emit 'readable' if necessary.\n//\n// This way, back-pressure is actually determined by the reading side,\n// since _read has to be called to start processing a new chunk. However,\n// a pathological inflate type of transform can cause excessive buffering\n// here. For example, imagine a stream where every byte of input is\n// interpreted as an integer from 0-255, and then results in that many\n// bytes of output. Writing the 4 bytes {ff,ff,ff,ff} would result in\n// 1kb of data being output. In this case, you could write a very small\n// amount of input, and end up with a very large amount of output. In\n// such a pathological inflating mechanism, there'd be no way to tell\n// the system to stop doing the transform. A single 4MB write could\n// cause the system to run out of memory.\n//\n// However, even in such a pathological case, only a single written chunk\n// would be consumed, and then the rest would wait (un-transformed) until\n// the results of the previous transformed chunk were consumed.\n'use strict';\n\nmodule.exports = Transform;\n\nvar _require$codes = require('../errors').codes,\n ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,\n ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;\n\nvar Duplex = require('./_stream_duplex');\n\nrequire('inherits')(Transform, Duplex);\n\nfunction afterTransform(er, data) {\n var ts = this._transformState;\n ts.transforming = false;\n var cb = ts.writecb;\n\n if (cb === null) {\n return this.emit('error', new ERR_MULTIPLE_CALLBACK());\n }\n\n ts.writechunk = null;\n ts.writecb = null;\n if (data != null) // single equals check for both `null` and `undefined`\n this.push(data);\n cb(er);\n var rs = this._readableState;\n rs.reading = false;\n\n if (rs.needReadable || rs.length < rs.highWaterMark) {\n this._read(rs.highWaterMark);\n }\n}\n\nfunction Transform(options) {\n if (!(this instanceof Transform)) return new Transform(options);\n Duplex.call(this, options);\n this._transformState = {\n afterTransform: afterTransform.bind(this),\n needTransform: false,\n transforming: false,\n writecb: null,\n writechunk: null,\n writeencoding: null\n }; // start out asking for a readable event once data is transformed.\n\n this._readableState.needReadable = true; // we have implemented the _read method, and done the other things\n // that Readable wants before the first _read call, so unset the\n // sync guard flag.\n\n this._readableState.sync = false;\n\n if (options) {\n if (typeof options.transform === 'function') this._transform = options.transform;\n if (typeof options.flush === 'function') this._flush = options.flush;\n } // When the writable side finishes, then flush out anything remaining.\n\n\n this.on('prefinish', prefinish);\n}\n\nfunction prefinish() {\n var _this = this;\n\n if (typeof this._flush === 'function' && !this._readableState.destroyed) {\n this._flush(function (er, data) {\n done(_this, er, data);\n });\n } else {\n done(this, null, null);\n }\n}\n\nTransform.prototype.push = function (chunk, encoding) {\n this._transformState.needTransform = false;\n return Duplex.prototype.push.call(this, chunk, encoding);\n}; // This is the part where you do stuff!\n// override this function in implementation classes.\n// 'chunk' is an input chunk.\n//\n// Call `push(newChunk)` to pass along transformed output\n// to the readable side. You may call 'push' zero or more times.\n//\n// Call `cb(err)` when you are done with this chunk. If you pass\n// an error, then that'll put the hurt on the whole operation. If you\n// never call cb(), then you'll never get another chunk.\n\n\nTransform.prototype._transform = function (chunk, encoding, cb) {\n cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));\n};\n\nTransform.prototype._write = function (chunk, encoding, cb) {\n var ts = this._transformState;\n ts.writecb = cb;\n ts.writechunk = chunk;\n ts.writeencoding = encoding;\n\n if (!ts.transforming) {\n var rs = this._readableState;\n if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);\n }\n}; // Doesn't matter what the args are here.\n// _transform does all the work.\n// That we got here means that the readable side wants more data.\n\n\nTransform.prototype._read = function (n) {\n var ts = this._transformState;\n\n if (ts.writechunk !== null && !ts.transforming) {\n ts.transforming = true;\n\n this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);\n } else {\n // mark that we need a transform, so that any data that comes in\n // will get processed, now that we've asked for it.\n ts.needTransform = true;\n }\n};\n\nTransform.prototype._destroy = function (err, cb) {\n Duplex.prototype._destroy.call(this, err, function (err2) {\n cb(err2);\n });\n};\n\nfunction done(stream, er, data) {\n if (er) return stream.emit('error', er);\n if (data != null) // single equals check for both `null` and `undefined`\n stream.push(data); // TODO(BridgeAR): Write a test for these two error cases\n // if there's nothing in the write buffer, then that means\n // that nothing more will ever be provided\n\n if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();\n if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();\n return stream.push(null);\n}","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n'use strict';\n\nmodule.exports = Writable;\n/* <replacement> */\n\nfunction WriteReq(chunk, encoding, cb) {\n this.chunk = chunk;\n this.encoding = encoding;\n this.callback = cb;\n this.next = null;\n} // It seems a linked list but it is not\n// there will be only 2 of these for each stream\n\n\nfunction CorkedRequest(state) {\n var _this = this;\n\n this.next = null;\n this.entry = null;\n\n this.finish = function () {\n onCorkedFinish(_this, state);\n };\n}\n/* </replacement> */\n\n/*<replacement>*/\n\n\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n/*<replacement>*/\n\nvar internalUtil = {\n deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n\nvar Buffer = require('buffer').Buffer;\n\nvar OurUint8Array = global.Uint8Array || function () {};\n\nfunction _uint8ArrayToBuffer(chunk) {\n return Buffer.from(chunk);\n}\n\nfunction _isUint8Array(obj) {\n return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nvar _require = require('./internal/streams/state'),\n getHighWaterMark = _require.getHighWaterMark;\n\nvar _require$codes = require('../errors').codes,\n ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,\n ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,\n ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,\n ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,\n ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,\n ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,\n ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,\n ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;\n\nvar errorOrDestroy = destroyImpl.errorOrDestroy;\n\nrequire('inherits')(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream, isDuplex) {\n Duplex = Duplex || require('./_stream_duplex');\n options = options || {}; // Duplex streams are both readable and writable, but share\n // the same options object.\n // However, some cases require setting options to different\n // values for the readable and the writable sides of the duplex stream,\n // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.\n\n if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream\n // contains buffers or objects.\n\n this.objectMode = !!options.objectMode;\n if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false\n // Note: 0 is a valid value, means that we always return false if\n // the entire buffer is not flushed immediately on write()\n\n this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called\n\n this.finalCalled = false; // drain event flag.\n\n this.needDrain = false; // at the start of calling end()\n\n this.ending = false; // when end() has been called, and returned\n\n this.ended = false; // when 'finish' is emitted\n\n this.finished = false; // has it been destroyed\n\n this.destroyed = false; // should we decode strings into buffers before passing to _write?\n // this is here so that some node-core streams can optimize string\n // handling at a lower level.\n\n var noDecode = options.decodeStrings === false;\n this.decodeStrings = !noDecode; // Crypto is kind of old and crusty. Historically, its default string\n // encoding is 'binary' so we have to make this configurable.\n // Everything else in the universe uses 'utf8', though.\n\n this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement\n // of how much we're waiting to get pushed to some underlying\n // socket or file.\n\n this.length = 0; // a flag to see when we're in the middle of a write.\n\n this.writing = false; // when true all writes will be buffered until .uncork() call\n\n this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,\n // or on a later tick. We set this to true at first, because any\n // actions that shouldn't happen until \"later\" should generally also\n // not happen before the first write call.\n\n this.sync = true; // a flag to know if we're processing previously buffered items, which\n // may call the _write() callback in the same tick, so that we don't\n // end up in an overlapped onwrite situation.\n\n this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)\n\n this.onwrite = function (er) {\n onwrite(stream, er);\n }; // the callback that the user supplies to write(chunk,encoding,cb)\n\n\n this.writecb = null; // the amount that is being written when _write is called.\n\n this.writelen = 0;\n this.bufferedRequest = null;\n this.lastBufferedRequest = null; // number of pending user-supplied write callbacks\n // this must be 0 before 'finish' can be emitted\n\n this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs\n // This is relevant for synchronous Transform streams\n\n this.prefinished = false; // True if the error was already emitted and should not be thrown again\n\n this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.\n\n this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')\n\n this.autoDestroy = !!options.autoDestroy; // count buffered requests\n\n this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always\n // one allocated and free to use, and we maintain at most two\n\n this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n var current = this.bufferedRequest;\n var out = [];\n\n while (current) {\n out.push(current);\n current = current.next;\n }\n\n return out;\n};\n\n(function () {\n try {\n Object.defineProperty(WritableState.prototype, 'buffer', {\n get: internalUtil.deprecate(function writableStateBufferGetter() {\n return this.getBuffer();\n }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n });\n } catch (_) {}\n})(); // Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\n\n\nvar realHasInstance;\n\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n realHasInstance = Function.prototype[Symbol.hasInstance];\n Object.defineProperty(Writable, Symbol.hasInstance, {\n value: function value(object) {\n if (realHasInstance.call(this, object)) return true;\n if (this !== Writable) return false;\n return object && object._writableState instanceof WritableState;\n }\n });\n} else {\n realHasInstance = function realHasInstance(object) {\n return object instanceof this;\n };\n}\n\nfunction Writable(options) {\n Duplex = Duplex || require('./_stream_duplex'); // Writable ctor is applied to Duplexes, too.\n // `realHasInstance` is necessary because using plain `instanceof`\n // would return false, as no `_writableState` property is attached.\n // Trying to use the custom `instanceof` for Writable here will also break the\n // Node.js LazyTransform implementation, which has a non-trivial getter for\n // `_writableState` that would lead to infinite recursion.\n // Checking for a Stream.Duplex instance is faster here instead of inside\n // the WritableState constructor, at least with V8 6.5\n\n var isDuplex = this instanceof Duplex;\n if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);\n this._writableState = new WritableState(options, this, isDuplex); // legacy.\n\n this.writable = true;\n\n if (options) {\n if (typeof options.write === 'function') this._write = options.write;\n if (typeof options.writev === 'function') this._writev = options.writev;\n if (typeof options.destroy === 'function') this._destroy = options.destroy;\n if (typeof options.final === 'function') this._final = options.final;\n }\n\n Stream.call(this);\n} // Otherwise people can pipe Writable streams, which is just wrong.\n\n\nWritable.prototype.pipe = function () {\n errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());\n};\n\nfunction writeAfterEnd(stream, cb) {\n var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb\n\n errorOrDestroy(stream, er);\n process.nextTick(cb, er);\n} // Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\n\n\nfunction validChunk(stream, state, chunk, cb) {\n var er;\n\n if (chunk === null) {\n er = new ERR_STREAM_NULL_VALUES();\n } else if (typeof chunk !== 'string' && !state.objectMode) {\n er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);\n }\n\n if (er) {\n errorOrDestroy(stream, er);\n process.nextTick(cb, er);\n return false;\n }\n\n return true;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n var state = this._writableState;\n var ret = false;\n\n var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n if (isBuf && !Buffer.isBuffer(chunk)) {\n chunk = _uint8ArrayToBuffer(chunk);\n }\n\n if (typeof encoding === 'function') {\n cb = encoding;\n encoding = null;\n }\n\n if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n if (typeof cb !== 'function') cb = nop;\n if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n state.pendingcb++;\n ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n }\n return ret;\n};\n\nWritable.prototype.cork = function () {\n this._writableState.corked++;\n};\n\nWritable.prototype.uncork = function () {\n var state = this._writableState;\n\n if (state.corked) {\n state.corked--;\n if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n // node::ParseEncoding() requires lower case.\n if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);\n this._writableState.defaultEncoding = encoding;\n return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableBuffer', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState && this._writableState.getBuffer();\n }\n});\n\nfunction decodeChunk(state, chunk, encoding) {\n if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n chunk = Buffer.from(chunk, encoding);\n }\n\n return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.highWaterMark;\n }\n}); // if we're already writing something, then just put this\n// in the queue, and wait our turn. Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\n\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n if (!isBuf) {\n var newChunk = decodeChunk(state, chunk, encoding);\n\n if (chunk !== newChunk) {\n isBuf = true;\n encoding = 'buffer';\n chunk = newChunk;\n }\n }\n\n var len = state.objectMode ? 1 : chunk.length;\n state.length += len;\n var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.\n\n if (!ret) state.needDrain = true;\n\n if (state.writing || state.corked) {\n var last = state.lastBufferedRequest;\n state.lastBufferedRequest = {\n chunk: chunk,\n encoding: encoding,\n isBuf: isBuf,\n callback: cb,\n next: null\n };\n\n if (last) {\n last.next = state.lastBufferedRequest;\n } else {\n state.bufferedRequest = state.lastBufferedRequest;\n }\n\n state.bufferedRequestCount += 1;\n } else {\n doWrite(stream, state, false, len, chunk, encoding, cb);\n }\n\n return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n state.writelen = len;\n state.writecb = cb;\n state.writing = true;\n state.sync = true;\n if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n state.sync = false;\n}\n\nfunction onwriteError(stream, state, sync, er, cb) {\n --state.pendingcb;\n\n if (sync) {\n // defer the callback if we are being called synchronously\n // to avoid piling up things on the stack\n process.nextTick(cb, er); // this can emit finish, and it will always happen\n // after error\n\n process.nextTick(finishMaybe, stream, state);\n stream._writableState.errorEmitted = true;\n errorOrDestroy(stream, er);\n } else {\n // the caller expect this to happen before if\n // it is async\n cb(er);\n stream._writableState.errorEmitted = true;\n errorOrDestroy(stream, er); // this can emit finish, but finish must\n // always follow error\n\n finishMaybe(stream, state);\n }\n}\n\nfunction onwriteStateUpdate(state) {\n state.writing = false;\n state.writecb = null;\n state.length -= state.writelen;\n state.writelen = 0;\n}\n\nfunction onwrite(stream, er) {\n var state = stream._writableState;\n var sync = state.sync;\n var cb = state.writecb;\n if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();\n onwriteStateUpdate(state);\n if (er) onwriteError(stream, state, sync, er, cb);else {\n // Check if we're actually ready to finish, but don't emit yet\n var finished = needFinish(state) || stream.destroyed;\n\n if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {\n clearBuffer(stream, state);\n }\n\n if (sync) {\n process.nextTick(afterWrite, stream, state, finished, cb);\n } else {\n afterWrite(stream, state, finished, cb);\n }\n }\n}\n\nfunction afterWrite(stream, state, finished, cb) {\n if (!finished) onwriteDrain(stream, state);\n state.pendingcb--;\n cb();\n finishMaybe(stream, state);\n} // Must force callback to be called on nextTick, so that we don't\n// emit 'drain' before the write() consumer gets the 'false' return\n// value, and has a chance to attach a 'drain' listener.\n\n\nfunction onwriteDrain(stream, state) {\n if (state.length === 0 && state.needDrain) {\n state.needDrain = false;\n stream.emit('drain');\n }\n} // if there's something in the buffer waiting, then process it\n\n\nfunction clearBuffer(stream, state) {\n state.bufferProcessing = true;\n var entry = state.bufferedRequest;\n\n if (stream._writev && entry && entry.next) {\n // Fast case, write everything using _writev()\n var l = state.bufferedRequestCount;\n var buffer = new Array(l);\n var holder = state.corkedRequestsFree;\n holder.entry = entry;\n var count = 0;\n var allBuffers = true;\n\n while (entry) {\n buffer[count] = entry;\n if (!entry.isBuf) allBuffers = false;\n entry = entry.next;\n count += 1;\n }\n\n buffer.allBuffers = allBuffers;\n doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time\n // as the hot path ends with doWrite\n\n state.pendingcb++;\n state.lastBufferedRequest = null;\n\n if (holder.next) {\n state.corkedRequestsFree = holder.next;\n holder.next = null;\n } else {\n state.corkedRequestsFree = new CorkedRequest(state);\n }\n\n state.bufferedRequestCount = 0;\n } else {\n // Slow case, write chunks one-by-one\n while (entry) {\n var chunk = entry.chunk;\n var encoding = entry.encoding;\n var cb = entry.callback;\n var len = state.objectMode ? 1 : chunk.length;\n doWrite(stream, state, false, len, chunk, encoding, cb);\n entry = entry.next;\n state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then\n // it means that we need to wait until it does.\n // also, that means that the chunk and cb are currently\n // being processed, so move the buffer counter past them.\n\n if (state.writing) {\n break;\n }\n }\n\n if (entry === null) state.lastBufferedRequest = null;\n }\n\n state.bufferedRequest = entry;\n state.bufferProcessing = false;\n}\n\nWritable.prototype._write = function (chunk, encoding, cb) {\n cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));\n};\n\nWritable.prototype._writev = null;\n\nWritable.prototype.end = function (chunk, encoding, cb) {\n var state = this._writableState;\n\n if (typeof chunk === 'function') {\n cb = chunk;\n chunk = null;\n encoding = null;\n } else if (typeof encoding === 'function') {\n cb = encoding;\n encoding = null;\n }\n\n if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks\n\n if (state.corked) {\n state.corked = 1;\n this.uncork();\n } // ignore unnecessary end() calls.\n\n\n if (!state.ending) endWritable(this, state, cb);\n return this;\n};\n\nObject.defineProperty(Writable.prototype, 'writableLength', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n return this._writableState.length;\n }\n});\n\nfunction needFinish(state) {\n return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;\n}\n\nfunction callFinal(stream, state) {\n stream._final(function (err) {\n state.pendingcb--;\n\n if (err) {\n errorOrDestroy(stream, err);\n }\n\n state.prefinished = true;\n stream.emit('prefinish');\n finishMaybe(stream, state);\n });\n}\n\nfunction prefinish(stream, state) {\n if (!state.prefinished && !state.finalCalled) {\n if (typeof stream._final === 'function' && !state.destroyed) {\n state.pendingcb++;\n state.finalCalled = true;\n process.nextTick(callFinal, stream, state);\n } else {\n state.prefinished = true;\n stream.emit('prefinish');\n }\n }\n}\n\nfunction finishMaybe(stream, state) {\n var need = needFinish(state);\n\n if (need) {\n prefinish(stream, state);\n\n if (state.pendingcb === 0) {\n state.finished = true;\n stream.emit('finish');\n\n if (state.autoDestroy) {\n // In case of duplex streams we need a way to detect\n // if the readable side is ready for autoDestroy as well\n var rState = stream._readableState;\n\n if (!rState || rState.autoDestroy && rState.endEmitted) {\n stream.destroy();\n }\n }\n }\n }\n\n return need;\n}\n\nfunction endWritable(stream, state, cb) {\n state.ending = true;\n finishMaybe(stream, state);\n\n if (cb) {\n if (state.finished) process.nextTick(cb);else stream.once('finish', cb);\n }\n\n state.ended = true;\n stream.writable = false;\n}\n\nfunction onCorkedFinish(corkReq, state, err) {\n var entry = corkReq.entry;\n corkReq.entry = null;\n\n while (entry) {\n var cb = entry.callback;\n state.pendingcb--;\n cb(err);\n entry = entry.next;\n } // reuse the free corkReq.\n\n\n state.corkedRequestsFree.next = corkReq;\n}\n\nObject.defineProperty(Writable.prototype, 'destroyed', {\n // making it explicit this property is not enumerable\n // because otherwise some prototype manipulation in\n // userland will fail\n enumerable: false,\n get: function get() {\n if (this._writableState === undefined) {\n return false;\n }\n\n return this._writableState.destroyed;\n },\n set: function set(value) {\n // we ignore the value if the stream\n // has not been initialized yet\n if (!this._writableState) {\n return;\n } // backward compatibility, the user is explicitly\n // managing destroyed\n\n\n this._writableState.destroyed = value;\n }\n});\nWritable.prototype.destroy = destroyImpl.destroy;\nWritable.prototype._undestroy = destroyImpl.undestroy;\n\nWritable.prototype._destroy = function (err, cb) {\n cb(err);\n};","'use strict';\n\nvar _Object$setPrototypeO;\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nvar finished = require('./end-of-stream');\n\nvar kLastResolve = Symbol('lastResolve');\nvar kLastReject = Symbol('lastReject');\nvar kError = Symbol('error');\nvar kEnded = Symbol('ended');\nvar kLastPromise = Symbol('lastPromise');\nvar kHandlePromise = Symbol('handlePromise');\nvar kStream = Symbol('stream');\n\nfunction createIterResult(value, done) {\n return {\n value: value,\n done: done\n };\n}\n\nfunction readAndResolve(iter) {\n var resolve = iter[kLastResolve];\n\n if (resolve !== null) {\n var data = iter[kStream].read(); // we defer if data is null\n // we can be expecting either 'end' or\n // 'error'\n\n if (data !== null) {\n iter[kLastPromise] = null;\n iter[kLastResolve] = null;\n iter[kLastReject] = null;\n resolve(createIterResult(data, false));\n }\n }\n}\n\nfunction onReadable(iter) {\n // we wait for the next tick, because it might\n // emit an error with process.nextTick\n process.nextTick(readAndResolve, iter);\n}\n\nfunction wrapForNext(lastPromise, iter) {\n return function (resolve, reject) {\n lastPromise.then(function () {\n if (iter[kEnded]) {\n resolve(createIterResult(undefined, true));\n return;\n }\n\n iter[kHandlePromise](resolve, reject);\n }, reject);\n };\n}\n\nvar AsyncIteratorPrototype = Object.getPrototypeOf(function () {});\nvar ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {\n get stream() {\n return this[kStream];\n },\n\n next: function next() {\n var _this = this;\n\n // if we have detected an error in the meanwhile\n // reject straight away\n var error = this[kError];\n\n if (error !== null) {\n return Promise.reject(error);\n }\n\n if (this[kEnded]) {\n return Promise.resolve(createIterResult(undefined, true));\n }\n\n if (this[kStream].destroyed) {\n // We need to defer via nextTick because if .destroy(err) is\n // called, the error will be emitted via nextTick, and\n // we cannot guarantee that there is no error lingering around\n // waiting to be emitted.\n return new Promise(function (resolve, reject) {\n process.nextTick(function () {\n if (_this[kError]) {\n reject(_this[kError]);\n } else {\n resolve(createIterResult(undefined, true));\n }\n });\n });\n } // if we have multiple next() calls\n // we will wait for the previous Promise to finish\n // this logic is optimized to support for await loops,\n // where next() is only called once at a time\n\n\n var lastPromise = this[kLastPromise];\n var promise;\n\n if (lastPromise) {\n promise = new Promise(wrapForNext(lastPromise, this));\n } else {\n // fast path needed to support multiple this.push()\n // without triggering the next() queue\n var data = this[kStream].read();\n\n if (data !== null) {\n return Promise.resolve(createIterResult(data, false));\n }\n\n promise = new Promise(this[kHandlePromise]);\n }\n\n this[kLastPromise] = promise;\n return promise;\n }\n}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {\n return this;\n}), _defineProperty(_Object$setPrototypeO, \"return\", function _return() {\n var _this2 = this;\n\n // destroy(err, cb) is a private API\n // we can guarantee we have that here, because we control the\n // Readable class this is attached to\n return new Promise(function (resolve, reject) {\n _this2[kStream].destroy(null, function (err) {\n if (err) {\n reject(err);\n return;\n }\n\n resolve(createIterResult(undefined, true));\n });\n });\n}), _Object$setPrototypeO), AsyncIteratorPrototype);\n\nvar createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {\n var _Object$create;\n\n var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {\n value: stream,\n writable: true\n }), _defineProperty(_Object$create, kLastResolve, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kLastReject, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kError, {\n value: null,\n writable: true\n }), _defineProperty(_Object$create, kEnded, {\n value: stream._readableState.endEmitted,\n writable: true\n }), _defineProperty(_Object$create, kHandlePromise, {\n value: function value(resolve, reject) {\n var data = iterator[kStream].read();\n\n if (data) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n resolve(createIterResult(data, false));\n } else {\n iterator[kLastResolve] = resolve;\n iterator[kLastReject] = reject;\n }\n },\n writable: true\n }), _Object$create));\n iterator[kLastPromise] = null;\n finished(stream, function (err) {\n if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {\n var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise\n // returned by next() and store the error\n\n if (reject !== null) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n reject(err);\n }\n\n iterator[kError] = err;\n return;\n }\n\n var resolve = iterator[kLastResolve];\n\n if (resolve !== null) {\n iterator[kLastPromise] = null;\n iterator[kLastResolve] = null;\n iterator[kLastReject] = null;\n resolve(createIterResult(undefined, true));\n }\n\n iterator[kEnded] = true;\n });\n stream.on('readable', onReadable.bind(null, iterator));\n return iterator;\n};\n\nmodule.exports = createReadableStreamAsyncIterator;","'use strict';\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\nvar _require = require('buffer'),\n Buffer = _require.Buffer;\n\nvar _require2 = require('util'),\n inspect = _require2.inspect;\n\nvar custom = inspect && inspect.custom || 'inspect';\n\nfunction copyBuffer(src, target, offset) {\n Buffer.prototype.copy.call(src, target, offset);\n}\n\nmodule.exports =\n/*#__PURE__*/\nfunction () {\n function BufferList() {\n _classCallCheck(this, BufferList);\n\n this.head = null;\n this.tail = null;\n this.length = 0;\n }\n\n _createClass(BufferList, [{\n key: \"push\",\n value: function push(v) {\n var entry = {\n data: v,\n next: null\n };\n if (this.length > 0) this.tail.next = entry;else this.head = entry;\n this.tail = entry;\n ++this.length;\n }\n }, {\n key: \"unshift\",\n value: function unshift(v) {\n var entry = {\n data: v,\n next: this.head\n };\n if (this.length === 0) this.tail = entry;\n this.head = entry;\n ++this.length;\n }\n }, {\n key: \"shift\",\n value: function shift() {\n if (this.length === 0) return;\n var ret = this.head.data;\n if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;\n --this.length;\n return ret;\n }\n }, {\n key: \"clear\",\n value: function clear() {\n this.head = this.tail = null;\n this.length = 0;\n }\n }, {\n key: \"join\",\n value: function join(s) {\n if (this.length === 0) return '';\n var p = this.head;\n var ret = '' + p.data;\n\n while (p = p.next) {\n ret += s + p.data;\n }\n\n return ret;\n }\n }, {\n key: \"concat\",\n value: function concat(n) {\n if (this.length === 0) return Buffer.alloc(0);\n var ret = Buffer.allocUnsafe(n >>> 0);\n var p = this.head;\n var i = 0;\n\n while (p) {\n copyBuffer(p.data, ret, i);\n i += p.data.length;\n p = p.next;\n }\n\n return ret;\n } // Consumes a specified amount of bytes or characters from the buffered data.\n\n }, {\n key: \"consume\",\n value: function consume(n, hasStrings) {\n var ret;\n\n if (n < this.head.data.length) {\n // `slice` is the same for buffers and strings.\n ret = this.head.data.slice(0, n);\n this.head.data = this.head.data.slice(n);\n } else if (n === this.head.data.length) {\n // First chunk is a perfect match.\n ret = this.shift();\n } else {\n // Result spans more than one buffer.\n ret = hasStrings ? this._getString(n) : this._getBuffer(n);\n }\n\n return ret;\n }\n }, {\n key: \"first\",\n value: function first() {\n return this.head.data;\n } // Consumes a specified amount of characters from the buffered data.\n\n }, {\n key: \"_getString\",\n value: function _getString(n) {\n var p = this.head;\n var c = 1;\n var ret = p.data;\n n -= ret.length;\n\n while (p = p.next) {\n var str = p.data;\n var nb = n > str.length ? str.length : n;\n if (nb === str.length) ret += str;else ret += str.slice(0, n);\n n -= nb;\n\n if (n === 0) {\n if (nb === str.length) {\n ++c;\n if (p.next) this.head = p.next;else this.head = this.tail = null;\n } else {\n this.head = p;\n p.data = str.slice(nb);\n }\n\n break;\n }\n\n ++c;\n }\n\n this.length -= c;\n return ret;\n } // Consumes a specified amount of bytes from the buffered data.\n\n }, {\n key: \"_getBuffer\",\n value: function _getBuffer(n) {\n var ret = Buffer.allocUnsafe(n);\n var p = this.head;\n var c = 1;\n p.data.copy(ret);\n n -= p.data.length;\n\n while (p = p.next) {\n var buf = p.data;\n var nb = n > buf.length ? buf.length : n;\n buf.copy(ret, ret.length - n, 0, nb);\n n -= nb;\n\n if (n === 0) {\n if (nb === buf.length) {\n ++c;\n if (p.next) this.head = p.next;else this.head = this.tail = null;\n } else {\n this.head = p;\n p.data = buf.slice(nb);\n }\n\n break;\n }\n\n ++c;\n }\n\n this.length -= c;\n return ret;\n } // Make sure the linked list only shows the minimal necessary information.\n\n }, {\n key: custom,\n value: function value(_, options) {\n return inspect(this, _objectSpread({}, options, {\n // Only inspect one level.\n depth: 0,\n // It should not recurse.\n customInspect: false\n }));\n }\n }]);\n\n return BufferList;\n}();","'use strict'; // undocumented cb() API, needed for core, not for public API\n\nfunction destroy(err, cb) {\n var _this = this;\n\n var readableDestroyed = this._readableState && this._readableState.destroyed;\n var writableDestroyed = this._writableState && this._writableState.destroyed;\n\n if (readableDestroyed || writableDestroyed) {\n if (cb) {\n cb(err);\n } else if (err) {\n if (!this._writableState) {\n process.nextTick(emitErrorNT, this, err);\n } else if (!this._writableState.errorEmitted) {\n this._writableState.errorEmitted = true;\n process.nextTick(emitErrorNT, this, err);\n }\n }\n\n return this;\n } // we set destroyed to true before firing error callbacks in order\n // to make it re-entrance safe in case destroy() is called within callbacks\n\n\n if (this._readableState) {\n this._readableState.destroyed = true;\n } // if this is a duplex stream mark the writable part as destroyed as well\n\n\n if (this._writableState) {\n this._writableState.destroyed = true;\n }\n\n this._destroy(err || null, function (err) {\n if (!cb && err) {\n if (!_this._writableState) {\n process.nextTick(emitErrorAndCloseNT, _this, err);\n } else if (!_this._writableState.errorEmitted) {\n _this._writableState.errorEmitted = true;\n process.nextTick(emitErrorAndCloseNT, _this, err);\n } else {\n process.nextTick(emitCloseNT, _this);\n }\n } else if (cb) {\n process.nextTick(emitCloseNT, _this);\n cb(err);\n } else {\n process.nextTick(emitCloseNT, _this);\n }\n });\n\n return this;\n}\n\nfunction emitErrorAndCloseNT(self, err) {\n emitErrorNT(self, err);\n emitCloseNT(self);\n}\n\nfunction emitCloseNT(self) {\n if (self._writableState && !self._writableState.emitClose) return;\n if (self._readableState && !self._readableState.emitClose) return;\n self.emit('close');\n}\n\nfunction undestroy() {\n if (this._readableState) {\n this._readableState.destroyed = false;\n this._readableState.reading = false;\n this._readableState.ended = false;\n this._readableState.endEmitted = false;\n }\n\n if (this._writableState) {\n this._writableState.destroyed = false;\n this._writableState.ended = false;\n this._writableState.ending = false;\n this._writableState.finalCalled = false;\n this._writableState.prefinished = false;\n this._writableState.finished = false;\n this._writableState.errorEmitted = false;\n }\n}\n\nfunction emitErrorNT(self, err) {\n self.emit('error', err);\n}\n\nfunction errorOrDestroy(stream, err) {\n // We have tests that rely on errors being emitted\n // in the same tick, so changing this is semver major.\n // For now when you opt-in to autoDestroy we allow\n // the error to be emitted nextTick. In a future\n // semver major update we should change the default to this.\n var rState = stream._readableState;\n var wState = stream._writableState;\n if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);\n}\n\nmodule.exports = {\n destroy: destroy,\n undestroy: undestroy,\n errorOrDestroy: errorOrDestroy\n};","// Ported from https://github.com/mafintosh/end-of-stream with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar ERR_STREAM_PREMATURE_CLOSE = require('../../../errors').codes.ERR_STREAM_PREMATURE_CLOSE;\n\nfunction once(callback) {\n var called = false;\n return function () {\n if (called) return;\n called = true;\n\n for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n args[_key] = arguments[_key];\n }\n\n callback.apply(this, args);\n };\n}\n\nfunction noop() {}\n\nfunction isRequest(stream) {\n return stream.setHeader && typeof stream.abort === 'function';\n}\n\nfunction eos(stream, opts, callback) {\n if (typeof opts === 'function') return eos(stream, null, opts);\n if (!opts) opts = {};\n callback = once(callback || noop);\n var readable = opts.readable || opts.readable !== false && stream.readable;\n var writable = opts.writable || opts.writable !== false && stream.writable;\n\n var onlegacyfinish = function onlegacyfinish() {\n if (!stream.writable) onfinish();\n };\n\n var writableEnded = stream._writableState && stream._writableState.finished;\n\n var onfinish = function onfinish() {\n writable = false;\n writableEnded = true;\n if (!readable) callback.call(stream);\n };\n\n var readableEnded = stream._readableState && stream._readableState.endEmitted;\n\n var onend = function onend() {\n readable = false;\n readableEnded = true;\n if (!writable) callback.call(stream);\n };\n\n var onerror = function onerror(err) {\n callback.call(stream, err);\n };\n\n var onclose = function onclose() {\n var err;\n\n if (readable && !readableEnded) {\n if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n return callback.call(stream, err);\n }\n\n if (writable && !writableEnded) {\n if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();\n return callback.call(stream, err);\n }\n };\n\n var onrequest = function onrequest() {\n stream.req.on('finish', onfinish);\n };\n\n if (isRequest(stream)) {\n stream.on('complete', onfinish);\n stream.on('abort', onclose);\n if (stream.req) onrequest();else stream.on('request', onrequest);\n } else if (writable && !stream._writableState) {\n // legacy streams\n stream.on('end', onlegacyfinish);\n stream.on('close', onlegacyfinish);\n }\n\n stream.on('end', onend);\n stream.on('finish', onfinish);\n if (opts.error !== false) stream.on('error', onerror);\n stream.on('close', onclose);\n return function () {\n stream.removeListener('complete', onfinish);\n stream.removeListener('abort', onclose);\n stream.removeListener('request', onrequest);\n if (stream.req) stream.req.removeListener('finish', onfinish);\n stream.removeListener('end', onlegacyfinish);\n stream.removeListener('close', onlegacyfinish);\n stream.removeListener('finish', onfinish);\n stream.removeListener('end', onend);\n stream.removeListener('error', onerror);\n stream.removeListener('close', onclose);\n };\n}\n\nmodule.exports = eos;","module.exports = function () {\n throw new Error('Readable.from is not available in the browser')\n};\n","// Ported from https://github.com/mafintosh/pump with\n// permission from the author, Mathias Buus (@mafintosh).\n'use strict';\n\nvar eos;\n\nfunction once(callback) {\n var called = false;\n return function () {\n if (called) return;\n called = true;\n callback.apply(void 0, arguments);\n };\n}\n\nvar _require$codes = require('../../../errors').codes,\n ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,\n ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;\n\nfunction noop(err) {\n // Rethrow the error if it exists to avoid swallowing it\n if (err) throw err;\n}\n\nfunction isRequest(stream) {\n return stream.setHeader && typeof stream.abort === 'function';\n}\n\nfunction destroyer(stream, reading, writing, callback) {\n callback = once(callback);\n var closed = false;\n stream.on('close', function () {\n closed = true;\n });\n if (eos === undefined) eos = require('./end-of-stream');\n eos(stream, {\n readable: reading,\n writable: writing\n }, function (err) {\n if (err) return callback(err);\n closed = true;\n callback();\n });\n var destroyed = false;\n return function (err) {\n if (closed) return;\n if (destroyed) return;\n destroyed = true; // request.destroy just do .end - .abort is what we want\n\n if (isRequest(stream)) return stream.abort();\n if (typeof stream.destroy === 'function') return stream.destroy();\n callback(err || new ERR_STREAM_DESTROYED('pipe'));\n };\n}\n\nfunction call(fn) {\n fn();\n}\n\nfunction pipe(from, to) {\n return from.pipe(to);\n}\n\nfunction popCallback(streams) {\n if (!streams.length) return noop;\n if (typeof streams[streams.length - 1] !== 'function') return noop;\n return streams.pop();\n}\n\nfunction pipeline() {\n for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {\n streams[_key] = arguments[_key];\n }\n\n var callback = popCallback(streams);\n if (Array.isArray(streams[0])) streams = streams[0];\n\n if (streams.length < 2) {\n throw new ERR_MISSING_ARGS('streams');\n }\n\n var error;\n var destroys = streams.map(function (stream, i) {\n var reading = i < streams.length - 1;\n var writing = i > 0;\n return destroyer(stream, reading, writing, function (err) {\n if (!error) error = err;\n if (err) destroys.forEach(call);\n if (reading) return;\n destroys.forEach(call);\n callback(error);\n });\n });\n return streams.reduce(pipe);\n}\n\nmodule.exports = pipeline;","'use strict';\n\nvar ERR_INVALID_OPT_VALUE = require('../../../errors').codes.ERR_INVALID_OPT_VALUE;\n\nfunction highWaterMarkFrom(options, isDuplex, duplexKey) {\n return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;\n}\n\nfunction getHighWaterMark(state, options, duplexKey, isDuplex) {\n var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);\n\n if (hwm != null) {\n if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {\n var name = isDuplex ? duplexKey : 'highWaterMark';\n throw new ERR_INVALID_OPT_VALUE(name, hwm);\n }\n\n return Math.floor(hwm);\n } // Default value\n\n\n return state.objectMode ? 16 : 16 * 1024;\n}\n\nmodule.exports = {\n getHighWaterMark: getHighWaterMark\n};","module.exports = require('events').EventEmitter;\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\nexports.finished = require('./lib/internal/streams/end-of-stream.js');\nexports.pipeline = require('./lib/internal/streams/pipeline.js');\n","'use strict'\nvar Buffer = require('buffer').Buffer\nvar inherits = require('inherits')\nvar HashBase = require('hash-base')\n\nvar ARRAY16 = new Array(16)\n\nvar zl = [\n 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,\n 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8,\n 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12,\n 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2,\n 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13\n]\n\nvar zr = [\n 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12,\n 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2,\n 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13,\n 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14,\n 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11\n]\n\nvar sl = [\n 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8,\n 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12,\n 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5,\n 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12,\n 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6\n]\n\nvar sr = [\n 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6,\n 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11,\n 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5,\n 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8,\n 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11\n]\n\nvar hl = [0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e]\nvar hr = [0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000]\n\nfunction RIPEMD160 () {\n HashBase.call(this, 64)\n\n // state\n this._a = 0x67452301\n this._b = 0xefcdab89\n this._c = 0x98badcfe\n this._d = 0x10325476\n this._e = 0xc3d2e1f0\n}\n\ninherits(RIPEMD160, HashBase)\n\nRIPEMD160.prototype._update = function () {\n var words = ARRAY16\n for (var j = 0; j < 16; ++j) words[j] = this._block.readInt32LE(j * 4)\n\n var al = this._a | 0\n var bl = this._b | 0\n var cl = this._c | 0\n var dl = this._d | 0\n var el = this._e | 0\n\n var ar = this._a | 0\n var br = this._b | 0\n var cr = this._c | 0\n var dr = this._d | 0\n var er = this._e | 0\n\n // computation\n for (var i = 0; i < 80; i += 1) {\n var tl\n var tr\n if (i < 16) {\n tl = fn1(al, bl, cl, dl, el, words[zl[i]], hl[0], sl[i])\n tr = fn5(ar, br, cr, dr, er, words[zr[i]], hr[0], sr[i])\n } else if (i < 32) {\n tl = fn2(al, bl, cl, dl, el, words[zl[i]], hl[1], sl[i])\n tr = fn4(ar, br, cr, dr, er, words[zr[i]], hr[1], sr[i])\n } else if (i < 48) {\n tl = fn3(al, bl, cl, dl, el, words[zl[i]], hl[2], sl[i])\n tr = fn3(ar, br, cr, dr, er, words[zr[i]], hr[2], sr[i])\n } else if (i < 64) {\n tl = fn4(al, bl, cl, dl, el, words[zl[i]], hl[3], sl[i])\n tr = fn2(ar, br, cr, dr, er, words[zr[i]], hr[3], sr[i])\n } else { // if (i<80) {\n tl = fn5(al, bl, cl, dl, el, words[zl[i]], hl[4], sl[i])\n tr = fn1(ar, br, cr, dr, er, words[zr[i]], hr[4], sr[i])\n }\n\n al = el\n el = dl\n dl = rotl(cl, 10)\n cl = bl\n bl = tl\n\n ar = er\n er = dr\n dr = rotl(cr, 10)\n cr = br\n br = tr\n }\n\n // update state\n var t = (this._b + cl + dr) | 0\n this._b = (this._c + dl + er) | 0\n this._c = (this._d + el + ar) | 0\n this._d = (this._e + al + br) | 0\n this._e = (this._a + bl + cr) | 0\n this._a = t\n}\n\nRIPEMD160.prototype._digest = function () {\n // create padding and handle blocks\n this._block[this._blockOffset++] = 0x80\n if (this._blockOffset > 56) {\n this._block.fill(0, this._blockOffset, 64)\n this._update()\n this._blockOffset = 0\n }\n\n this._block.fill(0, this._blockOffset, 56)\n this._block.writeUInt32LE(this._length[0], 56)\n this._block.writeUInt32LE(this._length[1], 60)\n this._update()\n\n // produce result\n var buffer = Buffer.alloc ? Buffer.alloc(20) : new Buffer(20)\n buffer.writeInt32LE(this._a, 0)\n buffer.writeInt32LE(this._b, 4)\n buffer.writeInt32LE(this._c, 8)\n buffer.writeInt32LE(this._d, 12)\n buffer.writeInt32LE(this._e, 16)\n return buffer\n}\n\nfunction rotl (x, n) {\n return (x << n) | (x >>> (32 - n))\n}\n\nfunction fn1 (a, b, c, d, e, m, k, s) {\n return (rotl((a + (b ^ c ^ d) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn2 (a, b, c, d, e, m, k, s) {\n return (rotl((a + ((b & c) | ((~b) & d)) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn3 (a, b, c, d, e, m, k, s) {\n return (rotl((a + ((b | (~c)) ^ d) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn4 (a, b, c, d, e, m, k, s) {\n return (rotl((a + ((b & d) | (c & (~d))) + m + k) | 0, s) + e) | 0\n}\n\nfunction fn5 (a, b, c, d, e, m, k, s) {\n return (rotl((a + (b ^ (c | (~d))) + m + k) | 0, s) + e) | 0\n}\n\nmodule.exports = RIPEMD160\n","import * as assert from 'assert'\n\nimport {\n codec,\n encodeSeed,\n decodeSeed,\n encodeAccountID,\n decodeAccountID,\n encodeNodePublic,\n decodeNodePublic,\n encodeAccountPublic,\n decodeAccountPublic,\n isValidClassicAddress,\n} from './xrp-codec'\n\nconst PREFIX_BYTES = {\n // 5, 68\n main: Buffer.from([0x05, 0x44]),\n // 4, 147\n test: Buffer.from([0x04, 0x93]),\n}\n\nconst MAX_32_BIT_UNSIGNED_INT = 4294967295\n\nfunction classicAddressToXAddress(\n classicAddress: string,\n tag: number | false,\n test: boolean,\n): string {\n const accountId = decodeAccountID(classicAddress)\n return encodeXAddress(accountId, tag, test)\n}\n\nfunction encodeXAddress(\n accountId: Buffer,\n tag: number | false,\n test: boolean,\n): string {\n if (accountId.length !== 20) {\n // RIPEMD160 is 160 bits = 20 bytes\n throw new Error('Account ID must be 20 bytes')\n }\n if (tag > MAX_32_BIT_UNSIGNED_INT) {\n throw new Error('Invalid tag')\n }\n const theTag = tag || 0\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Passing null is a common js mistake\n const flag = tag === false || tag == null ? 0 : 1\n /* eslint-disable no-bitwise ---\n * need to use bitwise operations here */\n const bytes = Buffer.concat([\n test ? PREFIX_BYTES.test : PREFIX_BYTES.main,\n accountId,\n Buffer.from([\n // 0x00 if no tag, 0x01 if 32-bit tag\n flag,\n // first byte\n theTag & 0xff,\n // second byte\n (theTag >> 8) & 0xff,\n // third byte\n (theTag >> 16) & 0xff,\n // fourth byte\n (theTag >> 24) & 0xff,\n 0,\n 0,\n 0,\n // four zero bytes (reserved for 64-bit tags)\n 0,\n ]),\n ])\n /* eslint-enable no-bitwise */\n return codec.encodeChecked(bytes)\n}\n\nfunction xAddressToClassicAddress(xAddress: string): {\n classicAddress: string\n tag: number | false\n test: boolean\n} {\n /* eslint-disable @typescript-eslint/naming-convention --\n * TODO 'test' should be something like 'isTest', do this later\n */\n const { accountId, tag, test } = decodeXAddress(xAddress)\n /* eslint-enable @typescript-eslint/naming-convention */\n const classicAddress = encodeAccountID(accountId)\n return {\n classicAddress,\n tag,\n test,\n }\n}\n\nfunction decodeXAddress(xAddress: string): {\n accountId: Buffer\n tag: number | false\n test: boolean\n} {\n const decoded = codec.decodeChecked(xAddress)\n /* eslint-disable @typescript-eslint/naming-convention --\n * TODO 'test' should be something like 'isTest', do this later\n */\n const test = isBufferForTestAddress(decoded)\n /* eslint-enable @typescript-eslint/naming-convention */\n const accountId = decoded.slice(2, 22)\n const tag = tagFromBuffer(decoded)\n return {\n accountId,\n tag,\n test,\n }\n}\n\nfunction isBufferForTestAddress(buf: Buffer): boolean {\n const decodedPrefix = buf.slice(0, 2)\n if (PREFIX_BYTES.main.equals(decodedPrefix)) {\n return false\n }\n if (PREFIX_BYTES.test.equals(decodedPrefix)) {\n return true\n }\n\n throw new Error('Invalid X-address: bad prefix')\n}\n\nfunction tagFromBuffer(buf: Buffer): number | false {\n const flag = buf[22]\n if (flag >= 2) {\n // No support for 64-bit tags at this time\n throw new Error('Unsupported X-address')\n }\n if (flag === 1) {\n // Little-endian to big-endian\n return buf[23] + buf[24] * 0x100 + buf[25] * 0x10000 + buf[26] * 0x1000000\n }\n assert.strictEqual(flag, 0, 'flag must be zero to indicate no tag')\n assert.ok(\n Buffer.from('0000000000000000', 'hex').equals(buf.slice(23, 23 + 8)),\n 'remaining bytes must be zero',\n )\n return false\n}\n\nfunction isValidXAddress(xAddress: string): boolean {\n try {\n decodeXAddress(xAddress)\n } catch (_error) {\n return false\n }\n return true\n}\n\nexport {\n // Codec with XRP alphabet\n codec,\n // Encode entropy as a \"seed\"\n encodeSeed,\n // Decode a seed into an object with its version, type, and bytes\n decodeSeed,\n // Encode bytes as a classic address (r...)\n encodeAccountID,\n // Decode a classic address to its raw bytes\n decodeAccountID,\n // Encode bytes to XRP Ledger node public key format\n encodeNodePublic,\n // Decode an XRP Ledger node public key into its raw bytes\n decodeNodePublic,\n // Encode a public key, as for payment channels\n encodeAccountPublic,\n // Decode a public key, as for payment channels\n decodeAccountPublic,\n // Check whether a classic address (r...) is valid\n isValidClassicAddress,\n // Derive X-address from classic address, tag, and network ID\n classicAddressToXAddress,\n // Encode account ID, tag, and network ID to X-address\n encodeXAddress,\n // Decode X-address to account ID, tag, and network ID\n xAddressToClassicAddress,\n // Convert X-address to classic address, tag, and network ID\n decodeXAddress,\n // Check whether an X-address (X...) is valid\n isValidXAddress,\n}\n","type Sequence = number[] | Buffer | Uint8Array\n\n/**\n * Check whether two sequences (e.g. Arrays of numbers) are equal.\n *\n * @param arr1 - One of the arrays to compare.\n * @param arr2 - The other array to compare.\n */\nexport function seqEqual(arr1: Sequence, arr2: Sequence): boolean {\n if (arr1.length !== arr2.length) {\n return false\n }\n\n for (let i = 0; i < arr1.length; i++) {\n if (arr1[i] !== arr2[i]) {\n return false\n }\n }\n return true\n}\n\n/**\n * Check whether a value is a sequence (e.g. Array of numbers).\n *\n * @param val - The value to check.\n */\nfunction isSequence(val: Sequence | number): val is Sequence {\n return typeof val !== 'number'\n}\n\n/**\n * Concatenate all `arguments` into a single array. Each argument can be either\n * a single element or a sequence, which has a `length` property and supports\n * element retrieval via sequence[ix].\n *\n * > concatArgs(1, [2, 3], Buffer.from([4,5]), new Uint8Array([6, 7]));\n * [1,2,3,4,5,6,7]\n *\n * @param args - Concatenate of these args into a single array.\n * @returns Array of concatenated arguments\n */\nexport function concatArgs(...args: Array<number | Sequence>): number[] {\n const ret: number[] = []\n\n args.forEach((arg) => {\n if (isSequence(arg)) {\n for (const j of arg) {\n ret.push(j)\n }\n } else {\n ret.push(arg)\n }\n })\n return ret\n}\n","/**\n * Codec class\n */\n\nimport baseCodec = require('base-x')\nimport type { BaseConverter } from 'base-x'\nimport createHash = require('create-hash')\n\nimport { seqEqual, concatArgs } from './utils'\n\nclass Codec {\n private readonly _sha256: (bytes: Uint8Array) => Buffer\n private readonly _alphabet: string\n private readonly _codec: BaseConverter\n\n public constructor(options: {\n sha256: (bytes: Uint8Array) => Buffer\n alphabet: string\n }) {\n this._sha256 = options.sha256\n this._alphabet = options.alphabet\n this._codec = baseCodec(this._alphabet)\n }\n\n /**\n * Encoder.\n *\n * @param bytes - Buffer of data to encode.\n * @param opts - Options object including the version bytes and the expected length of the data to encode.\n */\n public encode(\n bytes: Buffer,\n opts: {\n versions: number[]\n expectedLength: number\n },\n ): string {\n const versions = opts.versions\n return this._encodeVersioned(bytes, versions, opts.expectedLength)\n }\n\n /**\n * Decoder.\n *\n * @param base58string - Base58Check-encoded string to decode.\n * @param opts - Options object including the version byte(s) and the expected length of the data after decoding.\n */\n /* eslint-disable max-lines-per-function --\n * TODO refactor */\n public decode(\n base58string: string,\n opts: {\n versions: Array<number | number[]>\n expectedLength?: number\n versionTypes?: ['ed25519', 'secp256k1']\n },\n ): {\n version: number[]\n bytes: Buffer\n type: 'ed25519' | 'secp256k1' | null\n } {\n const versions = opts.versions\n const types = opts.versionTypes\n\n const withoutSum = this.decodeChecked(base58string)\n\n if (versions.length > 1 && !opts.expectedLength) {\n throw new Error(\n 'expectedLength is required because there are >= 2 possible versions',\n )\n }\n const versionLengthGuess =\n typeof versions[0] === 'number' ? 1 : versions[0].length\n const payloadLength =\n opts.expectedLength ?? withoutSum.length - versionLengthGuess\n const versionBytes = withoutSum.slice(0, -payloadLength)\n const payload = withoutSum.slice(-payloadLength)\n\n for (let i = 0; i < versions.length; i++) {\n /* eslint-disable @typescript-eslint/consistent-type-assertions --\n * TODO refactor */\n const version: number[] = Array.isArray(versions[i])\n ? (versions[i] as number[])\n : [versions[i] as number]\n if (seqEqual(versionBytes, version)) {\n return {\n version,\n bytes: payload,\n type: types ? types[i] : null,\n }\n }\n /* eslint-enable @typescript-eslint/consistent-type-assertions */\n }\n\n throw new Error(\n 'version_invalid: version bytes do not match any of the provided version(s)',\n )\n }\n\n public encodeChecked(buffer: Buffer): string {\n const check = this._sha256(this._sha256(buffer)).slice(0, 4)\n return this._encodeRaw(Buffer.from(concatArgs(buffer, check)))\n }\n\n public decodeChecked(base58string: string): Buffer {\n const buffer = this._decodeRaw(base58string)\n if (buffer.length < 5) {\n throw new Error('invalid_input_size: decoded data must have length >= 5')\n }\n if (!this._verifyCheckSum(buffer)) {\n throw new Error('checksum_invalid')\n }\n return buffer.slice(0, -4)\n }\n\n private _encodeVersioned(\n bytes: Buffer,\n versions: number[],\n expectedLength: number,\n ): string {\n if (expectedLength && bytes.length !== expectedLength) {\n throw new Error(\n 'unexpected_payload_length: bytes.length does not match expectedLength.' +\n ' Ensure that the bytes are a Buffer.',\n )\n }\n return this.encodeChecked(Buffer.from(concatArgs(versions, bytes)))\n }\n\n private _encodeRaw(bytes: Buffer): string {\n return this._codec.encode(bytes)\n }\n /* eslint-enable max-lines-per-function */\n\n private _decodeRaw(base58string: string): Buffer {\n return this._codec.decode(base58string)\n }\n\n private _verifyCheckSum(bytes: Buffer): boolean {\n const computed = this._sha256(this._sha256(bytes.slice(0, -4))).slice(0, 4)\n const checksum = bytes.slice(-4)\n return seqEqual(computed, checksum)\n }\n}\n\n/**\n * XRP codec\n */\n\n// base58 encodings: https://xrpl.org/base58-encodings.html\n// Account address (20 bytes)\nconst ACCOUNT_ID = 0\n// Account public key (33 bytes)\nconst ACCOUNT_PUBLIC_KEY = 0x23\n// 33; Seed value (for secret keys) (16 bytes)\nconst FAMILY_SEED = 0x21\n// 28; Validation public key (33 bytes)\nconst NODE_PUBLIC = 0x1c\n\n// [1, 225, 75]\nconst ED25519_SEED = [0x01, 0xe1, 0x4b]\n\nconst codecOptions = {\n sha256(bytes: Uint8Array): Buffer {\n return createHash('sha256').update(Buffer.from(bytes)).digest()\n },\n alphabet: 'rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz',\n}\n\nconst codecWithXrpAlphabet = new Codec(codecOptions)\n\nexport const codec = codecWithXrpAlphabet\n\n// entropy is a Buffer of size 16\n// type is 'ed25519' or 'secp256k1'\nexport function encodeSeed(\n entropy: Buffer,\n type: 'ed25519' | 'secp256k1',\n): string {\n if (entropy.length !== 16) {\n throw new Error('entropy must have length 16')\n }\n const opts = {\n expectedLength: 16,\n\n // for secp256k1, use `FAMILY_SEED`\n versions: type === 'ed25519' ? ED25519_SEED : [FAMILY_SEED],\n }\n\n // prefixes entropy with version bytes\n return codecWithXrpAlphabet.encode(entropy, opts)\n}\n\nexport function decodeSeed(\n seed: string,\n opts: {\n versionTypes: ['ed25519', 'secp256k1']\n versions: Array<number | number[]>\n expectedLength: number\n } = {\n versionTypes: ['ed25519', 'secp256k1'],\n versions: [ED25519_SEED, FAMILY_SEED],\n expectedLength: 16,\n },\n): {\n version: number[]\n bytes: Buffer\n type: 'ed25519' | 'secp256k1' | null\n} {\n return codecWithXrpAlphabet.decode(seed, opts)\n}\n\nexport function encodeAccountID(bytes: Buffer): string {\n const opts = { versions: [ACCOUNT_ID], expectedLength: 20 }\n return codecWithXrpAlphabet.encode(bytes, opts)\n}\n\n/* eslint-disable import/no-unused-modules ---\n * unclear why this is aliased but we should keep it in case someone else is\n * importing it with the aliased name */\nexport const encodeAddress = encodeAccountID\n/* eslint-enable import/no-unused-modules */\n\nexport function decodeAccountID(accountId: string): Buffer {\n const opts = { versions: [ACCOUNT_ID], expectedLength: 20 }\n return codecWithXrpAlphabet.decode(accountId, opts).bytes\n}\n\n/* eslint-disable import/no-unused-modules ---\n * unclear why this is aliased but we should keep it in case someone else is\n * importing it with the aliased name */\nexport const decodeAddress = decodeAccountID\n/* eslint-enable import/no-unused-modules */\n\nexport function decodeNodePublic(base58string: string): Buffer {\n const opts = { versions: [NODE_PUBLIC], expectedLength: 33 }\n return codecWithXrpAlphabet.decode(base58string, opts).bytes\n}\n\nexport function encodeNodePublic(bytes: Buffer): string {\n const opts = { versions: [NODE_PUBLIC], expectedLength: 33 }\n return codecWithXrpAlphabet.encode(bytes, opts)\n}\n\nexport function encodeAccountPublic(bytes: Buffer): string {\n const opts = { versions: [ACCOUNT_PUBLIC_KEY], expectedLength: 33 }\n return codecWithXrpAlphabet.encode(bytes, opts)\n}\n\nexport function decodeAccountPublic(base58string: string): Buffer {\n const opts = { versions: [ACCOUNT_PUBLIC_KEY], expectedLength: 33 }\n return codecWithXrpAlphabet.decode(base58string, opts).bytes\n}\n\nexport function isValidClassicAddress(address: string): boolean {\n try {\n decodeAccountID(address)\n } catch (_error) {\n return false\n }\n return true\n}\n","/* eslint-disable func-style */\n\nimport { coreTypes } from './types'\nimport { BinaryParser } from './serdes/binary-parser'\nimport { AccountID } from './types/account-id'\nimport { HashPrefix } from './hash-prefixes'\nimport { BinarySerializer, BytesList } from './serdes/binary-serializer'\nimport { sha512Half, transactionID } from './hashes'\nimport { FieldInstance } from './enums'\nimport { STObject } from './types/st-object'\nimport { JsonObject } from './types/serialized-type'\nimport { Buffer } from 'buffer/'\nimport bigInt = require('big-integer')\n\n/**\n * Construct a BinaryParser\n *\n * @param bytes hex-string to construct BinaryParser from\n * @returns A BinaryParser\n */\nconst makeParser = (bytes: string): BinaryParser => new BinaryParser(bytes)\n\n/**\n * Parse BinaryParser into JSON\n *\n * @param parser BinaryParser object\n * @returns JSON for the bytes in the BinaryParser\n */\nconst readJSON = (parser: BinaryParser): JsonObject =>\n (parser.readType(coreTypes.STObject) as STObject).toJSON()\n\n/**\n * Parse a hex-string into its JSON interpretation\n *\n * @param bytes hex-string to parse into JSON\n * @returns JSON\n */\nconst binaryToJSON = (bytes: string): JsonObject => readJSON(makeParser(bytes))\n\n/**\n * Interface for passing parameters to SerializeObject\n *\n * @field set signingFieldOnly to true if you want to serialize only signing fields\n */\ninterface OptionObject {\n prefix?: Buffer\n suffix?: Buffer\n signingFieldsOnly?: boolean\n}\n\n/**\n * Function to serialize JSON object representing a transaction\n *\n * @param object JSON object to serialize\n * @param opts options for serializing, including optional prefix, suffix, and signingFieldOnly\n * @returns A Buffer containing the serialized object\n */\nfunction serializeObject(object: JsonObject, opts: OptionObject = {}): Buffer {\n const { prefix, suffix, signingFieldsOnly = false } = opts\n const bytesList = new BytesList()\n\n if (prefix) {\n bytesList.put(prefix)\n }\n\n const filter = signingFieldsOnly\n ? (f: FieldInstance): boolean => f.isSigningField\n : undefined\n\n coreTypes.STObject.from(object, filter).toBytesSink(bytesList)\n\n if (suffix) {\n bytesList.put(suffix)\n }\n\n return bytesList.toBytes()\n}\n\n/**\n * Serialize an object for signing\n *\n * @param transaction Transaction to serialize\n * @param prefix Prefix bytes to put before the serialized object\n * @returns A Buffer with the serialized object\n */\nfunction signingData(\n transaction: JsonObject,\n prefix: Buffer = HashPrefix.transactionSig,\n): Buffer {\n return serializeObject(transaction, { prefix, signingFieldsOnly: true })\n}\n\n/**\n * Interface describing fields required for a Claim\n */\ninterface ClaimObject extends JsonObject {\n channel: string\n amount: string | number\n}\n\n/**\n * Serialize a signingClaim\n *\n * @param claim A claim object to serialize\n * @returns the serialized object with appropriate prefix\n */\nfunction signingClaimData(claim: ClaimObject): Buffer {\n const num = bigInt(String(claim.amount))\n const prefix = HashPrefix.paymentChannelClaim\n const channel = coreTypes.Hash256.from(claim.channel).toBytes()\n const amount = coreTypes.UInt64.from(num).toBytes()\n\n const bytesList = new BytesList()\n\n bytesList.put(prefix)\n bytesList.put(channel)\n bytesList.put(amount)\n return bytesList.toBytes()\n}\n\n/**\n * Serialize a transaction object for multiSigning\n *\n * @param transaction transaction to serialize\n * @param signingAccount Account to sign the transaction with\n * @returns serialized transaction with appropriate prefix and suffix\n */\nfunction multiSigningData(\n transaction: JsonObject,\n signingAccount: string | AccountID,\n): Buffer {\n const prefix = HashPrefix.transactionMultiSig\n const suffix = coreTypes.AccountID.from(signingAccount).toBytes()\n return serializeObject(transaction, {\n prefix,\n suffix,\n signingFieldsOnly: true,\n })\n}\n\nexport {\n BinaryParser,\n BinarySerializer,\n BytesList,\n ClaimObject,\n makeParser,\n serializeObject,\n readJSON,\n multiSigningData,\n signingData,\n signingClaimData,\n binaryToJSON,\n sha512Half,\n transactionID,\n}\n","import {\n Field,\n TransactionType,\n LedgerEntryType,\n Type,\n TransactionResult,\n} from './enums'\nimport * as types from './types'\nimport * as binary from './binary'\nimport { ShaMap } from './shamap'\nimport * as ledgerHashes from './ledger-hashes'\nimport * as hashes from './hashes'\nimport { quality } from './quality'\nimport { HashPrefix } from './hash-prefixes'\n\nexport {\n hashes,\n binary,\n ledgerHashes,\n Field,\n TransactionType,\n LedgerEntryType,\n Type,\n TransactionResult,\n quality,\n HashPrefix,\n ShaMap,\n types,\n}\n","import * as enums from './definitions.json'\nimport { SerializedType } from '../types/serialized-type'\nimport { Buffer } from 'buffer/'\nimport { BytesList } from '../binary'\n\n/*\n * @brief: All valid transaction types\n */\nexport const TRANSACTION_TYPES = Object.entries(enums.TRANSACTION_TYPES)\n .filter(([_key, value]) => value >= 0)\n .map(([key, _value]) => key)\n\nconst TYPE_WIDTH = 2\nconst LEDGER_ENTRY_WIDTH = 2\nconst TRANSACTION_TYPE_WIDTH = 2\nconst TRANSACTION_RESULT_WIDTH = 1\n\n/*\n * @brief: Serialize a field based on type_code and Field.nth\n */\nfunction fieldHeader(type: number, nth: number): Buffer {\n const header: Array<number> = []\n if (type < 16) {\n if (nth < 16) {\n header.push((type << 4) | nth)\n } else {\n header.push(type << 4, nth)\n }\n } else if (nth < 16) {\n header.push(nth, type)\n } else {\n header.push(0, type, nth)\n }\n return Buffer.from(header)\n}\n\n/*\n * @brief: Bytes, name, and ordinal representing one type, ledger_type, transaction type, or result\n */\nexport class Bytes {\n readonly bytes: Buffer\n\n constructor(\n readonly name: string,\n readonly ordinal: number,\n readonly ordinalWidth: number,\n ) {\n this.bytes = Buffer.alloc(ordinalWidth)\n for (let i = 0; i < ordinalWidth; i++) {\n this.bytes[ordinalWidth - i - 1] = (ordinal >>> (i * 8)) & 0xff\n }\n }\n\n toJSON(): string {\n return this.name\n }\n\n toBytesSink(sink: BytesList): void {\n sink.put(this.bytes)\n }\n\n toBytes(): Uint8Array {\n return this.bytes\n }\n}\n\n/*\n * @brief: Collection of Bytes objects, mapping bidirectionally\n */\nclass BytesLookup {\n constructor(types: Record<string, number>, readonly ordinalWidth: number) {\n Object.entries(types).forEach(([k, v]) => {\n this[k] = new Bytes(k, v, ordinalWidth)\n this[v.toString()] = this[k]\n })\n }\n\n from(value: Bytes | string): Bytes {\n return value instanceof Bytes ? value : (this[value] as Bytes)\n }\n\n fromParser(parser): Bytes {\n return this.from(parser.readUIntN(this.ordinalWidth).toString())\n }\n}\n\n/*\n * type FieldInfo is the type of the objects containing information about each field in definitions.json\n */\ninterface FieldInfo {\n nth: number\n isVLEncoded: boolean\n isSerialized: boolean\n isSigningField: boolean\n type: string\n}\n\ninterface FieldInstance {\n readonly nth: number\n readonly isVariableLengthEncoded: boolean\n readonly isSerialized: boolean\n readonly isSigningField: boolean\n readonly type: Bytes\n readonly ordinal: number\n readonly name: string\n readonly header: Buffer\n readonly associatedType: typeof SerializedType\n}\n\nfunction buildField([name, info]: [string, FieldInfo]): FieldInstance {\n const typeOrdinal = enums.TYPES[info.type]\n const field = fieldHeader(typeOrdinal, info.nth)\n return {\n name: name,\n nth: info.nth,\n isVariableLengthEncoded: info.isVLEncoded,\n isSerialized: info.isSerialized,\n isSigningField: info.isSigningField,\n ordinal: (typeOrdinal << 16) | info.nth,\n type: new Bytes(info.type, typeOrdinal, TYPE_WIDTH),\n header: field,\n associatedType: SerializedType, // For later assignment in ./types/index.js\n }\n}\n\n/*\n * @brief: The collection of all fields as defined in definitions.json\n */\nclass FieldLookup {\n constructor(fields: Array<[string, FieldInfo]>) {\n fields.forEach(([k, v]) => {\n this[k] = buildField([k, v])\n this[this[k].ordinal.toString()] = this[k]\n })\n }\n\n fromString(value: string): FieldInstance {\n return this[value] as FieldInstance\n }\n}\n\nconst Type = new BytesLookup(enums.TYPES, TYPE_WIDTH)\nconst LedgerEntryType = new BytesLookup(\n enums.LEDGER_ENTRY_TYPES,\n LEDGER_ENTRY_WIDTH,\n)\nconst TransactionType = new BytesLookup(\n enums.TRANSACTION_TYPES,\n TRANSACTION_TYPE_WIDTH,\n)\nconst TransactionResult = new BytesLookup(\n enums.TRANSACTION_RESULTS,\n TRANSACTION_RESULT_WIDTH,\n)\nconst Field = new FieldLookup(enums.FIELDS as Array<[string, FieldInfo]>)\n\nexport {\n Field,\n FieldInstance,\n Type,\n LedgerEntryType,\n TransactionResult,\n TransactionType,\n}\n","import { Buffer } from 'buffer/'\n\n/**\n * Write a 32 bit integer to a Buffer\n *\n * @param uint32 32 bit integer to write to buffer\n * @returns a buffer with the bytes representation of uint32\n */\nfunction bytes(uint32: number): Buffer {\n const result = Buffer.alloc(4)\n result.writeUInt32BE(uint32, 0)\n return result\n}\n\n/**\n * Maps HashPrefix names to their byte representation\n */\nconst HashPrefix: Record<string, Buffer> = {\n transactionID: bytes(0x54584e00),\n // transaction plus metadata\n transaction: bytes(0x534e4400),\n // account state\n accountStateEntry: bytes(0x4d4c4e00),\n // inner node in tree\n innerNode: bytes(0x4d494e00),\n // ledger master data for signing\n ledgerHeader: bytes(0x4c575200),\n // inner transaction to sign\n transactionSig: bytes(0x53545800),\n // inner transaction to sign\n transactionMultiSig: bytes(0x534d5400),\n // validation for signing\n validation: bytes(0x56414c00),\n // proposal for signing\n proposal: bytes(0x50525000),\n // payment channel claim\n paymentChannelClaim: bytes(0x434c4d00),\n}\n\nexport { HashPrefix }\n","import { HashPrefix } from './hash-prefixes'\nimport createHash = require('create-hash')\nimport { Hash256 } from './types/hash-256'\nimport { BytesList } from './serdes/binary-serializer'\nimport { Buffer } from 'buffer/'\n\n/**\n * Class for hashing with SHA512\n * @extends BytesList So SerializedTypes can write bytes to a Sha512Half\n */\nclass Sha512Half extends BytesList {\n private hash = createHash('sha512')\n\n /**\n * Construct a new Sha512Hash and write bytes this.hash\n *\n * @param bytes bytes to write to this.hash\n * @returns the new Sha512Hash object\n */\n static put(bytes: Buffer): Sha512Half {\n return new Sha512Half().put(bytes)\n }\n\n /**\n * Write bytes to an existing Sha512Hash\n *\n * @param bytes bytes to write to object\n * @returns the Sha512 object\n */\n put(bytes: Buffer): Sha512Half {\n this.hash.update(bytes)\n return this\n }\n\n /**\n * Compute SHA512 hash and slice in half\n *\n * @returns half of a SHA512 hash\n */\n finish256(): Buffer {\n return Buffer.from(this.hash.digest().slice(0, 32))\n }\n\n /**\n * Constructs a Hash256 from the Sha512Half object\n *\n * @returns a Hash256 object\n */\n finish(): Hash256 {\n return new Hash256(this.finish256())\n }\n}\n\n/**\n * compute SHA512 hash of a list of bytes\n *\n * @param args zero or more arguments to hash\n * @returns the sha512half hash of the arguments.\n */\nfunction sha512Half(...args: Buffer[]): Buffer {\n const hash = new Sha512Half()\n args.forEach((a) => hash.put(a))\n return hash.finish256()\n}\n\n/**\n * Construct a transactionID from a Serialized Transaction\n *\n * @param serialized bytes to hash\n * @returns a Hash256 object\n */\nfunction transactionID(serialized: Buffer): Hash256 {\n return new Hash256(sha512Half(HashPrefix.transactionID, serialized))\n}\n\nexport { Sha512Half, sha512Half, transactionID }\n","import * as assert from 'assert'\nimport { quality, binary } from './coretypes'\nimport { decodeLedgerData } from './ledger-hashes'\nimport { ClaimObject } from './binary'\nimport { JsonObject } from './types/serialized-type'\nimport { TRANSACTION_TYPES } from './enums'\n\nconst {\n signingData,\n signingClaimData,\n multiSigningData,\n binaryToJSON,\n serializeObject,\n} = binary\n\n/**\n * Decode a transaction\n *\n * @param binary hex-string of the encoded transaction\n * @returns the JSON representation of the transaction\n */\nfunction decode(binary: string): JsonObject {\n assert.ok(typeof binary === 'string', 'binary must be a hex string')\n return binaryToJSON(binary)\n}\n\n/**\n * Encode a transaction\n *\n * @param json The JSON representation of a transaction\n * @returns A hex-string of the encoded transaction\n */\nfunction encode(json: object): string {\n assert.ok(typeof json === 'object')\n return serializeObject(json as JsonObject)\n .toString('hex')\n .toUpperCase()\n}\n\n/**\n * Encode a transaction and prepare for signing\n *\n * @param json JSON object representing the transaction\n * @param signer string representing the account to sign the transaction with\n * @returns a hex string of the encoded transaction\n */\nfunction encodeForSigning(json: object): string {\n assert.ok(typeof json === 'object')\n return signingData(json as JsonObject)\n .toString('hex')\n .toUpperCase()\n}\n\n/**\n * Encode a transaction and prepare for signing with a claim\n *\n * @param json JSON object representing the transaction\n * @param signer string representing the account to sign the transaction with\n * @returns a hex string of the encoded transaction\n */\nfunction encodeForSigningClaim(json: object): string {\n assert.ok(typeof json === 'object')\n return signingClaimData(json as ClaimObject)\n .toString('hex')\n .toUpperCase()\n}\n\n/**\n * Encode a transaction and prepare for multi-signing\n *\n * @param json JSON object representing the transaction\n * @param signer string representing the account to sign the transaction with\n * @returns a hex string of the encoded transaction\n */\nfunction encodeForMultisigning(json: object, signer: string): string {\n assert.ok(typeof json === 'object')\n assert.equal(json['SigningPubKey'], '')\n return multiSigningData(json as JsonObject, signer)\n .toString('hex')\n .toUpperCase()\n}\n\n/**\n * Encode a quality value\n *\n * @param value string representation of a number\n * @returns a hex-string representing the quality\n */\nfunction encodeQuality(value: string): string {\n assert.ok(typeof value === 'string')\n return quality.encode(value).toString('hex').toUpperCase()\n}\n\n/**\n * Decode a quality value\n *\n * @param value hex-string of a quality\n * @returns a string representing the quality\n */\nfunction decodeQuality(value: string): string {\n assert.ok(typeof value === 'string')\n return quality.decode(value).toString()\n}\n\nexport {\n decode,\n encode,\n encodeForSigning,\n encodeForSigningClaim,\n encodeForMultisigning,\n encodeQuality,\n decodeQuality,\n decodeLedgerData,\n TRANSACTION_TYPES,\n}\n","import * as assert from 'assert'\nimport { ShaMap, ShaMapNode, ShaMapLeaf } from './shamap'\nimport { HashPrefix } from './hash-prefixes'\nimport { Sha512Half } from './hashes'\nimport { BinarySerializer, serializeObject } from './binary'\nimport { Hash256 } from './types/hash-256'\nimport { STObject } from './types/st-object'\nimport { UInt64 } from './types/uint-64'\nimport { UInt32 } from './types/uint-32'\nimport { UInt8 } from './types/uint-8'\nimport { BinaryParser } from './serdes/binary-parser'\nimport { JsonObject } from './types/serialized-type'\nimport bigInt = require('big-integer')\n\n/**\n * Computes the hash of a list of objects\n *\n * @param itemizer Converts an item into a format that can be added to SHAMap\n * @param itemsJson Array of items to add to a SHAMap\n * @returns the hash of the SHAMap\n */\nfunction computeHash(\n itemizer: (item: JsonObject) => [Hash256?, ShaMapNode?, ShaMapLeaf?],\n itemsJson: Array<JsonObject>,\n): Hash256 {\n const map = new ShaMap()\n itemsJson.forEach((item) => map.addItem(...itemizer(item)))\n return map.hash()\n}\n\n/**\n * Interface describing a transaction item\n */\ninterface transactionItemObject extends JsonObject {\n hash: string\n metaData: JsonObject\n}\n\n/**\n * Convert a transaction into an index and an item\n *\n * @param json transaction with metadata\n * @returns a tuple of index and item to be added to SHAMap\n */\nfunction transactionItemizer(\n json: transactionItemObject,\n): [Hash256, ShaMapNode, undefined] {\n assert.ok(json.hash)\n const index = Hash256.from(json.hash)\n const item = {\n hashPrefix() {\n return HashPrefix.transaction\n },\n toBytesSink(sink) {\n const serializer = new BinarySerializer(sink)\n serializer.writeLengthEncoded(STObject.from(json))\n serializer.writeLengthEncoded(STObject.from(json.metaData))\n },\n } as ShaMapNode\n return [index, item, undefined]\n}\n\n/**\n * Interface describing an entry item\n */\ninterface entryItemObject extends JsonObject {\n index: string\n}\n\n/**\n * Convert an entry to a pair Hash256 and ShaMapNode\n *\n * @param json JSON describing a ledger entry item\n * @returns a tuple of index and item to be added to SHAMap\n */\nfunction entryItemizer(\n json: entryItemObject,\n): [Hash256, ShaMapNode, undefined] {\n const index = Hash256.from(json.index)\n const bytes = serializeObject(json)\n const item = {\n hashPrefix() {\n return HashPrefix.accountStateEntry\n },\n toBytesSink(sink) {\n sink.put(bytes)\n },\n } as ShaMapNode\n return [index, item, undefined]\n}\n\n/**\n * Function computing the hash of a transaction tree\n *\n * @param param An array of transaction objects to hash\n * @returns A Hash256 object\n */\nfunction transactionTreeHash(param: Array<JsonObject>): Hash256 {\n const itemizer = transactionItemizer as (\n json: JsonObject,\n ) => [Hash256, ShaMapNode, undefined]\n return computeHash(itemizer, param)\n}\n\n/**\n * Function computing the hash of accountState\n *\n * @param param A list of accountStates hash\n * @returns A Hash256 object\n */\nfunction accountStateHash(param: Array<JsonObject>): Hash256 {\n const itemizer = entryItemizer as (\n json: JsonObject,\n ) => [Hash256, ShaMapNode, undefined]\n return computeHash(itemizer, param)\n}\n\n/**\n * Interface describing a ledger header\n */\ninterface ledgerObject {\n ledger_index: number\n total_coins: string | number | bigInt.BigInteger\n parent_hash: string\n transaction_hash: string\n account_hash: string\n parent_close_time: number\n close_time: number\n close_time_resolution: number\n close_flags: number\n}\n\n/**\n * Serialize and hash a ledger header\n *\n * @param header a ledger header\n * @returns the hash of header\n */\nfunction ledgerHash(header: ledgerObject): Hash256 {\n const hash = new Sha512Half()\n hash.put(HashPrefix.ledgerHeader)\n assert.ok(header.parent_close_time !== undefined)\n assert.ok(header.close_flags !== undefined)\n\n UInt32.from<number>(header.ledger_index).toBytesSink(hash)\n UInt64.from<bigInt.BigInteger>(\n bigInt(String(header.total_coins)),\n ).toBytesSink(hash)\n Hash256.from<string>(header.parent_hash).toBytesSink(hash)\n Hash256.from<string>(header.transaction_hash).toBytesSink(hash)\n Hash256.from<string>(header.account_hash).toBytesSink(hash)\n UInt32.from<number>(header.parent_close_time).toBytesSink(hash)\n UInt32.from<number>(header.close_time).toBytesSink(hash)\n UInt8.from<number>(header.close_time_resolution).toBytesSink(hash)\n UInt8.from<number>(header.close_flags).toBytesSink(hash)\n return hash.finish()\n}\n\n/**\n * Decodes a serialized ledger header\n *\n * @param binary A serialized ledger header\n * @returns A JSON object describing a ledger header\n */\nfunction decodeLedgerData(binary: string): object {\n assert.ok(typeof binary === 'string', 'binary must be a hex string')\n const parser = new BinaryParser(binary)\n return {\n ledger_index: parser.readUInt32(),\n total_coins: parser.readType(UInt64).valueOf().toString(),\n parent_hash: parser.readType(Hash256).toHex(),\n transaction_hash: parser.readType(Hash256).toHex(),\n account_hash: parser.readType(Hash256).toHex(),\n parent_close_time: parser.readUInt32(),\n close_time: parser.readUInt32(),\n close_time_resolution: parser.readUInt8(),\n close_flags: parser.readUInt8(),\n }\n}\n\nexport { accountStateHash, transactionTreeHash, ledgerHash, decodeLedgerData }\n","import { coreTypes } from './types'\nimport { Decimal } from 'decimal.js'\nimport bigInt = require('big-integer')\nimport { Buffer } from 'buffer/'\n\n/**\n * class for encoding and decoding quality\n */\nclass quality {\n /**\n * Encode quality amount\n *\n * @param arg string representation of an amount\n * @returns Serialized quality\n */\n static encode(quality: string): Buffer {\n const decimal = new Decimal(quality)\n const exponent = decimal.e - 15\n const qualityString = decimal.times(`1e${-exponent}`).abs().toString()\n const bytes = coreTypes.UInt64.from(bigInt(qualityString)).toBytes()\n bytes[0] = exponent + 100\n return bytes\n }\n\n /**\n * Decode quality amount\n *\n * @param arg hex-string denoting serialized quality\n * @returns deserialized quality\n */\n static decode(quality: string): Decimal {\n const bytes = Buffer.from(quality, 'hex').slice(-8)\n const exponent = bytes[0] - 100\n const mantissa = new Decimal(`0x${bytes.slice(1).toString('hex')}`)\n return mantissa.times(`1e${exponent}`)\n }\n}\n\nexport { quality }\n","import * as assert from 'assert'\nimport { Field, FieldInstance } from '../enums'\nimport { SerializedType } from '../types/serialized-type'\nimport { Buffer } from 'buffer/'\n\n/**\n * BinaryParser is used to compute fields and values from a HexString\n */\nclass BinaryParser {\n private bytes: Buffer\n\n /**\n * Initialize bytes to a hex string\n *\n * @param hexBytes a hex string\n */\n constructor(hexBytes: string) {\n this.bytes = Buffer.from(hexBytes, 'hex')\n }\n\n /**\n * Peek the first byte of the BinaryParser\n *\n * @returns The first byte of the BinaryParser\n */\n peek(): number {\n assert.ok(this.bytes.byteLength !== 0)\n return this.bytes[0]\n }\n\n /**\n * Consume the first n bytes of the BinaryParser\n *\n * @param n the number of bytes to skip\n */\n skip(n: number): void {\n assert.ok(n <= this.bytes.byteLength)\n this.bytes = this.bytes.slice(n)\n }\n\n /**\n * read the first n bytes from the BinaryParser\n *\n * @param n The number of bytes to read\n * @return The bytes\n */\n read(n: number): Buffer {\n assert.ok(n <= this.bytes.byteLength)\n\n const slice = this.bytes.slice(0, n)\n this.skip(n)\n return slice\n }\n\n /**\n * Read an integer of given size\n *\n * @param n The number of bytes to read\n * @return The number represented by those bytes\n */\n readUIntN(n: number): number {\n assert.ok(0 < n && n <= 4, 'invalid n')\n return this.read(n).reduce((a, b) => (a << 8) | b) >>> 0\n }\n\n readUInt8(): number {\n return this.readUIntN(1)\n }\n\n readUInt16(): number {\n return this.readUIntN(2)\n }\n\n readUInt32(): number {\n return this.readUIntN(4)\n }\n\n size(): number {\n return this.bytes.byteLength\n }\n\n end(customEnd?: number): boolean {\n const length = this.bytes.byteLength\n return length === 0 || (customEnd !== undefined && length <= customEnd)\n }\n\n /**\n * Reads variable length encoded bytes\n *\n * @return The variable length bytes\n */\n readVariableLength(): Buffer {\n return this.read(this.readVariableLengthLength())\n }\n\n /**\n * Reads the length of the variable length encoded bytes\n *\n * @return The length of the variable length encoded bytes\n */\n readVariableLengthLength(): number {\n const b1 = this.readUInt8()\n if (b1 <= 192) {\n return b1\n } else if (b1 <= 240) {\n const b2 = this.readUInt8()\n return 193 + (b1 - 193) * 256 + b2\n } else if (b1 <= 254) {\n const b2 = this.readUInt8()\n const b3 = this.readUInt8()\n return 12481 + (b1 - 241) * 65536 + b2 * 256 + b3\n }\n throw new Error('Invalid variable length indicator')\n }\n\n /**\n * Reads the field ordinal from the BinaryParser\n *\n * @return Field ordinal\n */\n readFieldOrdinal(): number {\n let type = this.readUInt8()\n let nth = type & 15\n type >>= 4\n\n if (type === 0) {\n type = this.readUInt8()\n if (type === 0 || type < 16) {\n throw new Error('Cannot read FieldOrdinal, type_code out of range')\n }\n }\n\n if (nth === 0) {\n nth = this.readUInt8()\n if (nth === 0 || nth < 16) {\n throw new Error('Cannot read FieldOrdinal, field_code out of range')\n }\n }\n\n return (type << 16) | nth\n }\n\n /**\n * Read the field from the BinaryParser\n *\n * @return The field represented by the bytes at the head of the BinaryParser\n */\n readField(): FieldInstance {\n return Field.fromString(this.readFieldOrdinal().toString())\n }\n\n /**\n * Read a given type from the BinaryParser\n *\n * @param type The type that you want to read from the BinaryParser\n * @return The instance of that type read from the BinaryParser\n */\n readType(type: typeof SerializedType): SerializedType {\n return type.fromParser(this)\n }\n\n /**\n * Get the type associated with a given field\n *\n * @param field The field that you wan to get the type of\n * @return The type associated with the given field\n */\n typeForField(field: FieldInstance): typeof SerializedType {\n return field.associatedType\n }\n\n /**\n * Read value of the type specified by field from the BinaryParser\n *\n * @param field The field that you want to get the associated value for\n * @return The value associated with the given field\n */\n readFieldValue(field: FieldInstance): SerializedType {\n const type = this.typeForField(field)\n if (!type) {\n throw new Error(`unsupported: (${field.name}, ${field.type.name})`)\n }\n const sizeHint = field.isVariableLengthEncoded\n ? this.readVariableLengthLength()\n : undefined\n const value = type.fromParser(this, sizeHint)\n if (value === undefined) {\n throw new Error(\n `fromParser for (${field.name}, ${field.type.name}) -> undefined `,\n )\n }\n return value\n }\n\n /**\n * Get the next field and value from the BinaryParser\n *\n * @return The field and value\n */\n readFieldAndValue(): [FieldInstance, SerializedType] {\n const field = this.readField()\n return [field, this.readFieldValue(field)]\n }\n}\n\nexport { BinaryParser }\n","import * as assert from 'assert'\nimport { FieldInstance } from '../enums'\nimport { SerializedType } from '../types/serialized-type'\nimport { Buffer } from 'buffer/'\n\n/**\n * Bytes list is a collection of buffer objects\n */\nclass BytesList {\n private bytesArray: Array<Buffer> = []\n\n /**\n * Get the total number of bytes in the BytesList\n *\n * @return the number of bytes\n */\n public getLength(): number {\n return Buffer.concat(this.bytesArray).byteLength\n }\n\n /**\n * Put bytes in the BytesList\n *\n * @param bytesArg A Buffer\n * @return this BytesList\n */\n public put(bytesArg: Buffer): BytesList {\n const bytes = Buffer.from(bytesArg) // Temporary, to catch instances of Uint8Array being passed in\n this.bytesArray.push(bytes)\n return this\n }\n\n /**\n * Write this BytesList to the back of another bytes list\n *\n * @param list The BytesList to write to\n */\n public toBytesSink(list: BytesList): void {\n list.put(this.toBytes())\n }\n\n public toBytes(): Buffer {\n return Buffer.concat(this.bytesArray)\n }\n\n toHex(): string {\n return this.toBytes().toString('hex').toUpperCase()\n }\n}\n\n/**\n * BinarySerializer is used to write fields and values to buffers\n */\nclass BinarySerializer {\n private sink: BytesList = new BytesList()\n\n constructor(sink: BytesList) {\n this.sink = sink\n }\n\n /**\n * Write a value to this BinarySerializer\n *\n * @param value a SerializedType value\n */\n write(value: SerializedType): void {\n value.toBytesSink(this.sink)\n }\n\n /**\n * Write bytes to this BinarySerializer\n *\n * @param bytes the bytes to write\n */\n put(bytes: Buffer): void {\n this.sink.put(bytes)\n }\n\n /**\n * Write a value of a given type to this BinarySerializer\n *\n * @param type the type to write\n * @param value a value of that type\n */\n writeType(type: typeof SerializedType, value: SerializedType): void {\n this.write(type.from(value))\n }\n\n /**\n * Write BytesList to this BinarySerializer\n *\n * @param bl BytesList to write to BinarySerializer\n */\n writeBytesList(bl: BytesList): void {\n bl.toBytesSink(this.sink)\n }\n\n /**\n * Calculate the header of Variable Length encoded bytes\n *\n * @param length the length of the bytes\n */\n private encodeVariableLength(length: number): Buffer {\n const lenBytes = Buffer.alloc(3)\n if (length <= 192) {\n lenBytes[0] = length\n return lenBytes.slice(0, 1)\n } else if (length <= 12480) {\n length -= 193\n lenBytes[0] = 193 + (length >>> 8)\n lenBytes[1] = length & 0xff\n return lenBytes.slice(0, 2)\n } else if (length <= 918744) {\n length -= 12481\n lenBytes[0] = 241 + (length >>> 16)\n lenBytes[1] = (length >> 8) & 0xff\n lenBytes[2] = length & 0xff\n return lenBytes.slice(0, 3)\n }\n throw new Error('Overflow error')\n }\n\n /**\n * Write field and value to BinarySerializer\n *\n * @param field field to write to BinarySerializer\n * @param value value to write to BinarySerializer\n */\n writeFieldAndValue(\n field: FieldInstance,\n value: SerializedType,\n isUnlModifyWorkaround = false,\n ): void {\n const associatedValue = field.associatedType.from(value)\n assert.ok(associatedValue.toBytesSink !== undefined)\n assert.ok(field.name !== undefined)\n\n this.sink.put(field.header)\n\n if (field.isVariableLengthEncoded) {\n this.writeLengthEncoded(associatedValue, isUnlModifyWorkaround)\n } else {\n associatedValue.toBytesSink(this.sink)\n }\n }\n\n /**\n * Write a variable length encoded value to the BinarySerializer\n *\n * @param value length encoded value to write to BytesList\n */\n public writeLengthEncoded(\n value: SerializedType,\n isUnlModifyWorkaround = false,\n ): void {\n const bytes = new BytesList()\n if (!isUnlModifyWorkaround) {\n // this part doesn't happen for the Account field in a UNLModify transaction\n value.toBytesSink(bytes)\n }\n this.put(this.encodeVariableLength(bytes.getLength()))\n this.writeBytesList(bytes)\n }\n}\n\nexport { BytesList, BinarySerializer }\n","import { strict as assert } from 'assert'\nimport { coreTypes } from './types'\nimport { HashPrefix } from './hash-prefixes'\nimport { Sha512Half } from './hashes'\nimport { Hash256 } from './types/hash-256'\nimport { BytesList } from './serdes/binary-serializer'\nimport { Buffer } from 'buffer/'\n\n/**\n * Abstract class describing a SHAMapNode\n */\nabstract class ShaMapNode {\n abstract hashPrefix(): Buffer\n abstract isLeaf(): boolean\n abstract isInner(): boolean\n abstract toBytesSink(list: BytesList): void\n abstract hash(): Hash256\n}\n\n/**\n * Class describing a Leaf of SHAMap\n */\nclass ShaMapLeaf extends ShaMapNode {\n constructor(public index: Hash256, public item?: ShaMapNode) {\n super()\n }\n\n /**\n * @returns true as ShaMapLeaf is a leaf node\n */\n isLeaf(): boolean {\n return true\n }\n\n /**\n * @returns false as ShaMapLeaf is not an inner node\n */\n isInner(): boolean {\n return false\n }\n\n /**\n * Get the prefix of the this.item\n *\n * @returns The hash prefix, unless this.item is undefined, then it returns an empty Buffer\n */\n hashPrefix(): Buffer {\n return this.item === undefined ? Buffer.alloc(0) : this.item.hashPrefix()\n }\n\n /**\n * Hash the bytes representation of this\n *\n * @returns hash of this.item concatenated with this.index\n */\n hash(): Hash256 {\n const hash = Sha512Half.put(this.hashPrefix())\n this.toBytesSink(hash)\n return hash.finish()\n }\n\n /**\n * Write the bytes representation of this to a BytesList\n * @param list BytesList to write bytes to\n */\n toBytesSink(list: BytesList): void {\n if (this.item !== undefined) {\n this.item.toBytesSink(list)\n }\n this.index.toBytesSink(list)\n }\n}\n\n/**\n * Class defining an Inner Node of a SHAMap\n */\nclass ShaMapInner extends ShaMapNode {\n private slotBits = 0\n private branches: Array<ShaMapNode> = Array(16)\n\n constructor(private depth: number = 0) {\n super()\n }\n\n /**\n * @returns true as ShaMapInner is an inner node\n */\n isInner(): boolean {\n return true\n }\n\n /**\n * @returns false as ShaMapInner is not a leaf node\n */\n isLeaf(): boolean {\n return false\n }\n\n /**\n * Get the hash prefix for this node\n *\n * @returns hash prefix describing an inner node\n */\n hashPrefix(): Buffer {\n return HashPrefix.innerNode\n }\n\n /**\n * Set a branch of this node to be another node\n *\n * @param slot Slot to add branch to this.branches\n * @param branch Branch to add\n */\n setBranch(slot: number, branch: ShaMapNode): void {\n this.slotBits = this.slotBits | (1 << slot)\n this.branches[slot] = branch\n }\n\n /**\n * @returns true if node is empty\n */\n empty(): boolean {\n return this.slotBits === 0\n }\n\n /**\n * Compute the hash of this node\n *\n * @returns The hash of this node\n */\n hash(): Hash256 {\n if (this.empty()) {\n return coreTypes.Hash256.ZERO_256\n }\n const hash = Sha512Half.put(this.hashPrefix())\n this.toBytesSink(hash)\n return hash.finish()\n }\n\n /**\n * Writes the bytes representation of this node to a BytesList\n *\n * @param list BytesList to write bytes to\n */\n toBytesSink(list: BytesList): void {\n for (let i = 0; i < this.branches.length; i++) {\n const branch = this.branches[i]\n const hash = branch ? branch.hash() : coreTypes.Hash256.ZERO_256\n hash.toBytesSink(list)\n }\n }\n\n /**\n * Add item to the SHAMap\n *\n * @param index Hash of the index of the item being inserted\n * @param item Item to insert in the map\n * @param leaf Leaf node to insert when branch doesn't exist\n */\n addItem(index?: Hash256, item?: ShaMapNode, leaf?: ShaMapLeaf): void {\n assert.ok(index !== undefined)\n if (index !== undefined) {\n const nibble = index.nibblet(this.depth)\n const existing = this.branches[nibble]\n\n if (existing === undefined) {\n this.setBranch(nibble, leaf || new ShaMapLeaf(index, item))\n } else if (existing instanceof ShaMapLeaf) {\n const newInner = new ShaMapInner(this.depth + 1)\n newInner.addItem(existing.index, undefined, existing)\n newInner.addItem(index, item, leaf)\n this.setBranch(nibble, newInner)\n } else if (existing instanceof ShaMapInner) {\n existing.addItem(index, item, leaf)\n } else {\n throw new Error('invalid ShaMap.addItem call')\n }\n }\n }\n}\n\nclass ShaMap extends ShaMapInner {}\n\nexport { ShaMap, ShaMapNode, ShaMapLeaf }\n","import {\n decodeAccountID,\n encodeAccountID,\n isValidXAddress,\n xAddressToClassicAddress,\n} from 'ripple-address-codec'\nimport { Hash160 } from './hash-160'\nimport { Buffer } from 'buffer/'\n\nconst HEX_REGEX = /^[A-F0-9]{40}$/\n\n/**\n * Class defining how to encode and decode an AccountID\n */\nclass AccountID extends Hash160 {\n static readonly defaultAccountID: AccountID = new AccountID(Buffer.alloc(20))\n\n constructor(bytes?: Buffer) {\n super(bytes ?? AccountID.defaultAccountID.bytes)\n }\n\n /**\n * Defines how to construct an AccountID\n *\n * @param value either an existing AccountID, a hex-string, or a base58 r-Address\n * @returns an AccountID object\n */\n static from<T extends Hash160 | string>(value: T): AccountID {\n if (value instanceof AccountID) {\n return value\n }\n\n if (typeof value === 'string') {\n if (value === '') {\n return new AccountID()\n }\n\n return HEX_REGEX.test(value)\n ? new AccountID(Buffer.from(value, 'hex'))\n : this.fromBase58(value)\n }\n\n throw new Error('Cannot construct AccountID from value given')\n }\n\n /**\n * Defines how to build an AccountID from a base58 r-Address\n *\n * @param value a base58 r-Address\n * @returns an AccountID object\n */\n static fromBase58(value: string): AccountID {\n if (isValidXAddress(value)) {\n const classic = xAddressToClassicAddress(value)\n\n if (classic.tag !== false)\n throw new Error('Only allowed to have tag on Account or Destination')\n\n value = classic.classicAddress\n }\n\n return new AccountID(Buffer.from(decodeAccountID(value)))\n }\n\n /**\n * Overload of toJSON\n *\n * @returns the base58 string for this AccountID\n */\n toJSON(): string {\n return this.toBase58()\n }\n\n /**\n * Defines how to encode AccountID into a base58 address\n *\n * @returns the base58 string defined by this.bytes\n */\n toBase58(): string {\n /* eslint-disable @typescript-eslint/no-explicit-any */\n return encodeAccountID(this.bytes as any)\n /* eslint-enable @typescript-eslint/no-explicit-any */\n }\n}\n\nexport { AccountID }\n","import { Decimal } from 'decimal.js'\n\nimport { BinaryParser } from '../serdes/binary-parser'\n\nimport { AccountID } from './account-id'\nimport { Currency } from './currency'\nimport { JsonObject, SerializedType } from './serialized-type'\nimport bigInt = require('big-integer')\nimport { Buffer } from 'buffer/'\n\n/**\n * Constants for validating amounts\n */\nconst MIN_IOU_EXPONENT = -96\nconst MAX_IOU_EXPONENT = 80\nconst MAX_IOU_PRECISION = 16\nconst MAX_DROPS = new Decimal('1e17')\nconst MIN_XRP = new Decimal('1e-6')\nconst mask = bigInt(0x00000000ffffffff)\n\n/**\n * decimal.js configuration for Amount IOUs\n */\nDecimal.config({\n toExpPos: MAX_IOU_EXPONENT + MAX_IOU_PRECISION,\n toExpNeg: MIN_IOU_EXPONENT - MAX_IOU_PRECISION,\n})\n\n/**\n * Interface for JSON objects that represent amounts\n */\ninterface AmountObject extends JsonObject {\n value: string\n currency: string\n issuer: string\n}\n\n/**\n * Type guard for AmountObject\n */\nfunction isAmountObject(arg): arg is AmountObject {\n const keys = Object.keys(arg).sort()\n return (\n keys.length === 3 &&\n keys[0] === 'currency' &&\n keys[1] === 'issuer' &&\n keys[2] === 'value'\n )\n}\n\n/**\n * Class for serializing/Deserializing Amounts\n */\nclass Amount extends SerializedType {\n static defaultAmount: Amount = new Amount(\n Buffer.from('4000000000000000', 'hex'),\n )\n\n constructor(bytes: Buffer) {\n super(bytes ?? Amount.defaultAmount.bytes)\n }\n\n /**\n * Construct an amount from an IOU or string amount\n *\n * @param value An Amount, object representing an IOU, or a string\n * representing an integer amount\n * @returns An Amount object\n */\n static from<T extends Amount | AmountObject | string>(value: T): Amount {\n if (value instanceof Amount) {\n return value\n }\n\n let amount = Buffer.alloc(8)\n if (typeof value === 'string') {\n Amount.assertXrpIsValid(value)\n\n const number = bigInt(value)\n\n const intBuf = [Buffer.alloc(4), Buffer.alloc(4)]\n intBuf[0].writeUInt32BE(Number(number.shiftRight(32)), 0)\n intBuf[1].writeUInt32BE(Number(number.and(mask)), 0)\n\n amount = Buffer.concat(intBuf)\n\n amount[0] |= 0x40\n\n return new Amount(amount)\n }\n\n if (isAmountObject(value)) {\n const number = new Decimal(value.value)\n Amount.assertIouIsValid(number)\n\n if (number.isZero()) {\n amount[0] |= 0x80\n } else {\n const integerNumberString = number\n .times(`1e${-(number.e - 15)}`)\n .abs()\n .toString()\n\n const num = bigInt(integerNumberString)\n const intBuf = [Buffer.alloc(4), Buffer.alloc(4)]\n intBuf[0].writeUInt32BE(Number(num.shiftRight(32)), 0)\n intBuf[1].writeUInt32BE(Number(num.and(mask)), 0)\n\n amount = Buffer.concat(intBuf)\n\n amount[0] |= 0x80\n\n if (number.gt(new Decimal(0))) {\n amount[0] |= 0x40\n }\n\n const exponent = number.e - 15\n const exponentByte = 97 + exponent\n amount[0] |= exponentByte >>> 2\n amount[1] |= (exponentByte & 0x03) << 6\n }\n\n const currency = Currency.from(value.currency).toBytes()\n const issuer = AccountID.from(value.issuer).toBytes()\n return new Amount(Buffer.concat([amount, currency, issuer]))\n }\n\n throw new Error('Invalid type to construct an Amount')\n }\n\n /**\n * Read an amount from a BinaryParser\n *\n * @param parser BinaryParser to read the Amount from\n * @returns An Amount object\n */\n static fromParser(parser: BinaryParser): Amount {\n const isXRP = parser.peek() & 0x80\n const numBytes = isXRP ? 48 : 8\n return new Amount(parser.read(numBytes))\n }\n\n /**\n * Get the JSON representation of this Amount\n *\n * @returns the JSON interpretation of this.bytes\n */\n toJSON(): AmountObject | string {\n if (this.isNative()) {\n const bytes = this.bytes\n const isPositive = bytes[0] & 0x40\n const sign = isPositive ? '' : '-'\n bytes[0] &= 0x3f\n\n const msb = bigInt(bytes.slice(0, 4).readUInt32BE(0))\n const lsb = bigInt(bytes.slice(4).readUInt32BE(0))\n const num = msb.shiftLeft(32).or(lsb)\n\n return `${sign}${num.toString()}`\n } else {\n const parser = new BinaryParser(this.toString())\n const mantissa = parser.read(8)\n const currency = Currency.fromParser(parser) as Currency\n const issuer = AccountID.fromParser(parser) as AccountID\n\n const b1 = mantissa[0]\n const b2 = mantissa[1]\n\n const isPositive = b1 & 0x40\n const sign = isPositive ? '' : '-'\n const exponent = ((b1 & 0x3f) << 2) + ((b2 & 0xff) >> 6) - 97\n\n mantissa[0] = 0\n mantissa[1] &= 0x3f\n const value = new Decimal(`${sign}0x${mantissa.toString('hex')}`).times(\n `1e${exponent}`,\n )\n Amount.assertIouIsValid(value)\n\n return {\n value: value.toString(),\n currency: currency.toJSON(),\n issuer: issuer.toJSON(),\n }\n }\n }\n\n /**\n * Validate XRP amount\n *\n * @param amount String representing XRP amount\n * @returns void, but will throw if invalid amount\n */\n private static assertXrpIsValid(amount: string): void {\n if (amount.indexOf('.') !== -1) {\n throw new Error(`${amount.toString()} is an illegal amount`)\n }\n\n const decimal = new Decimal(amount)\n if (!decimal.isZero()) {\n if (decimal.lt(MIN_XRP) || decimal.gt(MAX_DROPS)) {\n throw new Error(`${amount.toString()} is an illegal amount`)\n }\n }\n }\n\n /**\n * Validate IOU.value amount\n *\n * @param decimal Decimal.js object representing IOU.value\n * @returns void, but will throw if invalid amount\n */\n private static assertIouIsValid(decimal: Decimal): void {\n if (!decimal.isZero()) {\n const p = decimal.precision()\n const e = decimal.e - 15\n if (\n p > MAX_IOU_PRECISION ||\n e > MAX_IOU_EXPONENT ||\n e < MIN_IOU_EXPONENT\n ) {\n throw new Error('Decimal precision out of range')\n }\n this.verifyNoDecimal(decimal)\n }\n }\n\n /**\n * Ensure that the value after being multiplied by the exponent does not\n * contain a decimal.\n *\n * @param decimal a Decimal object\n * @returns a string of the object without a decimal\n */\n private static verifyNoDecimal(decimal: Decimal): void {\n const integerNumberString = decimal\n .times(`1e${-(decimal.e - 15)}`)\n .abs()\n .toString()\n\n if (integerNumberString.indexOf('.') !== -1) {\n throw new Error('Decimal place found in integerNumberString')\n }\n }\n\n /**\n * Test if this amount is in units of Native Currency(XRP)\n *\n * @returns true if Native (XRP)\n */\n private isNative(): boolean {\n return (this.bytes[0] & 0x80) === 0\n }\n}\n\nexport { Amount, AmountObject }\n","import { SerializedType } from './serialized-type'\nimport { BinaryParser } from '../serdes/binary-parser'\nimport { Buffer } from 'buffer/'\n\n/**\n * Variable length encoded type\n */\nclass Blob extends SerializedType {\n constructor(bytes: Buffer) {\n super(bytes)\n }\n\n /**\n * Defines how to read a Blob from a BinaryParser\n *\n * @param parser The binary parser to read the Blob from\n * @param hint The length of the blob, computed by readVariableLengthLength() and passed in\n * @returns A Blob object\n */\n static fromParser(parser: BinaryParser, hint: number): Blob {\n return new Blob(parser.read(hint))\n }\n\n /**\n * Create a Blob object from a hex-string\n *\n * @param value existing Blob object or a hex-string\n * @returns A Blob object\n */\n static from<T extends Blob | string>(value: T): Blob {\n if (value instanceof Blob) {\n return value\n }\n\n if (typeof value === 'string') {\n return new Blob(Buffer.from(value, 'hex'))\n }\n\n throw new Error('Cannot construct Blob from value given')\n }\n}\n\nexport { Blob }\n","import { Hash160 } from './hash-160'\nimport { Buffer } from 'buffer/'\n\nconst XRP_HEX_REGEX = /^0{40}$/\nconst ISO_REGEX = /^[A-Z0-9a-z?!@#$%^&*(){}[\\]|]{3}$/\nconst HEX_REGEX = /^[A-F0-9]{40}$/\n// eslint-disable-next-line no-control-regex\nconst STANDARD_FORMAT_HEX_REGEX = /^0{24}[\\x00-\\x7F]{6}0{10}$/\n\n/**\n * Convert an ISO code to a currency bytes representation\n */\nfunction isoToBytes(iso: string): Buffer {\n const bytes = Buffer.alloc(20)\n if (iso !== 'XRP') {\n const isoBytes = iso.split('').map((c) => c.charCodeAt(0))\n bytes.set(isoBytes, 12)\n }\n return bytes\n}\n\n/**\n * Tests if ISO is a valid iso code\n */\nfunction isIsoCode(iso: string): boolean {\n return ISO_REGEX.test(iso)\n}\n\nfunction isoCodeFromHex(code: Buffer): string | null {\n const iso = code.toString()\n if (iso === 'XRP') {\n return null\n }\n if (isIsoCode(iso)) {\n return iso\n }\n return null\n}\n\n/**\n * Tests if hex is a valid hex-string\n */\nfunction isHex(hex: string): boolean {\n return HEX_REGEX.test(hex)\n}\n\n/**\n * Tests if a string is a valid representation of a currency\n */\nfunction isStringRepresentation(input: string): boolean {\n return input.length === 3 || isHex(input)\n}\n\n/**\n * Tests if a Buffer is a valid representation of a currency\n */\nfunction isBytesArray(bytes: Buffer): boolean {\n return bytes.byteLength === 20\n}\n\n/**\n * Ensures that a value is a valid representation of a currency\n */\nfunction isValidRepresentation(input: Buffer | string): boolean {\n return input instanceof Buffer\n ? isBytesArray(input)\n : isStringRepresentation(input)\n}\n\n/**\n * Generate bytes from a string or buffer representation of a currency\n */\nfunction bytesFromRepresentation(input: string): Buffer {\n if (!isValidRepresentation(input)) {\n throw new Error(`Unsupported Currency representation: ${input}`)\n }\n return input.length === 3 ? isoToBytes(input) : Buffer.from(input, 'hex')\n}\n\n/**\n * Class defining how to encode and decode Currencies\n */\nclass Currency extends Hash160 {\n static readonly XRP = new Currency(Buffer.alloc(20))\n private readonly _iso: string | null\n\n constructor(byteBuf: Buffer) {\n super(byteBuf ?? Currency.XRP.bytes)\n const hex = this.bytes.toString('hex')\n\n if (XRP_HEX_REGEX.test(hex)) {\n this._iso = 'XRP'\n } else if (STANDARD_FORMAT_HEX_REGEX.test(hex)) {\n this._iso = isoCodeFromHex(this.bytes.slice(12, 15))\n } else {\n this._iso = null\n }\n }\n\n /**\n * Return the ISO code of this currency\n *\n * @returns ISO code if it exists, else null\n */\n iso(): string | null {\n return this._iso\n }\n\n /**\n * Constructs a Currency object\n *\n * @param val Currency object or a string representation of a currency\n */\n static from<T extends Hash160 | string>(value: T): Currency {\n if (value instanceof Currency) {\n return value\n }\n\n if (typeof value === 'string') {\n return new Currency(bytesFromRepresentation(value))\n }\n\n throw new Error('Cannot construct Currency from value given')\n }\n\n /**\n * Gets the JSON representation of a currency\n *\n * @returns JSON representation\n */\n toJSON(): string {\n const iso = this.iso()\n if (iso !== null) {\n return iso\n }\n return this.bytes.toString('hex').toUpperCase()\n }\n}\n\nexport { Currency }\n","import { Hash } from './hash'\nimport { Buffer } from 'buffer/'\n\n/**\n * Hash with a width of 128 bits\n */\nclass Hash128 extends Hash {\n static readonly width = 16\n static readonly ZERO_128: Hash128 = new Hash128(Buffer.alloc(Hash128.width))\n\n constructor(bytes: Buffer) {\n if (bytes && bytes.byteLength === 0) {\n bytes = Hash128.ZERO_128.bytes\n }\n\n super(bytes ?? Hash128.ZERO_128.bytes)\n }\n\n /**\n * Get the hex representation of a hash-128 bytes, allowing unset\n *\n * @returns hex String of this.bytes\n */\n toHex(): string {\n const hex = this.toBytes().toString('hex').toUpperCase()\n if (/^0+$/.exec(hex)) {\n return ''\n }\n return hex\n }\n}\n\nexport { Hash128 }\n","import { Hash } from './hash'\nimport { Buffer } from 'buffer/'\n\n/**\n * Hash with a width of 160 bits\n */\nclass Hash160 extends Hash {\n static readonly width = 20\n static readonly ZERO_160: Hash160 = new Hash160(Buffer.alloc(Hash160.width))\n\n constructor(bytes?: Buffer) {\n if (bytes && bytes.byteLength === 0) {\n bytes = Hash160.ZERO_160.bytes\n }\n\n super(bytes ?? Hash160.ZERO_160.bytes)\n }\n}\n\nexport { Hash160 }\n","import { Hash } from './hash'\nimport { Buffer } from 'buffer/'\n\n/**\n * Hash with a width of 256 bits\n */\nclass Hash256 extends Hash {\n static readonly width = 32\n static readonly ZERO_256 = new Hash256(Buffer.alloc(Hash256.width))\n\n constructor(bytes: Buffer) {\n super(bytes ?? Hash256.ZERO_256.bytes)\n }\n}\n\nexport { Hash256 }\n","import { Comparable } from './serialized-type'\nimport { BinaryParser } from '../serdes/binary-parser'\nimport { Buffer } from 'buffer/'\n\n/**\n * Base class defining how to encode and decode hashes\n */\nclass Hash extends Comparable {\n static readonly width: number\n\n constructor(bytes: Buffer) {\n super(bytes)\n if (this.bytes.byteLength !== (this.constructor as typeof Hash).width) {\n throw new Error(`Invalid Hash length ${this.bytes.byteLength}`)\n }\n }\n\n /**\n * Construct a Hash object from an existing Hash object or a hex-string\n *\n * @param value A hash object or hex-string of a hash\n */\n static from<T extends Hash | string>(value: T): Hash {\n if (value instanceof this) {\n return value\n }\n\n if (typeof value === 'string') {\n return new this(Buffer.from(value, 'hex'))\n }\n\n throw new Error('Cannot construct Hash from given value')\n }\n\n /**\n * Read a Hash object from a BinaryParser\n *\n * @param parser BinaryParser to read the hash from\n * @param hint length of the bytes to read, optional\n */\n static fromParser(parser: BinaryParser, hint?: number): Hash {\n return new this(parser.read(hint ?? this.width))\n }\n\n /**\n * Overloaded operator for comparing two hash objects\n *\n * @param other The Hash to compare this to\n */\n compareTo(other: Hash): number {\n return this.bytes.compare(\n (this.constructor as typeof Hash).from(other).bytes,\n )\n }\n\n /**\n * @returns the hex-string representation of this Hash\n */\n toString(): string {\n return this.toHex()\n }\n\n /**\n * Returns four bits at the specified depth within a hash\n *\n * @param depth The depth of the four bits\n * @returns The number represented by the four bits\n */\n nibblet(depth: number): number {\n const byteIx = depth > 0 ? (depth / 2) | 0 : 0\n let b = this.bytes[byteIx]\n if (depth % 2 === 0) {\n b = (b & 0xf0) >>> 4\n } else {\n b = b & 0x0f\n }\n return b\n }\n}\n\nexport { Hash }\n","import {\n Field,\n TransactionResult,\n TransactionType,\n LedgerEntryType,\n} from '../enums'\nimport { AccountID } from './account-id'\nimport { Amount } from './amount'\nimport { Blob } from './blob'\nimport { Currency } from './currency'\nimport { Hash128 } from './hash-128'\nimport { Hash160 } from './hash-160'\nimport { Hash256 } from './hash-256'\nimport { PathSet } from './path-set'\nimport { STArray } from './st-array'\nimport { STObject } from './st-object'\nimport { UInt16 } from './uint-16'\nimport { UInt32 } from './uint-32'\nimport { UInt64 } from './uint-64'\nimport { UInt8 } from './uint-8'\nimport { Vector256 } from './vector-256'\n\nconst coreTypes = {\n AccountID,\n Amount,\n Blob,\n Currency,\n Hash128,\n Hash160,\n Hash256,\n PathSet,\n STArray,\n STObject,\n UInt8,\n UInt16,\n UInt32,\n UInt64,\n Vector256,\n}\n\nObject.values(Field).forEach((field) => {\n field.associatedType = coreTypes[field.type.name]\n})\n\nField['TransactionType'].associatedType = TransactionType\nField['TransactionResult'].associatedType = TransactionResult\nField['LedgerEntryType'].associatedType = LedgerEntryType\n\nexport { coreTypes }\n","import { AccountID } from './account-id'\nimport { Currency } from './currency'\nimport { BinaryParser } from '../serdes/binary-parser'\nimport { SerializedType, JsonObject } from './serialized-type'\nimport { Buffer } from 'buffer/'\n\n/**\n * Constants for separating Paths in a PathSet\n */\nconst PATHSET_END_BYTE = 0x00\nconst PATH_SEPARATOR_BYTE = 0xff\n\n/**\n * Constant for masking types of a Hop\n */\nconst TYPE_ACCOUNT = 0x01\nconst TYPE_CURRENCY = 0x10\nconst TYPE_ISSUER = 0x20\n\n/**\n * The object representation of a Hop, an issuer AccountID, an account AccountID, and a Currency\n */\ninterface HopObject extends JsonObject {\n issuer?: string\n account?: string\n currency?: string\n}\n\n/**\n * TypeGuard for HopObject\n */\nfunction isHopObject(arg): arg is HopObject {\n return (\n arg.issuer !== undefined ||\n arg.account !== undefined ||\n arg.currency !== undefined\n )\n}\n\n/**\n * TypeGuard for PathSet\n */\nfunction isPathSet(arg): arg is Array<Array<HopObject>> {\n return (\n (Array.isArray(arg) && arg.length === 0) ||\n (Array.isArray(arg) && Array.isArray(arg[0]) && arg[0].length === 0) ||\n (Array.isArray(arg) && Array.isArray(arg[0]) && isHopObject(arg[0][0]))\n )\n}\n\n/**\n * Serialize and Deserialize a Hop\n */\nclass Hop extends SerializedType {\n /**\n * Create a Hop from a HopObject\n *\n * @param value Either a hop or HopObject to create a hop with\n * @returns a Hop\n */\n static from(value: Hop | HopObject): Hop {\n if (value instanceof Hop) {\n return value\n }\n\n const bytes: Array<Buffer> = [Buffer.from([0])]\n\n if (value.account) {\n bytes.push(AccountID.from(value.account).toBytes())\n bytes[0][0] |= TYPE_ACCOUNT\n }\n\n if (value.currency) {\n bytes.push(Currency.from(value.currency).toBytes())\n bytes[0][0] |= TYPE_CURRENCY\n }\n\n if (value.issuer) {\n bytes.push(AccountID.from(value.issuer).toBytes())\n bytes[0][0] |= TYPE_ISSUER\n }\n\n return new Hop(Buffer.concat(bytes))\n }\n\n /**\n * Construct a Hop from a BinaryParser\n *\n * @param parser BinaryParser to read the Hop from\n * @returns a Hop\n */\n static fromParser(parser: BinaryParser): Hop {\n const type = parser.readUInt8()\n const bytes: Array<Buffer> = [Buffer.from([type])]\n\n if (type & TYPE_ACCOUNT) {\n bytes.push(parser.read(AccountID.width))\n }\n\n if (type & TYPE_CURRENCY) {\n bytes.push(parser.read(Currency.width))\n }\n\n if (type & TYPE_ISSUER) {\n bytes.push(parser.read(AccountID.width))\n }\n\n return new Hop(Buffer.concat(bytes))\n }\n\n /**\n * Get the JSON interpretation of this hop\n *\n * @returns a HopObject, an JS object with optional account, issuer, and currency\n */\n toJSON(): HopObject {\n const hopParser = new BinaryParser(this.bytes.toString('hex'))\n const type = hopParser.readUInt8()\n\n let account, currency, issuer\n if (type & TYPE_ACCOUNT) {\n account = (AccountID.fromParser(hopParser) as AccountID).toJSON()\n }\n\n if (type & TYPE_CURRENCY) {\n currency = (Currency.fromParser(hopParser) as Currency).toJSON()\n }\n\n if (type & TYPE_ISSUER) {\n issuer = (AccountID.fromParser(hopParser) as AccountID).toJSON()\n }\n\n const result: HopObject = {}\n if (account) {\n result.account = account\n }\n\n if (issuer) {\n result.issuer = issuer\n }\n\n if (currency) {\n result.currency = currency\n }\n\n return result\n }\n\n /**\n * get a number representing the type of this hop\n *\n * @returns a number to be bitwise and-ed with TYPE_ constants to describe the types in the hop\n */\n type(): number {\n return this.bytes[0]\n }\n}\n\n/**\n * Class for serializing/deserializing Paths\n */\nclass Path extends SerializedType {\n /**\n * construct a Path from an array of Hops\n *\n * @param value Path or array of HopObjects to construct a Path\n * @returns the Path\n */\n static from(value: Path | Array<HopObject>): Path {\n if (value instanceof Path) {\n return value\n }\n\n const bytes: Array<Buffer> = []\n value.forEach((hop: HopObject) => {\n bytes.push(Hop.from(hop).toBytes())\n })\n\n return new Path(Buffer.concat(bytes))\n }\n\n /**\n * Read a Path from a BinaryParser\n *\n * @param parser BinaryParser to read Path from\n * @returns the Path represented by the bytes read from the BinaryParser\n */\n static fromParser(parser: BinaryParser): Path {\n const bytes: Array<Buffer> = []\n while (!parser.end()) {\n bytes.push(Hop.fromParser(parser).toBytes())\n\n if (\n parser.peek() === PATHSET_END_BYTE ||\n parser.peek() === PATH_SEPARATOR_BYTE\n ) {\n break\n }\n }\n return new Path(Buffer.concat(bytes))\n }\n\n /**\n * Get the JSON representation of this Path\n *\n * @returns an Array of HopObject constructed from this.bytes\n */\n toJSON(): Array<HopObject> {\n const json: Array<HopObject> = []\n const pathParser = new BinaryParser(this.toString())\n\n while (!pathParser.end()) {\n json.push(Hop.fromParser(pathParser).toJSON())\n }\n\n return json\n }\n}\n\n/**\n * Deserialize and Serialize the PathSet type\n */\nclass PathSet extends SerializedType {\n /**\n * Construct a PathSet from an Array of Arrays representing paths\n *\n * @param value A PathSet or Array of Array of HopObjects\n * @returns the PathSet constructed from value\n */\n static from<T extends PathSet | Array<Array<HopObject>>>(value: T): PathSet {\n if (value instanceof PathSet) {\n return value\n }\n\n if (isPathSet(value)) {\n const bytes: Array<Buffer> = []\n\n value.forEach((path: Array<HopObject>) => {\n bytes.push(Path.from(path).toBytes())\n bytes.push(Buffer.from([PATH_SEPARATOR_BYTE]))\n })\n\n bytes[bytes.length - 1] = Buffer.from([PATHSET_END_BYTE])\n\n return new PathSet(Buffer.concat(bytes))\n }\n\n throw new Error('Cannot construct PathSet from given value')\n }\n\n /**\n * Construct a PathSet from a BinaryParser\n *\n * @param parser A BinaryParser to read PathSet from\n * @returns the PathSet read from parser\n */\n static fromParser(parser: BinaryParser): PathSet {\n const bytes: Array<Buffer> = []\n\n while (!parser.end()) {\n bytes.push(Path.fromParser(parser).toBytes())\n bytes.push(parser.read(1))\n\n if (bytes[bytes.length - 1][0] == PATHSET_END_BYTE) {\n break\n }\n }\n\n return new PathSet(Buffer.concat(bytes))\n }\n\n /**\n * Get the JSON representation of this PathSet\n *\n * @returns an Array of Array of HopObjects, representing this PathSet\n */\n toJSON(): Array<Array<HopObject>> {\n const json: Array<Array<HopObject>> = []\n const pathParser = new BinaryParser(this.toString())\n\n while (!pathParser.end()) {\n json.push(Path.fromParser(pathParser).toJSON())\n pathParser.skip(1)\n }\n\n return json\n }\n}\n\nexport { PathSet }\n","import { BytesList } from '../serdes/binary-serializer'\nimport { BinaryParser } from '../serdes/binary-parser'\nimport bigInt = require('big-integer')\nimport { Buffer } from 'buffer/'\n\ntype JSON = string | number | boolean | null | undefined | JSON[] | JsonObject\n\ntype JsonObject = { [key: string]: JSON }\n\n/**\n * The base class for all binary-codec types\n */\nclass SerializedType {\n protected readonly bytes: Buffer = Buffer.alloc(0)\n\n constructor(bytes: Buffer) {\n this.bytes = bytes ?? Buffer.alloc(0)\n }\n\n static fromParser(parser: BinaryParser, hint?: number): SerializedType {\n throw new Error('fromParser not implemented')\n return this.fromParser(parser, hint)\n }\n\n static from(\n value: SerializedType | JSON | bigInt.BigInteger,\n ): SerializedType {\n throw new Error('from not implemented')\n return this.from(value)\n }\n\n /**\n * Write the bytes representation of a SerializedType to a BytesList\n *\n * @param list The BytesList to write SerializedType bytes to\n */\n toBytesSink(list: BytesList): void {\n list.put(this.bytes)\n }\n\n /**\n * Get the hex representation of a SerializedType's bytes\n *\n * @returns hex String of this.bytes\n */\n toHex(): string {\n return this.toBytes().toString('hex').toUpperCase()\n }\n\n /**\n * Get the bytes representation of a SerializedType\n *\n * @returns A buffer of the bytes\n */\n toBytes(): Buffer {\n if (this.bytes) {\n return this.bytes\n }\n const bytes = new BytesList()\n this.toBytesSink(bytes)\n return bytes.toBytes()\n }\n\n /**\n * Return the JSON representation of a SerializedType\n *\n * @returns any type, if not overloaded returns hexString representation of bytes\n */\n toJSON(): JSON {\n return this.toHex()\n }\n\n /**\n * @returns hexString representation of this.bytes\n */\n toString(): string {\n return this.toHex()\n }\n}\n\n/**\n * Base class for SerializedTypes that are comparable\n */\nclass Comparable extends SerializedType {\n lt(other: Comparable): boolean {\n return this.compareTo(other) < 0\n }\n\n eq(other: Comparable): boolean {\n return this.compareTo(other) === 0\n }\n\n gt(other: Comparable): boolean {\n return this.compareTo(other) > 0\n }\n\n gte(other: Comparable): boolean {\n return this.compareTo(other) > -1\n }\n\n lte(other: Comparable): boolean {\n return this.compareTo(other) < 1\n }\n\n /**\n * Overload this method to define how two Comparable SerializedTypes are compared\n *\n * @param other The comparable object to compare this to\n * @returns A number denoting the relationship of this and other\n */\n compareTo(other: Comparable): number {\n throw new Error(`cannot compare ${this.toString()} and ${other.toString()}`)\n }\n}\n\nexport { SerializedType, Comparable, JSON, JsonObject }\n","import { SerializedType, JsonObject } from './serialized-type'\nimport { STObject } from './st-object'\nimport { BinaryParser } from '../serdes/binary-parser'\nimport { Buffer } from 'buffer/'\n\nconst ARRAY_END_MARKER = Buffer.from([0xf1])\nconst ARRAY_END_MARKER_NAME = 'ArrayEndMarker'\n\nconst OBJECT_END_MARKER = Buffer.from([0xe1])\n\n/**\n * TypeGuard for Array<JsonObject>\n */\nfunction isObjects(args): args is Array<JsonObject> {\n return (\n Array.isArray(args) && (args.length === 0 || typeof args[0] === 'object')\n )\n}\n\n/**\n * Class for serializing and deserializing Arrays of Objects\n */\nclass STArray extends SerializedType {\n /**\n * Construct an STArray from a BinaryParser\n *\n * @param parser BinaryParser to parse an STArray from\n * @returns An STArray Object\n */\n static fromParser(parser: BinaryParser): STArray {\n const bytes: Array<Buffer> = []\n\n while (!parser.end()) {\n const field = parser.readField()\n if (field.name === ARRAY_END_MARKER_NAME) {\n break\n }\n\n bytes.push(\n field.header,\n parser.readFieldValue(field).toBytes(),\n OBJECT_END_MARKER,\n )\n }\n\n bytes.push(ARRAY_END_MARKER)\n return new STArray(Buffer.concat(bytes))\n }\n\n /**\n * Construct an STArray from an Array of JSON Objects\n *\n * @param value STArray or Array of Objects to parse into an STArray\n * @returns An STArray object\n */\n static from<T extends STArray | Array<JsonObject>>(value: T): STArray {\n if (value instanceof STArray) {\n return value\n }\n\n if (isObjects(value)) {\n const bytes: Array<Buffer> = []\n value.forEach((obj) => {\n bytes.push(STObject.from(obj).toBytes())\n })\n\n bytes.push(ARRAY_END_MARKER)\n return new STArray(Buffer.concat(bytes))\n }\n\n throw new Error('Cannot construct STArray from value given')\n }\n\n /**\n * Return the JSON representation of this.bytes\n *\n * @returns An Array of JSON objects\n */\n toJSON(): Array<JsonObject> {\n const result: Array<JsonObject> = []\n\n const arrayParser = new BinaryParser(this.toString())\n\n while (!arrayParser.end()) {\n const field = arrayParser.readField()\n if (field.name === ARRAY_END_MARKER_NAME) {\n break\n }\n\n const outer = {}\n outer[field.name] = STObject.fromParser(arrayParser).toJSON()\n result.push(outer)\n }\n\n return result\n }\n}\n\nexport { STArray }\n","import { Field, FieldInstance, Bytes } from '../enums'\nimport { SerializedType, JsonObject } from './serialized-type'\nimport { xAddressToClassicAddress, isValidXAddress } from 'ripple-address-codec'\nimport { BinaryParser } from '../serdes/binary-parser'\nimport { BinarySerializer, BytesList } from '../serdes/binary-serializer'\nimport { Buffer } from 'buffer/'\n\nconst OBJECT_END_MARKER_BYTE = Buffer.from([0xe1])\nconst OBJECT_END_MARKER = 'ObjectEndMarker'\nconst ST_OBJECT = 'STObject'\nconst DESTINATION = 'Destination'\nconst ACCOUNT = 'Account'\nconst SOURCE_TAG = 'SourceTag'\nconst DEST_TAG = 'DestinationTag'\n\n/**\n * Break down an X-Address into an account and a tag\n *\n * @param field Name of field\n * @param xAddress X-Address corresponding to the field\n */\nfunction handleXAddress(field: string, xAddress: string): JsonObject {\n const decoded = xAddressToClassicAddress(xAddress)\n\n let tagName\n if (field === DESTINATION) tagName = DEST_TAG\n else if (field === ACCOUNT) tagName = SOURCE_TAG\n else if (decoded.tag !== false)\n throw new Error(`${field} cannot have an associated tag`)\n\n return decoded.tag !== false\n ? { [field]: decoded.classicAddress, [tagName]: decoded.tag }\n : { [field]: decoded.classicAddress }\n}\n\n/**\n * Validate that two objects don't both have the same tag fields\n *\n * @param obj1 First object to check for tags\n * @param obj2 Second object to check for tags\n * @throws When both objects have SourceTag or DestinationTag\n */\nfunction checkForDuplicateTags(obj1: JsonObject, obj2: JsonObject): void {\n if (!(obj1[SOURCE_TAG] === undefined || obj2[SOURCE_TAG] === undefined))\n throw new Error('Cannot have Account X-Address and SourceTag')\n if (!(obj1[DEST_TAG] === undefined || obj2[DEST_TAG] === undefined))\n throw new Error('Cannot have Destination X-Address and DestinationTag')\n}\n\n/**\n * Class for Serializing/Deserializing objects\n */\nclass STObject extends SerializedType {\n /**\n * Construct a STObject from a BinaryParser\n *\n * @param parser BinaryParser to read STObject from\n * @returns A STObject object\n */\n static fromParser(parser: BinaryParser): STObject {\n const list: BytesList = new BytesList()\n const bytes: BinarySerializer = new BinarySerializer(list)\n\n while (!parser.end()) {\n const field = parser.readField()\n if (field.name === OBJECT_END_MARKER) {\n break\n }\n\n const associatedValue = parser.readFieldValue(field)\n\n bytes.writeFieldAndValue(field, associatedValue)\n if (field.type.name === ST_OBJECT) {\n bytes.put(OBJECT_END_MARKER_BYTE)\n }\n }\n\n return new STObject(list.toBytes())\n }\n\n /**\n * Construct a STObject from a JSON object\n *\n * @param value An object to include\n * @param filter optional, denote which field to include in serialized object\n * @returns a STObject object\n */\n static from<T extends STObject | JsonObject>(\n value: T,\n filter?: (...any) => boolean,\n ): STObject {\n if (value instanceof STObject) {\n return value\n }\n\n const list: BytesList = new BytesList()\n const bytes: BinarySerializer = new BinarySerializer(list)\n\n let isUnlModify = false\n\n const xAddressDecoded = Object.entries(value).reduce((acc, [key, val]) => {\n let handled: JsonObject | undefined = undefined\n if (val && isValidXAddress(val.toString())) {\n handled = handleXAddress(key, val.toString())\n checkForDuplicateTags(handled, value)\n }\n return Object.assign(acc, handled ?? { [key]: val })\n }, {})\n\n let sorted = Object.keys(xAddressDecoded)\n .map((f: string): FieldInstance => Field[f] as FieldInstance)\n .filter(\n (f: FieldInstance): boolean =>\n f !== undefined &&\n xAddressDecoded[f.name] !== undefined &&\n f.isSerialized,\n )\n .sort((a, b) => {\n return a.ordinal - b.ordinal\n })\n\n if (filter !== undefined) {\n sorted = sorted.filter(filter)\n }\n\n sorted.forEach((field) => {\n const associatedValue = field.associatedType.from(\n xAddressDecoded[field.name],\n )\n\n if (associatedValue == undefined) {\n throw new TypeError(\n `Unable to interpret \"${field.name}: ${\n xAddressDecoded[field.name]\n }\".`,\n )\n }\n\n if ((associatedValue as unknown as Bytes).name === 'UNLModify') {\n // triggered when the TransactionType field has a value of 'UNLModify'\n isUnlModify = true\n }\n // true when in the UNLModify pseudotransaction (after the transaction type has been processed) and working with the\n // Account field\n // The Account field must not be a part of the UNLModify pseudotransaction encoding, due to a bug in rippled\n const isUnlModifyWorkaround = field.name == 'Account' && isUnlModify\n bytes.writeFieldAndValue(field, associatedValue, isUnlModifyWorkaround)\n if (field.type.name === ST_OBJECT) {\n bytes.put(OBJECT_END_MARKER_BYTE)\n }\n })\n\n return new STObject(list.toBytes())\n }\n\n /**\n * Get the JSON interpretation of this.bytes\n *\n * @returns a JSON object\n */\n toJSON(): JsonObject {\n const objectParser = new BinaryParser(this.toString())\n const accumulator = {}\n\n while (!objectParser.end()) {\n const field = objectParser.readField()\n if (field.name === OBJECT_END_MARKER) {\n break\n }\n accumulator[field.name] = objectParser.readFieldValue(field).toJSON()\n }\n\n return accumulator\n }\n}\n\nexport { STObject }\n","import { UInt } from './uint'\nimport { BinaryParser } from '../serdes/binary-parser'\nimport { Buffer } from 'buffer/'\n\n/**\n * Derived UInt class for serializing/deserializing 16 bit UInt\n */\nclass UInt16 extends UInt {\n protected static readonly width: number = 16 / 8 // 2\n static readonly defaultUInt16: UInt16 = new UInt16(Buffer.alloc(UInt16.width))\n\n constructor(bytes: Buffer) {\n super(bytes ?? UInt16.defaultUInt16.bytes)\n }\n\n static fromParser(parser: BinaryParser): UInt {\n return new UInt16(parser.read(UInt16.width))\n }\n\n /**\n * Construct a UInt16 object from a number\n *\n * @param val UInt16 object or number\n */\n static from<T extends UInt16 | number>(val: T): UInt16 {\n if (val instanceof UInt16) {\n return val\n }\n\n if (typeof val === 'number') {\n const buf = Buffer.alloc(UInt16.width)\n buf.writeUInt16BE(val, 0)\n return new UInt16(buf)\n }\n\n throw new Error('Can not construct UInt16 with given value')\n }\n\n /**\n * get the value of a UInt16 object\n *\n * @returns the number represented by this.bytes\n */\n valueOf(): number {\n return this.bytes.readUInt16BE(0)\n }\n}\n\nexport { UInt16 }\n","import { UInt } from './uint'\nimport { BinaryParser } from '../serdes/binary-parser'\nimport { Buffer } from 'buffer/'\n\n/**\n * Derived UInt class for serializing/deserializing 32 bit UInt\n */\nclass UInt32 extends UInt {\n protected static readonly width: number = 32 / 8 // 4\n static readonly defaultUInt32: UInt32 = new UInt32(Buffer.alloc(UInt32.width))\n\n constructor(bytes: Buffer) {\n super(bytes ?? UInt32.defaultUInt32.bytes)\n }\n\n static fromParser(parser: BinaryParser): UInt {\n return new UInt32(parser.read(UInt32.width))\n }\n\n /**\n * Construct a UInt32 object from a number\n *\n * @param val UInt32 object or number\n */\n static from<T extends UInt32 | number | string>(val: T): UInt32 {\n if (val instanceof UInt32) {\n return val\n }\n\n const buf = Buffer.alloc(UInt32.width)\n\n if (typeof val === 'string') {\n const num = Number.parseInt(val)\n buf.writeUInt32BE(num, 0)\n return new UInt32(buf)\n }\n\n if (typeof val === 'number') {\n buf.writeUInt32BE(val, 0)\n return new UInt32(buf)\n }\n\n throw new Error('Cannot construct UInt32 from given value')\n }\n\n /**\n * get the value of a UInt32 object\n *\n * @returns the number represented by this.bytes\n */\n valueOf(): number {\n return this.bytes.readUInt32BE(0)\n }\n}\n\nexport { UInt32 }\n","import { UInt } from './uint'\nimport { BinaryParser } from '../serdes/binary-parser'\nimport bigInt = require('big-integer')\nimport { isInstance } from 'big-integer'\nimport { Buffer } from 'buffer/'\n\nconst HEX_REGEX = /^[a-fA-F0-9]{1,16}$/\nconst mask = bigInt(0x00000000ffffffff)\n\n/**\n * Derived UInt class for serializing/deserializing 64 bit UInt\n */\nclass UInt64 extends UInt {\n protected static readonly width: number = 64 / 8 // 8\n static readonly defaultUInt64: UInt64 = new UInt64(Buffer.alloc(UInt64.width))\n\n constructor(bytes: Buffer) {\n super(bytes ?? UInt64.defaultUInt64.bytes)\n }\n\n static fromParser(parser: BinaryParser): UInt {\n return new UInt64(parser.read(UInt64.width))\n }\n\n /**\n * Construct a UInt64 object\n *\n * @param val A UInt64, hex-string, bigInt, or number\n * @returns A UInt64 object\n */\n static from<T extends UInt64 | string | bigInt.BigInteger | number>(\n val: T,\n ): UInt64 {\n if (val instanceof UInt64) {\n return val\n }\n\n let buf = Buffer.alloc(UInt64.width)\n\n if (typeof val === 'number') {\n if (val < 0) {\n throw new Error('value must be an unsigned integer')\n }\n\n const number = bigInt(val)\n\n const intBuf = [Buffer.alloc(4), Buffer.alloc(4)]\n intBuf[0].writeUInt32BE(Number(number.shiftRight(32)), 0)\n intBuf[1].writeUInt32BE(Number(number.and(mask)), 0)\n\n return new UInt64(Buffer.concat(intBuf))\n }\n\n if (typeof val === 'string') {\n if (!HEX_REGEX.test(val)) {\n throw new Error(`${val} is not a valid hex-string`)\n }\n\n const strBuf = val.padStart(16, '0')\n buf = Buffer.from(strBuf, 'hex')\n return new UInt64(buf)\n }\n\n if (isInstance(val)) {\n const intBuf = [Buffer.alloc(4), Buffer.alloc(4)]\n intBuf[0].writeUInt32BE(Number(val.shiftRight(bigInt(32))), 0)\n intBuf[1].writeUInt32BE(Number(val.and(mask)), 0)\n\n return new UInt64(Buffer.concat(intBuf))\n }\n\n throw new Error('Cannot construct UInt64 from given value')\n }\n\n /**\n * The JSON representation of a UInt64 object\n *\n * @returns a hex-string\n */\n toJSON(): string {\n return this.bytes.toString('hex').toUpperCase()\n }\n\n /**\n * Get the value of the UInt64\n *\n * @returns the number represented buy this.bytes\n */\n valueOf(): bigInt.BigInteger {\n const msb = bigInt(this.bytes.slice(0, 4).readUInt32BE(0))\n const lsb = bigInt(this.bytes.slice(4).readUInt32BE(0))\n return msb.shiftLeft(bigInt(32)).or(lsb)\n }\n\n /**\n * Get the bytes representation of the UInt64 object\n *\n * @returns 8 bytes representing the UInt64\n */\n toBytes(): Buffer {\n return this.bytes\n }\n}\n\nexport { UInt64 }\n","import { UInt } from './uint'\nimport { BinaryParser } from '../serdes/binary-parser'\nimport { Buffer } from 'buffer/'\n\n/**\n * Derived UInt class for serializing/deserializing 8 bit UInt\n */\nclass UInt8 extends UInt {\n protected static readonly width: number = 8 / 8 // 1\n static readonly defaultUInt8: UInt8 = new UInt8(Buffer.alloc(UInt8.width))\n\n constructor(bytes: Buffer) {\n super(bytes ?? UInt8.defaultUInt8.bytes)\n }\n\n static fromParser(parser: BinaryParser): UInt {\n return new UInt8(parser.read(UInt8.width))\n }\n\n /**\n * Construct a UInt8 object from a number\n *\n * @param val UInt8 object or number\n */\n static from<T extends UInt8 | number>(val: T): UInt8 {\n if (val instanceof UInt8) {\n return val\n }\n\n if (typeof val === 'number') {\n const buf = Buffer.alloc(UInt8.width)\n buf.writeUInt8(val, 0)\n return new UInt8(buf)\n }\n\n throw new Error('Cannot construct UInt8 from given value')\n }\n\n /**\n * get the value of a UInt8 object\n *\n * @returns the number represented by this.bytes\n */\n valueOf(): number {\n return this.bytes.readUInt8(0)\n }\n}\n\nexport { UInt8 }\n","import bigInt = require('big-integer')\nimport { Comparable } from './serialized-type'\nimport { Buffer } from 'buffer/'\n\n/**\n * Compare numbers and bigInts n1 and n2\n *\n * @param n1 First object to compare\n * @param n2 Second object to compare\n * @returns -1, 0, or 1, depending on how the two objects compare\n */\nfunction compare(\n n1: number | bigInt.BigInteger,\n n2: number | bigInt.BigInteger,\n): number {\n return n1 < n2 ? -1 : n1 == n2 ? 0 : 1\n}\n\n/**\n * Base class for serializing and deserializing unsigned integers.\n */\nabstract class UInt extends Comparable {\n protected static width: number\n\n constructor(bytes: Buffer) {\n super(bytes)\n }\n\n /**\n * Overload of compareTo for Comparable\n *\n * @param other other UInt to compare this to\n * @returns -1, 0, or 1 depending on how the objects relate to each other\n */\n compareTo(other: UInt): number {\n return compare(this.valueOf(), other.valueOf())\n }\n\n /**\n * Convert a UInt object to JSON\n *\n * @returns number or string represented by this.bytes\n */\n toJSON(): number | string {\n const val = this.valueOf()\n return typeof val === 'number' ? val : val.toString()\n }\n\n /**\n * Get the value of the UInt represented by this.bytes\n *\n * @returns the value\n */\n abstract valueOf(): number | bigInt.BigInteger\n}\n\nexport { UInt }\n","import { SerializedType } from './serialized-type'\nimport { BinaryParser } from '../serdes/binary-parser'\nimport { Hash256 } from './hash-256'\nimport { BytesList } from '../serdes/binary-serializer'\nimport { Buffer } from 'buffer/'\n\n/**\n * TypeGuard for Array<string>\n */\nfunction isStrings(arg): arg is Array<string> {\n return Array.isArray(arg) && (arg.length === 0 || typeof arg[0] === 'string')\n}\n\n/**\n * Class for serializing and deserializing vectors of Hash256\n */\nclass Vector256 extends SerializedType {\n constructor(bytes: Buffer) {\n super(bytes)\n }\n\n /**\n * Construct a Vector256 from a BinaryParser\n *\n * @param parser BinaryParser to\n * @param hint length of the vector, in bytes, optional\n * @returns a Vector256 object\n */\n static fromParser(parser: BinaryParser, hint?: number): Vector256 {\n const bytesList = new BytesList()\n const bytes = hint ?? parser.size()\n const hashes = bytes / 32\n for (let i = 0; i < hashes; i++) {\n Hash256.fromParser(parser).toBytesSink(bytesList)\n }\n return new Vector256(bytesList.toBytes())\n }\n\n /**\n * Construct a Vector256 object from an array of hashes\n *\n * @param value A Vector256 object or array of hex-strings representing Hash256's\n * @returns a Vector256 object\n */\n static from<T extends Vector256 | Array<string>>(value: T): Vector256 {\n if (value instanceof Vector256) {\n return value\n }\n\n if (isStrings(value)) {\n const bytesList = new BytesList()\n value.forEach((hash) => {\n Hash256.from(hash).toBytesSink(bytesList)\n })\n return new Vector256(bytesList.toBytes())\n }\n\n throw new Error('Cannot construct Vector256 from given value')\n }\n\n /**\n * Return an Array of hex-strings represented by this.bytes\n *\n * @returns An Array of strings representing the Hash256 objects\n */\n toJSON(): Array<string> {\n if (this.bytes.byteLength % 32 !== 0) {\n throw new Error('Invalid bytes for Vector256')\n }\n\n const result: Array<string> = []\n for (let i = 0; i < this.bytes.byteLength; i += 32) {\n result.push(\n this.bytes\n .slice(i, i + 32)\n .toString('hex')\n .toUpperCase(),\n )\n }\n return result\n }\n}\n\nexport { Vector256 }\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author Feross Aboukhadijeh <https://feross.org>\n * @license MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar customInspectSymbol =\n (typeof Symbol === 'function' && typeof Symbol.for === 'function')\n ? Symbol.for('nodejs.util.inspect.custom')\n : null\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\nvar K_MAX_LENGTH = 0x7fffffff\nexports.kMaxLength = K_MAX_LENGTH\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n * === true Use Uint8Array implementation (fastest)\n * === false Print warning and recommend using `buffer` v4.x which has an Object\n * implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * We report that the browser does not support typed arrays if the are not subclassable\n * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`\n * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support\n * for __proto__ and has a buggy typed array implementation.\n */\nBuffer.TYPED_ARRAY_SUPPORT = typedArraySupport()\n\nif (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&\n typeof console.error === 'function') {\n console.error(\n 'This browser lacks typed array (Uint8Array) support which is required by ' +\n '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'\n )\n}\n\nfunction typedArraySupport () {\n // Can typed array instances can be augmented?\n try {\n var arr = new Uint8Array(1)\n var proto = { foo: function () { return 42 } }\n Object.setPrototypeOf(proto, Uint8Array.prototype)\n Object.setPrototypeOf(arr, proto)\n return arr.foo() === 42\n } catch (e) {\n return false\n }\n}\n\nObject.defineProperty(Buffer.prototype, 'parent', {\n enumerable: true,\n get: function () {\n if (!Buffer.isBuffer(this)) return undefined\n return this.buffer\n }\n})\n\nObject.defineProperty(Buffer.prototype, 'offset', {\n enumerable: true,\n get: function () {\n if (!Buffer.isBuffer(this)) return undefined\n return this.byteOffset\n }\n})\n\nfunction createBuffer (length) {\n if (length > K_MAX_LENGTH) {\n throw new RangeError('The value \"' + length + '\" is invalid for option \"size\"')\n }\n // Return an augmented `Uint8Array` instance\n var buf = new Uint8Array(length)\n Object.setPrototypeOf(buf, Buffer.prototype)\n return buf\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n // Common case.\n if (typeof arg === 'number') {\n if (typeof encodingOrOffset === 'string') {\n throw new TypeError(\n 'The \"string\" argument must be of type string. Received type number'\n )\n }\n return allocUnsafe(arg)\n }\n return from(arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\nfunction from (value, encodingOrOffset, length) {\n if (typeof value === 'string') {\n return fromString(value, encodingOrOffset)\n }\n\n if (ArrayBuffer.isView(value)) {\n return fromArrayLike(value)\n }\n\n if (value == null) {\n throw new TypeError(\n 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n 'or Array-like Object. Received type ' + (typeof value)\n )\n }\n\n if (isInstance(value, ArrayBuffer) ||\n (value && isInstance(value.buffer, ArrayBuffer))) {\n return fromArrayBuffer(value, encodingOrOffset, length)\n }\n\n if (typeof SharedArrayBuffer !== 'undefined' &&\n (isInstance(value, SharedArrayBuffer) ||\n (value && isInstance(value.buffer, SharedArrayBuffer)))) {\n return fromArrayBuffer(value, encodingOrOffset, length)\n }\n\n if (typeof value === 'number') {\n throw new TypeError(\n 'The \"value\" argument must not be of type number. Received type number'\n )\n }\n\n var valueOf = value.valueOf && value.valueOf()\n if (valueOf != null && valueOf !== value) {\n return Buffer.from(valueOf, encodingOrOffset, length)\n }\n\n var b = fromObject(value)\n if (b) return b\n\n if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&\n typeof value[Symbol.toPrimitive] === 'function') {\n return Buffer.from(\n value[Symbol.toPrimitive]('string'), encodingOrOffset, length\n )\n }\n\n throw new TypeError(\n 'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +\n 'or Array-like Object. Received type ' + (typeof value)\n )\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n return from(value, encodingOrOffset, length)\n}\n\n// Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:\n// https://github.com/feross/buffer/pull/148\nObject.setPrototypeOf(Buffer.prototype, Uint8Array.prototype)\nObject.setPrototypeOf(Buffer, Uint8Array)\n\nfunction assertSize (size) {\n if (typeof size !== 'number') {\n throw new TypeError('\"size\" argument must be of type number')\n } else if (size < 0) {\n throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n }\n}\n\nfunction alloc (size, fill, encoding) {\n assertSize(size)\n if (size <= 0) {\n return createBuffer(size)\n }\n if (fill !== undefined) {\n // Only pay attention to encoding if it's a string. This\n // prevents accidentally sending in a number that would\n // be interpretted as a start offset.\n return typeof encoding === 'string'\n ? createBuffer(size).fill(fill, encoding)\n : createBuffer(size).fill(fill)\n }\n return createBuffer(size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n return alloc(size, fill, encoding)\n}\n\nfunction allocUnsafe (size) {\n assertSize(size)\n return createBuffer(size < 0 ? 0 : checked(size) | 0)\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n return allocUnsafe(size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n return allocUnsafe(size)\n}\n\nfunction fromString (string, encoding) {\n if (typeof encoding !== 'string' || encoding === '') {\n encoding = 'utf8'\n }\n\n if (!Buffer.isEncoding(encoding)) {\n throw new TypeError('Unknown encoding: ' + encoding)\n }\n\n var length = byteLength(string, encoding) | 0\n var buf = createBuffer(length)\n\n var actual = buf.write(string, encoding)\n\n if (actual !== length) {\n // Writing a hex string, for example, that contains invalid characters will\n // cause everything after the first invalid character to be ignored. (e.g.\n // 'abxxcd' will be treated as 'ab')\n buf = buf.slice(0, actual)\n }\n\n return buf\n}\n\nfunction fromArrayLike (array) {\n var length = array.length < 0 ? 0 : checked(array.length) | 0\n var buf = createBuffer(length)\n for (var i = 0; i < length; i += 1) {\n buf[i] = array[i] & 255\n }\n return buf\n}\n\nfunction fromArrayBuffer (array, byteOffset, length) {\n if (byteOffset < 0 || array.byteLength < byteOffset) {\n throw new RangeError('\"offset\" is outside of buffer bounds')\n }\n\n if (array.byteLength < byteOffset + (length || 0)) {\n throw new RangeError('\"length\" is outside of buffer bounds')\n }\n\n var buf\n if (byteOffset === undefined && length === undefined) {\n buf = new Uint8Array(array)\n } else if (length === undefined) {\n buf = new Uint8Array(array, byteOffset)\n } else {\n buf = new Uint8Array(array, byteOffset, length)\n }\n\n // Return an augmented `Uint8Array` instance\n Object.setPrototypeOf(buf, Buffer.prototype)\n\n return buf\n}\n\nfunction fromObject (obj) {\n if (Buffer.isBuffer(obj)) {\n var len = checked(obj.length) | 0\n var buf = createBuffer(len)\n\n if (buf.length === 0) {\n return buf\n }\n\n obj.copy(buf, 0, 0, len)\n return buf\n }\n\n if (obj.length !== undefined) {\n if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {\n return createBuffer(0)\n }\n return fromArrayLike(obj)\n }\n\n if (obj.type === 'Buffer' && Array.isArray(obj.data)) {\n return fromArrayLike(obj.data)\n }\n}\n\nfunction checked (length) {\n // Note: cannot use `length < K_MAX_LENGTH` here because that fails when\n // length is NaN (which is otherwise coerced to zero.)\n if (length >= K_MAX_LENGTH) {\n throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n 'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')\n }\n return length | 0\n}\n\nfunction SlowBuffer (length) {\n if (+length != length) { // eslint-disable-line eqeqeq\n length = 0\n }\n return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n return b != null && b._isBuffer === true &&\n b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false\n}\n\nBuffer.compare = function compare (a, b) {\n if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)\n if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)\n if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n throw new TypeError(\n 'The \"buf1\", \"buf2\" arguments must be one of type Buffer or Uint8Array'\n )\n }\n\n if (a === b) return 0\n\n var x = a.length\n var y = b.length\n\n for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n if (a[i] !== b[i]) {\n x = a[i]\n y = b[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n switch (String(encoding).toLowerCase()) {\n case 'hex':\n case 'utf8':\n case 'utf-8':\n case 'ascii':\n case 'latin1':\n case 'binary':\n case 'base64':\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return true\n default:\n return false\n }\n}\n\nBuffer.concat = function concat (list, length) {\n if (!Array.isArray(list)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n\n if (list.length === 0) {\n return Buffer.alloc(0)\n }\n\n var i\n if (length === undefined) {\n length = 0\n for (i = 0; i < list.length; ++i) {\n length += list[i].length\n }\n }\n\n var buffer = Buffer.allocUnsafe(length)\n var pos = 0\n for (i = 0; i < list.length; ++i) {\n var buf = list[i]\n if (isInstance(buf, Uint8Array)) {\n buf = Buffer.from(buf)\n }\n if (!Buffer.isBuffer(buf)) {\n throw new TypeError('\"list\" argument must be an Array of Buffers')\n }\n buf.copy(buffer, pos)\n pos += buf.length\n }\n return buffer\n}\n\nfunction byteLength (string, encoding) {\n if (Buffer.isBuffer(string)) {\n return string.length\n }\n if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {\n return string.byteLength\n }\n if (typeof string !== 'string') {\n throw new TypeError(\n 'The \"string\" argument must be one of type string, Buffer, or ArrayBuffer. ' +\n 'Received type ' + typeof string\n )\n }\n\n var len = string.length\n var mustMatch = (arguments.length > 2 && arguments[2] === true)\n if (!mustMatch && len === 0) return 0\n\n // Use a for loop to avoid recursion\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'ascii':\n case 'latin1':\n case 'binary':\n return len\n case 'utf8':\n case 'utf-8':\n return utf8ToBytes(string).length\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return len * 2\n case 'hex':\n return len >>> 1\n case 'base64':\n return base64ToBytes(string).length\n default:\n if (loweredCase) {\n return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8\n }\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n var loweredCase = false\n\n // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n // property of a typed array.\n\n // This behaves neither like String nor Uint8Array in that we set start/end\n // to their upper/lower bounds if the value passed is out of range.\n // undefined is handled specially as per ECMA-262 6th Edition,\n // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n if (start === undefined || start < 0) {\n start = 0\n }\n // Return early if start > this.length. Done here to prevent potential uint32\n // coercion fail below.\n if (start > this.length) {\n return ''\n }\n\n if (end === undefined || end > this.length) {\n end = this.length\n }\n\n if (end <= 0) {\n return ''\n }\n\n // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n end >>>= 0\n start >>>= 0\n\n if (end <= start) {\n return ''\n }\n\n if (!encoding) encoding = 'utf8'\n\n while (true) {\n switch (encoding) {\n case 'hex':\n return hexSlice(this, start, end)\n\n case 'utf8':\n case 'utf-8':\n return utf8Slice(this, start, end)\n\n case 'ascii':\n return asciiSlice(this, start, end)\n\n case 'latin1':\n case 'binary':\n return latin1Slice(this, start, end)\n\n case 'base64':\n return base64Slice(this, start, end)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return utf16leSlice(this, start, end)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = (encoding + '').toLowerCase()\n loweredCase = true\n }\n }\n}\n\n// This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)\n// to detect a Buffer instance. It's not possible to use `instanceof Buffer`\n// reliably in a browserify context because there could be multiple different\n// copies of the 'buffer' package in use. This method works even for Buffer\n// instances that were created from another copy of the `buffer` package.\n// See: https://github.com/feross/buffer/issues/154\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n var i = b[n]\n b[n] = b[m]\n b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n var len = this.length\n if (len % 2 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 16-bits')\n }\n for (var i = 0; i < len; i += 2) {\n swap(this, i, i + 1)\n }\n return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n var len = this.length\n if (len % 4 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 32-bits')\n }\n for (var i = 0; i < len; i += 4) {\n swap(this, i, i + 3)\n swap(this, i + 1, i + 2)\n }\n return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n var len = this.length\n if (len % 8 !== 0) {\n throw new RangeError('Buffer size must be a multiple of 64-bits')\n }\n for (var i = 0; i < len; i += 8) {\n swap(this, i, i + 7)\n swap(this, i + 1, i + 6)\n swap(this, i + 2, i + 5)\n swap(this, i + 3, i + 4)\n }\n return this\n}\n\nBuffer.prototype.toString = function toString () {\n var length = this.length\n if (length === 0) return ''\n if (arguments.length === 0) return utf8Slice(this, 0, length)\n return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.toLocaleString = Buffer.prototype.toString\n\nBuffer.prototype.equals = function equals (b) {\n if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n if (this === b) return true\n return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n var str = ''\n var max = exports.INSPECT_MAX_BYTES\n str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()\n if (this.length > max) str += ' ... '\n return '<Buffer ' + str + '>'\n}\nif (customInspectSymbol) {\n Buffer.prototype[customInspectSymbol] = Buffer.prototype.inspect\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n if (isInstance(target, Uint8Array)) {\n target = Buffer.from(target, target.offset, target.byteLength)\n }\n if (!Buffer.isBuffer(target)) {\n throw new TypeError(\n 'The \"target\" argument must be one of type Buffer or Uint8Array. ' +\n 'Received type ' + (typeof target)\n )\n }\n\n if (start === undefined) {\n start = 0\n }\n if (end === undefined) {\n end = target ? target.length : 0\n }\n if (thisStart === undefined) {\n thisStart = 0\n }\n if (thisEnd === undefined) {\n thisEnd = this.length\n }\n\n if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n throw new RangeError('out of range index')\n }\n\n if (thisStart >= thisEnd && start >= end) {\n return 0\n }\n if (thisStart >= thisEnd) {\n return -1\n }\n if (start >= end) {\n return 1\n }\n\n start >>>= 0\n end >>>= 0\n thisStart >>>= 0\n thisEnd >>>= 0\n\n if (this === target) return 0\n\n var x = thisEnd - thisStart\n var y = end - start\n var len = Math.min(x, y)\n\n var thisCopy = this.slice(thisStart, thisEnd)\n var targetCopy = target.slice(start, end)\n\n for (var i = 0; i < len; ++i) {\n if (thisCopy[i] !== targetCopy[i]) {\n x = thisCopy[i]\n y = targetCopy[i]\n break\n }\n }\n\n if (x < y) return -1\n if (y < x) return 1\n return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n // Empty buffer means no match\n if (buffer.length === 0) return -1\n\n // Normalize byteOffset\n if (typeof byteOffset === 'string') {\n encoding = byteOffset\n byteOffset = 0\n } else if (byteOffset > 0x7fffffff) {\n byteOffset = 0x7fffffff\n } else if (byteOffset < -0x80000000) {\n byteOffset = -0x80000000\n }\n byteOffset = +byteOffset // Coerce to Number.\n if (numberIsNaN(byteOffset)) {\n // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n byteOffset = dir ? 0 : (buffer.length - 1)\n }\n\n // Normalize byteOffset: negative offsets start from the end of the buffer\n if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n if (byteOffset >= buffer.length) {\n if (dir) return -1\n else byteOffset = buffer.length - 1\n } else if (byteOffset < 0) {\n if (dir) byteOffset = 0\n else return -1\n }\n\n // Normalize val\n if (typeof val === 'string') {\n val = Buffer.from(val, encoding)\n }\n\n // Finally, search either indexOf (if dir is true) or lastIndexOf\n if (Buffer.isBuffer(val)) {\n // Special case: looking for empty string/buffer always fails\n if (val.length === 0) {\n return -1\n }\n return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n } else if (typeof val === 'number') {\n val = val & 0xFF // Search for a byte value [0-255]\n if (typeof Uint8Array.prototype.indexOf === 'function') {\n if (dir) {\n return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n } else {\n return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n }\n }\n return arrayIndexOf(buffer, [val], byteOffset, encoding, dir)\n }\n\n throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n var indexSize = 1\n var arrLength = arr.length\n var valLength = val.length\n\n if (encoding !== undefined) {\n encoding = String(encoding).toLowerCase()\n if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n encoding === 'utf16le' || encoding === 'utf-16le') {\n if (arr.length < 2 || val.length < 2) {\n return -1\n }\n indexSize = 2\n arrLength /= 2\n valLength /= 2\n byteOffset /= 2\n }\n }\n\n function read (buf, i) {\n if (indexSize === 1) {\n return buf[i]\n } else {\n return buf.readUInt16BE(i * indexSize)\n }\n }\n\n var i\n if (dir) {\n var foundIndex = -1\n for (i = byteOffset; i < arrLength; i++) {\n if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n if (foundIndex === -1) foundIndex = i\n if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n } else {\n if (foundIndex !== -1) i -= i - foundIndex\n foundIndex = -1\n }\n }\n } else {\n if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n for (i = byteOffset; i >= 0; i--) {\n var found = true\n for (var j = 0; j < valLength; j++) {\n if (read(arr, i + j) !== read(val, j)) {\n found = false\n break\n }\n }\n if (found) return i\n }\n }\n\n return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n offset = Number(offset) || 0\n var remaining = buf.length - offset\n if (!length) {\n length = remaining\n } else {\n length = Number(length)\n if (length > remaining) {\n length = remaining\n }\n }\n\n var strLen = string.length\n\n if (length > strLen / 2) {\n length = strLen / 2\n }\n for (var i = 0; i < length; ++i) {\n var parsed = parseInt(string.substr(i * 2, 2), 16)\n if (numberIsNaN(parsed)) return i\n buf[offset + i] = parsed\n }\n return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n // Buffer#write(string)\n if (offset === undefined) {\n encoding = 'utf8'\n length = this.length\n offset = 0\n // Buffer#write(string, encoding)\n } else if (length === undefined && typeof offset === 'string') {\n encoding = offset\n length = this.length\n offset = 0\n // Buffer#write(string, offset[, length][, encoding])\n } else if (isFinite(offset)) {\n offset = offset >>> 0\n if (isFinite(length)) {\n length = length >>> 0\n if (encoding === undefined) encoding = 'utf8'\n } else {\n encoding = length\n length = undefined\n }\n } else {\n throw new Error(\n 'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n )\n }\n\n var remaining = this.length - offset\n if (length === undefined || length > remaining) length = remaining\n\n if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n throw new RangeError('Attempt to write outside buffer bounds')\n }\n\n if (!encoding) encoding = 'utf8'\n\n var loweredCase = false\n for (;;) {\n switch (encoding) {\n case 'hex':\n return hexWrite(this, string, offset, length)\n\n case 'utf8':\n case 'utf-8':\n return utf8Write(this, string, offset, length)\n\n case 'ascii':\n return asciiWrite(this, string, offset, length)\n\n case 'latin1':\n case 'binary':\n return latin1Write(this, string, offset, length)\n\n case 'base64':\n // Warning: maxLength not taken into account in base64Write\n return base64Write(this, string, offset, length)\n\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return ucs2Write(this, string, offset, length)\n\n default:\n if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n encoding = ('' + encoding).toLowerCase()\n loweredCase = true\n }\n }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n return {\n type: 'Buffer',\n data: Array.prototype.slice.call(this._arr || this, 0)\n }\n}\n\nfunction base64Slice (buf, start, end) {\n if (start === 0 && end === buf.length) {\n return base64.fromByteArray(buf)\n } else {\n return base64.fromByteArray(buf.slice(start, end))\n }\n}\n\nfunction utf8Slice (buf, start, end) {\n end = Math.min(buf.length, end)\n var res = []\n\n var i = start\n while (i < end) {\n var firstByte = buf[i]\n var codePoint = null\n var bytesPerSequence = (firstByte > 0xEF) ? 4\n : (firstByte > 0xDF) ? 3\n : (firstByte > 0xBF) ? 2\n : 1\n\n if (i + bytesPerSequence <= end) {\n var secondByte, thirdByte, fourthByte, tempCodePoint\n\n switch (bytesPerSequence) {\n case 1:\n if (firstByte < 0x80) {\n codePoint = firstByte\n }\n break\n case 2:\n secondByte = buf[i + 1]\n if ((secondByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n if (tempCodePoint > 0x7F) {\n codePoint = tempCodePoint\n }\n }\n break\n case 3:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n codePoint = tempCodePoint\n }\n }\n break\n case 4:\n secondByte = buf[i + 1]\n thirdByte = buf[i + 2]\n fourthByte = buf[i + 3]\n if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n codePoint = tempCodePoint\n }\n }\n }\n }\n\n if (codePoint === null) {\n // we did not generate a valid codePoint so insert a\n // replacement char (U+FFFD) and advance only 1 byte\n codePoint = 0xFFFD\n bytesPerSequence = 1\n } else if (codePoint > 0xFFFF) {\n // encode to utf16 (surrogate pair dance)\n codePoint -= 0x10000\n res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n codePoint = 0xDC00 | codePoint & 0x3FF\n }\n\n res.push(codePoint)\n i += bytesPerSequence\n }\n\n return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n var len = codePoints.length\n if (len <= MAX_ARGUMENTS_LENGTH) {\n return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n }\n\n // Decode in chunks to avoid \"call stack size exceeded\".\n var res = ''\n var i = 0\n while (i < len) {\n res += String.fromCharCode.apply(\n String,\n codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n )\n }\n return res\n}\n\nfunction asciiSlice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i] & 0x7F)\n }\n return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n var ret = ''\n end = Math.min(buf.length, end)\n\n for (var i = start; i < end; ++i) {\n ret += String.fromCharCode(buf[i])\n }\n return ret\n}\n\nfunction hexSlice (buf, start, end) {\n var len = buf.length\n\n if (!start || start < 0) start = 0\n if (!end || end < 0 || end > len) end = len\n\n var out = ''\n for (var i = start; i < end; ++i) {\n out += hexSliceLookupTable[buf[i]]\n }\n return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n var bytes = buf.slice(start, end)\n var res = ''\n for (var i = 0; i < bytes.length; i += 2) {\n res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))\n }\n return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n var len = this.length\n start = ~~start\n end = end === undefined ? len : ~~end\n\n if (start < 0) {\n start += len\n if (start < 0) start = 0\n } else if (start > len) {\n start = len\n }\n\n if (end < 0) {\n end += len\n if (end < 0) end = 0\n } else if (end > len) {\n end = len\n }\n\n if (end < start) end = start\n\n var newBuf = this.subarray(start, end)\n // Return an augmented `Uint8Array` instance\n Object.setPrototypeOf(newBuf, Buffer.prototype)\n\n return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) {\n checkOffset(offset, byteLength, this.length)\n }\n\n var val = this[offset + --byteLength]\n var mul = 1\n while (byteLength > 0 && (mul *= 0x100)) {\n val += this[offset + --byteLength] * mul\n }\n\n return val\n}\n\nBuffer.prototype.readUInt8 = 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 = 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 = 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 = 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 = function readUInt32BE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] * 0x1000000) +\n ((this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var val = this[offset]\n var mul = 1\n var i = 0\n while (++i < byteLength && (mul *= 0x100)) {\n val += this[offset + i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n var i = byteLength\n var mul = 1\n var val = this[offset + --i]\n while (i > 0 && (mul *= 0x100)) {\n val += this[offset + --i] * mul\n }\n mul *= 0x80\n\n if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 1, this.length)\n if (!(this[offset] & 0x80)) return (this[offset])\n return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset] | (this[offset + 1] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 2, this.length)\n var val = this[offset + 1] | (this[offset] << 8)\n return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset]) |\n (this[offset + 1] << 8) |\n (this[offset + 2] << 16) |\n (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n\n return (this[offset] << 24) |\n (this[offset + 1] << 16) |\n (this[offset + 2] << 8) |\n (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 4, this.length)\n return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n offset = offset >>> 0\n if (!noAssert) checkOffset(offset, 8, this.length)\n return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var mul = 1\n var i = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset >>> 0\n byteLength = byteLength >>> 0\n if (!noAssert) {\n var maxBytes = Math.pow(2, 8 * byteLength) - 1\n checkInt(this, value, offset, byteLength, maxBytes, 0)\n }\n\n var i = byteLength - 1\n var mul = 1\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n this[offset + i] = (value / mul) & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = 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 = 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 = 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 = 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 = function writeUInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) {\n var limit = Math.pow(2, (8 * byteLength) - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = 0\n var mul = 1\n var sub = 0\n this[offset] = value & 0xFF\n while (++i < byteLength && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) {\n var limit = Math.pow(2, (8 * byteLength) - 1)\n\n checkInt(this, value, offset, byteLength, limit - 1, -limit)\n }\n\n var i = byteLength - 1\n var mul = 1\n var sub = 0\n this[offset + i] = value & 0xFF\n while (--i >= 0 && (mul *= 0x100)) {\n if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n sub = 1\n }\n this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n }\n\n return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n if (value < 0) value = 0xff + value + 1\n this[offset] = (value & 0xff)\n return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n this[offset] = (value >>> 8)\n this[offset + 1] = (value & 0xff)\n return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n this[offset] = (value & 0xff)\n this[offset + 1] = (value >>> 8)\n this[offset + 2] = (value >>> 16)\n this[offset + 3] = (value >>> 24)\n return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n if (value < 0) value = 0xffffffff + value + 1\n this[offset] = (value >>> 24)\n this[offset + 1] = (value >>> 16)\n this[offset + 2] = (value >>> 8)\n this[offset + 3] = (value & 0xff)\n return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n if (offset + ext > buf.length) throw new RangeError('Index out of range')\n if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n }\n ieee754.write(buf, value, offset, littleEndian, 23, 4)\n return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n value = +value\n offset = offset >>> 0\n if (!noAssert) {\n checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n }\n ieee754.write(buf, value, offset, littleEndian, 52, 8)\n return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')\n if (!start) start = 0\n if (!end && end !== 0) end = this.length\n if (targetStart >= target.length) targetStart = target.length\n if (!targetStart) targetStart = 0\n if (end > 0 && end < start) end = start\n\n // Copy 0 bytes; we're done\n if (end === start) return 0\n if (target.length === 0 || this.length === 0) return 0\n\n // Fatal error conditions\n if (targetStart < 0) {\n throw new RangeError('targetStart out of bounds')\n }\n if (start < 0 || start >= this.length) throw new RangeError('Index out of range')\n if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n // Are we oob?\n if (end > this.length) end = this.length\n if (target.length - targetStart < end - start) {\n end = target.length - targetStart + start\n }\n\n var len = end - start\n\n if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {\n // Use built-in when available, missing from IE11\n this.copyWithin(targetStart, start, end)\n } else if (this === target && start < targetStart && targetStart < end) {\n // descending copy from end\n for (var i = len - 1; i >= 0; --i) {\n target[i + targetStart] = this[i + start]\n }\n } else {\n Uint8Array.prototype.set.call(\n target,\n this.subarray(start, end),\n targetStart\n )\n }\n\n return len\n}\n\n// Usage:\n// buffer.fill(number[, offset[, end]])\n// buffer.fill(buffer[, offset[, end]])\n// buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n // Handle string cases:\n if (typeof val === 'string') {\n if (typeof start === 'string') {\n encoding = start\n start = 0\n end = this.length\n } else if (typeof end === 'string') {\n encoding = end\n end = this.length\n }\n if (encoding !== undefined && typeof encoding !== 'string') {\n throw new TypeError('encoding must be a string')\n }\n if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n throw new TypeError('Unknown encoding: ' + encoding)\n }\n if (val.length === 1) {\n var code = val.charCodeAt(0)\n if ((encoding === 'utf8' && code < 128) ||\n encoding === 'latin1') {\n // Fast path: If `val` fits into a single byte, use that numeric value.\n val = code\n }\n }\n } else if (typeof val === 'number') {\n val = val & 255\n } else if (typeof val === 'boolean') {\n val = Number(val)\n }\n\n // Invalid ranges are not set to a default, so can range check early.\n if (start < 0 || this.length < start || this.length < end) {\n throw new RangeError('Out of range index')\n }\n\n if (end <= start) {\n return this\n }\n\n start = start >>> 0\n end = end === undefined ? this.length : end >>> 0\n\n if (!val) val = 0\n\n var i\n if (typeof val === 'number') {\n for (i = start; i < end; ++i) {\n this[i] = val\n }\n } else {\n var bytes = Buffer.isBuffer(val)\n ? val\n : Buffer.from(val, encoding)\n var len = bytes.length\n if (len === 0) {\n throw new TypeError('The value \"' + val +\n '\" is invalid for argument \"value\"')\n }\n for (i = 0; i < end - start; ++i) {\n this[i + start] = bytes[i % len]\n }\n }\n\n return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n // Node takes equal signs as end of the Base64 encoding\n str = str.split('=')[0]\n // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n str = str.trim().replace(INVALID_BASE64_RE, '')\n // Node converts strings with length < 2 to ''\n if (str.length < 2) return ''\n // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n while (str.length % 4 !== 0) {\n str = str + '='\n }\n return str\n}\n\nfunction utf8ToBytes (string, units) {\n units = units || Infinity\n var codePoint\n var length = string.length\n var leadSurrogate = null\n var bytes = []\n\n for (var i = 0; i < length; ++i) {\n codePoint = string.charCodeAt(i)\n\n // is surrogate component\n if (codePoint > 0xD7FF && codePoint < 0xE000) {\n // last char was a lead\n if (!leadSurrogate) {\n // no lead yet\n if (codePoint > 0xDBFF) {\n // unexpected trail\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n } else if (i + 1 === length) {\n // unpaired lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n continue\n }\n\n // valid lead\n leadSurrogate = codePoint\n\n continue\n }\n\n // 2 leads in a row\n if (codePoint < 0xDC00) {\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n leadSurrogate = codePoint\n continue\n }\n\n // valid surrogate pair\n codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n } else if (leadSurrogate) {\n // valid bmp char, but last char was a lead\n if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n }\n\n leadSurrogate = null\n\n // encode utf8\n if (codePoint < 0x80) {\n if ((units -= 1) < 0) break\n bytes.push(codePoint)\n } else if (codePoint < 0x800) {\n if ((units -= 2) < 0) break\n bytes.push(\n codePoint >> 0x6 | 0xC0,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x10000) {\n if ((units -= 3) < 0) break\n bytes.push(\n codePoint >> 0xC | 0xE0,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else if (codePoint < 0x110000) {\n if ((units -= 4) < 0) break\n bytes.push(\n codePoint >> 0x12 | 0xF0,\n codePoint >> 0xC & 0x3F | 0x80,\n codePoint >> 0x6 & 0x3F | 0x80,\n codePoint & 0x3F | 0x80\n )\n } else {\n throw new Error('Invalid code point')\n }\n }\n\n return bytes\n}\n\nfunction asciiToBytes (str) {\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n // Node's code seems to be doing this and not & 0x7F..\n byteArray.push(str.charCodeAt(i) & 0xFF)\n }\n return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n var c, hi, lo\n var byteArray = []\n for (var i = 0; i < str.length; ++i) {\n if ((units -= 2) < 0) break\n\n c = str.charCodeAt(i)\n hi = c >> 8\n lo = c % 256\n byteArray.push(lo)\n byteArray.push(hi)\n }\n\n return byteArray\n}\n\nfunction base64ToBytes (str) {\n return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n for (var i = 0; i < length; ++i) {\n if ((i + offset >= dst.length) || (i >= src.length)) break\n dst[i + offset] = src[i]\n }\n return i\n}\n\n// ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass\n// the `instanceof` check but they should be treated as of that type.\n// See: https://github.com/feross/buffer/issues/166\nfunction isInstance (obj, type) {\n return obj instanceof type ||\n (obj != null && obj.constructor != null && obj.constructor.name != null &&\n obj.constructor.name === type.name)\n}\nfunction numberIsNaN (obj) {\n // For IE11 support\n return obj !== obj // eslint-disable-line no-self-compare\n}\n\n// Create lookup table for `toString('hex')`\n// See: https://github.com/feross/buffer/issues/219\nvar hexSliceLookupTable = (function () {\n var alphabet = '0123456789abcdef'\n var table = new Array(256)\n for (var i = 0; i < 16; ++i) {\n var i16 = i * 16\n for (var j = 0; j < 16; ++j) {\n table[i16 + j] = alphabet[i] + alphabet[j]\n }\n }\n return table\n})()\n","/* eslint-disable no-bitwise --\n * lots of bitwise operators necessary for this */\nimport * as hashjs from 'hash.js'\nimport BigNum = require('bn.js')\n\nexport default class Sha512 {\n // TODO: type of `hash`?\n hash: any\n\n constructor() {\n this.hash = hashjs.sha512()\n }\n\n add(bytes) {\n this.hash.update(bytes)\n return this\n }\n\n addU32(i) {\n return this.add([\n (i >>> 24) & 0xff,\n (i >>> 16) & 0xff,\n (i >>> 8) & 0xff,\n i & 0xff,\n ])\n }\n\n finish() {\n return this.hash.digest()\n }\n\n first256() {\n return this.finish().slice(0, 32)\n }\n\n first256BN() {\n return new BigNum(this.first256())\n }\n}\n","import * as assert from 'assert'\nimport brorand = require('brorand')\nimport * as hashjs from 'hash.js'\nimport * as elliptic from 'elliptic'\n\nimport * as addressCodec from 'ripple-address-codec'\nimport { derivePrivateKey, accountPublicFromPublicGenerator } from './secp256k1'\nimport * as utils from './utils'\n\nconst Ed25519 = elliptic.eddsa('ed25519')\nconst Secp256k1 = elliptic.ec('secp256k1')\n\nconst { hexToBytes } = utils\nconst { bytesToHex } = utils\n\nfunction generateSeed(\n options: {\n entropy?: Uint8Array\n algorithm?: 'ed25519' | 'ecdsa-secp256k1'\n } = {},\n): string {\n assert.ok(\n !options.entropy || options.entropy.length >= 16,\n 'entropy too short',\n )\n const entropy = options.entropy ? options.entropy.slice(0, 16) : brorand(16)\n const type = options.algorithm === 'ed25519' ? 'ed25519' : 'secp256k1'\n return addressCodec.encodeSeed(Buffer.from(entropy), type)\n}\n\nfunction hash(message): number[] {\n return hashjs.sha512().update(message).digest().slice(0, 32)\n}\n\nconst secp256k1 = {\n deriveKeypair(\n entropy: Uint8Array,\n options?: object,\n ): {\n privateKey: string\n publicKey: string\n } {\n const prefix = '00'\n\n const privateKey =\n prefix + derivePrivateKey(entropy, options).toString(16, 64).toUpperCase()\n\n const publicKey = bytesToHex(\n Secp256k1.keyFromPrivate(privateKey.slice(2))\n .getPublic()\n .encodeCompressed(),\n )\n return { privateKey, publicKey }\n },\n\n sign(message, privateKey): string {\n return bytesToHex(\n Secp256k1.sign(hash(message), hexToBytes(privateKey), {\n canonical: true,\n }).toDER(),\n )\n },\n\n verify(message, signature, publicKey): boolean {\n return Secp256k1.verify(hash(message), signature, hexToBytes(publicKey))\n },\n}\n\nconst ed25519 = {\n deriveKeypair(entropy: Uint8Array): {\n privateKey: string\n publicKey: string\n } {\n const prefix = 'ED'\n const rawPrivateKey = hash(entropy)\n const privateKey = prefix + bytesToHex(rawPrivateKey)\n const publicKey =\n prefix + bytesToHex(Ed25519.keyFromSecret(rawPrivateKey).pubBytes())\n return { privateKey, publicKey }\n },\n\n sign(message, privateKey): string {\n // caution: Ed25519.sign interprets all strings as hex, stripping\n // any non-hex characters without warning\n assert.ok(Array.isArray(message), 'message must be array of octets')\n return bytesToHex(\n Ed25519.sign(message, hexToBytes(privateKey).slice(1)).toBytes(),\n )\n },\n\n verify(message, signature, publicKey): boolean {\n return Ed25519.verify(\n message,\n hexToBytes(signature),\n hexToBytes(publicKey).slice(1),\n )\n },\n}\n\nfunction select(algorithm): any {\n const methods = { 'ecdsa-secp256k1': secp256k1, ed25519 }\n return methods[algorithm]\n}\n\nfunction deriveKeypair(\n seed: string,\n options?: object,\n): {\n publicKey: string\n privateKey: string\n} {\n const decoded = addressCodec.decodeSeed(seed)\n const algorithm = decoded.type === 'ed25519' ? 'ed25519' : 'ecdsa-secp256k1'\n const method = select(algorithm)\n const keypair = method.deriveKeypair(decoded.bytes, options)\n const messageToVerify = hash('This test message should verify.')\n const signature = method.sign(messageToVerify, keypair.privateKey)\n /* istanbul ignore if */\n if (method.verify(messageToVerify, signature, keypair.publicKey) !== true) {\n throw new Error('derived keypair did not generate verifiable signature')\n }\n return keypair\n}\n\nfunction getAlgorithmFromKey(key): 'ed25519' | 'ecdsa-secp256k1' {\n const bytes = hexToBytes(key)\n return bytes.length === 33 && bytes[0] === 0xed\n ? 'ed25519'\n : 'ecdsa-secp256k1'\n}\n\nfunction sign(messageHex, privateKey): string {\n const algorithm = getAlgorithmFromKey(privateKey)\n return select(algorithm).sign(hexToBytes(messageHex), privateKey)\n}\n\nfunction verify(messageHex, signature, publicKey): boolean {\n const algorithm = getAlgorithmFromKey(publicKey)\n return select(algorithm).verify(hexToBytes(messageHex), signature, publicKey)\n}\n\nfunction deriveAddressFromBytes(publicKeyBytes: Buffer): string {\n return addressCodec.encodeAccountID(\n utils.computePublicKeyHash(publicKeyBytes),\n )\n}\n\nfunction deriveAddress(publicKey): string {\n return deriveAddressFromBytes(Buffer.from(hexToBytes(publicKey)))\n}\n\nfunction deriveNodeAddress(publicKey): string {\n const generatorBytes = addressCodec.decodeNodePublic(publicKey)\n const accountPublicBytes = accountPublicFromPublicGenerator(generatorBytes)\n return deriveAddressFromBytes(accountPublicBytes)\n}\n\nconst { decodeSeed } = addressCodec\n\nexport {\n generateSeed,\n deriveKeypair,\n sign,\n verify,\n deriveAddress,\n deriveNodeAddress,\n decodeSeed,\n}\n","import * as elliptic from 'elliptic'\n\nimport Sha512 from './Sha512'\n\nconst secp256k1 = elliptic.ec('secp256k1')\n\nfunction deriveScalar(bytes, discrim?: number) {\n const order = secp256k1.curve.n\n for (let i = 0; i <= 0xffffffff; i++) {\n // We hash the bytes to find a 256 bit number, looping until we are sure it\n // is less than the order of the curve.\n const hasher = new Sha512().add(bytes)\n // If the optional discriminator index was passed in, update the hash.\n if (discrim !== undefined) {\n hasher.addU32(discrim)\n }\n hasher.addU32(i)\n const key = hasher.first256BN()\n /* istanbul ignore else */\n if (key.cmpn(0) > 0 && key.cmp(order) < 0) {\n return key\n }\n }\n // This error is practically impossible to reach.\n // The order of the curve describes the (finite) amount of points on the curve\n // https://github.com/indutny/elliptic/blob/master/lib/elliptic/curves.js#L182\n // How often will an (essentially) random number generated by Sha512 be larger than that?\n // There's 2^32 chances (the for loop) to get a number smaller than the order,\n // and it's rare that you'll even get past the first loop iteration.\n // Note that in TypeScript we actually need the throw, otherwise the function signature would be BN | undefined\n //\n /* istanbul ignore next */\n throw new Error('impossible unicorn ;)')\n}\n\n/**\n * @param seed - Bytes.\n * @param [opts] - Object.\n * @param [opts.accountIndex=0] - The account number to generate.\n * @param [opts.validator=false] - Generate root key-pair,\n * as used by validators.\n * @returns {bn.js} 256 bit scalar value.\n *\n */\nexport function derivePrivateKey(\n seed,\n opts: {\n validator?: boolean\n accountIndex?: number\n } = {},\n) {\n const root = opts.validator\n const order = secp256k1.curve.n\n\n // This private generator represents the `root` private key, and is what's\n // used by validators for signing when a keypair is generated from a seed.\n const privateGen = deriveScalar(seed)\n if (root) {\n // As returned by validation_create for a given seed\n return privateGen\n }\n const publicGen = secp256k1.g.mul(privateGen)\n // A seed can generate many keypairs as a function of the seed and a uint32.\n // Almost everyone just uses the first account, `0`.\n const accountIndex = opts.accountIndex || 0\n return deriveScalar(publicGen.encodeCompressed(), accountIndex)\n .add(privateGen)\n .mod(order)\n}\n\nexport function accountPublicFromPublicGenerator(publicGenBytes) {\n const rootPubPoint = secp256k1.curve.decodePoint(publicGenBytes)\n const scalar = deriveScalar(publicGenBytes, 0)\n const point = secp256k1.g.mul(scalar)\n const offset = rootPubPoint.add(point)\n return offset.encodeCompressed()\n}\n","import * as assert from 'assert'\nimport * as hashjs from 'hash.js'\nimport BN = require('bn.js')\n\nfunction bytesToHex(a: Iterable<number> | ArrayLike<number>): string {\n return Array.from(a, (byteValue) => {\n const hex = byteValue.toString(16).toUpperCase()\n return hex.length > 1 ? hex : `0${hex}`\n }).join('')\n}\n\nfunction hexToBytes(a): number[] {\n assert.ok(a.length % 2 === 0)\n // Special-case length zero to return [].\n // BN.toArray intentionally returns [0] rather than [] for length zero,\n // which may make sense for BigNum data, but not for byte strings.\n return a.length === 0 ? [] : new BN(a, 16).toArray(null, a.length / 2)\n}\n\nfunction computePublicKeyHash(publicKeyBytes: Buffer): Buffer {\n const hash256 = hashjs.sha256().update(publicKeyBytes).digest()\n\n const hash160 = hashjs.ripemd160().update(hash256).digest()\n return Buffer.from(hash160)\n}\n\nexport { bytesToHex, hexToBytes, computePublicKeyHash }\n","/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */\n/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n for (var key in src) {\n dst[key] = src[key]\n }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n module.exports = buffer\n} else {\n // Copy properties from require('buffer')\n copyProps(buffer, exports)\n exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.prototype = Object.create(Buffer.prototype)\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n if (typeof arg === 'number') {\n throw new TypeError('Argument must not be a number')\n }\n return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n if (typeof size !== 'number') {\n throw new TypeError('Argument must be a number')\n }\n var buf = Buffer(size)\n if (fill !== undefined) {\n if (typeof encoding === 'string') {\n buf.fill(fill, encoding)\n } else {\n buf.fill(fill)\n }\n } else {\n buf.fill(0)\n }\n return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n if (typeof size !== 'number') {\n throw new TypeError('Argument must be a number')\n }\n return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n if (typeof size !== 'number') {\n throw new TypeError('Argument must be a number')\n }\n return buffer.SlowBuffer(size)\n}\n","/* eslint-disable node/no-deprecated-api */\n\n'use strict'\n\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\nvar safer = {}\n\nvar key\n\nfor (key in buffer) {\n if (!buffer.hasOwnProperty(key)) continue\n if (key === 'SlowBuffer' || key === 'Buffer') continue\n safer[key] = buffer[key]\n}\n\nvar Safer = safer.Buffer = {}\nfor (key in Buffer) {\n if (!Buffer.hasOwnProperty(key)) continue\n if (key === 'allocUnsafe' || key === 'allocUnsafeSlow') continue\n Safer[key] = Buffer[key]\n}\n\nsafer.Buffer.prototype = Buffer.prototype\n\nif (!Safer.from || Safer.from === Uint8Array.from) {\n Safer.from = function (value, encodingOrOffset, length) {\n if (typeof value === 'number') {\n throw new TypeError('The \"value\" argument must not be of type number. Received type ' + typeof value)\n }\n if (value && typeof value.length === 'undefined') {\n throw new TypeError('The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type ' + typeof value)\n }\n return Buffer(value, encodingOrOffset, length)\n }\n}\n\nif (!Safer.alloc) {\n Safer.alloc = function (size, fill, encoding) {\n if (typeof size !== 'number') {\n throw new TypeError('The \"size\" argument must be of type number. Received type ' + typeof size)\n }\n if (size < 0 || size >= 2 * (1 << 30)) {\n throw new RangeError('The value \"' + size + '\" is invalid for option \"size\"')\n }\n var buf = Buffer(size)\n if (!fill || fill.length === 0) {\n buf.fill(0)\n } else if (typeof encoding === 'string') {\n buf.fill(fill, encoding)\n } else {\n buf.fill(fill)\n }\n return buf\n }\n}\n\nif (!safer.kStringMaxLength) {\n try {\n safer.kStringMaxLength = process.binding('buffer').kStringMaxLength\n } catch (e) {\n // we can't determine kStringMaxLength in environments where process.binding\n // is unsupported, so let's not set it\n }\n}\n\nif (!safer.constants) {\n safer.constants = {\n MAX_LENGTH: safer.kMaxLength\n }\n if (safer.kStringMaxLength) {\n safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength\n }\n}\n\nmodule.exports = safer\n","var Buffer = require('safe-buffer').Buffer\n\n// prototype class for hash functions\nfunction Hash (blockSize, finalSize) {\n this._block = Buffer.alloc(blockSize)\n this._finalSize = finalSize\n this._blockSize = blockSize\n this._len = 0\n}\n\nHash.prototype.update = function (data, enc) {\n if (typeof data === 'string') {\n enc = enc || 'utf8'\n data = Buffer.from(data, enc)\n }\n\n var block = this._block\n var blockSize = this._blockSize\n var length = data.length\n var accum = this._len\n\n for (var offset = 0; offset < length;) {\n var assigned = accum % blockSize\n var remainder = Math.min(length - offset, blockSize - assigned)\n\n for (var i = 0; i < remainder; i++) {\n block[assigned + i] = data[offset + i]\n }\n\n accum += remainder\n offset += remainder\n\n if ((accum % blockSize) === 0) {\n this._update(block)\n }\n }\n\n this._len += length\n return this\n}\n\nHash.prototype.digest = function (enc) {\n var rem = this._len % this._blockSize\n\n this._block[rem] = 0x80\n\n // zero (rem + 1) trailing bits, where (rem + 1) is the smallest\n // non-negative solution to the equation (length + 1 + (rem + 1)) === finalSize mod blockSize\n this._block.fill(0, rem + 1)\n\n if (rem >= this._finalSize) {\n this._update(this._block)\n this._block.fill(0)\n }\n\n var bits = this._len * 8\n\n // uint32\n if (bits <= 0xffffffff) {\n this._block.writeUInt32BE(bits, this._blockSize - 4)\n\n // uint64\n } else {\n var lowBits = (bits & 0xffffffff) >>> 0\n var highBits = (bits - lowBits) / 0x100000000\n\n this._block.writeUInt32BE(highBits, this._blockSize - 8)\n this._block.writeUInt32BE(lowBits, this._blockSize - 4)\n }\n\n this._update(this._block)\n var hash = this._hash()\n\n return enc ? hash.toString(enc) : hash\n}\n\nHash.prototype._update = function () {\n throw new Error('_update must be implemented by subclass')\n}\n\nmodule.exports = Hash\n","var exports = module.exports = function SHA (algorithm) {\n algorithm = algorithm.toLowerCase()\n\n var Algorithm = exports[algorithm]\n if (!Algorithm) throw new Error(algorithm + ' is not supported (we accept pull requests)')\n\n return new Algorithm()\n}\n\nexports.sha = require('./sha')\nexports.sha1 = require('./sha1')\nexports.sha224 = require('./sha224')\nexports.sha256 = require('./sha256')\nexports.sha384 = require('./sha384')\nexports.sha512 = require('./sha512')\n","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-0, as defined\n * in FIPS PUB 180-1\n * This source code is derived from sha1.js of the same repository.\n * The difference between SHA-0 and SHA-1 is just a bitwise rotate left\n * operation was added.\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha () {\n this.init()\n this._w = W\n\n Hash.call(this, 64, 56)\n}\n\ninherits(Sha, Hash)\n\nSha.prototype.init = function () {\n this._a = 0x67452301\n this._b = 0xefcdab89\n this._c = 0x98badcfe\n this._d = 0x10325476\n this._e = 0xc3d2e1f0\n\n return this\n}\n\nfunction rotl5 (num) {\n return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n if (s === 0) return (b & c) | ((~b) & d)\n if (s === 2) return (b & c) | (b & d) | (c & d)\n return b ^ c ^ d\n}\n\nSha.prototype._update = function (M) {\n var W = this._w\n\n var a = this._a | 0\n var b = this._b | 0\n var c = this._c | 0\n var d = this._d | 0\n var e = this._e | 0\n\n for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n for (; i < 80; ++i) W[i] = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16]\n\n for (var j = 0; j < 80; ++j) {\n var s = ~~(j / 20)\n var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n e = d\n d = c\n c = rotl30(b)\n b = a\n a = t\n }\n\n this._a = (a + this._a) | 0\n this._b = (b + this._b) | 0\n this._c = (c + this._c) | 0\n this._d = (d + this._d) | 0\n this._e = (e + this._e) | 0\n}\n\nSha.prototype._hash = function () {\n var H = Buffer.allocUnsafe(20)\n\n H.writeInt32BE(this._a | 0, 0)\n H.writeInt32BE(this._b | 0, 4)\n H.writeInt32BE(this._c | 0, 8)\n H.writeInt32BE(this._d | 0, 12)\n H.writeInt32BE(this._e | 0, 16)\n\n return H\n}\n\nmodule.exports = Sha\n","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined\n * in FIPS PUB 180-1\n * Version 2.1a Copyright Paul Johnston 2000 - 2002.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for details.\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc | 0, 0xca62c1d6 | 0\n]\n\nvar W = new Array(80)\n\nfunction Sha1 () {\n this.init()\n this._w = W\n\n Hash.call(this, 64, 56)\n}\n\ninherits(Sha1, Hash)\n\nSha1.prototype.init = function () {\n this._a = 0x67452301\n this._b = 0xefcdab89\n this._c = 0x98badcfe\n this._d = 0x10325476\n this._e = 0xc3d2e1f0\n\n return this\n}\n\nfunction rotl1 (num) {\n return (num << 1) | (num >>> 31)\n}\n\nfunction rotl5 (num) {\n return (num << 5) | (num >>> 27)\n}\n\nfunction rotl30 (num) {\n return (num << 30) | (num >>> 2)\n}\n\nfunction ft (s, b, c, d) {\n if (s === 0) return (b & c) | ((~b) & d)\n if (s === 2) return (b & c) | (b & d) | (c & d)\n return b ^ c ^ d\n}\n\nSha1.prototype._update = function (M) {\n var W = this._w\n\n var a = this._a | 0\n var b = this._b | 0\n var c = this._c | 0\n var d = this._d | 0\n var e = this._e | 0\n\n for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n for (; i < 80; ++i) W[i] = rotl1(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16])\n\n for (var j = 0; j < 80; ++j) {\n var s = ~~(j / 20)\n var t = (rotl5(a) + ft(s, b, c, d) + e + W[j] + K[s]) | 0\n\n e = d\n d = c\n c = rotl30(b)\n b = a\n a = t\n }\n\n this._a = (a + this._a) | 0\n this._b = (b + this._b) | 0\n this._c = (c + this._c) | 0\n this._d = (d + this._d) | 0\n this._e = (e + this._e) | 0\n}\n\nSha1.prototype._hash = function () {\n var H = Buffer.allocUnsafe(20)\n\n H.writeInt32BE(this._a | 0, 0)\n H.writeInt32BE(this._b | 0, 4)\n H.writeInt32BE(this._c | 0, 8)\n H.writeInt32BE(this._d | 0, 12)\n H.writeInt32BE(this._e | 0, 16)\n\n return H\n}\n\nmodule.exports = Sha1\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require('inherits')\nvar Sha256 = require('./sha256')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar W = new Array(64)\n\nfunction Sha224 () {\n this.init()\n\n this._w = W // new Array(64)\n\n Hash.call(this, 64, 56)\n}\n\ninherits(Sha224, Sha256)\n\nSha224.prototype.init = function () {\n this._a = 0xc1059ed8\n this._b = 0x367cd507\n this._c = 0x3070dd17\n this._d = 0xf70e5939\n this._e = 0xffc00b31\n this._f = 0x68581511\n this._g = 0x64f98fa7\n this._h = 0xbefa4fa4\n\n return this\n}\n\nSha224.prototype._hash = function () {\n var H = Buffer.allocUnsafe(28)\n\n H.writeInt32BE(this._a, 0)\n H.writeInt32BE(this._b, 4)\n H.writeInt32BE(this._c, 8)\n H.writeInt32BE(this._d, 12)\n H.writeInt32BE(this._e, 16)\n H.writeInt32BE(this._f, 20)\n H.writeInt32BE(this._g, 24)\n\n return H\n}\n\nmodule.exports = Sha224\n","/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,\n 0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,\n 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,\n 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,\n 0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,\n 0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,\n 0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,\n 0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,\n 0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,\n 0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,\n 0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,\n 0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,\n 0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,\n 0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,\n 0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,\n 0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2\n]\n\nvar W = new Array(64)\n\nfunction Sha256 () {\n this.init()\n\n this._w = W // new Array(64)\n\n Hash.call(this, 64, 56)\n}\n\ninherits(Sha256, Hash)\n\nSha256.prototype.init = function () {\n this._a = 0x6a09e667\n this._b = 0xbb67ae85\n this._c = 0x3c6ef372\n this._d = 0xa54ff53a\n this._e = 0x510e527f\n this._f = 0x9b05688c\n this._g = 0x1f83d9ab\n this._h = 0x5be0cd19\n\n return this\n}\n\nfunction ch (x, y, z) {\n return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x) {\n return (x >>> 2 | x << 30) ^ (x >>> 13 | x << 19) ^ (x >>> 22 | x << 10)\n}\n\nfunction sigma1 (x) {\n return (x >>> 6 | x << 26) ^ (x >>> 11 | x << 21) ^ (x >>> 25 | x << 7)\n}\n\nfunction gamma0 (x) {\n return (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ (x >>> 3)\n}\n\nfunction gamma1 (x) {\n return (x >>> 17 | x << 15) ^ (x >>> 19 | x << 13) ^ (x >>> 10)\n}\n\nSha256.prototype._update = function (M) {\n var W = this._w\n\n var a = this._a | 0\n var b = this._b | 0\n var c = this._c | 0\n var d = this._d | 0\n var e = this._e | 0\n var f = this._f | 0\n var g = this._g | 0\n var h = this._h | 0\n\n for (var i = 0; i < 16; ++i) W[i] = M.readInt32BE(i * 4)\n for (; i < 64; ++i) W[i] = (gamma1(W[i - 2]) + W[i - 7] + gamma0(W[i - 15]) + W[i - 16]) | 0\n\n for (var j = 0; j < 64; ++j) {\n var T1 = (h + sigma1(e) + ch(e, f, g) + K[j] + W[j]) | 0\n var T2 = (sigma0(a) + maj(a, b, c)) | 0\n\n h = g\n g = f\n f = e\n e = (d + T1) | 0\n d = c\n c = b\n b = a\n a = (T1 + T2) | 0\n }\n\n this._a = (a + this._a) | 0\n this._b = (b + this._b) | 0\n this._c = (c + this._c) | 0\n this._d = (d + this._d) | 0\n this._e = (e + this._e) | 0\n this._f = (f + this._f) | 0\n this._g = (g + this._g) | 0\n this._h = (h + this._h) | 0\n}\n\nSha256.prototype._hash = function () {\n var H = Buffer.allocUnsafe(32)\n\n H.writeInt32BE(this._a, 0)\n H.writeInt32BE(this._b, 4)\n H.writeInt32BE(this._c, 8)\n H.writeInt32BE(this._d, 12)\n H.writeInt32BE(this._e, 16)\n H.writeInt32BE(this._f, 20)\n H.writeInt32BE(this._g, 24)\n H.writeInt32BE(this._h, 28)\n\n return H\n}\n\nmodule.exports = Sha256\n","var inherits = require('inherits')\nvar SHA512 = require('./sha512')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar W = new Array(160)\n\nfunction Sha384 () {\n this.init()\n this._w = W\n\n Hash.call(this, 128, 112)\n}\n\ninherits(Sha384, SHA512)\n\nSha384.prototype.init = function () {\n this._ah = 0xcbbb9d5d\n this._bh = 0x629a292a\n this._ch = 0x9159015a\n this._dh = 0x152fecd8\n this._eh = 0x67332667\n this._fh = 0x8eb44a87\n this._gh = 0xdb0c2e0d\n this._hh = 0x47b5481d\n\n this._al = 0xc1059ed8\n this._bl = 0x367cd507\n this._cl = 0x3070dd17\n this._dl = 0xf70e5939\n this._el = 0xffc00b31\n this._fl = 0x68581511\n this._gl = 0x64f98fa7\n this._hl = 0xbefa4fa4\n\n return this\n}\n\nSha384.prototype._hash = function () {\n var H = Buffer.allocUnsafe(48)\n\n function writeInt64BE (h, l, offset) {\n H.writeInt32BE(h, offset)\n H.writeInt32BE(l, offset + 4)\n }\n\n writeInt64BE(this._ah, this._al, 0)\n writeInt64BE(this._bh, this._bl, 8)\n writeInt64BE(this._ch, this._cl, 16)\n writeInt64BE(this._dh, this._dl, 24)\n writeInt64BE(this._eh, this._el, 32)\n writeInt64BE(this._fh, this._fl, 40)\n\n return H\n}\n\nmodule.exports = Sha384\n","var inherits = require('inherits')\nvar Hash = require('./hash')\nvar Buffer = require('safe-buffer').Buffer\n\nvar K = [\n 0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd,\n 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,\n 0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019,\n 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,\n 0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe,\n 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,\n 0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1,\n 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,\n 0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3,\n 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,\n 0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483,\n 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,\n 0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210,\n 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,\n 0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725,\n 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,\n 0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926,\n 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,\n 0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8,\n 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,\n 0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001,\n 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,\n 0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910,\n 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,\n 0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53,\n 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,\n 0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb,\n 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,\n 0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60,\n 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,\n 0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9,\n 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,\n 0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207,\n 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,\n 0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6,\n 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,\n 0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493,\n 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,\n 0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a,\n 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817\n]\n\nvar W = new Array(160)\n\nfunction Sha512 () {\n this.init()\n this._w = W\n\n Hash.call(this, 128, 112)\n}\n\ninherits(Sha512, Hash)\n\nSha512.prototype.init = function () {\n this._ah = 0x6a09e667\n this._bh = 0xbb67ae85\n this._ch = 0x3c6ef372\n this._dh = 0xa54ff53a\n this._eh = 0x510e527f\n this._fh = 0x9b05688c\n this._gh = 0x1f83d9ab\n this._hh = 0x5be0cd19\n\n this._al = 0xf3bcc908\n this._bl = 0x84caa73b\n this._cl = 0xfe94f82b\n this._dl = 0x5f1d36f1\n this._el = 0xade682d1\n this._fl = 0x2b3e6c1f\n this._gl = 0xfb41bd6b\n this._hl = 0x137e2179\n\n return this\n}\n\nfunction Ch (x, y, z) {\n return z ^ (x & (y ^ z))\n}\n\nfunction maj (x, y, z) {\n return (x & y) | (z & (x | y))\n}\n\nfunction sigma0 (x, xl) {\n return (x >>> 28 | xl << 4) ^ (xl >>> 2 | x << 30) ^ (xl >>> 7 | x << 25)\n}\n\nfunction sigma1 (x, xl) {\n return (x >>> 14 | xl << 18) ^ (x >>> 18 | xl << 14) ^ (xl >>> 9 | x << 23)\n}\n\nfunction Gamma0 (x, xl) {\n return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7)\n}\n\nfunction Gamma0l (x, xl) {\n return (x >>> 1 | xl << 31) ^ (x >>> 8 | xl << 24) ^ (x >>> 7 | xl << 25)\n}\n\nfunction Gamma1 (x, xl) {\n return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6)\n}\n\nfunction Gamma1l (x, xl) {\n return (x >>> 19 | xl << 13) ^ (xl >>> 29 | x << 3) ^ (x >>> 6 | xl << 26)\n}\n\nfunction getCarry (a, b) {\n return (a >>> 0) < (b >>> 0) ? 1 : 0\n}\n\nSha512.prototype._update = function (M) {\n var W = this._w\n\n var ah = this._ah | 0\n var bh = this._bh | 0\n var ch = this._ch | 0\n var dh = this._dh | 0\n var eh = this._eh | 0\n var fh = this._fh | 0\n var gh = this._gh | 0\n var hh = this._hh | 0\n\n var al = this._al | 0\n var bl = this._bl | 0\n var cl = this._cl | 0\n var dl = this._dl | 0\n var el = this._el | 0\n var fl = this._fl | 0\n var gl = this._gl | 0\n var hl = this._hl | 0\n\n for (var i = 0; i < 32; i += 2) {\n W[i] = M.readInt32BE(i * 4)\n W[i + 1] = M.readInt32BE(i * 4 + 4)\n }\n for (; i < 160; i += 2) {\n var xh = W[i - 15 * 2]\n var xl = W[i - 15 * 2 + 1]\n var gamma0 = Gamma0(xh, xl)\n var gamma0l = Gamma0l(xl, xh)\n\n xh = W[i - 2 * 2]\n xl = W[i - 2 * 2 + 1]\n var gamma1 = Gamma1(xh, xl)\n var gamma1l = Gamma1l(xl, xh)\n\n // W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16]\n var Wi7h = W[i - 7 * 2]\n var Wi7l = W[i - 7 * 2 + 1]\n\n var Wi16h = W[i - 16 * 2]\n var Wi16l = W[i - 16 * 2 + 1]\n\n var Wil = (gamma0l + Wi7l) | 0\n var Wih = (gamma0 + Wi7h + getCarry(Wil, gamma0l)) | 0\n Wil = (Wil + gamma1l) | 0\n Wih = (Wih + gamma1 + getCarry(Wil, gamma1l)) | 0\n Wil = (Wil + Wi16l) | 0\n Wih = (Wih + Wi16h + getCarry(Wil, Wi16l)) | 0\n\n W[i] = Wih\n W[i + 1] = Wil\n }\n\n for (var j = 0; j < 160; j += 2) {\n Wih = W[j]\n Wil = W[j + 1]\n\n var majh = maj(ah, bh, ch)\n var majl = maj(al, bl, cl)\n\n var sigma0h = sigma0(ah, al)\n var sigma0l = sigma0(al, ah)\n var sigma1h = sigma1(eh, el)\n var sigma1l = sigma1(el, eh)\n\n // t1 = h + sigma1 + ch + K[j] + W[j]\n var Kih = K[j]\n var Kil = K[j + 1]\n\n var chh = Ch(eh, fh, gh)\n var chl = Ch(el, fl, gl)\n\n var t1l = (hl + sigma1l) | 0\n var t1h = (hh + sigma1h + getCarry(t1l, hl)) | 0\n t1l = (t1l + chl) | 0\n t1h = (t1h + chh + getCarry(t1l, chl)) | 0\n t1l = (t1l + Kil) | 0\n t1h = (t1h + Kih + getCarry(t1l, Kil)) | 0\n t1l = (t1l + Wil) | 0\n t1h = (t1h + Wih + getCarry(t1l, Wil)) | 0\n\n // t2 = sigma0 + maj\n var t2l = (sigma0l + majl) | 0\n var t2h = (sigma0h + majh + getCarry(t2l, sigma0l)) | 0\n\n hh = gh\n hl = gl\n gh = fh\n gl = fl\n fh = eh\n fl = el\n el = (dl + t1l) | 0\n eh = (dh + t1h + getCarry(el, dl)) | 0\n dh = ch\n dl = cl\n ch = bh\n cl = bl\n bh = ah\n bl = al\n al = (t1l + t2l) | 0\n ah = (t1h + t2h + getCarry(al, t1l)) | 0\n }\n\n this._al = (this._al + al) | 0\n this._bl = (this._bl + bl) | 0\n this._cl = (this._cl + cl) | 0\n this._dl = (this._dl + dl) | 0\n this._el = (this._el + el) | 0\n this._fl = (this._fl + fl) | 0\n this._gl = (this._gl + gl) | 0\n this._hl = (this._hl + hl) | 0\n\n this._ah = (this._ah + ah + getCarry(this._al, al)) | 0\n this._bh = (this._bh + bh + getCarry(this._bl, bl)) | 0\n this._ch = (this._ch + ch + getCarry(this._cl, cl)) | 0\n this._dh = (this._dh + dh + getCarry(this._dl, dl)) | 0\n this._eh = (this._eh + eh + getCarry(this._el, el)) | 0\n this._fh = (this._fh + fh + getCarry(this._fl, fl)) | 0\n this._gh = (this._gh + gh + getCarry(this._gl, gl)) | 0\n this._hh = (this._hh + hh + getCarry(this._hl, hl)) | 0\n}\n\nSha512.prototype._hash = function () {\n var H = Buffer.allocUnsafe(64)\n\n function writeInt64BE (h, l, offset) {\n H.writeInt32BE(h, offset)\n H.writeInt32BE(l, offset + 4)\n }\n\n writeInt64BE(this._ah, this._al, 0)\n writeInt64BE(this._bh, this._bl, 8)\n writeInt64BE(this._ch, this._cl, 16)\n writeInt64BE(this._dh, this._dl, 24)\n writeInt64BE(this._eh, this._el, 32)\n writeInt64BE(this._fh, this._fl, 40)\n writeInt64BE(this._gh, this._gl, 48)\n writeInt64BE(this._hh, this._hl, 56)\n\n return H\n}\n\nmodule.exports = Sha512\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require('events').EventEmitter;\nvar inherits = require('inherits');\n\ninherits(Stream, EE);\nStream.Readable = require('readable-stream/lib/_stream_readable.js');\nStream.Writable = require('readable-stream/lib/_stream_writable.js');\nStream.Duplex = require('readable-stream/lib/_stream_duplex.js');\nStream.Transform = require('readable-stream/lib/_stream_transform.js');\nStream.PassThrough = require('readable-stream/lib/_stream_passthrough.js');\nStream.finished = require('readable-stream/lib/internal/streams/end-of-stream.js')\nStream.pipeline = require('readable-stream/lib/internal/streams/pipeline.js')\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams. Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n var source = this;\n\n function ondata(chunk) {\n if (dest.writable) {\n if (false === dest.write(chunk) && source.pause) {\n source.pause();\n }\n }\n }\n\n source.on('data', ondata);\n\n function ondrain() {\n if (source.readable && source.resume) {\n source.resume();\n }\n }\n\n dest.on('drain', ondrain);\n\n // If the 'end' option is not supplied, dest.end() will be called when\n // source gets the 'end' or 'close' events. Only dest.end() once.\n if (!dest._isStdio && (!options || options.end !== false)) {\n source.on('end', onend);\n source.on('close', onclose);\n }\n\n var didOnEnd = false;\n function onend() {\n if (didOnEnd) return;\n didOnEnd = true;\n\n dest.end();\n }\n\n\n function onclose() {\n if (didOnEnd) return;\n didOnEnd = true;\n\n if (typeof dest.destroy === 'function') dest.destroy();\n }\n\n // don't leave dangling pipes when there are errors.\n function onerror(er) {\n cleanup();\n if (EE.listenerCount(this, 'error') === 0) {\n throw er; // Unhandled stream error in pipe.\n }\n }\n\n source.on('error', onerror);\n dest.on('error', onerror);\n\n // remove all the event listeners that were added.\n function cleanup() {\n source.removeListener('data', ondata);\n dest.removeListener('drain', ondrain);\n\n source.removeListener('end', onend);\n source.removeListener('close', onclose);\n\n source.removeListener('error', onerror);\n dest.removeListener('error', onerror);\n\n source.removeListener('end', cleanup);\n source.removeListener('close', cleanup);\n\n dest.removeListener('close', cleanup);\n }\n\n source.on('end', cleanup);\n source.on('close', cleanup);\n\n dest.on('close', cleanup);\n\n dest.emit('pipe', source);\n\n // Allow for unix-like usage: A.pipe(B).pipe(C)\n return dest;\n};\n","var ClientRequest = require('./lib/request')\nvar response = require('./lib/response')\nvar extend = require('xtend')\nvar statusCodes = require('builtin-status-codes')\nvar url = require('url')\n\nvar http = exports\n\nhttp.request = function (opts, cb) {\n\tif (typeof opts === 'string')\n\t\topts = url.parse(opts)\n\telse\n\t\topts = extend(opts)\n\n\t// Normally, the page is loaded from http or https, so not specifying a protocol\n\t// will result in a (valid) protocol-relative url. However, this won't work if\n\t// the protocol is something else, like 'file:'\n\tvar defaultProtocol = global.location.protocol.search(/^https?:$/) === -1 ? 'http:' : ''\n\n\tvar protocol = opts.protocol || defaultProtocol\n\tvar host = opts.hostname || opts.host\n\tvar port = opts.port\n\tvar path = opts.path || '/'\n\n\t// Necessary for IPv6 addresses\n\tif (host && host.indexOf(':') !== -1)\n\t\thost = '[' + host + ']'\n\n\t// This may be a relative url. The browser should always be able to interpret it correctly.\n\topts.url = (host ? (protocol + '//' + host) : '') + (port ? ':' + port : '') + path\n\topts.method = (opts.method || 'GET').toUpperCase()\n\topts.headers = opts.headers || {}\n\n\t// Also valid opts.auth, opts.mode\n\n\tvar req = new ClientRequest(opts)\n\tif (cb)\n\t\treq.on('response', cb)\n\treturn req\n}\n\nhttp.get = function get (opts, cb) {\n\tvar req = http.request(opts, cb)\n\treq.end()\n\treturn req\n}\n\nhttp.ClientRequest = ClientRequest\nhttp.IncomingMessage = response.IncomingMessage\n\nhttp.Agent = function () {}\nhttp.Agent.defaultMaxSockets = 4\n\nhttp.globalAgent = new http.Agent()\n\nhttp.STATUS_CODES = statusCodes\n\nhttp.METHODS = [\n\t'CHECKOUT',\n\t'CONNECT',\n\t'COPY',\n\t'DELETE',\n\t'GET',\n\t'HEAD',\n\t'LOCK',\n\t'M-SEARCH',\n\t'MERGE',\n\t'MKACTIVITY',\n\t'MKCOL',\n\t'MOVE',\n\t'NOTIFY',\n\t'OPTIONS',\n\t'PATCH',\n\t'POST',\n\t'PROPFIND',\n\t'PROPPATCH',\n\t'PURGE',\n\t'PUT',\n\t'REPORT',\n\t'SEARCH',\n\t'SUBSCRIBE',\n\t'TRACE',\n\t'UNLOCK',\n\t'UNSUBSCRIBE'\n]","exports.fetch = isFunction(global.fetch) && isFunction(global.ReadableStream)\n\nexports.writableStream = isFunction(global.WritableStream)\n\nexports.abortController = isFunction(global.AbortController)\n\n// The xhr request to example.com may violate some restrictive CSP configurations,\n// so if we're running in a browser that supports `fetch`, avoid calling getXHR()\n// and assume support for certain features below.\nvar xhr\nfunction getXHR () {\n\t// Cache the xhr value\n\tif (xhr !== undefined) return xhr\n\n\tif (global.XMLHttpRequest) {\n\t\txhr = new global.XMLHttpRequest()\n\t\t// If XDomainRequest is available (ie only, where xhr might not work\n\t\t// cross domain), use the page location. Otherwise use example.com\n\t\t// Note: this doesn't actually make an http request.\n\t\ttry {\n\t\t\txhr.open('GET', global.XDomainRequest ? '/' : 'https://example.com')\n\t\t} catch(e) {\n\t\t\txhr = null\n\t\t}\n\t} else {\n\t\t// Service workers don't have XHR\n\t\txhr = null\n\t}\n\treturn xhr\n}\n\nfunction checkTypeSupport (type) {\n\tvar xhr = getXHR()\n\tif (!xhr) return false\n\ttry {\n\t\txhr.responseType = type\n\t\treturn xhr.responseType === type\n\t} catch (e) {}\n\treturn false\n}\n\n// If fetch is supported, then arraybuffer will be supported too. Skip calling\n// checkTypeSupport(), since that calls getXHR().\nexports.arraybuffer = exports.fetch || checkTypeSupport('arraybuffer')\n\n// These next two tests unavoidably show warnings in Chrome. Since fetch will always\n// be used if it's available, just return false for these to avoid the warnings.\nexports.msstream = !exports.fetch && checkTypeSupport('ms-stream')\nexports.mozchunkedarraybuffer = !exports.fetch && checkTypeSupport('moz-chunked-arraybuffer')\n\n// If fetch is supported, then overrideMimeType will be supported too. Skip calling\n// getXHR().\nexports.overrideMimeType = exports.fetch || (getXHR() ? isFunction(getXHR().overrideMimeType) : false)\n\nfunction isFunction (value) {\n\treturn typeof value === 'function'\n}\n\nxhr = null // Help gc\n","var capability = require('./capability')\nvar inherits = require('inherits')\nvar response = require('./response')\nvar stream = require('readable-stream')\n\nvar IncomingMessage = response.IncomingMessage\nvar rStates = response.readyStates\n\nfunction decideMode (preferBinary, useFetch) {\n\tif (capability.fetch && useFetch) {\n\t\treturn 'fetch'\n\t} else if (capability.mozchunkedarraybuffer) {\n\t\treturn 'moz-chunked-arraybuffer'\n\t} else if (capability.msstream) {\n\t\treturn 'ms-stream'\n\t} else if (capability.arraybuffer && preferBinary) {\n\t\treturn 'arraybuffer'\n\t} else {\n\t\treturn 'text'\n\t}\n}\n\nvar ClientRequest = module.exports = function (opts) {\n\tvar self = this\n\tstream.Writable.call(self)\n\n\tself._opts = opts\n\tself._body = []\n\tself._headers = {}\n\tif (opts.auth)\n\t\tself.setHeader('Authorization', 'Basic ' + Buffer.from(opts.auth).toString('base64'))\n\tObject.keys(opts.headers).forEach(function (name) {\n\t\tself.setHeader(name, opts.headers[name])\n\t})\n\n\tvar preferBinary\n\tvar useFetch = true\n\tif (opts.mode === 'disable-fetch' || ('requestTimeout' in opts && !capability.abortController)) {\n\t\t// If the use of XHR should be preferred. Not typically needed.\n\t\tuseFetch = false\n\t\tpreferBinary = true\n\t} else if (opts.mode === 'prefer-streaming') {\n\t\t// If streaming is a high priority but binary compatibility and\n\t\t// the accuracy of the 'content-type' header aren't\n\t\tpreferBinary = false\n\t} else if (opts.mode === 'allow-wrong-content-type') {\n\t\t// If streaming is more important than preserving the 'content-type' header\n\t\tpreferBinary = !capability.overrideMimeType\n\t} else if (!opts.mode || opts.mode === 'default' || opts.mode === 'prefer-fast') {\n\t\t// Use binary if text streaming may corrupt data or the content-type header, or for speed\n\t\tpreferBinary = true\n\t} else {\n\t\tthrow new Error('Invalid value for opts.mode')\n\t}\n\tself._mode = decideMode(preferBinary, useFetch)\n\tself._fetchTimer = null\n\tself._socketTimeout = null\n\tself._socketTimer = null\n\n\tself.on('finish', function () {\n\t\tself._onFinish()\n\t})\n}\n\ninherits(ClientRequest, stream.Writable)\n\nClientRequest.prototype.setHeader = function (name, value) {\n\tvar self = this\n\tvar lowerName = name.toLowerCase()\n\t// This check is not necessary, but it prevents warnings from browsers about setting unsafe\n\t// headers. To be honest I'm not entirely sure hiding these warnings is a good thing, but\n\t// http-browserify did it, so I will too.\n\tif (unsafeHeaders.indexOf(lowerName) !== -1)\n\t\treturn\n\n\tself._headers[lowerName] = {\n\t\tname: name,\n\t\tvalue: value\n\t}\n}\n\nClientRequest.prototype.getHeader = function (name) {\n\tvar header = this._headers[name.toLowerCase()]\n\tif (header)\n\t\treturn header.value\n\treturn null\n}\n\nClientRequest.prototype.removeHeader = function (name) {\n\tvar self = this\n\tdelete self._headers[name.toLowerCase()]\n}\n\nClientRequest.prototype._onFinish = function () {\n\tvar self = this\n\n\tif (self._destroyed)\n\t\treturn\n\tvar opts = self._opts\n\n\tif ('timeout' in opts && opts.timeout !== 0) {\n\t\tself.setTimeout(opts.timeout)\n\t}\n\n\tvar headersObj = self._headers\n\tvar body = null\n\tif (opts.method !== 'GET' && opts.method !== 'HEAD') {\n body = new Blob(self._body, {\n type: (headersObj['content-type'] || {}).value || ''\n });\n }\n\n\t// create flattened list of headers\n\tvar headersList = []\n\tObject.keys(headersObj).forEach(function (keyName) {\n\t\tvar name = headersObj[keyName].name\n\t\tvar value = headersObj[keyName].value\n\t\tif (Array.isArray(value)) {\n\t\t\tvalue.forEach(function (v) {\n\t\t\t\theadersList.push([name, v])\n\t\t\t})\n\t\t} else {\n\t\t\theadersList.push([name, value])\n\t\t}\n\t})\n\n\tif (self._mode === 'fetch') {\n\t\tvar signal = null\n\t\tif (capability.abortController) {\n\t\t\tvar controller = new AbortController()\n\t\t\tsignal = controller.signal\n\t\t\tself._fetchAbortController = controller\n\n\t\t\tif ('requestTimeout' in opts && opts.requestTimeout !== 0) {\n\t\t\t\tself._fetchTimer = global.setTimeout(function () {\n\t\t\t\t\tself.emit('requestTimeout')\n\t\t\t\t\tif (self._fetchAbortController)\n\t\t\t\t\t\tself._fetchAbortController.abort()\n\t\t\t\t}, opts.requestTimeout)\n\t\t\t}\n\t\t}\n\n\t\tglobal.fetch(self._opts.url, {\n\t\t\tmethod: self._opts.method,\n\t\t\theaders: headersList,\n\t\t\tbody: body || undefined,\n\t\t\tmode: 'cors',\n\t\t\tcredentials: opts.withCredentials ? 'include' : 'same-origin',\n\t\t\tsignal: signal\n\t\t}).then(function (response) {\n\t\t\tself._fetchResponse = response\n\t\t\tself._resetTimers(false)\n\t\t\tself._connect()\n\t\t}, function (reason) {\n\t\t\tself._resetTimers(true)\n\t\t\tif (!self._destroyed)\n\t\t\t\tself.emit('error', reason)\n\t\t})\n\t} else {\n\t\tvar xhr = self._xhr = new global.XMLHttpRequest()\n\t\ttry {\n\t\t\txhr.open(self._opts.method, self._opts.url, true)\n\t\t} catch (err) {\n\t\t\tprocess.nextTick(function () {\n\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t\treturn\n\t\t}\n\n\t\t// Can't set responseType on really old browsers\n\t\tif ('responseType' in xhr)\n\t\t\txhr.responseType = self._mode\n\n\t\tif ('withCredentials' in xhr)\n\t\t\txhr.withCredentials = !!opts.withCredentials\n\n\t\tif (self._mode === 'text' && 'overrideMimeType' in xhr)\n\t\t\txhr.overrideMimeType('text/plain; charset=x-user-defined')\n\n\t\tif ('requestTimeout' in opts) {\n\t\t\txhr.timeout = opts.requestTimeout\n\t\t\txhr.ontimeout = function () {\n\t\t\t\tself.emit('requestTimeout')\n\t\t\t}\n\t\t}\n\n\t\theadersList.forEach(function (header) {\n\t\t\txhr.setRequestHeader(header[0], header[1])\n\t\t})\n\n\t\tself._response = null\n\t\txhr.onreadystatechange = function () {\n\t\t\tswitch (xhr.readyState) {\n\t\t\t\tcase rStates.LOADING:\n\t\t\t\tcase rStates.DONE:\n\t\t\t\t\tself._onXHRProgress()\n\t\t\t\t\tbreak\n\t\t\t}\n\t\t}\n\t\t// Necessary for streaming in Firefox, since xhr.response is ONLY defined\n\t\t// in onprogress, not in onreadystatechange with xhr.readyState = 3\n\t\tif (self._mode === 'moz-chunked-arraybuffer') {\n\t\t\txhr.onprogress = function () {\n\t\t\t\tself._onXHRProgress()\n\t\t\t}\n\t\t}\n\n\t\txhr.onerror = function () {\n\t\t\tif (self._destroyed)\n\t\t\t\treturn\n\t\t\tself._resetTimers(true)\n\t\t\tself.emit('error', new Error('XHR error'))\n\t\t}\n\n\t\ttry {\n\t\t\txhr.send(body)\n\t\t} catch (err) {\n\t\t\tprocess.nextTick(function () {\n\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t\treturn\n\t\t}\n\t}\n}\n\n/**\n * Checks if xhr.status is readable and non-zero, indicating no error.\n * Even though the spec says it should be available in readyState 3,\n * accessing it throws an exception in IE8\n */\nfunction statusValid (xhr) {\n\ttry {\n\t\tvar status = xhr.status\n\t\treturn (status !== null && status !== 0)\n\t} catch (e) {\n\t\treturn false\n\t}\n}\n\nClientRequest.prototype._onXHRProgress = function () {\n\tvar self = this\n\n\tself._resetTimers(false)\n\n\tif (!statusValid(self._xhr) || self._destroyed)\n\t\treturn\n\n\tif (!self._response)\n\t\tself._connect()\n\n\tself._response._onXHRProgress(self._resetTimers.bind(self))\n}\n\nClientRequest.prototype._connect = function () {\n\tvar self = this\n\n\tif (self._destroyed)\n\t\treturn\n\n\tself._response = new IncomingMessage(self._xhr, self._fetchResponse, self._mode, self._resetTimers.bind(self))\n\tself._response.on('error', function(err) {\n\t\tself.emit('error', err)\n\t})\n\n\tself.emit('response', self._response)\n}\n\nClientRequest.prototype._write = function (chunk, encoding, cb) {\n\tvar self = this\n\n\tself._body.push(chunk)\n\tcb()\n}\n\nClientRequest.prototype._resetTimers = function (done) {\n\tvar self = this\n\n\tglobal.clearTimeout(self._socketTimer)\n\tself._socketTimer = null\n\n\tif (done) {\n\t\tglobal.clearTimeout(self._fetchTimer)\n\t\tself._fetchTimer = null\n\t} else if (self._socketTimeout) {\n\t\tself._socketTimer = global.setTimeout(function () {\n\t\t\tself.emit('timeout')\n\t\t}, self._socketTimeout)\n\t}\n}\n\nClientRequest.prototype.abort = ClientRequest.prototype.destroy = function (err) {\n\tvar self = this\n\tself._destroyed = true\n\tself._resetTimers(true)\n\tif (self._response)\n\t\tself._response._destroyed = true\n\tif (self._xhr)\n\t\tself._xhr.abort()\n\telse if (self._fetchAbortController)\n\t\tself._fetchAbortController.abort()\n\n\tif (err)\n\t\tself.emit('error', err)\n}\n\nClientRequest.prototype.end = function (data, encoding, cb) {\n\tvar self = this\n\tif (typeof data === 'function') {\n\t\tcb = data\n\t\tdata = undefined\n\t}\n\n\tstream.Writable.prototype.end.call(self, data, encoding, cb)\n}\n\nClientRequest.prototype.setTimeout = function (timeout, cb) {\n\tvar self = this\n\n\tif (cb)\n\t\tself.once('timeout', cb)\n\n\tself._socketTimeout = timeout\n\tself._resetTimers(false)\n}\n\nClientRequest.prototype.flushHeaders = function () {}\nClientRequest.prototype.setNoDelay = function () {}\nClientRequest.prototype.setSocketKeepAlive = function () {}\n\n// Taken from http://www.w3.org/TR/XMLHttpRequest/#the-setrequestheader%28%29-method\nvar unsafeHeaders = [\n\t'accept-charset',\n\t'accept-encoding',\n\t'access-control-request-headers',\n\t'access-control-request-method',\n\t'connection',\n\t'content-length',\n\t'cookie',\n\t'cookie2',\n\t'date',\n\t'dnt',\n\t'expect',\n\t'host',\n\t'keep-alive',\n\t'origin',\n\t'referer',\n\t'te',\n\t'trailer',\n\t'transfer-encoding',\n\t'upgrade',\n\t'via'\n]\n","var capability = require('./capability')\nvar inherits = require('inherits')\nvar stream = require('readable-stream')\n\nvar rStates = exports.readyStates = {\n\tUNSENT: 0,\n\tOPENED: 1,\n\tHEADERS_RECEIVED: 2,\n\tLOADING: 3,\n\tDONE: 4\n}\n\nvar IncomingMessage = exports.IncomingMessage = function (xhr, response, mode, resetTimers) {\n\tvar self = this\n\tstream.Readable.call(self)\n\n\tself._mode = mode\n\tself.headers = {}\n\tself.rawHeaders = []\n\tself.trailers = {}\n\tself.rawTrailers = []\n\n\t// Fake the 'close' event, but only once 'end' fires\n\tself.on('end', function () {\n\t\t// The nextTick is necessary to prevent the 'request' module from causing an infinite loop\n\t\tprocess.nextTick(function () {\n\t\t\tself.emit('close')\n\t\t})\n\t})\n\n\tif (mode === 'fetch') {\n\t\tself._fetchResponse = response\n\n\t\tself.url = response.url\n\t\tself.statusCode = response.status\n\t\tself.statusMessage = response.statusText\n\t\t\n\t\tresponse.headers.forEach(function (header, key){\n\t\t\tself.headers[key.toLowerCase()] = header\n\t\t\tself.rawHeaders.push(key, header)\n\t\t})\n\n\t\tif (capability.writableStream) {\n\t\t\tvar writable = new WritableStream({\n\t\t\t\twrite: function (chunk) {\n\t\t\t\t\tresetTimers(false)\n\t\t\t\t\treturn new Promise(function (resolve, reject) {\n\t\t\t\t\t\tif (self._destroyed) {\n\t\t\t\t\t\t\treject()\n\t\t\t\t\t\t} else if(self.push(Buffer.from(chunk))) {\n\t\t\t\t\t\t\tresolve()\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tself._resumeFetch = resolve\n\t\t\t\t\t\t}\n\t\t\t\t\t})\n\t\t\t\t},\n\t\t\t\tclose: function () {\n\t\t\t\t\tresetTimers(true)\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.push(null)\n\t\t\t\t},\n\t\t\t\tabort: function (err) {\n\t\t\t\t\tresetTimers(true)\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.emit('error', err)\n\t\t\t\t}\n\t\t\t})\n\n\t\t\ttry {\n\t\t\t\tresponse.body.pipeTo(writable).catch(function (err) {\n\t\t\t\t\tresetTimers(true)\n\t\t\t\t\tif (!self._destroyed)\n\t\t\t\t\t\tself.emit('error', err)\n\t\t\t\t})\n\t\t\t\treturn\n\t\t\t} catch (e) {} // pipeTo method isn't defined. Can't find a better way to feature test this\n\t\t}\n\t\t// fallback for when writableStream or pipeTo aren't available\n\t\tvar reader = response.body.getReader()\n\t\tfunction read () {\n\t\t\treader.read().then(function (result) {\n\t\t\t\tif (self._destroyed)\n\t\t\t\t\treturn\n\t\t\t\tresetTimers(result.done)\n\t\t\t\tif (result.done) {\n\t\t\t\t\tself.push(null)\n\t\t\t\t\treturn\n\t\t\t\t}\n\t\t\t\tself.push(Buffer.from(result.value))\n\t\t\t\tread()\n\t\t\t}).catch(function (err) {\n\t\t\t\tresetTimers(true)\n\t\t\t\tif (!self._destroyed)\n\t\t\t\t\tself.emit('error', err)\n\t\t\t})\n\t\t}\n\t\tread()\n\t} else {\n\t\tself._xhr = xhr\n\t\tself._pos = 0\n\n\t\tself.url = xhr.responseURL\n\t\tself.statusCode = xhr.status\n\t\tself.statusMessage = xhr.statusText\n\t\tvar headers = xhr.getAllResponseHeaders().split(/\\r?\\n/)\n\t\theaders.forEach(function (header) {\n\t\t\tvar matches = header.match(/^([^:]+):\\s*(.*)/)\n\t\t\tif (matches) {\n\t\t\t\tvar key = matches[1].toLowerCase()\n\t\t\t\tif (key === 'set-cookie') {\n\t\t\t\t\tif (self.headers[key] === undefined) {\n\t\t\t\t\t\tself.headers[key] = []\n\t\t\t\t\t}\n\t\t\t\t\tself.headers[key].push(matches[2])\n\t\t\t\t} else if (self.headers[key] !== undefined) {\n\t\t\t\t\tself.headers[key] += ', ' + matches[2]\n\t\t\t\t} else {\n\t\t\t\t\tself.headers[key] = matches[2]\n\t\t\t\t}\n\t\t\t\tself.rawHeaders.push(matches[1], matches[2])\n\t\t\t}\n\t\t})\n\n\t\tself._charset = 'x-user-defined'\n\t\tif (!capability.overrideMimeType) {\n\t\t\tvar mimeType = self.rawHeaders['mime-type']\n\t\t\tif (mimeType) {\n\t\t\t\tvar charsetMatch = mimeType.match(/;\\s*charset=([^;])(;|$)/)\n\t\t\t\tif (charsetMatch) {\n\t\t\t\t\tself._charset = charsetMatch[1].toLowerCase()\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (!self._charset)\n\t\t\t\tself._charset = 'utf-8' // best guess\n\t\t}\n\t}\n}\n\ninherits(IncomingMessage, stream.Readable)\n\nIncomingMessage.prototype._read = function () {\n\tvar self = this\n\n\tvar resolve = self._resumeFetch\n\tif (resolve) {\n\t\tself._resumeFetch = null\n\t\tresolve()\n\t}\n}\n\nIncomingMessage.prototype._onXHRProgress = function (resetTimers) {\n\tvar self = this\n\n\tvar xhr = self._xhr\n\n\tvar response = null\n\tswitch (self._mode) {\n\t\tcase 'text':\n\t\t\tresponse = xhr.responseText\n\t\t\tif (response.length > self._pos) {\n\t\t\t\tvar newData = response.substr(self._pos)\n\t\t\t\tif (self._charset === 'x-user-defined') {\n\t\t\t\t\tvar buffer = Buffer.alloc(newData.length)\n\t\t\t\t\tfor (var i = 0; i < newData.length; i++)\n\t\t\t\t\t\tbuffer[i] = newData.charCodeAt(i) & 0xff\n\n\t\t\t\t\tself.push(buffer)\n\t\t\t\t} else {\n\t\t\t\t\tself.push(newData, self._charset)\n\t\t\t\t}\n\t\t\t\tself._pos = response.length\n\t\t\t}\n\t\t\tbreak\n\t\tcase 'arraybuffer':\n\t\t\tif (xhr.readyState !== rStates.DONE || !xhr.response)\n\t\t\t\tbreak\n\t\t\tresponse = xhr.response\n\t\t\tself.push(Buffer.from(new Uint8Array(response)))\n\t\t\tbreak\n\t\tcase 'moz-chunked-arraybuffer': // take whole\n\t\t\tresponse = xhr.response\n\t\t\tif (xhr.readyState !== rStates.LOADING || !response)\n\t\t\t\tbreak\n\t\t\tself.push(Buffer.from(new Uint8Array(response)))\n\t\t\tbreak\n\t\tcase 'ms-stream':\n\t\t\tresponse = xhr.response\n\t\t\tif (xhr.readyState !== rStates.LOADING)\n\t\t\t\tbreak\n\t\t\tvar reader = new global.MSStreamReader()\n\t\t\treader.onprogress = function () {\n\t\t\t\tif (reader.result.byteLength > self._pos) {\n\t\t\t\t\tself.push(Buffer.from(new Uint8Array(reader.result.slice(self._pos))))\n\t\t\t\t\tself._pos = reader.result.byteLength\n\t\t\t\t}\n\t\t\t}\n\t\t\treader.onload = function () {\n\t\t\t\tresetTimers(true)\n\t\t\t\tself.push(null)\n\t\t\t}\n\t\t\t// reader.onerror = ??? // TODO: this\n\t\t\treader.readAsArrayBuffer(response)\n\t\t\tbreak\n\t}\n\n\t// The ms-stream case handles end separately in reader.onload()\n\tif (self._xhr.readyState === rStates.DONE && self._mode !== 'ms-stream') {\n\t\tresetTimers(true)\n\t\tself.push(null)\n\t}\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n encoding = '' + encoding;\n switch (encoding && encoding.toLowerCase()) {\n case 'hex':case 'utf8':case 'utf-8':case 'ascii':case 'binary':case 'base64':case 'ucs2':case 'ucs-2':case 'utf16le':case 'utf-16le':case 'raw':\n return true;\n default:\n return false;\n }\n};\n\nfunction _normalizeEncoding(enc) {\n if (!enc) return 'utf8';\n var retried;\n while (true) {\n switch (enc) {\n case 'utf8':\n case 'utf-8':\n return 'utf8';\n case 'ucs2':\n case 'ucs-2':\n case 'utf16le':\n case 'utf-16le':\n return 'utf16le';\n case 'latin1':\n case 'binary':\n return 'latin1';\n case 'base64':\n case 'ascii':\n case 'hex':\n return enc;\n default:\n if (retried) return; // undefined\n enc = ('' + enc).toLowerCase();\n retried = true;\n }\n }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n var nenc = _normalizeEncoding(enc);\n if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n this.encoding = normalizeEncoding(encoding);\n var nb;\n switch (this.encoding) {\n case 'utf16le':\n this.text = utf16Text;\n this.end = utf16End;\n nb = 4;\n break;\n case 'utf8':\n this.fillLast = utf8FillLast;\n nb = 4;\n break;\n case 'base64':\n this.text = base64Text;\n this.end = base64End;\n nb = 3;\n break;\n default:\n this.write = simpleWrite;\n this.end = simpleEnd;\n return;\n }\n this.lastNeed = 0;\n this.lastTotal = 0;\n this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n if (buf.length === 0) return '';\n var r;\n var i;\n if (this.lastNeed) {\n r = this.fillLast(buf);\n if (r === undefined) return '';\n i = this.lastNeed;\n this.lastNeed = 0;\n } else {\n i = 0;\n }\n if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n if (this.lastNeed <= buf.length) {\n buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n }\n buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n var j = buf.length - 1;\n if (j < i) return 0;\n var nb = utf8CheckByte(buf[j]);\n if (nb >= 0) {\n if (nb > 0) self.lastNeed = nb - 1;\n return nb;\n }\n if (--j < i || nb === -2) return 0;\n nb = utf8CheckByte(buf[j]);\n if (nb >= 0) {\n if (nb > 0) self.lastNeed = nb - 2;\n return nb;\n }\n if (--j < i || nb === -2) return 0;\n nb = utf8CheckByte(buf[j]);\n if (nb >= 0) {\n if (nb > 0) {\n if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n }\n return nb;\n }\n return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n if ((buf[0] & 0xC0) !== 0x80) {\n self.lastNeed = 0;\n return '\\ufffd';\n }\n if (self.lastNeed > 1 && buf.length > 1) {\n if ((buf[1] & 0xC0) !== 0x80) {\n self.lastNeed = 1;\n return '\\ufffd';\n }\n if (self.lastNeed > 2 && buf.length > 2) {\n if ((buf[2] & 0xC0) !== 0x80) {\n self.lastNeed = 2;\n return '\\ufffd';\n }\n }\n }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n var p = this.lastTotal - this.lastNeed;\n var r = utf8CheckExtraBytes(this, buf, p);\n if (r !== undefined) return r;\n if (this.lastNeed <= buf.length) {\n buf.copy(this.lastChar, p, 0, this.lastNeed);\n return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n }\n buf.copy(this.lastChar, p, 0, buf.length);\n this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n var total = utf8CheckIncomplete(this, buf, i);\n if (!this.lastNeed) return buf.toString('utf8', i);\n this.lastTotal = total;\n var end = buf.length - (total - this.lastNeed);\n buf.copy(this.lastChar, 0, end);\n return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n var r = buf && buf.length ? this.write(buf) : '';\n if (this.lastNeed) return r + '\\ufffd';\n return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n if ((buf.length - i) % 2 === 0) {\n var r = buf.toString('utf16le', i);\n if (r) {\n var c = r.charCodeAt(r.length - 1);\n if (c >= 0xD800 && c <= 0xDBFF) {\n this.lastNeed = 2;\n this.lastTotal = 4;\n this.lastChar[0] = buf[buf.length - 2];\n this.lastChar[1] = buf[buf.length - 1];\n return r.slice(0, -1);\n }\n }\n return r;\n }\n this.lastNeed = 1;\n this.lastTotal = 2;\n this.lastChar[0] = buf[buf.length - 1];\n return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n var r = buf && buf.length ? this.write(buf) : '';\n if (this.lastNeed) {\n var end = this.lastTotal - this.lastNeed;\n return r + this.lastChar.toString('utf16le', 0, end);\n }\n return r;\n}\n\nfunction base64Text(buf, i) {\n var n = (buf.length - i) % 3;\n if (n === 0) return buf.toString('base64', i);\n this.lastNeed = 3 - n;\n this.lastTotal = 3;\n if (n === 1) {\n this.lastChar[0] = buf[buf.length - 1];\n } else {\n this.lastChar[0] = buf[buf.length - 2];\n this.lastChar[1] = buf[buf.length - 1];\n }\n return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n var r = buf && buf.length ? this.write(buf) : '';\n if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n return buf && buf.length ? this.write(buf) : '';\n}","const BN = require('bn.js')\nconst EC = require('elliptic').ec\nconst secp256k1 = new EC('secp256k1')\nconst deterministicGenerateK = require('./rfc6979')\n\nconst ZERO32 = Buffer.alloc(32, 0)\nconst EC_GROUP_ORDER = Buffer.from('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141', 'hex')\nconst EC_P = Buffer.from('fffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f', 'hex')\n\nconst n = secp256k1.curve.n\nconst nDiv2 = n.shrn(1)\nconst G = secp256k1.curve.g\n\nconst THROW_BAD_PRIVATE = 'Expected Private'\nconst THROW_BAD_POINT = 'Expected Point'\nconst THROW_BAD_TWEAK = 'Expected Tweak'\nconst THROW_BAD_HASH = 'Expected Hash'\nconst THROW_BAD_SIGNATURE = 'Expected Signature'\nconst THROW_BAD_EXTRA_DATA = 'Expected Extra Data (32 bytes)'\n\nfunction isScalar (x) {\n return Buffer.isBuffer(x) && x.length === 32\n}\n\nfunction isOrderScalar (x) {\n if (!isScalar(x)) return false\n return x.compare(EC_GROUP_ORDER) < 0 // < G\n}\n\nfunction isPoint (p) {\n if (!Buffer.isBuffer(p)) return false\n if (p.length < 33) return false\n\n const t = p[0]\n const x = p.slice(1, 33)\n if (x.compare(ZERO32) === 0) return false\n if (x.compare(EC_P) >= 0) return false\n if ((t === 0x02 || t === 0x03) && p.length === 33) {\n try { decodeFrom(p) } catch (e) { return false } // TODO: temporary\n return true\n }\n\n const y = p.slice(33)\n if (y.compare(ZERO32) === 0) return false\n if (y.compare(EC_P) >= 0) return false\n if (t === 0x04 && p.length === 65) return true\n return false\n}\n\nfunction __isPointCompressed (p) {\n return p[0] !== 0x04\n}\n\nfunction isPointCompressed (p) {\n if (!isPoint(p)) return false\n return __isPointCompressed(p)\n}\n\nfunction isPrivate (x) {\n if (!isScalar(x)) return false\n return x.compare(ZERO32) > 0 && // > 0\n x.compare(EC_GROUP_ORDER) < 0 // < G\n}\n\nfunction isSignature (value) {\n const r = value.slice(0, 32)\n const s = value.slice(32, 64)\n return Buffer.isBuffer(value) && value.length === 64 &&\n r.compare(EC_GROUP_ORDER) < 0 &&\n s.compare(EC_GROUP_ORDER) < 0\n}\n\nfunction assumeCompression (value, pubkey) {\n if (value === undefined && pubkey !== undefined) return __isPointCompressed(pubkey)\n if (value === undefined) return true\n return value\n}\n\nfunction fromBuffer (d) { return new BN(d) }\nfunction toBuffer (d) { return d.toArrayLike(Buffer, 'be', 32) }\nfunction decodeFrom (P) { return secp256k1.curve.decodePoint(P) }\nfunction getEncoded (P, compressed) { return Buffer.from(P._encode(compressed)) }\n\nfunction pointAdd (pA, pB, __compressed) {\n if (!isPoint(pA)) throw new TypeError(THROW_BAD_POINT)\n if (!isPoint(pB)) throw new TypeError(THROW_BAD_POINT)\n\n const a = decodeFrom(pA)\n const b = decodeFrom(pB)\n const pp = a.add(b)\n if (pp.isInfinity()) return null\n\n const compressed = assumeCompression(__compressed, pA)\n return getEncoded(pp, compressed)\n}\n\nfunction pointAddScalar (p, tweak, __compressed) {\n if (!isPoint(p)) throw new TypeError(THROW_BAD_POINT)\n if (!isOrderScalar(tweak)) throw new TypeError(THROW_BAD_TWEAK)\n\n const compressed = assumeCompression(__compressed, p)\n const pp = decodeFrom(p)\n if (tweak.compare(ZERO32) === 0) return getEncoded(pp, compressed)\n\n const tt = fromBuffer(tweak)\n const qq = G.mul(tt)\n const uu = pp.add(qq)\n if (uu.isInfinity()) return null\n\n return getEncoded(uu, compressed)\n}\n\nfunction pointCompress (p, __compressed) {\n if (!isPoint(p)) throw new TypeError(THROW_BAD_POINT)\n\n const pp = decodeFrom(p)\n if (pp.isInfinity()) throw new TypeError(THROW_BAD_POINT)\n\n const compressed = assumeCompression(__compressed, p)\n\n return getEncoded(pp, compressed)\n}\n\nfunction pointFromScalar (d, __compressed) {\n if (!isPrivate(d)) throw new TypeError(THROW_BAD_PRIVATE)\n\n const dd = fromBuffer(d)\n const pp = G.mul(dd)\n if (pp.isInfinity()) return null\n\n const compressed = assumeCompression(__compressed)\n return getEncoded(pp, compressed)\n}\n\nfunction pointMultiply (p, tweak, __compressed) {\n if (!isPoint(p)) throw new TypeError(THROW_BAD_POINT)\n if (!isOrderScalar(tweak)) throw new TypeError(THROW_BAD_TWEAK)\n\n const compressed = assumeCompression(__compressed, p)\n const pp = decodeFrom(p)\n const tt = fromBuffer(tweak)\n const qq = pp.mul(tt)\n if (qq.isInfinity()) return null\n\n return getEncoded(qq, compressed)\n}\n\nfunction privateAdd (d, tweak) {\n if (!isPrivate(d)) throw new TypeError(THROW_BAD_PRIVATE)\n if (!isOrderScalar(tweak)) throw new TypeError(THROW_BAD_TWEAK)\n\n const dd = fromBuffer(d)\n const tt = fromBuffer(tweak)\n const dt = toBuffer(dd.add(tt).umod(n))\n if (!isPrivate(dt)) return null\n\n return dt\n}\n\nfunction privateSub (d, tweak) {\n if (!isPrivate(d)) throw new TypeError(THROW_BAD_PRIVATE)\n if (!isOrderScalar(tweak)) throw new TypeError(THROW_BAD_TWEAK)\n\n const dd = fromBuffer(d)\n const tt = fromBuffer(tweak)\n const dt = toBuffer(dd.sub(tt).umod(n))\n if (!isPrivate(dt)) return null\n\n return dt\n}\n\nfunction sign (hash, x) {\n return __sign(hash, x)\n}\n\nfunction signWithEntropy (hash, x, addData) {\n return __sign(hash, x, addData)\n}\n\nfunction __sign (hash, x, addData) {\n if (!isScalar(hash)) throw new TypeError(THROW_BAD_HASH)\n if (!isPrivate(x)) throw new TypeError(THROW_BAD_PRIVATE)\n if (addData !== undefined && !isScalar(addData)) throw new TypeError(THROW_BAD_EXTRA_DATA)\n\n const d = fromBuffer(x)\n const e = fromBuffer(hash)\n\n let r, s\n const checkSig = function (k) {\n const kI = fromBuffer(k)\n const Q = G.mul(kI)\n\n if (Q.isInfinity()) return false\n\n r = Q.x.umod(n)\n if (r.isZero() === 0) return false\n\n s = kI\n .invm(n)\n .mul(e.add(d.mul(r)))\n .umod(n)\n if (s.isZero() === 0) return false\n\n return true\n }\n\n deterministicGenerateK(hash, x, checkSig, isPrivate, addData)\n\n // enforce low S values, see bip62: 'low s values in signatures'\n if (s.cmp(nDiv2) > 0) {\n s = n.sub(s)\n }\n\n const buffer = Buffer.allocUnsafe(64)\n toBuffer(r).copy(buffer, 0)\n toBuffer(s).copy(buffer, 32)\n return buffer\n}\n\nfunction verify (hash, q, signature, strict) {\n if (!isScalar(hash)) throw new TypeError(THROW_BAD_HASH)\n if (!isPoint(q)) throw new TypeError(THROW_BAD_POINT)\n\n // 1.4.1 Enforce r and s are both integers in the interval [1, n − 1] (1, isSignature enforces '< n - 1')\n if (!isSignature(signature)) throw new TypeError(THROW_BAD_SIGNATURE)\n\n const Q = decodeFrom(q)\n const r = fromBuffer(signature.slice(0, 32))\n const s = fromBuffer(signature.slice(32, 64))\n\n if (strict && s.cmp(nDiv2) > 0) {\n return false\n }\n\n // 1.4.1 Enforce r and s are both integers in the interval [1, n − 1] (2, enforces '> 0')\n if (r.gtn(0) <= 0 /* || r.compareTo(n) >= 0 */) return false\n if (s.gtn(0) <= 0 /* || s.compareTo(n) >= 0 */) return false\n\n // 1.4.2 H = Hash(M), already done by the user\n // 1.4.3 e = H\n const e = fromBuffer(hash)\n\n // Compute s^-1\n const sInv = s.invm(n)\n\n // 1.4.4 Compute u1 = es^−1 mod n\n // u2 = rs^−1 mod n\n const u1 = e.mul(sInv).umod(n)\n const u2 = r.mul(sInv).umod(n)\n\n // 1.4.5 Compute R = (xR, yR)\n // R = u1G + u2Q\n const R = G.mulAdd(u1, Q, u2)\n\n // 1.4.5 (cont.) Enforce R is not at infinity\n if (R.isInfinity()) return false\n\n // 1.4.6 Convert the field element R.x to an integer\n const xR = R.x\n\n // 1.4.7 Set v = xR mod n\n const v = xR.umod(n)\n\n // 1.4.8 If v = r, output \"valid\", and if v != r, output \"invalid\"\n return v.eq(r)\n}\n\nmodule.exports = {\n isPoint,\n isPointCompressed,\n isPrivate,\n pointAdd,\n pointAddScalar,\n pointCompress,\n pointFromScalar,\n pointMultiply,\n privateAdd,\n privateSub,\n sign,\n signWithEntropy,\n verify\n}\n","const createHmac = require('create-hmac')\n\nconst ONE1 = Buffer.alloc(1, 1)\nconst ZERO1 = Buffer.alloc(1, 0)\n\n// https://tools.ietf.org/html/rfc6979#section-3.2\nfunction deterministicGenerateK (hash, x, checkSig, isPrivate, extraEntropy) {\n // Step A, ignored as hash already provided\n // Step B\n // Step C\n let k = Buffer.alloc(32, 0)\n let v = Buffer.alloc(32, 1)\n\n // Step D\n k = createHmac('sha256', k)\n .update(v)\n .update(ZERO1)\n .update(x)\n .update(hash)\n .update(extraEntropy || '')\n .digest()\n\n // Step E\n v = createHmac('sha256', k).update(v).digest()\n\n // Step F\n k = createHmac('sha256', k)\n .update(v)\n .update(ONE1)\n .update(x)\n .update(hash)\n .update(extraEntropy || '')\n .digest()\n\n // Step G\n v = createHmac('sha256', k).update(v).digest()\n\n // Step H1/H2a, ignored as tlen === qlen (256 bit)\n // Step H2b\n v = createHmac('sha256', k).update(v).digest()\n\n let T = v\n\n // Step H3, repeat until T is within the interval [1, n - 1] and is suitable for ECDSA\n while (!isPrivate(T) || !checkSig(T)) {\n k = createHmac('sha256', k)\n .update(v)\n .update(ZERO1)\n .digest()\n\n v = createHmac('sha256', k).update(v).digest()\n\n // Step H1/H2a, again, ignored as tlen === qlen (256 bit)\n // Step H2b again\n v = createHmac('sha256', k).update(v).digest()\n T = v\n }\n\n return T\n}\n\nmodule.exports = deterministicGenerateK\n","var native = require('./native')\n\nfunction getTypeName (fn) {\n return fn.name || fn.toString().match(/function (.*?)\\s*\\(/)[1]\n}\n\nfunction getValueTypeName (value) {\n return native.Nil(value) ? '' : getTypeName(value.constructor)\n}\n\nfunction getValue (value) {\n if (native.Function(value)) return ''\n if (native.String(value)) return JSON.stringify(value)\n if (value && native.Object(value)) return ''\n return value\n}\n\nfunction captureStackTrace (e, t) {\n if (Error.captureStackTrace) {\n Error.captureStackTrace(e, t)\n }\n}\n\nfunction tfJSON (type) {\n if (native.Function(type)) return type.toJSON ? type.toJSON() : getTypeName(type)\n if (native.Array(type)) return 'Array'\n if (type && native.Object(type)) return 'Object'\n\n return type !== undefined ? type : ''\n}\n\nfunction tfErrorString (type, value, valueTypeName) {\n var valueJson = getValue(value)\n\n return 'Expected ' + tfJSON(type) + ', got' +\n (valueTypeName !== '' ? ' ' + valueTypeName : '') +\n (valueJson !== '' ? ' ' + valueJson : '')\n}\n\nfunction TfTypeError (type, value, valueTypeName) {\n valueTypeName = valueTypeName || getValueTypeName(value)\n this.message = tfErrorString(type, value, valueTypeName)\n\n captureStackTrace(this, TfTypeError)\n this.__type = type\n this.__value = value\n this.__valueTypeName = valueTypeName\n}\n\nTfTypeError.prototype = Object.create(Error.prototype)\nTfTypeError.prototype.constructor = TfTypeError\n\nfunction tfPropertyErrorString (type, label, name, value, valueTypeName) {\n var description = '\" of type '\n if (label === 'key') description = '\" with key type '\n\n return tfErrorString('property \"' + tfJSON(name) + description + tfJSON(type), value, valueTypeName)\n}\n\nfunction TfPropertyTypeError (type, property, label, value, valueTypeName) {\n if (type) {\n valueTypeName = valueTypeName || getValueTypeName(value)\n this.message = tfPropertyErrorString(type, label, property, value, valueTypeName)\n } else {\n this.message = 'Unexpected property \"' + property + '\"'\n }\n\n captureStackTrace(this, TfTypeError)\n this.__label = label\n this.__property = property\n this.__type = type\n this.__value = value\n this.__valueTypeName = valueTypeName\n}\n\nTfPropertyTypeError.prototype = Object.create(Error.prototype)\nTfPropertyTypeError.prototype.constructor = TfTypeError\n\nfunction tfCustomError (expected, actual) {\n return new TfTypeError(expected, {}, actual)\n}\n\nfunction tfSubError (e, property, label) {\n // sub child?\n if (e instanceof TfPropertyTypeError) {\n property = property + '.' + e.__property\n\n e = new TfPropertyTypeError(\n e.__type, property, e.__label, e.__value, e.__valueTypeName\n )\n\n // child?\n } else if (e instanceof TfTypeError) {\n e = new TfPropertyTypeError(\n e.__type, property, label, e.__value, e.__valueTypeName\n )\n }\n\n captureStackTrace(e)\n return e\n}\n\nmodule.exports = {\n TfTypeError: TfTypeError,\n TfPropertyTypeError: TfPropertyTypeError,\n tfCustomError: tfCustomError,\n tfSubError: tfSubError,\n tfJSON: tfJSON,\n getValueTypeName: getValueTypeName\n}\n","var NATIVE = require('./native')\nvar ERRORS = require('./errors')\n\nfunction _Buffer (value) {\n return Buffer.isBuffer(value)\n}\n\nfunction Hex (value) {\n return typeof value === 'string' && /^([0-9a-f]{2})+$/i.test(value)\n}\n\nfunction _LengthN (type, length) {\n var name = type.toJSON()\n\n function Length (value) {\n if (!type(value)) return false\n if (value.length === length) return true\n\n throw ERRORS.tfCustomError(name + '(Length: ' + length + ')', name + '(Length: ' + value.length + ')')\n }\n Length.toJSON = function () { return name }\n\n return Length\n}\n\nvar _ArrayN = _LengthN.bind(null, NATIVE.Array)\nvar _BufferN = _LengthN.bind(null, _Buffer)\nvar _HexN = _LengthN.bind(null, Hex)\nvar _StringN = _LengthN.bind(null, NATIVE.String)\n\nfunction Range (a, b, f) {\n f = f || NATIVE.Number\n function _range (value, strict) {\n return f(value, strict) && (value > a) && (value < b)\n }\n _range.toJSON = function () {\n return `${f.toJSON()} between [${a}, ${b}]`\n }\n return _range\n}\n\nvar INT53_MAX = Math.pow(2, 53) - 1\n\nfunction Finite (value) {\n return typeof value === 'number' && isFinite(value)\n}\nfunction Int8 (value) { return ((value << 24) >> 24) === value }\nfunction Int16 (value) { return ((value << 16) >> 16) === value }\nfunction Int32 (value) { return (value | 0) === value }\nfunction Int53 (value) {\n return typeof value === 'number' &&\n value >= -INT53_MAX &&\n value <= INT53_MAX &&\n Math.floor(value) === value\n}\nfunction UInt8 (value) { return (value & 0xff) === value }\nfunction UInt16 (value) { return (value & 0xffff) === value }\nfunction UInt32 (value) { return (value >>> 0) === value }\nfunction UInt53 (value) {\n return typeof value === 'number' &&\n value >= 0 &&\n value <= INT53_MAX &&\n Math.floor(value) === value\n}\n\nvar types = {\n ArrayN: _ArrayN,\n Buffer: _Buffer,\n BufferN: _BufferN,\n Finite: Finite,\n Hex: Hex,\n HexN: _HexN,\n Int8: Int8,\n Int16: Int16,\n Int32: Int32,\n Int53: Int53,\n Range: Range,\n StringN: _StringN,\n UInt8: UInt8,\n UInt16: UInt16,\n UInt32: UInt32,\n UInt53: UInt53\n}\n\nfor (var typeName in types) {\n types[typeName].toJSON = function (t) {\n return t\n }.bind(null, typeName)\n}\n\nmodule.exports = types\n","var ERRORS = require('./errors')\nvar NATIVE = require('./native')\n\n// short-hand\nvar tfJSON = ERRORS.tfJSON\nvar TfTypeError = ERRORS.TfTypeError\nvar TfPropertyTypeError = ERRORS.TfPropertyTypeError\nvar tfSubError = ERRORS.tfSubError\nvar getValueTypeName = ERRORS.getValueTypeName\n\nvar TYPES = {\n arrayOf: function arrayOf (type, options) {\n type = compile(type)\n options = options || {}\n\n function _arrayOf (array, strict) {\n if (!NATIVE.Array(array)) return false\n if (NATIVE.Nil(array)) return false\n if (options.minLength !== undefined && array.length < options.minLength) return false\n if (options.maxLength !== undefined && array.length > options.maxLength) return false\n if (options.length !== undefined && array.length !== options.length) return false\n\n return array.every(function (value, i) {\n try {\n return typeforce(type, value, strict)\n } catch (e) {\n throw tfSubError(e, i)\n }\n })\n }\n _arrayOf.toJSON = function () {\n var str = '[' + tfJSON(type) + ']'\n if (options.length !== undefined) {\n str += '{' + options.length + '}'\n } else if (options.minLength !== undefined || options.maxLength !== undefined) {\n str += '{' +\n (options.minLength === undefined ? 0 : options.minLength) + ',' +\n (options.maxLength === undefined ? Infinity : options.maxLength) + '}'\n }\n return str\n }\n\n return _arrayOf\n },\n\n maybe: function maybe (type) {\n type = compile(type)\n\n function _maybe (value, strict) {\n return NATIVE.Nil(value) || type(value, strict, maybe)\n }\n _maybe.toJSON = function () { return '?' + tfJSON(type) }\n\n return _maybe\n },\n\n map: function map (propertyType, propertyKeyType) {\n propertyType = compile(propertyType)\n if (propertyKeyType) propertyKeyType = compile(propertyKeyType)\n\n function _map (value, strict) {\n if (!NATIVE.Object(value)) return false\n if (NATIVE.Nil(value)) return false\n\n for (var propertyName in value) {\n try {\n if (propertyKeyType) {\n typeforce(propertyKeyType, propertyName, strict)\n }\n } catch (e) {\n throw tfSubError(e, propertyName, 'key')\n }\n\n try {\n var propertyValue = value[propertyName]\n typeforce(propertyType, propertyValue, strict)\n } catch (e) {\n throw tfSubError(e, propertyName)\n }\n }\n\n return true\n }\n\n if (propertyKeyType) {\n _map.toJSON = function () {\n return '{' + tfJSON(propertyKeyType) + ': ' + tfJSON(propertyType) + '}'\n }\n } else {\n _map.toJSON = function () { return '{' + tfJSON(propertyType) + '}' }\n }\n\n return _map\n },\n\n object: function object (uncompiled) {\n var type = {}\n\n for (var typePropertyName in uncompiled) {\n type[typePropertyName] = compile(uncompiled[typePropertyName])\n }\n\n function _object (value, strict) {\n if (!NATIVE.Object(value)) return false\n if (NATIVE.Nil(value)) return false\n\n var propertyName\n\n try {\n for (propertyName in type) {\n var propertyType = type[propertyName]\n var propertyValue = value[propertyName]\n\n typeforce(propertyType, propertyValue, strict)\n }\n } catch (e) {\n throw tfSubError(e, propertyName)\n }\n\n if (strict) {\n for (propertyName in value) {\n if (type[propertyName]) continue\n\n throw new TfPropertyTypeError(undefined, propertyName)\n }\n }\n\n return true\n }\n _object.toJSON = function () { return tfJSON(type) }\n\n return _object\n },\n\n anyOf: function anyOf () {\n var types = [].slice.call(arguments).map(compile)\n\n function _anyOf (value, strict) {\n return types.some(function (type) {\n try {\n return typeforce(type, value, strict)\n } catch (e) {\n return false\n }\n })\n }\n _anyOf.toJSON = function () { return types.map(tfJSON).join('|') }\n\n return _anyOf\n },\n\n allOf: function allOf () {\n var types = [].slice.call(arguments).map(compile)\n\n function _allOf (value, strict) {\n return types.every(function (type) {\n try {\n return typeforce(type, value, strict)\n } catch (e) {\n return false\n }\n })\n }\n _allOf.toJSON = function () { return types.map(tfJSON).join(' & ') }\n\n return _allOf\n },\n\n quacksLike: function quacksLike (type) {\n function _quacksLike (value) {\n return type === getValueTypeName(value)\n }\n _quacksLike.toJSON = function () { return type }\n\n return _quacksLike\n },\n\n tuple: function tuple () {\n var types = [].slice.call(arguments).map(compile)\n\n function _tuple (values, strict) {\n if (NATIVE.Nil(values)) return false\n if (NATIVE.Nil(values.length)) return false\n if (strict && (values.length !== types.length)) return false\n\n return types.every(function (type, i) {\n try {\n return typeforce(type, values[i], strict)\n } catch (e) {\n throw tfSubError(e, i)\n }\n })\n }\n _tuple.toJSON = function () { return '(' + types.map(tfJSON).join(', ') + ')' }\n\n return _tuple\n },\n\n value: function value (expected) {\n function _value (actual) {\n return actual === expected\n }\n _value.toJSON = function () { return expected }\n\n return _value\n }\n}\n\n// TODO: deprecate\nTYPES.oneOf = TYPES.anyOf\n\nfunction compile (type) {\n if (NATIVE.String(type)) {\n if (type[0] === '?') return TYPES.maybe(type.slice(1))\n\n return NATIVE[type] || TYPES.quacksLike(type)\n } else if (type && NATIVE.Object(type)) {\n if (NATIVE.Array(type)) {\n if (type.length !== 1) throw new TypeError('Expected compile() parameter of type Array of length 1')\n return TYPES.arrayOf(type[0])\n }\n\n return TYPES.object(type)\n } else if (NATIVE.Function(type)) {\n return type\n }\n\n return TYPES.value(type)\n}\n\nfunction typeforce (type, value, strict, surrogate) {\n if (NATIVE.Function(type)) {\n if (type(value, strict)) return true\n\n throw new TfTypeError(surrogate || type, value)\n }\n\n // JIT\n return typeforce(compile(type), value, strict)\n}\n\n// assign types to typeforce function\nfor (var typeName in NATIVE) {\n typeforce[typeName] = NATIVE[typeName]\n}\n\nfor (typeName in TYPES) {\n typeforce[typeName] = TYPES[typeName]\n}\n\nvar EXTRA = require('./extra')\nfor (typeName in EXTRA) {\n typeforce[typeName] = EXTRA[typeName]\n}\n\ntypeforce.compile = compile\ntypeforce.TfTypeError = TfTypeError\ntypeforce.TfPropertyTypeError = TfPropertyTypeError\n\nmodule.exports = typeforce\n","var types = {\n Array: function (value) { return value !== null && value !== undefined && value.constructor === Array },\n Boolean: function (value) { return typeof value === 'boolean' },\n Function: function (value) { return typeof value === 'function' },\n Nil: function (value) { return value === undefined || value === null },\n Number: function (value) { return typeof value === 'number' },\n Object: function (value) { return typeof value === 'object' },\n String: function (value) { return typeof value === 'string' },\n '': function () { return true }\n}\n\n// TODO: deprecate\ntypes.Null = types.Nil\n\nfor (var typeName in types) {\n types[typeName].toJSON = function (t) {\n return t\n }.bind(null, typeName)\n}\n\nmodule.exports = types\n","/*! https://mths.be/punycode v1.3.2 by @mathias */\n;(function(root) {\n\n\t/** Detect free variables */\n\tvar freeExports = typeof exports == 'object' && exports &&\n\t\t!exports.nodeType && exports;\n\tvar freeModule = typeof module == 'object' && module &&\n\t\t!module.nodeType && module;\n\tvar freeGlobal = typeof global == 'object' && global;\n\tif (\n\t\tfreeGlobal.global === freeGlobal ||\n\t\tfreeGlobal.window === freeGlobal ||\n\t\tfreeGlobal.self === freeGlobal\n\t) {\n\t\troot = freeGlobal;\n\t}\n\n\t/**\n\t * The `punycode` object.\n\t * @name punycode\n\t * @type Object\n\t */\n\tvar punycode,\n\n\t/** Highest positive signed 32-bit float value */\n\tmaxInt = 2147483647, // aka. 0x7FFFFFFF or 2^31-1\n\n\t/** Bootstring parameters */\n\tbase = 36,\n\ttMin = 1,\n\ttMax = 26,\n\tskew = 38,\n\tdamp = 700,\n\tinitialBias = 72,\n\tinitialN = 128, // 0x80\n\tdelimiter = '-', // '\\x2D'\n\n\t/** Regular expressions */\n\tregexPunycode = /^xn--/,\n\tregexNonASCII = /[^\\x20-\\x7E]/, // unprintable ASCII chars + non-ASCII chars\n\tregexSeparators = /[\\x2E\\u3002\\uFF0E\\uFF61]/g, // RFC 3490 separators\n\n\t/** Error messages */\n\terrors = {\n\t\t'overflow': 'Overflow: input needs wider integers to process',\n\t\t'not-basic': 'Illegal input >= 0x80 (not a basic code point)',\n\t\t'invalid-input': 'Invalid input'\n\t},\n\n\t/** Convenience shortcuts */\n\tbaseMinusTMin = base - tMin,\n\tfloor = Math.floor,\n\tstringFromCharCode = String.fromCharCode,\n\n\t/** Temporary variable */\n\tkey;\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/**\n\t * A generic error utility function.\n\t * @private\n\t * @param {String} type The error type.\n\t * @returns {Error} Throws a `RangeError` with the applicable error message.\n\t */\n\tfunction error(type) {\n\t\tthrow RangeError(errors[type]);\n\t}\n\n\t/**\n\t * A generic `Array#map` utility function.\n\t * @private\n\t * @param {Array} array The array to iterate over.\n\t * @param {Function} callback The function that gets called for every array\n\t * item.\n\t * @returns {Array} A new array of values returned by the callback function.\n\t */\n\tfunction map(array, fn) {\n\t\tvar length = array.length;\n\t\tvar result = [];\n\t\twhile (length--) {\n\t\t\tresult[length] = fn(array[length]);\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * A simple `Array#map`-like wrapper to work with domain name strings or email\n\t * addresses.\n\t * @private\n\t * @param {String} domain The domain name or email address.\n\t * @param {Function} callback The function that gets called for every\n\t * character.\n\t * @returns {Array} A new string of characters returned by the callback\n\t * function.\n\t */\n\tfunction mapDomain(string, fn) {\n\t\tvar parts = string.split('@');\n\t\tvar result = '';\n\t\tif (parts.length > 1) {\n\t\t\t// In email addresses, only the domain name should be punycoded. Leave\n\t\t\t// the local part (i.e. everything up to `@`) intact.\n\t\t\tresult = parts[0] + '@';\n\t\t\tstring = parts[1];\n\t\t}\n\t\t// Avoid `split(regex)` for IE8 compatibility. See #17.\n\t\tstring = string.replace(regexSeparators, '\\x2E');\n\t\tvar labels = string.split('.');\n\t\tvar encoded = map(labels, fn).join('.');\n\t\treturn result + encoded;\n\t}\n\n\t/**\n\t * Creates an array containing the numeric code points of each Unicode\n\t * character in the string. While JavaScript uses UCS-2 internally,\n\t * this function will convert a pair of surrogate halves (each of which\n\t * UCS-2 exposes as separate characters) into a single code point,\n\t * matching UTF-16.\n\t * @see `punycode.ucs2.encode`\n\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t * @memberOf punycode.ucs2\n\t * @name decode\n\t * @param {String} string The Unicode input string (UCS-2).\n\t * @returns {Array} The new array of code points.\n\t */\n\tfunction ucs2decode(string) {\n\t\tvar output = [],\n\t\t counter = 0,\n\t\t length = string.length,\n\t\t value,\n\t\t extra;\n\t\twhile (counter < length) {\n\t\t\tvalue = string.charCodeAt(counter++);\n\t\t\tif (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n\t\t\t\t// high surrogate, and there is a next character\n\t\t\t\textra = string.charCodeAt(counter++);\n\t\t\t\tif ((extra & 0xFC00) == 0xDC00) { // low surrogate\n\t\t\t\t\toutput.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n\t\t\t\t} else {\n\t\t\t\t\t// unmatched surrogate; only append this code unit, in case the next\n\t\t\t\t\t// code unit is the high surrogate of a surrogate pair\n\t\t\t\t\toutput.push(value);\n\t\t\t\t\tcounter--;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\toutput.push(value);\n\t\t\t}\n\t\t}\n\t\treturn output;\n\t}\n\n\t/**\n\t * Creates a string based on an array of numeric code points.\n\t * @see `punycode.ucs2.decode`\n\t * @memberOf punycode.ucs2\n\t * @name encode\n\t * @param {Array} codePoints The array of numeric code points.\n\t * @returns {String} The new Unicode string (UCS-2).\n\t */\n\tfunction ucs2encode(array) {\n\t\treturn map(array, function(value) {\n\t\t\tvar output = '';\n\t\t\tif (value > 0xFFFF) {\n\t\t\t\tvalue -= 0x10000;\n\t\t\t\toutput += stringFromCharCode(value >>> 10 & 0x3FF | 0xD800);\n\t\t\t\tvalue = 0xDC00 | value & 0x3FF;\n\t\t\t}\n\t\t\toutput += stringFromCharCode(value);\n\t\t\treturn output;\n\t\t}).join('');\n\t}\n\n\t/**\n\t * Converts a basic code point into a digit/integer.\n\t * @see `digitToBasic()`\n\t * @private\n\t * @param {Number} codePoint The basic numeric code point value.\n\t * @returns {Number} The numeric value of a basic code point (for use in\n\t * representing integers) in the range `0` to `base - 1`, or `base` if\n\t * the code point does not represent a value.\n\t */\n\tfunction basicToDigit(codePoint) {\n\t\tif (codePoint - 48 < 10) {\n\t\t\treturn codePoint - 22;\n\t\t}\n\t\tif (codePoint - 65 < 26) {\n\t\t\treturn codePoint - 65;\n\t\t}\n\t\tif (codePoint - 97 < 26) {\n\t\t\treturn codePoint - 97;\n\t\t}\n\t\treturn base;\n\t}\n\n\t/**\n\t * Converts a digit/integer into a basic code point.\n\t * @see `basicToDigit()`\n\t * @private\n\t * @param {Number} digit The numeric value of a basic code point.\n\t * @returns {Number} The basic code point whose value (when used for\n\t * representing integers) is `digit`, which needs to be in the range\n\t * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is\n\t * used; else, the lowercase form is used. The behavior is undefined\n\t * if `flag` is non-zero and `digit` has no uppercase form.\n\t */\n\tfunction digitToBasic(digit, flag) {\n\t\t// 0..25 map to ASCII a..z or A..Z\n\t\t// 26..35 map to ASCII 0..9\n\t\treturn digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);\n\t}\n\n\t/**\n\t * Bias adaptation function as per section 3.4 of RFC 3492.\n\t * http://tools.ietf.org/html/rfc3492#section-3.4\n\t * @private\n\t */\n\tfunction adapt(delta, numPoints, firstTime) {\n\t\tvar k = 0;\n\t\tdelta = firstTime ? floor(delta / damp) : delta >> 1;\n\t\tdelta += floor(delta / numPoints);\n\t\tfor (/* no initialization */; delta > baseMinusTMin * tMax >> 1; k += base) {\n\t\t\tdelta = floor(delta / baseMinusTMin);\n\t\t}\n\t\treturn floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n\t}\n\n\t/**\n\t * Converts a Punycode string of ASCII-only symbols to a string of Unicode\n\t * symbols.\n\t * @memberOf punycode\n\t * @param {String} input The Punycode string of ASCII-only symbols.\n\t * @returns {String} The resulting string of Unicode symbols.\n\t */\n\tfunction decode(input) {\n\t\t// Don't use UCS-2\n\t\tvar output = [],\n\t\t inputLength = input.length,\n\t\t out,\n\t\t i = 0,\n\t\t n = initialN,\n\t\t bias = initialBias,\n\t\t basic,\n\t\t j,\n\t\t index,\n\t\t oldi,\n\t\t w,\n\t\t k,\n\t\t digit,\n\t\t t,\n\t\t /** Cached calculation results */\n\t\t baseMinusT;\n\n\t\t// Handle the basic code points: let `basic` be the number of input code\n\t\t// points before the last delimiter, or `0` if there is none, then copy\n\t\t// the first basic code points to the output.\n\n\t\tbasic = input.lastIndexOf(delimiter);\n\t\tif (basic < 0) {\n\t\t\tbasic = 0;\n\t\t}\n\n\t\tfor (j = 0; j < basic; ++j) {\n\t\t\t// if it's not a basic code point\n\t\t\tif (input.charCodeAt(j) >= 0x80) {\n\t\t\t\terror('not-basic');\n\t\t\t}\n\t\t\toutput.push(input.charCodeAt(j));\n\t\t}\n\n\t\t// Main decoding loop: start just after the last delimiter if any basic code\n\t\t// points were copied; start at the beginning otherwise.\n\n\t\tfor (index = basic > 0 ? basic + 1 : 0; index < inputLength; /* no final expression */) {\n\n\t\t\t// `index` is the index of the next character to be consumed.\n\t\t\t// Decode a generalized variable-length integer into `delta`,\n\t\t\t// which gets added to `i`. The overflow checking is easier\n\t\t\t// if we increase `i` as we go, then subtract off its starting\n\t\t\t// value at the end to obtain `delta`.\n\t\t\tfor (oldi = i, w = 1, k = base; /* no condition */; k += base) {\n\n\t\t\t\tif (index >= inputLength) {\n\t\t\t\t\terror('invalid-input');\n\t\t\t\t}\n\n\t\t\t\tdigit = basicToDigit(input.charCodeAt(index++));\n\n\t\t\t\tif (digit >= base || digit > floor((maxInt - i) / w)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\ti += digit * w;\n\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\n\t\t\t\tif (digit < t) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\n\t\t\t\tbaseMinusT = base - t;\n\t\t\t\tif (w > floor(maxInt / baseMinusT)) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tw *= baseMinusT;\n\n\t\t\t}\n\n\t\t\tout = output.length + 1;\n\t\t\tbias = adapt(i - oldi, out, oldi == 0);\n\n\t\t\t// `i` was supposed to wrap around from `out` to `0`,\n\t\t\t// incrementing `n` each time, so we'll fix that now:\n\t\t\tif (floor(i / out) > maxInt - n) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tn += floor(i / out);\n\t\t\ti %= out;\n\n\t\t\t// Insert `n` at position `i` of the output\n\t\t\toutput.splice(i++, 0, n);\n\n\t\t}\n\n\t\treturn ucs2encode(output);\n\t}\n\n\t/**\n\t * Converts a string of Unicode symbols (e.g. a domain name label) to a\n\t * Punycode string of ASCII-only symbols.\n\t * @memberOf punycode\n\t * @param {String} input The string of Unicode symbols.\n\t * @returns {String} The resulting Punycode string of ASCII-only symbols.\n\t */\n\tfunction encode(input) {\n\t\tvar n,\n\t\t delta,\n\t\t handledCPCount,\n\t\t basicLength,\n\t\t bias,\n\t\t j,\n\t\t m,\n\t\t q,\n\t\t k,\n\t\t t,\n\t\t currentValue,\n\t\t output = [],\n\t\t /** `inputLength` will hold the number of code points in `input`. */\n\t\t inputLength,\n\t\t /** Cached calculation results */\n\t\t handledCPCountPlusOne,\n\t\t baseMinusT,\n\t\t qMinusT;\n\n\t\t// Convert the input in UCS-2 to Unicode\n\t\tinput = ucs2decode(input);\n\n\t\t// Cache the length\n\t\tinputLength = input.length;\n\n\t\t// Initialize the state\n\t\tn = initialN;\n\t\tdelta = 0;\n\t\tbias = initialBias;\n\n\t\t// Handle the basic code points\n\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\tcurrentValue = input[j];\n\t\t\tif (currentValue < 0x80) {\n\t\t\t\toutput.push(stringFromCharCode(currentValue));\n\t\t\t}\n\t\t}\n\n\t\thandledCPCount = basicLength = output.length;\n\n\t\t// `handledCPCount` is the number of code points that have been handled;\n\t\t// `basicLength` is the number of basic code points.\n\n\t\t// Finish the basic string - if it is not empty - with a delimiter\n\t\tif (basicLength) {\n\t\t\toutput.push(delimiter);\n\t\t}\n\n\t\t// Main encoding loop:\n\t\twhile (handledCPCount < inputLength) {\n\n\t\t\t// All non-basic code points < n have been handled already. Find the next\n\t\t\t// larger one:\n\t\t\tfor (m = maxInt, j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\t\t\t\tif (currentValue >= n && currentValue < m) {\n\t\t\t\t\tm = currentValue;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>,\n\t\t\t// but guard against overflow\n\t\t\thandledCPCountPlusOne = handledCPCount + 1;\n\t\t\tif (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n\t\t\t\terror('overflow');\n\t\t\t}\n\n\t\t\tdelta += (m - n) * handledCPCountPlusOne;\n\t\t\tn = m;\n\n\t\t\tfor (j = 0; j < inputLength; ++j) {\n\t\t\t\tcurrentValue = input[j];\n\n\t\t\t\tif (currentValue < n && ++delta > maxInt) {\n\t\t\t\t\terror('overflow');\n\t\t\t\t}\n\n\t\t\t\tif (currentValue == n) {\n\t\t\t\t\t// Represent delta as a generalized variable-length integer\n\t\t\t\t\tfor (q = delta, k = base; /* no condition */; k += base) {\n\t\t\t\t\t\tt = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n\t\t\t\t\t\tif (q < t) {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tqMinusT = q - t;\n\t\t\t\t\t\tbaseMinusT = base - t;\n\t\t\t\t\t\toutput.push(\n\t\t\t\t\t\t\tstringFromCharCode(digitToBasic(t + qMinusT % baseMinusT, 0))\n\t\t\t\t\t\t);\n\t\t\t\t\t\tq = floor(qMinusT / baseMinusT);\n\t\t\t\t\t}\n\n\t\t\t\t\toutput.push(stringFromCharCode(digitToBasic(q, 0)));\n\t\t\t\t\tbias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n\t\t\t\t\tdelta = 0;\n\t\t\t\t\t++handledCPCount;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t++delta;\n\t\t\t++n;\n\n\t\t}\n\t\treturn output.join('');\n\t}\n\n\t/**\n\t * Converts a Punycode string representing a domain name or an email address\n\t * to Unicode. Only the Punycoded parts of the input will be converted, i.e.\n\t * it doesn't matter if you call it on a string that has already been\n\t * converted to Unicode.\n\t * @memberOf punycode\n\t * @param {String} input The Punycoded domain name or email address to\n\t * convert to Unicode.\n\t * @returns {String} The Unicode representation of the given Punycode\n\t * string.\n\t */\n\tfunction toUnicode(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexPunycode.test(string)\n\t\t\t\t? decode(string.slice(4).toLowerCase())\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/**\n\t * Converts a Unicode string representing a domain name or an email address to\n\t * Punycode. Only the non-ASCII parts of the domain name will be converted,\n\t * i.e. it doesn't matter if you call it with a domain that's already in\n\t * ASCII.\n\t * @memberOf punycode\n\t * @param {String} input The domain name or email address to convert, as a\n\t * Unicode string.\n\t * @returns {String} The Punycode representation of the given domain name or\n\t * email address.\n\t */\n\tfunction toASCII(input) {\n\t\treturn mapDomain(input, function(string) {\n\t\t\treturn regexNonASCII.test(string)\n\t\t\t\t? 'xn--' + encode(string)\n\t\t\t\t: string;\n\t\t});\n\t}\n\n\t/*--------------------------------------------------------------------------*/\n\n\t/** Define the public API */\n\tpunycode = {\n\t\t/**\n\t\t * A string representing the current Punycode.js version number.\n\t\t * @memberOf punycode\n\t\t * @type String\n\t\t */\n\t\t'version': '1.3.2',\n\t\t/**\n\t\t * An object of methods to convert from JavaScript's internal character\n\t\t * representation (UCS-2) to Unicode code points, and back.\n\t\t * @see <https://mathiasbynens.be/notes/javascript-encoding>\n\t\t * @memberOf punycode\n\t\t * @type Object\n\t\t */\n\t\t'ucs2': {\n\t\t\t'decode': ucs2decode,\n\t\t\t'encode': ucs2encode\n\t\t},\n\t\t'decode': decode,\n\t\t'encode': encode,\n\t\t'toASCII': toASCII,\n\t\t'toUnicode': toUnicode\n\t};\n\n\t/** Expose `punycode` */\n\t// Some AMD build optimizers, like r.js, check for specific condition patterns\n\t// like the following:\n\tif (\n\t\ttypeof define == 'function' &&\n\t\ttypeof define.amd == 'object' &&\n\t\tdefine.amd\n\t) {\n\t\tdefine('punycode', function() {\n\t\t\treturn punycode;\n\t\t});\n\t} else if (freeExports && freeModule) {\n\t\tif (module.exports == freeExports) { // in Node.js or RingoJS v0.8.0+\n\t\t\tfreeModule.exports = punycode;\n\t\t} else { // in Narwhal or RingoJS v0.7.0-\n\t\t\tfor (key in punycode) {\n\t\t\t\tpunycode.hasOwnProperty(key) && (freeExports[key] = punycode[key]);\n\t\t\t}\n\t\t}\n\t} else { // in Rhino or a web browser\n\t\troot.punycode = punycode;\n\t}\n\n}(this));\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar punycode = require('punycode');\nvar util = require('./util');\n\nexports.parse = urlParse;\nexports.resolve = urlResolve;\nexports.resolveObject = urlResolveObject;\nexports.format = urlFormat;\n\nexports.Url = Url;\n\nfunction Url() {\n this.protocol = null;\n this.slashes = null;\n this.auth = null;\n this.host = null;\n this.port = null;\n this.hostname = null;\n this.hash = null;\n this.search = null;\n this.query = null;\n this.pathname = null;\n this.path = null;\n this.href = null;\n}\n\n// Reference: RFC 3986, RFC 1808, RFC 2396\n\n// define these here so at least they only have to be\n// compiled once on the first module load.\nvar protocolPattern = /^([a-z0-9.+-]+:)/i,\n portPattern = /:[0-9]*$/,\n\n // Special case for a simple path URL\n simplePathPattern = /^(\\/\\/?(?!\\/)[^\\?\\s]*)(\\?[^\\s]*)?$/,\n\n // RFC 2396: characters reserved for delimiting URLs.\n // We actually just auto-escape these.\n delims = ['<', '>', '\"', '`', ' ', '\\r', '\\n', '\\t'],\n\n // RFC 2396: characters not allowed for various reasons.\n unwise = ['{', '}', '|', '\\\\', '^', '`'].concat(delims),\n\n // Allowed by RFCs, but cause of XSS attacks. Always escape these.\n autoEscape = ['\\''].concat(unwise),\n // Characters that are never ever allowed in a hostname.\n // Note that any invalid chars are also handled, but these\n // are the ones that are *expected* to be seen, so we fast-path\n // them.\n nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape),\n hostEndingChars = ['/', '?', '#'],\n hostnameMaxLen = 255,\n hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,\n hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,\n // protocols that can allow \"unsafe\" and \"unwise\" chars.\n unsafeProtocol = {\n 'javascript': true,\n 'javascript:': true\n },\n // protocols that never have a hostname.\n hostlessProtocol = {\n 'javascript': true,\n 'javascript:': true\n },\n // protocols that always contain a // bit.\n slashedProtocol = {\n 'http': true,\n 'https': true,\n 'ftp': true,\n 'gopher': true,\n 'file': true,\n 'http:': true,\n 'https:': true,\n 'ftp:': true,\n 'gopher:': true,\n 'file:': true\n },\n querystring = require('querystring');\n\nfunction urlParse(url, parseQueryString, slashesDenoteHost) {\n if (url && util.isObject(url) && url instanceof Url) return url;\n\n var u = new Url;\n u.parse(url, parseQueryString, slashesDenoteHost);\n return u;\n}\n\nUrl.prototype.parse = function(url, parseQueryString, slashesDenoteHost) {\n if (!util.isString(url)) {\n throw new TypeError(\"Parameter 'url' must be a string, not \" + typeof url);\n }\n\n // Copy chrome, IE, opera backslash-handling behavior.\n // Back slashes before the query string get converted to forward slashes\n // See: https://code.google.com/p/chromium/issues/detail?id=25916\n var queryIndex = url.indexOf('?'),\n splitter =\n (queryIndex !== -1 && queryIndex < url.indexOf('#')) ? '?' : '#',\n uSplit = url.split(splitter),\n slashRegex = /\\\\/g;\n uSplit[0] = uSplit[0].replace(slashRegex, '/');\n url = uSplit.join(splitter);\n\n var rest = url;\n\n // trim before proceeding.\n // This is to support parse stuff like \" http://foo.com \\n\"\n rest = rest.trim();\n\n if (!slashesDenoteHost && url.split('#').length === 1) {\n // Try fast path regexp\n var simplePath = simplePathPattern.exec(rest);\n if (simplePath) {\n this.path = rest;\n this.href = rest;\n this.pathname = simplePath[1];\n if (simplePath[2]) {\n this.search = simplePath[2];\n if (parseQueryString) {\n this.query = querystring.parse(this.search.substr(1));\n } else {\n this.query = this.search.substr(1);\n }\n } else if (parseQueryString) {\n this.search = '';\n this.query = {};\n }\n return this;\n }\n }\n\n var proto = protocolPattern.exec(rest);\n if (proto) {\n proto = proto[0];\n var lowerProto = proto.toLowerCase();\n this.protocol = lowerProto;\n rest = rest.substr(proto.length);\n }\n\n // figure out if it's got a host\n // user@server is *always* interpreted as a hostname, and url\n // resolution will treat //foo/bar as host=foo,path=bar because that's\n // how the browser resolves relative URLs.\n if (slashesDenoteHost || proto || rest.match(/^\\/\\/[^@\\/]+@[^@\\/]+/)) {\n var slashes = rest.substr(0, 2) === '//';\n if (slashes && !(proto && hostlessProtocol[proto])) {\n rest = rest.substr(2);\n this.slashes = true;\n }\n }\n\n if (!hostlessProtocol[proto] &&\n (slashes || (proto && !slashedProtocol[proto]))) {\n\n // there's a hostname.\n // the first instance of /, ?, ;, or # ends the host.\n //\n // If there is an @ in the hostname, then non-host chars *are* allowed\n // to the left of the last @ sign, unless some host-ending character\n // comes *before* the @-sign.\n // URLs are obnoxious.\n //\n // ex:\n // http://a@b@c/ => user:a@b host:c\n // http://a@b?@c => user:a host:c path:/?@c\n\n // v0.12 TODO(isaacs): This is not quite how Chrome does things.\n // Review our test case against browsers more comprehensively.\n\n // find the first instance of any hostEndingChars\n var hostEnd = -1;\n for (var i = 0; i < hostEndingChars.length; i++) {\n var hec = rest.indexOf(hostEndingChars[i]);\n if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n hostEnd = hec;\n }\n\n // at this point, either we have an explicit point where the\n // auth portion cannot go past, or the last @ char is the decider.\n var auth, atSign;\n if (hostEnd === -1) {\n // atSign can be anywhere.\n atSign = rest.lastIndexOf('@');\n } else {\n // atSign must be in auth portion.\n // http://a@b/c@d => host:b auth:a path:/c@d\n atSign = rest.lastIndexOf('@', hostEnd);\n }\n\n // Now we have a portion which is definitely the auth.\n // Pull that off.\n if (atSign !== -1) {\n auth = rest.slice(0, atSign);\n rest = rest.slice(atSign + 1);\n this.auth = decodeURIComponent(auth);\n }\n\n // the host is the remaining to the left of the first non-host char\n hostEnd = -1;\n for (var i = 0; i < nonHostChars.length; i++) {\n var hec = rest.indexOf(nonHostChars[i]);\n if (hec !== -1 && (hostEnd === -1 || hec < hostEnd))\n hostEnd = hec;\n }\n // if we still have not hit it, then the entire thing is a host.\n if (hostEnd === -1)\n hostEnd = rest.length;\n\n this.host = rest.slice(0, hostEnd);\n rest = rest.slice(hostEnd);\n\n // pull out port.\n this.parseHost();\n\n // we've indicated that there is a hostname,\n // so even if it's empty, it has to be present.\n this.hostname = this.hostname || '';\n\n // if hostname begins with [ and ends with ]\n // assume that it's an IPv6 address.\n var ipv6Hostname = this.hostname[0] === '[' &&\n this.hostname[this.hostname.length - 1] === ']';\n\n // validate a little.\n if (!ipv6Hostname) {\n var hostparts = this.hostname.split(/\\./);\n for (var i = 0, l = hostparts.length; i < l; i++) {\n var part = hostparts[i];\n if (!part) continue;\n if (!part.match(hostnamePartPattern)) {\n var newpart = '';\n for (var j = 0, k = part.length; j < k; j++) {\n if (part.charCodeAt(j) > 127) {\n // we replace non-ASCII char with a temporary placeholder\n // we need this to make sure size of hostname is not\n // broken by replacing non-ASCII by nothing\n newpart += 'x';\n } else {\n newpart += part[j];\n }\n }\n // we test again with ASCII char only\n if (!newpart.match(hostnamePartPattern)) {\n var validParts = hostparts.slice(0, i);\n var notHost = hostparts.slice(i + 1);\n var bit = part.match(hostnamePartStart);\n if (bit) {\n validParts.push(bit[1]);\n notHost.unshift(bit[2]);\n }\n if (notHost.length) {\n rest = '/' + notHost.join('.') + rest;\n }\n this.hostname = validParts.join('.');\n break;\n }\n }\n }\n }\n\n if (this.hostname.length > hostnameMaxLen) {\n this.hostname = '';\n } else {\n // hostnames are always lower case.\n this.hostname = this.hostname.toLowerCase();\n }\n\n if (!ipv6Hostname) {\n // IDNA Support: Returns a punycoded representation of \"domain\".\n // It only converts parts of the domain name that\n // have non-ASCII characters, i.e. it doesn't matter if\n // you call it with a domain that already is ASCII-only.\n this.hostname = punycode.toASCII(this.hostname);\n }\n\n var p = this.port ? ':' + this.port : '';\n var h = this.hostname || '';\n this.host = h + p;\n this.href += this.host;\n\n // strip [ and ] from the hostname\n // the host field still retains them, though\n if (ipv6Hostname) {\n this.hostname = this.hostname.substr(1, this.hostname.length - 2);\n if (rest[0] !== '/') {\n rest = '/' + rest;\n }\n }\n }\n\n // now rest is set to the post-host stuff.\n // chop off any delim chars.\n if (!unsafeProtocol[lowerProto]) {\n\n // First, make 100% sure that any \"autoEscape\" chars get\n // escaped, even if encodeURIComponent doesn't think they\n // need to be.\n for (var i = 0, l = autoEscape.length; i < l; i++) {\n var ae = autoEscape[i];\n if (rest.indexOf(ae) === -1)\n continue;\n var esc = encodeURIComponent(ae);\n if (esc === ae) {\n esc = escape(ae);\n }\n rest = rest.split(ae).join(esc);\n }\n }\n\n\n // chop off from the tail first.\n var hash = rest.indexOf('#');\n if (hash !== -1) {\n // got a fragment string.\n this.hash = rest.substr(hash);\n rest = rest.slice(0, hash);\n }\n var qm = rest.indexOf('?');\n if (qm !== -1) {\n this.search = rest.substr(qm);\n this.query = rest.substr(qm + 1);\n if (parseQueryString) {\n this.query = querystring.parse(this.query);\n }\n rest = rest.slice(0, qm);\n } else if (parseQueryString) {\n // no query string, but parseQueryString still requested\n this.search = '';\n this.query = {};\n }\n if (rest) this.pathname = rest;\n if (slashedProtocol[lowerProto] &&\n this.hostname && !this.pathname) {\n this.pathname = '/';\n }\n\n //to support http.request\n if (this.pathname || this.search) {\n var p = this.pathname || '';\n var s = this.search || '';\n this.path = p + s;\n }\n\n // finally, reconstruct the href based on what has been validated.\n this.href = this.format();\n return this;\n};\n\n// format a parsed object into a url string\nfunction urlFormat(obj) {\n // ensure it's an object, and not a string url.\n // If it's an obj, this is a no-op.\n // this way, you can call url_format() on strings\n // to clean up potentially wonky urls.\n if (util.isString(obj)) obj = urlParse(obj);\n if (!(obj instanceof Url)) return Url.prototype.format.call(obj);\n return obj.format();\n}\n\nUrl.prototype.format = function() {\n var auth = this.auth || '';\n if (auth) {\n auth = encodeURIComponent(auth);\n auth = auth.replace(/%3A/i, ':');\n auth += '@';\n }\n\n var protocol = this.protocol || '',\n pathname = this.pathname || '',\n hash = this.hash || '',\n host = false,\n query = '';\n\n if (this.host) {\n host = auth + this.host;\n } else if (this.hostname) {\n host = auth + (this.hostname.indexOf(':') === -1 ?\n this.hostname :\n '[' + this.hostname + ']');\n if (this.port) {\n host += ':' + this.port;\n }\n }\n\n if (this.query &&\n util.isObject(this.query) &&\n Object.keys(this.query).length) {\n query = querystring.stringify(this.query);\n }\n\n var search = this.search || (query && ('?' + query)) || '';\n\n if (protocol && protocol.substr(-1) !== ':') protocol += ':';\n\n // only the slashedProtocols get the //. Not mailto:, xmpp:, etc.\n // unless they had them to begin with.\n if (this.slashes ||\n (!protocol || slashedProtocol[protocol]) && host !== false) {\n host = '//' + (host || '');\n if (pathname && pathname.charAt(0) !== '/') pathname = '/' + pathname;\n } else if (!host) {\n host = '';\n }\n\n if (hash && hash.charAt(0) !== '#') hash = '#' + hash;\n if (search && search.charAt(0) !== '?') search = '?' + search;\n\n pathname = pathname.replace(/[?#]/g, function(match) {\n return encodeURIComponent(match);\n });\n search = search.replace('#', '%23');\n\n return protocol + host + pathname + search + hash;\n};\n\nfunction urlResolve(source, relative) {\n return urlParse(source, false, true).resolve(relative);\n}\n\nUrl.prototype.resolve = function(relative) {\n return this.resolveObject(urlParse(relative, false, true)).format();\n};\n\nfunction urlResolveObject(source, relative) {\n if (!source) return relative;\n return urlParse(source, false, true).resolveObject(relative);\n}\n\nUrl.prototype.resolveObject = function(relative) {\n if (util.isString(relative)) {\n var rel = new Url();\n rel.parse(relative, false, true);\n relative = rel;\n }\n\n var result = new Url();\n var tkeys = Object.keys(this);\n for (var tk = 0; tk < tkeys.length; tk++) {\n var tkey = tkeys[tk];\n result[tkey] = this[tkey];\n }\n\n // hash is always overridden, no matter what.\n // even href=\"\" will remove it.\n result.hash = relative.hash;\n\n // if the relative url is empty, then there's nothing left to do here.\n if (relative.href === '') {\n result.href = result.format();\n return result;\n }\n\n // hrefs like //foo/bar always cut to the protocol.\n if (relative.slashes && !relative.protocol) {\n // take everything except the protocol from relative\n var rkeys = Object.keys(relative);\n for (var rk = 0; rk < rkeys.length; rk++) {\n var rkey = rkeys[rk];\n if (rkey !== 'protocol')\n result[rkey] = relative[rkey];\n }\n\n //urlParse appends trailing / to urls like http://www.example.com\n if (slashedProtocol[result.protocol] &&\n result.hostname && !result.pathname) {\n result.path = result.pathname = '/';\n }\n\n result.href = result.format();\n return result;\n }\n\n if (relative.protocol && relative.protocol !== result.protocol) {\n // if it's a known url protocol, then changing\n // the protocol does weird things\n // first, if it's not file:, then we MUST have a host,\n // and if there was a path\n // to begin with, then we MUST have a path.\n // if it is file:, then the host is dropped,\n // because that's known to be hostless.\n // anything else is assumed to be absolute.\n if (!slashedProtocol[relative.protocol]) {\n var keys = Object.keys(relative);\n for (var v = 0; v < keys.length; v++) {\n var k = keys[v];\n result[k] = relative[k];\n }\n result.href = result.format();\n return result;\n }\n\n result.protocol = relative.protocol;\n if (!relative.host && !hostlessProtocol[relative.protocol]) {\n var relPath = (relative.pathname || '').split('/');\n while (relPath.length && !(relative.host = relPath.shift()));\n if (!relative.host) relative.host = '';\n if (!relative.hostname) relative.hostname = '';\n if (relPath[0] !== '') relPath.unshift('');\n if (relPath.length < 2) relPath.unshift('');\n result.pathname = relPath.join('/');\n } else {\n result.pathname = relative.pathname;\n }\n result.search = relative.search;\n result.query = relative.query;\n result.host = relative.host || '';\n result.auth = relative.auth;\n result.hostname = relative.hostname || relative.host;\n result.port = relative.port;\n // to support http.request\n if (result.pathname || result.search) {\n var p = result.pathname || '';\n var s = result.search || '';\n result.path = p + s;\n }\n result.slashes = result.slashes || relative.slashes;\n result.href = result.format();\n return result;\n }\n\n var isSourceAbs = (result.pathname && result.pathname.charAt(0) === '/'),\n isRelAbs = (\n relative.host ||\n relative.pathname && relative.pathname.charAt(0) === '/'\n ),\n mustEndAbs = (isRelAbs || isSourceAbs ||\n (result.host && relative.pathname)),\n removeAllDots = mustEndAbs,\n srcPath = result.pathname && result.pathname.split('/') || [],\n relPath = relative.pathname && relative.pathname.split('/') || [],\n psychotic = result.protocol && !slashedProtocol[result.protocol];\n\n // if the url is a non-slashed url, then relative\n // links like ../.. should be able\n // to crawl up to the hostname, as well. This is strange.\n // result.protocol has already been set by now.\n // Later on, put the first path part into the host field.\n if (psychotic) {\n result.hostname = '';\n result.port = null;\n if (result.host) {\n if (srcPath[0] === '') srcPath[0] = result.host;\n else srcPath.unshift(result.host);\n }\n result.host = '';\n if (relative.protocol) {\n relative.hostname = null;\n relative.port = null;\n if (relative.host) {\n if (relPath[0] === '') relPath[0] = relative.host;\n else relPath.unshift(relative.host);\n }\n relative.host = null;\n }\n mustEndAbs = mustEndAbs && (relPath[0] === '' || srcPath[0] === '');\n }\n\n if (isRelAbs) {\n // it's absolute.\n result.host = (relative.host || relative.host === '') ?\n relative.host : result.host;\n result.hostname = (relative.hostname || relative.hostname === '') ?\n relative.hostname : result.hostname;\n result.search = relative.search;\n result.query = relative.query;\n srcPath = relPath;\n // fall through to the dot-handling below.\n } else if (relPath.length) {\n // it's relative\n // throw away the existing file, and take the new path instead.\n if (!srcPath) srcPath = [];\n srcPath.pop();\n srcPath = srcPath.concat(relPath);\n result.search = relative.search;\n result.query = relative.query;\n } else if (!util.isNullOrUndefined(relative.search)) {\n // just pull out the search.\n // like href='?foo'.\n // Put this after the other two cases because it simplifies the booleans\n if (psychotic) {\n result.hostname = result.host = srcPath.shift();\n //occationaly the auth can get stuck only in host\n //this especially happens in cases like\n //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n var authInHost = result.host && result.host.indexOf('@') > 0 ?\n result.host.split('@') : false;\n if (authInHost) {\n result.auth = authInHost.shift();\n result.host = result.hostname = authInHost.shift();\n }\n }\n result.search = relative.search;\n result.query = relative.query;\n //to support http.request\n if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n result.path = (result.pathname ? result.pathname : '') +\n (result.search ? result.search : '');\n }\n result.href = result.format();\n return result;\n }\n\n if (!srcPath.length) {\n // no path at all. easy.\n // we've already handled the other stuff above.\n result.pathname = null;\n //to support http.request\n if (result.search) {\n result.path = '/' + result.search;\n } else {\n result.path = null;\n }\n result.href = result.format();\n return result;\n }\n\n // if a url ENDs in . or .., then it must get a trailing slash.\n // however, if it ends in anything else non-slashy,\n // then it must NOT get a trailing slash.\n var last = srcPath.slice(-1)[0];\n var hasTrailingSlash = (\n (result.host || relative.host || srcPath.length > 1) &&\n (last === '.' || last === '..') || last === '');\n\n // strip single dots, resolve double dots to parent dir\n // if the path tries to go above the root, `up` ends up > 0\n var up = 0;\n for (var i = srcPath.length; i >= 0; i--) {\n last = srcPath[i];\n if (last === '.') {\n srcPath.splice(i, 1);\n } else if (last === '..') {\n srcPath.splice(i, 1);\n up++;\n } else if (up) {\n srcPath.splice(i, 1);\n up--;\n }\n }\n\n // if the path is allowed to go above the root, restore leading ..s\n if (!mustEndAbs && !removeAllDots) {\n for (; up--; up) {\n srcPath.unshift('..');\n }\n }\n\n if (mustEndAbs && srcPath[0] !== '' &&\n (!srcPath[0] || srcPath[0].charAt(0) !== '/')) {\n srcPath.unshift('');\n }\n\n if (hasTrailingSlash && (srcPath.join('/').substr(-1) !== '/')) {\n srcPath.push('');\n }\n\n var isAbsolute = srcPath[0] === '' ||\n (srcPath[0] && srcPath[0].charAt(0) === '/');\n\n // put the host back\n if (psychotic) {\n result.hostname = result.host = isAbsolute ? '' :\n srcPath.length ? srcPath.shift() : '';\n //occationaly the auth can get stuck only in host\n //this especially happens in cases like\n //url.resolveObject('mailto:local1@domain1', 'local2@domain2')\n var authInHost = result.host && result.host.indexOf('@') > 0 ?\n result.host.split('@') : false;\n if (authInHost) {\n result.auth = authInHost.shift();\n result.host = result.hostname = authInHost.shift();\n }\n }\n\n mustEndAbs = mustEndAbs || (result.host && srcPath.length);\n\n if (mustEndAbs && !isAbsolute) {\n srcPath.unshift('');\n }\n\n if (!srcPath.length) {\n result.pathname = null;\n result.path = null;\n } else {\n result.pathname = srcPath.join('/');\n }\n\n //to support request.http\n if (!util.isNull(result.pathname) || !util.isNull(result.search)) {\n result.path = (result.pathname ? result.pathname : '') +\n (result.search ? result.search : '');\n }\n result.auth = relative.auth || result.auth;\n result.slashes = result.slashes || relative.slashes;\n result.href = result.format();\n return result;\n};\n\nUrl.prototype.parseHost = function() {\n var host = this.host;\n var port = portPattern.exec(host);\n if (port) {\n port = port[0];\n if (port !== ':') {\n this.port = port.substr(1);\n }\n host = host.substr(0, host.length - port.length);\n }\n if (host) this.hostname = host;\n};\n","'use strict';\n\nmodule.exports = {\n isString: function(arg) {\n return typeof(arg) === 'string';\n },\n isObject: function(arg) {\n return typeof(arg) === 'object' && arg !== null;\n },\n isNull: function(arg) {\n return arg === null;\n },\n isNullOrUndefined: function(arg) {\n return arg == null;\n }\n};\n","\n/**\n * Module exports.\n */\n\nmodule.exports = deprecate;\n\n/**\n * Mark that a method should not be used.\n * Returns a modified function which warns once by default.\n *\n * If `localStorage.noDeprecation = true` is set, then it is a no-op.\n *\n * If `localStorage.throwDeprecation = true` is set, then deprecated functions\n * will throw an Error when invoked.\n *\n * If `localStorage.traceDeprecation = true` is set, then deprecated functions\n * will invoke `console.trace()` instead of `console.error()`.\n *\n * @param {Function} fn - the function to deprecate\n * @param {String} msg - the string to print to the console when `fn` is invoked\n * @returns {Function} a new \"deprecated\" version of `fn`\n * @api public\n */\n\nfunction deprecate (fn, msg) {\n if (config('noDeprecation')) {\n return fn;\n }\n\n var warned = false;\n function deprecated() {\n if (!warned) {\n if (config('throwDeprecation')) {\n throw new Error(msg);\n } else if (config('traceDeprecation')) {\n console.trace(msg);\n } else {\n console.warn(msg);\n }\n warned = true;\n }\n return fn.apply(this, arguments);\n }\n\n return deprecated;\n}\n\n/**\n * Checks `localStorage` for boolean values for the given `name`.\n *\n * @param {String} name\n * @returns {Boolean}\n * @api private\n */\n\nfunction config (name) {\n // accessing global.localStorage can trigger a DOMException in sandboxed iframes\n try {\n if (!global.localStorage) return false;\n } catch (_) {\n return false;\n }\n var val = global.localStorage[name];\n if (null == val) return false;\n return String(val).toLowerCase() === 'true';\n}\n","module.exports = function isBuffer(arg) {\n return arg && typeof arg === 'object'\n && typeof arg.copy === 'function'\n && typeof arg.fill === 'function'\n && typeof arg.readUInt8 === 'function';\n}","// Currently in sync with Node.js lib/internal/util/types.js\n// https://github.com/nodejs/node/commit/112cc7c27551254aa2b17098fb774867f05ed0d9\n\n'use strict';\n\nvar isArgumentsObject = require('is-arguments');\nvar isGeneratorFunction = require('is-generator-function');\nvar whichTypedArray = require('which-typed-array');\nvar isTypedArray = require('is-typed-array');\n\nfunction uncurryThis(f) {\n return f.call.bind(f);\n}\n\nvar BigIntSupported = typeof BigInt !== 'undefined';\nvar SymbolSupported = typeof Symbol !== 'undefined';\n\nvar ObjectToString = uncurryThis(Object.prototype.toString);\n\nvar numberValue = uncurryThis(Number.prototype.valueOf);\nvar stringValue = uncurryThis(String.prototype.valueOf);\nvar booleanValue = uncurryThis(Boolean.prototype.valueOf);\n\nif (BigIntSupported) {\n var bigIntValue = uncurryThis(BigInt.prototype.valueOf);\n}\n\nif (SymbolSupported) {\n var symbolValue = uncurryThis(Symbol.prototype.valueOf);\n}\n\nfunction checkBoxedPrimitive(value, prototypeValueOf) {\n if (typeof value !== 'object') {\n return false;\n }\n try {\n prototypeValueOf(value);\n return true;\n } catch(e) {\n return false;\n }\n}\n\nexports.isArgumentsObject = isArgumentsObject;\nexports.isGeneratorFunction = isGeneratorFunction;\nexports.isTypedArray = isTypedArray;\n\n// Taken from here and modified for better browser support\n// https://github.com/sindresorhus/p-is-promise/blob/cda35a513bda03f977ad5cde3a079d237e82d7ef/index.js\nfunction isPromise(input) {\n\treturn (\n\t\t(\n\t\t\ttypeof Promise !== 'undefined' &&\n\t\t\tinput instanceof Promise\n\t\t) ||\n\t\t(\n\t\t\tinput !== null &&\n\t\t\ttypeof input === 'object' &&\n\t\t\ttypeof input.then === 'function' &&\n\t\t\ttypeof input.catch === 'function'\n\t\t)\n\t);\n}\nexports.isPromise = isPromise;\n\nfunction isArrayBufferView(value) {\n if (typeof ArrayBuffer !== 'undefined' && ArrayBuffer.isView) {\n return ArrayBuffer.isView(value);\n }\n\n return (\n isTypedArray(value) ||\n isDataView(value)\n );\n}\nexports.isArrayBufferView = isArrayBufferView;\n\n\nfunction isUint8Array(value) {\n return whichTypedArray(value) === 'Uint8Array';\n}\nexports.isUint8Array = isUint8Array;\n\nfunction isUint8ClampedArray(value) {\n return whichTypedArray(value) === 'Uint8ClampedArray';\n}\nexports.isUint8ClampedArray = isUint8ClampedArray;\n\nfunction isUint16Array(value) {\n return whichTypedArray(value) === 'Uint16Array';\n}\nexports.isUint16Array = isUint16Array;\n\nfunction isUint32Array(value) {\n return whichTypedArray(value) === 'Uint32Array';\n}\nexports.isUint32Array = isUint32Array;\n\nfunction isInt8Array(value) {\n return whichTypedArray(value) === 'Int8Array';\n}\nexports.isInt8Array = isInt8Array;\n\nfunction isInt16Array(value) {\n return whichTypedArray(value) === 'Int16Array';\n}\nexports.isInt16Array = isInt16Array;\n\nfunction isInt32Array(value) {\n return whichTypedArray(value) === 'Int32Array';\n}\nexports.isInt32Array = isInt32Array;\n\nfunction isFloat32Array(value) {\n return whichTypedArray(value) === 'Float32Array';\n}\nexports.isFloat32Array = isFloat32Array;\n\nfunction isFloat64Array(value) {\n return whichTypedArray(value) === 'Float64Array';\n}\nexports.isFloat64Array = isFloat64Array;\n\nfunction isBigInt64Array(value) {\n return whichTypedArray(value) === 'BigInt64Array';\n}\nexports.isBigInt64Array = isBigInt64Array;\n\nfunction isBigUint64Array(value) {\n return whichTypedArray(value) === 'BigUint64Array';\n}\nexports.isBigUint64Array = isBigUint64Array;\n\nfunction isMapToString(value) {\n return ObjectToString(value) === '[object Map]';\n}\nisMapToString.working = (\n typeof Map !== 'undefined' &&\n isMapToString(new Map())\n);\n\nfunction isMap(value) {\n if (typeof Map === 'undefined') {\n return false;\n }\n\n return isMapToString.working\n ? isMapToString(value)\n : value instanceof Map;\n}\nexports.isMap = isMap;\n\nfunction isSetToString(value) {\n return ObjectToString(value) === '[object Set]';\n}\nisSetToString.working = (\n typeof Set !== 'undefined' &&\n isSetToString(new Set())\n);\nfunction isSet(value) {\n if (typeof Set === 'undefined') {\n return false;\n }\n\n return isSetToString.working\n ? isSetToString(value)\n : value instanceof Set;\n}\nexports.isSet = isSet;\n\nfunction isWeakMapToString(value) {\n return ObjectToString(value) === '[object WeakMap]';\n}\nisWeakMapToString.working = (\n typeof WeakMap !== 'undefined' &&\n isWeakMapToString(new WeakMap())\n);\nfunction isWeakMap(value) {\n if (typeof WeakMap === 'undefined') {\n return false;\n }\n\n return isWeakMapToString.working\n ? isWeakMapToString(value)\n : value instanceof WeakMap;\n}\nexports.isWeakMap = isWeakMap;\n\nfunction isWeakSetToString(value) {\n return ObjectToString(value) === '[object WeakSet]';\n}\nisWeakSetToString.working = (\n typeof WeakSet !== 'undefined' &&\n isWeakSetToString(new WeakSet())\n);\nfunction isWeakSet(value) {\n return isWeakSetToString(value);\n}\nexports.isWeakSet = isWeakSet;\n\nfunction isArrayBufferToString(value) {\n return ObjectToString(value) === '[object ArrayBuffer]';\n}\nisArrayBufferToString.working = (\n typeof ArrayBuffer !== 'undefined' &&\n isArrayBufferToString(new ArrayBuffer())\n);\nfunction isArrayBuffer(value) {\n if (typeof ArrayBuffer === 'undefined') {\n return false;\n }\n\n return isArrayBufferToString.working\n ? isArrayBufferToString(value)\n : value instanceof ArrayBuffer;\n}\nexports.isArrayBuffer = isArrayBuffer;\n\nfunction isDataViewToString(value) {\n return ObjectToString(value) === '[object DataView]';\n}\nisDataViewToString.working = (\n typeof ArrayBuffer !== 'undefined' &&\n typeof DataView !== 'undefined' &&\n isDataViewToString(new DataView(new ArrayBuffer(1), 0, 1))\n);\nfunction isDataView(value) {\n if (typeof DataView === 'undefined') {\n return false;\n }\n\n return isDataViewToString.working\n ? isDataViewToString(value)\n : value instanceof DataView;\n}\nexports.isDataView = isDataView;\n\n// Store a copy of SharedArrayBuffer in case it's deleted elsewhere\nvar SharedArrayBufferCopy = typeof SharedArrayBuffer !== 'undefined' ? SharedArrayBuffer : undefined;\nfunction isSharedArrayBufferToString(value) {\n return ObjectToString(value) === '[object SharedArrayBuffer]';\n}\nfunction isSharedArrayBuffer(value) {\n if (typeof SharedArrayBufferCopy === 'undefined') {\n return false;\n }\n\n if (typeof isSharedArrayBufferToString.working === 'undefined') {\n isSharedArrayBufferToString.working = isSharedArrayBufferToString(new SharedArrayBufferCopy());\n }\n\n return isSharedArrayBufferToString.working\n ? isSharedArrayBufferToString(value)\n : value instanceof SharedArrayBufferCopy;\n}\nexports.isSharedArrayBuffer = isSharedArrayBuffer;\n\nfunction isAsyncFunction(value) {\n return ObjectToString(value) === '[object AsyncFunction]';\n}\nexports.isAsyncFunction = isAsyncFunction;\n\nfunction isMapIterator(value) {\n return ObjectToString(value) === '[object Map Iterator]';\n}\nexports.isMapIterator = isMapIterator;\n\nfunction isSetIterator(value) {\n return ObjectToString(value) === '[object Set Iterator]';\n}\nexports.isSetIterator = isSetIterator;\n\nfunction isGeneratorObject(value) {\n return ObjectToString(value) === '[object Generator]';\n}\nexports.isGeneratorObject = isGeneratorObject;\n\nfunction isWebAssemblyCompiledModule(value) {\n return ObjectToString(value) === '[object WebAssembly.Module]';\n}\nexports.isWebAssemblyCompiledModule = isWebAssemblyCompiledModule;\n\nfunction isNumberObject(value) {\n return checkBoxedPrimitive(value, numberValue);\n}\nexports.isNumberObject = isNumberObject;\n\nfunction isStringObject(value) {\n return checkBoxedPrimitive(value, stringValue);\n}\nexports.isStringObject = isStringObject;\n\nfunction isBooleanObject(value) {\n return checkBoxedPrimitive(value, booleanValue);\n}\nexports.isBooleanObject = isBooleanObject;\n\nfunction isBigIntObject(value) {\n return BigIntSupported && checkBoxedPrimitive(value, bigIntValue);\n}\nexports.isBigIntObject = isBigIntObject;\n\nfunction isSymbolObject(value) {\n return SymbolSupported && checkBoxedPrimitive(value, symbolValue);\n}\nexports.isSymbolObject = isSymbolObject;\n\nfunction isBoxedPrimitive(value) {\n return (\n isNumberObject(value) ||\n isStringObject(value) ||\n isBooleanObject(value) ||\n isBigIntObject(value) ||\n isSymbolObject(value)\n );\n}\nexports.isBoxedPrimitive = isBoxedPrimitive;\n\nfunction isAnyArrayBuffer(value) {\n return typeof Uint8Array !== 'undefined' && (\n isArrayBuffer(value) ||\n isSharedArrayBuffer(value)\n );\n}\nexports.isAnyArrayBuffer = isAnyArrayBuffer;\n\n['isProxy', 'isExternal', 'isModuleNamespaceObject'].forEach(function(method) {\n Object.defineProperty(exports, method, {\n enumerable: false,\n value: function() {\n throw new Error(method + ' is not supported in userland');\n }\n });\n});\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors ||\n function getOwnPropertyDescriptors(obj) {\n var keys = Object.keys(obj);\n var descriptors = {};\n for (var i = 0; i < keys.length; i++) {\n descriptors[keys[i]] = Object.getOwnPropertyDescriptor(obj, keys[i]);\n }\n return descriptors;\n };\n\nvar formatRegExp = /%[sdj%]/g;\nexports.format = function(f) {\n if (!isString(f)) {\n var objects = [];\n for (var i = 0; i < arguments.length; i++) {\n objects.push(inspect(arguments[i]));\n }\n return objects.join(' ');\n }\n\n var i = 1;\n var args = arguments;\n var len = args.length;\n var str = String(f).replace(formatRegExp, function(x) {\n if (x === '%%') return '%';\n if (i >= len) return x;\n switch (x) {\n case '%s': return String(args[i++]);\n case '%d': return Number(args[i++]);\n case '%j':\n try {\n return JSON.stringify(args[i++]);\n } catch (_) {\n return '[Circular]';\n }\n default:\n return x;\n }\n });\n for (var x = args[i]; i < len; x = args[++i]) {\n if (isNull(x) || !isObject(x)) {\n str += ' ' + x;\n } else {\n str += ' ' + inspect(x);\n }\n }\n return str;\n};\n\n\n// Mark that a method should not be used.\n// Returns a modified function which warns once by default.\n// If --no-deprecation is set, then it is a no-op.\nexports.deprecate = function(fn, msg) {\n if (typeof process !== 'undefined' && process.noDeprecation === true) {\n return fn;\n }\n\n // Allow for deprecating things in the process of starting up.\n if (typeof process === 'undefined') {\n return function() {\n return exports.deprecate(fn, msg).apply(this, arguments);\n };\n }\n\n var warned = false;\n function deprecated() {\n if (!warned) {\n if (process.throwDeprecation) {\n throw new Error(msg);\n } else if (process.traceDeprecation) {\n console.trace(msg);\n } else {\n console.error(msg);\n }\n warned = true;\n }\n return fn.apply(this, arguments);\n }\n\n return deprecated;\n};\n\n\nvar debugs = {};\nvar debugEnvRegex = /^$/;\n\nif (process.env.NODE_DEBUG) {\n var debugEnv = process.env.NODE_DEBUG;\n debugEnv = debugEnv.replace(/[|\\\\{}()[\\]^$+?.]/g, '\\\\$&')\n .replace(/\\*/g, '.*')\n .replace(/,/g, '$|^')\n .toUpperCase();\n debugEnvRegex = new RegExp('^' + debugEnv + '$', 'i');\n}\nexports.debuglog = function(set) {\n set = set.toUpperCase();\n if (!debugs[set]) {\n if (debugEnvRegex.test(set)) {\n var pid = process.pid;\n debugs[set] = function() {\n var msg = exports.format.apply(exports, arguments);\n console.error('%s %d: %s', set, pid, msg);\n };\n } else {\n debugs[set] = function() {};\n }\n }\n return debugs[set];\n};\n\n\n/**\n * Echos the value of a value. Trys to print the value out\n * in the best way possible given the different types.\n *\n * @param {Object} obj The object to print out.\n * @param {Object} opts Optional options object that alters the output.\n */\n/* legacy: obj, showHidden, depth, colors*/\nfunction inspect(obj, opts) {\n // default options\n var ctx = {\n seen: [],\n stylize: stylizeNoColor\n };\n // legacy...\n if (arguments.length >= 3) ctx.depth = arguments[2];\n if (arguments.length >= 4) ctx.colors = arguments[3];\n if (isBoolean(opts)) {\n // legacy...\n ctx.showHidden = opts;\n } else if (opts) {\n // got an \"options\" object\n exports._extend(ctx, opts);\n }\n // set default options\n if (isUndefined(ctx.showHidden)) ctx.showHidden = false;\n if (isUndefined(ctx.depth)) ctx.depth = 2;\n if (isUndefined(ctx.colors)) ctx.colors = false;\n if (isUndefined(ctx.customInspect)) ctx.customInspect = true;\n if (ctx.colors) ctx.stylize = stylizeWithColor;\n return formatValue(ctx, obj, ctx.depth);\n}\nexports.inspect = inspect;\n\n\n// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics\ninspect.colors = {\n 'bold' : [1, 22],\n 'italic' : [3, 23],\n 'underline' : [4, 24],\n 'inverse' : [7, 27],\n 'white' : [37, 39],\n 'grey' : [90, 39],\n 'black' : [30, 39],\n 'blue' : [34, 39],\n 'cyan' : [36, 39],\n 'green' : [32, 39],\n 'magenta' : [35, 39],\n 'red' : [31, 39],\n 'yellow' : [33, 39]\n};\n\n// Don't use 'blue' not visible on cmd.exe\ninspect.styles = {\n 'special': 'cyan',\n 'number': 'yellow',\n 'boolean': 'yellow',\n 'undefined': 'grey',\n 'null': 'bold',\n 'string': 'green',\n 'date': 'magenta',\n // \"name\": intentionally not styling\n 'regexp': 'red'\n};\n\n\nfunction stylizeWithColor(str, styleType) {\n var style = inspect.styles[styleType];\n\n if (style) {\n return '\\u001b[' + inspect.colors[style][0] + 'm' + str +\n '\\u001b[' + inspect.colors[style][1] + 'm';\n } else {\n return str;\n }\n}\n\n\nfunction stylizeNoColor(str, styleType) {\n return str;\n}\n\n\nfunction arrayToHash(array) {\n var hash = {};\n\n array.forEach(function(val, idx) {\n hash[val] = true;\n });\n\n return hash;\n}\n\n\nfunction formatValue(ctx, value, recurseTimes) {\n // Provide a hook for user-specified inspect functions.\n // Check that value is an object with an inspect function on it\n if (ctx.customInspect &&\n value &&\n isFunction(value.inspect) &&\n // Filter out the util module, it's inspect function is special\n value.inspect !== exports.inspect &&\n // Also filter out any prototype objects using the circular check.\n !(value.constructor && value.constructor.prototype === value)) {\n var ret = value.inspect(recurseTimes, ctx);\n if (!isString(ret)) {\n ret = formatValue(ctx, ret, recurseTimes);\n }\n return ret;\n }\n\n // Primitive types cannot have properties\n var primitive = formatPrimitive(ctx, value);\n if (primitive) {\n return primitive;\n }\n\n // Look up the keys of the object.\n var keys = Object.keys(value);\n var visibleKeys = arrayToHash(keys);\n\n if (ctx.showHidden) {\n keys = Object.getOwnPropertyNames(value);\n }\n\n // IE doesn't make error fields non-enumerable\n // http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx\n if (isError(value)\n && (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {\n return formatError(value);\n }\n\n // Some type of object without properties can be shortcutted.\n if (keys.length === 0) {\n if (isFunction(value)) {\n var name = value.name ? ': ' + value.name : '';\n return ctx.stylize('[Function' + name + ']', 'special');\n }\n if (isRegExp(value)) {\n return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n }\n if (isDate(value)) {\n return ctx.stylize(Date.prototype.toString.call(value), 'date');\n }\n if (isError(value)) {\n return formatError(value);\n }\n }\n\n var base = '', array = false, braces = ['{', '}'];\n\n // Make Array say that they are Array\n if (isArray(value)) {\n array = true;\n braces = ['[', ']'];\n }\n\n // Make functions say that they are functions\n if (isFunction(value)) {\n var n = value.name ? ': ' + value.name : '';\n base = ' [Function' + n + ']';\n }\n\n // Make RegExps say that they are RegExps\n if (isRegExp(value)) {\n base = ' ' + RegExp.prototype.toString.call(value);\n }\n\n // Make dates with properties first say the date\n if (isDate(value)) {\n base = ' ' + Date.prototype.toUTCString.call(value);\n }\n\n // Make error with message first say the error\n if (isError(value)) {\n base = ' ' + formatError(value);\n }\n\n if (keys.length === 0 && (!array || value.length == 0)) {\n return braces[0] + base + braces[1];\n }\n\n if (recurseTimes < 0) {\n if (isRegExp(value)) {\n return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');\n } else {\n return ctx.stylize('[Object]', 'special');\n }\n }\n\n ctx.seen.push(value);\n\n var output;\n if (array) {\n output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);\n } else {\n output = keys.map(function(key) {\n return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);\n });\n }\n\n ctx.seen.pop();\n\n return reduceToSingleString(output, base, braces);\n}\n\n\nfunction formatPrimitive(ctx, value) {\n if (isUndefined(value))\n return ctx.stylize('undefined', 'undefined');\n if (isString(value)) {\n var simple = '\\'' + JSON.stringify(value).replace(/^\"|\"$/g, '')\n .replace(/'/g, \"\\\\'\")\n .replace(/\\\\\"/g, '\"') + '\\'';\n return ctx.stylize(simple, 'string');\n }\n if (isNumber(value))\n return ctx.stylize('' + value, 'number');\n if (isBoolean(value))\n return ctx.stylize('' + value, 'boolean');\n // For some reason typeof null is \"object\", so special case here.\n if (isNull(value))\n return ctx.stylize('null', 'null');\n}\n\n\nfunction formatError(value) {\n return '[' + Error.prototype.toString.call(value) + ']';\n}\n\n\nfunction formatArray(ctx, value, recurseTimes, visibleKeys, keys) {\n var output = [];\n for (var i = 0, l = value.length; i < l; ++i) {\n if (hasOwnProperty(value, String(i))) {\n output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n String(i), true));\n } else {\n output.push('');\n }\n }\n keys.forEach(function(key) {\n if (!key.match(/^\\d+$/)) {\n output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,\n key, true));\n }\n });\n return output;\n}\n\n\nfunction formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {\n var name, str, desc;\n desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };\n if (desc.get) {\n if (desc.set) {\n str = ctx.stylize('[Getter/Setter]', 'special');\n } else {\n str = ctx.stylize('[Getter]', 'special');\n }\n } else {\n if (desc.set) {\n str = ctx.stylize('[Setter]', 'special');\n }\n }\n if (!hasOwnProperty(visibleKeys, key)) {\n name = '[' + key + ']';\n }\n if (!str) {\n if (ctx.seen.indexOf(desc.value) < 0) {\n if (isNull(recurseTimes)) {\n str = formatValue(ctx, desc.value, null);\n } else {\n str = formatValue(ctx, desc.value, recurseTimes - 1);\n }\n if (str.indexOf('\\n') > -1) {\n if (array) {\n str = str.split('\\n').map(function(line) {\n return ' ' + line;\n }).join('\\n').slice(2);\n } else {\n str = '\\n' + str.split('\\n').map(function(line) {\n return ' ' + line;\n }).join('\\n');\n }\n }\n } else {\n str = ctx.stylize('[Circular]', 'special');\n }\n }\n if (isUndefined(name)) {\n if (array && key.match(/^\\d+$/)) {\n return str;\n }\n name = JSON.stringify('' + key);\n if (name.match(/^\"([a-zA-Z_][a-zA-Z_0-9]*)\"$/)) {\n name = name.slice(1, -1);\n name = ctx.stylize(name, 'name');\n } else {\n name = name.replace(/'/g, \"\\\\'\")\n .replace(/\\\\\"/g, '\"')\n .replace(/(^\"|\"$)/g, \"'\");\n name = ctx.stylize(name, 'string');\n }\n }\n\n return name + ': ' + str;\n}\n\n\nfunction reduceToSingleString(output, base, braces) {\n var numLinesEst = 0;\n var length = output.reduce(function(prev, cur) {\n numLinesEst++;\n if (cur.indexOf('\\n') >= 0) numLinesEst++;\n return prev + cur.replace(/\\u001b\\[\\d\\d?m/g, '').length + 1;\n }, 0);\n\n if (length > 60) {\n return braces[0] +\n (base === '' ? '' : base + '\\n ') +\n ' ' +\n output.join(',\\n ') +\n ' ' +\n braces[1];\n }\n\n return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];\n}\n\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\nexports.types = require('./support/types');\n\nfunction isArray(ar) {\n return Array.isArray(ar);\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n return isObject(re) && objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\nexports.types.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n return isObject(d) && objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\nexports.types.isDate = isDate;\n\nfunction isError(e) {\n return isObject(e) &&\n (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\nexports.types.isNativeError = isError;\n\nfunction isFunction(arg) {\n return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n return arg === null ||\n typeof arg === 'boolean' ||\n typeof arg === 'number' ||\n typeof arg === 'string' ||\n typeof arg === 'symbol' || // ES6 symbol\n typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = require('./support/isBuffer');\n\nfunction objectToString(o) {\n return Object.prototype.toString.call(o);\n}\n\n\nfunction pad(n) {\n return n < 10 ? '0' + n.toString(10) : n.toString(10);\n}\n\n\nvar months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',\n 'Oct', 'Nov', 'Dec'];\n\n// 26 Feb 16:19:34\nfunction timestamp() {\n var d = new Date();\n var time = [pad(d.getHours()),\n pad(d.getMinutes()),\n pad(d.getSeconds())].join(':');\n return [d.getDate(), months[d.getMonth()], time].join(' ');\n}\n\n\n// log is just a thin wrapper to console.log that prepends a timestamp\nexports.log = function() {\n console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));\n};\n\n\n/**\n * Inherit the prototype methods from one constructor into another.\n *\n * The Function.prototype.inherits from lang.js rewritten as a standalone\n * function (not on Function.prototype). NOTE: If this file is to be loaded\n * during bootstrapping this function needs to be rewritten using some native\n * functions as prototype setup using normal JavaScript does not work as\n * expected during bootstrapping (see mirror.js in r114903).\n *\n * @param {function} ctor Constructor function which needs to inherit the\n * prototype.\n * @param {function} superCtor Constructor function to inherit prototype from.\n */\nexports.inherits = require('inherits');\n\nexports._extend = function(origin, add) {\n // Don't do anything if add isn't an object\n if (!add || !isObject(add)) return origin;\n\n var keys = Object.keys(add);\n var i = keys.length;\n while (i--) {\n origin[keys[i]] = add[keys[i]];\n }\n return origin;\n};\n\nfunction hasOwnProperty(obj, prop) {\n return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n\nvar kCustomPromisifiedSymbol = typeof Symbol !== 'undefined' ? Symbol('util.promisify.custom') : undefined;\n\nexports.promisify = function promisify(original) {\n if (typeof original !== 'function')\n throw new TypeError('The \"original\" argument must be of type Function');\n\n if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {\n var fn = original[kCustomPromisifiedSymbol];\n if (typeof fn !== 'function') {\n throw new TypeError('The \"util.promisify.custom\" argument must be of type Function');\n }\n Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n value: fn, enumerable: false, writable: false, configurable: true\n });\n return fn;\n }\n\n function fn() {\n var promiseResolve, promiseReject;\n var promise = new Promise(function (resolve, reject) {\n promiseResolve = resolve;\n promiseReject = reject;\n });\n\n var args = [];\n for (var i = 0; i < arguments.length; i++) {\n args.push(arguments[i]);\n }\n args.push(function (err, value) {\n if (err) {\n promiseReject(err);\n } else {\n promiseResolve(value);\n }\n });\n\n try {\n original.apply(this, args);\n } catch (err) {\n promiseReject(err);\n }\n\n return promise;\n }\n\n Object.setPrototypeOf(fn, Object.getPrototypeOf(original));\n\n if (kCustomPromisifiedSymbol) Object.defineProperty(fn, kCustomPromisifiedSymbol, {\n value: fn, enumerable: false, writable: false, configurable: true\n });\n return Object.defineProperties(\n fn,\n getOwnPropertyDescriptors(original)\n );\n}\n\nexports.promisify.custom = kCustomPromisifiedSymbol\n\nfunction callbackifyOnRejected(reason, cb) {\n // `!reason` guard inspired by bluebird (Ref: https://goo.gl/t5IS6M).\n // Because `null` is a special error value in callbacks which means \"no error\n // occurred\", we error-wrap so the callback consumer can distinguish between\n // \"the promise rejected with null\" or \"the promise fulfilled with undefined\".\n if (!reason) {\n var newReason = new Error('Promise was rejected with a falsy value');\n newReason.reason = reason;\n reason = newReason;\n }\n return cb(reason);\n}\n\nfunction callbackify(original) {\n if (typeof original !== 'function') {\n throw new TypeError('The \"original\" argument must be of type Function');\n }\n\n // We DO NOT return the promise as it gives the user a false sense that\n // the promise is actually somehow related to the callback's execution\n // and that the callback throwing will reject the promise.\n function callbackified() {\n var args = [];\n for (var i = 0; i < arguments.length; i++) {\n args.push(arguments[i]);\n }\n\n var maybeCb = args.pop();\n if (typeof maybeCb !== 'function') {\n throw new TypeError('The last argument must be of type Function');\n }\n var self = this;\n var cb = function() {\n return maybeCb.apply(self, arguments);\n };\n // In true node style we process the callback on `nextTick` with all the\n // implications (stack, `uncaughtException`, `async_hooks`)\n original.apply(this, args)\n .then(function(ret) { process.nextTick(cb.bind(null, null, ret)) },\n function(rej) { process.nextTick(callbackifyOnRejected.bind(null, rej, cb)) });\n }\n\n Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original));\n Object.defineProperties(callbackified,\n getOwnPropertyDescriptors(original));\n return callbackified;\n}\nexports.callbackify = callbackify;\n","'use strict';\n\nvar forEach = require('for-each');\nvar availableTypedArrays = require('available-typed-arrays');\nvar callBound = require('call-bind/callBound');\nvar gOPD = require('gopd');\n\nvar $toString = callBound('Object.prototype.toString');\nvar hasToStringTag = require('has-tostringtag/shams')();\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\nvar typedArrays = availableTypedArrays();\n\nvar $slice = callBound('String.prototype.slice');\nvar toStrTags = {};\nvar getPrototypeOf = Object.getPrototypeOf; // require('getprototypeof');\nif (hasToStringTag && gOPD && getPrototypeOf) {\n\tforEach(typedArrays, function (typedArray) {\n\t\tif (typeof g[typedArray] === 'function') {\n\t\t\tvar arr = new g[typedArray]();\n\t\t\tif (Symbol.toStringTag in arr) {\n\t\t\t\tvar proto = getPrototypeOf(arr);\n\t\t\t\tvar descriptor = gOPD(proto, Symbol.toStringTag);\n\t\t\t\tif (!descriptor) {\n\t\t\t\t\tvar superProto = getPrototypeOf(proto);\n\t\t\t\t\tdescriptor = gOPD(superProto, Symbol.toStringTag);\n\t\t\t\t}\n\t\t\t\ttoStrTags[typedArray] = descriptor.get;\n\t\t\t}\n\t\t}\n\t});\n}\n\nvar tryTypedArrays = function tryAllTypedArrays(value) {\n\tvar foundName = false;\n\tforEach(toStrTags, function (getter, typedArray) {\n\t\tif (!foundName) {\n\t\t\ttry {\n\t\t\t\tvar name = getter.call(value);\n\t\t\t\tif (name === typedArray) {\n\t\t\t\t\tfoundName = name;\n\t\t\t\t}\n\t\t\t} catch (e) {}\n\t\t}\n\t});\n\treturn foundName;\n};\n\nvar isTypedArray = require('is-typed-array');\n\nmodule.exports = function whichTypedArray(value) {\n\tif (!isTypedArray(value)) { return false; }\n\tif (!hasToStringTag || !(Symbol.toStringTag in value)) { return $slice($toString(value), 8, -1); }\n\treturn tryTypedArrays(value);\n};\n","var bs58check = require('bs58check')\n\nfunction decodeRaw (buffer, version) {\n // check version only if defined\n if (version !== undefined && buffer[0] !== version) throw new Error('Invalid network version')\n\n // uncompressed\n if (buffer.length === 33) {\n return {\n version: buffer[0],\n privateKey: buffer.slice(1, 33),\n compressed: false\n }\n }\n\n // invalid length\n if (buffer.length !== 34) throw new Error('Invalid WIF length')\n\n // invalid compression flag\n if (buffer[33] !== 0x01) throw new Error('Invalid compression flag')\n\n return {\n version: buffer[0],\n privateKey: buffer.slice(1, 33),\n compressed: true\n }\n}\n\nfunction encodeRaw (version, privateKey, compressed) {\n var result = new Buffer(compressed ? 34 : 33)\n\n result.writeUInt8(version, 0)\n privateKey.copy(result, 1)\n\n if (compressed) {\n result[33] = 0x01\n }\n\n return result\n}\n\nfunction decode (string, version) {\n return decodeRaw(bs58check.decode(string), version)\n}\n\nfunction encode (version, privateKey, compressed) {\n if (typeof version === 'number') return bs58check.encode(encodeRaw(version, privateKey, compressed))\n\n return bs58check.encode(\n encodeRaw(\n version.version,\n version.privateKey,\n version.compressed\n )\n )\n}\n\nmodule.exports = {\n decode: decode,\n decodeRaw: decodeRaw,\n encode: encode,\n encodeRaw: encodeRaw\n}\n","module.exports = extend\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\n\nfunction extend() {\n var target = {}\n\n for (var i = 0; i < arguments.length; i++) {\n var source = arguments[i]\n\n for (var key in source) {\n if (hasOwnProperty.call(source, key)) {\n target[key] = source[key]\n }\n }\n }\n\n return target\n}\n","enum ECDSA {\n ed25519 = 'ed25519',\n secp256k1 = 'ecdsa-secp256k1',\n}\n\nexport default ECDSA\n","import type { Client } from '../client'\nimport { XRPLFaucetError } from '../errors'\n\nexport interface FaucetWallet {\n account: {\n xAddress: string\n classicAddress?: string\n secret: string\n }\n amount: number\n balance: number\n}\n\nexport enum FaucetNetwork {\n Testnet = 'faucet.altnet.rippletest.net',\n Devnet = 'faucet.devnet.rippletest.net',\n AMMDevnet = 'ammfaucet.devnet.rippletest.net',\n HooksV2Testnet = 'hooks-testnet-v2.xrpl-labs.com',\n}\n\nexport const FaucetNetworkPaths: Record<string, string> = {\n [FaucetNetwork.Testnet]: '/accounts',\n [FaucetNetwork.Devnet]: '/accounts',\n [FaucetNetwork.AMMDevnet]: '/accounts',\n [FaucetNetwork.HooksV2Testnet]: '/accounts',\n}\n\n/**\n * Get the faucet host based on the Client connection.\n *\n * @param client - Client.\n * @returns A {@link FaucetNetwork}.\n * @throws When the client url is not on altnet or devnet.\n */\nexport function getFaucetHost(client: Client): FaucetNetwork | undefined {\n const connectionUrl = client.url\n\n if (connectionUrl.includes('hooks-testnet-v2')) {\n return FaucetNetwork.HooksV2Testnet\n }\n\n // 'altnet' for Ripple Testnet server and 'testnet' for XRPL Labs Testnet server\n if (connectionUrl.includes('altnet') || connectionUrl.includes('testnet')) {\n return FaucetNetwork.Testnet\n }\n\n if (connectionUrl.includes('amm')) {\n return FaucetNetwork.AMMDevnet\n }\n\n if (connectionUrl.includes('devnet')) {\n return FaucetNetwork.Devnet\n }\n\n throw new XRPLFaucetError('Faucet URL is not defined or inferrable.')\n}\n\n/**\n * Get the faucet pathname based on the faucet hostname.\n *\n * @param hostname - hostname.\n * @returns A String with the correct path for the input hostname.\n * If hostname undefined or cannot find (key, value) pair in {@link FaucetNetworkPaths}, defaults to '/accounts'\n */\nexport function getDefaultFaucetPath(hostname: string | undefined): string {\n if (hostname === undefined) {\n return '/accounts'\n }\n return FaucetNetworkPaths[hostname] || '/accounts'\n}\n","import { IncomingMessage } from 'http'\nimport { request as httpsRequest, RequestOptions } from 'https'\n\nimport { isValidClassicAddress } from 'ripple-address-codec'\n\nimport type { Client } from '../client'\nimport { RippledError, XRPLFaucetError } from '../errors'\n\nimport {\n FaucetWallet,\n getFaucetHost,\n getDefaultFaucetPath,\n} from './defaultFaucets'\n\nimport Wallet from '.'\n\n// Interval to check an account balance\nconst INTERVAL_SECONDS = 1\n// Maximum attempts to retrieve a balance\nconst MAX_ATTEMPTS = 20\n\n/**\n * Generates a random wallet with some amount of XRP (usually 1000 XRP).\n *\n * @example\n * ```typescript\n * const api = new xrpl.Client(\"wss://s.altnet.rippletest.net:51233\")\n * await api.connect()\n * const { wallet, balance } = await api.fundWallet()\n * ```\n *\n * @param this - Client.\n * @param wallet - An existing XRPL Wallet to fund. If undefined or null, a new Wallet will be created.\n * @param options - See below.\n * @param options.faucetHost - A custom host for a faucet server. On devnet,\n * testnet, AMM devnet, and HooksV2 testnet, `fundWallet` will\n * attempt to determine the correct server automatically. In other environments,\n * or if you would like to customize the faucet host in devnet or testnet,\n * you should provide the host using this option.\n * @param options.faucetPath - A custom path for a faucet server. On devnet,\n * testnet, AMM devnet, and HooksV2 testnet, `fundWallet` will\n * attempt to determine the correct path automatically. In other environments,\n * or if you would like to customize the faucet path in devnet or testnet,\n * you should provide the path using this option.\n * Ex: client.fundWallet(null,{'faucet.altnet.rippletest.net', '/accounts'})\n * specifies a request to 'faucet.altnet.rippletest.net/accounts' to fund a new wallet.\n * @param options.amount - A custom amount to fund, if undefined or null, the default amount will be 1000.\n * @returns A Wallet on the Testnet or Devnet that contains some amount of XRP,\n * and that wallet's balance in XRP.\n * @throws When either Client isn't connected or unable to fund wallet address.\n */\n// eslint-disable-next-line max-lines-per-function -- All lines necessary\nasync function fundWallet(\n this: Client,\n wallet?: Wallet | null,\n options?: {\n faucetHost?: string\n faucetPath?: string\n amount?: string\n },\n): Promise<{\n wallet: Wallet\n balance: number\n}> {\n if (!this.isConnected()) {\n throw new RippledError('Client not connected, cannot call faucet')\n }\n\n // Generate a new Wallet if no existing Wallet is provided or its address is invalid to fund\n const walletToFund =\n wallet && isValidClassicAddress(wallet.classicAddress)\n ? wallet\n : Wallet.generate()\n\n // Create the POST request body\n const postBody = Buffer.from(\n new TextEncoder().encode(\n JSON.stringify({\n destination: walletToFund.classicAddress,\n xrpAmount: options?.amount,\n }),\n ),\n )\n\n let startingBalance = 0\n try {\n startingBalance = Number(\n await this.getXrpBalance(walletToFund.classicAddress),\n )\n } catch {\n /* startingBalance remains '0' */\n }\n // Options to pass to https.request\n const httpOptions = getHTTPOptions(this, postBody, {\n hostname: options?.faucetHost,\n pathname: options?.faucetPath,\n })\n\n return returnPromise(\n httpOptions,\n this,\n startingBalance,\n walletToFund,\n postBody,\n )\n}\n\n// eslint-disable-next-line max-params -- Helper function created for organizational purposes\nasync function returnPromise(\n options: RequestOptions,\n client: Client,\n startingBalance: number,\n walletToFund: Wallet,\n postBody: Buffer,\n): Promise<{\n wallet: Wallet\n balance: number\n}> {\n return new Promise((resolve, reject) => {\n const request = httpsRequest(options, (response) => {\n const chunks: Uint8Array[] = []\n response.on('data', (data) => chunks.push(data))\n // eslint-disable-next-line @typescript-eslint/no-misused-promises -- not actually misused, different resolve/reject\n response.on('end', async () =>\n onEnd(\n response,\n chunks,\n client,\n startingBalance,\n walletToFund,\n resolve,\n reject,\n ),\n )\n })\n // POST the body\n request.write(postBody)\n\n request.on('error', (error) => {\n reject(error)\n })\n\n request.end()\n })\n}\n\nfunction getHTTPOptions(\n client: Client,\n postBody: Uint8Array,\n options?: {\n hostname?: string\n pathname?: string\n },\n): RequestOptions {\n const finalHostname = options?.hostname ?? getFaucetHost(client)\n const finalPathname = options?.pathname ?? getDefaultFaucetPath(finalHostname)\n return {\n hostname: finalHostname,\n port: 443,\n path: finalPathname,\n method: 'POST',\n headers: {\n 'Content-Type': 'application/json',\n 'Content-Length': postBody.length,\n },\n }\n}\n\n// eslint-disable-next-line max-params -- Helper function created for organizational purposes\nasync function onEnd(\n response: IncomingMessage,\n chunks: Uint8Array[],\n client: Client,\n startingBalance: number,\n walletToFund: Wallet,\n resolve: (response: { wallet: Wallet; balance: number }) => void,\n reject: (err: ErrorConstructor | Error | unknown) => void,\n): Promise<void> {\n const body = Buffer.concat(chunks).toString()\n\n // \"application/json; charset=utf-8\"\n if (response.headers['content-type']?.startsWith('application/json')) {\n // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- We know this is safe and correct\n const faucetWallet: FaucetWallet = JSON.parse(body)\n const classicAddress = faucetWallet.account.classicAddress\n await processSuccessfulResponse(\n client,\n classicAddress,\n walletToFund,\n startingBalance,\n resolve,\n reject,\n )\n } else {\n reject(\n new XRPLFaucetError(\n `Content type is not \\`application/json\\`: ${JSON.stringify({\n statusCode: response.statusCode,\n contentType: response.headers['content-type'],\n body,\n })}`,\n ),\n )\n }\n}\n\n// eslint-disable-next-line max-params, max-lines-per-function -- Only used as a helper function, lines inc due to added balance.\nasync function processSuccessfulResponse(\n client: Client,\n classicAddress: string | undefined,\n walletToFund: Wallet,\n startingBalance: number,\n resolve: (response: { wallet: Wallet; balance: number }) => void,\n reject: (err: ErrorConstructor | Error | unknown) => void,\n): Promise<void> {\n if (!classicAddress) {\n reject(new XRPLFaucetError(`The faucet account is undefined`))\n return\n }\n try {\n // Check at regular interval if the address is enabled on the XRPL and funded\n const updatedBalance = await getUpdatedBalance(\n client,\n classicAddress,\n startingBalance,\n )\n\n if (updatedBalance > startingBalance) {\n resolve({\n wallet: walletToFund,\n balance: await getUpdatedBalance(\n client,\n walletToFund.classicAddress,\n startingBalance,\n ),\n })\n } else {\n reject(\n new XRPLFaucetError(\n `Unable to fund address with faucet after waiting ${\n INTERVAL_SECONDS * MAX_ATTEMPTS\n } seconds`,\n ),\n )\n }\n } catch (err) {\n if (err instanceof Error) {\n reject(new XRPLFaucetError(err.message))\n }\n reject(err)\n }\n}\n\n/**\n * Check at regular interval if the address is enabled on the XRPL and funded.\n *\n * @param client - Client.\n * @param address - The account address to check.\n * @param originalBalance - The initial balance before the funding.\n * @returns A Promise boolean.\n */\nasync function getUpdatedBalance(\n client: Client,\n address: string,\n originalBalance: number,\n): Promise<number> {\n return new Promise((resolve, reject) => {\n let attempts = MAX_ATTEMPTS\n // eslint-disable-next-line @typescript-eslint/no-misused-promises -- Not actually misused here, different resolve\n const interval = setInterval(async () => {\n if (attempts < 0) {\n clearInterval(interval)\n resolve(originalBalance)\n } else {\n attempts -= 1\n }\n\n try {\n let newBalance\n try {\n newBalance = Number(await client.getXrpBalance(address))\n } catch {\n /* newBalance remains undefined */\n }\n\n if (newBalance > originalBalance) {\n clearInterval(interval)\n resolve(newBalance)\n }\n } catch (err) {\n clearInterval(interval)\n if (err instanceof Error) {\n reject(\n new XRPLFaucetError(\n `Unable to check if the address ${address} balance has increased. Error: ${err.message}`,\n ),\n )\n }\n reject(err)\n }\n }, INTERVAL_SECONDS * 1000)\n })\n}\n\nexport default fundWallet\n","/* eslint-disable max-lines -- There are lots of equivalent constructors which make sense to have here. */\nimport BigNumber from 'bignumber.js'\nimport { fromSeed } from 'bip32'\nimport { mnemonicToSeedSync, validateMnemonic } from 'bip39'\nimport isEqual from 'lodash/isEqual'\nimport {\n classicAddressToXAddress,\n isValidXAddress,\n xAddressToClassicAddress,\n encodeSeed,\n} from 'ripple-address-codec'\nimport {\n decode,\n encodeForSigning,\n encodeForMultisigning,\n encode,\n} from 'ripple-binary-codec'\nimport {\n deriveAddress,\n deriveKeypair,\n generateSeed,\n verify,\n sign,\n} from 'ripple-keypairs'\n\nimport ECDSA from '../ECDSA'\nimport { ValidationError, XrplError } from '../errors'\nimport { IssuedCurrencyAmount } from '../models/common'\nimport { Transaction } from '../models/transactions'\nimport { isIssuedCurrency } from '../models/transactions/common'\nimport { isHex } from '../models/utils'\nimport { ensureClassicAddress } from '../sugar/utils'\nimport { hashSignedTx } from '../utils/hashes/hashLedger'\n\nimport { rfc1751MnemonicToKey } from './rfc1751'\n\nconst DEFAULT_ALGORITHM: ECDSA = ECDSA.ed25519\nconst DEFAULT_DERIVATION_PATH = \"m/44'/144'/0'/0/0\"\n\nfunction hexFromBuffer(buffer: Buffer): string {\n return buffer.toString('hex').toUpperCase()\n}\n\n/**\n * A utility for deriving a wallet composed of a keypair (publicKey/privateKey).\n * A wallet can be derived from either a seed, mnemonic, or entropy (array of random numbers).\n * It provides functionality to sign/verify transactions offline.\n *\n * @example\n * ```typescript\n *\n * // Derive a wallet from a base58 encoded seed.\n * const seedWallet = Wallet.fromSeed('ssZkdwURFMBXenJPbrpE14b6noJSu')\n * console.log(seedWallet)\n * // Wallet {\n * // publicKey: '02FE9932A9C4AA2AC9F0ED0F2B89302DE7C2C95F91D782DA3CF06E64E1C1216449',\n * // privateKey: '00445D0A16DD05EFAF6D5AF45E6B8A6DE4170D93C0627021A0B8E705786CBCCFF7',\n * // classicAddress: 'rG88FVLjvYiQaGftSa1cKuE2qNx7aK5ivo',\n * // seed: 'ssZkdwURFMBXenJPbrpE14b6noJSu'\n * // }.\n *\n * // Sign a JSON Transaction\n * const signed = seedWallet.signTransaction({\n * TransactionType: 'Payment',\n * Account: 'rG88FVLjvYiQaGftSa1cKuE2qNx7aK5ivo'\n * ...........\n * }).\n *\n * console.log(signed)\n * // '1200007321......B01BE1DFF3'.\n * console.log(decode(signed))\n * // {\n * // TransactionType: 'Payment',\n * // SigningPubKey: '02FE9932A9C4AA2AC9F0ED0F2B89302DE7C2C95F91D782DA3CF06E64E1C1216449',\n * // TxnSignature: '3045022100AAD......5B631ABD21171B61B07D304',\n * // Account: 'rG88FVLjvYiQaGftSa1cKuE2qNx7aK5ivo'\n * // ...........\n * // }\n * ```\n *\n * @category Signing\n */\nclass Wallet {\n public readonly publicKey: string\n public readonly privateKey: string\n public readonly classicAddress: string\n public readonly seed?: string\n\n /**\n * Creates a new Wallet.\n *\n * @param publicKey - The public key for the account.\n * @param privateKey - The private key used for signing transactions for the account.\n * @param opts - (Optional) Options to initialize a Wallet.\n * @param opts.masterAddress - Include if a Wallet uses a Regular Key Pair. It must be the master address of the account.\n * @param opts.seed - The seed used to derive the account keys.\n */\n public constructor(\n publicKey: string,\n privateKey: string,\n opts: {\n masterAddress?: string\n seed?: string\n } = {},\n ) {\n this.publicKey = publicKey\n this.privateKey = privateKey\n this.classicAddress = opts.masterAddress\n ? ensureClassicAddress(opts.masterAddress)\n : deriveAddress(publicKey)\n this.seed = opts.seed\n }\n\n /**\n * Alias for wallet.classicAddress.\n *\n * @returns The wallet's classic address.\n */\n public get address(): string {\n return this.classicAddress\n }\n\n /**\n * Generates a new Wallet using a generated seed.\n *\n * @param algorithm - The digital signature algorithm to generate an address for.\n * @returns A new Wallet derived from a generated seed.\n */\n public static generate(algorithm: ECDSA = DEFAULT_ALGORITHM): Wallet {\n const seed = generateSeed({ algorithm })\n return Wallet.fromSeed(seed)\n }\n\n /**\n * Derives a wallet from a seed.\n *\n * @param seed - A string used to generate a keypair (publicKey/privateKey) to derive a wallet.\n * @param opts - (Optional) Options to derive a Wallet.\n * @param opts.algorithm - The digital signature algorithm to generate an address for.\n * @param opts.masterAddress - Include if a Wallet uses a Regular Key Pair. It must be the master address of the account.\n * @returns A Wallet derived from a seed.\n */\n public static fromSeed(\n seed: string,\n opts: { masterAddress?: string; algorithm?: ECDSA } = {},\n ): Wallet {\n return Wallet.deriveWallet(seed, {\n algorithm: opts.algorithm,\n masterAddress: opts.masterAddress,\n })\n }\n\n /**\n * Derives a wallet from a secret (AKA a seed).\n *\n * @param secret - A string used to generate a keypair (publicKey/privateKey) to derive a wallet.\n * @param opts - (Optional) Options to derive a Wallet.\n * @param opts.algorithm - The digital signature algorithm to generate an address for.\n * @param opts.masterAddress - Include if a Wallet uses a Regular Key Pair. It must be the master address of the account.\n * @returns A Wallet derived from a secret (AKA a seed).\n */\n // eslint-disable-next-line @typescript-eslint/member-ordering -- Member is used as a function here\n public static fromSecret = Wallet.fromSeed\n\n /**\n * Derives a wallet from an entropy (array of random numbers).\n *\n * @param entropy - An array of random numbers to generate a seed used to derive a wallet.\n * @param opts - (Optional) Options to derive a Wallet.\n * @param opts.algorithm - The digital signature algorithm to generate an address for.\n * @param opts.masterAddress - Include if a Wallet uses a Regular Key Pair. It must be the master address of the account.\n * @returns A Wallet derived from an entropy.\n */\n public static fromEntropy(\n entropy: Uint8Array | number[],\n opts: { masterAddress?: string; algorithm?: ECDSA } = {},\n ): Wallet {\n const algorithm = opts.algorithm ?? DEFAULT_ALGORITHM\n const options = {\n entropy: Uint8Array.from(entropy),\n algorithm,\n }\n const seed = generateSeed(options)\n return Wallet.deriveWallet(seed, {\n algorithm,\n masterAddress: opts.masterAddress,\n })\n }\n\n /**\n * Derives a wallet from a bip39 or RFC1751 mnemonic (Defaults to bip39).\n *\n * @deprecated since version 2.6.1.\n * Will be deleted in version 3.0.0.\n * This representation is currently deprecated in rippled.\n * You should use another method to represent your keys such as a seed or public/private keypair.\n *\n * @param mnemonic - A string consisting of words (whitespace delimited) used to derive a wallet.\n * @param opts - (Optional) Options to derive a Wallet.\n * @param opts.masterAddress - Include if a Wallet uses a Regular Key Pair. It must be the master address of the account.\n * @param opts.derivationPath - The path to derive a keypair (publicKey/privateKey). Only used for bip39 conversions.\n * @param opts.mnemonicEncoding - If set to 'rfc1751', this interprets the mnemonic as a rippled RFC1751 mnemonic like\n * `wallet_propose` generates in rippled. Otherwise the function defaults to bip39 decoding.\n * @param opts.algorithm - Only used if opts.mnemonicEncoding is 'rfc1751'. Allows the mnemonic to generate its\n * secp256k1 seed, or its ed25519 seed. By default, it will generate the secp256k1 seed\n * to match the rippled `wallet_propose` default algorithm.\n * @returns A Wallet derived from a mnemonic.\n * @throws ValidationError if unable to derive private key from mnemonic input.\n */\n public static fromMnemonic(\n mnemonic: string,\n opts: {\n masterAddress?: string\n derivationPath?: string\n mnemonicEncoding?: 'bip39' | 'rfc1751'\n algorithm?: ECDSA\n } = {},\n ): Wallet {\n if (opts.mnemonicEncoding === 'rfc1751') {\n return Wallet.fromRFC1751Mnemonic(mnemonic, {\n masterAddress: opts.masterAddress,\n algorithm: opts.algorithm,\n })\n }\n // Otherwise decode using bip39's mnemonic standard\n if (!validateMnemonic(mnemonic)) {\n throw new ValidationError(\n 'Unable to parse the given mnemonic using bip39 encoding',\n )\n }\n\n const seed = mnemonicToSeedSync(mnemonic)\n const masterNode = fromSeed(seed)\n const node = masterNode.derivePath(\n opts.derivationPath ?? DEFAULT_DERIVATION_PATH,\n )\n if (node.privateKey === undefined) {\n throw new ValidationError(\n 'Unable to derive privateKey from mnemonic input',\n )\n }\n\n const publicKey = hexFromBuffer(node.publicKey)\n const privateKey = hexFromBuffer(node.privateKey)\n return new Wallet(publicKey, `00${privateKey}`, {\n masterAddress: opts.masterAddress,\n })\n }\n\n /**\n * Derives a wallet from a RFC1751 mnemonic, which is how `wallet_propose` encodes mnemonics.\n *\n * @param mnemonic - A string consisting of words (whitespace delimited) used to derive a wallet.\n * @param opts - (Optional) Options to derive a Wallet.\n * @param opts.masterAddress - Include if a Wallet uses a Regular Key Pair. It must be the master address of the account.\n * @param opts.algorithm - The digital signature algorithm to generate an address for.\n * @returns A Wallet derived from a mnemonic.\n */\n private static fromRFC1751Mnemonic(\n mnemonic: string,\n opts: { masterAddress?: string; algorithm?: ECDSA },\n ): Wallet {\n const seed = rfc1751MnemonicToKey(mnemonic)\n let encodeAlgorithm: 'ed25519' | 'secp256k1'\n if (opts.algorithm === ECDSA.ed25519) {\n encodeAlgorithm = 'ed25519'\n } else {\n // Defaults to secp256k1 since that's the default for `wallet_propose`\n encodeAlgorithm = 'secp256k1'\n }\n const encodedSeed = encodeSeed(seed, encodeAlgorithm)\n return Wallet.fromSeed(encodedSeed, {\n masterAddress: opts.masterAddress,\n algorithm: opts.algorithm,\n })\n }\n\n /**\n * Derive a Wallet from a seed.\n *\n * @param seed - The seed used to derive the wallet.\n * @param opts - (Optional) Options to derive a Wallet.\n * @param opts.algorithm - The digital signature algorithm to generate an address for.\n * @param opts.masterAddress - Include if a Wallet uses a Regular Key Pair. It must be the master address of the account.\n * @returns A Wallet derived from the seed.\n */\n private static deriveWallet(\n seed: string,\n opts: { masterAddress?: string; algorithm?: ECDSA } = {},\n ): Wallet {\n const { publicKey, privateKey } = deriveKeypair(seed, {\n algorithm: opts.algorithm ?? DEFAULT_ALGORITHM,\n })\n return new Wallet(publicKey, privateKey, {\n seed,\n masterAddress: opts.masterAddress,\n })\n }\n\n /**\n * Signs a transaction offline.\n *\n * @param this - Wallet instance.\n * @param transaction - A transaction to be signed offline.\n * @param multisign - Specify true/false to use multisign or actual address (classic/x-address) to make multisign tx request.\n * @returns A signed transaction.\n * @throws ValidationError if the transaction is already signed or does not encode/decode to same result.\n * @throws XrplError if the issued currency being signed is XRP ignoring case.\n */\n // eslint-disable-next-line max-lines-per-function -- introduced more checks to support both string and boolean inputs.\n public sign(\n this: Wallet,\n transaction: Transaction,\n multisign?: boolean | string,\n ): {\n tx_blob: string\n hash: string\n } {\n let multisignAddress: boolean | string = false\n if (typeof multisign === 'string' && multisign.startsWith('X')) {\n multisignAddress = multisign\n } else if (multisign) {\n multisignAddress = this.classicAddress\n }\n\n const tx = { ...transaction }\n\n if (tx.TxnSignature || tx.Signers) {\n throw new ValidationError(\n 'txJSON must not contain \"TxnSignature\" or \"Signers\" properties',\n )\n }\n\n removeTrailingZeros(tx)\n\n const txToSignAndEncode = { ...tx }\n\n txToSignAndEncode.SigningPubKey = multisignAddress ? '' : this.publicKey\n\n if (multisignAddress) {\n const signer = {\n Account: multisignAddress,\n SigningPubKey: this.publicKey,\n TxnSignature: computeSignature(\n txToSignAndEncode,\n this.privateKey,\n multisignAddress,\n ),\n }\n txToSignAndEncode.Signers = [{ Signer: signer }]\n } else {\n txToSignAndEncode.TxnSignature = computeSignature(\n txToSignAndEncode,\n this.privateKey,\n )\n }\n\n const serialized = encode(txToSignAndEncode)\n this.checkTxSerialization(serialized, tx)\n return {\n tx_blob: serialized,\n hash: hashSignedTx(serialized),\n }\n }\n\n /**\n * Verifies a signed transaction offline.\n *\n * @param signedTransaction - A signed transaction (hex string of signTransaction result) to be verified offline.\n * @returns Returns true if a signedTransaction is valid.\n */\n public verifyTransaction(signedTransaction: Transaction | string): boolean {\n const tx =\n typeof signedTransaction === 'string'\n ? decode(signedTransaction)\n : signedTransaction\n const messageHex: string = encodeForSigning(tx)\n const signature = tx.TxnSignature\n return verify(messageHex, signature, this.publicKey)\n }\n\n /**\n * Gets an X-address in Testnet/Mainnet format.\n *\n * @param tag - A tag to be included within the X-address.\n * @param isTestnet - A boolean to indicate if X-address should be in Testnet (true) or Mainnet (false) format.\n * @returns An X-address.\n */\n public getXAddress(tag: number | false = false, isTestnet = false): string {\n return classicAddressToXAddress(this.classicAddress, tag, isTestnet)\n }\n\n /**\n * Decode a serialized transaction, remove the fields that are added during the signing process,\n * and verify that it matches the transaction prior to signing. This gives the user a sanity check\n * to ensure that what they try to encode matches the message that will be recieved by rippled.\n *\n * @param serialized - A signed and serialized transaction.\n * @param tx - The transaction prior to signing.\n * @throws A ValidationError if the transaction does not have a TxnSignature/Signers property, or if\n * the serialized Transaction desn't match the original transaction.\n * @throws XrplError if the transaction includes an issued currency which is equivalent to XRP ignoring case.\n */\n // eslint-disable-next-line class-methods-use-this, max-lines-per-function -- Helper for organization purposes\n private checkTxSerialization(serialized: string, tx: Transaction): void {\n // Decode the serialized transaction:\n const decoded = decode(serialized)\n const txCopy = { ...tx }\n\n /*\n * And ensure it is equal to the original tx, except:\n * - It must have a TxnSignature or Signers (multisign).\n */\n if (!decoded.TxnSignature && !decoded.Signers) {\n throw new ValidationError(\n 'Serialized transaction must have a TxnSignature or Signers property',\n )\n }\n // - We know that the original tx did not have TxnSignature, so we should delete it:\n delete decoded.TxnSignature\n // - We know that the original tx did not have Signers, so if it exists, we should delete it:\n delete decoded.Signers\n\n /*\n * - If SigningPubKey was not in the original tx, then we should delete it.\n * But if it was in the original tx, then we should ensure that it has not been changed.\n */\n if (!tx.SigningPubKey) {\n delete decoded.SigningPubKey\n }\n\n /*\n * - Memos have exclusively hex data which should ignore case.\n * Since decode goes to upper case, we set all tx memos to be uppercase for the comparison.\n */\n txCopy.Memos?.map((memo) => {\n const memoCopy = { ...memo }\n if (memo.Memo.MemoData) {\n if (!isHex(memo.Memo.MemoData)) {\n throw new ValidationError('MemoData field must be a hex value')\n }\n memoCopy.Memo.MemoData = memo.Memo.MemoData.toUpperCase()\n }\n\n if (memo.Memo.MemoType) {\n if (!isHex(memo.Memo.MemoType)) {\n throw new ValidationError('MemoType field must be a hex value')\n }\n memoCopy.Memo.MemoType = memo.Memo.MemoType.toUpperCase()\n }\n\n if (memo.Memo.MemoFormat) {\n if (!isHex(memo.Memo.MemoFormat)) {\n throw new ValidationError('MemoFormat field must be a hex value')\n }\n memoCopy.Memo.MemoFormat = memo.Memo.MemoFormat.toUpperCase()\n }\n\n return memo\n })\n\n if (txCopy.TransactionType === 'NFTokenMint' && txCopy.URI) {\n if (!isHex(txCopy.URI)) {\n throw new ValidationError('URI must be a hex value')\n }\n txCopy.URI = txCopy.URI.toUpperCase()\n }\n\n /* eslint-disable @typescript-eslint/consistent-type-assertions -- We check at runtime that this is safe */\n Object.keys(txCopy).forEach((key) => {\n const standard_currency_code_len = 3\n if (txCopy[key] && isIssuedCurrency(txCopy[key])) {\n const decodedAmount = decoded[key] as unknown as IssuedCurrencyAmount\n const decodedCurrency = decodedAmount.currency\n const txCurrency = (txCopy[key] as IssuedCurrencyAmount).currency\n\n if (\n txCurrency.length === standard_currency_code_len &&\n txCurrency.toUpperCase() === 'XRP'\n ) {\n throw new XrplError(\n `Trying to sign an issued currency with a similar standard code to XRP (received '${txCurrency}'). XRP is not an issued currency.`,\n )\n }\n\n // Standardize the format of currency codes to the 40 byte hex string for comparison\n const amount = txCopy[key] as IssuedCurrencyAmount\n if (amount.currency.length !== decodedCurrency.length) {\n /* eslint-disable-next-line max-depth -- Easier to read with two if-statements */\n if (decodedCurrency.length === standard_currency_code_len) {\n decodedAmount.currency = isoToHex(decodedCurrency)\n } else {\n /* eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- We need to update txCopy directly */\n txCopy[key].currency = isoToHex(txCopy[key].currency)\n }\n }\n }\n })\n /* eslint-enable @typescript-eslint/consistent-type-assertions -- Done with dynamic checking */\n\n if (!isEqual(decoded, txCopy)) {\n const data = {\n decoded,\n tx,\n }\n const error = new ValidationError(\n 'Serialized transaction does not match original txJSON. See error.data',\n data,\n )\n throw error\n }\n }\n}\n\n/**\n * Signs a transaction with the proper signing encoding.\n *\n * @param tx - A transaction to sign.\n * @param privateKey - A key to sign the transaction with.\n * @param signAs - Multisign only. An account address to include in the Signer field.\n * Can be either a classic address or an XAddress.\n * @returns A signed transaction in the proper format.\n */\nfunction computeSignature(\n tx: Transaction,\n privateKey: string,\n signAs?: string,\n): string {\n if (signAs) {\n const classicAddress = isValidXAddress(signAs)\n ? xAddressToClassicAddress(signAs).classicAddress\n : signAs\n\n return sign(encodeForMultisigning(tx, classicAddress), privateKey)\n }\n return sign(encodeForSigning(tx), privateKey)\n}\n\n/**\n * Remove trailing insignificant zeros for non-XRP Payment amount.\n * This resolves the serialization mismatch bug when encoding/decoding a non-XRP Payment transaction\n * with an amount that contains trailing insignificant zeros; for example, '123.4000' would serialize\n * to '123.4' and cause a mismatch.\n *\n * @param tx - The transaction prior to signing.\n */\nfunction removeTrailingZeros(tx: Transaction): void {\n if (\n tx.TransactionType === 'Payment' &&\n typeof tx.Amount !== 'string' &&\n tx.Amount.value.includes('.') &&\n tx.Amount.value.endsWith('0')\n ) {\n // eslint-disable-next-line no-param-reassign -- Required to update Transaction.Amount.value\n tx.Amount = { ...tx.Amount }\n // eslint-disable-next-line no-param-reassign -- Required to update Transaction.Amount.value\n tx.Amount.value = new BigNumber(tx.Amount.value).toString()\n }\n}\n\n/**\n * Convert an ISO code to a hex string representation\n *\n * @param iso - A 3 letter standard currency code\n */\n/* eslint-disable @typescript-eslint/no-magic-numbers -- Magic numbers are from rippleds of currency code encoding */\nfunction isoToHex(iso: string): string {\n const bytes = Buffer.alloc(20)\n if (iso !== 'XRP') {\n const isoBytes = iso.split('').map((chr) => chr.charCodeAt(0))\n bytes.set(isoBytes, 12)\n }\n return bytes.toString('hex').toUpperCase()\n}\n/* eslint-enable @typescript-eslint/no-magic-numbers -- Only needed in this function */\n\nexport default Wallet\n","/* eslint-disable @typescript-eslint/no-magic-numbers -- Doing many bitwise operations which need specific numbers */\n/* eslint-disable no-bitwise -- Bitwise operators are required for this encoding/decoding */\n/* eslint-disable id-length -- Bitwise math uses shorthand terms */\n/*\n *rfc1751.ts : Converts between 128-bit strings and a human-readable\n *sequence of words, as defined in RFC1751: \"A Convention for\n *Human-Readable 128-bit Keys\", by Daniel L. McDonald.\n *Ported from rfc1751.py / Python Cryptography Toolkit (public domain).\n *Copied from https://github.com/bip32/bip32.github.io/blob/master/js/rfc1751.js which\n *is part of the public domain.\n */\n\nimport rfc1751Words from './rfc1751Words.json'\n\nconst rfc1751WordList: string[] = rfc1751Words\n\n// Added prettier-ignore to allow _BINARY to be on two lines, instead of one entry per line.\n\n// prettier-ignore\nconst BINARY = ['0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111',\n '1000', '1001', '1010', '1011', '1100', '1101', '1110', '1111'];\n\n/**\n * Convert a number array into a binary string.\n *\n * @param key - An array of numbers in base 10.\n * @returns A binary string.\n */\nfunction keyToBinary(key: number[]): string {\n let res = ''\n for (const num of key) {\n res += BINARY[num >> 4] + BINARY[num & 0x0f]\n }\n return res\n}\n\n/**\n * Converts a substring of an encoded secret to its numeric value.\n *\n * @param key - The encoded secret.\n * @param start - The start index to parse from.\n * @param length - The number of digits to parse after the start index.\n * @returns The binary value of the substring.\n */\nfunction extract(key: string, start: number, length: number): number {\n const subKey = key.substring(start, start + length)\n let acc = 0\n for (let index = 0; index < subKey.length; index++) {\n acc = acc * 2 + subKey.charCodeAt(index) - 48\n }\n return acc\n}\n\n/**\n * Generates a modified RFC1751 mnemonic in the same way rippled's wallet_propose does.\n *\n * @param hex_key - An encoded secret in hex format.\n * @returns A mnemonic following rippled's modified RFC1751 mnemonic standard.\n */\nfunction keyToRFC1751Mnemonic(hex_key: string): string {\n // Remove whitespace and interpret hex\n const buf = Buffer.from(hex_key.replace(/\\s+/gu, ''), 'hex')\n // Swap byte order and use rfc1751\n let key: number[] = bufferToArray(swap128(buf))\n\n // pad to 8 bytes\n const padding: number[] = []\n for (let index = 0; index < (8 - (key.length % 8)) % 8; index++) {\n padding.push(0)\n }\n key = padding.concat(key)\n\n const english: string[] = []\n for (let index = 0; index < key.length; index += 8) {\n const subKey = key.slice(index, index + 8)\n\n // add parity\n let skbin = keyToBinary(subKey)\n let parity = 0\n for (let j = 0; j < 64; j += 2) {\n parity += extract(skbin, j, 2)\n }\n subKey.push((parity << 6) & 0xff)\n\n skbin = keyToBinary(subKey)\n for (let j = 0; j < 64; j += 11) {\n english.push(rfc1751WordList[extract(skbin, j, 11)])\n }\n }\n return english.join(' ')\n}\n\n/**\n * Converts an english mnemonic following rippled's modified RFC1751 standard to an encoded hex secret.\n *\n * @param english - A mnemonic generated using ripple's modified RFC1751 standard.\n * @throws Error if the parity after decoding does not match.\n * @returns A Buffer containing an encoded secret.\n */\nfunction rfc1751MnemonicToKey(english: string): Buffer {\n const words = english.split(' ')\n let key: number[] = []\n\n for (let index = 0; index < words.length; index += 6) {\n const { subKey, word }: { subKey: number[]; word: string } = getSubKey(\n words,\n index,\n )\n\n // check parity\n const skbin = keyToBinary(subKey)\n let parity = 0\n for (let j = 0; j < 64; j += 2) {\n parity += extract(skbin, j, 2)\n }\n const cs0 = extract(skbin, 64, 2)\n const cs1 = parity & 3\n if (cs0 !== cs1) {\n throw new Error(`Parity error at ${word}`)\n }\n\n key = key.concat(subKey.slice(0, 8))\n }\n\n // This is a step specific to the XRPL's implementation\n const bufferKey = swap128(Buffer.from(key))\n return bufferKey\n}\n\nfunction getSubKey(\n words: string[],\n index: number,\n): { subKey: number[]; word: string } {\n const sublist = words.slice(index, index + 6)\n let bits = 0\n const ch = [0, 0, 0, 0, 0, 0, 0, 0, 0]\n let word = ''\n for (word of sublist) {\n const idx = rfc1751WordList.indexOf(word.toUpperCase())\n if (idx === -1) {\n throw new TypeError(\n `Expected an RFC1751 word, but received '${word}'. ` +\n `For the full list of words in the RFC1751 encoding see https://datatracker.ietf.org/doc/html/rfc1751`,\n )\n }\n const shift = (8 - ((bits + 11) % 8)) % 8\n const y = idx << shift\n const cl = y >> 16\n const cc = (y >> 8) & 0xff\n const cr = y & 0xff\n const t = Math.floor(bits / 8)\n if (shift > 5) {\n ch[t] |= cl\n ch[t + 1] |= cc\n ch[t + 2] |= cr\n } else if (shift > -3) {\n ch[t] |= cc\n ch[t + 1] |= cr\n } else {\n ch[t] |= cr\n }\n bits += 11\n }\n const subKey: number[] = ch.slice()\n return { subKey, word }\n}\n\nfunction bufferToArray(buf: Buffer): number[] {\n /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- We know the end type */\n return Array.prototype.slice.call(buf) as number[]\n}\n\n/**\n * Swap the byte order of a 128-bit buffer.\n *\n * @param buf - A 128-bit (16 byte) buffer\n * @returns A buffer containing the same data with reversed endianness\n */\nfunction swap128(buf: Buffer): Buffer {\n // Interprets buffer as an array of (two, in this case) 64-bit numbers and swaps byte order in-place.\n const reversedBytes = buf.swap64()\n\n // Swap the two 64-bit numbers since our buffer is 128 bits.\n return Buffer.concat(\n [reversedBytes.slice(8, 16), reversedBytes.slice(0, 8)],\n 16,\n )\n}\n\nexport { rfc1751MnemonicToKey, keyToRFC1751Mnemonic }\n","import { BigNumber } from 'bignumber.js'\nimport { flatMap } from 'lodash'\nimport { decodeAccountID } from 'ripple-address-codec'\nimport {\n decode,\n encode,\n encodeForSigning,\n encodeForSigningClaim,\n} from 'ripple-binary-codec'\nimport { sign as signWithKeypair, verify } from 'ripple-keypairs'\n\nimport { ValidationError } from '../errors'\nimport { Signer } from '../models/common'\nimport { Transaction, validate } from '../models/transactions'\n\nimport Wallet from '.'\n\n/**\n * Takes several transactions with Signer fields (in object or blob form) and creates a\n * single transaction with all Signers that then gets signed and returned.\n *\n * @param transactions - An array of signed Transactions (in object or blob form) to combine into a single signed Transaction.\n * @returns A single signed Transaction which has all Signers from transactions within it.\n * @throws ValidationError if:\n * - There were no transactions given to sign\n * - The SigningPubKey field is not the empty string in any given transaction\n * - Any transaction is missing a Signers field.\n * @category Signing\n */\nfunction multisign(transactions: Array<Transaction | string>): string {\n if (transactions.length === 0) {\n throw new ValidationError('There were 0 transactions to multisign')\n }\n\n transactions.forEach((txOrBlob) => {\n const tx: Transaction = getDecodedTransaction(txOrBlob)\n\n /*\n * This will throw a more clear error for JS users if any of the supplied transactions has incorrect formatting\n */\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- validate does not accept Transaction type\n validate(tx as unknown as Record<string, unknown>)\n if (tx.Signers == null || tx.Signers.length === 0) {\n throw new ValidationError(\n \"For multisigning all transactions must include a Signers field containing an array of signatures. You may have forgotten to pass the 'forMultisign' parameter when signing.\",\n )\n }\n\n if (tx.SigningPubKey !== '') {\n throw new ValidationError(\n 'SigningPubKey must be an empty string for all transactions when multisigning.',\n )\n }\n })\n\n const decodedTransactions: Transaction[] = transactions.map(\n (txOrBlob: string | Transaction) => {\n return getDecodedTransaction(txOrBlob)\n },\n )\n\n validateTransactionEquivalence(decodedTransactions)\n\n return encode(getTransactionWithAllSigners(decodedTransactions))\n}\n\n/**\n * Creates a signature that can be used to redeem a specific amount of XRP from a payment channel.\n *\n * @param wallet - The account that will sign for this payment channel.\n * @param channelId - An id for the payment channel to redeem XRP from.\n * @param amount - The amount in drops to redeem.\n * @returns A signature that can be used to redeem a specific amount of XRP from a payment channel.\n * @category Utilities\n */\nfunction authorizeChannel(\n wallet: Wallet,\n channelId: string,\n amount: string,\n): string {\n const signingData = encodeForSigningClaim({\n channel: channelId,\n amount,\n })\n\n return signWithKeypair(signingData, wallet.privateKey)\n}\n\n/**\n * Verifies that the given transaction has a valid signature based on public-key encryption.\n *\n * @param tx - A transaction to verify the signature of. (Can be in object or encoded string format).\n * @returns Returns true if tx has a valid signature, and returns false otherwise.\n * @category Utilities\n */\nfunction verifySignature(tx: Transaction | string): boolean {\n const decodedTx: Transaction = getDecodedTransaction(tx)\n return verify(\n encodeForSigning(decodedTx),\n decodedTx.TxnSignature,\n decodedTx.SigningPubKey,\n )\n}\n\n/**\n * The transactions should all be equal except for the 'Signers' field.\n *\n * @param transactions - An array of Transactions which are expected to be equal other than 'Signers'.\n * @throws ValidationError if the transactions are not equal in any field other than 'Signers'.\n */\nfunction validateTransactionEquivalence(transactions: Transaction[]): void {\n const exampleTransaction = JSON.stringify({\n ...transactions[0],\n Signers: null,\n })\n if (\n transactions\n .slice(1)\n .some(\n (tx) => JSON.stringify({ ...tx, Signers: null }) !== exampleTransaction,\n )\n ) {\n throw new ValidationError(\n 'txJSON is not the same for all signedTransactions',\n )\n }\n}\n\nfunction getTransactionWithAllSigners(\n transactions: Transaction[],\n): Transaction {\n // Signers must be sorted in the combined transaction - See compareSigners' documentation for more details\n const sortedSigners: Signer[] = flatMap(\n transactions,\n (tx) => tx.Signers ?? [],\n ).sort(compareSigners)\n\n return { ...transactions[0], Signers: sortedSigners }\n}\n\n/**\n * If presented in binary form, the Signers array must be sorted based on\n * the numeric value of the signer addresses, with the lowest value first.\n * (If submitted as JSON, the submit_multisigned method handles this automatically.)\n * https://xrpl.org/multi-signing.html.\n *\n * @param left - A Signer to compare with.\n * @param right - A second Signer to compare with.\n * @returns 1 if left \\> right, 0 if left = right, -1 if left \\< right, and null if left or right are NaN.\n */\nfunction compareSigners(left: Signer, right: Signer): number {\n return addressToBigNumber(left.Signer.Account).comparedTo(\n addressToBigNumber(right.Signer.Account),\n )\n}\n\nfunction addressToBigNumber(address: string): BigNumber {\n const hex = Buffer.from(decodeAccountID(address)).toString('hex')\n const numberOfBitsInHex = 16\n return new BigNumber(hex, numberOfBitsInHex)\n}\n\nfunction getDecodedTransaction(txOrBlob: Transaction | string): Transaction {\n if (typeof txOrBlob === 'object') {\n // We need this to handle X-addresses in multisigning\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- We are casting here to get strong typing\n return decode(encode(txOrBlob)) as unknown as Transaction\n }\n\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- We are casting here to get strong typing\n return decode(txOrBlob) as unknown as Transaction\n}\n\nexport { authorizeChannel, verifySignature, multisign }\n","import { Client, ClientOptions } from '.'\n\n/**\n * Client that can rely on multiple different servers.\n *\n * @deprecated since version 2.2.0.\n * Will be deleted in version 3.0.0.\n *\n * Currently this implementation does not provide better reliability.\n * To get better reliability, implement reconnect/error handling logic\n * and choose a reliable endpoint.\n *\n * If you need the ability to fall-back to different endpoints, consider\n * using [xrpl-client](https://github.com/XRPL-Labs/xrpl-client/)\n *\n * @category Clients\n */\nexport default class BroadcastClient extends Client {\n private readonly clients: Client[]\n\n /**\n * Creates a new BroadcastClient.\n *\n * @category Constructor\n * @param servers - An array of names of servers.\n * @param options - Options for the clients.\n */\n public constructor(servers: string[], options: ClientOptions = {}) {\n super(servers[0], options)\n\n const clients: Client[] = servers.map(\n (server) => new Client(server, options),\n )\n\n this.clients = clients\n this.getMethodNames().forEach((name: string) => {\n this[name] = async (...args): Promise<unknown> =>\n /* eslint-disable @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call -- Generates types\n from the Client */\n Promise.race(clients.map(async (client) => client[name](...args)))\n /* eslint-enable @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call */\n })\n\n // connection methods must be overridden to apply to all client instances\n this.connect = async (): Promise<void> => {\n await Promise.all(clients.map(async (client) => client.connect()))\n }\n this.disconnect = async (): Promise<void> => {\n await Promise.all(clients.map(async (client) => client.disconnect()))\n }\n this.isConnected = (): boolean =>\n clients.map((client) => client.isConnected()).every(Boolean)\n\n clients.forEach((client) => {\n client.on('error', (errorCode, errorMessage, data) =>\n this.emit('error', errorCode, errorMessage, data),\n )\n })\n }\n\n /**\n * Gets the method names of all the methods of the client.\n *\n * @returns A list of the names of all the methods of the client.\n */\n private getMethodNames(): string[] {\n const methodNames: string[] = []\n const firstClient = this.clients[0]\n const methods = Object.getOwnPropertyNames(firstClient)\n methods.push(\n ...Object.getOwnPropertyNames(Object.getPrototypeOf(firstClient)),\n )\n for (const name of methods) {\n if (\n typeof firstClient[name] === 'function' &&\n name !== 'constructor' &&\n name !== 'on'\n ) {\n methodNames.push(name)\n }\n }\n return methodNames\n }\n}\n","/**\n * Manage all the requests made to the websocket, and their async responses\n * that come in from the WebSocket. Because they come in over the WS connection\n * after-the-fact.\n */\nexport default class ConnectionManager {\n private promisesAwaitingConnection: Array<{\n resolve: (value?: void | PromiseLike<void>) => void\n reject: (value?: Error) => void\n }> = []\n\n /**\n * Resolves all awaiting connections.\n */\n public resolveAllAwaiting(): void {\n this.promisesAwaitingConnection.map(({ resolve }) => resolve())\n this.promisesAwaitingConnection = []\n }\n\n /**\n * Rejects all awaiting connections.\n *\n * @param error - Error to throw in the rejection.\n */\n public rejectAllAwaiting(error: Error): void {\n this.promisesAwaitingConnection.map(({ reject }) => reject(error))\n this.promisesAwaitingConnection = []\n }\n\n /**\n * Await a new connection.\n *\n * @returns A promise for resolving the connection.\n */\n public async awaitConnection(): Promise<void> {\n return new Promise((resolve, reject) => {\n this.promisesAwaitingConnection.push({ resolve, reject })\n })\n }\n}\n","/*\n * Original code based on \"backo\" - https://github.com/segmentio/backo\n * MIT License - Copyright 2014 Segment.io\n * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation\n * files (the \"Software\"), to deal in the Software without restriction, including without limitation the rights to use, copy,\n * modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software\n * is furnished to do so, subject to the following conditions:\n * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE\n * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\n * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,\n * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n */\n\ninterface ExponentialBackoffOptions {\n // The min backoff duration.\n min?: number\n // The max backoff duration.\n max?: number\n}\n\nconst DEFAULT_MIN = 100\nconst DEFAULT_MAX = 1000\n\n/**\n * A Back off strategy that increases exponentially. Useful with repeated\n * setTimeout calls over a network (where the destination may be down).\n */\nexport default class ExponentialBackoff {\n private readonly ms: number\n private readonly max: number\n private readonly factor: number = 2\n private numAttempts = 0\n\n /**\n * Constructs an ExponentialBackoff object.\n *\n * @param opts - The options for the object.\n */\n public constructor(opts: ExponentialBackoffOptions = {}) {\n this.ms = opts.min ?? DEFAULT_MIN\n this.max = opts.max ?? DEFAULT_MAX\n }\n\n /**\n * Number of attempts for backoff so far.\n *\n * @returns Number of attempts.\n */\n public get attempts(): number {\n return this.numAttempts\n }\n\n /**\n * Return the backoff duration.\n *\n * @returns The backoff duration in milliseconds.\n */\n public duration(): number {\n const ms = this.ms * this.factor ** this.numAttempts\n this.numAttempts += 1\n return Math.floor(Math.min(ms, this.max))\n }\n\n /**\n * Reset the number of attempts.\n */\n public reset(): void {\n this.numAttempts = 0\n }\n}\n","import {\n ResponseFormatError,\n RippledError,\n TimeoutError,\n XrplError,\n} from '../errors'\nimport { Response } from '../models/methods'\nimport { BaseRequest, ErrorResponse } from '../models/methods/baseMethod'\n\n/**\n * Manage all the requests made to the websocket, and their async responses\n * that come in from the WebSocket. Responses come in over the WS connection\n * after-the-fact, so this manager will tie that response to resolve the\n * original request.\n */\nexport default class RequestManager {\n private nextId = 0\n private readonly promisesAwaitingResponse = new Map<\n string | number,\n {\n resolve: (value: Response | PromiseLike<Response>) => void\n reject: (value: Error) => void\n timer: ReturnType<typeof setTimeout>\n }\n >()\n\n /**\n * Successfully resolves a request.\n *\n * @param id - ID of the request.\n * @param response - Response to return.\n * @throws Error if no existing promise with the given ID.\n */\n public resolve(id: string | number, response: Response): void {\n const promise = this.promisesAwaitingResponse.get(id)\n if (promise == null) {\n throw new XrplError(`No existing promise with id ${id}`, {\n type: 'resolve',\n response,\n })\n }\n clearTimeout(promise.timer)\n promise.resolve(response)\n this.deletePromise(id)\n }\n\n /**\n * Rejects a request.\n *\n * @param id - ID of the request.\n * @param error - Error to throw with the reject.\n * @throws Error if no existing promise with the given ID.\n */\n public reject(id: string | number, error: Error): void {\n const promise = this.promisesAwaitingResponse.get(id)\n if (promise == null) {\n throw new XrplError(`No existing promise with id ${id}`, {\n type: 'reject',\n error,\n })\n }\n clearTimeout(promise.timer)\n // TODO: figure out how to have a better stack trace for an error\n promise.reject(error)\n this.deletePromise(id)\n }\n\n /**\n * Reject all pending requests.\n *\n * @param error - Error to throw with the reject.\n */\n public rejectAll(error: Error): void {\n this.promisesAwaitingResponse.forEach((_promise, id, _map) => {\n this.reject(id, error)\n this.deletePromise(id)\n })\n }\n\n /**\n * Creates a new WebSocket request. This sets up a timeout timer to catch\n * hung responses, and a promise that will resolve with the response once\n * the response is seen & handled.\n *\n * @param request - Request to create.\n * @param timeout - Timeout length to catch hung responses.\n * @returns Request ID, new request form, and the promise for resolving the request.\n * @throws XrplError if request with the same ID is already pending.\n */\n public createRequest<T extends BaseRequest>(\n request: T,\n timeout: number,\n ): [string | number, string, Promise<Response>] {\n let newId: string | number\n if (request.id == null) {\n newId = this.nextId\n this.nextId += 1\n } else {\n newId = request.id\n }\n const newRequest = JSON.stringify({ ...request, id: newId })\n // Typing required for Jest running in browser\n const timer: ReturnType<typeof setTimeout> = setTimeout(() => {\n this.reject(\n newId,\n new TimeoutError(\n `Timeout for request: ${JSON.stringify(request)} with id ${newId}`,\n request,\n ),\n )\n }, timeout)\n /*\n * Node.js won't exit if a timer is still running, so we tell Node to ignore.\n * (Node will still wait for the request to complete).\n */\n // The following type assertions are required to get this code to pass in browser environments\n // where setTimeout has a different type\n // eslint-disable-next-line max-len -- Necessary to disable both rules.\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access -- Reason above.\n if ((timer as unknown as any).unref) {\n // eslint-disable-next-line max-len -- Necessary to disable both rules.\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call -- Reason above.\n ;(timer as unknown as any).unref()\n }\n if (this.promisesAwaitingResponse.has(newId)) {\n clearTimeout(timer)\n throw new XrplError(\n `Response with id '${newId}' is already pending`,\n request,\n )\n }\n const newPromise = new Promise<Response>(\n (resolve: (value: Response | PromiseLike<Response>) => void, reject) => {\n this.promisesAwaitingResponse.set(newId, { resolve, reject, timer })\n },\n )\n\n return [newId, newRequest, newPromise]\n }\n\n /**\n * Handle a \"response\". Responses match to the earlier request handlers,\n * and resolve/reject based on the data received.\n *\n * @param response - The response to handle.\n * @throws ResponseFormatError if the response format is invalid, RippledError if rippled returns an error.\n */\n public handleResponse(response: Partial<Response | ErrorResponse>): void {\n if (\n response.id == null ||\n !(typeof response.id === 'string' || typeof response.id === 'number')\n ) {\n throw new ResponseFormatError('valid id not found in response', response)\n }\n if (!this.promisesAwaitingResponse.has(response.id)) {\n return\n }\n if (response.status == null) {\n const error = new ResponseFormatError('Response has no status')\n this.reject(response.id, error)\n }\n if (response.status === 'error') {\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- We know this must be true\n const errorResponse = response as Partial<ErrorResponse>\n const error = new RippledError(\n errorResponse.error_message ?? errorResponse.error,\n errorResponse,\n )\n this.reject(response.id, error)\n return\n }\n if (response.status !== 'success') {\n const error = new ResponseFormatError(\n `unrecognized response.status: ${response.status ?? ''}`,\n response,\n )\n this.reject(response.id, error)\n return\n }\n // status no longer needed because error is thrown if status is not \"success\"\n delete response.status\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Must be a valid Response here\n this.resolve(response.id, response as unknown as Response)\n }\n\n /**\n * Delete a promise after it has been returned.\n *\n * @param id - ID of the request.\n */\n private deletePromise(id: string | number): void {\n this.promisesAwaitingResponse.delete(id)\n }\n}\n","/* eslint-disable max-classes-per-file -- Needs to be a wrapper for ws */\nimport { EventEmitter } from 'events'\n\n// Define the global WebSocket class found on the native browser\ndeclare class WebSocket {\n public onclose?: (closeEvent: CloseEvent) => void\n public onopen?: (openEvent: Event) => void\n public onerror?: (error: Error) => void\n public onmessage?: (message: MessageEvent) => void\n public readyState: number\n public constructor(url: string)\n public close(code?: number, reason?: Buffer): void\n public send(message: string): void\n}\n\ninterface WSWrapperOptions {\n perMessageDeflate: boolean\n handshakeTimeout: number\n protocolVersion: number\n origin: string\n maxPayload: number\n followRedirects: boolean\n maxRedirects: number\n}\n\n/**\n * Provides `EventEmitter` interface for native browser `WebSocket`,\n * same, as `ws` package provides.\n */\nexport default class WSWrapper extends EventEmitter {\n public static CONNECTING = 0\n public static OPEN = 1\n public static CLOSING = 2\n // eslint-disable-next-line @typescript-eslint/no-magic-numbers -- magic number is being defined here\n public static CLOSED = 3\n private readonly ws: WebSocket\n\n /**\n * Constructs a browser-safe websocket.\n *\n * @param url - URL to connect to.\n * @param _protocols - Not used.\n * @param _websocketOptions - Not used.\n */\n public constructor(\n url: string,\n _protocols: string | string[] | WSWrapperOptions | undefined,\n _websocketOptions: WSWrapperOptions,\n ) {\n super()\n this.setMaxListeners(Infinity)\n\n this.ws = new WebSocket(url)\n\n this.ws.onclose = (closeEvent: CloseEvent): void => {\n let reason: Uint8Array | undefined\n if (closeEvent.reason) {\n const enc = new TextEncoder()\n reason = enc.encode(closeEvent.reason)\n }\n this.emit('close', closeEvent.code, reason)\n }\n\n this.ws.onopen = (): void => {\n this.emit('open')\n }\n\n this.ws.onerror = (error): void => {\n this.emit('error', error)\n }\n\n this.ws.onmessage = (message: MessageEvent): void => {\n this.emit('message', message.data)\n }\n }\n\n /**\n * Get the ready state of the websocket.\n *\n * @returns The Websocket's ready state.\n */\n public get readyState(): number {\n return this.ws.readyState\n }\n\n /**\n * Closes the websocket.\n *\n * @param code - Close code.\n * @param reason - Close reason.\n */\n public close(code?: number, reason?: Buffer): void {\n if (this.readyState === 1) {\n this.ws.close(code, reason)\n }\n }\n\n /**\n * Sends a message over the Websocket connection.\n *\n * @param message - Message to send.\n */\n public send(message: string): void {\n this.ws.send(message)\n }\n}\n","/* eslint-disable max-lines -- Connection is a large file w/ lots of imports/exports */\nimport { EventEmitter } from 'events'\nimport { Agent } from 'http'\n\nimport omitBy from 'lodash/omitBy'\nimport WebSocket from 'ws'\n\nimport {\n DisconnectedError,\n NotConnectedError,\n ConnectionError,\n XrplError,\n} from '../errors'\nimport { BaseRequest } from '../models/methods/baseMethod'\n\nimport ConnectionManager from './ConnectionManager'\nimport ExponentialBackoff from './ExponentialBackoff'\nimport RequestManager from './RequestManager'\n\nconst SECONDS_PER_MINUTE = 60\nconst TIMEOUT = 20\nconst CONNECTION_TIMEOUT = 5\n\n/**\n * ConnectionOptions is the configuration for the Connection class.\n */\ninterface ConnectionOptions {\n trace?: boolean | ((id: string, message: string) => void)\n proxy?: string\n proxyAuthorization?: string\n authorization?: string\n trustedCertificates?: string[]\n key?: string\n passphrase?: string\n certificate?: string\n // request timeout\n timeout: number\n connectionTimeout: number\n headers?: { [key: string]: string }\n}\n\n/**\n * ConnectionUserOptions is the user-provided configuration object. All configuration\n * is optional, so any ConnectionOptions configuration that has a default value is\n * still optional at the point that the user provides it.\n */\nexport type ConnectionUserOptions = Partial<ConnectionOptions>\n\n/**\n * Represents an intentionally triggered web-socket disconnect code.\n * WebSocket spec allows 4xxx codes for app/library specific codes.\n * See: https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent\n */\nexport const INTENTIONAL_DISCONNECT_CODE = 4000\n\ntype WebsocketState = 0 | 1 | 2 | 3\n\nfunction getAgent(url: string, config: ConnectionOptions): Agent | undefined {\n if (config.proxy == null) {\n return undefined\n }\n\n const parsedURL = new URL(url)\n const parsedProxyURL = new URL(config.proxy)\n\n const proxyOptions = omitBy(\n {\n secureEndpoint: parsedURL.protocol === 'wss:',\n secureProxy: parsedProxyURL.protocol === 'https:',\n auth: config.proxyAuthorization,\n ca: config.trustedCertificates,\n key: config.key,\n passphrase: config.passphrase,\n cert: config.certificate,\n href: parsedProxyURL.href,\n origin: parsedProxyURL.origin,\n protocol: parsedProxyURL.protocol,\n username: parsedProxyURL.username,\n password: parsedProxyURL.password,\n host: parsedProxyURL.host,\n hostname: parsedProxyURL.hostname,\n port: parsedProxyURL.port,\n pathname: parsedProxyURL.pathname,\n search: parsedProxyURL.search,\n hash: parsedProxyURL.hash,\n },\n (value) => value == null,\n )\n\n let HttpsProxyAgent: new (opt: typeof proxyOptions) => Agent\n try {\n /* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-require-imports,\n node/global-require, global-require, -- Necessary for the `require` */\n HttpsProxyAgent = require('https-proxy-agent')\n /* eslint-enable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-require-imports,\n node/global-require, global-require, */\n } catch (_error) {\n throw new Error('\"proxy\" option is not supported in the browser')\n }\n\n return new HttpsProxyAgent(proxyOptions)\n}\n\n/**\n * Create a new websocket given your URL and optional proxy/certificate\n * configuration.\n *\n * @param url - The URL to connect to.\n * @param config - THe configuration options for the WebSocket.\n * @returns A Websocket that fits the given configuration parameters.\n */\nfunction createWebSocket(\n url: string,\n config: ConnectionOptions,\n): WebSocket | null {\n const options: WebSocket.ClientOptions = {}\n options.agent = getAgent(url, config)\n if (config.headers) {\n options.headers = config.headers\n }\n if (config.authorization != null) {\n const base64 = Buffer.from(config.authorization).toString('base64')\n options.headers = {\n ...options.headers,\n Authorization: `Basic ${base64}`,\n }\n }\n const optionsOverrides = omitBy(\n {\n ca: config.trustedCertificates,\n key: config.key,\n passphrase: config.passphrase,\n cert: config.certificate,\n },\n (value) => value == null,\n )\n const websocketOptions = { ...options, ...optionsOverrides }\n const websocket = new WebSocket(url, websocketOptions)\n /*\n * we will have a listener for each outstanding request,\n * so we have to raise the limit (the default is 10)\n */\n if (typeof websocket.setMaxListeners === 'function') {\n websocket.setMaxListeners(Infinity)\n }\n return websocket\n}\n\n/**\n * Ws.send(), but promisified.\n *\n * @param ws - Websocket to send with.\n * @param message - Message to send.\n * @returns When the message has been sent.\n */\nasync function websocketSendAsync(\n ws: WebSocket,\n message: string,\n): Promise<void> {\n return new Promise<void>((resolve, reject) => {\n ws.send(message, (error) => {\n if (error) {\n reject(new DisconnectedError(error.message, error))\n } else {\n resolve()\n }\n })\n })\n}\n\n/**\n * The main Connection class. Responsible for connecting to & managing\n * an active WebSocket connection to a XRPL node.\n */\nexport class Connection extends EventEmitter {\n private readonly url: string | undefined\n private ws: WebSocket | null = null\n // Typing necessary for Jest tests running in browser\n private reconnectTimeoutID: null | ReturnType<typeof setTimeout> = null\n // Typing necessary for Jest tetsts running in browser\n private heartbeatIntervalID: null | ReturnType<typeof setTimeout> = null\n private readonly retryConnectionBackoff = new ExponentialBackoff({\n min: 100,\n max: SECONDS_PER_MINUTE * 1000,\n })\n\n private readonly config: ConnectionOptions\n private readonly requestManager = new RequestManager()\n private readonly connectionManager = new ConnectionManager()\n\n /**\n * Creates a new Connection object.\n *\n * @param url - URL to connect to.\n * @param options - Options for the Connection object.\n */\n public constructor(url?: string, options: ConnectionUserOptions = {}) {\n super()\n this.setMaxListeners(Infinity)\n this.url = url\n this.config = {\n timeout: TIMEOUT * 1000,\n connectionTimeout: CONNECTION_TIMEOUT * 1000,\n ...options,\n }\n if (typeof options.trace === 'function') {\n this.trace = options.trace\n } else if (options.trace) {\n // eslint-disable-next-line no-console -- Used for tracing only\n this.trace = console.log\n }\n }\n\n /**\n * Gets the state of the websocket.\n *\n * @returns The Websocket's ready state.\n */\n private get state(): WebsocketState {\n return this.ws ? this.ws.readyState : WebSocket.CLOSED\n }\n\n /**\n * Returns whether the server should be connected.\n *\n * @returns Whether the server should be connected.\n */\n private get shouldBeConnected(): boolean {\n return this.ws !== null\n }\n\n /**\n * Returns whether the websocket is connected.\n *\n * @returns Whether the websocket connection is open.\n */\n public isConnected(): boolean {\n return this.state === WebSocket.OPEN\n }\n\n /**\n * Connects the websocket to the provided URL.\n *\n * @returns When the websocket is connected.\n * @throws ConnectionError if there is a connection error, RippleError if there is already a WebSocket in existence.\n */\n // eslint-disable-next-line max-lines-per-function -- Necessary\n public async connect(): Promise<void> {\n if (this.isConnected()) {\n return Promise.resolve()\n }\n if (this.state === WebSocket.CONNECTING) {\n return this.connectionManager.awaitConnection()\n }\n if (!this.url) {\n return Promise.reject(\n new ConnectionError('Cannot connect because no server was specified'),\n )\n }\n if (this.ws != null) {\n return Promise.reject(\n new XrplError('Websocket connection never cleaned up.', {\n state: this.state,\n }),\n )\n }\n\n // Create the connection timeout, in case the connection hangs longer than expected.\n const connectionTimeoutID: ReturnType<typeof setTimeout> = setTimeout(\n () => {\n this.onConnectionFailed(\n new ConnectionError(\n `Error: connect() timed out after ${this.config.connectionTimeout} ms. If your internet connection is working, the ` +\n `rippled server may be blocked or inaccessible. You can also try setting the 'connectionTimeout' option in the Client constructor.`,\n ),\n )\n },\n this.config.connectionTimeout,\n )\n // Connection listeners: these stay attached only until a connection is done/open.\n this.ws = createWebSocket(this.url, this.config)\n\n if (this.ws == null) {\n throw new XrplError('Connect: created null websocket')\n }\n\n this.ws.on('error', (error) => this.onConnectionFailed(error))\n this.ws.on('error', () => clearTimeout(connectionTimeoutID))\n this.ws.on('close', (reason) => this.onConnectionFailed(reason))\n this.ws.on('close', () => clearTimeout(connectionTimeoutID))\n this.ws.once('open', () => {\n void this.onceOpen(connectionTimeoutID)\n })\n return this.connectionManager.awaitConnection()\n }\n\n /**\n * Disconnect the websocket connection.\n * We never expect this method to reject. Even on \"bad\" disconnects, the websocket\n * should still successfully close with the relevant error code returned.\n * See https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent for the full list.\n * If no open websocket connection exists, resolve with no code (`undefined`).\n *\n * @returns A promise containing either `undefined` or a disconnected code, that resolves when the connection is destroyed.\n */\n public async disconnect(): Promise<number | undefined> {\n this.clearHeartbeatInterval()\n if (this.reconnectTimeoutID !== null) {\n clearTimeout(this.reconnectTimeoutID)\n this.reconnectTimeoutID = null\n }\n if (this.state === WebSocket.CLOSED) {\n return Promise.resolve(undefined)\n }\n if (this.ws == null) {\n return Promise.resolve(undefined)\n }\n\n return new Promise((resolve) => {\n if (this.ws == null) {\n resolve(undefined)\n }\n if (this.ws != null) {\n this.ws.once('close', (code) => resolve(code))\n }\n /*\n * Connection already has a disconnect handler for the disconnect logic.\n * Just close the websocket manually (with our \"intentional\" code) to\n * trigger that.\n */\n if (this.ws != null && this.state !== WebSocket.CLOSING) {\n this.ws.close(INTENTIONAL_DISCONNECT_CODE)\n }\n })\n }\n\n /**\n * Disconnect the websocket, then connect again.\n */\n public async reconnect(): Promise<void> {\n /*\n * NOTE: We currently have a \"reconnecting\" event, but that only triggers\n * through an unexpected connection retry logic.\n * See: https://github.com/XRPLF/xrpl.js/pull/1101#issuecomment-565360423\n */\n this.emit('reconnect')\n await this.disconnect()\n await this.connect()\n }\n\n /**\n * Sends a request to the rippled server.\n *\n * @param request - The request to send to the server.\n * @param timeout - How long the Connection instance should wait before assuming that there will not be a response.\n * @returns The response from the rippled server.\n * @throws NotConnectedError if the Connection isn't connected to a server.\n */\n public async request<T extends BaseRequest>(\n request: T,\n timeout?: number,\n ): Promise<unknown> {\n if (!this.shouldBeConnected || this.ws == null) {\n throw new NotConnectedError(JSON.stringify(request), request)\n }\n const [id, message, responsePromise] = this.requestManager.createRequest(\n request,\n timeout ?? this.config.timeout,\n )\n this.trace('send', message)\n websocketSendAsync(this.ws, message).catch((error) => {\n this.requestManager.reject(id, error)\n })\n\n return responsePromise\n }\n\n /**\n * Get the Websocket connection URL.\n *\n * @returns The Websocket connection URL.\n */\n public getUrl(): string {\n return this.url ?? ''\n }\n\n // eslint-disable-next-line @typescript-eslint/no-empty-function, class-methods-use-this -- Does nothing on default\n public readonly trace: (id: string, message: string) => void = () => {}\n\n /**\n * Handler for when messages are received from the server.\n *\n * @param message - The message received from the server.\n */\n private onMessage(message): void {\n this.trace('receive', message)\n let data: Record<string, unknown>\n try {\n // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- Must be a JSON dictionary\n data = JSON.parse(message)\n } catch (error) {\n if (error instanceof Error) {\n this.emit('error', 'badMessage', error.message, message)\n }\n return\n }\n if (data.type == null && data.error) {\n // e.g. slowDown\n this.emit('error', data.error, data.error_message, data)\n return\n }\n if (data.type) {\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Should be true\n this.emit(data.type as string, data)\n }\n if (data.type === 'response') {\n try {\n this.requestManager.handleResponse(data)\n } catch (error) {\n // eslint-disable-next-line max-depth -- okay here\n if (error instanceof Error) {\n this.emit('error', 'badMessage', error.message, message)\n } else {\n this.emit('error', 'badMessage', error, error)\n }\n }\n }\n }\n\n /**\n * Handler for what to do once the connection to the server is open.\n *\n * @param connectionTimeoutID - Timeout in case the connection hangs longer than expected.\n * @returns A promise that resolves to void when the connection is fully established.\n * @throws Error if the websocket initialized is somehow null.\n */\n // eslint-disable-next-line max-lines-per-function -- Many error code conditionals to check.\n private async onceOpen(\n connectionTimeoutID: ReturnType<typeof setTimeout>,\n ): Promise<void> {\n if (this.ws == null) {\n throw new XrplError('onceOpen: ws is null')\n }\n\n // Once the connection completes successfully, remove all old listeners\n this.ws.removeAllListeners()\n clearTimeout(connectionTimeoutID)\n // Add new, long-term connected listeners for messages and errors\n this.ws.on('message', (message: string) => this.onMessage(message))\n this.ws.on('error', (error) =>\n this.emit('error', 'websocket', error.message, error),\n )\n // Handle a closed connection: reconnect if it was unexpected\n this.ws.once('close', (code?: number, reason?: Buffer) => {\n if (this.ws == null) {\n throw new XrplError('onceClose: ws is null')\n }\n\n this.clearHeartbeatInterval()\n this.requestManager.rejectAll(\n new DisconnectedError(\n `websocket was closed, ${new TextDecoder('utf-8').decode(reason)}`,\n ),\n )\n this.ws.removeAllListeners()\n this.ws = null\n\n if (code === undefined) {\n // Useful to keep this code for debugging purposes.\n // const reasonText = reason ? reason.toString() : 'undefined'\n // // eslint-disable-next-line no-console -- The error is helpful for debugging.\n // console.error(\n // `Disconnected but the disconnect code was undefined (The given reason was ${reasonText}).` +\n // `This could be caused by an exception being thrown during a 'connect' callback. ` +\n // `Disconnecting with code 1011 to indicate an internal error has occurred.`,\n // )\n\n /*\n * Error code 1011 represents an Internal Error according to\n * https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/code\n */\n const internalErrorCode = 1011\n this.emit('disconnected', internalErrorCode)\n } else {\n this.emit('disconnected', code)\n }\n\n /*\n * If this wasn't a manual disconnect, then lets reconnect ASAP.\n * Code can be undefined if there's an exception while connecting.\n */\n if (code !== INTENTIONAL_DISCONNECT_CODE && code !== undefined) {\n this.intentionalDisconnect()\n }\n })\n // Finalize the connection and resolve all awaiting connect() requests\n try {\n this.retryConnectionBackoff.reset()\n this.startHeartbeatInterval()\n this.connectionManager.resolveAllAwaiting()\n this.emit('connected')\n } catch (error) {\n if (error instanceof Error) {\n this.connectionManager.rejectAllAwaiting(error)\n // Ignore this error, propagate the root cause.\n // eslint-disable-next-line @typescript-eslint/no-empty-function -- Need empty catch\n await this.disconnect().catch(() => {})\n }\n }\n }\n\n private intentionalDisconnect(): void {\n const retryTimeout = this.retryConnectionBackoff.duration()\n this.trace('reconnect', `Retrying connection in ${retryTimeout}ms.`)\n this.emit('reconnecting', this.retryConnectionBackoff.attempts)\n /*\n * Start the reconnect timeout, but set it to `this.reconnectTimeoutID`\n * so that we can cancel one in-progress on disconnect.\n */\n this.reconnectTimeoutID = setTimeout(() => {\n this.reconnect().catch((error: Error) => {\n this.emit('error', 'reconnect', error.message, error)\n })\n }, retryTimeout)\n }\n\n /**\n * Clears the heartbeat connection interval.\n */\n private clearHeartbeatInterval(): void {\n if (this.heartbeatIntervalID) {\n clearInterval(this.heartbeatIntervalID)\n }\n }\n\n /**\n * Starts a heartbeat to check the connection with the server.\n */\n private startHeartbeatInterval(): void {\n this.clearHeartbeatInterval()\n this.heartbeatIntervalID = setInterval(() => {\n void this.heartbeat()\n }, this.config.timeout)\n }\n\n /**\n * A heartbeat is just a \"ping\" command, sent on an interval.\n * If this succeeds, we're good. If it fails, disconnect so that the consumer can reconnect, if desired.\n *\n * @returns A Promise that resolves to void when the heartbeat returns successfully.\n */\n private async heartbeat(): Promise<void> {\n this.request({ command: 'ping' }).catch(async () => {\n return this.reconnect().catch((error: Error) => {\n this.emit('error', 'reconnect', error.message, error)\n })\n })\n }\n\n /**\n * Process a failed connection.\n *\n * @param errorOrCode - (Optional) Error or code for connection failure.\n */\n private onConnectionFailed(errorOrCode: Error | number | null): void {\n if (this.ws) {\n this.ws.removeAllListeners()\n this.ws.on('error', () => {\n /*\n * Correctly listen for -- but ignore -- any future errors: If you\n * don't have a listener on \"error\" node would log a warning on error.\n */\n })\n this.ws.close()\n this.ws = null\n }\n if (typeof errorOrCode === 'number') {\n this.connectionManager.rejectAllAwaiting(\n new NotConnectedError(`Connection failed with code ${errorOrCode}.`, {\n code: errorOrCode,\n }),\n )\n } else if (errorOrCode?.message) {\n this.connectionManager.rejectAllAwaiting(\n new NotConnectedError(errorOrCode.message, errorOrCode),\n )\n } else {\n this.connectionManager.rejectAllAwaiting(\n new NotConnectedError('Connection failed.'),\n )\n }\n }\n}\n","/* eslint-disable jsdoc/require-jsdoc -- Request has many aliases, but they don't need unique docs */\n/* eslint-disable @typescript-eslint/member-ordering -- TODO: remove when instance methods aren't members */\n/* eslint-disable max-lines -- Client is a large file w/ lots of imports/exports */\nimport * as assert from 'assert'\nimport { EventEmitter } from 'events'\n\nimport { NotFoundError, ValidationError, XrplError } from '../errors'\nimport {\n Request,\n Response,\n // account methods\n AccountChannelsRequest,\n AccountChannelsResponse,\n AccountCurrenciesRequest,\n AccountCurrenciesResponse,\n AccountInfoRequest,\n AccountInfoResponse,\n AccountLinesRequest,\n AccountLinesResponse,\n AccountNFTsRequest,\n AccountNFTsResponse,\n AccountObjectsRequest,\n AccountObjectsResponse,\n AccountOffersRequest,\n AccountOffersResponse,\n AccountTxRequest,\n AccountTxResponse,\n GatewayBalancesRequest,\n GatewayBalancesResponse,\n NoRippleCheckRequest,\n NoRippleCheckResponse,\n // ledger methods\n LedgerRequest,\n LedgerResponse,\n LedgerClosedRequest,\n LedgerClosedResponse,\n LedgerCurrentRequest,\n LedgerCurrentResponse,\n LedgerDataRequest,\n LedgerDataResponse,\n LedgerEntryRequest,\n LedgerEntryResponse,\n // transaction methods\n SubmitRequest,\n SubmitResponse,\n SubmitMultisignedRequest,\n SubmitMultisignedResponse,\n TransactionEntryRequest,\n TransactionEntryResponse,\n TxRequest,\n TxResponse,\n // path and order book methods\n BookOffersRequest,\n BookOffersResponse,\n DepositAuthorizedRequest,\n DepositAuthorizedResponse,\n PathFindRequest,\n PathFindResponse,\n RipplePathFindRequest,\n RipplePathFindResponse,\n // payment channel methods\n ChannelVerifyRequest,\n ChannelVerifyResponse,\n // server info methods\n FeeRequest,\n FeeResponse,\n ManifestRequest,\n ManifestResponse,\n ServerInfoRequest,\n ServerInfoResponse,\n ServerStateRequest,\n ServerStateResponse,\n // utility methods\n PingRequest,\n PingResponse,\n RandomRequest,\n RandomResponse,\n LedgerStream,\n ValidationStream,\n TransactionStream,\n PathFindStream,\n PeerStatusStream,\n ConsensusStream,\n SubscribeRequest,\n SubscribeResponse,\n UnsubscribeRequest,\n UnsubscribeResponse,\n // NFT methods\n NFTBuyOffersRequest,\n NFTBuyOffersResponse,\n NFTSellOffersRequest,\n NFTSellOffersResponse,\n} from '../models/methods'\nimport { BaseRequest, BaseResponse } from '../models/methods/baseMethod'\nimport {\n autofill,\n ensureClassicAddress,\n getLedgerIndex,\n getOrderbook,\n getBalances,\n getXrpBalance,\n submit,\n submitAndWait,\n} from '../sugar'\nimport fundWallet from '../Wallet/fundWallet'\n\nimport {\n Connection,\n ConnectionUserOptions,\n INTENTIONAL_DISCONNECT_CODE,\n} from './connection'\nimport {\n handlePartialPayment,\n handleStreamPartialPayment,\n} from './partialPayment'\n\nexport interface ClientOptions extends ConnectionUserOptions {\n feeCushion?: number\n maxFeeXRP?: string\n proxy?: string\n timeout?: number\n}\n\n/**\n * Get the response key / property name that contains the listed data for a\n * command. This varies from command to command, but we need to know it to\n * properly count across many requests.\n *\n * @param command - The rippled request command.\n * @returns The property key corresponding to the command.\n */\nfunction getCollectKeyFromCommand(command: string): string | null {\n switch (command) {\n case 'account_channels':\n return 'channels'\n case 'account_lines':\n return 'lines'\n case 'account_objects':\n return 'account_objects'\n case 'account_tx':\n return 'transactions'\n case 'account_offers':\n case 'book_offers':\n return 'offers'\n case 'ledger_data':\n return 'state'\n default:\n return null\n }\n}\n\nfunction clamp(value: number, min: number, max: number): number {\n assert.ok(min <= max, 'Illegal clamp bounds')\n return Math.min(Math.max(value, min), max)\n}\n\ninterface MarkerRequest extends BaseRequest {\n limit?: number\n marker?: unknown\n}\n\ninterface MarkerResponse extends BaseResponse {\n result: {\n marker?: unknown\n }\n}\n\nconst DEFAULT_FEE_CUSHION = 1.2\nconst DEFAULT_MAX_FEE_XRP = '2'\n\nconst MIN_LIMIT = 10\nconst MAX_LIMIT = 400\n\nconst NORMAL_DISCONNECT_CODE = 1000\n\n/**\n * Client for interacting with rippled servers.\n *\n * @category Clients\n */\nclass Client extends EventEmitter {\n /*\n * Underlying connection to rippled.\n */\n public readonly connection: Connection\n\n /**\n * Factor to multiply estimated fee by to provide a cushion in case the\n * required fee rises during submission of a transaction. Defaults to 1.2.\n *\n * @category Fee\n */\n public readonly feeCushion: number\n\n /**\n * Maximum transaction cost to allow, in decimal XRP. Must be a string-encoded\n * number. Defaults to '2'.\n *\n * @category Fee\n */\n public readonly maxFeeXRP: string\n\n /**\n * Creates a new Client with a websocket connection to a rippled server.\n *\n * @param server - URL of the server to connect to.\n * @param options - Options for client settings.\n * @category Constructor\n */\n // eslint-disable-next-line max-lines-per-function -- okay because we have to set up all the connection handlers\n public constructor(server: string, options: ClientOptions = {}) {\n super()\n if (typeof server !== 'string' || !/wss?(?:\\+unix)?:\\/\\//u.exec(server)) {\n throw new ValidationError(\n 'server URI must start with `wss://`, `ws://`, `wss+unix://`, or `ws+unix://`.',\n )\n }\n\n this.feeCushion = options.feeCushion ?? DEFAULT_FEE_CUSHION\n this.maxFeeXRP = options.maxFeeXRP ?? DEFAULT_MAX_FEE_XRP\n\n this.connection = new Connection(server, options)\n\n this.connection.on('error', (errorCode, errorMessage, data) => {\n this.emit('error', errorCode, errorMessage, data)\n })\n\n this.connection.on('connected', () => {\n this.emit('connected')\n })\n\n this.connection.on('disconnected', (code: number) => {\n let finalCode = code\n /*\n * 4000: Connection uses a 4000 code internally to indicate a manual disconnect/close\n * Since 4000 is a normal disconnect reason, we convert this to the standard exit code 1000\n */\n if (finalCode === INTENTIONAL_DISCONNECT_CODE) {\n finalCode = NORMAL_DISCONNECT_CODE\n }\n this.emit('disconnected', finalCode)\n })\n\n this.connection.on('ledgerClosed', (ledger) => {\n this.emit('ledgerClosed', ledger)\n })\n\n this.connection.on('transaction', (tx) => {\n // mutates `tx` to add warnings\n handleStreamPartialPayment(tx, this.connection.trace)\n this.emit('transaction', tx)\n })\n\n this.connection.on('validationReceived', (validation) => {\n this.emit('validationReceived', validation)\n })\n\n this.connection.on('manifestReceived', (manifest) => {\n this.emit('manifestReceived', manifest)\n })\n\n this.connection.on('peerStatusChange', (status) => {\n this.emit('peerStatusChange', status)\n })\n\n this.connection.on('consensusPhase', (consensus) => {\n this.emit('consensusPhase', consensus)\n })\n\n this.connection.on('path_find', (path) => {\n this.emit('path_find', path)\n })\n }\n\n /**\n * Get the url that the client is connected to.\n *\n * @returns The URL of the server this client is connected to.\n * @category Network\n */\n public get url(): string {\n return this.connection.getUrl()\n }\n\n /**\n * @category Network\n */\n public async request(\n r: AccountChannelsRequest,\n ): Promise<AccountChannelsResponse>\n public async request(\n r: AccountCurrenciesRequest,\n ): Promise<AccountCurrenciesResponse>\n public async request(r: AccountInfoRequest): Promise<AccountInfoResponse>\n public async request(r: AccountLinesRequest): Promise<AccountLinesResponse>\n public async request(r: AccountNFTsRequest): Promise<AccountNFTsResponse>\n public async request(\n r: AccountObjectsRequest,\n ): Promise<AccountObjectsResponse>\n public async request(r: AccountOffersRequest): Promise<AccountOffersResponse>\n public async request(r: AccountTxRequest): Promise<AccountTxResponse>\n public async request(r: BookOffersRequest): Promise<BookOffersResponse>\n public async request(r: ChannelVerifyRequest): Promise<ChannelVerifyResponse>\n public async request(\n r: DepositAuthorizedRequest,\n ): Promise<DepositAuthorizedResponse>\n public async request(r: FeeRequest): Promise<FeeResponse>\n public async request(\n r: GatewayBalancesRequest,\n ): Promise<GatewayBalancesResponse>\n public async request(r: LedgerRequest): Promise<LedgerResponse>\n public async request(r: LedgerClosedRequest): Promise<LedgerClosedResponse>\n public async request(r: LedgerCurrentRequest): Promise<LedgerCurrentResponse>\n public async request(r: LedgerDataRequest): Promise<LedgerDataResponse>\n public async request(r: LedgerEntryRequest): Promise<LedgerEntryResponse>\n public async request(r: ManifestRequest): Promise<ManifestResponse>\n public async request(r: NFTBuyOffersRequest): Promise<NFTBuyOffersResponse>\n public async request(r: NFTSellOffersRequest): Promise<NFTSellOffersResponse>\n public async request(r: NoRippleCheckRequest): Promise<NoRippleCheckResponse>\n public async request(r: PathFindRequest): Promise<PathFindResponse>\n public async request(r: PingRequest): Promise<PingResponse>\n public async request(r: RandomRequest): Promise<RandomResponse>\n public async request(\n r: RipplePathFindRequest,\n ): Promise<RipplePathFindResponse>\n public async request(r: ServerInfoRequest): Promise<ServerInfoResponse>\n public async request(r: ServerStateRequest): Promise<ServerStateResponse>\n public async request(r: SubmitRequest): Promise<SubmitResponse>\n public async request(\n r: SubmitMultisignedRequest,\n ): Promise<SubmitMultisignedResponse>\n public request(r: SubscribeRequest): Promise<SubscribeResponse>\n public request(r: UnsubscribeRequest): Promise<UnsubscribeResponse>\n public async request(\n r: TransactionEntryRequest,\n ): Promise<TransactionEntryResponse>\n public async request(r: TxRequest): Promise<TxResponse>\n public async request<R extends BaseRequest, T extends BaseResponse>(\n r: R,\n ): Promise<T>\n /**\n * Makes a request to the client with the given command and\n * additional request body parameters.\n *\n * @param req - Request to send to the server.\n * @returns The response from the server.\n * @category Network\n */\n public async request<R extends Request, T extends Response>(\n req: R,\n ): Promise<T> {\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Necessary for overloading\n const response = (await this.connection.request({\n ...req,\n account: req.account\n ? // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Must be string\n ensureClassicAddress(req.account as string)\n : undefined,\n })) as T\n\n // mutates `response` to add warnings\n handlePartialPayment(req.command, response)\n\n return response\n }\n\n /**\n * @category Network\n */\n public async requestNextPage(\n req: AccountChannelsRequest,\n resp: AccountChannelsResponse,\n ): Promise<AccountChannelsResponse>\n public async requestNextPage(\n req: AccountLinesRequest,\n resp: AccountLinesResponse,\n ): Promise<AccountLinesResponse>\n public async requestNextPage(\n req: AccountObjectsRequest,\n resp: AccountObjectsResponse,\n ): Promise<AccountObjectsResponse>\n public async requestNextPage(\n req: AccountOffersRequest,\n resp: AccountOffersResponse,\n ): Promise<AccountOffersResponse>\n public async requestNextPage(\n req: AccountTxRequest,\n resp: AccountTxResponse,\n ): Promise<AccountTxResponse>\n public async requestNextPage(\n req: LedgerDataRequest,\n resp: LedgerDataResponse,\n ): Promise<LedgerDataResponse>\n /**\n * Requests the next page of data.\n *\n * @param req - Request to send.\n * @param resp - Response with the marker to use in the request.\n * @returns The response with the next page of data.\n */\n public async requestNextPage<\n T extends MarkerRequest,\n U extends MarkerResponse,\n >(req: T, resp: U): Promise<U> {\n if (!resp.result.marker) {\n return Promise.reject(\n new NotFoundError('response does not have a next page'),\n )\n }\n const nextPageRequest = { ...req, marker: resp.result.marker }\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Necessary for overloading\n return this.request(nextPageRequest) as unknown as U\n }\n\n /**\n * Event handler for subscription streams.\n *\n * @example\n * ```ts\n * const api = new Client('wss://s.altnet.rippletest.net:51233')\n *\n * api.on('transactions', (tx: TransactionStream) => {\n * console.log(\"Received Transaction\")\n * console.log(tx)\n * })\n *\n * await api.connect()\n * const response = await api.request({\n * command: 'subscribe',\n * streams: ['transactions_proposed']\n * })\n * ```\n *\n * @category Network\n */\n public on(event: 'connected', listener: () => void): this\n public on(event: 'disconnected', listener: (code: number) => void): this\n public on(\n event: 'ledgerClosed',\n listener: (ledger: LedgerStream) => void,\n ): this\n public on(\n event: 'validationReceived',\n listener: (validation: ValidationStream) => void,\n ): this\n public on(\n event: 'transaction',\n listener: (tx: TransactionStream) => void,\n ): this\n public on(\n event: 'peerStatusChange',\n listener: (status: PeerStatusStream) => void,\n ): this\n public on(\n event: 'consensusPhase',\n listener: (phase: ConsensusStream) => void,\n ): this\n public on(\n event: 'manifestReceived',\n listener: (manifest: ManifestResponse) => void,\n ): this\n public on(event: 'path_find', listener: (path: PathFindStream) => void): this\n // eslint-disable-next-line @typescript-eslint/no-explicit-any -- needs to be any for overload\n public on(event: 'error', listener: (...err: any[]) => void): this\n /**\n * Event handler for subscription streams.\n *\n * @param eventName - Name of the event. Only forwards streams.\n * @param listener - Function to run on event.\n * @returns This, because it inherits from EventEmitter.\n */\n // eslint-disable-next-line @typescript-eslint/no-explicit-any -- needs to be any for overload\n public on(eventName: string, listener: (...args: any[]) => void): this {\n return super.on(eventName, listener)\n }\n\n /**\n * @category Network\n */\n public async requestAll(\n req: AccountChannelsRequest,\n ): Promise<AccountChannelsResponse[]>\n public async requestAll(\n req: AccountLinesRequest,\n ): Promise<AccountLinesResponse[]>\n public async requestAll(\n req: AccountObjectsRequest,\n ): Promise<AccountObjectsResponse[]>\n public async requestAll(\n req: AccountOffersRequest,\n ): Promise<AccountOffersResponse[]>\n public async requestAll(req: AccountTxRequest): Promise<AccountTxResponse[]>\n public async requestAll(req: BookOffersRequest): Promise<BookOffersResponse[]>\n public async requestAll(req: LedgerDataRequest): Promise<LedgerDataResponse[]>\n /**\n * Makes multiple paged requests to the client to return a given number of\n * resources. Multiple paged requests will be made until the `limit`\n * number of resources is reached (if no `limit` is provided, a single request\n * will be made).\n *\n * If the command is unknown, an additional `collect` property is required to\n * know which response key contains the array of resources.\n *\n * NOTE: This command is used by existing methods and is not recommended for\n * general use. Instead, use rippled's built-in pagination and make multiple\n * requests as needed.\n *\n * @param request - The initial request to send to the server.\n * @param collect - (Optional) the param to use to collect the array of resources (only needed if command is unknown).\n * @returns The array of all responses.\n * @throws ValidationError if there is no collection key (either from a known command or for the unknown command).\n */\n public async requestAll<T extends MarkerRequest, U extends MarkerResponse>(\n request: T,\n collect?: string,\n ): Promise<U[]> {\n /*\n * The data under collection is keyed based on the command. Fail if command\n * not recognized and collection key not provided.\n */\n const collectKey = collect ?? getCollectKeyFromCommand(request.command)\n if (!collectKey) {\n throw new ValidationError(`no collect key for command ${request.command}`)\n }\n /*\n * If limit is not provided, fetches all data over multiple requests.\n * NOTE: This may return much more than needed. Set limit when possible.\n */\n const countTo: number = request.limit == null ? Infinity : request.limit\n let count = 0\n let marker: unknown = request.marker\n let lastBatchLength: number\n const results: U[] = []\n do {\n const countRemaining = clamp(countTo - count, MIN_LIMIT, MAX_LIMIT)\n const repeatProps = {\n ...request,\n limit: countRemaining,\n marker,\n }\n // eslint-disable-next-line no-await-in-loop -- Necessary for this, it really has to wait\n const singleResponse = await this.connection.request(repeatProps)\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Should be true\n const singleResult = (singleResponse as U).result\n if (!(collectKey in singleResult)) {\n throw new XrplError(`${collectKey} not in result`)\n }\n // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- Should be true\n const collectedData = singleResult[collectKey]\n marker = singleResult.marker\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Should be true\n results.push(singleResponse as U)\n // Make sure we handle when no data (not even an empty array) is returned.\n if (Array.isArray(collectedData)) {\n count += collectedData.length\n lastBatchLength = collectedData.length\n } else {\n lastBatchLength = 0\n }\n } while (Boolean(marker) && count < countTo && lastBatchLength !== 0)\n return results\n }\n\n /**\n * Tells the Client instance to connect to its rippled server.\n *\n * @returns A promise that resolves with a void value when a connection is established.\n * @category Network\n */\n public async connect(): Promise<void> {\n return this.connection.connect()\n }\n\n /**\n * Tells the Client instance to disconnect from it's rippled server.\n *\n * @returns A promise that resolves with a void value when a connection is destroyed.\n * @category Network\n */\n public async disconnect(): Promise<void> {\n /*\n * backwards compatibility: connection.disconnect() can return a number, but\n * this method returns nothing. SO we await but don't return any result.\n */\n await this.connection.disconnect()\n }\n\n /**\n * Checks if the Client instance is connected to its rippled server.\n *\n * @returns Whether the client instance is connected.\n * @category Network\n */\n public isConnected(): boolean {\n return this.connection.isConnected()\n }\n\n /**\n * @category Core\n */\n public autofill = autofill\n\n /**\n * @category Core\n */\n public submit = submit\n /**\n * @category Core\n */\n public submitAndWait = submitAndWait\n\n /**\n * @deprecated Use autofill instead, provided for users familiar with v1\n */\n public prepareTransaction = autofill\n\n /**\n * @category Abstraction\n */\n public getXrpBalance = getXrpBalance\n\n /**\n * @category Abstraction\n */\n public getBalances = getBalances\n\n /**\n * @category Abstraction\n */\n public getOrderbook = getOrderbook\n\n /**\n * @category Abstraction\n */\n public getLedgerIndex = getLedgerIndex\n\n /**\n * @category Faucet\n */\n public fundWallet = fundWallet\n}\n\nexport { Client }\n","import BigNumber from 'bignumber.js'\nimport { decode } from 'ripple-binary-codec'\n\nimport type {\n AccountTxResponse,\n Response,\n TransactionEntryResponse,\n TransactionStream,\n TxResponse,\n} from '..'\nimport type { Amount } from '../models/common'\nimport { PaymentFlags, Transaction } from '../models/transactions'\nimport type { TransactionMetadata } from '../models/transactions/metadata'\nimport { isFlagEnabled } from '../models/utils'\n\nconst WARN_PARTIAL_PAYMENT_CODE = 2001\n\nfunction amountsEqual(amt1: Amount, amt2: Amount): boolean {\n if (typeof amt1 === 'string' && typeof amt2 === 'string') {\n return amt1 === amt2\n }\n\n if (typeof amt1 === 'string' || typeof amt2 === 'string') {\n return false\n }\n\n const aValue = new BigNumber(amt1.value)\n const bValue = new BigNumber(amt2.value)\n\n return (\n amt1.currency === amt2.currency &&\n amt1.issuer === amt2.issuer &&\n aValue.isEqualTo(bValue)\n )\n}\n\nfunction isPartialPayment(\n tx?: Transaction,\n metadata?: TransactionMetadata | string,\n): boolean {\n if (tx == null || metadata == null || tx.TransactionType !== 'Payment') {\n return false\n }\n\n let meta = metadata\n if (typeof meta === 'string') {\n if (meta === 'unavailable') {\n return false\n }\n\n /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- binary-codec typing */\n meta = decode(meta) as unknown as TransactionMetadata\n }\n\n const tfPartial =\n typeof tx.Flags === 'number'\n ? isFlagEnabled(tx.Flags, PaymentFlags.tfPartialPayment)\n : tx.Flags?.tfPartialPayment\n\n if (!tfPartial) {\n return false\n }\n\n const delivered = meta.delivered_amount\n const amount = tx.Amount\n\n if (delivered === undefined) {\n return false\n }\n\n return !amountsEqual(delivered, amount)\n}\n\nfunction txHasPartialPayment(response: TxResponse): boolean {\n return isPartialPayment(response.result, response.result.meta)\n}\n\nfunction txEntryHasPartialPayment(response: TransactionEntryResponse): boolean {\n return isPartialPayment(response.result.tx_json, response.result.metadata)\n}\n\nfunction accountTxHasPartialPayment(response: AccountTxResponse): boolean {\n const { transactions } = response.result\n const foo = transactions.some((tx) => isPartialPayment(tx.tx, tx.meta))\n return foo\n}\n\nfunction hasPartialPayment(command: string, response: Response): boolean {\n /* eslint-disable @typescript-eslint/consistent-type-assertions -- Request type is known at runtime from command */\n switch (command) {\n case 'tx':\n return txHasPartialPayment(response as TxResponse)\n case 'transaction_entry':\n return txEntryHasPartialPayment(response as TransactionEntryResponse)\n case 'account_tx':\n return accountTxHasPartialPayment(response as AccountTxResponse)\n default:\n return false\n }\n /* eslint-enable @typescript-eslint/consistent-type-assertions */\n}\n\n/**\n * Checks a response for a partial payment.\n *\n * @param command - Command from the request, tells us what response to expect.\n * @param response - Response to check for a partial payment.\n */\nexport function handlePartialPayment(\n command: string,\n response: Response,\n): void {\n if (hasPartialPayment(command, response)) {\n const warnings = response.warnings ?? []\n\n const warning = {\n id: WARN_PARTIAL_PAYMENT_CODE,\n message: 'This response contains a Partial Payment',\n }\n\n warnings.push(warning)\n\n response.warnings = warnings\n }\n}\n\n/**\n * Check a transaction from a subscription stream for partial payment.\n *\n * @param stream - Stream Transaction to check for partial payment.\n * @param log - The method used for logging by the connection (to report the partial payment).\n */\nexport function handleStreamPartialPayment(\n stream: TransactionStream,\n log: (id: string, message: string) => void,\n): void {\n if (isPartialPayment(stream.transaction, stream.meta)) {\n const warnings = stream.warnings ?? []\n\n const warning = {\n id: WARN_PARTIAL_PAYMENT_CODE,\n message: 'This response contains a Partial Payment',\n }\n\n warnings.push(warning)\n\n /* eslint-disable-next-line no-param-reassign -- Handles the case where there are no warnings */\n stream.warnings = warnings\n\n log('Partial payment received', JSON.stringify(stream))\n }\n}\n","/* eslint-disable max-classes-per-file -- Errors can be defined in the same file */\nimport { inspect } from 'util'\n\n/**\n * Base Error class for xrpl.js. All Errors thrown by xrpl.js should throw\n * XrplErrors.\n *\n * @category Errors\n */\nclass XrplError extends Error {\n public readonly name: string\n public readonly message: string\n public readonly data?: unknown\n\n /**\n * Construct an XrplError.\n *\n * @param message - The error message.\n * @param data - The data that caused the error.\n */\n public constructor(message = '', data?: unknown) {\n super(message)\n\n this.name = this.constructor.name\n this.message = message\n this.data = data\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- `captureStackTrace` can be null in browsers\n if (Error.captureStackTrace != null) {\n Error.captureStackTrace(this, this.constructor)\n }\n }\n\n /**\n * Converts the Error to a human-readable String form.\n *\n * @returns The String output of the Error.\n */\n public toString(): string {\n let result = `[${this.name}(${this.message}`\n if (this.data) {\n result += `, ${inspect(this.data)}`\n }\n result += ')]'\n return result\n }\n\n /**\n * Console.log in node uses util.inspect on object, and util.inspect allows\n * us to customize its output:\n * https://nodejs.org/api/util.html#util_custom_inspect_function_on_objects.\n *\n * @returns The String output of the Error.\n */\n public inspect(): string {\n return this.toString()\n }\n}\n\n/**\n * Error thrown when rippled responds with an error.\n *\n * @category Errors\n */\nclass RippledError extends XrplError {}\n\n/**\n * Error thrown when xrpl.js cannot specify error type.\n *\n * @category Errors\n */\nclass UnexpectedError extends XrplError {}\n\n/**\n * Error thrown when xrpl.js has an error with connection to rippled.\n *\n * @category Errors\n */\nclass ConnectionError extends XrplError {}\n\n/**\n * Error thrown when xrpl.js is not connected to rippled server.\n *\n * @category Errors\n */\nclass NotConnectedError extends ConnectionError {}\n\n/**\n * Error thrown when xrpl.js has disconnected from rippled server.\n *\n * @category Errors\n */\nclass DisconnectedError extends ConnectionError {}\n\n/**\n * Error thrown when rippled is not initialized.\n *\n * @category Errors\n */\nclass RippledNotInitializedError extends ConnectionError {}\n\n/**\n * Error thrown when xrpl.js times out.\n *\n * @category Errors\n */\nclass TimeoutError extends ConnectionError {}\n\n/**\n * Error thrown when xrpl.js sees a response in the wrong format.\n *\n * @category Errors\n */\nclass ResponseFormatError extends ConnectionError {}\n\n/**\n * Error thrown when xrpl.js sees a malformed transaction.\n *\n * @category Errors\n */\nclass ValidationError extends XrplError {}\n\n/**\n * Error thrown when a client cannot generate a wallet from the testnet/devnet\n * faucets, or when the client cannot infer the faucet URL (i.e. when the Client\n * is connected to mainnet).\n *\n * @category Errors\n */\nclass XRPLFaucetError extends XrplError {}\n\n/**\n * Error thrown when xrpl.js cannot retrieve a transaction, ledger, account, etc.\n * From rippled.\n *\n * @category Errors\n */\nclass NotFoundError extends XrplError {\n /**\n * Construct an XrplError.\n *\n * @param message - The error message. Defaults to \"Not found\".\n */\n public constructor(message = 'Not found') {\n super(message)\n }\n}\n\nexport {\n XrplError,\n UnexpectedError,\n ConnectionError,\n RippledError,\n NotConnectedError,\n DisconnectedError,\n RippledNotInitializedError,\n TimeoutError,\n ResponseFormatError,\n ValidationError,\n NotFoundError,\n XRPLFaucetError,\n}\n","// Broadcast client is experimental\nexport { default as BroadcastClient } from './client/BroadcastClient'\n\nexport { Client, ClientOptions } from './client'\n\nexport * from './models'\n\nexport * from './utils'\n\nexport * from './errors'\n\nexport { default as Wallet } from './Wallet'\n\nexport { keyToRFC1751Mnemonic, rfc1751MnemonicToKey } from './Wallet/rfc1751'\n\nexport * from './Wallet/signer'\n","/**\n * LedgerEntry type definitions are exported in their own namespace to prevent\n * collisions of the DepositPreauth SLE and Transaction. LedgerEntries are used\n * by the client less often, and in most scenarios, like when parsing a\n * response, the client won't need to import the type. If it is required to use\n * a Ledger Entry, import `LedgerEntry`, and access individual ledger entry\n * types on the `LedgerEntry` namespace.\n */\nexport * as LedgerEntry from './ledger'\nexport {\n setTransactionFlagsToNumber,\n parseAccountRootFlags,\n} from './utils/flags'\nexport * from './methods'\nexport * from './transactions'\n","import BaseLedgerEntry from './BaseLedgerEntry'\n\n/**\n * The AccountRoot object type describes a single account, its settings, and\n * XRP balance.\n *\n * @category Ledger Entries\n */\nexport default interface AccountRoot extends BaseLedgerEntry {\n LedgerEntryType: 'AccountRoot'\n /** The identifying (classic) address of this account. */\n Account: string\n /** The account's current XRP balance in drops, represented as a string. */\n Balance: string\n /** A bit-map of boolean flags enabled for this account. */\n Flags: number\n /**\n * The number of objects this account owns in the ledger, which contributes\n * to its owner reserve.\n */\n OwnerCount: number\n /**\n * The identifying hash of the transaction that most recently modified this\n * object.\n */\n PreviousTxnID: string\n /**\n * The index of the ledger that contains the transaction that most recently\n * modified this object.\n */\n PreviousTxnLgrSeq: number\n /** The sequence number of the next valid transaction for this account. */\n Sequence: number\n /**\n * The identifying hash of the transaction most recently sent by this\n * account. This field must be enabled to use the AccountTxnID transaction\n * field. To enable it, send an AccountSet transaction with the.\n * `asfAccountTxnID` flag enabled.\n */\n AccountTxnID?: string\n /**\n * A domain associated with this account. In JSON, this is the hexadecimal\n * for the ASCII representation of the domain.\n */\n Domain?: string\n /** The md5 hash of an email address. */\n EmailHash?: string\n /**\n * A public key that may be used to send encrypted messages to this account\n * in JSON, uses hexadecimal.\n */\n MessageKey?: string\n /**\n * The address of a key pair that can be used to sign transactions for this\n * account instead of the master key. Use a SetRegularKey transaction to\n * change this value.\n */\n RegularKey?: string\n /**\n * How many Tickets this account owns in the ledger. This is updated\n * automatically to ensure that the account stays within the hard limit of 250.\n * Tickets at a time.\n */\n TicketCount?: number\n /**\n * How many significant digits to use for exchange rates of Offers involving\n * currencies issued by this address. Valid values are 3 to 15, inclusive.\n */\n TickSize?: number\n /**\n * A transfer fee to charge other users for sending currency issued by this\n * account to each other.\n */\n TransferRate?: number\n}\n\n/**\n * A boolean map of AccountRootFlags for simplified code checking AccountRoot settings.\n * For submitting settings flags to the ledger, use AccountRootFlags instead.\n */\nexport interface AccountRootFlagsInterface {\n /**\n * The account has used its free SetRegularKey transaction.\n */\n lsfPasswordSpent?: boolean\n /**\n * Requires incoming payments to specify a Destination Tag.\n */\n lsfRequireDestTag?: boolean\n /**\n * This account must individually approve other users for those users to hold this account's issued currencies.\n */\n lsfRequireAuth?: boolean\n /**\n * Client applications should not send XRP to this account. Not enforced by rippled.\n */\n lsfDisallowXRP?: boolean\n /**\n * Disallows use of the master key to sign transactions for this account.\n */\n lsfDisableMaster?: boolean\n /**\n * This address cannot freeze trust lines connected to it. Once enabled, cannot be disabled.\n */\n lsfNoFreeze?: boolean\n /**\n * All assets issued by this address are frozen.\n */\n lsfGlobalFreeze?: boolean\n /**\n * Enable rippling on this address's trust lines by default. Required for issuing addresses; discouraged for others.\n */\n lsfDefaultRipple?: boolean\n /**\n * This account can only receive funds from transactions it sends, and from preauthorized accounts.\n * (It has DepositAuth enabled.)\n */\n lsfDepositAuth?: boolean\n /**\n * Disallow incoming NFTOffers from other accounts.\n */\n lsfDisallowIncomingNFTokenOffer?: boolean\n /**\n * Disallow incoming Checks from other accounts.\n */\n lsfDisallowIncomingCheck?: boolean\n /**\n * Disallow incoming PayChannels from other accounts.\n */\n lsfDisallowIncomingPayChan?: boolean\n /**\n * Disallow incoming Trustlines from other accounts.\n */\n lsfDisallowIncomingTrustline?: boolean\n}\n\nexport enum AccountRootFlags {\n /**\n * The account has used its free SetRegularKey transaction.\n */\n lsfPasswordSpent = 0x00010000,\n /**\n * Requires incoming payments to specify a Destination Tag.\n */\n lsfRequireDestTag = 0x00020000,\n /**\n * This account must individually approve other users for those users to hold this account's issued currencies.\n */\n lsfRequireAuth = 0x00040000,\n /**\n * Client applications should not send XRP to this account. Not enforced by rippled.\n */\n lsfDisallowXRP = 0x00080000,\n /**\n * Disallows use of the master key to sign transactions for this account.\n */\n lsfDisableMaster = 0x00100000,\n /**\n * This address cannot freeze trust lines connected to it. Once enabled, cannot be disabled.\n */\n lsfNoFreeze = 0x00200000,\n /**\n * All assets issued by this address are frozen.\n */\n lsfGlobalFreeze = 0x00400000,\n /**\n * Enable rippling on this address's trust lines by default. Required for issuing addresses; discouraged for others.\n */\n lsfDefaultRipple = 0x00800000,\n /**\n * This account can only receive funds from transactions it sends, and from preauthorized accounts.\n * (It has DepositAuth enabled.)\n */\n lsfDepositAuth = 0x01000000,\n /**\n * Disallow incoming NFTOffers from other accounts.\n */\n lsfDisallowIncomingNFTokenOffer = 0x04000000,\n /**\n * Disallow incoming Checks from other accounts.\n */\n lsfDisallowIncomingCheck = 0x08000000,\n /**\n * Disallow incoming PayChannels from other accounts.\n */\n lsfDisallowIncomingPayChan = 0x10000000,\n /**\n * Disallow incoming Trustlines from other accounts.\n */\n lsfDisallowIncomingTrustline = 0x20000000,\n}\n","import { Amount } from '../common'\n\nimport BaseLedgerEntry from './BaseLedgerEntry'\n\nexport default interface Offer extends BaseLedgerEntry {\n LedgerEntryType: 'Offer'\n /** A bit-map of boolean flags enabled for this Offer. */\n Flags: number\n /** The address of the account that placed this Offer. */\n Account: string\n /**\n * The Sequence value of the OfferCreate transaction that created this Offer\n * object. Used in combination with the Account to identify this Offer.\n */\n Sequence: number\n /** The remaining amount and type of currency requested by the Offer creator. */\n TakerPays: Amount\n /**\n * The remaining amount and type of currency being provided by the Offer\n * creator.\n */\n TakerGets: Amount\n /** The ID of the Offer Directory that links to this Offer. */\n BookDirectory: string\n /**\n * A hint indicating which page of the Offer Directory links to this object,\n * in case the directory consists of multiple pages.\n */\n BookNode: string\n /**\n * A hint indicating which page of the Owner Directory links to this object,\n * in case the directory consists of multiple pages.\n */\n OwnerNode: string\n /**\n * The identifying hash of the transaction that most recently modified this\n * object.\n */\n PreviousTxnID: string\n /**\n * The index of the ledger that contains the transaction that most recently\n * modified this object.\n */\n PreviousTxnLgrSeq: number\n /** The time this Offer expires, in seconds since the Ripple Epoch. */\n Expiration?: number\n}\n\nexport enum OfferFlags {\n lsfPassive = 0x00010000,\n lsfSell = 0x00020000,\n}\n","import { IssuedCurrencyAmount } from '../common'\n\nimport BaseLedgerEntry from './BaseLedgerEntry'\n\n/**\n * The RippleState object type connects two accounts in a single currency.\n *\n * @category Ledger Entries\n */\nexport default interface RippleState extends BaseLedgerEntry {\n LedgerEntryType: 'RippleState'\n /** A bit-map of boolean options enabled for this object. */\n Flags: number\n /**\n * The balance of the trust line, from the perspective of the low account. A\n * negative balance indicates that the low account has issued currency to the\n * high account. The issuer is always the neutral value ACCOUNT_ONE.\n */\n Balance: IssuedCurrencyAmount\n /**\n * The limit that the low account has set on the trust line. The issuer is\n * the address of the low account that set this limit.\n */\n LowLimit: IssuedCurrencyAmount\n /**\n * The limit that the high account has set on the trust line. The issuer is\n * the address of the high account that set this limit.\n */\n HighLimit: IssuedCurrencyAmount\n /**\n * The identifying hash of the transaction that most recently modified this\n * object.\n */\n PreviousTxnID: string\n /**\n * The index of the ledger that contains the transaction that most recently\n * modified this object.\n */\n PreviousTxnLgrSeq: number\n /**\n * A hint indicating which page of the low account's owner directory links to\n * this object, in case the directory consists of multiple pages.\n */\n LowNode?: string\n /**\n * A hint indicating which page of the high account's owner directory links\n * to this object, in case the directory consists of multiple pages.\n */\n HighNode?: string\n /**\n * The inbound quality set by the low account, as an integer in the implied\n * ratio LowQualityIn:1,000,000,000. As a special case, the value 0 is\n * equivalent to 1 billion, or face value.\n */\n LowQualityIn?: number\n /**\n * The outbound quality set by the low account, as an integer in the implied\n * ratio LowQualityOut:1,000,000,000. As a special case, the value 0 is\n * equivalent to 1 billion, or face value.\n */\n LowQualityOut?: number\n /**\n * The inbound quality set by the high account, as an integer in the implied\n * ratio HighQualityIn:1,000,000,000. As a special case, the value 0 is\n * equivalent to 1 billion, or face value.\n */\n HighQualityIn?: number\n /**\n * The outbound quality set by the high account, as an integer in the implied\n * ratio HighQualityOut:1,000,000,000. As a special case, the value 0 is\n * equivalent to 1 billion, or face value.\n */\n HighQualityOut?: number\n}\n\nexport enum RippleStateFlags {\n // True, if entry counts toward reserve.\n lsfLowReserve = 0x00010000,\n lsfHighReserve = 0x00020000,\n lsfLowAuth = 0x00040000,\n lsfHighAuth = 0x00080000,\n lsfLowNoRipple = 0x00100000,\n lsfHighNoRipple = 0x00200000,\n // True, low side has set freeze flag\n lsfLowFreeze = 0x00400000,\n // True, high side has set freeze flag\n lsfHighFreeze = 0x00800000,\n}\n","import BaseLedgerEntry from './BaseLedgerEntry'\n\ninterface SignerEntry {\n SignerEntry: {\n Account: string\n SignerWeight: number\n }\n}\n\n/**\n * The SignerList object type represents a list of parties that, as a group,\n * are authorized to sign a transaction in place of an individual account. You\n * can create, replace, or remove a signer list using a SignerListSet\n * transaction.\n *\n * @category Ledger Entries\n */\nexport default interface SignerList extends BaseLedgerEntry {\n LedgerEntryType: 'SignerList'\n /**\n * A bit-map of Boolean flags enabled for this signer list. For more\n * information, see SignerList Flags.\n */\n Flags: number\n /**\n * The identifying hash of the transaction that most recently modified this\n * object.\n */\n PreviousTxnID: string\n /**\n * The index of the ledger that contains the transaction that most recently\n * modified this object.\n */\n PreviousTxnLgrSeq: number\n /**\n * A hint indicating which page of the owner directory links to this object,\n * in case the directory consists of multiple pages.\n */\n OwnerNode: string\n /**\n * An array of Signer Entry objects representing the parties who are part of\n * this signer list.\n */\n SignerEntries: SignerEntry[]\n /**\n * An ID for this signer list. Currently always set to 0. If a future\n * amendment allows multiple signer lists for an account, this may change.\n */\n SignerListID: number\n /**\n * A target number for signer weights. To produce a valid signature for the\n * owner of this SignerList, the signers must provide valid signatures whose\n * weights sum to this value or more.\n */\n SignerQuorum: number\n}\n\nexport enum SignerListFlags {\n // True, uses only one OwnerCount\n lsfOneOwnerCount = 0x00010000,\n}\n","import AccountRoot, {\n AccountRootFlags,\n AccountRootFlagsInterface,\n} from './AccountRoot'\nimport Amendments from './Amendments'\nimport Check from './Check'\nimport DepositPreauth from './DepositPreauth'\nimport DirectoryNode from './DirectoryNode'\nimport Escrow from './Escrow'\nimport FeeSettings from './FeeSettings'\nimport Ledger from './Ledger'\nimport LedgerEntry from './LedgerEntry'\nimport LedgerHashes from './LedgerHashes'\nimport NegativeUNL from './NegativeUNL'\nimport Offer, { OfferFlags } from './Offer'\nimport PayChannel from './PayChannel'\nimport RippleState, { RippleStateFlags } from './RippleState'\nimport SignerList, { SignerListFlags } from './SignerList'\nimport Ticket from './Ticket'\n\nexport {\n AccountRoot,\n AccountRootFlags,\n AccountRootFlagsInterface,\n Amendments,\n Check,\n DepositPreauth,\n DirectoryNode,\n Escrow,\n FeeSettings,\n Ledger,\n LedgerEntry,\n LedgerHashes,\n NegativeUNL,\n Offer,\n OfferFlags,\n PayChannel,\n RippleState,\n RippleStateFlags,\n SignerList,\n SignerListFlags,\n Ticket,\n}\n","import { ValidationError } from '../../errors'\nimport { Amount } from '../common'\n\nimport {\n BaseTransaction,\n parseAmountValue,\n validateBaseTransaction,\n} from './common'\n\n/**\n * The NFTokenOfferAccept transaction is used to accept offers\n * to buy or sell an NFToken. It can either:\n *\n * 1. Allow one offer to be accepted. This is called direct\n * mode.\n * 2. Allow two distinct offers, one offering to buy a\n * given NFToken and the other offering to sell the same\n * NFToken, to be accepted in an atomic fashion. This is\n * called brokered mode.\n *\n * To indicate direct mode, use either the `sell_offer` or\n * `buy_offer` fields, but not both. To indicate brokered mode,\n * use both the `sell_offer` and `buy_offer` fields. If you use\n * neither `sell_offer` nor `buy_offer`, the transaction is invalid.\n */\nexport interface NFTokenAcceptOffer extends BaseTransaction {\n TransactionType: 'NFTokenAcceptOffer'\n /**\n * Identifies the NFTokenOffer that offers to sell the NFToken.\n *\n * In direct mode this field is optional, but either NFTokenSellOffer or\n * NFTokenBuyOffer must be specified. In brokered mode, both NFTokenSellOffer\n * and NFTokenBuyOffer must be specified.\n */\n NFTokenSellOffer?: string\n /**\n * Identifies the NFTokenOffer that offers to buy the NFToken.\n *\n * In direct mode this field is optional, but either NFTokenSellOffer or\n * NFTokenBuyOffer must be specified. In brokered mode, both NFTokenSellOffer\n * and NFTokenBuyOffer must be specified.\n */\n NFTokenBuyOffer?: string\n /**\n * This field is only valid in brokered mode. It specifies the\n * amount that the broker will keep as part of their fee for\n * bringing the two offers together; the remaining amount will\n * be sent to the seller of the NFToken being bought. If\n * specified, the fee must be such that, prior to accounting\n * for the transfer fee charged by the issuer, the amount that\n * the seller would receive is at least as much as the amount\n * indicated in the sell offer.\n *\n * This functionality is intended to allow the owner of an\n * NFToken to offer their token for sale to a third party\n * broker, who may then attempt to sell the NFToken on for a\n * larger amount, without the broker having to own the NFToken\n * or custody funds.\n *\n * Note: in brokered mode, the offers referenced by NFTokenBuyOffer\n * and NFTokenSellOffer must both specify the same NFTokenID; that is,\n * both must be for the same NFToken.\n */\n NFTokenBrokerFee?: Amount\n}\n\nfunction validateNFTokenBrokerFee(tx: Record<string, unknown>): void {\n const value = parseAmountValue(tx.NFTokenBrokerFee)\n if (Number.isNaN(value)) {\n throw new ValidationError('NFTokenAcceptOffer: invalid NFTokenBrokerFee')\n }\n\n if (value <= 0) {\n throw new ValidationError(\n 'NFTokenAcceptOffer: NFTokenBrokerFee must be greater than 0; omit if there is no fee',\n )\n }\n\n if (tx.NFTokenSellOffer == null || tx.NFTokenBuyOffer == null) {\n throw new ValidationError(\n 'NFTokenAcceptOffer: both NFTokenSellOffer and NFTokenBuyOffer must be set if using brokered mode',\n )\n }\n}\n\n/**\n * Verify the form and type of an NFTokenAcceptOffer at runtime.\n *\n * @param tx - An NFTokenAcceptOffer Transaction.\n * @throws When the NFTokenAcceptOffer is Malformed.\n */\nexport function validateNFTokenAcceptOffer(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.NFTokenBrokerFee != null) {\n validateNFTokenBrokerFee(tx)\n }\n\n if (tx.NFTokenSellOffer == null && tx.NFTokenBuyOffer == null) {\n throw new ValidationError(\n 'NFTokenAcceptOffer: must set either NFTokenSellOffer or NFTokenBuyOffer',\n )\n }\n}\n","import { ValidationError } from '../../errors'\n\nimport { BaseTransaction, validateBaseTransaction } from './common'\n\n/**\n * The NFTokenBurn transaction is used to remove an NFToken object from the\n * NFTokenPage in which it is being held, effectively removing the token from\n * the ledger (\"burning\" it).\n *\n * If this operation succeeds, the corresponding NFToken is removed. If this\n * operation empties the NFTokenPage holding the NFToken or results in the\n * consolidation, thus removing an NFTokenPage, the owner’s reserve requirement\n * is reduced by one.\n */\nexport interface NFTokenBurn extends BaseTransaction {\n TransactionType: 'NFTokenBurn'\n /**\n * Indicates the AccountID that submitted this transaction. The account MUST\n * be either the present owner of the token or, if the lsfBurnable flag is set\n * in the NFToken, either the issuer account or an account authorized by the\n * issuer, i.e. MintAccount.\n */\n Account: string\n /**\n * Identifies the NFToken object to be removed by the transaction.\n */\n NFTokenID: string\n /**\n * Indicates which account currently owns the token if it is different than\n * Account. Only used to burn tokens which have the lsfBurnable flag enabled\n * and are not owned by the signing account.\n */\n Owner?: string\n}\n\n/**\n * Verify the form and type of an NFTokenBurn at runtime.\n *\n * @param tx - An NFTokenBurn Transaction.\n * @throws When the NFTokenBurn is Malformed.\n */\nexport function validateNFTokenBurn(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.NFTokenID == null) {\n throw new ValidationError('NFTokenBurn: missing field NFTokenID')\n }\n}\n","import { ValidationError } from '../../errors'\n\nimport { BaseTransaction, validateBaseTransaction } from './common'\n\n/**\n * The NFTokenCancelOffer transaction deletes existing NFTokenOffer objects.\n * It is useful if you want to free up space on your account to lower your\n * reserve requirement.\n *\n * The transaction can be executed by the account that originally created\n * the NFTokenOffer, the account in the `Recipient` field of the NFTokenOffer\n * (if present), or any account if the NFTokenOffer has an `Expiration` and\n * the NFTokenOffer has already expired.\n */\nexport interface NFTokenCancelOffer extends BaseTransaction {\n TransactionType: 'NFTokenCancelOffer'\n /**\n * An array of identifiers of NFTokenOffer objects that should be cancelled\n * by this transaction.\n *\n * It is an error if an entry in this list points to an\n * object that is not an NFTokenOffer object. It is not an\n * error if an entry in this list points to an object that\n * does not exist. This field is required.\n */\n NFTokenOffers: string[]\n}\n\n/**\n * Verify the form and type of an NFTokenCancelOffer at runtime.\n *\n * @param tx - An NFTokenCancelOffer Transaction.\n * @throws When the NFTokenCancelOffer is Malformed.\n */\nexport function validateNFTokenCancelOffer(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (!Array.isArray(tx.NFTokenOffers)) {\n throw new ValidationError('NFTokenCancelOffer: missing field NFTokenOffers')\n }\n\n if (tx.NFTokenOffers.length < 1) {\n throw new ValidationError('NFTokenCancelOffer: empty field NFTokenOffers')\n }\n}\n","import { ValidationError } from '../../errors'\nimport { Amount } from '../common'\nimport { isFlagEnabled } from '../utils'\n\nimport {\n BaseTransaction,\n GlobalFlags,\n validateBaseTransaction,\n isAmount,\n parseAmountValue,\n} from './common'\n\n/**\n * Transaction Flags for an NFTokenCreateOffer Transaction.\n *\n * @category Transaction Flags\n */\nexport enum NFTokenCreateOfferFlags {\n /**\n * If set, indicates that the offer is a sell offer.\n * Otherwise, it is a buy offer.\n */\n tfSellNFToken = 0x00000001,\n}\n\n/**\n * Map of flags to boolean values representing {@link NFTokenCreateOffer} transaction\n * flags.\n *\n * @category Transaction Flags\n */\nexport interface NFTokenCreateOfferFlagsInterface extends GlobalFlags {\n tfSellNFToken?: boolean\n}\n\n/**\n * The NFTokenCreateOffer transaction creates either an offer to buy an\n * NFT the submitting account does not own, or an offer to sell an NFT\n * the submitting account does own.\n */\nexport interface NFTokenCreateOffer extends BaseTransaction {\n TransactionType: 'NFTokenCreateOffer'\n /**\n * Identifies the NFTokenID of the NFToken object that the\n * offer references.\n */\n NFTokenID: string\n /**\n * Indicates the amount expected or offered for the Token.\n *\n * The amount must be non-zero, except when this is a sell\n * offer and the asset is XRP. This would indicate that the current\n * owner of the token is giving it away free, either to anyone at all,\n * or to the account identified by the Destination field.\n */\n Amount: Amount\n /**\n * Indicates the AccountID of the account that owns the\n * corresponding NFToken.\n *\n * If the offer is to buy a token, this field must be present\n * and it must be different than Account (since an offer to\n * buy a token one already holds is meaningless).\n *\n * If the offer is to sell a token, this field must not be\n * present, as the owner is, implicitly, the same as Account\n * (since an offer to sell a token one doesn't already hold\n * is meaningless).\n */\n Owner?: string\n /**\n * Indicates the time after which the offer will no longer\n * be valid. The value is the number of seconds since the\n * Ripple Epoch.\n */\n Expiration?: number\n /**\n * If present, indicates that this offer may only be\n * accepted by the specified account. Attempts by other\n * accounts to accept this offer MUST fail.\n */\n Destination?: string\n Flags?: number | NFTokenCreateOfferFlagsInterface\n}\n\nfunction validateNFTokenSellOfferCases(tx: Record<string, unknown>): void {\n if (tx.Owner != null) {\n throw new ValidationError(\n 'NFTokenCreateOffer: Owner must not be present for sell offers',\n )\n }\n}\n\nfunction validateNFTokenBuyOfferCases(tx: Record<string, unknown>): void {\n if (tx.Owner == null) {\n throw new ValidationError(\n 'NFTokenCreateOffer: Owner must be present for buy offers',\n )\n }\n\n if (parseAmountValue(tx.Amount) <= 0) {\n throw new ValidationError(\n 'NFTokenCreateOffer: Amount must be greater than 0 for buy offers',\n )\n }\n}\n\n/**\n * Verify the form and type of an NFTokenCreateOffer at runtime.\n *\n * @param tx - An NFTokenCreateOffer Transaction.\n * @throws When the NFTokenCreateOffer is Malformed.\n */\nexport function validateNFTokenCreateOffer(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.Account === tx.Owner) {\n throw new ValidationError(\n 'NFTokenCreateOffer: Owner and Account must not be equal',\n )\n }\n\n if (tx.Account === tx.Destination) {\n throw new ValidationError(\n 'NFTokenCreateOffer: Destination and Account must not be equal',\n )\n }\n\n if (tx.NFTokenID == null) {\n throw new ValidationError('NFTokenCreateOffer: missing field NFTokenID')\n }\n\n if (!isAmount(tx.Amount)) {\n throw new ValidationError('NFTokenCreateOffer: invalid Amount')\n }\n\n if (\n typeof tx.Flags === 'number' &&\n isFlagEnabled(tx.Flags, NFTokenCreateOfferFlags.tfSellNFToken)\n ) {\n validateNFTokenSellOfferCases(tx)\n } else {\n validateNFTokenBuyOfferCases(tx)\n }\n}\n","import { ValidationError } from '../../errors'\nimport { isHex } from '../utils'\n\nimport { BaseTransaction, GlobalFlags, validateBaseTransaction } from './common'\n\n/**\n * Transaction Flags for an NFTokenMint Transaction.\n *\n * @category Transaction Flags\n */\nexport enum NFTokenMintFlags {\n /**\n * If set, indicates that the minted token may be burned by the issuer even\n * if the issuer does not currently hold the token. The current holder of\n * the token may always burn it.\n */\n tfBurnable = 0x00000001,\n /**\n * If set, indicates that the token may only be offered or sold for XRP.\n */\n tfOnlyXRP = 0x00000002,\n /**\n * If set, indicates that the issuer wants a trustline to be automatically\n * created.\n */\n tfTrustLine = 0x00000004,\n /**\n * If set, indicates that this NFT can be transferred. This flag has no\n * effect if the token is being transferred from the issuer or to the\n * issuer.\n */\n tfTransferable = 0x00000008,\n}\n\n/**\n * Map of flags to boolean values representing {@link NFTokenMint} transaction\n * flags.\n *\n * @category Transaction Flags\n */\nexport interface NFTokenMintFlagsInterface extends GlobalFlags {\n tfBurnable?: boolean\n tfOnlyXRP?: boolean\n tfTrustLine?: boolean\n tfTransferable?: boolean\n}\n\n/**\n * The NFTokenMint transaction creates an NFToken object and adds it to the\n * relevant NFTokenPage object of the minter. If the transaction is\n * successful, the newly minted token will be owned by the minter account\n * specified by the transaction.\n */\nexport interface NFTokenMint extends BaseTransaction {\n TransactionType: 'NFTokenMint'\n /**\n * Indicates the taxon associated with this token. The taxon is generally a\n * value chosen by the minter of the token and a given taxon may be used for\n * multiple tokens. The implementation reserves taxon identifiers greater\n * than or equal to 2147483648 (0x80000000). If you have no use for this\n * field, set it to 0.\n */\n NFTokenTaxon: number\n /**\n * Indicates the account that should be the issuer of this token. This value\n * is optional and should only be specified if the account executing the\n * transaction is not the `Issuer` of the `NFToken` object. If it is\n * present, the `MintAccount` field in the `AccountRoot` of the `Issuer`\n * field must match the `Account`, otherwise the transaction will fail.\n */\n Issuer?: string\n /**\n * Specifies the fee charged by the issuer for secondary sales of the Token,\n * if such sales are allowed. Valid values for this field are between 0 and\n * 50000 inclusive, allowing transfer rates between 0.000% and 50.000% in\n * increments of 0.001%. This field must NOT be present if the\n * `tfTransferable` flag is not set.\n */\n TransferFee?: number\n /**\n * URI that points to the data and/or metadata associated with the NFT.\n * This field need not be an HTTP or HTTPS URL; it could be an IPFS URI, a\n * magnet link, immediate data encoded as an RFC2379 \"data\" URL, or even an\n * opaque issuer-specific encoding. The URI is NOT checked for validity, but\n * the field is limited to a maximum length of 256 bytes.\n *\n * This field must be hex-encoded. You can use `convertStringToHex` to\n * convert this field to the proper encoding.\n */\n URI?: string\n Flags?: number | NFTokenMintFlagsInterface\n}\n\n/**\n * Verify the form and type of an NFTokenMint at runtime.\n *\n * @param tx - An NFTokenMint Transaction.\n * @throws When the NFTokenMint is Malformed.\n */\nexport function validateNFTokenMint(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.Account === tx.Issuer) {\n throw new ValidationError(\n 'NFTokenMint: Issuer must not be equal to Account',\n )\n }\n\n if (typeof tx.URI === 'string' && !isHex(tx.URI)) {\n throw new ValidationError('NFTokenMint: URI must be in hex format')\n }\n\n if (tx.NFTokenTaxon == null) {\n throw new ValidationError('NFTokenMint: missing field NFTokenTaxon')\n }\n}\n","import { ValidationError } from '../../errors'\n\nimport { BaseTransaction, validateBaseTransaction } from './common'\n\n/**\n * An AccountDelete transaction deletes an account and any objects it owns in\n * the XRP Ledger, if possible, sending the account's remaining XRP to a\n * specified destination account.\n *\n * @category Transaction Models\n */\nexport interface AccountDelete extends BaseTransaction {\n TransactionType: 'AccountDelete'\n /**\n * The address of an account to receive any leftover XRP after deleting the\n * sending account. Must be a funded account in the ledger, and must not be.\n * the sending account.\n */\n Destination: string\n /**\n * Arbitrary destination tag that identifies a hosted recipient or other.\n * information for the recipient of the deleted account's leftover XRP.\n */\n DestinationTag?: number\n}\n\n/**\n * Verify the form and type of an AccountDelete at runtime.\n *\n * @param tx - An AccountDelete Transaction.\n * @throws When the AccountDelete is Malformed.\n */\nexport function validateAccountDelete(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.Destination === undefined) {\n throw new ValidationError('AccountDelete: missing field Destination')\n }\n\n if (typeof tx.Destination !== 'string') {\n throw new ValidationError('AccountDelete: invalid Destination')\n }\n\n if (\n tx.DestinationTag !== undefined &&\n typeof tx.DestinationTag !== 'number'\n ) {\n throw new ValidationError('AccountDelete: invalid DestinationTag')\n }\n}\n","/* eslint-disable complexity -- Necessary for validateAccountSet */\n\nimport { isValidClassicAddress } from 'ripple-address-codec'\n\nimport { ValidationError } from '../../errors'\n\nimport { BaseTransaction, validateBaseTransaction } from './common'\n\n/**\n * Enum for AccountSet Flags.\n *\n * @category Transaction Flags\n */\nexport enum AccountSetAsfFlags {\n /** Require a destination tag to send transactions to this account. */\n asfRequireDest = 1,\n /**\n * Require authorization for users to hold balances issued by this address\n * can only be enabled if the address has no trust lines connected to it.\n */\n asfRequireAuth = 2,\n /** XRP should not be sent to this account. */\n asfDisallowXRP = 3,\n /**\n * Disallow use of the master key pair. Can only be enabled if the account\n * has configured another way to sign transactions, such as a Regular Key or a\n * Signer List.\n */\n asfDisableMaster = 4,\n /**\n * Track the ID of this account's most recent transaction. Required for\n * AccountTxnID.\n */\n asfAccountTxnID = 5,\n /**\n * Permanently give up the ability to freeze individual trust lines or\n * disable Global Freeze. This flag can never be disabled after being enabled.\n */\n asfNoFreeze = 6,\n /** Freeze all assets issued by this account. */\n asfGlobalFreeze = 7,\n /** Enable rippling on this account's trust lines by default. */\n asfDefaultRipple = 8,\n /** Enable Deposit Authorization on this account. */\n asfDepositAuth = 9,\n /**\n * Allow another account to mint and burn tokens on behalf of this account.\n */\n asfAuthorizedNFTokenMinter = 10,\n /** asf 11 is reserved for Hooks amendment */\n /** Disallow other accounts from creating incoming NFTOffers */\n asfDisallowIncomingNFTokenOffer = 12,\n /** Disallow other accounts from creating incoming Checks */\n asfDisallowIncomingCheck = 13,\n /** Disallow other accounts from creating incoming PayChannels */\n asfDisallowIncomingPayChan = 14,\n /** Disallow other accounts from creating incoming Trustlines */\n asfDisallowIncomingTrustline = 15,\n}\n\n/**\n * Enum for AccountSet Transaction Flags.\n *\n * @category Transaction Flags\n */\nexport enum AccountSetTfFlags {\n /** The same as SetFlag: asfRequireDest. */\n tfRequireDestTag = 0x00010000,\n /** The same as ClearFlag: asfRequireDest. */\n tfOptionalDestTag = 0x00020000,\n /** The same as SetFlag: asfRequireAuth. */\n tfRequireAuth = 0x00040000,\n /** The same as ClearFlag: asfRequireAuth. */\n tfOptionalAuth = 0x00080000,\n /** The same as SetFlag: asfDisallowXRP. */\n tfDisallowXRP = 0x00100000,\n /** The same as ClearFlag: asfDisallowXRP. */\n tfAllowXRP = 0x00200000,\n}\n\n/**\n * Map of flags to boolean values representing {@link AccountSet} transaction\n * flags.\n *\n * @category Transaction Flags\n *\n * @example\n * ```typescript\n * const accountSetTx: AccountSet = {\n * TransactionType: 'AccountSet',\n * Account: 'rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn',\n * Flags: {\n * tfOptionalDestTag: true,\n * tfRequireAuth: true\n * },\n * }\n *\n * // Autofill the tx to see how flags actually look compared to the interface usage.\n * const autofilledTx = await client.autofill(accountSetTx)\n * console.log(autofilledTx)\n * // {\n * // TransactionType: 'AccountSet',\n * // Account: 'rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn',\n * // Flags: 393216,\n * // Sequence: 1,\n * // Fee: '12',\n * // LastLedgerSequence: 21971793\n * // }\n * ```\n */\nexport interface AccountSetFlagsInterface {\n tfRequireDestTag?: boolean\n tfOptionalDestTag?: boolean\n tfRequireAuth?: boolean\n tfOptionalAuth?: boolean\n tfDisallowXRP?: boolean\n tfAllowXRP?: boolean\n}\n\n/**\n * An AccountSet transaction modifies the properties of an account in the XRP\n * Ledger.\n *\n * @category Transaction Models\n */\nexport interface AccountSet extends BaseTransaction {\n TransactionType: 'AccountSet'\n Flags?: number | AccountSetFlagsInterface\n /** Unique identifier of a flag to disable for this account. */\n ClearFlag?: number\n /**\n * The domain that owns this account, as a string of hex representing the.\n * ASCII for the domain in lowercase.\n */\n Domain?: string\n /** Hash of an email address to be used for generating an avatar image. */\n EmailHash?: string\n /** Public key for sending encrypted messages to this account. */\n MessageKey?: string\n /** Integer flag to enable for this account. */\n SetFlag?: AccountSetAsfFlags\n /**\n * The fee to charge when users transfer this account's issued currencies,\n * represented as billionths of a unit. Cannot be more than 2000000000 or less\n * than 1000000000, except for the special case 0 meaning no fee.\n */\n TransferRate?: number\n /**\n * Tick size to use for offers involving a currency issued by this address.\n * The exchange rates of those offers is rounded to this many significant\n * digits. Valid values are 3 to 15 inclusive, or 0 to disable.\n */\n TickSize?: number\n /**\n * Sets an alternate account that is allowed to mint NFTokens on this\n * account's behalf using NFTokenMint's `Issuer` field.\n */\n NFTokenMinter?: string\n}\n\nconst MIN_TICK_SIZE = 3\nconst MAX_TICK_SIZE = 15\n\n/**\n * Verify the form and type of an AccountSet at runtime.\n *\n * @param tx - An AccountSet Transaction.\n * @throws When the AccountSet is Malformed.\n */\n// eslint-disable-next-line max-lines-per-function, max-statements -- okay for this method, only a little over\nexport function validateAccountSet(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (\n tx.NFTokenMinter !== undefined &&\n !isValidClassicAddress(String(tx.NFTokenMinter))\n ) {\n throw new ValidationError('AccountSet: invalid NFTokenMinter')\n }\n\n if (tx.ClearFlag !== undefined) {\n if (typeof tx.ClearFlag !== 'number') {\n throw new ValidationError('AccountSet: invalid ClearFlag')\n }\n if (!Object.values(AccountSetAsfFlags).includes(tx.ClearFlag)) {\n throw new ValidationError('AccountSet: invalid ClearFlag')\n }\n }\n\n if (tx.Domain !== undefined && typeof tx.Domain !== 'string') {\n throw new ValidationError('AccountSet: invalid Domain')\n }\n\n if (tx.EmailHash !== undefined && typeof tx.EmailHash !== 'string') {\n throw new ValidationError('AccountSet: invalid EmailHash')\n }\n\n if (tx.MessageKey !== undefined && typeof tx.MessageKey !== 'string') {\n throw new ValidationError('AccountSet: invalid MessageKey')\n }\n\n if (tx.SetFlag !== undefined) {\n if (typeof tx.SetFlag !== 'number') {\n throw new ValidationError('AccountSet: invalid SetFlag')\n }\n if (!Object.values(AccountSetAsfFlags).includes(tx.SetFlag)) {\n throw new ValidationError('AccountSet: invalid SetFlag')\n }\n }\n\n if (tx.TransferRate !== undefined && typeof tx.TransferRate !== 'number') {\n throw new ValidationError('AccountSet: invalid TransferRate')\n }\n\n if (tx.TickSize !== undefined) {\n if (typeof tx.TickSize !== 'number') {\n throw new ValidationError('AccountSet: invalid TickSize')\n }\n if (\n tx.TickSize !== 0 &&\n (tx.TickSize < MIN_TICK_SIZE || tx.TickSize > MAX_TICK_SIZE)\n ) {\n throw new ValidationError('AccountSet: invalid TickSize')\n }\n }\n}\n","import { ValidationError } from '../../errors'\n\nimport { BaseTransaction, validateBaseTransaction } from './common'\n\n/**\n * Cancels an unredeemed Check, removing it from the ledger without sending any\n * money. The source or the destination of the check can cancel a Check at any\n * time using this transaction type. If the Check has expired, any address can\n * cancel it.\n *\n * @category Transaction Models\n */\nexport interface CheckCancel extends BaseTransaction {\n TransactionType: 'CheckCancel'\n /**\n * The ID of the Check ledger object to cancel as a 64-character hexadecimal\n * string.\n */\n CheckID: string\n}\n\n/**\n * Verify the form and type of an CheckCancel at runtime.\n *\n * @param tx - An CheckCancel Transaction.\n * @throws When the CheckCancel is Malformed.\n */\nexport function validateCheckCancel(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.CheckID !== undefined && typeof tx.CheckID !== 'string') {\n throw new ValidationError('CheckCancel: invalid CheckID')\n }\n}\n","/* eslint-disable complexity -- Necessary for validateCheckCash */\nimport { ValidationError } from '../../errors'\nimport { Amount } from '../common'\n\nimport { BaseTransaction, validateBaseTransaction, isAmount } from './common'\n\n/**\n * Attempts to redeem a Check object in the ledger to receive up to the amount\n * authorized by the corresponding CheckCreate transaction. Only the Destination\n * address of a Check can cash it with a CheckCash transaction.\n *\n * @category Transaction Models\n */\nexport interface CheckCash extends BaseTransaction {\n TransactionType: 'CheckCash'\n /**\n * The ID of the Check ledger object to cash as a 64-character hexadecimal\n * string.\n */\n CheckID: string\n /**\n * Redeem the Check for exactly this amount, if possible. The currency must\n * match that of the SendMax of the corresponding CheckCreate transaction. You.\n * must provide either this field or DeliverMin.\n */\n Amount?: Amount\n /**\n * Redeem the Check for at least this amount and for as much as possible. The\n * currency must match that of the SendMax of the corresponding CheckCreate.\n * transaction. You must provide either this field or Amount.\n */\n DeliverMin?: Amount\n}\n\n/**\n * Verify the form and type of an CheckCash at runtime.\n *\n * @param tx - An CheckCash Transaction.\n * @throws When the CheckCash is Malformed.\n */\nexport function validateCheckCash(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.Amount == null && tx.DeliverMin == null) {\n throw new ValidationError(\n 'CheckCash: must have either Amount or DeliverMin',\n )\n }\n\n if (tx.Amount != null && tx.DeliverMin != null) {\n throw new ValidationError(\n 'CheckCash: cannot have both Amount and DeliverMin',\n )\n }\n\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Necessary check\n if (tx.Amount != null && tx.Amount !== undefined && !isAmount(tx.Amount)) {\n throw new ValidationError('CheckCash: invalid Amount')\n }\n\n if (\n tx.DeliverMin != null &&\n // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Necessary check\n tx.DeliverMin !== undefined &&\n !isAmount(tx.DeliverMin)\n ) {\n throw new ValidationError('CheckCash: invalid DeliverMin')\n }\n\n if (tx.CheckID !== undefined && typeof tx.CheckID !== 'string') {\n throw new ValidationError('CheckCash: invalid CheckID')\n }\n}\n","/* eslint-disable complexity -- Necessary for validateCheckCreate */\nimport { ValidationError } from '../../errors'\nimport { Amount } from '../common'\n\nimport {\n BaseTransaction,\n validateBaseTransaction,\n isIssuedCurrency,\n} from './common'\n\n/**\n * Create a Check object in the ledger, which is a deferred payment that can be\n * cashed by its intended destination. The sender of this transaction is the\n * sender of the Check.\n *\n * @category Transaction Models\n */\nexport interface CheckCreate extends BaseTransaction {\n TransactionType: 'CheckCreate'\n /** The unique address of the account that can cash the Check. */\n Destination: string\n /**\n * Maximum amount of source currency the Check is allowed to debit the\n * sender, including transfer fees on non-XRP currencies. The Check can only\n * credit the destination with the same currency (from the same issuer, for\n * non-XRP currencies). For non-XRP amounts, the nested field names MUST be.\n * lower-case.\n */\n SendMax: Amount\n /**\n * Arbitrary tag that identifies the reason for the Check, or a hosted.\n * recipient to pay.\n */\n DestinationTag?: number\n /**\n * Time after which the Check is no longer valid, in seconds since the Ripple.\n * Epoch.\n */\n Expiration?: number\n /**\n * Arbitrary 256-bit hash representing a specific reason or identifier for.\n * this Check.\n */\n InvoiceID?: string\n}\n\n/**\n * Verify the form and type of an CheckCreate at runtime.\n *\n * @param tx - An CheckCreate Transaction.\n * @throws When the CheckCreate is Malformed.\n */\nexport function validateCheckCreate(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.SendMax === undefined) {\n throw new ValidationError('CheckCreate: missing field SendMax')\n }\n\n if (tx.Destination === undefined) {\n throw new ValidationError('CheckCreate: missing field Destination')\n }\n\n if (\n typeof tx.SendMax !== 'string' &&\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS\n !isIssuedCurrency(tx.SendMax as Record<string, unknown>)\n ) {\n throw new ValidationError('CheckCreate: invalid SendMax')\n }\n\n if (typeof tx.Destination !== 'string') {\n throw new ValidationError('CheckCreate: invalid Destination')\n }\n\n if (\n tx.DestinationTag !== undefined &&\n typeof tx.DestinationTag !== 'number'\n ) {\n throw new ValidationError('CheckCreate: invalid DestinationTag')\n }\n\n if (tx.Expiration !== undefined && typeof tx.Expiration !== 'number') {\n throw new ValidationError('CheckCreate: invalid Expiration')\n }\n\n if (tx.InvoiceID !== undefined && typeof tx.InvoiceID !== 'string') {\n throw new ValidationError('CheckCreate: invalid InvoiceID')\n }\n}\n","/* eslint-disable max-lines-per-function -- Necessary for validateBaseTransaction */\n/* eslint-disable complexity -- Necessary for validateBaseTransaction */\n/* eslint-disable max-statements -- Necessary for validateBaseTransaction */\nimport { TRANSACTION_TYPES } from 'ripple-binary-codec'\n\nimport { ValidationError } from '../../errors'\nimport { Amount, IssuedCurrencyAmount, Memo, Signer } from '../common'\nimport { onlyHasFields } from '../utils'\n\nconst MEMO_SIZE = 3\n\nfunction isMemo(obj: { Memo?: unknown }): boolean {\n if (obj.Memo == null) {\n return false\n }\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS\n const memo = obj.Memo as Record<string, unknown>\n const size = Object.keys(memo).length\n const validData = memo.MemoData == null || typeof memo.MemoData === 'string'\n const validFormat =\n memo.MemoFormat == null || typeof memo.MemoFormat === 'string'\n const validType = memo.MemoType == null || typeof memo.MemoType === 'string'\n\n return (\n size >= 1 &&\n size <= MEMO_SIZE &&\n validData &&\n validFormat &&\n validType &&\n onlyHasFields(memo, ['MemoFormat', 'MemoData', 'MemoType'])\n )\n}\n\nconst SIGNER_SIZE = 3\n\nfunction isSigner(obj: unknown): boolean {\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS\n const signerWrapper = obj as Record<string, unknown>\n\n if (signerWrapper.Signer == null) {\n return false\n }\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS and Signer is previously unknown\n const signer = signerWrapper.Signer as Record<string, unknown>\n return (\n Object.keys(signer).length === SIGNER_SIZE &&\n typeof signer.Account === 'string' &&\n typeof signer.TxnSignature === 'string' &&\n typeof signer.SigningPubKey === 'string'\n )\n}\n\nconst ISSUED_CURRENCY_SIZE = 3\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n return value !== null && typeof value === 'object'\n}\n\n/**\n * Verify the form and type of an IssuedCurrencyAmount at runtime.\n *\n * @param input - The input to check the form and type of.\n * @returns Whether the IssuedCurrencyAmount is malformed.\n */\nexport function isIssuedCurrency(\n input: unknown,\n): input is IssuedCurrencyAmount {\n return (\n isRecord(input) &&\n Object.keys(input).length === ISSUED_CURRENCY_SIZE &&\n typeof input.value === 'string' &&\n typeof input.issuer === 'string' &&\n typeof input.currency === 'string'\n )\n}\n\n/**\n * Verify the form and type of an Amount at runtime.\n *\n * @param amount - The object to check the form and type of.\n * @returns Whether the Amount is malformed.\n */\nexport function isAmount(amount: unknown): amount is Amount {\n return typeof amount === 'string' || isIssuedCurrency(amount)\n}\n\n// eslint-disable-next-line @typescript-eslint/no-empty-interface -- no global flags right now, so this is fine\nexport interface GlobalFlags {}\n\n/**\n * Every transaction has the same set of common fields.\n */\nexport interface BaseTransaction {\n /** The unique address of the account that initiated the transaction. */\n Account: string\n /**\n * The type of transaction. Valid types include: `Payment`, `OfferCreate`,\n * `SignerListSet`, `EscrowCreate`, `EscrowFinish`, `EscrowCancel`,\n * `PaymentChannelCreate`, `PaymentChannelFund`, `PaymentChannelClaim`, and\n * `DepositPreauth`.\n */\n TransactionType: string\n /**\n * Integer amount of XRP, in drops, to be destroyed as a cost for\n * distributing this transaction to the network. Some transaction types have\n * different minimum requirements.\n */\n Fee?: string\n /**\n * The sequence number of the account sending the transaction. A transaction\n * is only valid if the Sequence number is exactly 1 greater than the previous\n * transaction from the same account. The special case 0 means the transaction\n * is using a Ticket instead.\n */\n Sequence?: number\n /**\n * Hash value identifying another transaction. If provided, this transaction\n * is only valid if the sending account's previously-sent transaction matches\n * the provided hash.\n */\n AccountTxnID?: string\n /** Set of bit-flags for this transaction. */\n Flags?: number | GlobalFlags\n /**\n * Highest ledger index this transaction can appear in. Specifying this field\n * places a strict upper limit on how long the transaction can wait to be\n * validated or rejected.\n */\n LastLedgerSequence?: number\n /**\n * Additional arbitrary information used to identify this transaction.\n */\n Memos?: Memo[]\n /**\n * Array of objects that represent a multi-signature which authorizes this\n * transaction.\n */\n Signers?: Signer[]\n /**\n * Arbitrary integer used to identify the reason for this payment, or a sender\n * on whose behalf this transaction is made. Conventionally, a refund should\n * specify the initial payment's SourceTag as the refund payment's\n * DestinationTag.\n */\n SourceTag?: number\n /**\n * Hex representation of the public key that corresponds to the private key\n * used to sign this transaction. If an empty string, indicates a\n * multi-signature is present in the Signers field instead.\n */\n SigningPubKey?: string\n /**\n * The sequence number of the ticket to use in place of a Sequence number. If\n * this is provided, Sequence must be 0. Cannot be used with AccountTxnID.\n */\n TicketSequence?: number\n /**\n * The signature that verifies this transaction as originating from the\n * account it says it is from.\n */\n TxnSignature?: string\n}\n\n/**\n * Verify the common fields of a transaction. The validate functionality will be\n * optional, and will check transaction form at runtime. This should be called\n * any time a transaction will be verified.\n *\n * @param common - An interface w/ common transaction fields.\n * @throws When the common param is malformed.\n */\nexport function validateBaseTransaction(common: Record<string, unknown>): void {\n if (common.Account === undefined) {\n throw new ValidationError('BaseTransaction: missing field Account')\n }\n\n if (typeof common.Account !== 'string') {\n throw new ValidationError('BaseTransaction: Account not string')\n }\n\n if (common.TransactionType === undefined) {\n throw new ValidationError('BaseTransaction: missing field TransactionType')\n }\n\n if (typeof common.TransactionType !== 'string') {\n throw new ValidationError('BaseTransaction: TransactionType not string')\n }\n\n if (!TRANSACTION_TYPES.includes(common.TransactionType)) {\n throw new ValidationError('BaseTransaction: Unknown TransactionType')\n }\n\n if (common.Fee !== undefined && typeof common.Fee !== 'string') {\n throw new ValidationError('BaseTransaction: invalid Fee')\n }\n\n if (common.Sequence !== undefined && typeof common.Sequence !== 'number') {\n throw new ValidationError('BaseTransaction: invalid Sequence')\n }\n\n if (\n common.AccountTxnID !== undefined &&\n typeof common.AccountTxnID !== 'string'\n ) {\n throw new ValidationError('BaseTransaction: invalid AccountTxnID')\n }\n\n if (\n common.LastLedgerSequence !== undefined &&\n typeof common.LastLedgerSequence !== 'number'\n ) {\n throw new ValidationError('BaseTransaction: invalid LastLedgerSequence')\n }\n\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS\n const memos = common.Memos as Array<{ Memo?: unknown }> | undefined\n if (memos !== undefined && !memos.every(isMemo)) {\n throw new ValidationError('BaseTransaction: invalid Memos')\n }\n\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS\n const signers = common.Signers as Array<Record<string, unknown>> | undefined\n\n if (\n signers !== undefined &&\n (signers.length === 0 || !signers.every(isSigner))\n ) {\n throw new ValidationError('BaseTransaction: invalid Signers')\n }\n\n if (common.SourceTag !== undefined && typeof common.SourceTag !== 'number') {\n throw new ValidationError('BaseTransaction: invalid SourceTag')\n }\n\n if (\n common.SigningPubKey !== undefined &&\n typeof common.SigningPubKey !== 'string'\n ) {\n throw new ValidationError('BaseTransaction: invalid SigningPubKey')\n }\n\n if (\n common.TicketSequence !== undefined &&\n typeof common.TicketSequence !== 'number'\n ) {\n throw new ValidationError('BaseTransaction: invalid TicketSequence')\n }\n\n if (\n common.TxnSignature !== undefined &&\n typeof common.TxnSignature !== 'string'\n ) {\n throw new ValidationError('BaseTransaction: invalid TxnSignature')\n }\n}\n\n/**\n * Parse the value of an amount, expressed either in XRP or as an Issued Currency, into a number.\n *\n * @param amount - An Amount to parse for its value.\n * @returns The parsed amount value, or NaN if the amount count not be parsed.\n */\nexport function parseAmountValue(amount: unknown): number {\n if (!isAmount(amount)) {\n return NaN\n }\n if (typeof amount === 'string') {\n return parseFloat(amount)\n }\n return parseFloat(amount.value)\n}\n","/* eslint-disable complexity -- Necessary for validateDepositPreauth */\nimport { ValidationError } from '../../errors'\n\nimport { BaseTransaction, validateBaseTransaction } from './common'\n\n/**\n * A DepositPreauth transaction gives another account pre-approval to deliver\n * payments to the sender of this transaction. This is only useful if the sender\n * of this transaction is using (or plans to use) Deposit Authorization.\n *\n * @category Transaction Models\n */\nexport interface DepositPreauth extends BaseTransaction {\n TransactionType: 'DepositPreauth'\n /** The XRP Ledger address of the sender to preauthorize. */\n Authorize?: string\n /**\n * The XRP Ledger address of a sender whose preauthorization should be.\n * revoked.\n */\n Unauthorize?: string\n}\n\n/**\n * Verify the form and type of a DepositPreauth at runtime.\n *\n * @param tx - A DepositPreauth Transaction.\n * @throws When the DepositPreauth is malformed.\n */\nexport function validateDepositPreauth(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.Authorize !== undefined && tx.Unauthorize !== undefined) {\n throw new ValidationError(\n \"DepositPreauth: can't provide both Authorize and Unauthorize fields\",\n )\n }\n\n if (tx.Authorize === undefined && tx.Unauthorize === undefined) {\n throw new ValidationError(\n 'DepositPreauth: must provide either Authorize or Unauthorize field',\n )\n }\n\n if (tx.Authorize !== undefined) {\n if (typeof tx.Authorize !== 'string') {\n throw new ValidationError('DepositPreauth: Authorize must be a string')\n }\n\n if (tx.Account === tx.Authorize) {\n throw new ValidationError(\n \"DepositPreauth: Account can't preauthorize its own address\",\n )\n }\n }\n\n if (tx.Unauthorize !== undefined) {\n if (typeof tx.Unauthorize !== 'string') {\n throw new ValidationError('DepositPreauth: Unauthorize must be a string')\n }\n\n if (tx.Account === tx.Unauthorize) {\n throw new ValidationError(\n \"DepositPreauth: Account can't unauthorize its own address\",\n )\n }\n }\n}\n","import { ValidationError } from '../../errors'\n\nimport { BaseTransaction, validateBaseTransaction } from './common'\n\n/**\n * Return escrowed XRP to the sender.\n *\n * @category Transaction Models\n */\nexport interface EscrowCancel extends BaseTransaction {\n TransactionType: 'EscrowCancel'\n /** Address of the source account that funded the escrow payment. */\n Owner: string\n /**\n * Transaction sequence (or Ticket number) of EscrowCreate transaction that.\n * created the escrow to cancel.\n */\n OfferSequence: number\n}\n\n/**\n * Verify the form and type of an EscrowCancel at runtime.\n *\n * @param tx - An EscrowCancel Transaction.\n * @throws When the EscrowCancel is Malformed.\n */\nexport function validateEscrowCancel(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.Owner === undefined) {\n throw new ValidationError('EscrowCancel: missing Owner')\n }\n\n if (typeof tx.Owner !== 'string') {\n throw new ValidationError('EscrowCancel: Owner must be a string')\n }\n\n if (tx.OfferSequence === undefined) {\n throw new ValidationError('EscrowCancel: missing OfferSequence')\n }\n\n if (typeof tx.OfferSequence !== 'number') {\n throw new ValidationError('EscrowCancel: OfferSequence must be a number')\n }\n}\n","/* eslint-disable complexity -- Necessary for validateEscrowCreate */\nimport { ValidationError } from '../../errors'\n\nimport { BaseTransaction, validateBaseTransaction } from './common'\n\n/**\n * Sequester XRP until the escrow process either finishes or is canceled.\n *\n * @category Transaction Models\n */\nexport interface EscrowCreate extends BaseTransaction {\n TransactionType: 'EscrowCreate'\n /**\n * Amount of XRP, in drops, to deduct from the sender's balance and escrow.\n * Once escrowed, the XRP can either go to the Destination address (after the.\n * FinishAfter time) or returned to the sender (after the CancelAfter time).\n */\n Amount: string\n /** Address to receive escrowed XRP. */\n Destination: string\n /**\n * The time, in seconds since the Ripple Epoch, when this escrow expires.\n * This value is immutable; the funds can only be returned the sender after.\n * this time.\n */\n CancelAfter?: number\n /**\n * The time, in seconds since the Ripple Epoch, when the escrowed XRP can be\n * released to the recipient. This value is immutable; the funds cannot move.\n * until this time is reached.\n */\n FinishAfter?: number\n /**\n * Hex value representing a PREIMAGE-SHA-256 crypto-condition . The funds can.\n * only be delivered to the recipient if this condition is fulfilled.\n */\n Condition?: string\n /**\n * Arbitrary tag to further specify the destination for this escrowed.\n * payment, such as a hosted recipient at the destination address.\n */\n DestinationTag?: number\n}\n\n/**\n * Verify the form and type of an EscrowCreate at runtime.\n *\n * @param tx - An EscrowCreate Transaction.\n * @throws When the EscrowCreate is Malformed.\n */\nexport function validateEscrowCreate(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.Amount === undefined) {\n throw new ValidationError('EscrowCreate: missing field Amount')\n }\n\n if (typeof tx.Amount !== 'string') {\n throw new ValidationError('EscrowCreate: Amount must be a string')\n }\n\n if (tx.Destination === undefined) {\n throw new ValidationError('EscrowCreate: missing field Destination')\n }\n\n if (typeof tx.Destination !== 'string') {\n throw new ValidationError('EscrowCreate: Destination must be a string')\n }\n\n if (tx.CancelAfter === undefined && tx.FinishAfter === undefined) {\n throw new ValidationError(\n 'EscrowCreate: Either CancelAfter or FinishAfter must be specified',\n )\n }\n\n if (tx.FinishAfter === undefined && tx.Condition === undefined) {\n throw new ValidationError(\n 'EscrowCreate: Either Condition or FinishAfter must be specified',\n )\n }\n\n if (tx.CancelAfter !== undefined && typeof tx.CancelAfter !== 'number') {\n throw new ValidationError('EscrowCreate: CancelAfter must be a number')\n }\n\n if (tx.FinishAfter !== undefined && typeof tx.FinishAfter !== 'number') {\n throw new ValidationError('EscrowCreate: FinishAfter must be a number')\n }\n\n if (tx.Condition !== undefined && typeof tx.Condition !== 'string') {\n throw new ValidationError('EscrowCreate: Condition must be a string')\n }\n\n if (\n tx.DestinationTag !== undefined &&\n typeof tx.DestinationTag !== 'number'\n ) {\n throw new ValidationError('EscrowCreate: DestinationTag must be a number')\n }\n}\n","import { ValidationError } from '../../errors'\n\nimport { BaseTransaction, validateBaseTransaction } from './common'\n\n/**\n * Deliver XRP from a held payment to the recipient.\n *\n * @category Transaction Models\n */\nexport interface EscrowFinish extends BaseTransaction {\n TransactionType: 'EscrowFinish'\n /** Address of the source account that funded the held payment. */\n Owner: string\n /**\n * Transaction sequence of EscrowCreate transaction that created the held.\n * payment to finish.\n */\n OfferSequence: number\n /**\n * Hex value matching the previously-supplied PREIMAGE-SHA-256.\n * crypto-condition of the held payment.\n */\n Condition?: string\n /**\n * Hex value of the PREIMAGE-SHA-256 crypto-condition fulfillment matching.\n * the held payment's Condition.\n */\n Fulfillment?: string\n}\n\n/**\n * Verify the form and type of an EscrowFinish at runtime.\n *\n * @param tx - An EscrowFinish Transaction.\n * @throws When the EscrowFinish is Malformed.\n */\nexport function validateEscrowFinish(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.Owner === undefined) {\n throw new ValidationError('EscrowFinish: missing field Owner')\n }\n\n if (typeof tx.Owner !== 'string') {\n throw new ValidationError('EscrowFinish: Owner must be a string')\n }\n\n if (tx.OfferSequence === undefined) {\n throw new ValidationError('EscrowFinish: missing field OfferSequence')\n }\n\n if (typeof tx.OfferSequence !== 'number') {\n throw new ValidationError('EscrowFinish: OfferSequence must be a number')\n }\n\n if (tx.Condition !== undefined && typeof tx.Condition !== 'string') {\n throw new ValidationError('EscrowFinish: Condition must be a string')\n }\n\n if (tx.Fulfillment !== undefined && typeof tx.Fulfillment !== 'string') {\n throw new ValidationError('EscrowFinish: Fulfillment must be a string')\n }\n}\n","export { validate, TransactionAndMetadata, Transaction } from './transaction'\nexport { TransactionMetadata } from './metadata'\nexport {\n AccountSetAsfFlags,\n AccountSetTfFlags,\n AccountSetFlagsInterface,\n AccountSet,\n} from './accountSet'\nexport { AccountDelete } from './accountDelete'\nexport { CheckCancel } from './checkCancel'\nexport { CheckCash } from './checkCash'\nexport { CheckCreate } from './checkCreate'\nexport { DepositPreauth } from './depositPreauth'\nexport { EscrowCancel } from './escrowCancel'\nexport { EscrowCreate } from './escrowCreate'\nexport { EscrowFinish } from './escrowFinish'\nexport { NFTokenAcceptOffer } from './NFTokenAcceptOffer'\nexport { NFTokenBurn } from './NFTokenBurn'\nexport { NFTokenCancelOffer } from './NFTokenCancelOffer'\nexport {\n NFTokenCreateOffer,\n NFTokenCreateOfferFlags,\n NFTokenCreateOfferFlagsInterface,\n} from './NFTokenCreateOffer'\nexport {\n NFTokenMint,\n NFTokenMintFlags,\n NFTokenMintFlagsInterface,\n} from './NFTokenMint'\nexport { OfferCancel } from './offerCancel'\nexport {\n OfferCreateFlags,\n OfferCreateFlagsInterface,\n OfferCreate,\n} from './offerCreate'\nexport { PaymentFlags, PaymentFlagsInterface, Payment } from './payment'\nexport {\n PaymentChannelClaimFlags,\n PaymentChannelClaimFlagsInterface,\n PaymentChannelClaim,\n} from './paymentChannelClaim'\nexport { PaymentChannelCreate } from './paymentChannelCreate'\nexport { PaymentChannelFund } from './paymentChannelFund'\nexport { SetRegularKey } from './setRegularKey'\nexport { SignerListSet } from './signerListSet'\nexport { TicketCreate } from './ticketCreate'\nexport { TrustSetFlagsInterface, TrustSetFlags, TrustSet } from './trustSet'\n","import { Amount } from '../common'\n\nexport interface CreatedNode {\n CreatedNode: {\n LedgerEntryType: string\n LedgerIndex: string\n NewFields: { [field: string]: unknown }\n }\n}\n\nexport interface ModifiedNode {\n ModifiedNode: {\n LedgerEntryType: string\n LedgerIndex: string\n FinalFields?: { [field: string]: unknown }\n PreviousFields?: { [field: string]: unknown }\n PreviousTxnID?: string\n PreviousTxnLgrSeq?: number\n }\n}\n\nexport interface DeletedNode {\n DeletedNode: {\n LedgerEntryType: string\n LedgerIndex: string\n FinalFields: { [field: string]: unknown }\n }\n}\n\nexport type Node = CreatedNode | ModifiedNode | DeletedNode\n\n/**\n * A typeguard to check if a node is a CreatedNode.\n *\n * @param node - A node from metadata.\n * @returns whether the given node is a CreatedNode.\n */\nexport function isCreatedNode(node: Node): node is CreatedNode {\n return Object.prototype.hasOwnProperty.call(node, `CreatedNode`)\n}\n\n/**\n * A typeguard to check if a node is a ModifiedNode.\n *\n * @param node - A node from metadata.\n * @returns whether the given node is a ModifiedNode.\n */\nexport function isModifiedNode(node: Node): node is ModifiedNode {\n return Object.prototype.hasOwnProperty.call(node, `ModifiedNode`)\n}\n\n/**\n * A typeguard to check if a node is a DeletedNode.\n *\n * @param node - A node from metadata.\n * @returns whether the given node is a DeletedNode.\n */\nexport function isDeletedNode(node: Node): node is DeletedNode {\n return Object.prototype.hasOwnProperty.call(node, `DeletedNode`)\n}\n\nexport interface TransactionMetadata {\n AffectedNodes: Node[]\n DeliveredAmount?: Amount\n // \"unavailable\" possible for transactions before 2014-01-20\n delivered_amount?: Amount | 'unavailable'\n TransactionIndex: number\n TransactionResult: string\n}\n","import { ValidationError } from '../../errors'\n\nimport { BaseTransaction, validateBaseTransaction } from './common'\n\n/**\n * An OfferCancel transaction removes an Offer object from the XRP Ledger.\n *\n * @category Transaction Models\n */\nexport interface OfferCancel extends BaseTransaction {\n TransactionType: 'OfferCancel'\n /**\n * The sequence number (or Ticket number) of a previous OfferCreate\n * transaction. If specified, cancel any offer object in the ledger that was\n * created by that transaction. It is not considered an error if the offer.\n * specified does not exist.\n */\n OfferSequence: number\n}\n\n/**\n * Verify the form and type of an OfferCancel at runtime.\n *\n * @param tx - An OfferCancel Transaction.\n * @throws When the OfferCancel is Malformed.\n */\nexport function validateOfferCancel(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.OfferSequence === undefined) {\n throw new ValidationError('OfferCancel: missing field OfferSequence')\n }\n\n if (typeof tx.OfferSequence !== 'number') {\n throw new ValidationError('OfferCancel: OfferSequence must be a number')\n }\n}\n","/* eslint-disable complexity -- Necessary for validateOfferCreate */\nimport { ValidationError } from '../../errors'\nimport { Amount } from '../common'\n\nimport {\n BaseTransaction,\n GlobalFlags,\n validateBaseTransaction,\n isAmount,\n} from './common'\n\n/**\n * Transaction Flags for an OfferCreate Transaction.\n *\n * @category Transaction Flags\n */\nexport enum OfferCreateFlags {\n /**\n * If enabled, the offer does not consume offers that exactly match it, and\n * instead becomes an Offer object in the ledger. It still consumes offers\n * that cross it.\n */\n tfPassive = 0x00010000,\n /**\n * Treat the offer as an Immediate or Cancel order. If enabled, the offer\n * never becomes a ledger object: it only tries to match existing offers in\n * the ledger. If the offer cannot match any offers immediately, it executes\n * \"successfully\" without trading any currency. In this case, the transaction\n * has the result code tesSUCCESS, but creates no Offer objects in the ledger.\n */\n tfImmediateOrCancel = 0x00020000,\n /**\n * Treat the offer as a Fill or Kill order . Only try to match existing\n * offers in the ledger, and only do so if the entire TakerPays quantity can\n * be obtained. If the fix1578 amendment is enabled and the offer cannot be\n * executed when placed, the transaction has the result code tecKILLED;\n * otherwise, the transaction uses the result code tesSUCCESS even when it was\n * killed without trading any currency.\n */\n tfFillOrKill = 0x00040000,\n /**\n * Exchange the entire TakerGets amount, even if it means obtaining more than\n * the TakerPays amount in exchange.\n */\n tfSell = 0x00080000,\n}\n\n/**\n * Map of flags to boolean values representing {@link OfferCreate} transaction\n * flags.\n *\n * @category Transaction Flags\n *\n * @example\n * ```typescript\n * const tx: OfferCreate = {\n * Account: 'rhFcpWDHLqpBmX4ezWiA5VLSS4e1BHqhHd',\n * TakerGets: '43000.51',\n * TakerPays: '12928290425',\n * TransactionType: 'OfferCreate',\n * Flags: {\n * tfPassive: true,\n * tfFillOrKill: true,\n * },\n * }\n *\n * // Autofill the tx to see how flags actually look compared to the interface usage.\n * const autofilledTx = await client.autofill(tx)\n * console.log(autofilledTx)\n * // {\n * // Account: 'rhFcpWDHLqpBmX4ezWiA5VLSS4e1BHqhHd',\n * // TakerGets: '43000.51',\n * // TakerPays: '12928290425',\n * // TransactionType: 'OfferCreate',\n * // Flags: 327680,\n * // Sequence: 21970384,\n * // Fee: '12',\n * // LastLedgerSequence: 21970404\n * // }\n * ```\n */\nexport interface OfferCreateFlagsInterface extends GlobalFlags {\n tfPassive?: boolean\n tfImmediateOrCancel?: boolean\n tfFillOrKill?: boolean\n tfSell?: boolean\n}\n\n/**\n * An OfferCreate transaction is effectively a limit order . It defines an\n * intent to exchange currencies, and creates an Offer object if not completely.\n * Fulfilled when placed. Offers can be partially fulfilled.\n *\n * @category Transaction Models\n */\nexport interface OfferCreate extends BaseTransaction {\n TransactionType: 'OfferCreate'\n Flags?: number | OfferCreateFlagsInterface\n /**\n * Time after which the offer is no longer active, in seconds since the.\n * Ripple Epoch.\n */\n Expiration?: number\n /** An offer to delete first, specified in the same way as OfferCancel. */\n OfferSequence?: number\n /** The amount and type of currency being provided by the offer creator. */\n TakerGets: Amount\n /** The amount and type of currency being requested by the offer creator. */\n TakerPays: Amount\n}\n\n/**\n * Verify the form and type of an OfferCreate at runtime.\n *\n * @param tx - An OfferCreate Transaction.\n * @throws When the OfferCreate is Malformed.\n */\nexport function validateOfferCreate(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.TakerGets === undefined) {\n throw new ValidationError('OfferCreate: missing field TakerGets')\n }\n\n if (tx.TakerPays === undefined) {\n throw new ValidationError('OfferCreate: missing field TakerPays')\n }\n\n if (typeof tx.TakerGets !== 'string' && !isAmount(tx.TakerGets)) {\n throw new ValidationError('OfferCreate: invalid TakerGets')\n }\n\n if (typeof tx.TakerPays !== 'string' && !isAmount(tx.TakerPays)) {\n throw new ValidationError('OfferCreate: invalid TakerPays')\n }\n\n if (tx.Expiration !== undefined && typeof tx.Expiration !== 'number') {\n throw new ValidationError('OfferCreate: invalid Expiration')\n }\n\n if (tx.OfferSequence !== undefined && typeof tx.OfferSequence !== 'number') {\n throw new ValidationError('OfferCreate: invalid OfferSequence')\n }\n}\n","/* eslint-disable complexity -- Necessary for validatePayment */\nimport { ValidationError } from '../../errors'\nimport { Amount, Path } from '../common'\nimport { isFlagEnabled } from '../utils'\n\nimport {\n BaseTransaction,\n isAmount,\n GlobalFlags,\n validateBaseTransaction,\n} from './common'\n\n/**\n * Enum representing values for Payment Transaction Flags.\n *\n * @category Transaction Flags\n */\nexport enum PaymentFlags {\n /**\n * Do not use the default path; only use paths included in the Paths field.\n * This is intended to force the transaction to take arbitrage opportunities.\n * Most clients do not need this.\n */\n tfNoDirectRipple = 0x00010000,\n /**\n * If the specified Amount cannot be sent without spending more than SendMax,\n * reduce the received amount instead of failing outright. See Partial.\n * Payments for more details.\n */\n tfPartialPayment = 0x00020000,\n /**\n * Only take paths where all the conversions have an input:output ratio that\n * is equal or better than the ratio of Amount:SendMax. See Limit Quality for\n * details.\n */\n tfLimitQuality = 0x00040000,\n}\n\n/**\n * Map of flags to boolean values representing {@link Payment} transaction\n * flags.\n *\n * @category Transaction Flags\n *\n * @example\n * ```typescript\n * const partialPayment: Payment = {\n * TransactionType: 'Payment',\n * Account: 'rM9WCfJU6udpFkvKThRaFHDMsp7L8rpgN',\n * Amount: {\n * currency: 'FOO',\n * value: '4000',\n * issuer: 'rPzwM2JfCSDjhbesdTCqFjWWdK7eFtTwZz',\n * },\n * Destination: 'rPzwM2JfCSDjhbesdTCqFjWWdK7eFtTwZz',\n * Flags: {\n * tfPartialPayment: true\n * }\n * }\n *\n * // Autofill the tx to see how flags actually look compared to the interface usage.\n * const autofilledTx = await client.autofill(partialPayment)\n * console.log(autofilledTx)\n * // {\n * // TransactionType: 'Payment',\n * // Account: 'rM9WCfJU6udpFkvKThRaFHDMsp7L8rpgN',\n * // Amount: {\n * // currency: 'FOO',\n * // value: '4000',\n * // issuer: 'rPzwM2JfCSDjhbesdTCqFjWWdK7eFtTwZz'\n * // },\n * // Destination: 'rPzwM2JfCSDjhbesdTCqFjWWdK7eFtTwZz',\n * // Flags: 131072,\n * // Sequence: 21970996,\n * // Fee: '12',\n * // LastLedgerSequence: 21971016\n * // }\n * ```\n */\nexport interface PaymentFlagsInterface extends GlobalFlags {\n /**\n * Do not use the default path; only use paths included in the Paths field.\n * This is intended to force the transaction to take arbitrage opportunities.\n * Most clients do not need this.\n */\n tfNoDirectRipple?: boolean\n /**\n * If the specified Amount cannot be sent without spending more than SendMax,\n * reduce the received amount instead of failing outright. See Partial.\n * Payments for more details.\n */\n tfPartialPayment?: boolean\n /**\n * Only take paths where all the conversions have an input:output ratio that\n * is equal or better than the ratio of Amount:SendMax. See Limit Quality for\n * details.\n */\n tfLimitQuality?: boolean\n}\n\n/**\n * A Payment transaction represents a transfer of value from one account to\n * another.\n *\n * @category Transaction Models\n */\nexport interface Payment extends BaseTransaction {\n TransactionType: 'Payment'\n /**\n * The amount of currency to deliver. For non-XRP amounts, the nested field\n * names MUST be lower-case. If the tfPartialPayment flag is set, deliver up\n * to this amount instead.\n */\n Amount: Amount\n /** The unique address of the account receiving the payment. */\n Destination: string\n /**\n * Arbitrary tag that identifies the reason for the payment to the\n * destination, or a hosted recipient to pay.\n */\n DestinationTag?: number\n /**\n * Arbitrary 256-bit hash representing a specific reason or identifier for\n * this payment.\n */\n InvoiceID?: string\n /**\n * Array of payment paths to be used for this transaction. Must be omitted\n * for XRP-to-XRP transactions.\n */\n Paths?: Path[]\n /**\n * Highest amount of source currency this transaction is allowed to cost,\n * including transfer fees, exchange rates, and slippage . Does not include\n * the XRP destroyed as a cost for submitting the transaction. For non-XRP\n * amounts, the nested field names MUST be lower-case. Must be supplied for\n * cross-currency/cross-issue payments. Must be omitted for XRP-to-XRP\n * Payments.\n */\n SendMax?: Amount\n /**\n * Minimum amount of destination currency this transaction should deliver.\n * Only valid if this is a partial payment. For non-XRP amounts, the nested\n * field names are lower-case.\n */\n DeliverMin?: Amount\n Flags?: number | PaymentFlagsInterface\n}\n\n/**\n * Verify the form and type of a Payment at runtime.\n *\n * @param tx - A Payment Transaction.\n * @throws When the Payment is malformed.\n */\nexport function validatePayment(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.Amount === undefined) {\n throw new ValidationError('PaymentTransaction: missing field Amount')\n }\n\n if (!isAmount(tx.Amount)) {\n throw new ValidationError('PaymentTransaction: invalid Amount')\n }\n\n if (tx.Destination === undefined) {\n throw new ValidationError('PaymentTransaction: missing field Destination')\n }\n\n if (!isAmount(tx.Destination)) {\n throw new ValidationError('PaymentTransaction: invalid Destination')\n }\n\n if (tx.DestinationTag != null && typeof tx.DestinationTag !== 'number') {\n throw new ValidationError(\n 'PaymentTransaction: DestinationTag must be a number',\n )\n }\n\n if (tx.InvoiceID !== undefined && typeof tx.InvoiceID !== 'string') {\n throw new ValidationError('PaymentTransaction: InvoiceID must be a string')\n }\n\n if (\n tx.Paths !== undefined &&\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS\n !isPaths(tx.Paths as Array<Array<Record<string, unknown>>>)\n ) {\n throw new ValidationError('PaymentTransaction: invalid Paths')\n }\n\n if (tx.SendMax !== undefined && !isAmount(tx.SendMax)) {\n throw new ValidationError('PaymentTransaction: invalid SendMax')\n }\n\n checkPartialPayment(tx)\n}\n\nfunction checkPartialPayment(tx: Record<string, unknown>): void {\n if (tx.DeliverMin != null) {\n if (tx.Flags == null) {\n throw new ValidationError(\n 'PaymentTransaction: tfPartialPayment flag required with DeliverMin',\n )\n }\n\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Only used by JS\n const flags = tx.Flags as number | PaymentFlagsInterface\n const isTfPartialPayment =\n typeof flags === 'number'\n ? isFlagEnabled(flags, PaymentFlags.tfPartialPayment)\n : flags.tfPartialPayment ?? false\n\n if (!isTfPartialPayment) {\n throw new ValidationError(\n 'PaymentTransaction: tfPartialPayment flag required with DeliverMin',\n )\n }\n\n if (!isAmount(tx.DeliverMin)) {\n throw new ValidationError('PaymentTransaction: invalid DeliverMin')\n }\n }\n}\n\nfunction isPathStep(pathStep: Record<string, unknown>): boolean {\n if (pathStep.account !== undefined && typeof pathStep.account !== 'string') {\n return false\n }\n if (\n pathStep.currency !== undefined &&\n typeof pathStep.currency !== 'string'\n ) {\n return false\n }\n if (pathStep.issuer !== undefined && typeof pathStep.issuer !== 'string') {\n return false\n }\n if (\n pathStep.account !== undefined &&\n pathStep.currency === undefined &&\n pathStep.issuer === undefined\n ) {\n return true\n }\n if (pathStep.currency !== undefined || pathStep.issuer !== undefined) {\n return true\n }\n return false\n}\n\nfunction isPath(path: Array<Record<string, unknown>>): boolean {\n for (const pathStep of path) {\n if (!isPathStep(pathStep)) {\n return false\n }\n }\n return true\n}\n\nfunction isPaths(paths: Array<Array<Record<string, unknown>>>): boolean {\n if (!Array.isArray(paths) || paths.length === 0) {\n return false\n }\n\n for (const path of paths) {\n if (!Array.isArray(path) || path.length === 0) {\n return false\n }\n\n if (!isPath(path)) {\n return false\n }\n }\n\n return true\n}\n","/* eslint-disable complexity -- Necessary for validatePaymentChannelClaim */\nimport { ValidationError } from '../../errors'\n\nimport { BaseTransaction, GlobalFlags, validateBaseTransaction } from './common'\n\n/**\n * Enum representing values for PaymentChannelClaim transaction flags.\n *\n * @category Transaction Flags\n */\nexport enum PaymentChannelClaimFlags {\n /**\n * Clear the channel's Expiration time. (Expiration is different from the\n * channel's immutable CancelAfter time.) Only the source address of the\n * payment channel can use this flag.\n */\n tfRenew = 0x00010000,\n /**\n * Request to close the channel. Only the channel source and destination\n * addresses can use this flag. This flag closes the channel immediately if it\n * has no more XRP allocated to it after processing the current claim, or if\n * the destination address uses it. If the source address uses this flag when\n * the channel still holds XRP, this schedules the channel to close after\n * SettleDelay seconds have passed. (Specifically, this sets the Expiration of\n * the channel to the close time of the previous ledger plus the channel's\n * SettleDelay time, unless the channel already has an earlier Expiration\n * time.) If the destination address uses this flag when the channel still\n * holds XRP, any XRP that remains after processing the claim is returned to\n * the source address.\n */\n tfClose = 0x00020000,\n}\n\n/**\n * Map of flags to boolean values representing {@link PaymentChannelClaim}\n * transaction flags.\n *\n * @category Transaction Flags\n *\n * @example\n * ```typescript\n * const paymentChannelClaim: PaymentChannelClaim = {\n * Account: 'rMpxZpuy5RBSP47oK2hDWUtk3B5BNQHfGj,\n * TransactionType: 'PaymentChannelClaim',\n * Channel: hashes.hashPaymentChannel(\n * 'rMpxZpuy5RBSP47oK2hDWUtk3B5BNQHfGj',\n * 'rQGYqiyH5Ue9J96p4E6Qt6AvqxK4sDhnS5',\n * 21970712,\n * ),\n * Amount: '100',\n * Flags: {\n * tfClose: true\n * }\n *}\n *\n * // Autofill the tx to see how flags actually look compared to the interface usage.\n * const autofilledTx = await client.autofill(paymentChannelClaim)\n * console.log(autofilledTx)\n * // {\n * // Account: 'rMpxZpuy5RBSP47oK2hDWUtk3B5BNQHfGj',\n * // TransactionType: 'PaymentChannelClaim',\n * // Channel: 'FC14BF9245D731DC1749EE0F070765E4EB4E993F8ECEE3D00F7E6E26D6EF98CF',\n * // Amount: '100',\n * // Flags: 131072,\n * // Sequence: 21970713,\n * // Fee: '12',\n * // LastLedgerSequence: 21970658\n * // }\n * ```\n */\nexport interface PaymentChannelClaimFlagsInterface extends GlobalFlags {\n /**\n * Clear the channel's Expiration time. (Expiration is different from the\n * channel's immutable CancelAfter time.) Only the source address of the\n * payment channel can use this flag.\n */\n tfRenew?: boolean\n /**\n * Request to close the channel. Only the channel source and destination\n * addresses can use this flag. This flag closes the channel immediately if it\n * has no more XRP allocated to it after processing the current claim, or if\n * the destination address uses it. If the source address uses this flag when\n * the channel still holds XRP, this schedules the channel to close after\n * SettleDelay seconds have passed. (Specifically, this sets the Expiration of\n * the channel to the close time of the previous ledger plus the channel's\n * SettleDelay time, unless the channel already has an earlier Expiration\n * time.) If the destination address uses this flag when the channel still\n * holds XRP, any XRP that remains after processing the claim is returned to\n * the source address.\n */\n tfClose?: boolean\n}\n\n/**\n * Claim XRP from a payment channel, adjust the payment channel's expiration,\n * or both.\n *\n * @category Transaction Models\n */\nexport interface PaymentChannelClaim extends BaseTransaction {\n TransactionType: 'PaymentChannelClaim'\n Flags?: number | PaymentChannelClaimFlagsInterface\n /** The unique ID of the channel as a 64-character hexadecimal string. */\n Channel: string\n /**\n * Total amount of XRP, in drops, delivered by this channel after processing\n * this claim. Required to deliver XRP. Must be more than the total amount\n * delivered by the channel so far, but not greater than the Amount of the\n * signed claim. Must be provided except when closing the channel.\n */\n Balance?: string\n /**\n * The amount of XRP, in drops, authorized by the Signature. This must match\n * the amount in the signed message. This is the cumulative amount of XRP that\n * can be dispensed by the channel, including XRP previously redeemed.\n */\n Amount?: string\n /**\n * The signature of this claim, as hexadecimal. The signed message contains\n * the channel ID and the amount of the claim. Required unless the sender of\n * the transaction is the source address of the channel.\n */\n Signature?: string\n /**\n * The public key used for the signature, as hexadecimal. This must match the\n * PublicKey stored in the ledger for the channel. Required unless the sender\n * of the transaction is the source address of the channel and the Signature\n * field is omitted.\n */\n PublicKey?: string\n}\n\n/**\n * Verify the form and type of an PaymentChannelClaim at runtime.\n *\n * @param tx - An PaymentChannelClaim Transaction.\n * @throws When the PaymentChannelClaim is Malformed.\n */\nexport function validatePaymentChannelClaim(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.Channel === undefined) {\n throw new ValidationError('PaymentChannelClaim: missing Channel')\n }\n\n if (typeof tx.Channel !== 'string') {\n throw new ValidationError('PaymentChannelClaim: Channel must be a string')\n }\n\n if (tx.Balance !== undefined && typeof tx.Balance !== 'string') {\n throw new ValidationError('PaymentChannelClaim: Balance must be a string')\n }\n\n if (tx.Amount !== undefined && typeof tx.Amount !== 'string') {\n throw new ValidationError('PaymentChannelClaim: Amount must be a string')\n }\n\n if (tx.Signature !== undefined && typeof tx.Signature !== 'string') {\n throw new ValidationError('PaymentChannelClaim: Signature must be a string')\n }\n\n if (tx.PublicKey !== undefined && typeof tx.PublicKey !== 'string') {\n throw new ValidationError('PaymentChannelClaim: PublicKey must be a string')\n }\n}\n","/* eslint-disable complexity -- Necessary for validatePaymentChannelCreate */\nimport { ValidationError } from '../../errors'\n\nimport { BaseTransaction, validateBaseTransaction } from './common'\n\n/**\n * Create a unidirectional channel and fund it with XRP. The address sending\n * this transaction becomes the \"source address\" of the payment channel.\n *\n * @category Transaction Models\n */\nexport interface PaymentChannelCreate extends BaseTransaction {\n TransactionType: 'PaymentChannelCreate'\n /**\n * Amount of XRP, in drops, to deduct from the sender's balance and set aside\n * in this channel. While the channel is open, the XRP can only go to the\n * Destination address. When the channel closes, any unclaimed XRP is returned\n * to the source address's balance.\n */\n Amount: string\n /**\n * Address to receive XRP claims against this channel. This is also known as\n * the \"destination address\" for the channel.\n */\n Destination: string\n /**\n * Amount of time the source address must wait before closing the channel if\n * it has unclaimed XRP.\n */\n SettleDelay: number\n /**\n * The public key of the key pair the source will use to sign claims against\n * this channel in hexadecimal. This can be any secp256k1 or ed25519 public\n * key.\n */\n PublicKey: string\n /**\n * The time, in seconds since the Ripple Epoch, when this channel expires.\n * Any transaction that would modify the channel after this time closes the\n * channel without otherwise affecting it. This value is immutable; the\n * channel can be closed earlier than this time but cannot remain open after\n * this time.\n */\n CancelAfter?: number\n /**\n * Arbitrary tag to further specify the destination for this payment channel,\n * such as a hosted recipient at the destination address.\n */\n DestinationTag?: number\n}\n\n/**\n * Verify the form and type of an PaymentChannelCreate at runtime.\n *\n * @param tx - An PaymentChannelCreate Transaction.\n * @throws When the PaymentChannelCreate is Malformed.\n */\n// eslint-disable-next-line max-lines-per-function -- okay for this function, there's a lot of things to check\nexport function validatePaymentChannelCreate(\n tx: Record<string, unknown>,\n): void {\n validateBaseTransaction(tx)\n\n if (tx.Amount === undefined) {\n throw new ValidationError('PaymentChannelCreate: missing Amount')\n }\n\n if (typeof tx.Amount !== 'string') {\n throw new ValidationError('PaymentChannelCreate: Amount must be a string')\n }\n\n if (tx.Destination === undefined) {\n throw new ValidationError('PaymentChannelCreate: missing Destination')\n }\n\n if (typeof tx.Destination !== 'string') {\n throw new ValidationError(\n 'PaymentChannelCreate: Destination must be a string',\n )\n }\n\n if (tx.SettleDelay === undefined) {\n throw new ValidationError('PaymentChannelCreate: missing SettleDelay')\n }\n\n if (typeof tx.SettleDelay !== 'number') {\n throw new ValidationError(\n 'PaymentChannelCreate: SettleDelay must be a number',\n )\n }\n\n if (tx.PublicKey === undefined) {\n throw new ValidationError('PaymentChannelCreate: missing PublicKey')\n }\n\n if (typeof tx.PublicKey !== 'string') {\n throw new ValidationError(\n 'PaymentChannelCreate: PublicKey must be a string',\n )\n }\n\n if (tx.CancelAfter !== undefined && typeof tx.CancelAfter !== 'number') {\n throw new ValidationError(\n 'PaymentChannelCreate: CancelAfter must be a number',\n )\n }\n\n if (\n tx.DestinationTag !== undefined &&\n typeof tx.DestinationTag !== 'number'\n ) {\n throw new ValidationError(\n 'PaymentChannelCreate: DestinationTag must be a number',\n )\n }\n}\n","import { ValidationError } from '../../errors'\n\nimport { BaseTransaction, validateBaseTransaction } from './common'\n\n/**\n * Add additional XRP to an open payment channel, and optionally update the\n * expiration time of the channel. Only the source address of the channel can\n * use this transaction.\n *\n * @category Transaction Models\n */\nexport interface PaymentChannelFund extends BaseTransaction {\n TransactionType: 'PaymentChannelFund'\n /**\n * The unique ID of the channel to fund as a 64-character hexadecimal\n * string.\n */\n Channel: string\n /**\n * Amount of XRP in drops to add to the channel. Must be a positive amount\n * of XRP.\n */\n Amount: string\n /**\n * New Expiration time to set for the channel in seconds since the Ripple\n * Epoch. This must be later than either the current time plus the SettleDelay\n * of the channel, or the existing Expiration of the channel. After the\n * Expiration time, any transaction that would access the channel closes the\n * channel without taking its normal action. Any unspent XRP is returned to\n * the source address when the channel closes. (Expiration is separate from\n * the channel's immutable CancelAfter time.) For more information, see the\n * PayChannel ledger object type.\n */\n Expiration?: number\n}\n\n/**\n * Verify the form and type of an PaymentChannelFund at runtime.\n *\n * @param tx - An PaymentChannelFund Transaction.\n * @throws When the PaymentChannelFund is Malformed.\n */\nexport function validatePaymentChannelFund(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.Channel === undefined) {\n throw new ValidationError('PaymentChannelFund: missing Channel')\n }\n\n if (typeof tx.Channel !== 'string') {\n throw new ValidationError('PaymentChannelFund: Channel must be a string')\n }\n\n if (tx.Amount === undefined) {\n throw new ValidationError('PaymentChannelFund: missing Amount')\n }\n\n if (typeof tx.Amount !== 'string') {\n throw new ValidationError('PaymentChannelFund: Amount must be a string')\n }\n\n if (tx.Expiration !== undefined && typeof tx.Expiration !== 'number') {\n throw new ValidationError('PaymentChannelFund: Expiration must be a number')\n }\n}\n","import { ValidationError } from '../../errors'\n\nimport { BaseTransaction, validateBaseTransaction } from './common'\n\n/**\n * A SetRegularKey transaction assigns, changes, or removes the regular key\n * pair associated with an account.\n *\n * @category Transaction Models\n */\nexport interface SetRegularKey extends BaseTransaction {\n TransactionType: 'SetRegularKey'\n /**\n * A base-58-encoded Address that indicates the regular key pair to be\n * assigned to the account. If omitted, removes any existing regular key pair.\n * from the account. Must not match the master key pair for the address.\n */\n RegularKey?: string\n}\n\n/**\n * Verify the form and type of a SetRegularKey at runtime.\n *\n * @param tx - A SetRegularKey Transaction.\n * @throws When the SetRegularKey is malformed.\n */\nexport function validateSetRegularKey(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.RegularKey !== undefined && typeof tx.RegularKey !== 'string') {\n throw new ValidationError('SetRegularKey: RegularKey must be a string')\n }\n}\n","import { ValidationError } from '../../errors'\nimport { SignerEntry } from '../common'\n\nimport { BaseTransaction, validateBaseTransaction } from './common'\n\n/**\n * The SignerListSet transaction creates, replaces, or removes a list of\n * signers that can be used to multi-sign a transaction.\n *\n * @category Transaction Models\n */\nexport interface SignerListSet extends BaseTransaction {\n TransactionType: 'SignerListSet'\n /**\n * A target number for the signer weights. A multi-signature from this list\n * is valid only if the sum weights of the signatures provided is greater than\n * or equal to this value. To delete a signer list, use the value 0.\n */\n SignerQuorum: number\n /**\n * Array of SignerEntry objects, indicating the addresses and weights of\n * signers in this list. This signer list must have at least 1 member and no\n * more than 32 members. No address may appear more than once in the list, nor\n * may the Account submitting the transaction appear in the list.\n */\n SignerEntries: SignerEntry[]\n}\n\nconst MAX_SIGNERS = 32\n\nconst HEX_WALLET_LOCATOR_REGEX = /^[0-9A-Fa-f]{64}$/u\n\n/**\n * Verify the form and type of an SignerListSet at runtime.\n *\n * @param tx - An SignerListSet Transaction.\n * @throws When the SignerListSet is Malformed.\n */\nexport function validateSignerListSet(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n\n if (tx.SignerQuorum === undefined) {\n throw new ValidationError('SignerListSet: missing field SignerQuorum')\n }\n\n if (typeof tx.SignerQuorum !== 'number') {\n throw new ValidationError('SignerListSet: invalid SignerQuorum')\n }\n\n if (tx.SignerEntries === undefined) {\n throw new ValidationError('SignerListSet: missing field SignerEntries')\n }\n\n if (!Array.isArray(tx.SignerEntries)) {\n throw new ValidationError('SignerListSet: invalid SignerEntries')\n }\n\n if (tx.SignerEntries.length === 0) {\n throw new ValidationError(\n 'SignerListSet: need at least 1 member in SignerEntries',\n )\n }\n\n if (tx.SignerEntries.length > MAX_SIGNERS) {\n throw new ValidationError(\n `SignerListSet: maximum of ${MAX_SIGNERS} members allowed in SignerEntries`,\n )\n }\n\n for (const entry of tx.SignerEntries) {\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Should be a SignerEntry\n const signerEntry = entry as SignerEntry\n const { WalletLocator } = signerEntry.SignerEntry\n if (\n WalletLocator !== undefined &&\n !HEX_WALLET_LOCATOR_REGEX.test(WalletLocator)\n ) {\n throw new ValidationError(\n `SignerListSet: WalletLocator in SignerEntry must be a 256-bit (32-byte) hexadecimal value`,\n )\n }\n }\n}\n","import { ValidationError } from '../../errors'\n\nimport { BaseTransaction, validateBaseTransaction } from './common'\n\n/**\n * A TicketCreate transaction sets aside one or more sequence numbers as\n * Tickets.\n *\n * @category Transaction Models\n */\nexport interface TicketCreate extends BaseTransaction {\n TransactionType: 'TicketCreate'\n /**\n * How many Tickets to create. This must be a positive number and cannot\n * cause the account to own more than 250 Tickets after executing this\n * transaction.\n */\n TicketCount: number\n}\n\nconst MAX_TICKETS = 250\n\n/**\n * Verify the form and type of a TicketCreate at runtime.\n *\n * @param tx - A TicketCreate Transaction.\n * @throws When the TicketCreate is malformed.\n */\nexport function validateTicketCreate(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n const { TicketCount } = tx\n\n if (TicketCount === undefined) {\n throw new ValidationError('TicketCreate: missing field TicketCount')\n }\n\n if (typeof TicketCount !== 'number') {\n throw new ValidationError('TicketCreate: TicketCount must be a number')\n }\n\n if (\n !Number.isInteger(TicketCount) ||\n TicketCount < 1 ||\n TicketCount > MAX_TICKETS\n ) {\n throw new ValidationError(\n 'TicketCreate: TicketCount must be an integer from 1 to 250',\n )\n }\n}\n","/* eslint-disable complexity -- verifies 19 tx types hence a lot of checks needed */\n/* eslint-disable max-lines-per-function -- need to work with a lot of Tx verifications */\n\nimport isEqual from 'lodash/isEqual'\nimport omitBy from 'lodash/omitBy'\nimport { encode, decode } from 'ripple-binary-codec'\n\nimport { ValidationError } from '../../errors'\nimport { setTransactionFlagsToNumber } from '../utils/flags'\n\nimport { AccountDelete, validateAccountDelete } from './accountDelete'\nimport { AccountSet, validateAccountSet } from './accountSet'\nimport { CheckCancel, validateCheckCancel } from './checkCancel'\nimport { CheckCash, validateCheckCash } from './checkCash'\nimport { CheckCreate, validateCheckCreate } from './checkCreate'\nimport { DepositPreauth, validateDepositPreauth } from './depositPreauth'\nimport { EscrowCancel, validateEscrowCancel } from './escrowCancel'\nimport { EscrowCreate, validateEscrowCreate } from './escrowCreate'\nimport { EscrowFinish, validateEscrowFinish } from './escrowFinish'\nimport { TransactionMetadata } from './metadata'\nimport {\n NFTokenAcceptOffer,\n validateNFTokenAcceptOffer,\n} from './NFTokenAcceptOffer'\nimport { NFTokenBurn, validateNFTokenBurn } from './NFTokenBurn'\nimport {\n NFTokenCancelOffer,\n validateNFTokenCancelOffer,\n} from './NFTokenCancelOffer'\nimport {\n NFTokenCreateOffer,\n validateNFTokenCreateOffer,\n} from './NFTokenCreateOffer'\nimport { NFTokenMint, validateNFTokenMint } from './NFTokenMint'\nimport { OfferCancel, validateOfferCancel } from './offerCancel'\nimport { OfferCreate, validateOfferCreate } from './offerCreate'\nimport { Payment, validatePayment } from './payment'\nimport {\n PaymentChannelClaim,\n validatePaymentChannelClaim,\n} from './paymentChannelClaim'\nimport {\n PaymentChannelCreate,\n validatePaymentChannelCreate,\n} from './paymentChannelCreate'\nimport {\n PaymentChannelFund,\n validatePaymentChannelFund,\n} from './paymentChannelFund'\nimport { SetRegularKey, validateSetRegularKey } from './setRegularKey'\nimport { SignerListSet, validateSignerListSet } from './signerListSet'\nimport { TicketCreate, validateTicketCreate } from './ticketCreate'\nimport { TrustSet, validateTrustSet } from './trustSet'\n\n/**\n * @category Transaction Models\n */\nexport type Transaction =\n | AccountDelete\n | AccountSet\n | CheckCancel\n | CheckCash\n | CheckCreate\n | DepositPreauth\n | EscrowCancel\n | EscrowCreate\n | EscrowFinish\n | NFTokenAcceptOffer\n | NFTokenBurn\n | NFTokenCancelOffer\n | NFTokenCreateOffer\n | NFTokenMint\n | OfferCancel\n | OfferCreate\n | Payment\n | PaymentChannelClaim\n | PaymentChannelCreate\n | PaymentChannelFund\n | SetRegularKey\n | SignerListSet\n | TicketCreate\n | TrustSet\n\n/**\n * @category Transaction Models\n */\nexport interface TransactionAndMetadata {\n transaction: Transaction\n metadata: TransactionMetadata\n}\n\n/**\n * Verifies various Transaction Types.\n * Encode/decode and individual type validation.\n *\n * @param transaction - A Transaction.\n * @throws ValidationError When the Transaction is malformed.\n * @category Utilities\n */\nexport function validate(transaction: Record<string, unknown>): void {\n const tx = { ...transaction }\n if (tx.TransactionType == null) {\n throw new ValidationError('Object does not have a `TransactionType`')\n }\n if (typeof tx.TransactionType !== 'string') {\n throw new ValidationError(\"Object's `TransactionType` is not a string\")\n }\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- okay here\n setTransactionFlagsToNumber(tx as unknown as Transaction)\n switch (tx.TransactionType) {\n case 'AccountDelete':\n validateAccountDelete(tx)\n break\n\n case 'AccountSet':\n validateAccountSet(tx)\n break\n\n case 'CheckCancel':\n validateCheckCancel(tx)\n break\n\n case 'CheckCash':\n validateCheckCash(tx)\n break\n\n case 'CheckCreate':\n validateCheckCreate(tx)\n break\n\n case 'DepositPreauth':\n validateDepositPreauth(tx)\n break\n\n case 'EscrowCancel':\n validateEscrowCancel(tx)\n break\n\n case 'EscrowCreate':\n validateEscrowCreate(tx)\n break\n\n case 'EscrowFinish':\n validateEscrowFinish(tx)\n break\n\n case 'NFTokenAcceptOffer':\n validateNFTokenAcceptOffer(tx)\n break\n\n case 'NFTokenBurn':\n validateNFTokenBurn(tx)\n break\n\n case 'NFTokenCancelOffer':\n validateNFTokenCancelOffer(tx)\n break\n\n case 'NFTokenCreateOffer':\n validateNFTokenCreateOffer(tx)\n break\n\n case 'NFTokenMint':\n validateNFTokenMint(tx)\n break\n\n case 'OfferCancel':\n validateOfferCancel(tx)\n break\n\n case 'OfferCreate':\n validateOfferCreate(tx)\n break\n\n case 'Payment':\n validatePayment(tx)\n break\n\n case 'PaymentChannelClaim':\n validatePaymentChannelClaim(tx)\n break\n\n case 'PaymentChannelCreate':\n validatePaymentChannelCreate(tx)\n break\n\n case 'PaymentChannelFund':\n validatePaymentChannelFund(tx)\n break\n\n case 'SetRegularKey':\n validateSetRegularKey(tx)\n break\n\n case 'SignerListSet':\n validateSignerListSet(tx)\n break\n\n case 'TicketCreate':\n validateTicketCreate(tx)\n break\n\n case 'TrustSet':\n validateTrustSet(tx)\n break\n\n default:\n throw new ValidationError(\n `Invalid field TransactionType: ${tx.TransactionType}`,\n )\n }\n\n if (\n !isEqual(\n decode(encode(tx)),\n omitBy(tx, (value) => value == null),\n )\n ) {\n throw new ValidationError(`Invalid Transaction: ${tx.TransactionType}`)\n }\n}\n","import { ValidationError } from '../../errors'\nimport { IssuedCurrencyAmount } from '../common'\n\nimport {\n BaseTransaction,\n GlobalFlags,\n isAmount,\n validateBaseTransaction,\n} from './common'\n\n/**\n * Enum representing values of {@link TrustSet} transaction flags.\n *\n * @category Transaction Flags\n */\nexport enum TrustSetFlags {\n /**\n * Authorize the other party to hold currency issued by this account. (No\n * effect unless using the asfRequireAuth AccountSet flag.) Cannot be unset.\n */\n tfSetfAuth = 0x00010000,\n /**\n * Enable the No Ripple flag, which blocks rippling between two trust lines.\n * of the same currency if this flag is enabled on both.\n */\n tfSetNoRipple = 0x00020000,\n /** Disable the No Ripple flag, allowing rippling on this trust line. */\n tfClearNoRipple = 0x00040000,\n /** Freeze the trust line. */\n tfSetFreeze = 0x00100000,\n /** Unfreeze the trust line. */\n tfClearFreeze = 0x00200000,\n}\n\n/**\n * Map of flags to boolean values representing {@link TrustSet} transaction\n * flags.\n *\n * @category Transaction Flags\n *\n * @example\n * ```typescript\n *\n * const trustSetTx: TrustSet = {\n * TransactionType: 'TrustSet',\n * Account: wallet2.getClassicAddress(),\n * LimitAmount: {\n * currency: 'FOO',\n * issuer: wallet1.getClassicAddress(),\n * value: '10000000000',\n * },\n * Flags: {\n * tfSetNoRipple: true\n * }\n * }\n *\n * // Autofill the tx to see how flags actually look compared to the interface usage.\n * const autofilledTx = await client.autofill(trustSetTx)\n * console.log(autofilledTx)\n * // {\n * // TransactionType: 'TrustSet',\n * // Account: 'r9dAdQQCBcGajVSeC9CqW3LCugjPDnAkEb',\n * // LimitAmount: {\n * // currency: 'FOO',\n * // issuer: 'rWZzUjo5xGiAoRBqzsndyzonXz47UV8u1',\n * // value: '10000000000'\n * // },\n * // Flags: 131072,\n * // Sequence: 21971483,\n * // Fee: '12',\n * // LastLedgerSequence: 21971503\n * // }\n * ```\n */\nexport interface TrustSetFlagsInterface extends GlobalFlags {\n /**\n * Authorize the other party to hold currency issued by this account. (No\n * effect unless using the asfRequireAuth AccountSet flag.) Cannot be unset.\n */\n tfSetfAuth?: boolean\n /**\n * Enable the No Ripple flag, which blocks rippling between two trust lines\n * of the same currency if this flag is enabled on both.\n */\n tfSetNoRipple?: boolean\n /** Disable the No Ripple flag, allowing rippling on this trust line. */\n tfClearNoRipple?: boolean\n /** Freeze the trust line. */\n tfSetFreeze?: boolean\n /** Unfreeze the trust line. */\n tfClearFreeze?: boolean\n}\n\n/**\n * Create or modify a trust line linking two accounts.\n *\n * @category Transaction Models\n */\nexport interface TrustSet extends BaseTransaction {\n TransactionType: 'TrustSet'\n /**\n * Object defining the trust line to create or modify, in the format of a\n * Currency Amount.\n */\n LimitAmount: IssuedCurrencyAmount\n /**\n * Value incoming balances on this trust line at the ratio of this number per\n * 1,000,000,000 units. A value of 0 is shorthand for treating balances at\n * face value.\n */\n QualityIn?: number\n /**\n * Value outgoing balances on this trust line at the ratio of this number per\n * 1,000,000,000 units. A value of 0 is shorthand for treating balances at\n * face value.\n */\n QualityOut?: number\n Flags?: number | TrustSetFlagsInterface\n}\n\n/**\n * Verify the form and type of a TrustSet at runtime.\n *\n * @param tx - A TrustSet Transaction.\n * @throws When the TrustSet is malformed.\n */\nexport function validateTrustSet(tx: Record<string, unknown>): void {\n validateBaseTransaction(tx)\n const { LimitAmount, QualityIn, QualityOut } = tx\n\n if (LimitAmount === undefined) {\n throw new ValidationError('TrustSet: missing field LimitAmount')\n }\n\n if (!isAmount(LimitAmount)) {\n throw new ValidationError('TrustSet: invalid LimitAmount')\n }\n\n if (QualityIn !== undefined && typeof QualityIn !== 'number') {\n throw new ValidationError('TrustSet: QualityIn must be a number')\n }\n\n if (QualityOut !== undefined && typeof QualityOut !== 'number') {\n throw new ValidationError('TrustSet: QualityOut must be a number')\n }\n}\n","/* eslint-disable no-param-reassign -- param reassign is safe */\n/* eslint-disable no-bitwise -- flags require bitwise operations */\n\nimport { ValidationError } from '../../errors'\nimport {\n AccountRootFlagsInterface,\n AccountRootFlags,\n} from '../ledger/AccountRoot'\nimport {\n AccountSetFlagsInterface,\n AccountSetTfFlags,\n} from '../transactions/accountSet'\nimport { GlobalFlags } from '../transactions/common'\nimport {\n OfferCreateFlagsInterface,\n OfferCreateFlags,\n} from '../transactions/offerCreate'\nimport { PaymentFlagsInterface, PaymentFlags } from '../transactions/payment'\nimport {\n PaymentChannelClaimFlagsInterface,\n PaymentChannelClaimFlags,\n} from '../transactions/paymentChannelClaim'\nimport type { Transaction } from '../transactions/transaction'\nimport { TrustSetFlagsInterface, TrustSetFlags } from '../transactions/trustSet'\n\nimport { isFlagEnabled } from '.'\n\n/**\n * Convert an AccountRoot Flags number into an interface for easy interpretation.\n *\n * @param flags - A number which is the bitwise and of all enabled AccountRootFlagsInterface.\n * @returns An interface with all flags as booleans.\n */\nexport function parseAccountRootFlags(\n flags: number,\n): AccountRootFlagsInterface {\n const flagsInterface: AccountRootFlagsInterface = {}\n\n Object.keys(AccountRootFlags).forEach((flag) => {\n if (isFlagEnabled(flags, AccountRootFlags[flag])) {\n flagsInterface[flag] = true\n }\n })\n\n return flagsInterface\n}\n\n/**\n * Sets a transaction's flags to its numeric representation.\n *\n * @param tx - A transaction to set its flags to its numeric representation.\n */\nexport function setTransactionFlagsToNumber(tx: Transaction): void {\n if (tx.Flags == null) {\n tx.Flags = 0\n return\n }\n if (typeof tx.Flags === 'number') {\n return\n }\n\n switch (tx.TransactionType) {\n case 'AccountSet':\n tx.Flags = convertAccountSetFlagsToNumber(tx.Flags)\n return\n case 'OfferCreate':\n tx.Flags = convertOfferCreateFlagsToNumber(tx.Flags)\n return\n case 'PaymentChannelClaim':\n tx.Flags = convertPaymentChannelClaimFlagsToNumber(tx.Flags)\n return\n case 'Payment':\n tx.Flags = convertPaymentTransactionFlagsToNumber(tx.Flags)\n return\n case 'TrustSet':\n tx.Flags = convertTrustSetFlagsToNumber(tx.Flags)\n return\n default:\n tx.Flags = 0\n }\n}\n\nfunction convertAccountSetFlagsToNumber(\n flags: AccountSetFlagsInterface,\n): number {\n return reduceFlags(flags, AccountSetTfFlags)\n}\n\nfunction convertOfferCreateFlagsToNumber(\n flags: OfferCreateFlagsInterface,\n): number {\n return reduceFlags(flags, OfferCreateFlags)\n}\n\nfunction convertPaymentChannelClaimFlagsToNumber(\n flags: PaymentChannelClaimFlagsInterface,\n): number {\n return reduceFlags(flags, PaymentChannelClaimFlags)\n}\n\nfunction convertPaymentTransactionFlagsToNumber(\n flags: PaymentFlagsInterface,\n): number {\n return reduceFlags(flags, PaymentFlags)\n}\n\nfunction convertTrustSetFlagsToNumber(flags: TrustSetFlagsInterface): number {\n return reduceFlags(flags, TrustSetFlags)\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any -- added ValidationError check for flagEnum\nfunction reduceFlags(flags: GlobalFlags, flagEnum: any): number {\n return Object.keys(flags).reduce((resultFlags, flag) => {\n // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- safe member access\n if (flagEnum[flag] == null) {\n throw new ValidationError(\n `flag ${flag} doesn't exist in flagEnum: ${JSON.stringify(flagEnum)}`,\n )\n }\n // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access -- safe member access\n return flags[flag] ? resultFlags | flagEnum[flag] : resultFlags\n }, 0)\n}\n","const HEX_REGEX = /^[0-9A-Fa-f]+$/u\n\n/**\n * Verify that all fields of an object are in fields.\n *\n * @param obj - Object to verify fields.\n * @param fields - Fields to verify.\n * @returns True if keys in object are all in fields.\n */\nexport function onlyHasFields(\n obj: Record<string, unknown>,\n fields: string[],\n): boolean {\n return Object.keys(obj).every((key: string) => fields.includes(key))\n}\n\n/**\n * Perform bitwise AND (&) to check if a flag is enabled within Flags (as a number).\n *\n * @param Flags - A number that represents flags enabled.\n * @param checkFlag - A specific flag to check if it's enabled within Flags.\n * @returns True if checkFlag is enabled within Flags.\n */\nexport function isFlagEnabled(Flags: number, checkFlag: number): boolean {\n // eslint-disable-next-line no-bitwise -- flags needs bitwise\n return (checkFlag & Flags) === checkFlag\n}\n\n/**\n * Check if string is in hex format.\n *\n * @param str - The string to check if it's in hex format.\n * @returns True if string is in hex format\n */\nexport function isHex(str: string): boolean {\n return HEX_REGEX.test(str)\n}\n","import BigNumber from 'bignumber.js'\nimport { xAddressToClassicAddress, isValidXAddress } from 'ripple-address-codec'\n\nimport type { Client } from '..'\nimport { ValidationError, XrplError } from '../errors'\nimport { AccountInfoRequest, AccountObjectsRequest } from '../models/methods'\nimport { Transaction } from '../models/transactions'\nimport { setTransactionFlagsToNumber } from '../models/utils/flags'\nimport { xrpToDrops } from '../utils'\n\nimport getFeeXrp from './getFeeXrp'\n\n// Expire unconfirmed transactions after 20 ledger versions, approximately 1 minute, by default\nconst LEDGER_OFFSET = 20\ninterface ClassicAccountAndTag {\n classicAccount: string\n tag: number | false | undefined\n}\n\n/**\n * Autofills fields in a transaction. This will set `Sequence`, `Fee`,\n * `lastLedgerSequence` according to the current state of the server this Client\n * is connected to. It also converts all X-Addresses to classic addresses and\n * flags interfaces into numbers.\n *\n * @param this - A client.\n * @param transaction - A {@link Transaction} in JSON format\n * @param signersCount - The expected number of signers for this transaction.\n * Only used for multisigned transactions.\n * @returns The autofilled transaction.\n */\nasync function autofill<T extends Transaction>(\n this: Client,\n transaction: T,\n signersCount?: number,\n): Promise<T> {\n const tx = { ...transaction }\n\n setValidAddresses(tx)\n\n setTransactionFlagsToNumber(tx)\n\n const promises: Array<Promise<void>> = []\n if (tx.Sequence == null) {\n promises.push(setNextValidSequenceNumber(this, tx))\n }\n if (tx.Fee == null) {\n promises.push(calculateFeePerTransactionType(this, tx, signersCount))\n }\n if (tx.LastLedgerSequence == null) {\n promises.push(setLatestValidatedLedgerSequence(this, tx))\n }\n if (tx.TransactionType === 'AccountDelete') {\n promises.push(checkAccountDeleteBlockers(this, tx))\n }\n\n return Promise.all(promises).then(() => tx)\n}\n\nfunction setValidAddresses(tx: Transaction): void {\n validateAccountAddress(tx, 'Account', 'SourceTag')\n // eslint-disable-next-line @typescript-eslint/dot-notation -- Destination can exist on Transaction\n if (tx['Destination'] != null) {\n validateAccountAddress(tx, 'Destination', 'DestinationTag')\n }\n\n // DepositPreauth:\n convertToClassicAddress(tx, 'Authorize')\n convertToClassicAddress(tx, 'Unauthorize')\n // EscrowCancel, EscrowFinish:\n convertToClassicAddress(tx, 'Owner')\n // SetRegularKey:\n convertToClassicAddress(tx, 'RegularKey')\n}\n\nfunction validateAccountAddress(\n tx: Transaction,\n accountField: string,\n tagField: string,\n): void {\n // if X-address is given, convert it to classic address\n const { classicAccount, tag } = getClassicAccountAndTag(tx[accountField])\n // eslint-disable-next-line no-param-reassign -- param reassign is safe\n tx[accountField] = classicAccount\n\n if (tag != null && tag !== false) {\n if (tx[tagField] && tx[tagField] !== tag) {\n throw new ValidationError(\n `The ${tagField}, if present, must match the tag of the ${accountField} X-address`,\n )\n }\n // eslint-disable-next-line no-param-reassign -- param reassign is safe\n tx[tagField] = tag\n }\n}\n\nfunction getClassicAccountAndTag(\n Account: string,\n expectedTag?: number,\n): ClassicAccountAndTag {\n if (isValidXAddress(Account)) {\n const classic = xAddressToClassicAddress(Account)\n if (expectedTag != null && classic.tag !== expectedTag) {\n throw new ValidationError(\n 'address includes a tag that does not match the tag specified in the transaction',\n )\n }\n return {\n classicAccount: classic.classicAddress,\n tag: classic.tag,\n }\n }\n return {\n classicAccount: Account,\n tag: expectedTag,\n }\n}\n\nfunction convertToClassicAddress(tx: Transaction, fieldName: string): void {\n // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- assignment is safe\n const account = tx[fieldName]\n if (typeof account === 'string') {\n const { classicAccount } = getClassicAccountAndTag(account)\n // eslint-disable-next-line no-param-reassign -- param reassign is safe\n tx[fieldName] = classicAccount\n }\n}\n\nasync function setNextValidSequenceNumber(\n client: Client,\n tx: Transaction,\n): Promise<void> {\n const request: AccountInfoRequest = {\n command: 'account_info',\n account: tx.Account,\n ledger_index: 'current',\n }\n const data = await client.request(request)\n // eslint-disable-next-line no-param-reassign, require-atomic-updates -- param reassign is safe with no race condition\n tx.Sequence = data.result.account_data.Sequence\n}\n\nasync function fetchAccountDeleteFee(client: Client): Promise<BigNumber> {\n const response = await client.request({ command: 'server_state' })\n const fee = response.result.state.validated_ledger?.reserve_inc\n\n if (fee == null) {\n return Promise.reject(new Error('Could not fetch Owner Reserve.'))\n }\n\n return new BigNumber(fee)\n}\n\nasync function calculateFeePerTransactionType(\n client: Client,\n tx: Transaction,\n signersCount = 0,\n): Promise<void> {\n // netFee is usually 0.00001 XRP (10 drops)\n const netFeeXRP = await getFeeXrp(client)\n const netFeeDrops = xrpToDrops(netFeeXRP)\n let baseFee = new BigNumber(netFeeDrops)\n\n // EscrowFinish Transaction with Fulfillment\n if (tx.TransactionType === 'EscrowFinish' && tx.Fulfillment != null) {\n const fulfillmentBytesSize: number = Math.ceil(tx.Fulfillment.length / 2)\n // 10 drops × (33 + (Fulfillment size in bytes / 16))\n const product = new BigNumber(\n // eslint-disable-next-line @typescript-eslint/no-magic-numbers -- expected use of magic numbers\n scaleValue(netFeeDrops, 33 + fulfillmentBytesSize / 16),\n )\n baseFee = product.dp(0, BigNumber.ROUND_CEIL)\n }\n\n // AccountDelete Transaction\n if (tx.TransactionType === 'AccountDelete') {\n baseFee = await fetchAccountDeleteFee(client)\n }\n\n /*\n * Multi-signed Transaction\n * 10 drops × (1 + Number of Signatures Provided)\n */\n if (signersCount > 0) {\n baseFee = BigNumber.sum(baseFee, scaleValue(netFeeDrops, 1 + signersCount))\n }\n\n const maxFeeDrops = xrpToDrops(client.maxFeeXRP)\n const totalFee =\n tx.TransactionType === 'AccountDelete'\n ? baseFee\n : BigNumber.min(baseFee, maxFeeDrops)\n\n // Round up baseFee and return it as a string\n // eslint-disable-next-line no-param-reassign, @typescript-eslint/no-magic-numbers -- param reassign is safe, base 10 magic num\n tx.Fee = totalFee.dp(0, BigNumber.ROUND_CEIL).toString(10)\n}\n\nfunction scaleValue(value, multiplier): string {\n return new BigNumber(value).times(multiplier).toString()\n}\n\nasync function setLatestValidatedLedgerSequence(\n client: Client,\n tx: Transaction,\n): Promise<void> {\n const ledgerSequence = await client.getLedgerIndex()\n // eslint-disable-next-line no-param-reassign -- param reassign is safe\n tx.LastLedgerSequence = ledgerSequence + LEDGER_OFFSET\n}\n\nasync function checkAccountDeleteBlockers(\n client: Client,\n tx: Transaction,\n): Promise<void> {\n const request: AccountObjectsRequest = {\n command: 'account_objects',\n account: tx.Account,\n ledger_index: 'validated',\n deletion_blockers_only: true,\n }\n const response = await client.request(request)\n return new Promise((resolve, reject) => {\n if (response.result.account_objects.length > 0) {\n reject(\n new XrplError(\n `Account ${tx.Account} cannot be deleted; there are Escrows, PayChannels, RippleStates, or Checks associated with the account.`,\n response.result.account_objects,\n ),\n )\n }\n resolve()\n })\n}\n\nexport default autofill\n","import flatMap from 'lodash/flatMap'\n\nimport type { Client } from '..'\nimport { LedgerIndex } from '../models/common'\nimport { AccountInfoRequest } from '../models/methods'\nimport { AccountLinesRequest, Trustline } from '../models/methods/accountLines'\nimport { dropsToXrp } from '../utils'\n\ninterface Balance {\n value: string\n currency: string\n issuer?: string\n}\n\nfunction formatBalances(trustlines: Trustline[]): Balance[] {\n return trustlines.map((trustline) => ({\n value: trustline.balance,\n currency: trustline.currency,\n issuer: trustline.account,\n }))\n}\n\n/**\n * Get the XRP balance for an account.\n *\n * @example\n * ```ts\n * const client = new Client(wss://s.altnet.rippletest.net:51233)\n * const balance = await client.getXrpBalance('rG1QQv2nh2gr7RCZ1P8YYcBUKCCN633jCn')\n * console.log(balance)\n * /// '200'\n * ```\n *\n * @param this - Client.\n * @param address - Address of the account to retrieve XRP balance.\n * @param options - Options to include for getting the XRP balance.\n * @param options.ledger_index - Retrieve the account balances at a given\n * ledger_index.\n * @param options.ledger_hash - Retrieve the account balances at the ledger with\n * a given ledger_hash.\n * @returns The XRP balance of the account (as a string).\n */\nasync function getXrpBalance(\n this: Client,\n address: string,\n options: {\n ledger_hash?: string\n ledger_index?: LedgerIndex\n } = {},\n): Promise<string> {\n const xrpRequest: AccountInfoRequest = {\n command: 'account_info',\n account: address,\n ledger_index: options.ledger_index ?? 'validated',\n ledger_hash: options.ledger_hash,\n }\n const response = await this.request(xrpRequest)\n return dropsToXrp(response.result.account_data.Balance)\n}\n\n/**\n * Get XRP/non-XRP balances for an account.\n *\n * @param this - Client.\n * @param address - Address of the account to retrieve balances for.\n * @param options - Allows the client to specify a ledger_hash, ledger_index,\n * filter by peer, and/or limit number of balances.\n * @param options.ledger_index - Retrieve the account balances at a given\n * ledger_index.\n * @param options.ledger_hash - Retrieve the account balances at the ledger with\n * a given ledger_hash.\n * @param options.peer - Filter balances by peer.\n * @param options.limit - Limit number of balances to return.\n * @returns An array of XRP/non-XRP balances for the given account.\n */\n// eslint-disable-next-line max-lines-per-function -- Longer definition is required for end users to see the definition.\nasync function getBalances(\n this: Client,\n address: string,\n options: {\n ledger_hash?: string\n ledger_index?: LedgerIndex\n peer?: string\n limit?: number\n } = {},\n): Promise<\n Array<{ value: string; currency: string; issuer?: string | undefined }>\n> {\n const balances: Balance[] = []\n\n // get XRP balance\n let xrpPromise: Promise<string> = Promise.resolve('')\n if (!options.peer) {\n xrpPromise = this.getXrpBalance(address, {\n ledger_hash: options.ledger_hash,\n ledger_index: options.ledger_index,\n })\n }\n\n // get non-XRP balances\n const linesRequest: AccountLinesRequest = {\n command: 'account_lines',\n account: address,\n ledger_index: options.ledger_index ?? 'validated',\n ledger_hash: options.ledger_hash,\n peer: options.peer,\n limit: options.limit,\n }\n const linesPromise = this.requestAll(linesRequest)\n\n // combine results\n await Promise.all([xrpPromise, linesPromise]).then(\n ([xrpBalance, linesResponses]) => {\n const accountLinesBalance = flatMap(linesResponses, (response) =>\n formatBalances(response.result.lines),\n )\n if (xrpBalance !== '') {\n balances.push({ currency: 'XRP', value: xrpBalance })\n }\n balances.push(...accountLinesBalance)\n },\n )\n return balances.slice(0, options.limit)\n}\n\nexport { getXrpBalance, getBalances }\n","import BigNumber from 'bignumber.js'\n\nimport type { Client } from '..'\nimport { XrplError } from '../errors'\n\nconst NUM_DECIMAL_PLACES = 6\nconst BASE_10 = 10\n\n/**\n * Calculates the current transaction fee for the ledger.\n * Note: This is a public API that can be called directly.\n *\n * @param client - The Client used to connect to the ledger.\n * @param cushion - The fee cushion to use.\n * @returns The transaction fee.\n */\nexport default async function getFeeXrp(\n client: Client,\n cushion?: number,\n): Promise<string> {\n const feeCushion = cushion ?? client.feeCushion\n\n const serverInfo = (await client.request({ command: 'server_info' })).result\n .info\n\n const baseFee = serverInfo.validated_ledger?.base_fee_xrp\n\n if (baseFee == null) {\n throw new XrplError(\n 'getFeeXrp: Could not get base_fee_xrp from server_info',\n )\n }\n\n const baseFeeXrp = new BigNumber(baseFee)\n if (serverInfo.load_factor == null) {\n // https://github.com/ripple/rippled/issues/3812#issuecomment-816871100\n serverInfo.load_factor = 1\n }\n let fee = baseFeeXrp.times(serverInfo.load_factor).times(feeCushion)\n\n // Cap fee to `client.maxFeeXRP`\n fee = BigNumber.min(fee, client.maxFeeXRP)\n // Round fee to 6 decimal places\n return new BigNumber(fee.toFixed(NUM_DECIMAL_PLACES)).toString(BASE_10)\n}\n","import type { Client } from '..'\n\n/**\n * Returns the index of the most recently validated ledger.\n *\n * @param this - The Client used to connect to the ledger.\n * @returns The most recently validated ledger index.\n */\nexport default async function getLedgerIndex(this: Client): Promise<number> {\n const ledgerResponse = await this.request({\n command: 'ledger',\n ledger_index: 'validated',\n })\n return ledgerResponse.result.ledger_index\n}\n","/* eslint-disable max-lines-per-function -- Needs to process orderbooks. */\nimport BigNumber from 'bignumber.js'\nimport flatMap from 'lodash/flatMap'\n\nimport type { Client } from '../client'\nimport { ValidationError } from '../errors'\nimport { LedgerIndex } from '../models/common'\nimport { OfferFlags } from '../models/ledger/Offer'\nimport {\n BookOffer,\n BookOffersRequest,\n TakerAmount,\n} from '../models/methods/bookOffers'\n\nconst DEFAULT_LIMIT = 20\n\nfunction sortOffers(offers: BookOffer[]): BookOffer[] {\n return offers.sort((offerA, offerB) => {\n const qualityA = offerA.quality ?? 0\n const qualityB = offerB.quality ?? 0\n\n return new BigNumber(qualityA).comparedTo(qualityB)\n })\n}\n\nconst getOrderbookOptionsSet = new Set([\n 'limit',\n 'ledger_index',\n 'ledger_hash',\n 'taker',\n])\n\n/**\n * Fetch orderbook (buy/sell orders) between two accounts.\n *\n * @param this - Client.\n * @param takerPays - Specification of which currency the account taking the\n * offer would pay, as an object with `currency` and `issuer` fields.\n * @param takerGets - Specification of which currency the account taking the\n * offer would receive, as an object with `currency` and `issuer` fields.\n * @param options - Options allowing the client to specify ledger_index,\n * ledger_hash, filter by taker, and/or limit number of orders.\n * @param options.ledger_index - Retrieve the orderbook at a given ledger_index.\n * @param options.ledger_hash - Retrieve the orderbook at the ledger with a\n * given ledger_hash.\n * @param options.taker - Filter orders by taker.\n * @param options.limit - Limit number of order books to fetch for each side of\n * the order book. Defaults to 20.\n * @returns An object containing buy and sell objects.\n */\n// eslint-disable-next-line max-params, complexity -- Once bound to Client, getOrderbook only has 3 parameters.\nasync function getOrderbook(\n this: Client,\n takerPays: TakerAmount,\n takerGets: TakerAmount,\n options: {\n limit?: number\n ledger_index?: LedgerIndex\n ledger_hash?: string | null\n taker?: string | null\n } = {},\n): Promise<{\n buy: BookOffer[]\n sell: BookOffer[]\n}> {\n Object.keys(options).forEach((key) => {\n if (!getOrderbookOptionsSet.has(key)) {\n throw new ValidationError(`Unexpected option: ${key}`, options)\n }\n })\n\n if (options.limit && typeof options.limit !== 'number') {\n throw new ValidationError('limit must be a number', options.limit)\n }\n\n if (\n options.ledger_index &&\n !(\n typeof options.ledger_index === 'number' ||\n (typeof options.ledger_index === 'string' &&\n ['validated', 'closed', 'current'].includes(options.ledger_index))\n )\n ) {\n throw new ValidationError(\n 'ledger_index must be a number or a string of \"validated\", \"closed\", or \"current\"',\n options.ledger_index,\n )\n }\n\n if (\n options.ledger_hash !== undefined &&\n options.ledger_hash !== null &&\n typeof options.ledger_hash !== 'string'\n ) {\n throw new ValidationError(\n 'ledger_hash must be a string',\n options.ledger_hash,\n )\n }\n\n if (options.taker !== undefined && typeof options.taker !== 'string') {\n throw new ValidationError('taker must be a string', options.taker)\n }\n\n const request: BookOffersRequest = {\n command: 'book_offers',\n taker_pays: takerPays,\n taker_gets: takerGets,\n ledger_index: options.ledger_index ?? 'validated',\n ledger_hash: options.ledger_hash === null ? undefined : options.ledger_hash,\n limit: options.limit ?? DEFAULT_LIMIT,\n taker: options.taker ? options.taker : undefined,\n }\n // 2. Make Request\n const directOfferResults = await this.requestAll(request)\n request.taker_gets = takerPays\n request.taker_pays = takerGets\n const reverseOfferResults = await this.requestAll(request)\n // 3. Return Formatted Response\n const directOffers = flatMap(\n directOfferResults,\n (directOfferResult) => directOfferResult.result.offers,\n )\n const reverseOffers = flatMap(\n reverseOfferResults,\n (reverseOfferResult) => reverseOfferResult.result.offers,\n )\n\n const orders = [...directOffers, ...reverseOffers]\n // separate out the buy and sell orders\n const buy: BookOffer[] = []\n const sell: BookOffer[] = []\n orders.forEach((order) => {\n // eslint-disable-next-line no-bitwise -- necessary for flags check\n if ((order.Flags & OfferFlags.lsfSell) === 0) {\n buy.push(order)\n } else {\n sell.push(order)\n }\n })\n /*\n * Sort the orders\n * for both buys and sells, lowest quality is closest to mid-market\n * we sort the orders so that earlier orders are closer to mid-market\n */\n return {\n buy: sortOffers(buy).slice(0, options.limit),\n sell: sortOffers(sell).slice(0, options.limit),\n }\n}\n\nexport default getOrderbook\n","export { default as autofill } from './autofill'\n\nexport { getBalances, getXrpBalance } from './balances'\n\nexport { default as getLedgerIndex } from './getLedgerIndex'\n\nexport { default as getOrderbook } from './getOrderbook'\n\nexport * from './submit'\n\nexport * from './utils'\n","import { decode, encode } from 'ripple-binary-codec'\n\nimport type { Client, SubmitRequest, SubmitResponse, Wallet } from '..'\nimport { ValidationError, XrplError } from '../errors'\nimport { TxResponse } from '../models/methods'\nimport { Transaction } from '../models/transactions'\nimport { hashes } from '../utils'\n\n/** Approximate time for a ledger to close, in milliseconds */\nconst LEDGER_CLOSE_TIME = 1000\n\nasync function sleep(ms: number): Promise<void> {\n return new Promise((resolve) => {\n setTimeout(resolve, ms)\n })\n}\n\n/**\n * Submits a signed/unsigned transaction.\n * Steps performed on a transaction:\n * 1. Autofill.\n * 2. Sign & Encode.\n * 3. Submit.\n *\n * @param this - A Client.\n * @param transaction - A transaction to autofill, sign & encode, and submit.\n * @param opts - (Optional) Options used to sign and submit a transaction.\n * @param opts.autofill - If true, autofill a transaction.\n * @param opts.failHard - If true, and the transaction fails locally, do not retry or relay the transaction to other servers.\n * @param opts.wallet - A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.\n * @returns A promise that contains SubmitResponse.\n * @throws RippledError if submit request fails.\n */\nasync function submit(\n this: Client,\n transaction: Transaction | string,\n opts?: {\n // If true, autofill a transaction.\n autofill?: boolean\n // If true, and the transaction fails locally, do not retry or relay the transaction to other servers.\n failHard?: boolean\n // A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.\n wallet?: Wallet\n },\n): Promise<SubmitResponse> {\n const signedTx = await getSignedTx(this, transaction, opts)\n return submitRequest(this, signedTx, opts?.failHard)\n}\n\n/**\n * Asynchronously submits a transaction and verifies that it has been included in a\n * validated ledger (or has errored/will not be included for some reason).\n * See [Reliable Transaction Submission](https://xrpl.org/reliable-transaction-submission.html).\n *\n * @param this - A Client.\n * @param transaction - A transaction to autofill, sign & encode, and submit.\n * @param opts - (Optional) Options used to sign and submit a transaction.\n * @param opts.autofill - If true, autofill a transaction.\n * @param opts.failHard - If true, and the transaction fails locally, do not retry or relay the transaction to other servers.\n * @param opts.wallet - A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.\n * @returns A promise that contains TxResponse, that will return when the transaction has been validated.\n */\nasync function submitAndWait(\n this: Client,\n transaction: Transaction | string,\n opts?: {\n // If true, autofill a transaction.\n autofill?: boolean\n // If true, and the transaction fails locally, do not retry or relay the transaction to other servers.\n failHard?: boolean\n // A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.\n wallet?: Wallet\n },\n): Promise<TxResponse> {\n const signedTx = await getSignedTx(this, transaction, opts)\n\n const lastLedger = getLastLedgerSequence(signedTx)\n if (lastLedger == null) {\n throw new ValidationError(\n 'Transaction must contain a LastLedgerSequence value for reliable submission.',\n )\n }\n\n const response = await submitRequest(this, signedTx, opts?.failHard)\n\n const txHash = hashes.hashSignedTx(signedTx)\n return waitForFinalTransactionOutcome(\n this,\n txHash,\n lastLedger,\n response.result.engine_result,\n )\n}\n\n// Helper functions\n\n// Encodes and submits a signed transaction.\nasync function submitRequest(\n client: Client,\n signedTransaction: Transaction | string,\n failHard = false,\n): Promise<SubmitResponse> {\n if (!isSigned(signedTransaction)) {\n throw new ValidationError('Transaction must be signed')\n }\n\n const signedTxEncoded =\n typeof signedTransaction === 'string'\n ? signedTransaction\n : encode(signedTransaction)\n const request: SubmitRequest = {\n command: 'submit',\n tx_blob: signedTxEncoded,\n fail_hard: isAccountDelete(signedTransaction) || failHard,\n }\n return client.request(request)\n}\n\n/*\n * The core logic of reliable submission. This polls the ledger until the result of the\n * transaction can be considered final, meaning it has either been included in a\n * validated ledger, or the transaction's lastLedgerSequence has been surpassed by the\n * latest ledger sequence (meaning it will never be included in a validated ledger).\n */\n// eslint-disable-next-line max-params, max-lines-per-function -- this function needs to display and do with more information.\nasync function waitForFinalTransactionOutcome(\n client: Client,\n txHash: string,\n lastLedger: number,\n submissionResult: string,\n): Promise<TxResponse> {\n await sleep(LEDGER_CLOSE_TIME)\n\n const latestLedger = await client.getLedgerIndex()\n\n if (lastLedger < latestLedger) {\n throw new XrplError(\n `The latest ledger sequence ${latestLedger} is greater than the transaction's LastLedgerSequence (${lastLedger}).\\n` +\n `Preliminary result: ${submissionResult}`,\n )\n }\n\n const txResponse = await client\n .request({\n command: 'tx',\n transaction: txHash,\n })\n .catch(async (error) => {\n // error is of an unknown type and hence we assert type to extract the value we need.\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions,@typescript-eslint/no-unsafe-member-access -- ^\n const message = error?.data?.error as string\n if (message === 'txnNotFound') {\n return waitForFinalTransactionOutcome(\n client,\n txHash,\n lastLedger,\n submissionResult,\n )\n }\n throw new Error(\n `${message} \\n Preliminary result: ${submissionResult}.\\nFull error details: ${String(\n error,\n )}`,\n )\n })\n\n if (txResponse.result.validated) {\n return txResponse\n }\n\n return waitForFinalTransactionOutcome(\n client,\n txHash,\n lastLedger,\n submissionResult,\n )\n}\n\n// checks if the transaction has been signed\nfunction isSigned(transaction: Transaction | string): boolean {\n const tx = typeof transaction === 'string' ? decode(transaction) : transaction\n return (\n typeof tx !== 'string' &&\n (tx.SigningPubKey != null || tx.TxnSignature != null)\n )\n}\n\n// initializes a transaction for a submit request\nasync function getSignedTx(\n client: Client,\n transaction: Transaction | string,\n {\n autofill = true,\n wallet,\n }: {\n // If true, autofill a transaction.\n autofill?: boolean\n // If true, and the transaction fails locally, do not retry or relay the transaction to other servers.\n failHard?: boolean\n // A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.\n wallet?: Wallet\n } = {},\n): Promise<Transaction | string> {\n if (isSigned(transaction)) {\n return transaction\n }\n\n if (!wallet) {\n throw new ValidationError(\n 'Wallet must be provided when submitting an unsigned transaction',\n )\n }\n\n let tx =\n typeof transaction === 'string'\n ? // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- converts JsonObject to correct Transaction type\n (decode(transaction) as unknown as Transaction)\n : transaction\n\n if (autofill) {\n tx = await client.autofill(tx)\n }\n\n return wallet.sign(tx).tx_blob\n}\n\n// checks if there is a LastLedgerSequence as a part of the transaction\nfunction getLastLedgerSequence(\n transaction: Transaction | string,\n): number | null {\n const tx = typeof transaction === 'string' ? decode(transaction) : transaction\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- converts LastLedgSeq to number if present.\n return tx.LastLedgerSequence as number | null\n}\n\n// checks if the transaction is an AccountDelete transaction\nfunction isAccountDelete(transaction: Transaction | string): boolean {\n const tx = typeof transaction === 'string' ? decode(transaction) : transaction\n return tx.TransactionType === 'AccountDelete'\n}\n\nexport { submit, submitAndWait }\n","import { xAddressToClassicAddress, isValidXAddress } from 'ripple-address-codec'\n\n/**\n * If an address is an X-Address, converts it to a classic address.\n *\n * @param account - A classic address or X-address.\n * @returns The account's classic address.\n * @throws Error if the X-Address has an associated tag.\n */\n// eslint-disable-next-line import/prefer-default-export -- okay for a utils file - there could be more exports later\nexport function ensureClassicAddress(account: string): string {\n if (isValidXAddress(account)) {\n const { classicAddress, tag } = xAddressToClassicAddress(account)\n\n /*\n * Except for special cases, X-addresses used for requests\n * must not have an embedded tag. In other words,\n * `tag` should be `false`.\n */\n if (tag !== false) {\n throw new Error(\n 'This command does not support the use of a tag. Use an address without a tag.',\n )\n }\n\n // For rippled requests that use an account, always use a classic address.\n return classicAddress\n }\n return account\n}\n","import { XrplError } from '../errors'\nimport { Payment } from '../models'\nimport { Memo } from '../models/common'\n\nimport { convertStringToHex } from './stringConversion'\n\n/**\n * Creates a cross-chain payment transaction.\n *\n * @param payment - The initial payment transaction. If the transaction is\n * signed, then it will need to be re-signed. There must be no more than 2\n * memos, since one memo is used for the sidechain destination account. The\n * destination must be the sidechain's door account.\n * @param destAccount - the destination account on the sidechain.\n * @returns A cross-chain payment transaction, where the mainchain door account\n * is the `Destination` and the destination account on the sidechain is encoded\n * in the memos.\n * @throws XrplError - if there are more than 2 memos.\n * @category Utilities\n */\nexport default function createCrossChainPayment(\n payment: Payment,\n destAccount: string,\n): Payment {\n const destAccountHex = convertStringToHex(destAccount)\n const destAccountMemo: Memo = { Memo: { MemoData: destAccountHex } }\n\n const memos = payment.Memos ?? []\n if (memos.length > 2) {\n throw new XrplError(\n 'Cannot have more than 2 memos in a cross-chain transaction.',\n )\n }\n const newMemos = [destAccountMemo, ...memos]\n\n const newPayment = { ...payment, Memos: newMemos }\n delete newPayment.TxnSignature\n\n return newPayment\n}\n","import { classicAddressToXAddress } from 'ripple-address-codec'\nimport { deriveKeypair, deriveAddress } from 'ripple-keypairs'\n\n/**\n * Derive an X-Address from a public key and a destination tag.\n *\n * @param options - Public key and destination tag to encode as an X-Address.\n * @param options.publicKey - The public key corresponding to an address.\n * @param options.tag - A destination tag to encode into an X-address. False indicates no destination tag.\n * @param options.test - Whether this address is for use in Testnet.\n * @returns X-Address.\n * @category Utilities\n */\nfunction deriveXAddress(options: {\n publicKey: string\n tag: number | false\n test: boolean\n}): string {\n const classicAddress = deriveAddress(options.publicKey)\n return classicAddressToXAddress(classicAddress, options.tag, options.test)\n}\n\nexport { deriveKeypair, deriveAddress, deriveXAddress }\n","import BigNumber from 'bignumber.js'\nimport flatten from 'lodash/flatten'\nimport groupBy from 'lodash/groupBy'\n\nimport { Amount, IssuedCurrencyAmount } from '../models/common'\nimport { TransactionMetadata, Node } from '../models/transactions/metadata'\n\nimport { dropsToXrp } from './xrpConversion'\n\ninterface Balance {\n currency: string\n issuer?: string\n value: string\n}\n\ninterface BalanceChange {\n account: string\n balance: Balance\n}\ninterface Fields {\n Account?: string\n Balance?: Amount\n LowLimit?: IssuedCurrencyAmount\n HighLimit?: IssuedCurrencyAmount\n // eslint-disable-next-line @typescript-eslint/member-ordering -- okay here, just some of the fields are typed to make it easier\n [field: string]: unknown\n}\n\ninterface NormalizedNode {\n // 'CreatedNode' | 'ModifiedNode' | 'DeletedNode'\n NodeType: string\n LedgerEntryType: string\n LedgerIndex: string\n NewFields?: Fields\n FinalFields?: Fields\n PreviousFields?: Fields\n PreviousTxnID?: string\n PreviousTxnLgrSeq?: number\n}\n\nfunction normalizeNode(affectedNode: Node): NormalizedNode {\n const diffType = Object.keys(affectedNode)[0]\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- not quite right, but close enough\n const node = affectedNode[diffType] as NormalizedNode\n return {\n ...node,\n NodeType: diffType,\n LedgerEntryType: node.LedgerEntryType,\n LedgerIndex: node.LedgerIndex,\n NewFields: node.NewFields,\n FinalFields: node.FinalFields,\n PreviousFields: node.PreviousFields,\n }\n}\n\nfunction normalizeNodes(metadata: TransactionMetadata): NormalizedNode[] {\n if (metadata.AffectedNodes.length === 0) {\n return []\n }\n return metadata.AffectedNodes.map(normalizeNode)\n}\n\nfunction groupByAccount(balanceChanges: BalanceChange[]): Array<{\n account: string\n balances: Balance[]\n}> {\n const grouped = groupBy(balanceChanges, (node) => node.account)\n return Object.entries(grouped).map(([account, items]) => {\n return { account, balances: items.map((item) => item.balance) }\n })\n}\n\nfunction getValue(balance: Amount): BigNumber {\n if (typeof balance === 'string') {\n return new BigNumber(balance)\n }\n return new BigNumber(balance.value)\n}\n\nfunction computeBalanceChange(node: NormalizedNode): BigNumber | null {\n let value: BigNumber | null = null\n if (node.NewFields?.Balance) {\n value = getValue(node.NewFields.Balance)\n } else if (node.PreviousFields?.Balance && node.FinalFields?.Balance) {\n value = getValue(node.FinalFields.Balance).minus(\n getValue(node.PreviousFields.Balance),\n )\n }\n if (value === null || value.isZero()) {\n return null\n }\n return value\n}\n\nfunction getXRPQuantity(\n node: NormalizedNode,\n): { account: string; balance: Balance } | null {\n const value = computeBalanceChange(node)\n\n if (value === null) {\n return null\n }\n\n return {\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- okay here\n account: (node.FinalFields?.Account ?? node.NewFields?.Account) as string,\n balance: {\n currency: 'XRP',\n value: dropsToXrp(value).toString(),\n },\n }\n}\n\nfunction flipTrustlinePerspective(balanceChange: BalanceChange): BalanceChange {\n const negatedBalance = new BigNumber(balanceChange.balance.value).negated()\n return {\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- we know this is true\n account: balanceChange.balance.issuer as string,\n balance: {\n issuer: balanceChange.account,\n currency: balanceChange.balance.currency,\n value: negatedBalance.toString(),\n },\n }\n}\n\nfunction getTrustlineQuantity(node: NormalizedNode): BalanceChange[] | null {\n const value = computeBalanceChange(node)\n\n if (value === null) {\n return null\n }\n\n /*\n * A trustline can be created with a non-zero starting balance.\n * If an offer is placed to acquire an asset with no existing trustline,\n * the trustline can be created when the offer is taken.\n */\n const fields = node.NewFields == null ? node.FinalFields : node.NewFields\n\n // the balance is always from low node's perspective\n const result = {\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- we know that this is true\n account: fields?.LowLimit?.issuer as string,\n balance: {\n issuer: fields?.HighLimit?.issuer,\n // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- we know that this is true\n currency: (fields?.Balance as IssuedCurrencyAmount).currency,\n value: value.toString(),\n },\n }\n return [result, flipTrustlinePerspective(result)]\n}\n\n/**\n * Computes the complete list of every balance that changed in the ledger\n * as a result of the given transaction.\n *\n * @param metadata - Transaction metadata.\n * @returns Parsed balance changes.\n * @category Utilities\n */\nexport default function getBalanceChanges(\n metadata: TransactionMetadata,\n): Array<{\n account: string\n balances: Array<{\n currency: string\n issuer?: string\n value: string\n }>\n}> {\n const quantities = normalizeNodes(metadata).map((node) => {\n if (node.LedgerEntryType === 'AccountRoot') {\n const xrpQuantity = getXRPQuantity(node)\n if (xrpQuantity == null) {\n return []\n }\n return [xrpQuantity]\n }\n if (node.LedgerEntryType === 'RippleState') {\n const trustlineQuantity = getTrustlineQuantity(node)\n if (trustlineQuantity == null) {\n return []\n }\n return trustlineQuantity\n }\n return []\n })\n return groupByAccount(flatten(quantities))\n}\n","import flatMap from 'lodash/flatMap'\n\nimport {\n CreatedNode,\n isCreatedNode,\n isModifiedNode,\n ModifiedNode,\n TransactionMetadata,\n} from '../models/transactions/metadata'\n\ninterface NFToken {\n NFToken: {\n NFTokenID: string\n URI: string\n }\n}\n\n/**\n * Gets the NFTokenID for an NFT recently minted with NFTokenMint.\n *\n * @param meta - Metadata from the response to submitting an NFTokenMint transaction.\n * @returns The NFTokenID for the minted NFT.\n * @throws if meta is not TransactionMetadata.\n */\nexport default function getNFTokenID(\n meta: TransactionMetadata,\n): string | undefined {\n /* eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Provides a nicer error for js users */\n if (meta.AffectedNodes === undefined) {\n throw new TypeError(`Unable to parse the parameter given to getNFTokenID. \n 'meta' must be the metadata from an NFTokenMint transaction. Received ${JSON.stringify(\n meta,\n )} instead.`)\n }\n\n /*\n * When a mint results in splitting an existing page,\n * it results in a created page and a modified node. Sometimes,\n * the created node needs to be linked to a third page, resulting\n * in modifying that third page's PreviousPageMin or NextPageMin\n * field changing, but no NFTs within that page changing. In this\n * case, there will be no previous NFTs and we need to skip.\n * However, there will always be NFTs listed in the final fields,\n * as rippled outputs all fields in final fields even if they were\n * not changed. Thus why we add the additional condition to check\n * if the PreviousFields contains NFTokens\n */\n\n const affectedNodes = meta.AffectedNodes.filter((node) => {\n if (isCreatedNode(node)) {\n return node.CreatedNode.LedgerEntryType === 'NFTokenPage'\n }\n if (isModifiedNode(node)) {\n return (\n node.ModifiedNode.LedgerEntryType === 'NFTokenPage' &&\n Boolean(node.ModifiedNode.PreviousFields?.NFTokens)\n )\n }\n return false\n })\n /* eslint-disable @typescript-eslint/consistent-type-assertions -- Necessary for parsing metadata */\n const previousTokenIDSet = new Set(\n flatMap(affectedNodes, (node) => {\n const nftokens = isModifiedNode(node)\n ? (node.ModifiedNode.PreviousFields?.NFTokens as NFToken[])\n : []\n return nftokens.map((token) => token.NFToken.NFTokenID)\n }).filter((id) => Boolean(id)),\n )\n\n /* eslint-disable @typescript-eslint/no-unnecessary-condition -- Cleaner to read */\n const finalTokenIDs = flatMap(affectedNodes, (node) =>\n (\n (((node as ModifiedNode).ModifiedNode?.FinalFields?.NFTokens ??\n (node as CreatedNode).CreatedNode?.NewFields?.NFTokens) as NFToken[]) ??\n []\n ).map((token) => token.NFToken.NFTokenID),\n ).filter((nftokenID) => Boolean(nftokenID))\n /* eslint-enable @typescript-eslint/consistent-type-assertions -- Necessary for parsing metadata */\n /* eslint-enable @typescript-eslint/no-unnecessary-condition -- Cleaner to read */\n\n const nftokenID = finalTokenIDs.find((id) => !previousTokenIDSet.has(id))\n\n return nftokenID\n}\n","/**\n * Prefix for hashing functions.\n *\n * These prefixes are inserted before the source material used to\n * generate various hashes. This is done to put each hash in its own\n * \"space.\" This way, two different types of objects with the\n * same binary data will produce different hashes.\n *\n * Each prefix is a 4-byte value with the last byte set to zero\n * and the first three bytes formed from the ASCII equivalent of\n * some arbitrary string. For example \"TXN\".\n */\n\nenum HashPrefix {\n // transaction plus signature to give transaction ID 'TXN'\n TRANSACTION_ID = 0x54584e00,\n\n // transaction plus metadata 'TND'\n TRANSACTION_NODE = 0x534e4400,\n\n // inner node in tree 'MIN'\n INNER_NODE = 0x4d494e00,\n\n // leaf node in tree 'MLN'\n LEAF_NODE = 0x4d4c4e00,\n\n // inner transaction to sign 'STX'\n TRANSACTION_SIGN = 0x53545800,\n\n // inner transaction to sign (TESTNET) 'stx'\n TRANSACTION_SIGN_TESTNET = 0x73747800,\n\n // inner transaction to multisign 'SMT'\n TRANSACTION_MULTISIGN = 0x534d5400,\n\n // ledger 'LWR'\n LEDGER = 0x4c575200,\n}\n\nexport default HashPrefix\n","import { XrplError } from '../../../errors'\nimport HashPrefix from '../HashPrefix'\nimport sha512Half from '../sha512Half'\n\nimport LeafNode from './LeafNode'\nimport { NodeType, Node } from './node'\n\nconst HEX_ZERO =\n '0000000000000000000000000000000000000000000000000000000000000000'\n\nconst SLOT_MAX = 15\nconst HEX = 16\n\n/**\n * Class for SHAMap InnerNode.\n */\nclass InnerNode extends Node {\n public leaves: { [slot: number]: Node | undefined }\n public type: NodeType\n public depth: number\n public empty: boolean\n\n /**\n * Define an Inner (non-leaf) node in a SHAMap tree.\n *\n * @param depth - I.e. How many parent inner nodes.\n */\n public constructor(depth = 0) {\n super()\n this.leaves = {}\n this.type = NodeType.INNER\n this.depth = depth\n this.empty = true\n }\n\n /**\n * Get the hash of a LeafNode.\n *\n * @returns Hash of the LeafNode.\n */\n public get hash(): string {\n if (this.empty) {\n return HEX_ZERO\n }\n let hex = ''\n for (let iter = 0; iter <= SLOT_MAX; iter++) {\n const child = this.leaves[iter]\n const hash: string = child == null ? HEX_ZERO : child.hash\n hex += hash\n }\n\n const prefix = HashPrefix.INNER_NODE.toString(HEX)\n return sha512Half(prefix + hex)\n }\n\n /**\n * Adds an item to the InnerNode.\n *\n * @param tag - Equates to a ledger entry `index`.\n * @param node - Node to add.\n * @throws If there is a index collision.\n */\n public addItem(tag: string, node: Node): void {\n const existingNode = this.getNode(parseInt(tag[this.depth], HEX))\n\n if (existingNode === undefined) {\n this.setNode(parseInt(tag[this.depth], HEX), node)\n return\n }\n\n // A node already exists in this slot\n if (existingNode instanceof InnerNode) {\n // There is an inner node, so we need to go deeper\n existingNode.addItem(tag, node)\n } else if (existingNode instanceof LeafNode) {\n if (existingNode.tag === tag) {\n // Collision\n throw new XrplError(\n 'Tried to add a node to a SHAMap that was already in there.',\n )\n } else {\n const newInnerNode = new InnerNode(this.depth + 1)\n\n // Parent new and existing node\n newInnerNode.addItem(existingNode.tag, existingNode)\n newInnerNode.addItem(tag, node)\n\n // And place the newly created inner node in the slot\n this.setNode(parseInt(tag[this.depth], HEX), newInnerNode)\n }\n }\n }\n\n /**\n * Overwrite the node that is currently in a given slot.\n *\n * @param slot - A number 0-15.\n * @param node - To place.\n * @throws If slot is out of range.\n */\n public setNode(slot: number, node: Node): void {\n if (slot < 0 || slot > SLOT_MAX) {\n throw new XrplError('Invalid slot: slot must be between 0-15.')\n }\n this.leaves[slot] = node\n this.empty = false\n }\n\n /**\n * Get the node that is currently in a given slot.\n *\n * @param slot - A number 0-15.\n * @returns Node currently in a slot.\n * @throws If slot is out of range.\n */\n public getNode(slot: number): Node | undefined {\n if (slot < 0 || slot > SLOT_MAX) {\n throw new XrplError('Invalid slot: slot must be between 0-15.')\n }\n return this.leaves[slot]\n }\n}\n\nexport default InnerNode\n","import { XrplError } from '../../../errors'\nimport HashPrefix from '../HashPrefix'\nimport sha512Half from '../sha512Half'\n\nimport { NodeType, Node } from './node'\n\nconst HEX = 16\n\n/**\n * Class for SHAMap Leaf Node.\n */\nclass LeafNode extends Node {\n public tag: string\n public type: NodeType\n public data: string\n\n /**\n * Leaf node in a SHAMap tree.\n *\n * @param tag - Equates to a ledger entry `index`.\n * @param data - Hex of account state, transaction etc.\n * @param type - One of TYPE_ACCOUNT_STATE, TYPE_TRANSACTION_MD etc.\n */\n public constructor(tag: string, data: string, type: NodeType) {\n super()\n this.tag = tag\n this.type = type\n this.data = data\n }\n\n /**\n * Get the hash of a LeafNode.\n *\n * @returns Hash or undefined.\n * @throws If node is of unknown type.\n */\n public get hash(): string {\n switch (this.type) {\n case NodeType.ACCOUNT_STATE: {\n const leafPrefix = HashPrefix.LEAF_NODE.toString(HEX)\n return sha512Half(leafPrefix + this.data + this.tag)\n }\n case NodeType.TRANSACTION_NO_METADATA: {\n const txIDPrefix = HashPrefix.TRANSACTION_ID.toString(HEX)\n return sha512Half(txIDPrefix + this.data)\n }\n case NodeType.TRANSACTION_METADATA: {\n const txNodePrefix = HashPrefix.TRANSACTION_NODE.toString(HEX)\n return sha512Half(txNodePrefix + this.data + this.tag)\n }\n default:\n throw new XrplError('Tried to hash a SHAMap node of unknown type.')\n }\n }\n\n /**\n * Add item to Leaf.\n *\n * @param tag - Index of the Node.\n * @param node - Node to insert.\n * @throws When called, because LeafNodes cannot addItem.\n */\n public addItem(tag: string, node: Node): void {\n throw new XrplError('Cannot call addItem on a LeafNode')\n this.addItem(tag, node)\n }\n}\n\nexport default LeafNode\n","import InnerNode from './InnerNode'\nimport LeafNode from './LeafNode'\nimport { NodeType } from './node'\n\n/**\n * SHAMap is the hash structure used to model ledgers.\n * If the root hash is equivalent, that means all nodes should be equivalent as well.\n */\nclass SHAMap {\n public root: InnerNode\n\n /**\n * SHAMap tree constructor.\n */\n public constructor() {\n this.root = new InnerNode(0)\n }\n\n /**\n * Get the hash of the SHAMap.\n *\n * @returns The hash of the root of the SHAMap.\n */\n public get hash(): string {\n return this.root.hash\n }\n\n /**\n * Add an item to the SHAMap.\n *\n * @param tag - Index of the Node to add.\n * @param data - Data to insert into the tree.\n * @param type - Type of the node to add.\n */\n public addItem(tag: string, data: string, type: NodeType): void {\n this.root.addItem(tag, new LeafNode(tag, data, type))\n }\n}\n\nexport * from './node'\nexport default SHAMap\n","export enum NodeType {\n INNER = 1,\n TRANSACTION_NO_METADATA = 2,\n TRANSACTION_METADATA = 3,\n ACCOUNT_STATE = 4,\n}\n\n/**\n * Abstract base class for SHAMapNode.\n */\nexport abstract class Node {\n public abstract get hash(): string\n public abstract addItem(_tag: string, _node: Node): void\n}\n","/* eslint-disable @typescript-eslint/no-magic-numbers -- this file mimics\n behavior in rippled. Magic numbers are used for lengths and conditions */\n/* eslint-disable no-bitwise -- this file mimics behavior in rippled. It uses\n bitwise operators for and-ing numbers with a mask and bit shifting. */\n\nimport BigNumber from 'bignumber.js'\nimport { decode, encode } from 'ripple-binary-codec'\n\nimport { ValidationError, XrplError } from '../../errors'\nimport type { Ledger } from '../../models/ledger'\nimport { LedgerEntry } from '../../models/ledger'\nimport { Transaction, TransactionMetadata } from '../../models/transactions'\n\nimport HashPrefix from './HashPrefix'\nimport sha512Half from './sha512Half'\nimport SHAMap, { NodeType } from './SHAMap'\n\nconst HEX = 16\n\ninterface HashLedgerHeaderOptions {\n computeTreeHashes?: boolean\n}\n\nfunction intToHex(integer: number, byteLength: number): string {\n const foo = Number(integer)\n .toString(HEX)\n .padStart(byteLength * 2, '0')\n\n return foo\n}\n\nfunction bytesToHex(bytes: number[]): string {\n return Buffer.from(bytes).toString('hex')\n}\n\nfunction bigintToHex(\n integerString: string | number | BigNumber,\n byteLength: number,\n): string {\n const hex = new BigNumber(integerString).toString(HEX)\n return hex.padStart(byteLength * 2, '0')\n}\n\nfunction addLengthPrefix(hex: string): string {\n const length = hex.length / 2\n if (length <= 192) {\n return bytesToHex([length]) + hex\n }\n if (length <= 12480) {\n const prefix = length - 193\n return bytesToHex([193 + (prefix >>> 8), prefix & 0xff]) + hex\n }\n if (length <= 918744) {\n const prefix = length - 12481\n return (\n bytesToHex([\n 241 + (prefix >>> 16),\n (prefix >>> 8) & 0xff,\n prefix & 0xff,\n ]) + hex\n )\n }\n throw new XrplError('Variable integer overflow.')\n}\n\n/**\n * Hashes the Transaction object as the ledger does. Throws if the transaction is unsigned.\n *\n * @param tx - A transaction to hash. Tx may be in binary blob form. Tx must be signed.\n * @returns A hash of tx.\n * @throws ValidationError if the Transaction is unsigned.\\\n * @category Utilities\n */\nexport function hashSignedTx(tx: Transaction | string): string {\n let txBlob: string\n let txObject: Transaction\n if (typeof tx === 'string') {\n txBlob = tx\n /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- Required until updated in binary codec. */\n txObject = decode(tx) as unknown as Transaction\n } else {\n txBlob = encode(tx)\n txObject = tx\n }\n\n if (txObject.TxnSignature === undefined && txObject.Signers === undefined) {\n throw new ValidationError('The transaction must be signed to hash it.')\n }\n\n const prefix = HashPrefix.TRANSACTION_ID.toString(16).toUpperCase()\n return sha512Half(prefix.concat(txBlob))\n}\n\n/**\n * Compute the hash of a ledger.\n *\n * @param ledgerHeader - Ledger to compute the hash of.\n * @returns The hash of the ledger.\n * @category Utilities\n */\nexport function hashLedgerHeader(ledgerHeader: Ledger): string {\n const prefix = HashPrefix.LEDGER.toString(HEX).toUpperCase()\n\n const ledger =\n prefix +\n intToHex(Number(ledgerHeader.ledger_index), 4) +\n bigintToHex(ledgerHeader.total_coins, 8) +\n ledgerHeader.parent_hash +\n ledgerHeader.transaction_hash +\n ledgerHeader.account_hash +\n intToHex(ledgerHeader.parent_close_time, 4) +\n intToHex(ledgerHeader.close_time, 4) +\n intToHex(ledgerHeader.close_time_resolution, 1) +\n intToHex(ledgerHeader.close_flags, 1)\n\n return sha512Half(ledger)\n}\n\n/**\n * Compute the root hash of the SHAMap containing all transactions.\n *\n * @param transactions - List of Transactions.\n * @returns The root hash of the SHAMap.\n * @category Utilities\n */\nexport function hashTxTree(\n transactions: Array<Transaction & { metaData?: TransactionMetadata }>,\n): string {\n const shamap = new SHAMap()\n for (const txJSON of transactions) {\n const txBlobHex = encode(txJSON)\n const metaHex = encode(txJSON.metaData ?? {})\n const txHash = hashSignedTx(txBlobHex)\n const data = addLengthPrefix(txBlobHex) + addLengthPrefix(metaHex)\n shamap.addItem(txHash, data, NodeType.TRANSACTION_METADATA)\n }\n\n return shamap.hash\n}\n\n/**\n * Compute the state hash of a list of LedgerEntries.\n *\n * @param entries - List of LedgerEntries.\n * @returns Hash of SHAMap that consists of all entries.\n * @category Utilities\n */\nexport function hashStateTree(entries: LedgerEntry[]): string {\n const shamap = new SHAMap()\n\n entries.forEach((ledgerEntry) => {\n const data = encode(ledgerEntry)\n shamap.addItem(ledgerEntry.index, data, NodeType.ACCOUNT_STATE)\n })\n\n return shamap.hash\n}\n\nfunction computeTransactionHash(\n ledger: Ledger,\n options: HashLedgerHeaderOptions,\n): string {\n const { transaction_hash } = ledger\n\n if (!options.computeTreeHashes) {\n return transaction_hash\n }\n\n if (ledger.transactions == null) {\n throw new ValidationError('transactions is missing from the ledger')\n }\n\n const transactionHash = hashTxTree(ledger.transactions)\n\n if (transaction_hash !== transactionHash) {\n throw new ValidationError(\n 'transactionHash in header' +\n ' does not match computed hash of transactions',\n {\n transactionHashInHeader: transaction_hash,\n computedHashOfTransactions: transactionHash,\n },\n )\n }\n\n return transactionHash\n}\n\nfunction computeStateHash(\n ledger: Ledger,\n options: HashLedgerHeaderOptions,\n): string {\n const { account_hash } = ledger\n\n if (!options.computeTreeHashes) {\n return account_hash\n }\n\n if (ledger.accountState == null) {\n throw new ValidationError('accountState is missing from the ledger')\n }\n\n const stateHash = hashStateTree(ledger.accountState)\n\n if (account_hash !== stateHash) {\n throw new ValidationError(\n 'stateHash in header does not match computed hash of state',\n )\n }\n\n return stateHash\n}\n\n/**\n * Compute the hash of a ledger.\n *\n * @param ledger - Ledger to compute the hash for.\n * @param options - Allow client to recompute Transaction and State Hashes.\n * @param options.computeTreeHashes - Whether to recompute the Transaction and State Hashes.\n * @returns The has of ledger.\n * @category Utilities\n */\nfunction hashLedger(\n ledger: Ledger,\n options: {\n computeTreeHashes?: boolean\n } = {},\n): string {\n const subhashes = {\n transaction_hash: computeTransactionHash(ledger, options),\n account_hash: computeStateHash(ledger, options),\n }\n return hashLedgerHeader({ ...ledger, ...subhashes })\n}\n\nexport default hashLedger\n","/* eslint-disable @typescript-eslint/no-magic-numbers -- this file mimics\n behavior in rippled. Magic numbers are used for lengths and conditions */\n/* eslint-disable no-bitwise -- this file mimics behavior in rippled. It uses\n bitwise operators for and-ing numbers with a mask and bit shifting. */\n\nimport BigNumber from 'bignumber.js'\nimport { decodeAccountID } from 'ripple-address-codec'\n\nimport hashLedger, {\n hashLedgerHeader,\n hashSignedTx,\n hashTxTree,\n hashStateTree,\n} from './hashLedger'\nimport HashPrefix from './HashPrefix'\nimport ledgerSpaces from './ledgerSpaces'\nimport sha512Half from './sha512Half'\n\nconst HEX = 16\nconst BYTE_LENGTH = 4\n\nfunction addressToHex(address: string): string {\n return Buffer.from(decodeAccountID(address)).toString('hex')\n}\n\nfunction ledgerSpaceHex(name: keyof typeof ledgerSpaces): string {\n return ledgerSpaces[name].charCodeAt(0).toString(HEX).padStart(4, '0')\n}\n\nconst MASK = 0xff\nfunction currencyToHex(currency: string): string {\n if (currency.length !== 3) {\n return currency\n }\n\n const bytes = Array(20).fill(0)\n bytes[12] = currency.charCodeAt(0) & MASK\n bytes[13] = currency.charCodeAt(1) & MASK\n bytes[14] = currency.charCodeAt(2) & MASK\n return Buffer.from(bytes).toString('hex')\n}\n\n/**\n * Hash the given binary transaction data with the single-signing prefix.\n *\n * See [Serialization Format](https://xrpl.org/serialization.html).\n *\n * @param txBlobHex - The binary transaction blob as a hexadecimal string.\n * @returns The hash to sign.\n * @category Utilities\n */\nexport function hashTx(txBlobHex: string): string {\n const prefix = HashPrefix.TRANSACTION_SIGN.toString(HEX).toUpperCase()\n return sha512Half(prefix + txBlobHex)\n}\n\n/**\n * Compute AccountRoot Ledger Object Index.\n *\n * All objects in a ledger's state tree have a unique Index.\n * The AccountRoot Ledger Object Index is derived by hashing the\n * address with a namespace identifier. This ensures every\n * Index is unique.\n *\n * See [Ledger Object Indexes](https://xrpl.org/ledger-object-ids.html).\n *\n * @param address - The classic account address.\n * @returns The Ledger Object Index for the account.\n * @category Utilities\n */\nexport function hashAccountRoot(address: string): string {\n return sha512Half(ledgerSpaceHex('account') + addressToHex(address))\n}\n\n/**\n * [SignerList Index Format](https://xrpl.org/signerlist.html#signerlist-id-format).\n *\n * The Index of a SignerList object is the SHA-512Half of the following values, concatenated in order:\n * * The RippleState space key (0x0053)\n * * The AccountID of the owner of the SignerList\n * * The SignerListID (currently always 0).\n *\n * This method computes a SignerList Ledger Object Index.\n *\n * @param address - The classic account address of the SignerList owner (starting with r).\n * @returns The Index of the account's SignerList object.\n * @category Utilities\n */\nexport function hashSignerListId(address: string): string {\n return sha512Half(\n `${ledgerSpaceHex('signerList') + addressToHex(address)}00000000`,\n )\n}\n\n/**\n * [Offer Index Format](https://xrpl.org/offer.html#offer-id-format).\n *\n * The Index of a Offer object is the SHA-512Half of the following values, concatenated in order:\n * * The Offer space key (0x006F)\n * * The AccountID of the account placing the offer\n * * The Sequence number of the OfferCreate transaction that created the offer.\n *\n * This method computes an Offer Index.\n *\n * @param address - The classic account address of the SignerList owner (starting with r).\n * @param sequence - Sequence of the Offer.\n * @returns The Index of the account's Offer object.\n * @category Utilities\n */\nexport function hashOfferId(address: string, sequence: number): string {\n const hexPrefix = ledgerSpaces.offer\n .charCodeAt(0)\n .toString(HEX)\n .padStart(2, '0')\n const hexSequence = sequence.toString(HEX).padStart(8, '0')\n const prefix = `00${hexPrefix}`\n return sha512Half(prefix + addressToHex(address) + hexSequence)\n}\n\n/**\n * Compute the hash of a Trustline.\n *\n * @param address1 - One of the addresses in the Trustline.\n * @param address2 - The other address in the Trustline.\n * @param currency - Currency in the Trustline.\n * @returns The hash of the Trustline.\n * @category Utilities\n */\nexport function hashTrustline(\n address1: string,\n address2: string,\n currency: string,\n): string {\n const address1Hex = addressToHex(address1)\n const address2Hex = addressToHex(address2)\n\n const swap = new BigNumber(address1Hex, 16).isGreaterThan(\n new BigNumber(address2Hex, 16),\n )\n const lowAddressHex = swap ? address2Hex : address1Hex\n const highAddressHex = swap ? address1Hex : address2Hex\n\n const prefix = ledgerSpaceHex('rippleState')\n return sha512Half(\n prefix + lowAddressHex + highAddressHex + currencyToHex(currency),\n )\n}\n\n/**\n * Compute the Hash of an Escrow LedgerEntry.\n *\n * @param address - Address of the Escrow.\n * @param sequence - OfferSequence of the Escrow.\n * @returns The hash of the Escrow LedgerEntry.\n * @category Utilities\n */\nexport function hashEscrow(address: string, sequence: number): string {\n return sha512Half(\n ledgerSpaceHex('escrow') +\n addressToHex(address) +\n sequence.toString(HEX).padStart(BYTE_LENGTH * 2, '0'),\n )\n}\n\n/**\n * Compute the hash of a Payment Channel.\n *\n * @param address - Account of the Payment Channel.\n * @param dstAddress - Destination Account of the Payment Channel.\n * @param sequence - Sequence number of the Transaction that created the Payment Channel.\n * @returns Hash of the Payment Channel.\n * @category Utilities\n */\nexport function hashPaymentChannel(\n address: string,\n dstAddress: string,\n sequence: number,\n): string {\n return sha512Half(\n ledgerSpaceHex('paychan') +\n addressToHex(address) +\n addressToHex(dstAddress) +\n sequence.toString(HEX).padStart(BYTE_LENGTH * 2, '0'),\n )\n}\n\nexport { hashLedgerHeader, hashSignedTx, hashLedger, hashStateTree, hashTxTree }\n","/**\n * XRP Ledger namespace prefixes.\n *\n * The XRP Ledger is a key-value store. In order to avoid name collisions,\n * names are partitioned into namespaces.\n *\n * Each namespace is just a single character prefix.\n *\n * See [LedgerNameSpace enum](https://github.com/ripple/rippled/blob/master/src/ripple/protocol/LedgerFormats.h#L100).\n */\nconst ledgerSpaces = {\n account: 'a',\n dirNode: 'd',\n generatorMap: 'g',\n rippleState: 'r',\n // Entry for an offer.\n offer: 'o',\n // Directory of things owned by an account.\n ownerDir: 'O',\n // Directory of order books.\n bookDir: 'B',\n contract: 'c',\n skipList: 's',\n escrow: 'u',\n amendment: 'f',\n feeSettings: 'e',\n ticket: 'T',\n signerList: 'S',\n paychan: 'x',\n check: 'C',\n depositPreauth: 'p',\n}\n\nexport default ledgerSpaces\n","import { createHash } from 'crypto'\n\nconst HASH_SIZE = 64\n\n/**\n * Compute a sha512Half Hash of a hex string.\n *\n * @param hex - Hex string to hash.\n * @returns Hash of hex.\n */\nfunction sha512Half(hex: string): string {\n return createHash('sha512')\n .update(Buffer.from(hex, 'hex'))\n .digest('hex')\n .toUpperCase()\n .slice(0, HASH_SIZE)\n}\n\nexport default sha512Half\n","import {\n classicAddressToXAddress,\n decodeAccountID,\n decodeAccountPublic,\n decodeNodePublic,\n decodeSeed,\n decodeXAddress,\n encodeAccountID,\n encodeAccountPublic,\n encodeNodePublic,\n encodeSeed,\n encodeXAddress,\n isValidClassicAddress,\n isValidXAddress,\n xAddressToClassicAddress,\n} from 'ripple-address-codec'\nimport * as rbc from 'ripple-binary-codec'\nimport { verify as verifyKeypairSignature } from 'ripple-keypairs'\n\nimport { LedgerEntry } from '../models/ledger'\nimport { Response } from '../models/methods'\nimport { PaymentChannelClaim } from '../models/transactions/paymentChannelClaim'\nimport { Transaction } from '../models/transactions/transaction'\n\nimport createCrossChainPayment from './createCrossChainPayment'\nimport { deriveKeypair, deriveAddress, deriveXAddress } from './derive'\nimport getBalanceChanges from './getBalanceChanges'\nimport getNFTokenID from './getNFTokenID'\nimport {\n hashSignedTx,\n hashTx,\n hashAccountRoot,\n hashSignerListId,\n hashOfferId,\n hashTrustline,\n hashTxTree,\n hashStateTree,\n hashLedger,\n hashLedgerHeader,\n hashEscrow,\n hashPaymentChannel,\n} from './hashes'\nimport parseNFTokenID from './parseNFTokenID'\nimport {\n percentToTransferRate,\n decimalToTransferRate,\n transferRateToDecimal,\n percentToQuality,\n decimalToQuality,\n qualityToDecimal,\n} from './quality'\nimport signPaymentChannelClaim from './signPaymentChannelClaim'\nimport { convertHexToString, convertStringToHex } from './stringConversion'\nimport {\n rippleTimeToISOTime,\n isoTimeToRippleTime,\n rippleTimeToUnixTime,\n unixTimeToRippleTime,\n} from './timeConversion'\nimport verifyPaymentChannelClaim from './verifyPaymentChannelClaim'\nimport { xrpToDrops, dropsToXrp } from './xrpConversion'\n\n/**\n * Check if a secret is valid.\n *\n * @param secret - Secret to test for validity.\n * @returns True if secret can be derived into a keypair.\n * @category Utilities\n */\nfunction isValidSecret(secret: string): boolean {\n try {\n deriveKeypair(secret)\n return true\n } catch (_err) {\n return false\n }\n}\n\n/**\n * Encodes a LedgerEntry or Transaction into a hex string\n *\n * @param object - LedgerEntry or Transaction in JSON format.\n * @returns A hex string representing the encoded object.\n */\nfunction encode(object: Transaction | LedgerEntry): string {\n return rbc.encode(object)\n}\n\n/**\n * Encodes a Transaction for signing\n *\n * @param object - LedgerEntry in JSON or Transaction format.\n * @returns A hex string representing the encoded object.\n */\nfunction encodeForSigning(object: Transaction): string {\n return rbc.encodeForSigning(object)\n}\n\n/**\n * Encodes a PaymentChannelClaim for signing\n *\n * @param object - PaymentChannelClaim in JSON format.\n * @returns A hex string representing the encoded object.\n */\nfunction encodeForSigningClaim(object: PaymentChannelClaim): string {\n return rbc.encodeForSigningClaim(object)\n}\n\n/**\n * Encodes a Transaction for multi-signing\n *\n * @param object - Transaction in JSON format.\n * @param signer - The address of the account signing this transaction\n * @returns A hex string representing the encoded object.\n */\nfunction encodeForMultiSigning(object: Transaction, signer: string): string {\n return rbc.encodeForMultisigning(object, signer)\n}\n\n/**\n * Decodes a hex string into a transaction | ledger entry\n *\n * @param hex - hex string in the XRPL serialization format.\n * @returns The hex string decoded according to XRPL serialization format.\n */\nfunction decode(hex: string): Record<string, unknown> {\n return rbc.decode(hex)\n}\n\n/**\n * Validates that a given address is a valid X-Address or a valid classic\n * address.\n *\n * @param address - Address to validate.\n * @returns True if address is a valid X-Address or classic address.\n * @category Utilities\n */\nfunction isValidAddress(address: string): boolean {\n return isValidXAddress(address) || isValidClassicAddress(address)\n}\n\n/**\n * Returns true if there are more pages of data.\n *\n * When there are more results than contained in the response, the response\n * includes a `marker` field.\n *\n * See https://ripple.com/build/rippled-apis/#markers-and-pagination.\n *\n * @param response - Response to check for more pages on.\n * @returns Whether the response has more pages of data.\n * @category Utilities\n */\nfunction hasNextPage(response: Response): boolean {\n // eslint-disable-next-line @typescript-eslint/dot-notation -- only checking if it exists\n return Boolean(response.result['marker'])\n}\n\n/**\n * @category Utilities\n */\nconst hashes = {\n hashSignedTx,\n hashTx,\n hashAccountRoot,\n hashSignerListId,\n hashOfferId,\n hashTrustline,\n hashTxTree,\n hashStateTree,\n hashLedger,\n hashLedgerHeader,\n hashEscrow,\n hashPaymentChannel,\n}\n\nexport {\n getBalanceChanges,\n dropsToXrp,\n xrpToDrops,\n hasNextPage,\n rippleTimeToISOTime,\n isoTimeToRippleTime,\n rippleTimeToUnixTime,\n unixTimeToRippleTime,\n percentToQuality,\n decimalToQuality,\n percentToTransferRate,\n decimalToTransferRate,\n transferRateToDecimal,\n qualityToDecimal,\n isValidSecret,\n isValidAddress,\n hashes,\n deriveKeypair,\n deriveAddress,\n deriveXAddress,\n signPaymentChannelClaim,\n verifyKeypairSignature,\n verifyPaymentChannelClaim,\n convertStringToHex,\n convertHexToString,\n classicAddressToXAddress,\n xAddressToClassicAddress,\n isValidXAddress,\n isValidClassicAddress,\n encodeSeed,\n decodeSeed,\n encodeAccountID,\n decodeAccountID,\n encodeNodePublic,\n decodeNodePublic,\n encodeAccountPublic,\n decodeAccountPublic,\n encodeXAddress,\n decodeXAddress,\n encode,\n decode,\n encodeForMultiSigning,\n encodeForSigning,\n encodeForSigningClaim,\n getNFTokenID,\n createCrossChainPayment,\n parseNFTokenID,\n}\n","/* eslint-disable @typescript-eslint/no-magic-numbers -- Doing hex string parsing. */\nimport BigNumber from 'bignumber.js'\nimport { encodeAccountID } from 'ripple-address-codec'\n\nimport { XrplError } from '../errors'\n\n/**\n * An issuer may issue several NFTs with the same taxon; to ensure that NFTs are\n * spread across multiple pages we lightly mix the taxon up by using the sequence\n * (which is not under the issuer's direct control) as the seed for a simple linear\n * congruential generator.\n *\n * From the Hull-Dobell theorem we know that f(x)=(m*x+c) mod n will yield a\n * permutation of [0, n) when n is a power of 2 if m is congruent to 1 mod 4 and\n * c is odd. By doing a bitwise XOR with this permutation we can scramble/unscramble\n * the taxon.\n *\n * The XLS-20d proposal fixes m = 384160001 and c = 2459.\n * We then take the modulus of 2^32 which is 4294967296.\n *\n * @param taxon - The scrambled or unscrambled taxon (The XOR is both the encoding and decoding)\n * @param tokenSeq - The account sequence when the token was minted. Used as a psuedorandom seed.\n * @returns the opposite taxon. If the taxon was scrambled it becomes unscrambled, and vice versa.\n */\nfunction unscrambleTaxon(taxon: number, tokenSeq: number): number {\n /* eslint-disable no-bitwise -- XOR is part of the encode/decode scheme. */\n return (taxon ^ (384160001 * tokenSeq + 2459)) % 4294967296\n /* eslint-enable no-bitwise */\n}\n\n/**\n * Parses an NFTokenID into the information it is encoding.\n *\n * Example decoding:\n *\n * 000B 0539 C35B55AA096BA6D87A6E6C965A6534150DC56E5E 12C5D09E 0000000C\n * +--- +--- +--------------------------------------- +------- +-------\n * | | | | |\n * | | | | `---> Sequence: 12\n * | | | |\n * | | | `---> Scrambled Taxon: 314,953,886\n * | | | Unscrambled Taxon: 1337\n * | | |\n * | | `---> Issuer: rJoxBSzpXhPtAuqFmqxQtGKjA13jUJWthE\n * | |\n * | `---> TransferFee: 1337.0 bps or 13.37%\n * |\n * `---> Flags: 11 -> lsfBurnable, lsfOnlyXRP and lsfTransferable\n *\n * @param nftokenID - A hex string which identifies an NFToken on the ledger.\n * @throws XrplError when given an invalid nftokenID.\n * @returns a decoded nftokenID with all fields encoded within.\n */\nexport default function parseNFTokenID(nftokenID: string): {\n NFTokenID: string\n Flags: number\n TransferFee: number\n Issuer: string\n Taxon: number\n Sequence: number\n} {\n const expectedLength = 64\n if (nftokenID.length !== expectedLength) {\n throw new XrplError(`Attempting to parse a nftokenID with length ${nftokenID.length}\n , but expected a token with length ${expectedLength}`)\n }\n\n const scrambledTaxon = new BigNumber(\n nftokenID.substring(48, 56),\n 16,\n ).toNumber()\n const sequence = new BigNumber(nftokenID.substring(56, 64), 16).toNumber()\n\n const NFTokenIDData = {\n NFTokenID: nftokenID,\n Flags: new BigNumber(nftokenID.substring(0, 4), 16).toNumber(),\n TransferFee: new BigNumber(nftokenID.substring(4, 8), 16).toNumber(),\n Issuer: encodeAccountID(Buffer.from(nftokenID.substring(8, 48), 'hex')),\n Taxon: unscrambleTaxon(scrambledTaxon, sequence),\n Sequence: sequence,\n }\n\n return NFTokenIDData\n}\n","import BigNumber from 'bignumber.js'\n\nimport { ValidationError } from '../errors'\n\nconst BASE_TEN = 10\nconst ONE_BILLION = '1000000000'\nconst TWO_BILLION = '2000000000'\n\nfunction percentToDecimal(percent: string): string {\n if (!percent.endsWith('%')) {\n throw new ValidationError(`Value ${percent} must end with %`)\n }\n\n // Split the string on % and filter out any empty strings\n const split = percent.split('%').filter((str) => str !== '')\n if (split.length !== 1) {\n throw new ValidationError(`Value ${percent} contains too many % signs`)\n }\n\n return new BigNumber(split[0]).dividedBy('100').toString(BASE_TEN)\n}\n\n/**\n * Converts a string decimal to \"billionths\" format for use with TransferRate.\n *\n * @param decimal - A string decimal between 0 and 1.00\n * @returns A number in the \"billionths\" format.\n * @throws ValidationError when the parameter is not convertible to\n * \"billionths\" format.\n * @category Utilities\n */\nexport function decimalToTransferRate(decimal: string): number {\n const rate = new BigNumber(decimal).times(ONE_BILLION).plus(ONE_BILLION)\n\n if (rate.isLessThan(ONE_BILLION) || rate.isGreaterThan(TWO_BILLION)) {\n throw new ValidationError(`Decimal value must be between 0 and 1.00.`)\n }\n\n const billionths = rate.toString(BASE_TEN)\n\n if (billionths === ONE_BILLION) {\n return 0\n }\n\n if (billionths === 'NaN') {\n throw new ValidationError(`Value is not a number`)\n }\n\n if (billionths.includes('.')) {\n throw new ValidationError(`Decimal exceeds maximum precision.`)\n }\n\n return Number(billionths)\n}\n\n/**\n * Converts a string percent to \"billionths\" format for use with TransferRate.\n *\n * @param percent - A string percent between 0% and 100%.\n * @returns A number in the \"billionths\" format.\n * @throws ValidationError when the percent parameter is not convertible to\n * \"billionths\" format.\n * @category Utilities\n */\nexport function percentToTransferRate(percent: string): number {\n return decimalToTransferRate(percentToDecimal(percent))\n}\n\n/**\n * Converts a string decimal to the \"billionths\" format for use with QualityIn/\n * QualityOut\n *\n * @param decimal - A string decimal (i.e. \".00034\").\n * @returns A number in the \"billionths\" format.\n * @throws ValidationError when the parameter is not convertible to\n * \"billionths\" format.\n * @category Utilities\n */\nexport function decimalToQuality(decimal: string): number {\n const rate = new BigNumber(decimal).times(ONE_BILLION)\n\n const billionths = rate.toString(BASE_TEN)\n\n if (billionths === 'NaN') {\n throw new ValidationError(`Value is not a number`)\n }\n\n if (billionths.includes('-')) {\n throw new ValidationError('Cannot have negative Quality')\n }\n\n if (billionths === ONE_BILLION) {\n return 0\n }\n\n if (billionths.includes('.')) {\n throw new ValidationError(`Decimal exceeds maximum precision.`)\n }\n\n return Number(billionths)\n}\n\n/**\n * Converts a quality in \"billionths\" format to a decimal.\n *\n * @param quality - Quality to convert to decimal.\n * @returns decimal representation of quality.\n * @throws ValidationError when quality is not convertible to decimal format.\n * @category Utilities\n */\nexport function qualityToDecimal(quality: number): string {\n if (!Number.isInteger(quality)) {\n throw new ValidationError('Quality must be an integer')\n }\n\n if (quality < 0) {\n throw new ValidationError('Negative quality not allowed')\n }\n\n if (quality === 0) {\n return '1'\n }\n\n const decimal = new BigNumber(quality).dividedBy(ONE_BILLION)\n\n return decimal.toString(BASE_TEN)\n}\n\n/**\n * Converts a transfer rate in \"billionths\" format to a decimal.\n *\n * @param rate - TransferRate to convert to decimal.\n * @returns decimal representation of transfer Rate.\n * @throws ValidationError when it cannot convert from billionths format.\n * @category Utilities\n */\nexport function transferRateToDecimal(rate: number): string {\n if (!Number.isInteger(rate)) {\n throw new ValidationError(\n 'Error decoding, transfer Rate must be an integer',\n )\n }\n\n if (rate === 0) {\n return '0'\n }\n\n const decimal = new BigNumber(rate).minus(ONE_BILLION).dividedBy(ONE_BILLION)\n\n if (decimal.isLessThan(0)) {\n throw new ValidationError('Error decoding, negative transfer rate')\n }\n\n return decimal.toString(BASE_TEN)\n}\n\n/**\n * Converts a string percent to the \"billionths\" format for use with QualityIn/\n * QualityOut\n *\n * @param percent - A string percent (i.e. \".034%\").\n * @returns A number in the \"billionths\" format.\n * @throws ValidationError when the percent parameter is not convertible to\n * \"billionths\" format.\n * @category Utilities\n */\nexport function percentToQuality(percent: string): number {\n return decimalToQuality(percentToDecimal(percent))\n}\n","import { encodeForSigningClaim } from 'ripple-binary-codec'\nimport { sign } from 'ripple-keypairs'\n\nimport { xrpToDrops } from './xrpConversion'\n\n/**\n * Sign a payment channel claim.\n *\n * @param channel - Channel identifier specified by the paymentChannelClaim.\n * @param amount - Amount specified by the paymentChannelClaim.\n * @param privateKey - Private Key to sign paymentChannelClaim with.\n * @returns True if the channel is valid.\n * @category Utilities\n */\nfunction signPaymentChannelClaim(\n channel: string,\n amount: string,\n privateKey: string,\n): string {\n const signingData = encodeForSigningClaim({\n channel,\n amount: xrpToDrops(amount),\n })\n return sign(signingData, privateKey)\n}\n\nexport default signPaymentChannelClaim\n","/**\n * Converts a string to its hex equivalent. Useful for Memos.\n *\n * @param string - The string to convert to Hex.\n * @returns The Hex equivalent of the string.\n * @category Utilities\n */\nfunction convertStringToHex(string: string): string {\n return Buffer.from(string, 'utf8').toString('hex').toUpperCase()\n}\n\n/**\n * Converts hex to its string equivalent. Useful to read the Domain field and some Memos.\n *\n * @param hex - The hex to convert to a string.\n * @param encoding - The encoding to use. Defaults to 'utf8' (UTF-8). 'ascii' is also allowed.\n * @returns The converted string.\n * @category Utilities\n */\nfunction convertHexToString(\n hex: string,\n encoding: BufferEncoding = 'utf8',\n): string {\n return Buffer.from(hex, 'hex').toString(encoding)\n}\n\nexport { convertHexToString, convertStringToHex }\n","const RIPPLE_EPOCH_DIFF = 0x386d4380\n\n/**\n * Convert a ripple timestamp to a unix timestamp.\n *\n * @param rpepoch - (seconds since 1/1/2000 GMT).\n * @returns Milliseconds since unix epoch.\n * @category Utilities\n */\nfunction rippleTimeToUnixTime(rpepoch: number): number {\n return (rpepoch + RIPPLE_EPOCH_DIFF) * 1000\n}\n\n/**\n * Convert a unix timestamp to a ripple timestamp.\n *\n * @param timestamp - (ms since unix epoch).\n * @returns Seconds since Ripple Epoch (1/1/2000 GMT).\n * @category Utilities\n */\nfunction unixTimeToRippleTime(timestamp: number): number {\n return Math.round(timestamp / 1000) - RIPPLE_EPOCH_DIFF\n}\n\n/**\n * Convert a ripple timestamp to an Iso8601 timestamp.\n *\n * @param rippleTime - Is the number of seconds since Ripple Epoch (1/1/2000 GMT).\n * @returns Iso8601 international standard date format.\n * @category Utilities\n */\nfunction rippleTimeToISOTime(rippleTime: number): string {\n return new Date(rippleTimeToUnixTime(rippleTime)).toISOString()\n}\n\n/**\n * Convert an ISO8601 timestmap to a ripple timestamp.\n *\n * @param iso8601 - International standard date format.\n * @returns Seconds since ripple epoch (1/1/2000 GMT).\n * @category Utilities\n */\nfunction isoTimeToRippleTime(iso8601: string | Date): number {\n const isoDate = typeof iso8601 === 'string' ? new Date(iso8601) : iso8601\n return unixTimeToRippleTime(isoDate.getTime())\n}\n\nexport {\n rippleTimeToUnixTime,\n unixTimeToRippleTime,\n rippleTimeToISOTime,\n isoTimeToRippleTime,\n}\n","import { encodeForSigningClaim } from 'ripple-binary-codec'\nimport { verify } from 'ripple-keypairs'\n\nimport { xrpToDrops } from './xrpConversion'\n\n/**\n * Verify the signature of a payment channel claim.\n *\n * @param channel - Channel identifier specified by the paymentChannelClaim.\n * @param amount - Amount specified by the paymentChannelClaim.\n * @param signature - Signature produced from signing paymentChannelClaim.\n * @param publicKey - Public key that signed the paymentChannelClaim.\n * @returns True if the channel is valid.\n * @category Utilities\n */\n// eslint-disable-next-line max-params -- Needs 4 params\nfunction verifyPaymentChannelClaim(\n channel: string,\n amount: string,\n signature: string,\n publicKey: string,\n): boolean {\n const signingData = encodeForSigningClaim({\n channel,\n amount: xrpToDrops(amount),\n })\n return verify(signingData, signature, publicKey)\n}\n\nexport default verifyPaymentChannelClaim\n","import BigNumber from 'bignumber.js'\n\nimport { ValidationError } from '../errors'\n\nconst DROPS_PER_XRP = 1000000.0\nconst MAX_FRACTION_LENGTH = 6\nconst BASE_TEN = 10\nconst SANITY_CHECK = /^-?[0-9.]+$/u\n\n/**\n * Convert Drops to XRP.\n *\n * @param dropsToConvert - Drops to convert to XRP. This can be a string, number, or BigNumber.\n * @returns Amount in XRP.\n * @throws When drops amount is invalid.\n * @category Utilities\n */\nexport function dropsToXrp(dropsToConvert: BigNumber.Value): string {\n /*\n * Converting to BigNumber and then back to string should remove any\n * decimal point followed by zeros, e.g. '1.00'.\n * Important: specify base BASE_10 to avoid exponential notation, e.g. '1e-7'.\n */\n const drops = new BigNumber(dropsToConvert).toString(BASE_TEN)\n\n // check that the value is valid and actually a number\n if (typeof dropsToConvert === 'string' && drops === 'NaN') {\n throw new ValidationError(\n `dropsToXrp: invalid value '${dropsToConvert}', should be a BigNumber or string-encoded number.`,\n )\n }\n\n // drops are only whole units\n if (drops.includes('.')) {\n throw new ValidationError(\n `dropsToXrp: value '${drops}' has too many decimal places.`,\n )\n }\n\n /*\n * This should never happen; the value has already been\n * validated above. This just ensures BigNumber did not do\n * something unexpected.\n */\n if (!SANITY_CHECK.exec(drops)) {\n throw new ValidationError(\n `dropsToXrp: failed sanity check -` +\n ` value '${drops}',` +\n ` does not match (^-?[0-9]+$).`,\n )\n }\n\n return new BigNumber(drops).dividedBy(DROPS_PER_XRP).toString(BASE_TEN)\n}\n\n/**\n * Convert an amount in XRP to an amount in drops.\n *\n * @param xrpToConvert - Amount in XRP.\n * @returns Amount in drops.\n * @throws When amount in xrp is invalid.\n * @category Utilities\n */\nexport function xrpToDrops(xrpToConvert: BigNumber.Value): string {\n // Important: specify base BASE_TEN to avoid exponential notation, e.g. '1e-7'.\n const xrp = new BigNumber(xrpToConvert).toString(BASE_TEN)\n\n // check that the value is valid and actually a number\n if (typeof xrpToConvert === 'string' && xrp === 'NaN') {\n throw new ValidationError(\n `xrpToDrops: invalid value '${xrpToConvert}', should be a BigNumber or string-encoded number.`,\n )\n }\n\n /*\n * This should never happen; the value has already been\n * validated above. This just ensures BigNumber did not do\n * something unexpected.\n */\n if (!SANITY_CHECK.exec(xrp)) {\n throw new ValidationError(\n `xrpToDrops: failed sanity check - value '${xrp}', does not match (^-?[0-9.]+$).`,\n )\n }\n\n const components = xrp.split('.')\n if (components.length > 2) {\n throw new ValidationError(\n `xrpToDrops: failed sanity check - value '${xrp}' has too many decimal points.`,\n )\n }\n\n const fraction = components[1] || '0'\n if (fraction.length > MAX_FRACTION_LENGTH) {\n throw new ValidationError(\n `xrpToDrops: value '${xrp}' has too many decimal places.`,\n )\n }\n\n return new BigNumber(xrp)\n .times(DROPS_PER_XRP)\n .integerValue(BigNumber.ROUND_FLOOR)\n .toString(BASE_TEN)\n}\n","'use strict';\n\nvar possibleNames = [\n\t'BigInt64Array',\n\t'BigUint64Array',\n\t'Float32Array',\n\t'Float64Array',\n\t'Int16Array',\n\t'Int32Array',\n\t'Int8Array',\n\t'Uint16Array',\n\t'Uint32Array',\n\t'Uint8Array',\n\t'Uint8ClampedArray'\n];\n\nvar g = typeof globalThis === 'undefined' ? global : globalThis;\n\nmodule.exports = function availableTypedArrays() {\n\tvar out = [];\n\tfor (var i = 0; i < possibleNames.length; i++) {\n\t\tif (typeof g[possibleNames[i]] === 'function') {\n\t\t\tout[out.length] = possibleNames[i];\n\t\t}\n\t}\n\treturn out;\n};\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\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\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// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","// startup\n// Load entry module and return exports\n// This entry module is referenced by other modules so it can't be inlined\nvar __webpack_exports__ = __webpack_require__(66);\n"],"names":["asn1","exports","bignum","define","base","constants","decoders","encoders","inherits","Entity","name","body","this","prototype","_createNamed","Base","Generated","entity","_initNamed","call","_getDecoder","enc","hasOwnProperty","decode","data","options","_getEncoder","encode","reporter","Reporter","Buffer","DecoderBuffer","isBuffer","offset","length","error","EncoderBuffer","value","Array","isArray","map","item","isEncoderBuffer","byteLength","isDecoderBuffer","constructor","save","restore","isEmpty","readUInt8","skip","raw","res","fail","bytes","_reporterState","slice","join","out","alloc","forEach","write","copy","Node","assert","tags","methods","concat","parent","state","_baseState","children","tag","args","reverseArgs","choice","optional","any","obj","use","useDecoder","key","explicit","implicit","contains","_wrap","module","stateProps","clone","cstate","prop","method","push","apply","arguments","_init","filter","child","equal","_useArgs","arg","Object","keys","Error","def","val","num","newKey","_decode","input","wrapResult","prevObj","result","present","prevKey","enterKey","_peekTag","isError","_decodeGeneric","_decodeChoice","e","enterObject","_decodeTag","start","track","path","_getUse","leaveObject","exitKey","leaveKey","_decodeList","test","_decodeStr","_decodeObjid","_decodeTime","_decodeNull","_decodeBool","_decodeInt","_use","match","some","node","type","_createEncoderBuffer","_encode","_encodeValue","undefined","_skipDefault","content","primitive","_encodeChoice","_encodePrimitive","cls","_encodeComposite","JSON","stringify","_encodeStr","_encodeObjid","_encodeTime","_encodeNull","_encodeInt","_encodeBool","_isNumstr","str","_isPrintstr","errors","ReporterError","msg","rethrow","pathLen","index","prev","now","err","inherited","elem","message","stack","partial","captureStackTrace","reverse","tagClass","tagClassByName","tagByName","_reverse","der","DERDecoder","tree","DERNode","derDecodeTag","buf","oct","tagStr","derDecodeLen","len","i","j","buffer","decodedTag","_skipUntilEnd","decoder","possibleEnd","unused","String","fromCharCode","readUInt16BE","numstr","toString","printstr","values","relative","identifiers","ident","subident","first","second","tmp","year","mon","day","hour","min","sec","Date","UTC","pem","PEMDecoder","lines","split","label","toUpperCase","re","end","base64","replace","from","DEREncoder","two","encodedTag","encodeTag","header","lenOctets","writeUInt16BE","charCodeAt","id","splice","size","objid","time","date","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","numArray","toArray","sign","unshift","dataBuffer","defaultBuffer","PEMEncoder","p","_typeof","Symbol","iterator","isDeepEqual","isDeepStrictEqual","_require$codes","codes","ERR_AMBIGUOUS_ARGUMENT","ERR_INVALID_ARG_TYPE","ERR_INVALID_ARG_VALUE","ERR_INVALID_RETURN_VALUE","ERR_MISSING_ARGS","AssertionError","inspect","_require$types","isPromise","isRegExp","objectAssign","assign","objectIs","is","lazyLoadComparison","comparison","Map","warned","ok","NO_EXCEPTION_SENTINEL","innerFail","innerOk","fn","argLen","generatedMessage","actual","expected","operator","stackStartFn","_len","_key","internalMessage","argsLen","process","emitWarning","console","warn","bind","errArgs","notEqual","deepEqual","notDeepEqual","deepStrictEqual","notDeepStrictEqual","strictEqual","notStrictEqual","Comparison","_this","instance","Constructor","TypeError","_classCallCheck","expectedException","a","b","compareExceptionKey","isPrototypeOf","getActual","checkIsPromise","then","catch","waitForActual","promiseFn","Promise","resolve","resultPromise","expectsError","details","fnType","expectsNoError","strict","_len6","_key6","throws","_len2","_key2","rejects","_len3","_key3","doesNotThrow","_len4","_key4","doesNotReject","_len5","_key5","ifError","newErr","origStack","tmp2","shift","tmp1","pos","indexOf","_defineProperty","defineProperty","enumerable","configurable","writable","_defineProperties","target","props","descriptor","_possibleConstructorReturn","self","_assertThisInitialized","ReferenceError","_wrapNativeSuper","Class","_cache","Function","has","get","set","Wrapper","_construct","_getPrototypeOf","create","_setPrototypeOf","Parent","Reflect","construct","sham","Proxy","isNativeReflectConstruct","o","setPrototypeOf","__proto__","getPrototypeOf","endsWith","search","this_len","substring","blue","green","red","white","kReadableOperator","strictEqualObject","notStrictEqualObject","notIdentical","kMaxShortLength","copyError","source","inspectValue","compact","customInspect","depth","maxArrayLength","Infinity","showHidden","breakLength","showProxy","sorted","getters","_Error","limit","stackTraceLimit","stderr","isTTY","getColorDepth","other","lastPos","skipped","actualInspected","actualLines","expectedLines","indicator","inputLength","columns","count","Math","floor","maxCount","log","repeat","pop","maxLines","max","_actualLines","printedLines","skippedMsg","cur","expectedLine","actualLine","divergingLines","createErrDiff","_res","knownOperators","code","protoProps","subClass","superClass","_inherits","custom","recurseTimes","ctx","ownKeys","getOwnPropertySymbols","sym","getOwnPropertyDescriptor","_objectSpread","util","createErrorType","NodeError","_Base","arg1","arg2","arg3","getMessage","oneOf","thing","determiner","substr","reason","inspected","RangeError","_slicedToArray","arr","_arrayWithHoles","_arr","_n","_d","_e","_s","_i","next","done","_iterableToArrayLimit","_nonIterableRest","regexFlagsSupported","flags","arrayFromSet","array","arrayFromMap","objectGetOwnPropertySymbols","numberIsNaN","Number","isNaN","uncurryThis","f","propertyIsEnumerable","objectToString","isAnyArrayBuffer","isArrayBufferView","isDate","isMap","isSet","isNativeError","isBoxedPrimitive","isNumberObject","isStringObject","isBooleanObject","isBigIntObject","isSymbolObject","isFloat32Array","isFloat64Array","isNonIndex","pow","getOwnNonIndexProperties","compare","x","y","kNoIterator","kIsArray","kIsSet","kIsMap","innerDeepEqual","val1","val2","memos","buf1","buf2","val1Tag","keys1","keys2","keyCheck","getTime","RegExp","Uint8Array","byteOffset","areSimilarTypedArrays","areSimilarFloatArrays","_keys","_keys2","valueOf","Boolean","BigInt","isEqualBoxedPrimitive","getEnumerables","k","iterationType","aKeys","bKeys","symbolKeysA","symbolKeysB","_symbolKeysB","position","val2MemoA","val2MemoB","areEq","memo","aValues","Set","add","setMightHaveLoosePrim","bValues","_val","setHasEqualElement","setEquiv","aEntries","_aEntries$i","item1","item2","mapMightHaveLoosePrim","bEntries","_i2","_bEntries$_i","mapHasEqualEntry","mapEquiv","keysA","objEquiv","delete","setValues","findLooseMatchingPrimitives","prim","altValue","curB","key1","key2","_Buffer","ALPHABET","BASE_MAP","charAt","xc","BASE","LEADER","FACTOR","iFACTOR","decodeUnsafe","psz","zeroes","b256","carry","it3","it4","vch","allocUnsafe","fill","pbegin","pend","b58","it1","it2","string","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","Arr","_byteLength","curByte","revLookup","fromByteArray","uint8","extraBytes","parts","maxChunkLength","len2","encodeChunk","lookup","output","LOG_BASE","MAX_INT","MAX_INT_ARR","smallToArray","DEFAULT_ALPHABET","supportsNativeBigInt","Integer","v","radix","alphabet","caseSensitive","parseValue","parseBase","BigInteger","isSmall","SmallInteger","NativeBigInt","isPrecise","n","arrayToSmall","trim","compareAbs","createArray","truncate","ceil","sum","l_a","l_b","r","addAny","addSmall","l","subtract","difference","a_l","b_l","borrow","subtractSmall","multiplyLong","product","a_i","multiplySmall","shiftLeft","multiplyKaratsuba","d","c","ac","bd","abcd","multiplySmallAndArray","square","divModSmall","lambda","q","remainder","divisor","quotient","divModAny","negate","abs","quotientDigit","divisorMostSignificantDigit","divMod1","guess","xlen","highx","highy","check","part","divMod2","qSign","mod","mSign","isBasicPrime","isUnit","equals","isEven","isDivisibleBy","lesser","millerRabinTest","nPrev","divide","bigInt","modPow","plus","subtractAny","minus","small","multiply","l1","l2","times","_multiplyBySmall","divmod","over","_0","_1","_2","isNegative","exp","isZero","modInv","isPositive","isOdd","compareTo","eq","notEquals","neq","greater","gt","lt","greaterOrEquals","geq","lesserOrEquals","leq","isPrime","bits","bitLength","logN","toJSNumber","t","isProbablePrime","iterations","rng","randBetween","lastT","lastR","zero","newT","one","newR","powersOfTwo","powers2Length","highestPower2","shift_isSmall","bitwise","xSign","ySign","xRem","not","yRem","xDigit","yDigit","xDivMod","yDivMod","shiftRight","remQuo","and","or","xor","LOBMASK_I","LOBMASK_BI","roughLOB","integerLogarithm","gcd","text","toLowerCase","absBase","alphabetValues","digits","parseBaseFromArray","toBase","neg","left","digit","toBaseString","parseStringValue","decimalPlace","parseNumberValue","toJSON","parseInt","minusOne","lcm","isInstance","usedRNG","random","low","range","restricted","top","fromArray","globalObject","BigNumber","isNumeric","mathceil","mathfloor","bignumberError","tooManyDigits","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","bitFloor","coeffToString","s","z","yc","intCheck","toExponential","toFixedPoint","zs","configObject","div","convertBase","parseNumeric","pow2_53","random53bitInt","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","P","ONE","DECIMAL_PLACES","ROUNDING_MODE","TO_EXP_NEG","TO_EXP_POS","MIN_EXP","MAX_EXP","CRYPTO","MODULO_MODE","POW_PRECISION","FORMAT","prefix","groupSize","secondaryGroupSize","groupSeparator","decimalSeparator","fractionGroupSize","fractionGroupSeparator","suffix","alphabetHasNormalDecimalDigits","caseChanged","isNum","_isBigNumber","round","DEBUG","format","rm","c0","ne","maxOrMin","m","normalise","sd","ni","rd","pows10","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","config","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","maximum","minimum","dp","rand","Uint32Array","decimal","toBaseOut","baseIn","baseOut","arrL","callerIsToString","temp","xlo","xhi","klo","khi","aL","bL","cmp","more","prod","prodL","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","NaN","p1","p2","absoluteValue","comparedTo","decimalPlaces","dividedBy","dividedToIntegerBy","idiv","exponentiatedBy","half","isModExp","nIsBig","nIsNeg","nIsOdd","isInteger","integerValue","isEqualTo","isFinite","isGreaterThan","isGreaterThanOrEqualTo","gte","isLessThan","isLessThanOrEqualTo","lte","xLTy","xe","ye","modulo","multipliedBy","xcL","ycL","ylo","yhi","zc","sqrtBase","negated","precision","shiftedBy","squareRoot","sqrt","rep","toFixed","toFormat","g1","g2","intPart","fractionPart","isNeg","intDigits","toFraction","md","d0","d1","d2","n0","n1","toNumber","toPrecision","bs58check","ecc","typeforce","wif","UINT256_TYPE","BufferN","NETWORK_TYPE","compile","UInt8","bip32","public","UInt32","private","BITCOIN","messagePrefix","bech32","pubKeyHash","scriptHash","HIGHEST_BIT","UINT31_MAX","BIP32Path","UInt31","BIP32","__D","__Q","chainCode","network","__DEPTH","__INDEX","__PARENT_FINGERPRINT","lowR","parentFingerprint","publicKey","pointFromScalar","privateKey","identifier","hash160","fingerprint","compressed","isNeutered","neutered","fromPublicKeyLocal","toBase58","version","writeUInt32BE","writeUInt8","toWIF","derive","isHardened","I","hmacSHA512","IL","IR","isPrivate","hd","Ki","pointAddScalar","readUInt32BE","ki","privateAdd","fromPrivateKeyLocal","deriveHardened","derivePath","splitPath","reduce","prevHd","indexStr","hash","sig","extraData","counter","writeUIntLE","signWithEntropy","verify","signature","fromPrivateKey","isPoint","fromBase58","inString","fromPublicKey","fromSeed","seed","createHash","createHmac","sha256Hash","update","digest","bip32_1","wordlists","_default","czech","chinese_simplified","chinese_traditional","korean","french","italian","spanish","japanese","JA","portuguese","english","EN","pbkdf2_1","_wordlists_1","DEFAULT_WORDLIST","INVALID_MNEMONIC","INVALID_ENTROPY","INVALID_CHECKSUM","WORDLIST_REQUIRED","normalize","lpad","padString","binaryToByte","bin","bytesToBinary","deriveChecksumBits","entropyBuffer","CS","salt","password","mnemonicToEntropy","mnemonic","wordlist","words","word","dividerIndex","entropyBits","checksumBits","entropyBytes","entropy","entropyToMnemonic","binary","mnemonicToSeedSync","mnemonicBuffer","saltBuffer","pbkdf2Sync","mnemonicToSeed","saltMixin","keylen","reject","pbkdf2","derivedKey","pbkdf2Promise","generateMnemonic","strength","validateMnemonic","setDefaultWordlist","language","getDefaultWordlist","lang","every","_wordlists_2","ctor","superCtor","super_","TempCtor","BN","number","endian","isBN","negative","wordSize","window","parseHex4Bits","parseHexByte","lowerBound","mul","move","dest","src","right","_initNumber","_initArray","_parseHex","_parseBase","w","off","_strip","limbLen","limbPow","total","imuln","_iaddn","_move","_expand","_normSign","for","zeros","groupSizes","groupBases","smallMulTo","lo","ncarry","rword","maxJ","padding","groupBase","modrn","idivn","ret","toBuffer","toArrayLike","ArrayType","reqLength","allocate","_toArrayLikeLE","_toArrayLikeBE","clz32","_countBits","_zeroBits","hi","zeroBits","toTwos","width","inotn","iaddn","fromTwos","testn","notn","ineg","iuor","ior","uor","iuand","iand","uand","iuxor","ixor","uxor","bytesNeeded","bitsLeft","setn","bit","wbit","iadd","isub","sub","comb10MulTo","mid","a0","al0","ah0","a1","al1","ah1","a2","al2","ah2","a3","al3","ah3","a4","al4","ah4","a5","al5","ah5","a6","al6","ah6","a7","al7","ah7","a8","al8","ah8","a9","al9","ah9","b0","bl0","bh0","b1","bl1","bh1","b2","bl2","bh2","b3","bl3","bh3","b4","bl4","bh4","b5","bl5","bh5","b6","bl6","bh6","b7","bl7","bh7","b8","bl8","bh8","b9","bl9","bh9","w0","imul","w1","w2","w3","w4","w5","w6","w7","w8","w9","w10","w11","w12","w13","w14","w15","w16","w17","w18","bigMulTo","hncarry","jumboMulTo","FFTM","mulTo","makeRBT","N","revBin","rb","permute","rbt","rws","iws","rtws","itws","transform","rtwdf","cos","PI","itwdf","sin","rtwdf_","itwdf_","ie","ro","io","rx","guessLen13b","odd","conjugate","normalize13b","ws","convert13b","stub","ph","mulp","_","rwst","iwst","nrws","nrwst","niwst","rmws","mulf","isNegNum","muln","sqr","isqr","toBitArray","iushln","carryMask","newCarry","ishln","iushrn","hint","extended","h","mask","maskedWords","ishrn","shln","ushln","shrn","ushrn","imaskn","maskn","isubn","addn","subn","iabs","_ishlnsubmul","_wordDiv","mode","bhi","diff","qj","positive","divn","umod","divRound","dm","r2","andln","acc","modn","egcd","A","B","C","D","g","yp","xp","im","jm","_invmp","x1","x2","delta","cmpn","invm","bincn","ucmp","gtn","gten","ltn","lten","eqn","Red","toRed","convertTo","_forceRed","fromRed","convertFrom","forceRed","redAdd","redIAdd","redSub","redISub","redShl","shl","redMul","_verify2","redIMul","redSqr","_verify1","redISqr","redSqrt","redInvm","redNeg","redPow","primes","k256","p224","p192","p25519","MPrime","_tmp","K256","P224","P192","P25519","prime","_prime","Mont","imod","rinv","minv","ireduce","rlen","imulK","strip","outLen","mod3","nOne","lpow","inv","wnd","current","currentLen","mont","u","Rand","generate","_rand","getBytes","getByte","msCrypto","asUInt32Array","scrubVec","cryptBlock","M","keySchedule","SUB_MIX","SBOX","nRounds","t0","t1","t2","t3","SUB_MIX0","SUB_MIX1","SUB_MIX2","SUB_MIX3","s0","s1","s2","s3","ksRow","RCON","G","INV_SBOX","INV_SUB_MIX","sx","x4","x8","AES","_reset","blockSize","keySize","keyWords","ksRows","invKeySchedule","ik","ksR","tt","_nRounds","_keySchedule","_invKeySchedule","encryptBlockRaw","encryptBlock","decryptBlock","m1","scrub","aes","Transform","GHASH","incr32","StreamCipher","iv","decrypt","_cipher","ck","_ghash","_finID","ghash","toPad","ivBits","tail","writeUIntBE","calcIv","_prev","_secCache","_decrypt","_alen","_mode","_authTag","_called","_update","chunk","rump","encrypt","_final","final","xorTest","getAuthTag","setAuthTag","setAAD","ciphers","deciphers","modes","createCipher","Cipher","createCipheriv","Cipheriv","createDecipher","Decipher","createDecipheriv","Decipheriv","listCiphers","getCiphers","AuthCipher","MODES","ebtk","Splitter","_last","_autopadding","cache","suite","flush","last","padded","unpad","setAutoPadding","setTo","autoPadding","PADDING","padBuff","ZEROES","block","_multiply","lsbVi","Vi","Zi","abl","bl","pad","encryptStart","encryptByte","byteParam","shiftIn","getBlock","chunkNum","modeModules","ECB","CBC","CFB","CFB8","CFB1","OFB","CTR","GCM","DES","aesModes","desModes","keyLen","ivLen","CipherBase","des","instantiate","EDE","opts","modeName","_des","des3","getr","priv","modulus","prime1","prime2","crt","blinds","blinder","publicExponent","unblinder","blind","blinded","c1","c2","qinv","coefficient","exponent1","m2","exponent2","stream","algorithms","Sign","algorithm","Writable","_hashType","_hash","_tag","_signType","Verify","createSign","createVerify","_write","EC","parseKeys","curves","getKey","algo","hlen","hbits","bits2int","bits2octets","obits","makeKey","kv","makeR","hashType","signType","curve","curveId","keyFromPrivate","toDER","ecSign","params","priv_key","H","dsaSign","checkValue","pub","pubkey","subjectPrivateKey","ecVerify","pub_key","unpacked","montp","dsaVerify","padNum","basex","base58","checksumFn","decodeRaw","payload","checksum","newChecksum","bs58checkBase","ieee754","customInspectSymbol","SlowBuffer","INSPECT_MAX_BYTES","K_MAX_LENGTH","createBuffer","encodingOrOffset","encoding","isEncoding","fromString","ArrayBuffer","isView","arrayView","fromArrayBuffer","fromArrayLike","fromArrayView","SharedArrayBuffer","checked","fromObject","toPrimitive","assertSize","mustMatch","loweredCase","utf8ToBytes","base64ToBytes","slowToString","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","bidirectionalIndexOf","dir","arrayIndexOf","lastIndexOf","indexSize","arrLength","valLength","read","foundIndex","found","hexWrite","remaining","strLen","parsed","utf8Write","blitBuffer","asciiWrite","byteArray","asciiToBytes","base64Write","ucs2Write","units","utf16leToBytes","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","codePoints","MAX_ARGUMENTS_LENGTH","decodeCodePointsArray","kMaxLength","TYPED_ARRAY_SUPPORT","proto","foo","typedArraySupport","poolSize","allocUnsafeSlow","_isBuffer","list","swap16","swap32","swap64","toLocaleString","thisStart","thisEnd","thisCopy","targetCopy","includes","hexSliceLookupTable","checkOffset","ext","checkInt","wrtBigUInt64LE","checkIntBI","wrtBigUInt64BE","checkIEEE754","writeFloat","littleEndian","noAssert","writeDouble","newBuf","subarray","readUintLE","readUIntLE","readUintBE","readUIntBE","readUint8","readUint16LE","readUInt16LE","readUint16BE","readUint32LE","readUInt32LE","readUint32BE","readBigUInt64LE","defineBigIntMethod","validateNumber","boundsError","readBigUInt64BE","readIntLE","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readBigInt64LE","readBigInt64BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUintLE","writeUintBE","writeUint8","writeUint16LE","writeUInt16LE","writeUint16BE","writeUint32LE","writeUInt32LE","writeUint32BE","writeBigUInt64LE","writeBigUInt64BE","writeIntLE","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeBigInt64LE","writeBigInt64BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","copyWithin","E","super","addNumericalSeparator","ERR_OUT_OF_RANGE","checkBounds","ERR_BUFFER_OUT_OF_BOUNDS","received","INVALID_BASE64_RE","leadSurrogate","base64clean","dst","table","i16","BufferBigIntNotDefined","GetIntrinsic","callBind","$indexOf","allowMissing","intrinsic","$apply","$call","$reflectApply","$gOPD","$defineProperty","$max","originalFunction","func","applyBind","StringDecoder","hashMode","_finalOrDigest","__final","_decoder","_encoding","inputEnc","outputEnc","outData","_toString","_transform","_flush","fin","elliptic","ECDH","aliases","secp256k1","secp224r1","prime256v1","prime192v1","ed25519","secp384r1","secp521r1","curveType","ec","formatReturnValue","bn","p256","secp256r1","secp192r1","p384","p521","generateKeys","genKeyPair","getPublicKey","computeSecret","inenc","keyFromPublic","getPublic","getPrivate","getX","getPrivateKey","setPublicKey","_importPublic","setPrivateKey","_priv","_importPrivate","MD5","RIPEMD160","sha","Hash","alg","Legacy","md5","ZEROS","Hmac","blocksize","_alg","ipad","_ipad","opad","_opad","pseudoRandomBytes","prng","algos","algoKeys","hashes","getHashes","dh","DiffieHellmanGroup","createDiffieHellmanGroup","getDiffieHellman","createDiffieHellman","DiffieHellman","createECDH","publicEncrypt","privateEncrypt","publicDecrypt","privateDecrypt","rf","randomFill","randomFillSync","createCredentials","globalScope","Decimal","inexact","quadrant","EXP_LIMIT","MAX_DIGITS","NUMERALS","LN10","DEFAULTS","rounding","toExpNeg","toExpPos","minE","maxE","external","decimalError","invalidArgument","precisionLimitExceeded","cryptoUnavailable","mathpow","isBinary","isHex","isOctal","isDecimal","LN10_PRECISION","PI_PRECISION","toStringTag","digitsToString","indexOfLastWord","getZeroString","checkInt32","checkRoundingDigits","repeating","di","strL","finalise","clampedTo","clamp","Ctor","xdL","ydL","xd","yd","xs","ys","cosine","pr","tinyPow","taylorSeries","cos2x","toLessThanHalfPi","cubeRoot","cbrt","t3plusx","divToInt","greaterThan","greaterThanOrEqualTo","hyperbolicCosine","cosh","cosh2_x","d8","hyperbolicSine","sinh","sinh2_x","d5","d16","d20","hyperbolicTangent","tanh","inverseCosine","acos","halfPi","getPi","asin","inverseHyperbolicCosine","acosh","ln","inverseHyperbolicSine","asinh","inverseHyperbolicTangent","atanh","wpr","xsd","inverseSine","atan","inverseTangent","px","isInt","isPos","lessThan","lessThanOrEqualTo","logarithm","isBase10","denominator","inf","naturalLogarithm","getLn10","getBase10Exponent","naturalExponential","getPrecision","sine","sin2_x","tangent","tan","rL","toBinary","toStringBinary","toDecimalPlaces","toDP","finiteToString","maxD","toHexadecimal","toHex","toNearest","toOctal","toPower","yn","intPow","toSignificantDigits","toSD","truncated","trunc","multiplyInteger","logBase","qd","yd0","isTruncated","roundUp","xdi","isExp","nonFiniteToString","ltgt","guard","numerator","parseDecimal","parseOther","isFloat","isHyperbolic","pi","atan2","useDefaults","defaults","ps","hypot","isDecimalInstance","log2","log10","hasSymbols","toStr","origDefineProperty","hasPropertyDescriptors","supportsDescriptors","object","predicate","defineProperties","predicates","utils","CBCState","_cbcInit","_cbcState","inp","inOff","outOff","superProto","bufferOff","_updateDecrypt","_updateEncrypt","_buffer","_flushBuffer","inputOff","outputOff","_finalEncrypt","_finalDecrypt","_pad","_unpad","DESState","_desState","deriveKeys","shiftTable","kL","kR","pc1","r28shl","pc2","ip","_encrypt","lStart","rStart","keyL","keyR","expand","substitute","rip","EDEState","k1","k2","k3","_edeState","inL","inR","outL","outR","pc2table","sTable","permuteTable","padSplit","group","generatePrime","DH","ENCODINGS","gen","generator","genc","millerRabin","TWENTYFOUR","ELEVEN","TEN","THREE","SEVEN","_pub","primeCache","malleable","setGenerator","__prime","_primeLen","_primeCode","hex","simpleSieve","fermatTest","checkPrime","__gen","_gen","secret","getPrime","front","getGenerator","findPrime","TWO","FIVE","FOUR","_getPrimes","n2","eddsa","getNAF","getJSF","BaseCurve","conf","pointFromJSON","gRed","_wnafT1","_wnafT2","_wnafT3","_wnafT4","_bitLength","adjustCount","redN","_maxwellTrick","BasePoint","precomputed","point","validate","_fixedNafMul","doubles","_getDoubles","naf","step","nafW","repr","jpoint","mixedAdd","points","toP","_wnafMul","nafPoints","_getNAFPoints","dblp","_wnafMulAdd","defW","coeffs","jacobianResult","wndWidth","comb","toJ","jsf","ja","jb","decodePoint","pointFromX","encodeCompressed","getY","precompute","power","beta","_getBeta","_hasDoubles","dbl","EdwardsCurve","twisted","mOneA","dd","oneC","Point","zOne","_mulA","_mulC","rhs","lhs","y2","pointFromY","isInfinity","fromJSON","_extDbl","nx","ny","nt","nz","_projDbl","_extAdd","_projAdd","mulAdd","jmulAdd","zi","eqXToP","short","edwards","MontCurve","i4","a24","aa","bb","diffAdd","da","cb","jumlAdd","ShortCurve","tinv","zeroA","threeA","endo","_getEndomorphism","_endoWnafT1","_endoWnafT2","isRed","JPoint","betas","_getEndoRoots","lambdas","basis","vec","_getEndoBasis","ntinv","prevR","aprxSqrt","y1","len1","_endoSplit","v1","v2","q1","q2","ax","_endoWnafMulAdd","npoints","ncoeffs","pre","endoMul","parse","obj2point","ys1","dyinv","_precompute","zinv","zinv2","ay","pz2","z2","u1","u2","h2","h3","jx","jy","jz","jz4","jyd","jx2","jyd2","jyd4","dny","_zeroDbl","_threeDbl","_dbl","xx","yy","yyyy","yyyy8","c8","gamma","alpha","beta4","beta8","ggamma8","jy2","jxd4","jyd8","trpl","zz","mm","ee","yyu4","kbase","z3","pz3","PresetCurve","defineCurve","sha256","sha384","sha512","HmacDRBG","KeyPair","Signature","nh","keyPair","fromPrivate","fromPublic","drbg","pers","persEnc","hmacStrength","entropyEnc","nonce","ns2","_truncateToN","truncOnly","bkey","ns1","iter","kp","kpX","recoveryParam","canonical","sinv","recoverPubKey","isYOdd","isSecondKey","rInv","getKeyRecoveryParam","Q","Qprime","privEnc","pubEnc","_importDER","Position","place","getLength","initial","octetLen","rmPadding","constructLength","octets","LN2","slen","backHalf","parseBytes","EDDSA","pointClass","encodingLength","keyFromSecret","hashInt","R","Rencoded","encodePoint","s_","pubBytes","S","makeSignature","SG","intFromLE","fromSecret","lastIx","normed","xIsOdd","encodeInt","decodeInt","cachedProperty","_secret","_pubBytes","privBytes","getSecret","_R","_S","_Rencoded","_Sencoded","Sencoded","toBytes","minAssert","minUtils","zero2","m8","m14","m24","computer","firstSource","to","nextSource","keysArray","nextIndex","nextKey","desc","polyfill","ReflectOwnKeys","ReflectApply","receiver","getOwnPropertyNames","NumberIsNaN","EventEmitter","init","once","emitter","errorListener","removeListener","resolver","eventTargetAgnosticAddListener","handler","on","addErrorHandlerIfEventEmitter","_events","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","_getMaxListeners","that","_addListener","prepend","events","existing","warning","newListener","emit","onceWrapper","fired","wrapFn","_onceWrap","wrapped","_listeners","unwrap","evlistener","unwrapListeners","arrayClone","listenerCount","addEventListener","wrapListener","removeEventListener","setMaxListeners","getMaxListeners","doError","er","context","listeners","addListener","prependListener","prependOnceListener","originalListener","spliceOne","removeAllListeners","rawListeners","eventNames","keyBits","used","keyStart","ivStart","isCallable","forEachArray","forEachString","forEachObject","thisArg","ERROR_MESSAGE","funcType","bound","boundLength","boundArgs","Empty","implementation","$SyntaxError","SyntaxError","$Function","$TypeError","getEvalledConstructor","expressionSyntax","throwTypeError","ThrowTypeError","calleeThrows","gOPDthrows","getProto","needsEval","TypedArray","INTRINSICS","AggregateError","Atomics","BigInt64Array","BigUint64Array","DataView","decodeURI","decodeURIComponent","encodeURI","encodeURIComponent","eval","EvalError","Float32Array","Float64Array","FinalizationRegistry","Int8Array","Int16Array","Int32Array","parseFloat","Uint8ClampedArray","Uint16Array","URIError","WeakMap","WeakRef","WeakSet","errorProto","doEval","LEGACY_ALIASES","hasOwn","$concat","$spliceApply","$replace","$strSlice","$exec","exec","rePropName","reEscapeChar","stringToPath","quote","subString","getBaseIntrinsic","alias","intrinsicName","intrinsicBaseName","intrinsicRealName","skipFurtherCaching","isOwn","hasArrayLengthDefineBug","origSymbol","hasSymbolSham","symObj","syms","HashBase","_block","_blockSize","_blockOffset","_length","_finalized","callback","throwIfNotStringOrBuffer","_digest","common","ripemd","hmac","sha1","sha224","ripemd160","BlockHash","pending","pendingTotal","outSize","padLength","_delta8","_delta32","join32","inner","outer","rotl32","sum32","sum32_3","sum32_4","K","Kh","Ah","Bh","Ch","Dh","Eh","T","rh","sh","toHex32","split32","shaCommon","sum32_5","ft_1","sha1_K","SHA1","W","SHA256","SHA224","ch32","maj32","s0_256","s1_256","g0_256","g1_256","sha256_K","T1","T2","SHA512","SHA384","rotr64_hi","rotr64_lo","shr64_hi","shr64_lo","sum64","sum64_hi","sum64_lo","sum64_4_hi","sum64_4_lo","sum64_5_hi","sum64_5_lo","sha512_K","ch64_hi","xh","xl","yh","yl","zh","ch64_lo","zl","maj64_hi","maj64_lo","s0_512_hi","s0_512_lo","s1_512_lo","g0_512_hi","g0_512_lo","g1_512_lo","_prepareBlock","c0_hi","c0_lo","c1_hi","c1_lo","c2_hi","c2_lo","c3_hi","c3_lo","ah","al","bh","ch","cl","dl","eh","el","fh","fl","gh","gl","hh","hl","c4_hi","c4_lo","T1_hi","T1_lo","T2_hi","T2_lo","rotr32","p32","isSurrogatePair","htonl","zero8","predResist","minEntropy","_reseed","reseedInterval","V","nonceEnc","_hmac","kmac","reseed","addEnc","http","url","https","validateParams","protocol","request","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","rt","hasToStringTag","$toString","callBound","isStandardArguments","isLegacyArguments","callee","supportsStandardArguments","badArrayLike","isCallableMarker","fnToStr","reflectApply","constructorRegex","isES6ClassFn","fnStr","tryFunctionObject","isIE68","isDDA","document","all","strClass","GeneratorFunction","isFnRegex","generatorFunc","getGeneratorFunc","getPolyfill","shim","availableTypedArrays","gOPD","globalThis","typedArrays","$slice","toStrTags","typedArray","anyTrue","getter","tryTypedArrays","getNative","hashClear","hashDelete","hashGet","hashHas","hashSet","entries","clear","entry","listCacheClear","listCacheDelete","listCacheGet","listCacheHas","listCacheSet","ListCache","mapCacheClear","mapCacheDelete","mapCacheGet","mapCacheHas","mapCacheSet","MapCache","setCacheAdd","setCacheHas","SetCache","__data__","stackClear","stackDelete","stackGet","stackHas","stackSet","Stack","setter","iteratee","accumulator","resIndex","baseTimes","isArguments","isIndex","isTypedArray","isArr","isArg","isBuff","isType","skipIndexes","baseAssignValue","objValue","baseEach","collection","baseForOwn","createBaseEach","arrayPush","isFlattenable","baseFlatten","isStrict","baseFor","createBaseFor","castPath","toKey","keysFunc","symbolsFunc","getRawTag","symToStringTag","baseGetTag","isObjectLike","baseIsEqualDeep","baseIsEqual","bitmask","customizer","equalArrays","equalByTag","equalObjects","getTag","argsTag","arrayTag","objectTag","equalFunc","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","matchData","noCustomizer","srcValue","COMPARE_PARTIAL_FLAG","isFunction","isMasked","isObject","toSource","reIsHostCtor","funcProto","objectProto","funcToString","reIsNative","isLength","typedArrayTags","baseMatches","baseMatchesProperty","identity","property","isPrototype","nativeKeys","nativeKeysIn","isProto","isArrayLike","baseIsMatch","getMatchData","matchesStrictComparable","hasIn","isKey","isStrictComparable","baseGet","baseSet","paths","assignValue","lastIndex","nested","newValue","arrayMap","isSymbol","symbolProto","symbolToString","baseToString","coreJsData","arrayAggregator","baseAggregator","baseIteratee","initializer","eachFunc","fromRight","iterable","arraySome","cacheHas","isPartial","othLength","arrStacked","othStacked","seen","arrValue","othValue","compared","othIndex","mapToArray","setToArray","symbolValueOf","convert","stacked","getAllKeys","objProps","objLength","objStacked","skipCtor","objCtor","othCtor","freeGlobal","baseGetAllKeys","getSymbols","getSymbolsIn","keysIn","isKeyable","baseIsNative","getValue","getPrototype","overArg","nativeObjectToString","unmasked","arrayFilter","stubArray","nativeGetSymbols","symbol","mapTag","promiseTag","setTag","weakMapTag","dataViewTag","dataViewCtorString","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","ctorString","hasFunc","nativeCreate","spreadableSymbol","isConcatSpreadable","reIsUint","reIsDeepProp","reIsPlainProp","uid","maskSrcKey","IE_PROTO","assocIndexOf","getMapData","memoize","freeExports","nodeType","freeModule","freeProcess","nodeUtil","require","types","binding","freeSelf","root","pairs","LARGE_ARRAY_SIZE","memoizeCapped","defaultValue","createAggregator","groupBy","baseHasIn","hasPath","baseIsArguments","stubFalse","baseIsTypedArray","baseUnary","nodeIsTypedArray","arrayLikeKeys","baseKeys","baseKeysIn","FUNC_ERROR_TEXT","HASH_UNDEFINED","PLACEHOLDER","CLONE_DEEP_FLAG","CLONE_FLAT_FLAG","CLONE_SYMBOLS_FLAG","COMPARE_UNORDERED_FLAG","WRAP_BIND_FLAG","WRAP_BIND_KEY_FLAG","WRAP_CURRY_BOUND_FLAG","WRAP_CURRY_FLAG","WRAP_CURRY_RIGHT_FLAG","WRAP_PARTIAL_FLAG","WRAP_PARTIAL_RIGHT_FLAG","WRAP_ARY_FLAG","WRAP_REARG_FLAG","WRAP_FLIP_FLAG","HOT_COUNT","HOT_SPAN","INFINITY","MAX_INTEGER","NAN","MAX_ARRAY_LENGTH","MAX_ARRAY_INDEX","HALF_MAX_ARRAY_LENGTH","wrapFlags","asyncTag","boolTag","dateTag","domExcTag","errorTag","funcTag","genTag","numberTag","nullTag","proxyTag","regexpTag","stringTag","symbolTag","undefinedTag","arrayBufferTag","float32Tag","float64Tag","int8Tag","int16Tag","int32Tag","uint8Tag","uint8ClampedTag","uint16Tag","uint32Tag","reEmptyStringLeading","reEmptyStringMiddle","reEmptyStringTrailing","reEscapedHtml","reUnescapedHtml","reHasEscapedHtml","reHasUnescapedHtml","reEscape","reEvaluate","reInterpolate","reRegExpChar","reHasRegExpChar","reTrimStart","reWhitespace","reWrapComment","reWrapDetails","reSplitDetails","reAsciiWord","reForbiddenIdentifierChars","reEsTemplate","reFlags","reIsBadHex","reIsBinary","reIsOctal","reLatin","reNoMatch","reUnescapedString","rsAstralRange","rsComboRange","rsComboMarksRange","rsDingbatRange","rsLowerRange","rsUpperRange","rsVarRange","rsBreakRange","rsMathOpRange","rsAstral","rsBreak","rsCombo","rsDigits","rsDingbat","rsLower","rsMisc","rsFitz","rsNonAstral","rsRegional","rsSurrPair","rsUpper","rsZWJ","rsMiscLower","rsMiscUpper","rsOptContrLower","rsOptContrUpper","reOptMod","rsModifier","rsOptVar","rsSeq","rsEmoji","rsSymbol","reApos","reComboMark","reUnicode","reUnicodeWord","reHasUnicode","reHasUnicodeWord","contextProps","templateCounter","cloneableTags","stringEscapes","freeParseFloat","freeParseInt","moduleExports","nodeIsArrayBuffer","isArrayBuffer","nodeIsDate","nodeIsMap","nodeIsRegExp","nodeIsSet","arrayEach","arrayEachRight","arrayEvery","arrayIncludes","baseIndexOf","arrayIncludesWith","comparator","arrayReduce","initAccum","arrayReduceRight","asciiSize","baseProperty","baseFindKey","baseFindIndex","fromIndex","strictIndexOf","baseIsNaN","baseIndexOfWith","baseMean","baseSum","basePropertyOf","baseReduce","baseTrim","trimmedEndIndex","baseValues","charsStartIndex","strSymbols","chrSymbols","charsEndIndex","deburrLetter","escapeHtmlChar","escapeStringChar","chr","hasUnicode","replaceHolders","placeholder","setToPairs","stringSize","unicodeSize","stringToArray","unicodeToArray","asciiToArray","unescapeHtmlChar","runInContext","pick","arrayProto","idCounter","objectCtorString","oldDash","objectCreate","symIterator","ctxClearTimeout","clearTimeout","ctxNow","ctxSetTimeout","setTimeout","nativeCeil","nativeFloor","nativeIsBuffer","nativeIsFinite","nativeJoin","nativeMax","nativeMin","nativeNow","nativeParseInt","nativeRandom","nativeReverse","metaMap","realNames","lodash","LazyWrapper","LodashWrapper","wrapperClone","baseCreate","baseLodash","chainAll","__wrapped__","__actions__","__chain__","__index__","__values__","__dir__","__filtered__","__iteratees__","__takeCount__","__views__","arraySample","baseRandom","arraySampleSize","shuffleSelf","copyArray","baseClamp","arrayShuffle","assignMergeValue","baseAssign","copyObject","baseAt","lower","upper","baseClone","isDeep","isFlat","isFull","initCloneArray","isFunc","cloneBuffer","initCloneObject","copySymbolsIn","baseAssignIn","copySymbols","cloneArrayBuffer","dataView","cloneDataView","cloneTypedArray","regexp","cloneRegExp","initCloneByTag","subValue","getAllKeysIn","baseConformsTo","baseDelay","wait","baseDifference","isCommon","valuesLength","computed","valuesIndex","templateSettings","baseEachRight","baseForOwnRight","baseEvery","baseExtremum","baseFilter","baseForRight","baseFunctions","baseGt","baseHas","baseIntersection","arrays","caches","maxLength","baseInvoke","baseLt","baseMap","baseMerge","srcIndex","mergeFunc","safeGet","isTyped","isArrayLikeObject","isPlainObject","toPlainObject","baseMergeDeep","baseNth","baseOrderBy","iteratees","orders","getIteratee","criteria","comparer","sort","objCriteria","othCriteria","ordersLength","compareAscending","compareMultiple","baseSortBy","basePickBy","basePullAll","basePullAt","indexes","previous","baseUnset","baseRepeat","baseRest","setToString","overRest","baseSample","baseSampleSize","baseSetData","baseSetToString","constant","baseShuffle","baseSlice","baseSome","baseSortedIndex","retHighest","high","baseSortedIndexBy","valIsNaN","valIsNull","valIsSymbol","valIsUndefined","othIsDefined","othIsNull","othIsReflexive","othIsSymbol","setLow","baseSortedUniq","baseToNumber","baseUniq","createSet","seenIndex","baseUpdate","updater","baseWhile","isDrop","baseWrapperValue","actions","action","baseXor","baseZipObject","assignFunc","valsLength","castArrayLikeObject","castFunction","castRest","castSlice","arrayBuffer","valIsDefined","valIsReflexive","composeArgs","partials","holders","isCurried","argsIndex","argsLength","holdersLength","leftIndex","leftLength","rangeLength","isUncurried","composeArgsRight","holdersIndex","rightIndex","rightLength","isNew","createAssigner","assigner","sources","isIterateeCall","createCaseFirst","methodName","trailing","createCompounder","deburr","createCtor","thisBinding","createFind","findIndexFunc","createFlow","flatRest","funcs","prereq","thru","wrapper","getFuncName","funcName","getData","isLaziable","plant","createHybrid","partialsRight","holdersRight","argPos","ary","arity","isAry","isBind","isBindKey","isFlip","getHolder","holdersCount","countHolders","newHolders","createRecurry","oldArray","reorder","createInverter","toIteratee","baseInverter","createMathOperation","createOver","arrayFunc","createPadding","chars","charsLength","createRange","toFinite","baseRange","createRelationalOperation","wrapFunc","isCurry","newData","setData","setWrapToString","createRound","toInteger","pair","noop","createToPairs","baseToPairs","createWrap","srcBitmask","newBitmask","isCombo","mergeData","createCurry","createPartial","createBind","customDefaultsAssignIn","customDefaultsMerge","customOmitClone","flatten","otherFunc","isMaskable","otherArgs","shortOut","reference","insertWrapDetails","updateWrapDetails","getWrapDetails","lastCalled","stamp","differenceBy","differenceWith","findIndex","findLastIndex","head","intersection","mapped","intersectionBy","intersectionWith","pull","pullAll","pullAt","union","unionBy","unionWith","unzip","unzipWith","without","xorBy","xorWith","zip","zipWith","chain","interceptor","wrapperAt","countBy","find","findLast","forEachRight","invokeMap","keyBy","partition","sortBy","before","bindKey","debounce","lastArgs","lastThis","maxWait","timerId","lastCallTime","lastInvokeTime","leading","maxing","invokeFunc","shouldInvoke","timeSinceLastCall","timerExpired","trailingEdge","timeWaiting","remainingWait","debounced","isInvoking","leadingEdge","cancel","defer","delay","memoized","Cache","overArgs","transforms","funcsLength","partialRight","rearg","isNumber","isString","iteratorToArray","toLength","assignIn","assignInWith","assignWith","at","propsIndex","propsLength","defaultsDeep","mergeWith","invert","invertBy","invoke","merge","omit","basePick","pickBy","toPairs","toPairsIn","camelCase","capitalize","upperFirst","kebabCase","lowerCase","lowerFirst","snakeCase","startCase","upperCase","pattern","hasUnicodeWord","unicodeWords","asciiWords","attempt","bindAll","methodNames","flow","flowRight","methodOf","mixin","overEvery","overSome","basePropertyDeep","rangeRight","augend","addend","dividend","multiplier","multiplicand","minuend","subtrahend","after","castArray","cond","conforms","baseConforms","properties","curry","curryRight","drop","dropRight","dropRightWhile","dropWhile","baseFill","flatMap","flatMapDeep","flatMapDepth","flattenDeep","flattenDepth","flip","fromPairs","functions","functionsIn","mapKeys","mapValues","matches","matchesProperty","nthArg","omitBy","orderBy","propertyOf","pullAllBy","pullAllWith","remove","rest","sampleSize","setWith","shuffle","sortedUniq","sortedUniqBy","separator","spread","take","takeRight","takeRightWhile","takeWhile","tap","throttle","toPath","isArrLike","unary","uniq","uniqBy","uniqWith","unset","updateWith","valuesIn","wrap","zipObject","zipObjectDeep","entriesIn","extend","extendWith","cloneDeep","cloneDeepWith","cloneWith","conformsTo","defaultTo","escape","escapeRegExp","findKey","findLastKey","forIn","forInRight","forOwn","forOwnRight","inRange","baseInRange","isBoolean","isElement","isEqual","isEqualWith","isMatch","isMatchWith","isNative","isNil","isNull","isSafeInteger","isUndefined","isWeakMap","isWeakSet","strictLastIndexOf","maxBy","mean","meanBy","minBy","stubObject","stubString","stubTrue","nth","noConflict","strLength","padEnd","padStart","floating","reduceRight","sample","sortedIndex","sortedIndexBy","sortedIndexOf","sortedLastIndex","sortedLastIndexBy","sortedLastIndexOf","startsWith","sumBy","template","settings","isEscaping","isEvaluating","imports","importsKeys","importsValues","interpolate","reDelimiters","evaluate","sourceURL","escapeValue","interpolateValue","esTemplateValue","evaluateValue","variable","toLower","toSafeInteger","toUpper","trimEnd","trimStart","omission","global","newEnd","unescape","uniqueId","each","eachRight","VERSION","isFilter","takeName","dropName","checkIteratee","isTaker","lodashFunc","retUnwrapped","isLazy","useLazy","isHybrid","isUnwrapped","onlyLazy","chainName","isRight","view","getView","iterLength","takeCount","iterIndex","commit","ARRAY16","_a","_b","_c","rotl","fnF","fnG","fnH","fnI","brorand","MillerRabin","_randbelow","min_bytes","_randrange","stop","rone","rn1","getDivisor","keysShim","isArgs","isEnumerable","hasDontEnumBug","hasProtoEnumBug","dontEnums","equalsConstructorPrototype","excludedKeys","$applicationCache","$console","$external","$frame","$frameElement","$frames","$innerHeight","$innerWidth","$onmozfullscreenchange","$onmozfullscreenerror","$outerHeight","$outerWidth","$pageXOffset","$pageYOffset","$parent","$scrollLeft","$scrollTop","$scrollX","$scrollY","$self","$webkitIndexedDB","$webkitStorageInfo","$window","hasAutomationEqualityBug","theKeys","skipProto","skipConstructor","equalsConstructorPrototypeIfNotBuggy","origKeys","originalKeys","keysWorksWithArguments","certificate","RSAPrivateKey","seq","int","RSAPublicKey","PublicKey","AlgorithmIdentifier","bitstr","null_","PrivateKeyInfo","octstr","PrivateKey","EncryptedPrivateKeyInfo","EncryptedPrivateKey","DSAPrivateKey","DSAparam","ECPrivateKey","ECParameters","namedCurve","asn","Time","utcTime","utctime","generalTime","gentime","AttributeTypeValue","SubjectPublicKeyInfo","RelativeDistinguishedName","setof","RDNSequence","seqof","Name","rdnSequence","Validity","Extension","bool","TBSCertificate","X509Certificate","findProc","startRegex","fullRegex","evp","okey","decrypted","cipherText","cipherKey","cipher","match2","aesid","fixProc","compat","passphrase","subtype","ndata","stripped","tbsCertificate","subjectPublicKeyInfo","subjectPublicKey","kde","kdeparams","iters","parameters","ZERO_BUF","nextTick","checkParameters","defaultEncoding","sync","subtle","toBrowser","checks","getNextTick","queueMicrotask","setImmediate","browserPbkdf2","importKey","deriveBits","promise","resolvePromise","browser","prom","checkNative","resp","MAX_ALLOC","sizes","rmd160","saltLen","getDigest","ipad1","ipad2","run","DK","block1","destPos","hLen","U","cachedSetTimeout","cachedClearTimeout","defaultSetTimout","defaultClearTimeout","runTimeout","fun","currentQueue","queue","draining","queueIndex","cleanUpNextTick","drainQueue","timeout","marker","runClearTimeout","Item","title","env","argv","versions","cwd","chdir","umask","i2ops","mgf","withPublic","zBuffer","iHash","maskedSeed","maskedDb","db","dif","oaep","status","pkcs1","paddedMsg","hLen2","dblen","nonZero","qs","sep","maxKeys","kstr","vstr","idx","stringifyPrimitive","ks","MAX_BYTES","generated","oldBrowser","safeBuffer","randombytes","kBufferMaxLength","kMaxUint32","assertOffset","actualFill","ourBuf","uint","objectKeys","Duplex","Readable","allowHalfOpen","readable","onend","_writableState","ended","onEndNT","highWaterMark","getBuffer","_readableState","destroyed","PassThrough","ReadableState","debug","EElistenerCount","Stream","OurUint8Array","debugUtil","debuglog","createReadableStreamAsyncIterator","BufferList","destroyImpl","getHighWaterMark","ERR_STREAM_PUSH_AFTER_EOF","ERR_METHOD_NOT_IMPLEMENTED","ERR_STREAM_UNSHIFT_AFTER_END_EVENT","errorOrDestroy","kProxyEvents","isDuplex","objectMode","readableObjectMode","pipes","pipesCount","flowing","endEmitted","reading","needReadable","emittedReadable","readableListening","resumeScheduled","paused","emitClose","autoDestroy","awaitDrain","readingMore","_read","destroy","_destroy","readableAddChunk","addToFront","skipChunkCheck","emitReadable","emitReadable_","onEofChunk","chunkInvalid","_uint8ArrayToBuffer","addChunk","maybeReadMore","_undestroy","undestroy","isPaused","setEncoding","MAX_HWM","howMuchToRead","computeNewHighWaterMark","maybeReadMore_","updateReadableListening","resume","nReadingNextTick","resume_","fromList","consume","endReadable","endReadableNT","wState","finished","nOrig","doRead","pipe","pipeOpts","endFn","stdout","unpipe","onunpipe","unpipeInfo","hasUnpiped","onclose","onfinish","ondrain","onerror","ondata","cleanedUp","needDrain","pipeOnDrain","pause","event","dests","ev","asyncIterator","_fromList","ERR_MULTIPLE_CALLBACK","ERR_TRANSFORM_ALREADY_TRANSFORMING","ERR_TRANSFORM_WITH_LENGTH_0","afterTransform","ts","_transformState","transforming","writecb","writechunk","rs","needTransform","writeencoding","prefinish","err2","CorkedRequest","finish","corkReq","pendingcb","onCorkedFinish","corkedRequestsFree","WritableState","realHasInstance","internalUtil","deprecate","ERR_STREAM_CANNOT_PIPE","ERR_STREAM_DESTROYED","ERR_STREAM_NULL_VALUES","ERR_STREAM_WRITE_AFTER_END","ERR_UNKNOWN_ENCODING","nop","writableObjectMode","finalCalled","ending","noDecode","decodeStrings","writing","corked","bufferProcessing","onwrite","writelen","onwriteStateUpdate","finishMaybe","errorEmitted","onwriteError","needFinish","bufferedRequest","clearBuffer","afterWrite","lastBufferedRequest","prefinished","bufferedRequestCount","writev","_writev","doWrite","onwriteDrain","holder","allBuffers","isBuf","callFinal","need","rState","hasInstance","writeAfterEnd","validChunk","newChunk","decodeChunk","writeOrBuffer","cork","uncork","setDefaultEncoding","endWritable","_Object$setPrototypeO","kLastResolve","kLastReject","kError","kEnded","kLastPromise","kHandlePromise","kStream","createIterResult","readAndResolve","onReadable","AsyncIteratorPrototype","ReadableStreamAsyncIteratorPrototype","lastPromise","wrapForNext","_this2","_Object$create","enumerableOnly","symbols","hasStrings","_getString","_getBuffer","nb","getOwnPropertyDescriptors","emitErrorAndCloseNT","emitErrorNT","emitCloseNT","readableDestroyed","writableDestroyed","ERR_STREAM_PREMATURE_CLOSE","eos","called","onlegacyfinish","writableEnded","readableEnded","onrequest","req","setHeader","abort","isRequest","streams","popCallback","destroys","closed","destroyer","ERR_INVALID_OPT_VALUE","duplexKey","hwm","highWaterMarkFrom","pipeline","zr","sl","sr","hr","fn1","fn2","fn3","fn4","fn5","ar","br","cr","dr","tl","tr","codec","encodeSeed","decodeSeed","encodeAccountID","decodeAccountID","encodeNodePublic","decodeNodePublic","encodeAccountPublic","decodeAccountPublic","isValidClassicAddress","PREFIX_BYTES","main","MAX_32_BIT_UNSIGNED_INT","encodeXAddress","accountId","theTag","flag","encodeChecked","decodeXAddress","xAddress","decoded","decodeChecked","decodedPrefix","isBufferForTestAddress","tagFromBuffer","classicAddressToXAddress","classicAddress","xAddressToClassicAddress","isValidXAddress","_error","arr1","arr2","ACCOUNT_ID","ED25519_SEED","codecOptions","codecWithXrpAlphabet","_sha256","_alphabet","_codec","baseCodec","_encodeVersioned","expectedLength","base58string","versionTypes","withoutSum","versionLengthGuess","payloadLength","versionBytes","seqEqual","_encodeRaw","concatArgs","_decodeRaw","_verifyCheckSum","encodeAddress","decodeAddress","address","BinaryParser","BinarySerializer","BytesList","sha512Half","transactionID","makeParser","readJSON","parser","readType","coreTypes","STObject","serializeObject","signingFieldsOnly","bytesList","put","isSigningField","toBytesSink","binaryToJSON","signingData","transaction","HashPrefix","transactionSig","signingClaimData","claim","amount","paymentChannelClaim","channel","Hash256","UInt64","multiSigningData","signingAccount","transactionMultiSig","AccountID","Field","TransactionType","LedgerEntryType","Type","TransactionResult","ShaMap","ledgerHashes","quality","TRANSACTION_TYPES","enums","_value","TYPE_WIDTH","Bytes","ordinal","ordinalWidth","sink","BytesLookup","fromParser","readUIntN","TYPES","LEDGER_ENTRY_TYPES","TRANSACTION_RESULTS","fields","info","typeOrdinal","field","fieldHeader","isVariableLengthEncoded","isVLEncoded","isSerialized","associatedType","SerializedType","buildField","FIELDS","uint32","accountStateEntry","innerNode","ledgerHeader","validation","proposal","Sha512Half","static","finish256","serialized","decodeLedgerData","json","encodeForSigning","encodeForSigningClaim","encodeForMultisigning","signer","encodeQuality","decodeQuality","computeHash","itemizer","itemsJson","addItem","transactionItemizer","hashPrefix","serializer","writeLengthEncoded","metaData","entryItemizer","transactionTreeHash","param","accountStateHash","ledgerHash","parent_close_time","close_flags","ledger_index","total_coins","parent_hash","transaction_hash","account_hash","close_time","close_time_resolution","readUInt32","exponent","qualityString","hexBytes","peek","readUInt16","customEnd","readVariableLength","readVariableLengthLength","readFieldOrdinal","readField","typeForField","readFieldValue","sizeHint","readFieldAndValue","bytesArray","bytesArg","writeType","writeBytesList","encodeVariableLength","lenBytes","writeFieldAndValue","isUnlModifyWorkaround","associatedValue","ShaMapNode","ShaMapLeaf","isLeaf","isInner","ShaMapInner","slotBits","branches","setBranch","slot","branch","empty","ZERO_256","leaf","nibble","nibblet","newInner","HEX_REGEX","Hash160","defaultAccountID","classic","MAX_DROPS","MIN_XRP","MAX_IOU_EXPONENT","MIN_IOU_EXPONENT","Amount","defaultAmount","assertXrpIsValid","intBuf","isAmountObject","assertIouIsValid","integerNumberString","exponentByte","currency","Currency","issuer","numBytes","msb","lsb","mantissa","verifyNoDecimal","Blob","XRP_HEX_REGEX","ISO_REGEX","STANDARD_FORMAT_HEX_REGEX","bytesFromRepresentation","isStringRepresentation","isValidRepresentation","iso","isoBytes","isoToBytes","byteBuf","XRP","_iso","isIsoCode","isoCodeFromHex","Hash128","ZERO_128","ZERO_160","Comparable","byteIx","PathSet","STArray","UInt16","Vector256","Hop","account","hopParser","Path","hop","pathParser","isHopObject","ARRAY_END_MARKER","ARRAY_END_MARKER_NAME","OBJECT_END_MARKER","arrayParser","OBJECT_END_MARKER_BYTE","ST_OBJECT","SOURCE_TAG","DEST_TAG","isUnlModify","xAddressDecoded","handled","tagName","handleXAddress","obj1","obj2","checkForDuplicateTags","objectParser","UInt","defaultUInt16","defaultUInt32","defaultUInt64","strBuf","defaultUInt8","latin1Write","hashjs","addU32","first256","first256BN","BigNum","Ed25519","Secp256k1","hexToBytes","bytesToHex","generateSeed","addressCodec","deriveKeypair","derivePrivateKey","rawPrivateKey","select","getAlgorithmFromKey","deriveAddressFromBytes","publicKeyBytes","computePublicKeyHash","keypair","messageToVerify","messageHex","deriveAddress","deriveNodeAddress","generatorBytes","accountPublicFromPublicGenerator","deriveScalar","discrim","order","hasher","validator","privateGen","publicGen","accountIndex","publicGenBytes","rootPubPoint","scalar","byteValue","hash256","copyProps","SafeBuffer","safer","Safer","kStringMaxLength","MAX_LENGTH","MAX_STRING_LENGTH","finalSize","_finalSize","accum","assigned","lowBits","highBits","Algorithm","Sha","_w","rotl30","ft","Sha1","rotl5","Sha256","Sha224","_f","_g","_h","maj","sigma0","sigma1","gamma0","Sha384","_ah","_bh","_ch","_dh","_eh","_fh","_gh","_hh","_al","_bl","_cl","_dl","_el","_fl","_gl","_hl","writeInt64BE","Sha512","Gamma0","Gamma0l","Gamma1","Gamma1l","getCarry","gamma0l","gamma1","gamma1l","Wi7h","Wi7l","Wi16h","Wi16l","Wil","Wih","majh","majl","sigma0h","sigma0l","sigma1h","sigma1l","Kih","Kil","chh","chl","t1l","t1h","t2l","t2h","EE","_isStdio","didOnEnd","cleanup","ClientRequest","response","statusCodes","defaultProtocol","location","host","hostname","port","headers","IncomingMessage","Agent","defaultMaxSockets","globalAgent","STATUS_CODES","METHODS","xhr","getXHR","XMLHttpRequest","open","XDomainRequest","checkTypeSupport","responseType","fetch","ReadableStream","writableStream","WritableStream","abortController","AbortController","arraybuffer","msstream","mozchunkedarraybuffer","overrideMimeType","capability","rStates","readyStates","preferBinary","_opts","_body","_headers","auth","useFetch","decideMode","_fetchTimer","_socketTimeout","_socketTimer","_onFinish","lowerName","unsafeHeaders","getHeader","removeHeader","_destroyed","headersObj","headersList","keyName","signal","controller","_fetchAbortController","requestTimeout","credentials","withCredentials","_fetchResponse","_resetTimers","_connect","_xhr","ontimeout","setRequestHeader","_response","onreadystatechange","readyState","LOADING","DONE","_onXHRProgress","onprogress","send","statusValid","flushHeaders","setNoDelay","setSocketKeepAlive","UNSENT","OPENED","HEADERS_RECEIVED","resetTimers","rawHeaders","trailers","rawTrailers","statusCode","statusMessage","statusText","_resumeFetch","close","pipeTo","reader","getReader","_pos","responseURL","getAllResponseHeaders","_charset","mimeType","charsetMatch","responseText","MSStreamReader","onload","readAsArrayBuffer","nenc","retried","_normalizeEncoding","normalizeEncoding","utf16Text","utf16End","fillLast","utf8FillLast","base64Text","base64End","simpleWrite","simpleEnd","lastNeed","lastTotal","lastChar","utf8CheckByte","byte","utf8CheckExtraBytes","utf8CheckIncomplete","deterministicGenerateK","ZERO32","EC_GROUP_ORDER","EC_P","nDiv2","THROW_BAD_PRIVATE","THROW_BAD_POINT","THROW_BAD_TWEAK","THROW_BAD_HASH","THROW_BAD_EXTRA_DATA","isScalar","isOrderScalar","decodeFrom","__isPointCompressed","assumeCompression","fromBuffer","getEncoded","__sign","addData","kI","isPointCompressed","pointAdd","pA","pB","__compressed","pp","tweak","qq","uu","pointCompress","pointMultiply","dt","privateSub","isSignature","sInv","ONE1","ZERO1","checkSig","extraEntropy","native","getTypeName","getValueTypeName","Nil","tfJSON","tfErrorString","valueTypeName","valueJson","TfTypeError","__type","__value","__valueTypeName","TfPropertyTypeError","description","tfPropertyErrorString","__label","__property","tfCustomError","tfSubError","NATIVE","ERRORS","Hex","_LengthN","Length","_ArrayN","_BufferN","_HexN","_StringN","INT53_MAX","ArrayN","Finite","HexN","Int8","Int16","Int32","Int53","Range","_range","StringN","UInt53","typeName","arrayOf","_arrayOf","minLength","maybe","_maybe","propertyType","propertyKeyType","_map","propertyName","propertyValue","uncompiled","typePropertyName","_object","anyOf","_anyOf","allOf","_allOf","quacksLike","_quacksLike","tuple","_tuple","surrogate","EXTRA","Null","punycode","maxInt","tMin","tMax","skew","damp","initialBias","initialN","delimiter","regexPunycode","regexNonASCII","regexSeparators","baseMinusTMin","stringFromCharCode","mapDomain","ucs2decode","extra","ucs2encode","digitToBasic","adapt","numPoints","firstTime","basic","oldi","baseMinusT","bias","handledCPCount","basicLength","currentValue","handledCPCountPlusOne","qMinusT","Url","slashes","query","pathname","href","urlParse","resolveObject","protocolPattern","portPattern","simplePathPattern","unwise","autoEscape","nonHostChars","hostEndingChars","hostnamePartPattern","hostnamePartStart","unsafeProtocol","hostlessProtocol","slashedProtocol","querystring","parseQueryString","slashesDenoteHost","queryIndex","splitter","uSplit","simplePath","lowerProto","atSign","hostEnd","hec","parseHost","ipv6Hostname","hostparts","newpart","validParts","notHost","toASCII","ae","esc","qm","rel","tkeys","tk","tkey","rkeys","rk","rkey","relPath","isSourceAbs","isRelAbs","mustEndAbs","removeAllDots","srcPath","psychotic","isNullOrUndefined","authInHost","hasTrailingSlash","up","isAbsolute","localStorage","trace","isArgumentsObject","isGeneratorFunction","whichTypedArray","BigIntSupported","SymbolSupported","ObjectToString","numberValue","stringValue","booleanValue","bigIntValue","symbolValue","checkBoxedPrimitive","prototypeValueOf","isMapToString","isSetToString","isWeakMapToString","isWeakSetToString","isArrayBufferToString","working","isDataViewToString","isDataView","isUint8Array","isUint8ClampedArray","isUint16Array","isUint32Array","isInt8Array","isInt16Array","isInt32Array","isBigInt64Array","isBigUint64Array","SharedArrayBufferCopy","isSharedArrayBufferToString","isSharedArrayBuffer","isAsyncFunction","isMapIterator","isSetIterator","isGeneratorObject","isWebAssemblyCompiledModule","descriptors","formatRegExp","objects","noDeprecation","throwDeprecation","traceDeprecation","debugs","debugEnvRegex","NODE_DEBUG","debugEnv","stylize","stylizeNoColor","colors","_extend","stylizeWithColor","formatValue","styleType","style","styles","simple","formatPrimitive","visibleKeys","arrayToHash","formatError","braces","toUTCString","formatProperty","formatArray","reduceToSingleString","line","pid","isPrimitive","months","getHours","getMinutes","getSeconds","getDate","getMonth","origin","kCustomPromisifiedSymbol","callbackifyOnRejected","newReason","promisify","original","promiseResolve","promiseReject","callbackify","callbackified","maybeCb","rej","foundName","encodeRaw","ECDSA","FaucetNetwork","FaucetNetworkPaths","Testnet","Devnet","AMMDevnet","HooksV2Testnet","client","connectionUrl","XRPLFaucetError","INTERVAL_SECONDS","MAX_ATTEMPTS","getUpdatedBalance","originalBalance","attempts","interval","setInterval","clearInterval","newBalance","getXrpBalance","wallet","isConnected","RippledError","walletToFund","postBody","TextEncoder","destination","xrpAmount","startingBalance","httpOptions","finalHostname","getFaucetHost","getDefaultFaucetPath","getHTTPOptions","faucetHost","faucetPath","chunks","balance","processSuccessfulResponse","contentType","onEnd","returnPromise","DEFAULT_ALGORITHM","hexFromBuffer","Wallet","masterAddress","ensureClassicAddress","deriveWallet","mnemonicEncoding","fromRFC1751Mnemonic","ValidationError","derivationPath","rfc1751MnemonicToKey","encodeAlgorithm","encodedSeed","multisign","multisignAddress","tx","TxnSignature","Signers","removeTrailingZeros","txToSignAndEncode","SigningPubKey","Account","computeSignature","Signer","checkTxSerialization","tx_blob","hashSignedTx","verifyTransaction","signedTransaction","getXAddress","isTestnet","txCopy","Memos","memoCopy","Memo","MemoData","MemoType","MemoFormat","URI","isIssuedCurrency","decodedAmount","decodedCurrency","txCurrency","XrplError","isoToHex","signAs","rfc1751WordList","BINARY","keyToBinary","extract","subKey","getSubKey","sublist","cc","swap128","reversedBytes","keyToRFC1751Mnemonic","hex_key","skbin","parity","compareSigners","addressToBigNumber","getDecodedTransaction","txOrBlob","transactions","decodedTransactions","exampleTransaction","validateTransactionEquivalence","sortedSigners","getTransactionWithAllSigners","authorizeChannel","channelId","verifySignature","decodedTx","BroadcastClient","Client","servers","clients","server","getMethodNames","race","connect","disconnect","errorCode","errorMessage","firstClient","promisesAwaitingConnection","resolveAllAwaiting","rejectAllAwaiting","awaitConnection","factor","numAttempts","ms","duration","reset","nextId","promisesAwaitingResponse","timer","deletePromise","rejectAll","_promise","createRequest","newId","newRequest","TimeoutError","unref","newPromise","handleResponse","ResponseFormatError","errorResponse","error_message","WSWrapper","_protocols","_websocketOptions","WebSocket","closeEvent","onopen","onmessage","CONNECTING","OPEN","CLOSING","CLOSED","INTENTIONAL_DISCONNECT_CODE","Connection","reconnectTimeoutID","heartbeatIntervalID","retryConnectionBackoff","SECONDS_PER_MINUTE","requestManager","connectionManager","TIMEOUT","connectionTimeout","CONNECTION_TIMEOUT","shouldBeConnected","ConnectionError","connectionTimeoutID","onConnectionFailed","agent","proxy","parsedURL","URL","parsedProxyURL","proxyOptions","secureEndpoint","secureProxy","proxyAuthorization","ca","trustedCertificates","cert","username","HttpsProxyAgent","getAgent","authorization","Authorization","optionsOverrides","websocketOptions","websocket","createWebSocket","onceOpen","clearHeartbeatInterval","reconnect","NotConnectedError","responsePromise","DisconnectedError","websocketSendAsync","getUrl","onMessage","TextDecoder","internalErrorCode","intentionalDisconnect","startHeartbeatInterval","retryTimeout","heartbeat","command","errorOrCode","autofill","submit","submitAndWait","prepareTransaction","getBalances","getOrderbook","getLedgerIndex","fundWallet","feeCushion","maxFeeXRP","connection","finalCode","ledger","handleStreamPartialPayment","manifest","consensus","handlePartialPayment","requestNextPage","NotFoundError","nextPageRequest","eventName","requestAll","collect","collectKey","getCollectKeyFromCommand","countTo","lastBatchLength","results","countRemaining","repeatProps","singleResponse","singleResult","collectedData","isPartialPayment","metadata","meta","Flags","isFlagEnabled","PaymentFlags","tfPartialPayment","delivered","delivered_amount","amt1","amt2","aValue","bValue","amountsEqual","txHasPartialPayment","tx_json","txEntryHasPartialPayment","accountTxHasPartialPayment","hasPartialPayment","warnings","UnexpectedError","RippledNotInitializedError","default","setTransactionFlagsToNumber","parseAccountRootFlags","AccountRootFlags","OfferFlags","RippleStateFlags","SignerListFlags","validateBaseTransaction","NFTokenBrokerFee","parseAmountValue","NFTokenSellOffer","NFTokenBuyOffer","validateNFTokenBrokerFee","NFTokenID","NFTokenOffers","NFTokenCreateOfferFlags","Owner","Destination","isAmount","tfSellNFToken","validateNFTokenSellOfferCases","validateNFTokenBuyOfferCases","NFTokenMintFlags","Issuer","NFTokenTaxon","DestinationTag","AccountSetAsfFlags","AccountSetTfFlags","NFTokenMinter","ClearFlag","Domain","EmailHash","MessageKey","SetFlag","TransferRate","TickSize","CheckID","DeliverMin","SendMax","Expiration","InvoiceID","MEMO_SIZE","isMemo","validData","validFormat","validType","onlyHasFields","SIGNER_SIZE","isSigner","signerWrapper","ISSUED_CURRENCY_SIZE","Fee","Sequence","AccountTxnID","LastLedgerSequence","signers","SourceTag","TicketSequence","Authorize","Unauthorize","OfferSequence","CancelAfter","FinishAfter","Condition","Fulfillment","OfferCreateFlags","PaymentChannelClaimFlags","TrustSetFlags","TakerGets","TakerPays","isPathStep","pathStep","isPath","Paths","isPaths","checkPartialPayment","Channel","Balance","SettleDelay","RegularKey","HEX_WALLET_LOCATOR_REGEX","SignerQuorum","SignerEntries","signerEntry","WalletLocator","SignerEntry","TicketCount","validateAccountDelete","validateAccountSet","validateCheckCancel","validateCheckCash","validateCheckCreate","validateDepositPreauth","validateEscrowCancel","validateEscrowCreate","validateEscrowFinish","validateNFTokenAcceptOffer","validateNFTokenBurn","validateNFTokenCancelOffer","validateNFTokenCreateOffer","validateNFTokenMint","validateOfferCancel","validateOfferCreate","validatePayment","validatePaymentChannelClaim","validatePaymentChannelCreate","validatePaymentChannelFund","validateSetRegularKey","validateSignerListSet","validateTicketCreate","validateTrustSet","LimitAmount","QualityIn","QualityOut","reduceFlags","flagEnum","resultFlags","flagsInterface","convertOfferCreateFlagsToNumber","convertPaymentChannelClaimFlagsToNumber","convertPaymentTransactionFlagsToNumber","convertTrustSetFlagsToNumber","checkFlag","validateAccountAddress","accountField","tagField","classicAccount","getClassicAccountAndTag","expectedTag","convertToClassicAddress","fieldName","scaleValue","signersCount","setValidAddresses","promises","account_data","setNextValidSequenceNumber","netFeeXRP","netFeeDrops","xrpToDrops","baseFee","fulfillmentBytesSize","fee","validated_ledger","reserve_inc","fetchAccountDeleteFee","maxFeeDrops","totalFee","calculateFeePerTransactionType","ledgerSequence","setLatestValidatedLedgerSequence","deletion_blockers_only","account_objects","checkAccountDeleteBlockers","xrpRequest","ledger_hash","dropsToXrp","balances","xrpPromise","peer","linesRequest","linesPromise","xrpBalance","linesResponses","accountLinesBalance","trustline","cushion","serverInfo","base_fee_xrp","baseFeeXrp","load_factor","sortOffers","offers","offerA","offerB","qualityA","qualityB","getOrderbookOptionsSet","takerPays","takerGets","taker","taker_pays","taker_gets","directOfferResults","reverseOfferResults","directOfferResult","reverseOfferResult","buy","sell","lsfSell","LEDGER_CLOSE_TIME","submitRequest","failHard","isSigned","fail_hard","waitForFinalTransactionOutcome","txHash","lastLedger","submissionResult","sleep","latestLedger","txResponse","validated","getSignedTx","signedTx","getLastLedgerSequence","engine_result","payment","destAccount","destAccountMemo","convertStringToHex","newMemos","newPayment","deriveXAddress","normalizeNode","affectedNode","diffType","NodeType","LedgerIndex","NewFields","FinalFields","PreviousFields","computeBalanceChange","flipTrustlinePerspective","balanceChange","negatedBalance","quantities","AffectedNodes","normalizeNodes","xrpQuantity","getXRPQuantity","trustlineQuantity","LowLimit","HighLimit","getTrustlineQuantity","balanceChanges","grouped","items","groupByAccount","affectedNodes","isCreatedNode","CreatedNode","isModifiedNode","ModifiedNode","NFTokens","previousTokenIDSet","token","NFToken","nftokenID","HEX_ZERO","InnerNode","leaves","INNER","INNER_NODE","existingNode","getNode","newInnerNode","setNode","LeafNode","ACCOUNT_STATE","leafPrefix","LEAF_NODE","TRANSACTION_NO_METADATA","txIDPrefix","TRANSACTION_ID","TRANSACTION_METADATA","txNodePrefix","TRANSACTION_NODE","HEX","intToHex","integer","addLengthPrefix","txBlob","txObject","hashLedgerHeader","LEDGER","integerString","hashTxTree","shamap","txJSON","txBlobHex","metaHex","hashStateTree","ledgerEntry","computeTransactionHash","computeTreeHashes","transactionHash","transactionHashInHeader","computedHashOfTransactions","computeStateHash","accountState","stateHash","subhashes","hashLedger","addressToHex","ledgerSpaceHex","TRANSACTION_SIGN","sequence","hexPrefix","offer","hexSequence","address1","address2","address1Hex","address2Hex","lowAddressHex","highAddressHex","currencyToHex","BYTE_LENGTH","dstAddress","dirNode","generatorMap","rippleState","ownerDir","bookDir","contract","skipList","escrow","amendment","feeSettings","ticket","signerList","paychan","depositPreauth","createCrossChainPayment","getBalanceChanges","getNFTokenID","parseNFTokenID","percentToTransferRate","decimalToTransferRate","transferRateToDecimal","percentToQuality","decimalToQuality","qualityToDecimal","signPaymentChannelClaim","convertHexToString","rippleTimeToISOTime","isoTimeToRippleTime","rippleTimeToUnixTime","unixTimeToRippleTime","verifyPaymentChannelClaim","isValidSecret","_err","rbc","encodeForMultiSigning","isValidAddress","hasNextPage","hashTx","hashAccountRoot","hashSignerListId","hashOfferId","hashTrustline","hashEscrow","hashPaymentChannel","scrambledTaxon","taxon","tokenSeq","TransferFee","Taxon","BASE_TEN","ONE_BILLION","TWO_BILLION","percentToDecimal","percent","rate","billionths","RIPPLE_EPOCH_DIFF","rpepoch","timestamp","rippleTime","toISOString","iso8601","DROPS_PER_XRP","SANITY_CHECK","dropsToConvert","drops","xrpToConvert","xrp","components","possibleNames","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","loaded","__webpack_modules__","nmd","__webpack_exports__"],"sourceRoot":""}
|
