{"version":3,"file":"static/js/7021.89ace8c9.js","mappings":"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","sources":["../../../node_modules/.pnpm/@astrox+sdk-web@0.1.41_@peculiar+webcrypto@1.5.0_@types+node@13.13.52_babel-plugin-macros@3.1_oy7bw253unceh2qzy65cinfy44/node_modules/@astrox/sdk-web/build/connections/baseConnection.js","../../../node_modules/.pnpm/@astrox+sdk-web@0.1.41_@peculiar+webcrypto@1.5.0_@types+node@13.13.52_babel-plugin-macros@3.1_oy7bw253unceh2qzy65cinfy44/node_modules/@astrox/sdk-web/build/canisters/ledger.idl.js","../../../node_modules/.pnpm/@astrox+sdk-web@0.1.41_@peculiar+webcrypto@1.5.0_@types+node@13.13.52_babel-plugin-macros@3.1_oy7bw253unceh2qzy65cinfy44/node_modules/@astrox/sdk-web/build/utils/constants.js","../../../node_modules/.pnpm/@astrox+sdk-web@0.1.41_@peculiar+webcrypto@1.5.0_@types+node@13.13.52_babel-plugin-macros@3.1_oy7bw253unceh2qzy65cinfy44/node_modules/@astrox/sdk-web/build/connections/ledgerConnection.js","../../../node_modules/.pnpm/@astrox+sdk-web@0.1.41_@peculiar+webcrypto@1.5.0_@types+node@13.13.52_babel-plugin-macros@3.1_oy7bw253unceh2qzy65cinfy44/node_modules/@astrox/sdk-web/build/utils/common/types.js","../../../node_modules/.pnpm/@astrox+sdk-web@0.1.41_@peculiar+webcrypto@1.5.0_@types+node@13.13.52_babel-plugin-macros@3.1_oy7bw253unceh2qzy65cinfy44/node_modules/@astrox/sdk-web/build/utils/converter.js","../../../node_modules/.pnpm/@astrox+sdk-web@0.1.41_@peculiar+webcrypto@1.5.0_@types+node@13.13.52_babel-plugin-macros@3.1_oy7bw253unceh2qzy65cinfy44/node_modules/@astrox/sdk-web/build/types/index.js","../../../node_modules/.pnpm/@astrox+sdk-web@0.1.41_@peculiar+webcrypto@1.5.0_@types+node@13.13.52_babel-plugin-macros@3.1_oy7bw253unceh2qzy65cinfy44/node_modules/@astrox/sdk-web/build/ic/icStorage.js","../../../node_modules/.pnpm/@astrox+sdk-web@0.1.41_@peculiar+webcrypto@1.5.0_@types+node@13.13.52_babel-plugin-macros@3.1_oy7bw253unceh2qzy65cinfy44/node_modules/@astrox/sdk-web/build/ic/icAuthClient.js","../../../node_modules/.pnpm/@astrox+sdk-web@0.1.41_@peculiar+webcrypto@1.5.0_@types+node@13.13.52_babel-plugin-macros@3.1_oy7bw253unceh2qzy65cinfy44/node_modules/@astrox/sdk-web/build/ic/icWindow.js","../../../node_modules/.pnpm/@astrox+sdk-web@0.1.41_@peculiar+webcrypto@1.5.0_@types+node@13.13.52_babel-plugin-macros@3.1_oy7bw253unceh2qzy65cinfy44/node_modules/@astrox/sdk-web/build/ic/icConnect.js","../../../node_modules/.pnpm/@astrox+sdk-webview@0.1.41_@peculiar+webcrypto@1.5.0_babel-plugin-macros@3.1.0_node-notifier@_xa2wywmqqx2tfnjpv37fmwtx5a/node_modules/@astrox/sdk-webview/build/util.js","../../../node_modules/.pnpm/@astrox+sdk-webview@0.1.41_@peculiar+webcrypto@1.5.0_babel-plugin-macros@3.1.0_node-notifier@_xa2wywmqqx2tfnjpv37fmwtx5a/node_modules/@astrox/sdk-webview/build/storage.js","../../../node_modules/.pnpm/@astrox+sdk-webview-bridge@0.1.41_@types+node@18.19.64_babel-plugin-macros@3.1.0_node-notifie_gfavk4zdsr4wh3pvyqbryoxd6m/node_modules/@astrox/sdk-webview-bridge/build/buffer.js","../../../node_modules/.pnpm/@astrox+sdk-webview-bridge@0.1.41_@types+node@18.19.64_babel-plugin-macros@3.1.0_node-notifie_gfavk4zdsr4wh3pvyqbryoxd6m/node_modules/@astrox/sdk-webview-bridge/build/cbor.js","../../../node_modules/.pnpm/@astrox+sdk-webview-bridge@0.1.41_@types+node@18.19.64_babel-plugin-macros@3.1.0_node-notifie_gfavk4zdsr4wh3pvyqbryoxd6m/node_modules/@astrox/sdk-webview-bridge/build/util.js","../../../node_modules/.pnpm/@astrox+sdk-webview-bridge@0.1.41_@types+node@18.19.64_babel-plugin-macros@3.1.0_node-notifie_gfavk4zdsr4wh3pvyqbryoxd6m/node_modules/@astrox/sdk-webview-bridge/build/adapter.js","../../../node_modules/.pnpm/@astrox+sdk-webview-bridge@0.1.41_@types+node@18.19.64_babel-plugin-macros@3.1.0_node-notifie_gfavk4zdsr4wh3pvyqbryoxd6m/node_modules/@astrox/sdk-webview-bridge/build/bridge.js","../../../node_modules/.pnpm/@astrox+sdk-webview-bridge@0.1.41_@types+node@18.19.64_babel-plugin-macros@3.1.0_node-notifie_gfavk4zdsr4wh3pvyqbryoxd6m/node_modules/@astrox/sdk-webview-bridge/build/method.js","../../../node_modules/.pnpm/@astrox+sdk-webview@0.1.41_@peculiar+webcrypto@1.5.0_babel-plugin-macros@3.1.0_node-notifier@_xa2wywmqqx2tfnjpv37fmwtx5a/node_modules/@astrox/sdk-webview/build/types.js","../../../node_modules/.pnpm/@astrox+sdk-webview@0.1.41_@peculiar+webcrypto@1.5.0_babel-plugin-macros@3.1.0_node-notifier@_xa2wywmqqx2tfnjpv37fmwtx5a/node_modules/@astrox/sdk-webview/build/methods.js","../../../node_modules/.pnpm/@astrox+sdk-webview@0.1.41_@peculiar+webcrypto@1.5.0_babel-plugin-macros@3.1.0_node-notifier@_xa2wywmqqx2tfnjpv37fmwtx5a/node_modules/@astrox/sdk-webview/build/identity.js","../../../node_modules/.pnpm/@astrox+sdk-webview@0.1.41_@peculiar+webcrypto@1.5.0_babel-plugin-macros@3.1.0_node-notifier@_xa2wywmqqx2tfnjpv37fmwtx5a/node_modules/@astrox/sdk-webview/build/errors.js","../../../node_modules/.pnpm/@astrox+sdk-webview@0.1.41_@peculiar+webcrypto@1.5.0_babel-plugin-macros@3.1.0_node-notifier@_xa2wywmqqx2tfnjpv37fmwtx5a/node_modules/@astrox/sdk-webview/build/cbor.js","../../../node_modules/.pnpm/@astrox+sdk-webview@0.1.41_@peculiar+webcrypto@1.5.0_babel-plugin-macros@3.1.0_node-notifier@_xa2wywmqqx2tfnjpv37fmwtx5a/node_modules/@astrox/sdk-webview/build/handler.js","../../../node_modules/.pnpm/aria-hidden@1.2.4/node_modules/aria-hidden/dist/es2015/index.js","../../../node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js","../../../node_modules/.pnpm/bech32@1.1.4/node_modules/bech32/index.js","../../../node_modules/.pnpm/bignumber.js@9.1.2/node_modules/bignumber.js/bignumber.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/createClass.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/extends.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/inheritsLoose.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/defineProperty.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/objectSpread2.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/toConsumableArray.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/iterableToArray.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/typeof.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/toPropertyKey.js","../../../node_modules/.pnpm/@babel+runtime@7.25.0/node_modules/@babel/runtime/helpers/esm/toPrimitive.js","../../../node_modules/.pnpm/@adraffy+ens-normalize@1.11.0/node_modules/@adraffy/ens-normalize/dist/index.mjs","../../../node_modules/.pnpm/abitype@0.7.1_typescript@4.9.5_zod@3.23.8/node_modules/abitype/dist/chunk-WP7KDV47.mjs","../../../node_modules/.pnpm/abitype@0.7.1_typescript@4.9.5_zod@3.23.8/node_modules/abitype/dist/chunk-NHABU752.mjs","../../../node_modules/.pnpm/abitype@0.7.1_typescript@4.9.5_zod@3.23.8/node_modules/abitype/dist/index.mjs","../../../node_modules/.pnpm/big.js@6.2.2/node_modules/big.js/big.mjs","../../../node_modules/.pnpm/bignumber.js@9.1.2/node_modules/bignumber.js/bignumber.mjs"],"sourcesContent":["import { Actor, HttpAgent } from \"@dfinity/agent\";\nimport { Delegation, DelegationChain, DelegationIdentity, Ed25519KeyIdentity } from \"@dfinity/identity\";\nimport { Principal } from \"@dfinity/principal\";\nexport function createConnection(identity, delegationIdentity, canisterId, interfaceFactory, actor, agent) {\n    return new BaseConnection(identity, delegationIdentity, canisterId, interfaceFactory, actor, agent);\n}\nexport const requestDelegation = async (identity, { canisterId, date })=>{\n    const sessionKey = Ed25519KeyIdentity.generate();\n    const chain = await DelegationChain.create(identity, sessionKey.getPublicKey(), date || new Date(Date.parse('2100-01-01')), {\n        targets: canisterId != undefined ? [\n            Principal.fromText(canisterId)\n        ] : undefined\n    });\n    return DelegationIdentity.fromDelegation(sessionKey, chain);\n};\nexport async function _createActor(interfaceFactory, canisterId, identity, host) {\n    const agent = new HttpAgent({\n        identity,\n        host\n    });\n    if (process && (process.env?.NODE_ENV === 'development' || process.env?.II_ENV === 'development')) {\n        await agent.fetchRootKey();\n    }\n    const actor = Actor.createActor(interfaceFactory, {\n        agent,\n        canisterId\n    });\n    return {\n        actor,\n        agent\n    };\n}\nexport class BaseConnection {\n    identity;\n    delegationIdentity;\n    canisterId;\n    interfaceFactory;\n    actor;\n    agent;\n    constructor(identity, delegationIdentity, canisterId, interfaceFactory, actor, agent){\n        this.identity = identity;\n        this.delegationIdentity = delegationIdentity;\n        this.canisterId = canisterId;\n        this.interfaceFactory = interfaceFactory;\n        this.actor = actor;\n        this.agent = agent;\n    }\n    async getActor() {\n        throw new Error('Method not implemented.');\n    }\n    async _getActor(canisterId, interfaceFactory, date) {\n        if (this.delegationIdentity) {\n            for (const { delegation } of this.delegationIdentity.getDelegation().delegations){\n                if (+new Date(Number(delegation.expiration / BigInt(1000000))) <= +Date.now()) {\n                    this.actor = undefined;\n                    break;\n                }\n            }\n        }\n        if (this.actor === undefined) {\n            this.delegationIdentity = await requestDelegation(this.identity, {\n                canisterId: this.canisterId ?? canisterId,\n                date: date ?? undefined\n            });\n            this.actor = (await _createActor(interfaceFactory, this.canisterId ?? canisterId, this.delegationIdentity)).actor;\n        }\n        return this.actor;\n    }\n}\nexport async function handleDelegation(message, key) {\n    const delegations = message.delegations.map((signedDelegation)=>{\n        return {\n            delegation: new Delegation(signedDelegation.delegation.pubkey, signedDelegation.delegation.expiration, signedDelegation.delegation.targets),\n            signature: signedDelegation.signature.buffer\n        };\n    });\n    const delegationChain = DelegationChain.fromDelegations(delegations, message.userPublicKey.buffer);\n    return {\n        delegationChain,\n        delegationIdentity: DelegationIdentity.fromDelegation(key, delegationChain)\n    };\n}\nexport const executeWithLogging = async (func)=>{\n    try {\n        return await func();\n    } catch (e) {\n        console.log(e);\n        throw e;\n    }\n};\n","export default (({ IDL })=>{\n    const AccountIdentifier = IDL.Text;\n    const Duration = IDL.Record({\n        secs: IDL.Nat64,\n        nanos: IDL.Nat32\n    });\n    const ArchiveOptions = IDL.Record({\n        max_message_size_bytes: IDL.Opt(IDL.Nat32),\n        node_max_memory_size_bytes: IDL.Opt(IDL.Nat32),\n        controller_id: IDL.Principal\n    });\n    const ICPTs = IDL.Record({\n        e8s: IDL.Nat64\n    });\n    const LedgerCanisterInitPayload = IDL.Record({\n        send_whitelist: IDL.Vec(IDL.Tuple(IDL.Principal)),\n        minting_account: AccountIdentifier,\n        transaction_window: IDL.Opt(Duration),\n        max_message_size_bytes: IDL.Opt(IDL.Nat32),\n        archive_options: IDL.Opt(ArchiveOptions),\n        initial_values: IDL.Vec(IDL.Tuple(AccountIdentifier, ICPTs))\n    });\n    const AccountBalanceArgs = IDL.Record({\n        account: AccountIdentifier\n    });\n    const CanisterId = IDL.Principal;\n    const HeaderField = IDL.Tuple(IDL.Text, IDL.Text);\n    const HttpRequest = IDL.Record({\n        url: IDL.Text,\n        method: IDL.Text,\n        body: IDL.Vec(IDL.Nat8),\n        headers: IDL.Vec(HeaderField)\n    });\n    const HttpResponse = IDL.Record({\n        body: IDL.Vec(IDL.Nat8),\n        headers: IDL.Vec(HeaderField),\n        status_code: IDL.Nat16\n    });\n    const SubAccount = IDL.Vec(IDL.Nat8);\n    const BlockHeight = IDL.Nat64;\n    const NotifyCanisterArgs = IDL.Record({\n        to_subaccount: IDL.Opt(SubAccount),\n        from_subaccount: IDL.Opt(SubAccount),\n        to_canister: IDL.Principal,\n        max_fee: ICPTs,\n        block_height: BlockHeight\n    });\n    const Memo = IDL.Nat64;\n    const TimeStamp = IDL.Record({\n        timestamp_nanos: IDL.Nat64\n    });\n    const SendArgs = IDL.Record({\n        to: AccountIdentifier,\n        fee: ICPTs,\n        memo: Memo,\n        from_subaccount: IDL.Opt(SubAccount),\n        created_at_time: IDL.Opt(TimeStamp),\n        amount: ICPTs\n    });\n    return IDL.Service({\n        account_balance_dfx: IDL.Func([\n            AccountBalanceArgs\n        ], [\n            ICPTs\n        ], [\n            'query'\n        ]),\n        get_nodes: IDL.Func([], [\n            IDL.Vec(CanisterId)\n        ], [\n            'query'\n        ]),\n        http_request: IDL.Func([\n            HttpRequest\n        ], [\n            HttpResponse\n        ], [\n            'query'\n        ]),\n        notify_dfx: IDL.Func([\n            NotifyCanisterArgs\n        ], [], []),\n        send_dfx: IDL.Func([\n            SendArgs\n        ], [\n            BlockHeight\n        ], [])\n    });\n});\nexport const init = ({ IDL })=>{\n    const AccountIdentifier = IDL.Text;\n    const Duration = IDL.Record({\n        secs: IDL.Nat64,\n        nanos: IDL.Nat32\n    });\n    const ArchiveOptions = IDL.Record({\n        max_message_size_bytes: IDL.Opt(IDL.Nat32),\n        node_max_memory_size_bytes: IDL.Opt(IDL.Nat32),\n        controller_id: IDL.Principal\n    });\n    const ICPTs = IDL.Record({\n        e8s: IDL.Nat64\n    });\n    const LedgerCanisterInitPayload = IDL.Record({\n        send_whitelist: IDL.Vec(IDL.Tuple(IDL.Principal)),\n        minting_account: AccountIdentifier,\n        transaction_window: IDL.Opt(Duration),\n        max_message_size_bytes: IDL.Opt(IDL.Nat32),\n        archive_options: IDL.Opt(ArchiveOptions),\n        initial_values: IDL.Vec(IDL.Tuple(AccountIdentifier, ICPTs))\n    });\n    return [\n        LedgerCanisterInitPayload\n    ];\n};\n","export const LEDGER_CANISTER_ID = 'ryjl3-tyaaa-aaaaa-aaaba-cai';\nexport const NNS_CANISTER_ID = 'qoctq-giaaa-aaaaa-aaaea-cai';\nexport const SUB_ACCOUNT_BYTE_LENGTH = 32;\nexport const CREATE_CANISTER_MEMO = BigInt(0x41455243);\nexport const TOP_UP_CANISTER_MEMO = BigInt(0x50555054);\nexport const TRANSACTION_FEE = BigInt(10_000);\nexport const NET_ID = {\n    blockchain: 'Internet Computer',\n    network: '00000000000000020101'\n};\nexport const ROSETTA_URL = 'https://rosetta-api.internetcomputer.org';\nexport const IC_EXPLORER = 'https://dashboard.internetcomputer.org';\nexport const IC_ROCKS = 'https://ic.rocks';\nexport const MAX_TRANSACTION_DECISION_MILSECONDS = 120000;\nexport const PRINCIPAL_REGEX = /(\\w{5}-){10}\\w{3}/;\nexport const ALPHANUM_REGEX = /^[a-zA-Z0-9]+$/;\nexport const CANISTER_REGEX = /(\\w{5}-){4}\\w{3}/;\nexport const CANISTER_MAX_LENGTH = 27;\nexport const ADDRESS_TYPES = {\n    PRINCIPAL: 'principal',\n    ACCOUNT: 'accountId',\n    CANISTER: 'canister',\n    ERC20: 'erc20',\n    UNKNOWN: 'unknown'\n};\n","import { BaseConnection, executeWithLogging, _createActor } from \"./baseConnection\";\nimport ledger_idl from \"../canisters/ledger.idl\";\nimport { LEDGER_CANISTER_ID } from \"../utils/constants\";\nexport class LedgerConnection extends BaseConnection {\n    identity;\n    delegationIdentity;\n    actor;\n    agent;\n    constructor(identity, delegationIdentity, actor, agent, legerCanisterId){\n        super(identity, delegationIdentity, legerCanisterId ?? LEDGER_CANISTER_ID, ledger_idl, actor, agent);\n        this.identity = identity;\n        this.delegationIdentity = delegationIdentity;\n        this.actor = actor;\n        this.agent = agent;\n    }\n    static createConnection(identity, delegationIdentity, legerCanisterId, actor, agent) {\n        return new LedgerConnection(identity, delegationIdentity, actor, agent, legerCanisterId ?? LEDGER_CANISTER_ID);\n    }\n    static async createActor(delegationIdentity, ledgerCanisterId, host) {\n        const actor = await _createActor(ledger_idl, ledgerCanisterId ?? LEDGER_CANISTER_ID, delegationIdentity, host);\n        return actor;\n    }\n    static async createConnectionWithII(identity, delegationIdentity, legerCanisterId) {\n        const actorResult = await LedgerConnection.createActor(delegationIdentity);\n        return LedgerConnection.createConnection(identity, delegationIdentity, legerCanisterId ?? LEDGER_CANISTER_ID, actorResult.actor, actorResult.agent);\n    }\n    static async actorGetBalance(actor, account) {\n        const response = await executeWithLogging(()=>actor.account_balance_dfx({\n                account\n            }));\n        return response.e8s;\n    }\n    static async actorSend(actor, { to, amount, sendOpts }) {\n        const response = await executeWithLogging(()=>{\n            const defaultFee = BigInt(10000);\n            const defaultMemo = BigInt(Math.floor(Math.random() * 10000));\n            const subAccount = sendOpts?.from_subaccount === undefined ? [] : Array.from([\n                sendOpts?.from_subaccount\n            ]);\n            const createAtTime = sendOpts?.created_at_time === undefined ? [] : Array.from([\n                {\n                    timestamp_nanos: BigInt(sendOpts?.created_at_time?.getTime())\n                }\n            ]);\n            const sendArgs = {\n                to: to,\n                fee: {\n                    e8s: sendOpts?.fee ?? defaultFee\n                },\n                amount: {\n                    e8s: amount\n                },\n                memo: sendOpts?.memo ?? defaultMemo,\n                from_subaccount: subAccount,\n                created_at_time: createAtTime\n            };\n            return actor.send_dfx(sendArgs);\n        });\n        return response;\n    }\n    async getLedgerActor(ledgerCanisterId) {\n        const actor = await this._getActor(ledgerCanisterId ?? LEDGER_CANISTER_ID, ledger_idl);\n        return actor;\n    }\n    async getBalance(account) {\n        const actor = await this.getLedgerActor();\n        const response = await executeWithLogging(()=>actor.account_balance_dfx({\n                account\n            }));\n        return response.e8s;\n    }\n    async send({ to, amount, sendOpts }) {\n        const actor = await this.getLedgerActor();\n        const response = await executeWithLogging(()=>{\n            const defaultFee = BigInt(10000);\n            const defaultMemo = BigInt(Math.floor(Math.random() * 10000));\n            const subAccount = sendOpts?.from_subaccount === undefined ? [] : Array.from([\n                sendOpts?.from_subaccount\n            ]);\n            const createAtTime = sendOpts?.created_at_time === undefined ? [] : Array.from([\n                {\n                    timestamp_nanos: BigInt(sendOpts?.created_at_time?.getTime())\n                }\n            ]);\n            const sendArgs = {\n                to: to,\n                fee: {\n                    e8s: sendOpts?.fee ?? defaultFee\n                },\n                amount: {\n                    e8s: amount\n                },\n                memo: sendOpts?.memo ?? defaultMemo,\n                from_subaccount: subAccount,\n                created_at_time: createAtTime\n            };\n            return actor.send_dfx(sendArgs);\n        });\n        return response;\n    }\n}\n","export var WalletType;\n(function(WalletType) {\n    WalletType[\"nns\"] = \"nns\";\n    WalletType[\"plug\"] = \"plug\";\n    WalletType[\"stoic\"] = \"stoic\";\n    WalletType[\"me\"] = \"me\";\n    WalletType[\"unknown\"] = \"unknown\";\n})(WalletType || (WalletType = {}));\n","import { Principal } from \"@dfinity/principal\";\nimport { sha224 } from \"js-sha256\";\nimport { Buffer } from \"buffer\";\nimport crc from \"crc\";\nimport { ALPHANUM_REGEX, CANISTER_MAX_LENGTH, SUB_ACCOUNT_BYTE_LENGTH } from \"./constants\";\nexport const uint8ArrayToBigInt = (array)=>{\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    if (typeof view.getBigUint64 === 'function') {\n        return view.getBigUint64(0);\n    } else {\n        const high = BigInt(view.getUint32(0));\n        const low = BigInt(view.getUint32(4));\n        return (high << BigInt(32)) + low;\n    }\n};\nconst TWO_TO_THE_32 = BigInt(1) << BigInt(32);\nexport const bigIntToUint8Array = (value)=>{\n    const array = new Uint8Array(8);\n    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);\n    if (typeof view.setBigUint64 === 'function') {\n        view.setBigUint64(0, value);\n    } else {\n        view.setUint32(0, Number(value >> BigInt(32)));\n        view.setUint32(4, Number(value % TWO_TO_THE_32));\n    }\n    return array;\n};\nexport const arrayBufferToArrayOfNumber = (buffer)=>{\n    const typedArray = new Uint8Array(buffer);\n    return Array.from(typedArray);\n};\nexport const arrayOfNumberToUint8Array = (numbers)=>{\n    return new Uint8Array(numbers);\n};\nexport const arrayOfNumberToArrayBuffer = (numbers)=>{\n    return arrayOfNumberToUint8Array(numbers).buffer;\n};\nexport const arrayBufferToNumber = (buffer)=>{\n    const view = new DataView(buffer);\n    return view.getUint32(view.byteLength - 4);\n};\nexport const numberToArrayBuffer = (value, byteLength)=>{\n    const buffer = new ArrayBuffer(byteLength);\n    new DataView(buffer).setUint32(byteLength - 4, value);\n    return buffer;\n};\nexport const asciiStringToByteArray = (text)=>{\n    return Array.from(text).map((c)=>c.charCodeAt(0));\n};\nexport const toSubAccountId = (subAccount)=>{\n    const bytes = arrayOfNumberToArrayBuffer(subAccount);\n    return arrayBufferToNumber(bytes);\n};\nexport const fromSubAccountId = (subAccountId)=>{\n    const buffer = numberToArrayBuffer(subAccountId, SUB_ACCOUNT_BYTE_LENGTH);\n    return arrayBufferToArrayOfNumber(buffer);\n};\nexport const accountIdentifierToBytes = (accountIdentifier)=>{\n    return Uint8Array.from(Buffer.from(accountIdentifier, 'hex')).subarray(4);\n};\nexport const accountIdentifierFromBytes = (accountIdentifier)=>{\n    return Buffer.from(accountIdentifier).toString('hex');\n};\nexport const principalToAccountIdentifier = (principal, subAccount)=>{\n    const padding = asciiStringToByteArray('\\x0Aaccount-id');\n    const shaObj = sha224.create();\n    shaObj.update([\n        ...padding,\n        ...principal.toUint8Array(),\n        ...subAccount ?? Array(32).fill(0)\n    ]);\n    const hash = new Uint8Array(shaObj.array());\n    const checksum = calculateCrc32(hash);\n    const bytes = new Uint8Array([\n        ...checksum,\n        ...hash\n    ]);\n    return toHexString(bytes);\n};\nexport const principalToSubAccount = (principal)=>{\n    const bytes = principal.toUint8Array();\n    const subAccount = new Uint8Array(32);\n    subAccount[0] = bytes.length;\n    subAccount.set(bytes, 1);\n    return subAccount;\n};\nexport const stringToAccountIdentifier = (str)=>{\n    try {\n        if (str.length === 64) {\n            return str;\n        }\n        if (str.length === 63) {\n            return principalToAccountIdentifier(Principal.fromText(str));\n        }\n        return undefined;\n    } catch (error) {\n        return undefined;\n    }\n};\nconst toHexString = (bytes)=>bytes.reduce((str, byte)=>str + byte.toString(16).padStart(2, '0'), '');\nexport const calculateCrc32 = (bytes)=>{\n    const checksumArrayBuf = new ArrayBuffer(4);\n    const view = new DataView(checksumArrayBuf);\n    view.setUint32(0, crc.crc32(Buffer.from(bytes)), false);\n    return Buffer.from(checksumArrayBuf);\n};\nexport const E8S_PER_ICP = 100_000_000;\nexport var TokenSymbol;\n(function(TokenSymbol) {\n    TokenSymbol[\"ICP\"] = \"ICP\";\n})(TokenSymbol || (TokenSymbol = {}));\nexport const getDecimalFromSymbol = (sym)=>{\n    switch(sym){\n        case TokenSymbol.ICP:\n            return 8;\n        default:\n            return 8;\n    }\n};\nexport const formatAssetBySymbol = (_amount, symbol)=>{\n    const balanceString = balanceToString(_amount, getDecimalFromSymbol(symbol));\n    const amount = Number(balanceString.total);\n    const tokenMap = [\n        {\n            ICP: {\n                amount: amount,\n                balanceString,\n                symbol: 'ICP'\n            }\n        }\n    ];\n    const found = tokenMap.find((v)=>v[symbol] !== undefined);\n    return found?.[symbol];\n};\nexport const parseBalance = (balance)=>{\n    return (parseInt(balance.value, 10) / 10 ** balance.decimals).toString();\n};\nexport const balanceFromString = (balance, decimal = 8)=>{\n    const list = balance.split('.');\n    const aboveZero = list[0];\n    const aboveZeroBigInt = BigInt(aboveZero) * BigInt(1 * 10 ** decimal);\n    let belowZeroBigInt = BigInt(0);\n    const belowZero = list[1];\n    if (belowZero !== undefined) {\n        belowZeroBigInt = BigInt(belowZero.substring(0, decimal).padEnd(decimal, '0'));\n    }\n    return aboveZeroBigInt + belowZeroBigInt;\n};\nexport const balanceToString = (balance, decimal = 8)=>{\n    const balanceString = balance.toString(10);\n    const balanceStringLength = balanceString.length;\n    let aboveZero = '0';\n    let belowZero = '0'.padEnd(decimal, '0');\n    if (balanceStringLength > decimal) {\n        belowZero = balanceString.substring(balanceStringLength - decimal, balanceStringLength);\n        aboveZero = balanceString.substring(0, balanceStringLength - decimal);\n    } else {\n        belowZero = balanceString.padStart(decimal, '0');\n    }\n    const formatAboveZero = String(aboveZero).replace(/\\B(?=(\\d{3})+(?!\\d))/g, ',');\n    return {\n        total: aboveZero + '.' + belowZero,\n        aboveZero,\n        belowZero,\n        formatAboveZero\n    };\n};\nexport const validateAccountId = (text)=>text.length === 64 && ALPHANUM_REGEX.test(text);\nexport const validatePrincipalId = (text)=>{\n    try {\n        return text === Principal.fromText(text).toString();\n    } catch (e) {\n        return false;\n    }\n};\nexport const validateCanisterId = (text)=>{\n    try {\n        return text.length <= CANISTER_MAX_LENGTH && validatePrincipalId(text);\n    } catch (e) {\n        return false;\n    }\n};\nexport var AddressType;\n(function(AddressType) {\n    AddressType[\"PRINCIPAL\"] = 'principal';\n    AddressType[\"ACCOUNT\"] = 'accountId';\n    AddressType[\"CANISTER\"] = 'canister';\n    AddressType[\"ERC20\"] = 'erc20';\n    AddressType[\"INVALID\"] = 'invalid';\n})(AddressType || (AddressType = {}));\nexport const getAddressType = (text)=>{\n    try {\n        if (validateAccountId(text)) {\n            return AddressType.ACCOUNT;\n        } else if (validatePrincipalId(text)) {\n            return AddressType.PRINCIPAL;\n        } else if (validateCanisterId(text)) {\n            return AddressType.CANISTER;\n        }\n        return AddressType.INVALID;\n    } catch (error) {\n        throw error;\n    }\n};\n","export var PermissionsType;\n(function(PermissionsType) {\n    PermissionsType[\"identity\"] = 'permissions-identity';\n    PermissionsType[\"wallet\"] = 'permissions-wallet';\n})(PermissionsType || (PermissionsType = {}));\nexport var SignerMessageKind;\n(function(SignerMessageKind) {\n    SignerMessageKind[\"client\"] = 'signer-client';\n    SignerMessageKind[\"ready\"] = 'signer-ready';\n    SignerMessageKind[\"success\"] = 'signer-client-success';\n    SignerMessageKind[\"fail\"] = 'signer-client-failure';\n})(SignerMessageKind || (SignerMessageKind = {}));\nexport var TransactionMessageKind;\n(function(TransactionMessageKind) {\n    TransactionMessageKind[\"client\"] = 'transaction-client';\n    TransactionMessageKind[\"ready\"] = 'transaction-ready';\n    TransactionMessageKind[\"success\"] = 'transaction-client-success';\n    TransactionMessageKind[\"fail\"] = 'transaction-client-failure';\n})(TransactionMessageKind || (TransactionMessageKind = {}));\n","export const KEY_ICSTORAGE_KEY = 'identity';\nexport const KEY_ICSTORAGE_DELEGATION = 'delegation';\nexport const KEY_ICSTORAGE_WALLET = 'wallet';\nexport const KEY_DELEGATION_PARAMS = 'delegation_params';\nexport const IDENTITY_PROVIDER_DEFAULT = 'https://identity.ic0.app';\nexport const IDENTITY_PROVIDER_ENDPOINT = '#authorize';\nexport async function _deleteStorage(storage) {\n    await storage.remove(KEY_ICSTORAGE_KEY);\n    await storage.remove(KEY_ICSTORAGE_DELEGATION);\n    await storage.remove(KEY_ICSTORAGE_WALLET);\n    await storage.remove(KEY_DELEGATION_PARAMS);\n}\nexport class ICStorage {\n    prefix;\n    _localStorage;\n    constructor(prefix = 'astrox-', _localStorage){\n        this.prefix = prefix;\n        this._localStorage = _localStorage;\n    }\n    get(key) {\n        return Promise.resolve(this._getICStorage().getItem(this.prefix + key));\n    }\n    set(key, value) {\n        this._getICStorage().setItem(this.prefix + key, value);\n        return Promise.resolve();\n    }\n    remove(key) {\n        this._getICStorage().removeItem(this.prefix + key);\n        return Promise.resolve();\n    }\n    _getICStorage() {\n        if (this._localStorage) {\n            return this._localStorage;\n        }\n        const ls = typeof window === 'undefined' ? typeof global === 'undefined' ? typeof self === 'undefined' ? undefined : self.localStorage : global.localStorage : window.localStorage;\n        if (!ls) {\n            throw new Error('Could not find local storage.');\n        }\n        return ls;\n    }\n}\n","import { AnonymousIdentity } from \"@dfinity/agent\";\nimport { Principal } from \"@dfinity/principal\";\nimport { Delegation, DelegationChain, DelegationIdentity, Ed25519KeyIdentity, isDelegationValid } from \"@dfinity/identity\";\nimport { PermissionsType } from \"../types/index\";\nimport { IDENTITY_PROVIDER_DEFAULT, IDENTITY_PROVIDER_ENDPOINT, KEY_ICSTORAGE_DELEGATION, KEY_ICSTORAGE_KEY, KEY_ICSTORAGE_WALLET, ICStorage, _deleteStorage, KEY_DELEGATION_PARAMS } from \"./icStorage\";\nexport class AuthClient {\n    _identity;\n    _key;\n    _chain;\n    _storage;\n    _wallet;\n    _appId;\n    _delegationIdentity;\n    _delegationTargets;\n    _lastRequest;\n    _confirm;\n    _idpWindowOption;\n    _idpWindow;\n    _eventHandler;\n    static async create(options = {\n        appId: ''\n    }) {\n        const storage = options.storage ?? new ICStorage('astrox-');\n        let key = null;\n        if (options.identity) {\n            key = options.identity;\n        } else {\n            const maybeIdentityStorage = await storage.get(KEY_ICSTORAGE_KEY);\n            if (maybeIdentityStorage) {\n                try {\n                    key = Ed25519KeyIdentity.fromJSON(maybeIdentityStorage);\n                } catch (e) {}\n            }\n        }\n        let identity = new AnonymousIdentity();\n        let chain = null;\n        let wallet = undefined;\n        let delegationTargets = [];\n        let lastRequest = undefined;\n        let confirm = true;\n        let delegationIdentity = undefined;\n        if (key) {\n            try {\n                const chainStorage = await storage.get(KEY_ICSTORAGE_DELEGATION);\n                let walletString = await storage.get(KEY_ICSTORAGE_WALLET);\n                if (walletString) {\n                    wallet = JSON.parse(walletString);\n                }\n                if (chainStorage) {\n                    chain = DelegationChain.fromJSON(chainStorage);\n                    chain.delegations.forEach((signedDelegation)=>{\n                        const targets = signedDelegation.delegation.targets && signedDelegation.delegation.targets.length > 0 ? signedDelegation.delegation.targets : undefined;\n                        if (targets) {\n                            delegationTargets = [\n                                ...new Set(delegationTargets.concat(targets.map((e)=>e.toText())))\n                            ];\n                        }\n                    });\n                    if (!isDelegationValid(chain)) {\n                        await _deleteStorage(storage);\n                        key = null;\n                    } else {\n                        identity = DelegationIdentity.fromDelegation(key, chain);\n                    }\n                }\n            } catch (e) {\n                console.error(e);\n                await _deleteStorage(storage);\n                key = null;\n            }\n        }\n        let delegationParams;\n        const delegationParamsString = await storage.get(KEY_DELEGATION_PARAMS);\n        if (delegationParamsString) {\n            delegationParams = JSON.parse(delegationParamsString);\n            lastRequest = {\n                ...delegationParams.lastRequest,\n                maxTimeToLive: delegationParams.lastRequest.maxTimeToLive !== undefined ? BigInt(delegationParams.lastRequest.maxTimeToLive) : undefined\n            };\n            confirm = delegationParams.confirm;\n            delegationIdentity = DelegationIdentity.fromDelegation(key, chain);\n        }\n        const ret = new this(identity, key, chain, storage, wallet, options.appId, delegationIdentity, delegationTargets, lastRequest, confirm, options.idpWindowOption);\n        return ret;\n    }\n    constructor(_identity, _key, _chain, _storage, _wallet, _appId, _delegationIdentity, _delegationTargets = [], _lastRequest, _confirm, _idpWindowOption, _idpWindow, _eventHandler){\n        this._identity = _identity;\n        this._key = _key;\n        this._chain = _chain;\n        this._storage = _storage;\n        this._wallet = _wallet;\n        this._appId = _appId;\n        this._delegationIdentity = _delegationIdentity;\n        this._delegationTargets = _delegationTargets;\n        this._lastRequest = _lastRequest;\n        this._confirm = _confirm;\n        this._idpWindowOption = _idpWindowOption;\n        this._idpWindow = _idpWindow;\n        this._eventHandler = _eventHandler;\n    }\n    async _handleSuccess(message, onSuccess) {\n        if (message['identity'] !== undefined) {\n            const idDelegations = message['identity'].delegations.map((signedDelegation)=>{\n                const targets = signedDelegation.delegation.targets && signedDelegation.delegation.targets.length > 0 ? signedDelegation.delegation.targets?.map((t)=>Principal.fromText(t)) : undefined;\n                if (targets) {\n                    this._delegationTargets = [\n                        ...new Set(this._delegationTargets.concat(targets.map((e)=>e.toText())))\n                    ];\n                }\n                return {\n                    delegation: new Delegation(signedDelegation.delegation.pubkey.buffer, signedDelegation.delegation.expiration, targets),\n                    signature: signedDelegation.signature.buffer\n                };\n            });\n            const idDelegationChain = DelegationChain.fromDelegations(idDelegations, message['identity'].userPublicKey.buffer);\n            this._chain = idDelegationChain;\n            this._wallet = message['wallet'];\n            this._confirm = message['confirm'];\n        } else {\n            const iiDelegations = message.delegations.map((signedDelegation)=>{\n                const targets = signedDelegation.delegation.targets && signedDelegation.delegation.targets.length > 0 ? signedDelegation.delegation.targets?.map((t)=>Principal.fromText(t)) : undefined;\n                if (targets) {\n                    this._delegationTargets = [\n                        ...new Set(this._delegationTargets.concat(targets.map((e)=>e.toText())))\n                    ];\n                }\n                return {\n                    delegation: new Delegation(signedDelegation.delegation.pubkey.buffer, signedDelegation.delegation.expiration, targets),\n                    signature: signedDelegation.signature.buffer\n                };\n            });\n            const iiDelegationChain = DelegationChain.fromDelegations(iiDelegations, message.userPublicKey.buffer);\n            this._chain = iiDelegationChain;\n        }\n        const key = this._key;\n        if (!key) {\n            return this;\n        }\n        this._delegationIdentity = DelegationIdentity.fromDelegation(key, this._chain);\n        this._identity = this._delegationIdentity;\n        this._idpWindow?.close();\n        await onSuccess?.();\n        this._removeEventListener();\n        return this;\n    }\n    getIdentity() {\n        return this._identity;\n    }\n    getLastRequest() {\n        return this._lastRequest;\n    }\n    getDelegationIdentity() {\n        return this._delegationIdentity;\n    }\n    getInnerKey() {\n        return this._key;\n    }\n    getDelegationChain() {\n        return this._chain;\n    }\n    get wallet() {\n        return this._wallet;\n    }\n    getConfirm() {\n        return this._confirm;\n    }\n    setWallet(data) {\n        this._wallet = data;\n    }\n    getDelegateTargets() {\n        return this._delegationTargets;\n    }\n    setDelegationTargets(targets) {\n        this._delegationTargets = [\n            ...new Set(this._delegationTargets.concat(targets))\n        ];\n    }\n    async isAuthenticated() {\n        return !this.getIdentity().getPrincipal().isAnonymous() && this._chain !== null;\n    }\n    async login(options) {\n        let key = this._key;\n        if (!key) {\n            key = Ed25519KeyIdentity.generate();\n            this._key = key;\n            await this._storage.set(KEY_ICSTORAGE_KEY, JSON.stringify(key));\n        }\n        const identityProviderUrl = new URL(options?.identityProvider?.toString() || IDENTITY_PROVIDER_DEFAULT);\n        identityProviderUrl.hash = IDENTITY_PROVIDER_ENDPOINT;\n        this._idpWindow?.close();\n        this._removeEventListener();\n        this._idpWindow = window.open(identityProviderUrl.toString(), 'idpWindow', this._idpWindowOption) ?? undefined;\n        return new Promise((resolve, reject)=>{\n            this._eventHandler = this._getEventHandler(identityProviderUrl, resolve, reject, options);\n            window.addEventListener('message', this._eventHandler);\n        });\n    }\n    _getEventHandler(identityProviderUrl, resolve, reject, options) {\n        return async (event)=>{\n            if (event.origin !== identityProviderUrl.origin) {\n                return;\n            }\n            const message = event.data;\n            switch(message.kind){\n                case 'authorize-ready':\n                    {\n                        const request = options?.authType === 'authorize-append' && this._lastRequest ? {\n                            ...this._lastRequest,\n                            delegationTargets: options?.delegationTargets ?? [],\n                            sessionPublicKey: new Uint8Array(this._key?.getPublicKey().toDer()),\n                            kind: 'authorize-append'\n                        } : {\n                            kind: 'authorize-client',\n                            sessionPublicKey: new Uint8Array(this._key?.getPublicKey().toDer()),\n                            maxTimeToLive: options?.maxTimeToLive,\n                            permissions: options?.permissions ?? [\n                                PermissionsType.identity\n                            ],\n                            delegationTargets: options?.delegationTargets ?? [],\n                            delegationModes: options?.delegationModes,\n                            appId: this._appId,\n                            noUnify: options?.noUnify,\n                            host: options?.customDomain || options?.host\n                        };\n                        this._lastRequest = request;\n                        this._idpWindow?.postMessage(request, identityProviderUrl.origin);\n                        break;\n                    }\n                case 'authorize-client-success':\n                    try {\n                        resolve(await this._handleSuccess(message, options?.onSuccess));\n                        if (this._chain) {\n                            await this._storage.set(KEY_ICSTORAGE_DELEGATION, JSON.stringify(this._chain.toJSON()));\n                        }\n                        if (this._wallet !== undefined) {\n                            await this._storage.set(KEY_ICSTORAGE_WALLET, JSON.stringify(this._wallet));\n                        }\n                        if (this._lastRequest !== undefined) {\n                            const params = {\n                                lastRequest: {\n                                    ...this._lastRequest,\n                                    maxTimeToLive: this._lastRequest.maxTimeToLive?.toString()\n                                },\n                                confirm: this._confirm\n                            };\n                            await this._storage.set(KEY_DELEGATION_PARAMS, JSON.stringify(params));\n                        }\n                    } catch (err) {\n                        reject(this._handleFailure(err.message, options?.onError));\n                    }\n                    break;\n                case 'authorize-client-failure':\n                    reject(this._handleFailure(message.text, options?.onError));\n                    break;\n                default:\n                    break;\n            }\n        };\n    }\n    _handleFailure(errorMessage, onError) {\n        this._idpWindow?.close();\n        onError?.(errorMessage);\n        this._removeEventListener();\n        return errorMessage;\n    }\n    _removeEventListener() {\n        if (this._eventHandler) {\n            window.removeEventListener('message', this._eventHandler);\n        }\n        this._eventHandler = undefined;\n    }\n    async logout(options = {}) {\n        _deleteStorage(this._storage);\n        this._identity = new AnonymousIdentity();\n        this._key = null;\n        this._chain = null;\n        this._delegationTargets = [];\n        this._wallet = undefined;\n        this._delegationIdentity = undefined;\n        this._lastRequest = undefined;\n        this._confirm = undefined;\n        if (options.returnTo) {\n            try {\n                window.history.pushState({}, '', options.returnTo);\n            } catch (e) {\n                window.location.href = options.returnTo;\n            }\n        }\n    }\n}\n","export class ICWindow {\n    _window;\n    _eventHandler;\n    _removeEventListener() {\n        if (this._eventHandler) {\n            window.removeEventListener('message', this._eventHandler);\n        }\n        this._eventHandler = undefined;\n    }\n    _openWindow(url, target, feature) {\n        this._remove();\n        this._window = window.open(url, target ?? 'icWindow', feature) ?? undefined;\n    }\n    _remove() {\n        this._window?.close();\n        this._removeEventListener();\n    }\n}\n","import { Actor, HttpAgent } from \"@dfinity/agent\";\nimport { AuthClient } from \"./icAuthClient\";\nimport { IDENTITY_PROVIDER_DEFAULT } from \"./icStorage\";\nimport { ICWindow } from \"./icWindow\";\nimport { LedgerConnection } from \"../connections/ledgerConnection\";\nimport { PermissionsType, SignerMessageKind, TransactionMessageKind } from \"../types/index\";\nconst days = BigInt(1);\nconst hours = BigInt(24);\nconst nanoseconds = BigInt(3600000000000);\nconst WALLET_PROVIDER_DEFAULT = 'https://63k2f-nyaaa-aaaah-aakla-cai.raw.ic0.app';\nconst WALLET_PROVIDER_ENDPOINT = '#transaction';\nconst SIGNER_PROVIDER_DEFAULT = 'https://63k2f-nyaaa-aaaah-aakla-cai.raw.ic0.app';\nconst SIGNER_PROVIDER_ENDPOINT = '#signer';\nfunction targetsFilter(arr) {\n    return arr.filter((value)=>typeof value === 'string' && value.trim());\n}\nconst FRAME_SETTING = 'height=600, width=800, top=0, right=0, toolbar=no, menubar=no, scrollbars=no, resizable=no, location=no, status=no';\nconst FRAME_SETTING_PAYMENT = 'height=600, width=480, top=0, right=0, toolbar=no, menubar=no, scrollbars=no, resizable=no, location=no, status=no';\nexport class IC extends ICWindow {\n    #authClient;\n    #agent;\n    #localLedger;\n    #walletProvider;\n    #signerProvider;\n    #useFrame = false;\n    #loginOption;\n    #connectOptions;\n    constructor(authClient, agent){\n        super();\n        this.#authClient = authClient;\n        this.#agent = agent;\n        this.injectWindow();\n    }\n    static async create(config) {\n        let delegationTargets = [\n            'ryjl3-tyaaa-aaaaa-aaaba-cai'\n        ];\n        if (config && config?.delegationTargets) {\n            delegationTargets = [\n                ...new Set(delegationTargets.concat(config?.delegationTargets))\n            ];\n        }\n        if (config && config?.ledgerCanisterId) {\n            delegationTargets = [\n                ...new Set(delegationTargets.concat(config?.ledgerCanisterId))\n            ];\n        }\n        if (config && config?.whitelist) {\n            delegationTargets = [\n                ...new Set(delegationTargets.concat(config?.whitelist))\n            ];\n        }\n        delegationTargets = targetsFilter([\n            ...new Set(delegationTargets)\n        ]);\n        const authClient = await AuthClient.create({\n            ...config,\n            delegationTargets,\n            idpWindowOption: config.useFrame === true ? FRAME_SETTING : undefined\n        });\n        const identity = authClient.getIdentity();\n        const agent = new HttpAgent({\n            identity,\n            host: config.host ?? window.location.origin\n        });\n        if (config.dev) {\n            await agent.fetchRootKey();\n        }\n        const newIC = new IC(authClient, agent);\n        newIC._setWalletProvider(config?.walletProviderUrl);\n        newIC._setSignerProvider(config?.signerProviderUrl);\n        newIC._setUseFrame(config?.useFrame);\n        if (await newIC.isAuthenticated()) {\n            await newIC.handleAuthenticated({\n                ledgerCanisterId: config.ledgerCanisterId ?? 'ryjl3-tyaaa-aaaaa-aaaba-cai',\n                ledgerHost: config.ledgerHost ?? 'https://boundary.ic0.app/'\n            });\n            await config?.onAuthenticated?.(newIC);\n        }\n        const provider = config?.identityProvider ?? IDENTITY_PROVIDER_DEFAULT;\n        newIC._setConnectOptions({\n            ...config,\n            dev: config.dev,\n            delegationTargets\n        });\n        newIC._setLoginOptions({\n            ...config,\n            identityProvider: provider,\n            maxTimeToLive: config?.maxTimeToLive ?? days * hours * nanoseconds,\n            permissions: config?.permissions ?? [\n                PermissionsType.identity\n            ],\n            delegationTargets\n        });\n        return newIC;\n    }\n    async connect(connectOptions) {\n        let delegationModes = connectOptions.delegationModes;\n        if (delegationModes && delegationModes.length) {\n            const modes = [\n                'global',\n                'domain'\n            ];\n            const hasNotInclude = delegationModes.some((v)=>!modes.includes(v));\n            if (hasNotInclude) {\n                throw new Error('`delegationModes` elements only support `global` and `private`');\n            }\n            delegationModes = [\n                ...new Set(delegationModes)\n            ];\n        }\n        const provider = connectOptions?.identityProvider ?? IDENTITY_PROVIDER_DEFAULT;\n        let delegationTargets = [\n            'ryjl3-tyaaa-aaaaa-aaaba-cai'\n        ];\n        if (connectOptions && connectOptions?.delegationTargets) {\n            delegationTargets = [\n                ...new Set(delegationTargets.concat(connectOptions?.delegationTargets))\n            ];\n        }\n        if (connectOptions && connectOptions?.ledgerCanisterId) {\n            delegationTargets = [\n                ...new Set(delegationTargets.concat(connectOptions?.ledgerCanisterId))\n            ];\n        }\n        if (connectOptions && connectOptions?.whitelist) {\n            delegationTargets = [\n                ...new Set(delegationTargets.concat(connectOptions?.whitelist))\n            ];\n        }\n        delegationTargets = targetsFilter([\n            ...new Set(delegationTargets)\n        ]);\n        this._setConnectOptions({\n            ...connectOptions,\n            delegationTargets\n        });\n        this._setLoginOptions({\n            ...connectOptions,\n            identityProvider: provider,\n            maxTimeToLive: connectOptions?.maxTimeToLive ?? days * hours * nanoseconds,\n            permissions: connectOptions?.permissions ?? [\n                PermissionsType.identity\n            ],\n            delegationTargets,\n            delegationModes\n        });\n        await new Promise((resolve, reject)=>{\n            this.getAuthClient().login({\n                ...this.#loginOption,\n                onSuccess: async ()=>{\n                    const identity = this.getAuthClient().getIdentity();\n                    this.#agent = new HttpAgent({\n                        identity,\n                        host: connectOptions.host ?? window.location.origin\n                    });\n                    if (connectOptions.dev) {\n                        await this.#agent.fetchRootKey();\n                    }\n                    await this.handleAuthenticated({\n                        ledgerCanisterId: connectOptions.ledgerCanisterId,\n                        ledgerHost: connectOptions.ledgerHost ?? 'https://boundary.ic0.app/'\n                    });\n                    connectOptions?.onSuccess ? await connectOptions?.onSuccess?.() : await connectOptions?.onAuthenticated?.(this);\n                    resolve(this);\n                },\n                onError: this.handleError\n            });\n        });\n        return this;\n    }\n    async isAuthenticated() {\n        const result = await this.#authClient.isAuthenticated();\n        return result;\n    }\n    get identity() {\n        return this.#authClient.getIdentity();\n    }\n    get principal() {\n        return this.identity.getPrincipal();\n    }\n    get wallet() {\n        return this.#authClient.wallet;\n    }\n    get delegationTargets() {\n        return this.#authClient.getDelegateTargets();\n    }\n    _setWalletProvider(provider) {\n        this.#walletProvider = provider;\n    }\n    _setSignerProvider(provider) {\n        this.#signerProvider = provider;\n    }\n    _setUseFrame(useFrame) {\n        this.#useFrame = useFrame;\n    }\n    _setConnectOptions(options) {\n        this.#connectOptions = options;\n    }\n    _setLoginOptions(options) {\n        this.#loginOption = options;\n    }\n    get loginOption() {\n        return this.#loginOption;\n    }\n    get connectOptions() {\n        return this.#connectOptions;\n    }\n    getAuthClient() {\n        return this.#authClient;\n    }\n    disconnect = async (options = {})=>{\n        this.#agent = undefined;\n        this.#localLedger = undefined;\n        this.#walletProvider = undefined;\n        this.#signerProvider = undefined;\n        this.#loginOption = undefined;\n        this.#connectOptions = undefined;\n        await this.getAuthClient().logout(options);\n    };\n    queryBalance = async ()=>{\n        if (this.wallet === undefined) {\n            throw Error('Wallet address is not found');\n        }\n        if (this.#localLedger === undefined) {\n            throw Error('Ledger connection failed');\n        }\n        const result = await this.#localLedger?.getBalance(this.wallet.accountId);\n        return result;\n    };\n    handleAuthenticated = async ({ ledgerCanisterId, ledgerHost })=>{\n        const actorResult = await LedgerConnection.createActor(this.getAuthClient().getDelegationIdentity(), ledgerCanisterId, ledgerHost);\n        this.#localLedger = LedgerConnection.createConnection(this.getAuthClient().getInnerKey(), this.getAuthClient().getDelegationIdentity(), ledgerCanisterId, actorResult.actor, this.#agent);\n    };\n    injectWindow() {\n        if (window.ic !== undefined) {\n            window.ic.astrox = this;\n        } else {\n            window.ic = {\n                astrox: this\n            };\n        }\n    }\n    async _appendAuth(canisterId) {\n        const currentTargets = targetsFilter(this.#authClient.getDelegateTargets());\n        if (currentTargets.includes(canisterId)) {\n            return this;\n        } else {\n            let newTargets = [\n                ...currentTargets,\n                canisterId\n            ];\n            newTargets = targetsFilter(newTargets);\n            this._setConnectOptions({\n                ...this.#connectOptions,\n                delegationTargets: newTargets\n            });\n            this._setLoginOptions({\n                ...this.#loginOption,\n                delegationTargets: newTargets\n            });\n            return await new Promise((resolve, reject)=>{\n                this.getAuthClient().login({\n                    ...this.#loginOption,\n                    authType: 'authorize-append',\n                    delegationTargets: newTargets,\n                    onSuccess: async ()=>{\n                        const identity = this.getAuthClient().getIdentity();\n                        this.#agent = new HttpAgent({\n                            identity,\n                            host: this.#connectOptions !== undefined ? this.#connectOptions.host : window.location.origin\n                        });\n                        if (this.#connectOptions?.dev) {\n                            await this.#agent.fetchRootKey();\n                        }\n                        await this.handleAuthenticated({\n                            ledgerCanisterId: this.#connectOptions?.ledgerCanisterId,\n                            ledgerHost: this.#connectOptions?.ledgerHost ?? 'https://boundary.ic0.app/'\n                        });\n                        await this.#connectOptions?.onSuccess ? await this.#connectOptions?.onSuccess?.() : await this.#connectOptions?.onAuthenticated?.(this);\n                        resolve(this);\n                    },\n                    onError: this.handleError\n                });\n            });\n        }\n    }\n    handleError(error) {\n        throw new Error(error);\n    }\n    createActor = async (idlFactory, canisterId)=>{\n        if (this.#authClient.getConfirm() === true && canisterId !== undefined && canisterId !== '') {\n            await this._appendAuth(canisterId);\n        }\n        if (this.#connectOptions?.dev) {\n            await this.#agent?.fetchRootKey();\n        }\n        return Actor.createActor(idlFactory, {\n            agent: this.#agent,\n            canisterId\n        });\n    };\n    requestTransfer = async (options)=>{\n        const memo = options.sendOpts?.memo;\n        if (memo) {\n            const standard = options.standard.toUpperCase();\n            if (standard === 'EXT' && !Array.isArray(memo)) {\n                throw new Error('`sendOpts.memo` only supports `Array<number>` type when the standard is `EXT`');\n            }\n            if (standard === 'ICP' && typeof memo !== 'bigint') {\n                throw new Error('`sendOpts.memo` only supports `bigint` type when the standard is `ICP`');\n            }\n        }\n        console.assert(this.wallet !== undefined, 'wallet address is not found');\n        const walletProviderUrl = new URL(options?.walletProvider?.toString() || this.#walletProvider || WALLET_PROVIDER_DEFAULT);\n        walletProviderUrl.hash = WALLET_PROVIDER_ENDPOINT;\n        this._openWindow(walletProviderUrl.toString(), 'icWindow', this.#useFrame ? FRAME_SETTING_PAYMENT : undefined);\n        return new Promise((resolve, reject)=>{\n            this._eventHandler = this._getEventHandler(walletProviderUrl, resolve, reject, options);\n            window.addEventListener('message', this._eventHandler);\n        });\n    };\n    signMessage = async (options)=>{\n        console.assert(this.wallet !== undefined, 'wallet address is not found');\n        const signerProviderUrl = new URL(options?.signerProvider?.toString() || this.#signerProvider || SIGNER_PROVIDER_DEFAULT);\n        signerProviderUrl.hash = SIGNER_PROVIDER_ENDPOINT;\n        this._openWindow(signerProviderUrl.toString(), 'icWindow', this.#useFrame ? FRAME_SETTING_PAYMENT : undefined);\n        return new Promise((resolve, reject)=>{\n            this._eventHandler = this._getSignerHandler(signerProviderUrl, resolve, reject, options);\n            window.addEventListener('message', this._eventHandler);\n        });\n    };\n    _getSignerHandler(walletProviderUrl, resolve, reject, options) {\n        return async (event)=>{\n            if (event.origin !== walletProviderUrl.origin) {\n                return;\n            }\n            const message = event.data;\n            switch(message.kind){\n                case SignerMessageKind.ready:\n                    {\n                        const request = {\n                            kind: SignerMessageKind.client,\n                            from: options.from ?? this.wallet.accountId,\n                            message: options.message,\n                            maxTimeout: options.maxTimeout ?? 90,\n                            successTimeout: options.successTimeout ?? 10\n                        };\n                        this._window?.postMessage(request, walletProviderUrl.origin);\n                        break;\n                    }\n                case SignerMessageKind.success:\n                    try {\n                        resolve(this._handleSuccess(message, options.onSuccess, options.successTimeout ?? 10));\n                    } catch (err) {\n                        reject(this._handleFailure(err.message, options.onError));\n                    }\n                    break;\n                case SignerMessageKind.fail:\n                    reject(this._handleFailure(message.text, options.onError));\n                    break;\n                default:\n                    break;\n            }\n        };\n    }\n    _getEventHandler(walletProviderUrl, resolve, reject, options) {\n        return async (event)=>{\n            if (event.origin !== walletProviderUrl.origin) {\n                return;\n            }\n            const message = event.data;\n            switch(message.kind){\n                case TransactionMessageKind.ready:\n                    {\n                        const request = {\n                            kind: TransactionMessageKind.client,\n                            sendData: {\n                                ...options\n                            }\n                        };\n                        this._window?.postMessage(request, walletProviderUrl.origin);\n                        break;\n                    }\n                case TransactionMessageKind.success:\n                    try {\n                        resolve(this._handleSuccess(message, options.onSuccess, options.successTimeout ?? 10));\n                    } catch (err) {\n                        reject(this._handleFailure(err.message, options.onError));\n                    }\n                    break;\n                case TransactionMessageKind.fail:\n                    reject(this._handleFailure(message.text, options.onError));\n                    break;\n                default:\n                    break;\n            }\n        };\n    }\n    _handleFailure(errorMessage, onError) {\n        this._remove();\n        onError?.(errorMessage);\n        return errorMessage;\n    }\n    _handleSuccess(value, onSuccess, delay) {\n        if (delay) {\n            setTimeout(()=>this._remove(), delay * 1000);\n        } else {\n            this._remove();\n        }\n        onSuccess?.(value);\n        return value;\n    }\n}\n","export function isDelegationValid(chain) {\n    var _chain;\n    if (!chain || !((_chain = chain) === null || _chain === void 0 ? void 0 : _chain.delegations)) {\n        return false;\n    }\n    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;\n    try {\n        for(var _iterator = chain.delegations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){\n            var delegation = _step.value.delegation;\n            if (parseInt(delegation.expiration, 16) / 1e6 <= +Date.now()) {\n                return false;\n            }\n        }\n    } catch (err) {\n        _didIteratorError = true;\n        _iteratorError = err;\n    } finally{\n        try {\n            if (!_iteratorNormalCompletion && _iterator.return != null) {\n                _iterator.return();\n            }\n        } finally{\n            if (_didIteratorError) {\n                throw _iteratorError;\n            }\n        }\n    }\n    return true;\n}\n","function _class_call_check(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n        throw new TypeError(\"Cannot call a class as a function\");\n    }\n}\nfunction _defineProperties(target, props) {\n    for(var i = 0; i < props.length; i++){\n        var descriptor = props[i];\n        descriptor.enumerable = descriptor.enumerable || false;\n        descriptor.configurable = true;\n        if (\"value\" in descriptor) descriptor.writable = true;\n        Object.defineProperty(target, descriptor.key, descriptor);\n    }\n}\nfunction _create_class(Constructor, protoProps, staticProps) {\n    if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) _defineProperties(Constructor, staticProps);\n    return Constructor;\n}\nfunction _define_property(obj, key, value) {\n    if (key in obj) {\n        Object.defineProperty(obj, key, {\n            value: value,\n            enumerable: true,\n            configurable: true,\n            writable: true\n        });\n    } else {\n        obj[key] = value;\n    }\n    return obj;\n}\nexport var ICStorage = function() {\n    \"use strict\";\n    function ICStorage() {\n        var prefix = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : \"astrox-\", _localStorage = arguments.length > 1 ? arguments[1] : void 0;\n        _class_call_check(this, ICStorage);\n        _define_property(this, \"prefix\", void 0);\n        _define_property(this, \"_localStorage\", void 0);\n        this.prefix = prefix;\n        this._localStorage = _localStorage;\n    }\n    _create_class(ICStorage, [\n        {\n            key: \"get\",\n            value: function get(key) {\n                return Promise.resolve(this._getICStorage().getItem(this.prefix + key));\n            }\n        },\n        {\n            key: \"set\",\n            value: function set(key, value) {\n                this._getICStorage().setItem(this.prefix + key, value);\n                return Promise.resolve();\n            }\n        },\n        {\n            key: \"remove\",\n            value: function remove(key) {\n                this._getICStorage().removeItem(this.prefix + key);\n                return Promise.resolve();\n            }\n        },\n        {\n            key: \"_getICStorage\",\n            value: function _getICStorage() {\n                if (this._localStorage) {\n                    return this._localStorage;\n                }\n                var ls = typeof window === \"undefined\" ? typeof global === \"undefined\" ? typeof self === \"undefined\" ? undefined : self.localStorage : global.localStorage : window.localStorage;\n                if (!ls) {\n                    throw new Error(\"Could not find local storage.\");\n                }\n                return ls;\n            }\n        }\n    ]);\n    return ICStorage;\n}();\n","function _array_like_to_array(arr, len) {\n    if (len == null || len > arr.length) len = arr.length;\n    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];\n    return arr2;\n}\nfunction _array_without_holes(arr) {\n    if (Array.isArray(arr)) return _array_like_to_array(arr);\n}\nfunction _iterable_to_array(iter) {\n    if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\nfunction _non_iterable_spread() {\n    throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nfunction _to_consumable_array(arr) {\n    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();\n}\nfunction _unsupported_iterable_to_array(o, minLen) {\n    if (!o) return;\n    if (typeof o === \"string\") return _array_like_to_array(o, minLen);\n    var n = Object.prototype.toString.call(o).slice(8, -1);\n    if (n === \"Object\" && o.constructor) n = o.constructor.name;\n    if (n === \"Map\" || n === \"Set\") return Array.from(n);\n    if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);\n}\nexport function concat() {\n    for(var _len = arguments.length, buffers = new Array(_len), _key = 0; _key < _len; _key++){\n        buffers[_key] = arguments[_key];\n    }\n    var result = new Uint8Array(buffers.reduce(function(acc, curr) {\n        return acc + curr.byteLength;\n    }, 0));\n    var index = 0;\n    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;\n    try {\n        for(var _iterator = buffers[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){\n            var b = _step.value;\n            result.set(new Uint8Array(b), index);\n            index += b.byteLength;\n        }\n    } catch (err) {\n        _didIteratorError = true;\n        _iteratorError = err;\n    } finally{\n        try {\n            if (!_iteratorNormalCompletion && _iterator.return != null) {\n                _iterator.return();\n            }\n        } finally{\n            if (_didIteratorError) {\n                throw _iteratorError;\n            }\n        }\n    }\n    return result.buffer;\n}\nexport function toHex(buffer) {\n    return _to_consumable_array(new Uint8Array(buffer)).map(function(x) {\n        return x.toString(16).padStart(2, \"0\");\n    }).join(\"\");\n}\nvar hexRe = new RegExp(/^([0-9A-F]{2})*$/i);\nexport function fromHex(hex) {\n    if (hex.length % 2 !== 0) {\n        hex = \"0\" + hex;\n    }\n    if (!hexRe.test(hex)) {\n        throw new Error(\"Invalid hexadecimal string.\");\n    }\n    var buffer = _to_consumable_array(hex).reduce(function(acc, curr, i) {\n        acc[i / 2 | 0] = (acc[i / 2 | 0] || \"\") + curr;\n        return acc;\n    }, []).map(function(x) {\n        return Number.parseInt(x, 16);\n    });\n    return new Uint8Array(buffer).buffer;\n}\nexport function compare(b1, b2) {\n    if (b1.byteLength !== b2.byteLength) {\n        return b1.byteLength - b2.byteLength;\n    }\n    var u1 = new Uint8Array(b1);\n    var u2 = new Uint8Array(b2);\n    for(var i = 0; i < u1.length; i++){\n        if (u1[i] !== u2[i]) {\n            return u1[i] - u2[i];\n        }\n    }\n    return 0;\n}\n","function _array_like_to_array(arr, len) {\n    if (len == null || len > arr.length) len = arr.length;\n    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];\n    return arr2;\n}\nfunction _array_without_holes(arr) {\n    if (Array.isArray(arr)) return _array_like_to_array(arr);\n}\nfunction _assert_this_initialized(self) {\n    if (self === void 0) {\n        throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n    }\n    return self;\n}\nfunction _class_call_check(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n        throw new TypeError(\"Cannot call a class as a function\");\n    }\n}\nfunction _defineProperties(target, props) {\n    for(var i = 0; i < props.length; i++){\n        var descriptor = props[i];\n        descriptor.enumerable = descriptor.enumerable || false;\n        descriptor.configurable = true;\n        if (\"value\" in descriptor) descriptor.writable = true;\n        Object.defineProperty(target, descriptor.key, descriptor);\n    }\n}\nfunction _create_class(Constructor, protoProps, staticProps) {\n    if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) _defineProperties(Constructor, staticProps);\n    return Constructor;\n}\nfunction _define_property(obj, key, value1) {\n    if (key in obj) {\n        Object.defineProperty(obj, key, {\n            value: value1,\n            enumerable: true,\n            configurable: true,\n            writable: true\n        });\n    } else {\n        obj[key] = value1;\n    }\n    return obj;\n}\nfunction _get_prototype_of(o) {\n    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {\n        return o.__proto__ || Object.getPrototypeOf(o);\n    };\n    return _get_prototype_of(o);\n}\nfunction _inherits(subClass, superClass) {\n    if (typeof superClass !== \"function\" && superClass !== null) {\n        throw new TypeError(\"Super expression must either be null or a function\");\n    }\n    subClass.prototype = Object.create(superClass && superClass.prototype, {\n        constructor: {\n            value: subClass,\n            writable: true,\n            configurable: true\n        }\n    });\n    if (superClass) _set_prototype_of(subClass, superClass);\n}\nfunction _instanceof(left, right) {\n    if (right != null && typeof Symbol !== \"undefined\" && right[Symbol.hasInstance]) {\n        return !!right[Symbol.hasInstance](left);\n    } else {\n        return left instanceof right;\n    }\n}\nfunction _iterable_to_array(iter) {\n    if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\nfunction _non_iterable_spread() {\n    throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nfunction _possible_constructor_return(self, call) {\n    if (call && (_type_of(call) === \"object\" || typeof call === \"function\")) {\n        return call;\n    }\n    return _assert_this_initialized(self);\n}\nfunction _set_prototype_of(o, p) {\n    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {\n        o.__proto__ = p;\n        return o;\n    };\n    return _set_prototype_of(o, p);\n}\nfunction _to_consumable_array(arr) {\n    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();\n}\nfunction _type_of(obj) {\n    \"@swc/helpers - typeof\";\n    return obj && typeof Symbol !== \"undefined\" && obj.constructor === Symbol ? \"symbol\" : typeof obj;\n}\nfunction _unsupported_iterable_to_array(o, minLen) {\n    if (!o) return;\n    if (typeof o === \"string\") return _array_like_to_array(o, minLen);\n    var n = Object.prototype.toString.call(o).slice(8, -1);\n    if (n === \"Object\" && o.constructor) n = o.constructor.name;\n    if (n === \"Map\" || n === \"Set\") return Array.from(n);\n    if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);\n}\nfunction _is_native_reflect_construct() {\n    if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n    if (Reflect.construct.sham) return false;\n    if (typeof Proxy === \"function\") return true;\n    try {\n        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\nfunction _create_super(Derived) {\n    var hasNativeReflectConstruct = _is_native_reflect_construct();\n    return function _createSuperInternal() {\n        var Super = _get_prototype_of(Derived), result;\n        if (hasNativeReflectConstruct) {\n            var NewTarget = _get_prototype_of(this).constructor;\n            result = Reflect.construct(Super, arguments, NewTarget);\n        } else {\n            result = Super.apply(this, arguments);\n        }\n        return _possible_constructor_return(this, result);\n    };\n}\nimport borc from \"borc\";\nimport { SelfDescribeCborSerializer, value } from \"simple-cbor\";\nimport { concat, fromHex } from \"./buffer\";\nvar BufferEncoder = function() {\n    \"use strict\";\n    function BufferEncoder() {\n        _class_call_check(this, BufferEncoder);\n    }\n    _create_class(BufferEncoder, [\n        {\n            key: \"name\",\n            get: function get() {\n                return \"Buffer\";\n            }\n        },\n        {\n            key: \"priority\",\n            get: function get() {\n                return 1;\n            }\n        },\n        {\n            key: \"match\",\n            value: function match(value) {\n                return _instanceof(value, ArrayBuffer) || ArrayBuffer.isView(value);\n            }\n        },\n        {\n            key: \"encode\",\n            value: function encode(v) {\n                return value.bytes(new Uint8Array(v));\n            }\n        }\n    ]);\n    return BufferEncoder;\n}();\nvar BigIntEncoder = function() {\n    \"use strict\";\n    function BigIntEncoder() {\n        _class_call_check(this, BigIntEncoder);\n    }\n    _create_class(BigIntEncoder, [\n        {\n            key: \"name\",\n            get: function get() {\n                return \"BigInt\";\n            }\n        },\n        {\n            key: \"priority\",\n            get: function get() {\n                return 1;\n            }\n        },\n        {\n            key: \"match\",\n            value: function match(value) {\n                return (typeof value === \"undefined\" ? \"undefined\" : _type_of(value)) === \"bigint\";\n            }\n        },\n        {\n            key: \"encode\",\n            value: function encode(v) {\n                if (v > BigInt(0)) {\n                    return value.tagged(2, value.bytes(fromHex(v.toString(16))));\n                } else {\n                    return value.tagged(3, value.bytes(fromHex((BigInt(\"-1\") * v).toString(16))));\n                }\n            }\n        }\n    ]);\n    return BigIntEncoder;\n}();\nvar serializer = SelfDescribeCborSerializer.withDefaultEncoders(true);\nserializer.addEncoder(new BufferEncoder());\nserializer.addEncoder(new BigIntEncoder());\nexport var CborTag;\n(function(CborTag) {\n    CborTag[CborTag[\"Uint64LittleEndian\"] = 71] = \"Uint64LittleEndian\";\n    CborTag[CborTag[\"Semantic\"] = 55799] = \"Semantic\";\n})(CborTag || (CborTag = {}));\nexport function encode(value1) {\n    return serializer.serialize(value1);\n}\nfunction decodePositiveBigInt(buf) {\n    var len = buf.byteLength;\n    var res = BigInt(0);\n    for(var i = 0; i < len; i++){\n        res = res * BigInt(0x100) + BigInt(buf[i]);\n    }\n    return res;\n}\nvar Uint8ArrayDecoder = function(_borc_Decoder) {\n    \"use strict\";\n    _inherits(Uint8ArrayDecoder, _borc_Decoder);\n    var _super = _create_super(Uint8ArrayDecoder);\n    function Uint8ArrayDecoder() {\n        _class_call_check(this, Uint8ArrayDecoder);\n        return _super.apply(this, arguments);\n    }\n    _create_class(Uint8ArrayDecoder, [\n        {\n            key: \"createByteString\",\n            value: function createByteString(raw) {\n                return concat.apply(void 0, _to_consumable_array(raw));\n            }\n        },\n        {\n            key: \"createByteStringFromHeap\",\n            value: function createByteStringFromHeap(start, end) {\n                if (start === end) {\n                    return new ArrayBuffer(0);\n                }\n                return new Uint8Array(this._heap.slice(start, end));\n            }\n        }\n    ]);\n    return Uint8ArrayDecoder;\n}(borc.Decoder);\nexport function decode(input) {\n    var buffer = new Uint8Array(input);\n    var decoder = new Uint8ArrayDecoder({\n        size: buffer.byteLength,\n        tags: _define_property({\n            2: function(val) {\n                return decodePositiveBigInt(val);\n            },\n            3: function(val) {\n                return -decodePositiveBigInt(val);\n            }\n        }, CborTag.Semantic, function(value) {\n            return value;\n        })\n    });\n    return decoder.decodeFirst(buffer);\n}\n","export function fromHexString(hexString) {\n    var _hexString_match;\n    return new Uint8Array(((_hexString_match = hexString.match(/.{1,2}/g)) !== null && _hexString_match !== void 0 ? _hexString_match : []).map(function(byte) {\n        return parseInt(byte, 16);\n    })).buffer;\n}\nexport function toHexString(bytes) {\n    return new Uint8Array(bytes).reduce(function(str, byte) {\n        return str + byte.toString(16).padStart(2, \"0\");\n    }, \"\");\n}\nexport function isDelegationValid(chain) {\n    var _chain;\n    if (!chain || !((_chain = chain) === null || _chain === void 0 ? void 0 : _chain.delegations)) {\n        return false;\n    }\n    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;\n    try {\n        for(var _iterator = chain.delegations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){\n            var delegation = _step.value.delegation;\n            if (parseInt(delegation.expiration, 16) / 1e6 <= +Date.now()) {\n                return false;\n            }\n        }\n    } catch (err) {\n        _didIteratorError = true;\n        _iteratorError = err;\n    } finally{\n        try {\n            if (!_iteratorNormalCompletion && _iterator.return != null) {\n                _iterator.return();\n            }\n        } finally{\n            if (_didIteratorError) {\n                throw _iteratorError;\n            }\n        }\n    }\n    return true;\n}\n","import * as Cbor from \"./cbor\";\nimport { fromHexString, toHexString } from \"./util\";\nexport function encodeRequest(rpc) {\n    return toHexString(Cbor.encode(rpc));\n}\nexport function decodeResponse(buf) {\n    var decoded = Cbor.decode(fromHexString(buf));\n    if (decoded.error) {\n        throw new Error(JSON.stringify(decoded.error));\n    }\n    return decoded.result;\n}\nexport function rpcBuilder(method) {\n    for(var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){\n        params[_key - 1] = arguments[_key];\n    }\n    return {\n        jsonrpc: \"2.0\",\n        method: method,\n        params: params,\n        id: 0\n    };\n}\nexport function hasOwnProperty(obj, prop) {\n    return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n","function injectChromeBridge() {\n    if (!window.top || window.top === window) {\n        window._astrox_bridge_.bridgeCall = function(bridgeName, encodedParams) {\n            var _callHandlerID = nextId();\n            window.astrox_webview._callHandler(bridgeName, _callHandlerID, JSON.stringify([\n                encodedParams\n            ]));\n            return new Promise(function(resolve, _) {\n                window.astrox_webview[_callHandlerID] = resolve;\n            });\n        };\n    } else {\n        window._astrox_bridge_.bridgeCall = function(bridgeName, encodedParams) {\n            var _callHandlerID = nextId();\n            window.top.astrox_webview._callHandler(bridgeName, _callHandlerID, JSON.stringify([\n                encodedParams\n            ]));\n            return new Promise(function(resolve, _) {\n                window.top.astrox_webview[_callHandlerID] = resolve;\n            });\n        };\n    }\n}\nfunction injectWebKitBridge() {\n    window._astrox_bridge_.bridgeCall = function(bridgeName, encodedParams) {\n        var _windowId = \"window._astrox_webview_windowId\";\n        var _callHandlerID = nextId();\n        window.webkit.messageHandlers[\"callHandler\"].postMessage({\n            handlerName: bridgeName,\n            _callHandlerID: _callHandlerID,\n            args: JSON.stringify([\n                encodedParams\n            ]),\n            _windowId: _windowId\n        });\n        return new Promise(function(resolve, _) {\n            window.astrox_webview[_callHandlerID] = resolve;\n        });\n    };\n}\nexport function injectBridgeIfNeed() {\n    if (window._astrox_bridge_ && window._astrox_bridge_.bridgeCall) {\n        return;\n    }\n    if (!window._astrox_bridge_) {\n        window._astrox_bridge_ = {};\n    }\n    if (window.webkit && window.webkit.messageHandlers) {\n        injectWebKitBridge();\n    } else {\n        injectChromeBridge();\n    }\n}\nexport function nextId() {\n    return setTimeout(null);\n}\n","function _array_like_to_array(arr, len) {\n    if (len == null || len > arr.length) len = arr.length;\n    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];\n    return arr2;\n}\nfunction _array_without_holes(arr) {\n    if (Array.isArray(arr)) return _array_like_to_array(arr);\n}\nfunction asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n    try {\n        var info = gen[key](arg);\n        var value = info.value;\n    } catch (error) {\n        reject(error);\n        return;\n    }\n    if (info.done) {\n        resolve(value);\n    } else {\n        Promise.resolve(value).then(_next, _throw);\n    }\n}\nfunction _async_to_generator(fn) {\n    return function() {\n        var self = this, args = arguments;\n        return new Promise(function(resolve, reject) {\n            var gen = fn.apply(self, args);\n            function _next(value) {\n                asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n            }\n            function _throw(err) {\n                asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n            }\n            _next(undefined);\n        });\n    };\n}\nfunction _class_call_check(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n        throw new TypeError(\"Cannot call a class as a function\");\n    }\n}\nfunction _defineProperties(target, props) {\n    for(var i = 0; i < props.length; i++){\n        var descriptor = props[i];\n        descriptor.enumerable = descriptor.enumerable || false;\n        descriptor.configurable = true;\n        if (\"value\" in descriptor) descriptor.writable = true;\n        Object.defineProperty(target, descriptor.key, descriptor);\n    }\n}\nfunction _create_class(Constructor, protoProps, staticProps) {\n    if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) _defineProperties(Constructor, staticProps);\n    return Constructor;\n}\nfunction _define_property(obj, key, value) {\n    if (key in obj) {\n        Object.defineProperty(obj, key, {\n            value: value,\n            enumerable: true,\n            configurable: true,\n            writable: true\n        });\n    } else {\n        obj[key] = value;\n    }\n    return obj;\n}\nfunction _iterable_to_array(iter) {\n    if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\nfunction _non_iterable_spread() {\n    throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nfunction _to_consumable_array(arr) {\n    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();\n}\nfunction _unsupported_iterable_to_array(o, minLen) {\n    if (!o) return;\n    if (typeof o === \"string\") return _array_like_to_array(o, minLen);\n    var n = Object.prototype.toString.call(o).slice(8, -1);\n    if (n === \"Object\" && o.constructor) n = o.constructor.name;\n    if (n === \"Map\" || n === \"Set\") return Array.from(n);\n    if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);\n}\nfunction _ts_generator(thisArg, body) {\n    var f, y, t, g, _ = {\n        label: 0,\n        sent: function() {\n            if (t[0] & 1) throw t[1];\n            return t[1];\n        },\n        trys: [],\n        ops: []\n    };\n    return g = {\n        next: verb(0),\n        \"throw\": verb(1),\n        \"return\": verb(2)\n    }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() {\n        return this;\n    }), g;\n    function verb(n) {\n        return function(v) {\n            return step([\n                n,\n                v\n            ]);\n        };\n    }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while(_)try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [\n                op[0] & 2,\n                t.value\n            ];\n            switch(op[0]){\n                case 0:\n                case 1:\n                    t = op;\n                    break;\n                case 4:\n                    _.label++;\n                    return {\n                        value: op[1],\n                        done: false\n                    };\n                case 5:\n                    _.label++;\n                    y = op[1];\n                    op = [\n                        0\n                    ];\n                    continue;\n                case 7:\n                    op = _.ops.pop();\n                    _.trys.pop();\n                    continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {\n                        _ = 0;\n                        continue;\n                    }\n                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {\n                        _.label = op[1];\n                        break;\n                    }\n                    if (op[0] === 6 && _.label < t[1]) {\n                        _.label = t[1];\n                        t = op;\n                        break;\n                    }\n                    if (t && _.label < t[2]) {\n                        _.label = t[2];\n                        _.ops.push(op);\n                        break;\n                    }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop();\n                    continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) {\n            op = [\n                6,\n                e\n            ];\n            y = 0;\n        } finally{\n            f = t = 0;\n        }\n        if (op[0] & 5) throw op[1];\n        return {\n            value: op[0] ? op[1] : void 0,\n            done: true\n        };\n    }\n}\nimport { decodeResponse, encodeRequest, rpcBuilder } from \"./adapter\";\nimport { injectBridgeIfNeed, nextId } from \"./bridge\";\nexport var MethodBuilder = function() {\n    \"use strict\";\n    function MethodBuilder(bridge, method) {\n        _class_call_check(this, MethodBuilder);\n        _define_property(this, \"bridge\", void 0);\n        _define_property(this, \"method\", void 0);\n        this.bridge = bridge;\n        this.method = method;\n    }\n    _create_class(MethodBuilder, [\n        {\n            key: \"invoke\",\n            value: function invoke() {\n                for(var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++){\n                    params[_key] = arguments[_key];\n                }\n                var _this = this;\n                return _async_to_generator(function() {\n                    var request, result;\n                    return _ts_generator(this, function(_state) {\n                        switch(_state.label){\n                            case 0:\n                                injectBridgeIfNeed();\n                                request = rpcBuilder.apply(void 0, [\n                                    _this.method\n                                ].concat(_to_consumable_array(params)));\n                                request.id = nextId();\n                                return [\n                                    4,\n                                    window._astrox_bridge_.bridgeCall(_this.bridge, encodeRequest(request))\n                                ];\n                            case 1:\n                                result = _state.sent();\n                                return [\n                                    2,\n                                    decodeResponse(result)\n                                ];\n                        }\n                    });\n                })();\n            }\n        }\n    ]);\n    return MethodBuilder;\n}();\n","export var TransactionMessageKind;\n(function(TransactionMessageKind) {\n    TransactionMessageKind[\"success\"] = \"transaction-client-success\";\n    TransactionMessageKind[\"fail\"] = \"transaction-client-failure\";\n})(TransactionMessageKind || (TransactionMessageKind = {}));\nexport var TransactionType;\n(function(TransactionType) {\n    TransactionType[\"token\"] = \"token\";\n    TransactionType[\"nft\"] = \"nft\";\n})(TransactionType || (TransactionType = {}));\n","import { MethodBuilder } from \"@astrox/sdk-webview-bridge\";\nvar bridgeHandler = \"bridgeCall\";\nexport var init = new MethodBuilder(bridgeHandler, \"init\");\nexport var connect = new MethodBuilder(bridgeHandler, \"connect\");\nexport var isConnected = new MethodBuilder(bridgeHandler, \"isConnected\");\nexport var disconnect = new MethodBuilder(bridgeHandler, \"disconnect\");\nexport var signMessage = new MethodBuilder(bridgeHandler, \"signMessage\");\nexport var requestTransfer = new MethodBuilder(bridgeHandler, \"requestTransfer\");\nexport var queryBalance = new MethodBuilder(bridgeHandler, \"queryBalance\");\nexport var appendAuth = new MethodBuilder(bridgeHandler, \"appendAuth\");\nexport var supportedStandardList = new MethodBuilder(bridgeHandler, \"supportedStandardList\");\n","function _array_like_to_array(arr, len) {\n    if (len == null || len > arr.length) len = arr.length;\n    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];\n    return arr2;\n}\nfunction _array_without_holes(arr) {\n    if (Array.isArray(arr)) return _array_like_to_array(arr);\n}\nfunction _assert_this_initialized(self) {\n    if (self === void 0) {\n        throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n    }\n    return self;\n}\nfunction asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n    try {\n        var info = gen[key](arg);\n        var value = info.value;\n    } catch (error) {\n        reject(error);\n        return;\n    }\n    if (info.done) {\n        resolve(value);\n    } else {\n        Promise.resolve(value).then(_next, _throw);\n    }\n}\nfunction _async_to_generator(fn) {\n    return function() {\n        var self = this, args = arguments;\n        return new Promise(function(resolve, reject) {\n            var gen = fn.apply(self, args);\n            function _next(value) {\n                asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n            }\n            function _throw(err) {\n                asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n            }\n            _next(undefined);\n        });\n    };\n}\nfunction _check_private_redeclaration(obj, privateCollection) {\n    if (privateCollection.has(obj)) {\n        throw new TypeError(\"Cannot initialize the same private elements twice on an object\");\n    }\n}\nfunction _class_apply_descriptor_get(receiver, descriptor) {\n    if (descriptor.get) {\n        return descriptor.get.call(receiver);\n    }\n    return descriptor.value;\n}\nfunction _class_apply_descriptor_set(receiver, descriptor, value) {\n    if (descriptor.set) {\n        descriptor.set.call(receiver, value);\n    } else {\n        if (!descriptor.writable) {\n            throw new TypeError(\"attempted to set read only private field\");\n        }\n        descriptor.value = value;\n    }\n}\nfunction _class_call_check(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n        throw new TypeError(\"Cannot call a class as a function\");\n    }\n}\nfunction _class_extract_field_descriptor(receiver, privateMap, action) {\n    if (!privateMap.has(receiver)) {\n        throw new TypeError(\"attempted to \" + action + \" private field on non-instance\");\n    }\n    return privateMap.get(receiver);\n}\nfunction _class_private_field_get(receiver, privateMap) {\n    var descriptor = _class_extract_field_descriptor(receiver, privateMap, \"get\");\n    return _class_apply_descriptor_get(receiver, descriptor);\n}\nfunction _class_private_field_init(obj, privateMap, value) {\n    _check_private_redeclaration(obj, privateMap);\n    privateMap.set(obj, value);\n}\nfunction _class_private_field_set(receiver, privateMap, value) {\n    var descriptor = _class_extract_field_descriptor(receiver, privateMap, \"set\");\n    _class_apply_descriptor_set(receiver, descriptor, value);\n    return value;\n}\nfunction _defineProperties(target, props) {\n    for(var i = 0; i < props.length; i++){\n        var descriptor = props[i];\n        descriptor.enumerable = descriptor.enumerable || false;\n        descriptor.configurable = true;\n        if (\"value\" in descriptor) descriptor.writable = true;\n        Object.defineProperty(target, descriptor.key, descriptor);\n    }\n}\nfunction _create_class(Constructor, protoProps, staticProps) {\n    if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) _defineProperties(Constructor, staticProps);\n    return Constructor;\n}\nfunction _define_property(obj, key, value) {\n    if (key in obj) {\n        Object.defineProperty(obj, key, {\n            value: value,\n            enumerable: true,\n            configurable: true,\n            writable: true\n        });\n    } else {\n        obj[key] = value;\n    }\n    return obj;\n}\nfunction _get_prototype_of(o) {\n    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {\n        return o.__proto__ || Object.getPrototypeOf(o);\n    };\n    return _get_prototype_of(o);\n}\nfunction _inherits(subClass, superClass) {\n    if (typeof superClass !== \"function\" && superClass !== null) {\n        throw new TypeError(\"Super expression must either be null or a function\");\n    }\n    subClass.prototype = Object.create(superClass && superClass.prototype, {\n        constructor: {\n            value: subClass,\n            writable: true,\n            configurable: true\n        }\n    });\n    if (superClass) _set_prototype_of(subClass, superClass);\n}\nfunction _iterable_to_array(iter) {\n    if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\nfunction _non_iterable_spread() {\n    throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nfunction _object_spread(target) {\n    for(var i = 1; i < arguments.length; i++){\n        var source = arguments[i] != null ? arguments[i] : {};\n        var ownKeys = Object.keys(source);\n        if (typeof Object.getOwnPropertySymbols === \"function\") {\n            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {\n                return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n            }));\n        }\n        ownKeys.forEach(function(key) {\n            _define_property(target, key, source[key]);\n        });\n    }\n    return target;\n}\nfunction ownKeys(object, enumerableOnly) {\n    var keys = Object.keys(object);\n    if (Object.getOwnPropertySymbols) {\n        var symbols = Object.getOwnPropertySymbols(object);\n        if (enumerableOnly) {\n            symbols = symbols.filter(function(sym) {\n                return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n            });\n        }\n        keys.push.apply(keys, symbols);\n    }\n    return keys;\n}\nfunction _object_spread_props(target, source) {\n    source = source != null ? source : {};\n    if (Object.getOwnPropertyDescriptors) {\n        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n        ownKeys(Object(source)).forEach(function(key) {\n            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n        });\n    }\n    return target;\n}\nfunction _object_without_properties(source, excluded) {\n    if (source == null) return {};\n    var target = _object_without_properties_loose(source, excluded);\n    var key, i;\n    if (Object.getOwnPropertySymbols) {\n        var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n        for(i = 0; i < sourceSymbolKeys.length; i++){\n            key = sourceSymbolKeys[i];\n            if (excluded.indexOf(key) >= 0) continue;\n            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n            target[key] = source[key];\n        }\n    }\n    return target;\n}\nfunction _object_without_properties_loose(source, excluded) {\n    if (source == null) return {};\n    var target = {};\n    var sourceKeys = Object.keys(source);\n    var key, i;\n    for(i = 0; i < sourceKeys.length; i++){\n        key = sourceKeys[i];\n        if (excluded.indexOf(key) >= 0) continue;\n        target[key] = source[key];\n    }\n    return target;\n}\nfunction _possible_constructor_return(self, call) {\n    if (call && (_type_of(call) === \"object\" || typeof call === \"function\")) {\n        return call;\n    }\n    return _assert_this_initialized(self);\n}\nfunction _set_prototype_of(o, p) {\n    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {\n        o.__proto__ = p;\n        return o;\n    };\n    return _set_prototype_of(o, p);\n}\nfunction _to_consumable_array(arr) {\n    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();\n}\nfunction _type_of(obj) {\n    \"@swc/helpers - typeof\";\n    return obj && typeof Symbol !== \"undefined\" && obj.constructor === Symbol ? \"symbol\" : typeof obj;\n}\nfunction _unsupported_iterable_to_array(o, minLen) {\n    if (!o) return;\n    if (typeof o === \"string\") return _array_like_to_array(o, minLen);\n    var n = Object.prototype.toString.call(o).slice(8, -1);\n    if (n === \"Object\" && o.constructor) n = o.constructor.name;\n    if (n === \"Map\" || n === \"Set\") return Array.from(n);\n    if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);\n}\nfunction _is_native_reflect_construct() {\n    if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n    if (Reflect.construct.sham) return false;\n    if (typeof Proxy === \"function\") return true;\n    try {\n        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));\n        return true;\n    } catch (e) {\n        return false;\n    }\n}\nfunction _create_super(Derived) {\n    var hasNativeReflectConstruct = _is_native_reflect_construct();\n    return function _createSuperInternal() {\n        var Super = _get_prototype_of(Derived), result;\n        if (hasNativeReflectConstruct) {\n            var NewTarget = _get_prototype_of(this).constructor;\n            result = Reflect.construct(Super, arguments, NewTarget);\n        } else {\n            result = Super.apply(this, arguments);\n        }\n        return _possible_constructor_return(this, result);\n    };\n}\nfunction _ts_generator(thisArg, body) {\n    var f, y, t, g, _ = {\n        label: 0,\n        sent: function() {\n            if (t[0] & 1) throw t[1];\n            return t[1];\n        },\n        trys: [],\n        ops: []\n    };\n    return g = {\n        next: verb(0),\n        \"throw\": verb(1),\n        \"return\": verb(2)\n    }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() {\n        return this;\n    }), g;\n    function verb(n) {\n        return function(v) {\n            return step([\n                n,\n                v\n            ]);\n        };\n    }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while(_)try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [\n                op[0] & 2,\n                t.value\n            ];\n            switch(op[0]){\n                case 0:\n                case 1:\n                    t = op;\n                    break;\n                case 4:\n                    _.label++;\n                    return {\n                        value: op[1],\n                        done: false\n                    };\n                case 5:\n                    _.label++;\n                    y = op[1];\n                    op = [\n                        0\n                    ];\n                    continue;\n                case 7:\n                    op = _.ops.pop();\n                    _.trys.pop();\n                    continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {\n                        _ = 0;\n                        continue;\n                    }\n                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {\n                        _.label = op[1];\n                        break;\n                    }\n                    if (op[0] === 6 && _.label < t[1]) {\n                        _.label = t[1];\n                        t = op;\n                        break;\n                    }\n                    if (t && _.label < t[2]) {\n                        _.label = t[2];\n                        _.ops.push(op);\n                        break;\n                    }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop();\n                    continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) {\n            op = [\n                6,\n                e\n            ];\n            y = 0;\n        } finally{\n            f = t = 0;\n        }\n        if (op[0] & 5) throw op[1];\n        return {\n            value: op[0] ? op[1] : void 0,\n            done: true\n        };\n    }\n}\nimport { requestIdOf, SignIdentity } from \"@dfinity/agent\";\nimport { Principal } from \"@dfinity/principal\";\nimport { fromHexString, toHexString } from \"@astrox/sdk-webview-bridge\";\nimport * as _ms from \"./methods\";\nvar _principal = new WeakMap();\nexport var AstroXIdentity = function(SignIdentity1) {\n    \"use strict\";\n    _inherits(AstroXIdentity, SignIdentity1);\n    var _super = _create_super(AstroXIdentity);\n    function AstroXIdentity(_cacheKey, _chain) {\n        _class_call_check(this, AstroXIdentity);\n        var _this;\n        _this = _super.call(this);\n        _define_property(_assert_this_initialized(_this), \"_cacheKey\", void 0);\n        _define_property(_assert_this_initialized(_this), \"_chain\", void 0);\n        _class_private_field_init(_assert_this_initialized(_this), _principal, {\n            writable: true,\n            value: void 0\n        });\n        _this._cacheKey = _cacheKey;\n        _this._chain = _chain;\n        return _this;\n    }\n    _create_class(AstroXIdentity, [\n        {\n            key: \"getPublicKey\",\n            value: function getPublicKey() {\n                var _this = this;\n                return {\n                    toDer: function() {\n                        return _this._chain.publicKey;\n                    }\n                };\n            }\n        },\n        {\n            key: \"getPrincipal\",\n            value: function getPrincipal() {\n                if (!_class_private_field_get(this, _principal)) {\n                    _class_private_field_set(this, _principal, Principal.selfAuthenticating(new Uint8Array(this.getPublicKey().toDer())));\n                }\n                return _class_private_field_get(this, _principal);\n            }\n        },\n        {\n            key: \"sign\",\n            value: function sign(blob) {\n                var _this = this;\n                return _async_to_generator(function() {\n                    var hex, signedResponse, error;\n                    return _ts_generator(this, function(_state) {\n                        switch(_state.label){\n                            case 0:\n                                _state.trys.push([\n                                    0,\n                                    2,\n                                    ,\n                                    3\n                                ]);\n                                hex = toHexString(blob);\n                                return [\n                                    4,\n                                    _ms.signMessage.invoke(_this._cacheKey, hex)\n                                ];\n                            case 1:\n                                signedResponse = _state.sent();\n                                return [\n                                    2,\n                                    fromHexString(signedResponse)\n                                ];\n                            case 2:\n                                error = _state.sent();\n                                throw new Error(\"signing message error: \".concat(error.message));\n                            case 3:\n                                return [\n                                    2\n                                ];\n                        }\n                    });\n                })();\n            }\n        },\n        {\n            key: \"transformRequest\",\n            value: function transformRequest(request) {\n                var _this = this;\n                return _async_to_generator(function() {\n                    var body, fields, requestId, requestDomainSeparator, _tmp, _tmp1, _tmp2;\n                    return _ts_generator(this, function(_state) {\n                        switch(_state.label){\n                            case 0:\n                                body = request.body, fields = _object_without_properties(request, [\n                                    \"body\"\n                                ]);\n                                return [\n                                    4,\n                                    requestIdOf(body)\n                                ];\n                            case 1:\n                                requestId = _state.sent();\n                                requestDomainSeparator = new TextEncoder().encode(\"\\nic-request\");\n                                _tmp = [\n                                    _object_spread({}, fields)\n                                ];\n                                _tmp1 = {};\n                                _tmp2 = {\n                                    content: body\n                                };\n                                return [\n                                    4,\n                                    _this.sign(new Uint8Array(_to_consumable_array(requestDomainSeparator).concat(_to_consumable_array(new Uint8Array(requestId)))))\n                                ];\n                            case 2:\n                                return [\n                                    2,\n                                    _object_spread_props.apply(void 0, _tmp.concat([\n                                        (_tmp1.body = (_tmp2.sender_sig = _state.sent(), _tmp2.sender_delegation = _this._chain.delegations, _tmp2.sender_pubkey = _this._chain.publicKey, _tmp2), _tmp1)\n                                    ]))\n                                ];\n                        }\n                    });\n                })();\n            }\n        }\n    ]);\n    return AstroXIdentity;\n}(SignIdentity);\n","function _class_call_check(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n        throw new TypeError(\"Cannot call a class as a function\");\n    }\n}\nfunction _defineProperties(target, props) {\n    for(var i = 0; i < props.length; i++){\n        var descriptor = props[i];\n        descriptor.enumerable = descriptor.enumerable || false;\n        descriptor.configurable = true;\n        if (\"value\" in descriptor) descriptor.writable = true;\n        Object.defineProperty(target, descriptor.key, descriptor);\n    }\n}\nfunction _create_class(Constructor, protoProps, staticProps) {\n    if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) _defineProperties(Constructor, staticProps);\n    return Constructor;\n}\nfunction _define_property(obj, key, value) {\n    if (key in obj) {\n        Object.defineProperty(obj, key, {\n            value: value,\n            enumerable: true,\n            configurable: true,\n            writable: true\n        });\n    } else {\n        obj[key] = value;\n    }\n    return obj;\n}\nexport var BridgeErrors = function() {\n    \"use strict\";\n    function BridgeErrors() {\n        _class_call_check(this, BridgeErrors);\n    }\n    _create_class(BridgeErrors, null, [\n        {\n            key: \"fromErrorCode\",\n            value: function fromErrorCode(code) {\n                var kind = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : BridgeErrors.defaultErrorKind, message = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : BridgeErrors.defaultErrorMessage;\n                var defaultReturn = {\n                    kind: kind,\n                    text: \"Unknown Error\"\n                };\n                switch(code){\n                    case BridgeErrors.bridgeUnknownError:\n                        return {\n                            kind: kind,\n                            text: \"Unknown Error: \".concat(message)\n                        };\n                    case BridgeErrors.bridgeIllegalArguments:\n                        return {\n                            kind: kind,\n                            text: \"Illegal Arguments: \".concat(message)\n                        };\n                    case BridgeErrors.bridgeIllegalState:\n                        return {\n                            kind: kind,\n                            text: \"Illegal State: \".concat(message)\n                        };\n                    case BridgeErrors.bridgeUnsupportedError:\n                        return {\n                            kind: kind,\n                            text: \"Unsupported Error: \".concat(message)\n                        };\n                    case BridgeErrors.bridgeIdentityNotFound:\n                        return {\n                            kind: kind,\n                            text: \"Identity Not Found: \".concat(message)\n                        };\n                    case BridgeErrors.bridgeIdentityExpired:\n                        return {\n                            kind: kind,\n                            text: \"Identity Expired: \".concat(message)\n                        };\n                    case BridgeErrors.bridgeWalletNotFound:\n                        return {\n                            kind: kind,\n                            text: \"Wallet Not Found: \".concat(message)\n                        };\n                    case BridgeErrors.bridgeOperationCancelled:\n                        return {\n                            kind: kind,\n                            text: \"Operation Cancelled: \".concat(message)\n                        };\n                    case BridgeErrors.bridgeNFTIdentifierError:\n                        return {\n                            kind: kind,\n                            text: \"NFT Identifier Error: \".concat(message)\n                        };\n                    case BridgeErrors.bridgeUnknownMethod:\n                        return {\n                            kind: kind,\n                            text: \"Unknown method: \".concat(message)\n                        };\n                    default:\n                        return defaultReturn;\n                }\n            }\n        }\n    ]);\n    return BridgeErrors;\n}();\n_define_property(BridgeErrors, \"bridgeUnknownError\", 50000);\n_define_property(BridgeErrors, \"bridgeIllegalArguments\", 50001);\n_define_property(BridgeErrors, \"bridgeIllegalState\", 50002);\n_define_property(BridgeErrors, \"bridgeUnsupportedError\", 50003);\n_define_property(BridgeErrors, \"bridgeIdentityNotFound\", 50004);\n_define_property(BridgeErrors, \"bridgeIdentityExpired\", 50005);\n_define_property(BridgeErrors, \"bridgeWalletNotFound\", 50006);\n_define_property(BridgeErrors, \"bridgeOperationCancelled\", 50007);\n_define_property(BridgeErrors, \"bridgeNFTIdentifierError\", 50008);\n_define_property(BridgeErrors, \"bridgeUnknownMethod\", 50009);\n_define_property(BridgeErrors, \"defaultErrorKind\", \"JS-SDK-Error\");\n_define_property(BridgeErrors, \"defaultErrorMessage\", \"No More Detail\");\n","function _class_call_check(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n        throw new TypeError(\"Cannot call a class as a function\");\n    }\n}\nfunction _defineProperties(target, props) {\n    for(var i = 0; i < props.length; i++){\n        var descriptor = props[i];\n        descriptor.enumerable = descriptor.enumerable || false;\n        descriptor.configurable = true;\n        if (\"value\" in descriptor) descriptor.writable = true;\n        Object.defineProperty(target, descriptor.key, descriptor);\n    }\n}\nfunction _create_class(Constructor, protoProps, staticProps) {\n    if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) _defineProperties(Constructor, staticProps);\n    return Constructor;\n}\nimport { SelfDescribeCborSerializer, value } from \"simple-cbor\";\nvar PrincipalEncoder = function() {\n    \"use strict\";\n    function PrincipalEncoder() {\n        _class_call_check(this, PrincipalEncoder);\n    }\n    _create_class(PrincipalEncoder, [\n        {\n            key: \"name\",\n            get: function get() {\n                return \"Principal\";\n            }\n        },\n        {\n            key: \"priority\",\n            get: function get() {\n                return 0;\n            }\n        },\n        {\n            key: \"match\",\n            value: function match(value) {\n                return value && value._isPrincipal === true;\n            }\n        },\n        {\n            key: \"encode\",\n            value: function encode(v) {\n                return value.bytes(v.toUint8Array());\n            }\n        }\n    ]);\n    return PrincipalEncoder;\n}();\nvar serializer = SelfDescribeCborSerializer.withDefaultEncoders(true);\nserializer.addEncoder(new PrincipalEncoder());\n","function _array_like_to_array(arr, len) {\n    if (len == null || len > arr.length) len = arr.length;\n    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];\n    return arr2;\n}\nfunction _array_without_holes(arr) {\n    if (Array.isArray(arr)) return _array_like_to_array(arr);\n}\nfunction asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n    try {\n        var info = gen[key](arg);\n        var value = info.value;\n    } catch (error) {\n        reject(error);\n        return;\n    }\n    if (info.done) {\n        resolve(value);\n    } else {\n        Promise.resolve(value).then(_next, _throw);\n    }\n}\nfunction _async_to_generator(fn) {\n    return function() {\n        var self = this, args = arguments;\n        return new Promise(function(resolve, reject) {\n            var gen = fn.apply(self, args);\n            function _next(value) {\n                asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n            }\n            function _throw(err) {\n                asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n            }\n            _next(undefined);\n        });\n    };\n}\nfunction _class_call_check(instance, Constructor) {\n    if (!(instance instanceof Constructor)) {\n        throw new TypeError(\"Cannot call a class as a function\");\n    }\n}\nfunction _defineProperties(target, props) {\n    for(var i = 0; i < props.length; i++){\n        var descriptor = props[i];\n        descriptor.enumerable = descriptor.enumerable || false;\n        descriptor.configurable = true;\n        if (\"value\" in descriptor) descriptor.writable = true;\n        Object.defineProperty(target, descriptor.key, descriptor);\n    }\n}\nfunction _create_class(Constructor, protoProps, staticProps) {\n    if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) _defineProperties(Constructor, staticProps);\n    return Constructor;\n}\nfunction _define_property(obj, key, value) {\n    if (key in obj) {\n        Object.defineProperty(obj, key, {\n            value: value,\n            enumerable: true,\n            configurable: true,\n            writable: true\n        });\n    } else {\n        obj[key] = value;\n    }\n    return obj;\n}\nfunction _instanceof(left, right) {\n    if (right != null && typeof Symbol !== \"undefined\" && right[Symbol.hasInstance]) {\n        return !!right[Symbol.hasInstance](left);\n    } else {\n        return left instanceof right;\n    }\n}\nfunction _iterable_to_array(iter) {\n    if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\nfunction _non_iterable_spread() {\n    throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nfunction _object_spread(target) {\n    for(var i = 1; i < arguments.length; i++){\n        var source = arguments[i] != null ? arguments[i] : {};\n        var ownKeys = Object.keys(source);\n        if (typeof Object.getOwnPropertySymbols === \"function\") {\n            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {\n                return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n            }));\n        }\n        ownKeys.forEach(function(key) {\n            _define_property(target, key, source[key]);\n        });\n    }\n    return target;\n}\nfunction ownKeys(object, enumerableOnly) {\n    var keys = Object.keys(object);\n    if (Object.getOwnPropertySymbols) {\n        var symbols = Object.getOwnPropertySymbols(object);\n        if (enumerableOnly) {\n            symbols = symbols.filter(function(sym) {\n                return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n            });\n        }\n        keys.push.apply(keys, symbols);\n    }\n    return keys;\n}\nfunction _object_spread_props(target, source) {\n    source = source != null ? source : {};\n    if (Object.getOwnPropertyDescriptors) {\n        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n        ownKeys(Object(source)).forEach(function(key) {\n            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n        });\n    }\n    return target;\n}\nfunction _to_consumable_array(arr) {\n    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();\n}\nfunction _type_of(obj) {\n    \"@swc/helpers - typeof\";\n    return obj && typeof Symbol !== \"undefined\" && obj.constructor === Symbol ? \"symbol\" : typeof obj;\n}\nfunction _unsupported_iterable_to_array(o, minLen) {\n    if (!o) return;\n    if (typeof o === \"string\") return _array_like_to_array(o, minLen);\n    var n = Object.prototype.toString.call(o).slice(8, -1);\n    if (n === \"Object\" && o.constructor) n = o.constructor.name;\n    if (n === \"Map\" || n === \"Set\") return Array.from(n);\n    if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);\n}\nfunction _ts_generator(thisArg, body) {\n    var f, y, t, g, _ = {\n        label: 0,\n        sent: function() {\n            if (t[0] & 1) throw t[1];\n            return t[1];\n        },\n        trys: [],\n        ops: []\n    };\n    return g = {\n        next: verb(0),\n        \"throw\": verb(1),\n        \"return\": verb(2)\n    }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() {\n        return this;\n    }), g;\n    function verb(n) {\n        return function(v) {\n            return step([\n                n,\n                v\n            ]);\n        };\n    }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while(_)try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [\n                op[0] & 2,\n                t.value\n            ];\n            switch(op[0]){\n                case 0:\n                case 1:\n                    t = op;\n                    break;\n                case 4:\n                    _.label++;\n                    return {\n                        value: op[1],\n                        done: false\n                    };\n                case 5:\n                    _.label++;\n                    y = op[1];\n                    op = [\n                        0\n                    ];\n                    continue;\n                case 7:\n                    op = _.ops.pop();\n                    _.trys.pop();\n                    continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {\n                        _ = 0;\n                        continue;\n                    }\n                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {\n                        _.label = op[1];\n                        break;\n                    }\n                    if (op[0] === 6 && _.label < t[1]) {\n                        _.label = t[1];\n                        t = op;\n                        break;\n                    }\n                    if (t && _.label < t[2]) {\n                        _.label = t[2];\n                        _.ops.push(op);\n                        break;\n                    }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop();\n                    continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) {\n            op = [\n                6,\n                e\n            ];\n            y = 0;\n        } finally{\n            f = t = 0;\n        }\n        if (op[0] & 5) throw op[1];\n        return {\n            value: op[0] ? op[1] : void 0,\n            done: true\n        };\n    }\n}\nimport { DelegationChain } from \"@dfinity/identity\";\nimport { Actor, HttpAgent } from \"@dfinity/agent\";\nimport { isDelegationValid } from \"./util\";\nimport { ICStorage } from \"./storage\";\nimport * as _ms from \"./methods\";\nimport { TransactionMessageKind, TransactionType } from \"./types\";\nimport { AstroXIdentity } from \"./identity\";\nimport { BridgeErrors } from \"./errors\";\nimport \"./cbor\";\nvar KEY_ICSTORAGE_CACHEKEY = \"cacheKey\";\nvar KEY_ICSTORAGE_CHAIN = \"chain\";\nvar KEY_ICSTORAGE_WALLET = \"wallet\";\nvar KEY_ICSTORAGE_CONFIRM = \"confirm\";\nvar KEY_ICSTORAGE_HOST = \"host\";\nvar KEY_CUSTOM_DOMAIN = \"customDomain\";\nexport var AstroXWebViewHandler = function() {\n    \"use strict\";\n    function AstroXWebViewHandler(_identity, _agent, _chain, _storage, _cacheKey, _wallet, _confirm, _host, _customDomain) {\n        _class_call_check(this, AstroXWebViewHandler);\n        _define_property(this, \"_identity\", void 0);\n        _define_property(this, \"_agent\", void 0);\n        _define_property(this, \"_chain\", void 0);\n        _define_property(this, \"_storage\", void 0);\n        _define_property(this, \"_cacheKey\", void 0);\n        _define_property(this, \"_wallet\", void 0);\n        _define_property(this, \"_confirm\", void 0);\n        _define_property(this, \"_host\", void 0);\n        _define_property(this, \"_customDomain\", void 0);\n        _define_property(this, \"principal\", void 0);\n        _define_property(this, \"_isReady\", void 0);\n        _define_property(this, \"config\", void 0);\n        _define_property(this, \"createActor\", void 0);\n        this._identity = _identity;\n        this._agent = _agent;\n        this._chain = _chain;\n        this._storage = _storage;\n        this._cacheKey = _cacheKey;\n        this._wallet = _wallet;\n        this._confirm = _confirm;\n        this._host = _host;\n        this._customDomain = _customDomain;\n        this._isReady = false;\n        var _this = this;\n        this.createActor = function() {\n            var _ref = _async_to_generator(function(canisterId, idlFactory) {\n                var authed, _;\n                return _ts_generator(this, function(_state) {\n                    switch(_state.label){\n                        case 0:\n                            _this._assertEnv();\n                            if (!_this._confirm) return [\n                                3,\n                                2\n                            ];\n                            _ = _this._handleWebViewConnectResponse;\n                            return [\n                                4,\n                                _ms.appendAuth.invoke(_this._cacheKey, _this._wallet, [\n                                    canisterId\n                                ])\n                            ];\n                        case 1:\n                            authed = _.apply(_this, [\n                                _state.sent(),\n                                _this.host,\n                                _this.customDomain\n                            ]);\n                            if (!authed) {\n                                throw new Error(\"User cancel authorization\");\n                            }\n                            _state.label = 2;\n                        case 2:\n                            return [\n                                2,\n                                Actor.createActor(idlFactory, {\n                                    agent: _this._agent,\n                                    canisterId: canisterId\n                                })\n                            ];\n                    }\n                });\n            });\n            return function(canisterId, idlFactory) {\n                return _ref.apply(this, arguments);\n            };\n        }();\n        this._injectWindow();\n    }\n    _create_class(AstroXWebViewHandler, [\n        {\n            key: \"setCacheKey\",\n            value: function setCacheKey(value) {\n                this._cacheKey = value;\n                this._storage.set(KEY_ICSTORAGE_CACHEKEY, value);\n            }\n        },\n        {\n            key: \"cacheKey\",\n            get: function get() {\n                return this._cacheKey;\n            }\n        },\n        {\n            key: \"setWallet\",\n            value: function setWallet(value) {\n                this._wallet = value;\n                this._storage.set(KEY_ICSTORAGE_WALLET, JSON.stringify(_object_spread({}, value)));\n            }\n        },\n        {\n            key: \"wallet\",\n            get: function get() {\n                return this._wallet;\n            }\n        },\n        {\n            key: \"setChain\",\n            value: function setChain(value) {\n                var _value;\n                this._chain = value;\n                this._storage.set(KEY_ICSTORAGE_CHAIN, JSON.stringify((_value = value) === null || _value === void 0 ? void 0 : _value.toJSON()));\n            }\n        },\n        {\n            key: \"chain\",\n            get: function get() {\n                return this._chain;\n            }\n        },\n        {\n            key: \"setConfirm\",\n            value: function setConfirm(value) {\n                this._confirm = value;\n                this._storage.set(KEY_ICSTORAGE_CONFIRM, String(value));\n            }\n        },\n        {\n            key: \"confirm\",\n            get: function get() {\n                return this._confirm;\n            }\n        },\n        {\n            key: \"setIdentity\",\n            value: function setIdentity(value) {\n                this._identity = value;\n            }\n        },\n        {\n            key: \"identity\",\n            get: function get() {\n                return this._identity;\n            }\n        },\n        {\n            key: \"setAgent\",\n            value: function setAgent(value) {\n                this._agent = value;\n            }\n        },\n        {\n            key: \"setHost\",\n            value: function setHost(host) {\n                this._host = host;\n                this._storage.set(KEY_ICSTORAGE_HOST, String(host));\n            }\n        },\n        {\n            key: \"setCustomDomain\",\n            value: function setCustomDomain(customDomain) {\n                this._customDomain = customDomain;\n                this._storage.set(KEY_CUSTOM_DOMAIN, String(customDomain));\n            }\n        },\n        {\n            key: \"host\",\n            get: function get() {\n                return this._host;\n            }\n        },\n        {\n            key: \"customDomain\",\n            get: function get() {\n                return this._customDomain;\n            }\n        },\n        {\n            key: \"agent\",\n            get: function get() {\n                return this._agent;\n            }\n        },\n        {\n            key: \"setStorage\",\n            value: function setStorage(storage) {\n                this._storage = storage;\n            }\n        },\n        {\n            key: \"storage\",\n            get: function get() {\n                return this._storage;\n            }\n        },\n        {\n            key: \"clear\",\n            value: function clear() {\n                this._cacheKey = undefined;\n                this._confirm = undefined;\n                this._chain = undefined;\n                this._wallet = undefined;\n                this._identity = undefined;\n                this._agent = undefined;\n                this._storage.remove(KEY_ICSTORAGE_CACHEKEY);\n                this._storage.remove(KEY_ICSTORAGE_WALLET);\n                this._storage.remove(KEY_ICSTORAGE_CHAIN);\n                this._storage.remove(KEY_ICSTORAGE_CONFIRM);\n                this._storage.remove(KEY_ICSTORAGE_HOST);\n                this._storage.remove(KEY_CUSTOM_DOMAIN);\n            }\n        },\n        {\n            key: \"_injectWindow\",\n            value: function _injectWindow() {\n                window.icx = this;\n            }\n        },\n        {\n            key: \"_initBridge\",\n            value: function _initBridge() {\n                var _this = this;\n                return _async_to_generator(function() {\n                    var e;\n                    return _ts_generator(this, function(_state) {\n                        switch(_state.label){\n                            case 0:\n                                _state.trys.push([\n                                    0,\n                                    2,\n                                    ,\n                                    3\n                                ]);\n                                return [\n                                    4,\n                                    _this.fromStorage()\n                                ];\n                            case 1:\n                                _state.sent();\n                                _this._isReady = true;\n                                return [\n                                    3,\n                                    3\n                                ];\n                            case 2:\n                                e = _state.sent();\n                                console.log(\"AstroXWebViewBridge occurs error:\", e);\n                                throw e;\n                            case 3:\n                                return [\n                                    2\n                                ];\n                        }\n                    });\n                })();\n            }\n        },\n        {\n            key: \"fromStorage\",\n            value: function fromStorage() {\n                var _this = this;\n                return _async_to_generator(function() {\n                    var storage, cacheKey, connected, chainString, chain, identity, walletJson, hostString, customDomainString, _;\n                    return _ts_generator(this, function(_state) {\n                        switch(_state.label){\n                            case 0:\n                                storage = new ICStorage(\"astrox-\");\n                                return [\n                                    4,\n                                    storage.get(KEY_ICSTORAGE_CACHEKEY)\n                                ];\n                            case 1:\n                                cacheKey = _state.sent();\n                                _this.setStorage(storage);\n                                if (!cacheKey) return [\n                                    3,\n                                    8\n                                ];\n                                return [\n                                    4,\n                                    _ms.isConnected.invoke(cacheKey)\n                                ];\n                            case 2:\n                                connected = _state.sent();\n                                if (!connected) {\n                                    _this.clear();\n                                    return [\n                                        2\n                                    ];\n                                }\n                                return [\n                                    4,\n                                    storage.get(KEY_ICSTORAGE_CHAIN)\n                                ];\n                            case 3:\n                                chainString = _state.sent();\n                                chain = chainString ? DelegationChain.fromJSON(chainString) : null;\n                                if (!chain || !isDelegationValid(chain)) {\n                                    _this.clear();\n                                    return [\n                                        2\n                                    ];\n                                }\n                                identity = new AstroXIdentity(cacheKey, chain);\n                                return [\n                                    4,\n                                    storage.get(KEY_ICSTORAGE_WALLET)\n                                ];\n                            case 4:\n                                walletJson = _state.sent();\n                                return [\n                                    4,\n                                    storage.get(KEY_ICSTORAGE_HOST)\n                                ];\n                            case 5:\n                                hostString = _state.sent();\n                                return [\n                                    4,\n                                    storage.get(KEY_CUSTOM_DOMAIN)\n                                ];\n                            case 6:\n                                customDomainString = _state.sent();\n                                _this.setHost(hostString);\n                                _this.setCacheKey(cacheKey);\n                                _this.setChain(chain);\n                                _this.setWallet(walletJson ? JSON.parse(walletJson) : null);\n                                _ = _this.setConfirm;\n                                return [\n                                    4,\n                                    storage.get(KEY_ICSTORAGE_CONFIRM)\n                                ];\n                            case 7:\n                                _.apply(_this, [\n                                    _state.sent() == \"true\"\n                                ]);\n                                _this.setIdentity(identity);\n                                _this.setAgent(new HttpAgent({\n                                    identity: identity,\n                                    host: hostString !== null && hostString !== void 0 ? hostString : window.location.origin\n                                }));\n                                _this.setCustomDomain(customDomainString);\n                                _state.label = 8;\n                            case 8:\n                                return [\n                                    2\n                                ];\n                        }\n                    });\n                })();\n            }\n        },\n        {\n            key: \"isReady\",\n            value: function isReady() {\n                return !!window.astrox_webview && this._isReady;\n            }\n        },\n        {\n            key: \"getDelegation\",\n            value: function getDelegation() {\n                return this._chain;\n            }\n        },\n        {\n            key: \"getPublicKey\",\n            value: function getPublicKey() {\n                var _this__identity;\n                return (_this__identity = this._identity) === null || _this__identity === void 0 ? void 0 : _this__identity.getPublicKey();\n            }\n        },\n        {\n            key: \"getPrincipal\",\n            value: function getPrincipal() {\n                var _this__identity;\n                return (_this__identity = this._identity) === null || _this__identity === void 0 ? void 0 : _this__identity.getPrincipal();\n            }\n        },\n        {\n            key: \"_assertEnv\",\n            value: function _assertEnv() {\n                if (!this.isReady()) {\n                    throw Error(\"Webview Bridge is not ready\");\n                }\n            }\n        },\n        {\n            key: \"connect\",\n            value: function connect(params) {\n                var _this = this;\n                return _async_to_generator(function() {\n                    return _ts_generator(this, function(_state) {\n                        _this._assertEnv();\n                        if (!_this.identity) {\n                            return [\n                                2,\n                                _this.reconnect(params)\n                            ];\n                        }\n                        return [\n                            2,\n                            true\n                        ];\n                    });\n                })();\n            }\n        },\n        {\n            key: \"reconnect\",\n            value: function reconnect(params) {\n                var _this = this;\n                return _async_to_generator(function() {\n                    var _params_delegationTargets, delegationModes, modes, hasNotInclude, _params_customDomain, result;\n                    return _ts_generator(this, function(_state) {\n                        switch(_state.label){\n                            case 0:\n                                _this._assertEnv();\n                                delegationModes = params.delegationModes;\n                                if (delegationModes && delegationModes.length) {\n                                    modes = [\n                                        \"global\",\n                                        \"domain\"\n                                    ];\n                                    hasNotInclude = delegationModes.some(function(v) {\n                                        return !modes.includes(v);\n                                    });\n                                    if (hasNotInclude) {\n                                        throw new Error(\"`delegationModes` elements only support `global` and `domain`\");\n                                    }\n                                    delegationModes = _to_consumable_array(new Set(delegationModes));\n                                }\n                                return [\n                                    4,\n                                    _ms.connect.invoke(_object_spread_props(_object_spread({}, params), {\n                                        host: (_params_customDomain = params.customDomain) !== null && _params_customDomain !== void 0 ? _params_customDomain : window.location.origin,\n                                        delegationTargets: (_params_delegationTargets = params.delegationTargets) === null || _params_delegationTargets === void 0 ? void 0 : _params_delegationTargets.filter(function(value) {\n                                            return typeof value === \"string\" && value.trim();\n                                        }),\n                                        delegationModes: delegationModes\n                                    }))\n                                ];\n                            case 1:\n                                result = _state.sent();\n                                return [\n                                    2,\n                                    _this._handleWebViewConnectResponse(result, params.host, params.customDomain)\n                                ];\n                        }\n                    });\n                })();\n            }\n        },\n        {\n            key: \"_handleWebViewConnectResponse\",\n            value: function _handleWebViewConnectResponse(result, host, customDomain) {\n                var authorized = result.authorized, payload = result.payload;\n                if (!authorized) {\n                    return false;\n                }\n                if (!payload) {\n                    return true;\n                }\n                if (!payload.chain) {\n                    return false;\n                }\n                var chainObject;\n                try {\n                    chainObject = DelegationChain.fromJSON(payload.chain);\n                } catch (error) {\n                    return false;\n                }\n                if (isDelegationValid(chainObject)) {\n                    this.setChain(chainObject);\n                    this.setCacheKey(payload.cacheKey);\n                    this.setWallet(payload.wallet);\n                    this.setIdentity(new AstroXIdentity(this._cacheKey, this._chain));\n                    this.setConfirm(payload.confirm === true);\n                    this.setAgent(new HttpAgent({\n                        identity: this._identity,\n                        host: host !== null && host !== void 0 ? host : window.location.origin\n                    }));\n                    this.setHost(host !== null && host !== void 0 ? host : window.location.origin);\n                    this.setCustomDomain(customDomain);\n                    return true;\n                }\n                return false;\n            }\n        },\n        {\n            key: \"getSupportedTokenList\",\n            value: function getSupportedTokenList() {\n                var _this = this;\n                return _async_to_generator(function() {\n                    return _ts_generator(this, function(_state) {\n                        _this._assertEnv();\n                        return [\n                            2,\n                            _ms.supportedStandardList.invoke()\n                        ];\n                    });\n                })();\n            }\n        },\n        {\n            key: \"isConnected\",\n            value: function isConnected() {\n                var _this = this;\n                return _async_to_generator(function() {\n                    var _tmp;\n                    return _ts_generator(this, function(_state) {\n                        switch(_state.label){\n                            case 0:\n                                _this._assertEnv();\n                                _tmp = !!_this.cacheKey;\n                                if (!_tmp) return [\n                                    3,\n                                    2\n                                ];\n                                return [\n                                    4,\n                                    _ms.isConnected.invoke(_this.cacheKey)\n                                ];\n                            case 1:\n                                _tmp = _state.sent();\n                                _state.label = 2;\n                            case 2:\n                                return [\n                                    2,\n                                    _tmp\n                                ];\n                        }\n                    });\n                })();\n            }\n        },\n        {\n            key: \"disconnect\",\n            value: function disconnect() {\n                var _this = this;\n                return _async_to_generator(function() {\n                    var _tmp;\n                    return _ts_generator(this, function(_state) {\n                        switch(_state.label){\n                            case 0:\n                                _this._assertEnv();\n                                _tmp = _this.cacheKey;\n                                if (!_tmp) return [\n                                    3,\n                                    2\n                                ];\n                                return [\n                                    4,\n                                    _ms.disconnect.invoke(_this.cacheKey)\n                                ];\n                            case 1:\n                                _tmp = _state.sent();\n                                _state.label = 2;\n                            case 2:\n                                _tmp;\n                                _this.clear();\n                                return [\n                                    2,\n                                    true\n                                ];\n                        }\n                    });\n                })();\n            }\n        },\n        {\n            key: \"signMessage\",\n            value: function signMessage(message) {\n                return _async_to_generator(function() {\n                    return _ts_generator(this, function(_state) {\n                        throw new Error(\"Unsupported api\");\n                    });\n                })();\n            }\n        },\n        {\n            key: \"requestTransfer\",\n            value: function requestTransfer(req) {\n                var _this = this;\n                return _async_to_generator(function() {\n                    var rawSendOpts, sendOpts, memo, standard, createdAtTime, txType, success, e, _JSON_parse, code, message;\n                    return _ts_generator(this, function(_state) {\n                        switch(_state.label){\n                            case 0:\n                                _this._assertEnv();\n                                if (!_this.cacheKey) {\n                                    return [\n                                        2,\n                                        BridgeErrors.fromErrorCode(BridgeErrors.bridgeIdentityNotFound, TransactionMessageKind.fail)\n                                    ];\n                                }\n                                if (!_this._wallet) {\n                                    return [\n                                        2,\n                                        BridgeErrors.fromErrorCode(BridgeErrors.bridgeWalletNotFound, TransactionMessageKind.fail)\n                                    ];\n                                }\n                                rawSendOpts = req.sendOpts;\n                                if (rawSendOpts) {\n                                    memo = rawSendOpts.memo;\n                                    if (memo) {\n                                        standard = req.standard.toUpperCase();\n                                        if (standard === \"EXT\" && !Array.isArray(memo)) {\n                                            throw new Error(\"`sendOpts.memo` only supports `Array<number>` type when the standard is `EXT`\");\n                                        }\n                                        if (standard === \"ICP\" && (typeof memo === \"undefined\" ? \"undefined\" : _type_of(memo)) !== \"bigint\") {\n                                            throw new Error(\"`sendOpts.memo` only supports `bigint` type when the standard is `ICP`\");\n                                        }\n                                    }\n                                    createdAtTime = rawSendOpts.created_at_time;\n                                    sendOpts = _object_spread({}, rawSendOpts);\n                                    if (createdAtTime) {\n                                        if (_instanceof(createdAtTime, Date)) {\n                                            sendOpts.created_at_time = createdAtTime.getTime();\n                                        }\n                                    }\n                                }\n                                _state.label = 1;\n                            case 1:\n                                _state.trys.push([\n                                    1,\n                                    3,\n                                    ,\n                                    4\n                                ]);\n                                txType = req.symbol !== undefined ? TransactionType.token : TransactionType.nft;\n                                return [\n                                    4,\n                                    _ms.requestTransfer.invoke(_this.cacheKey, _object_spread_props(_object_spread({}, req), {\n                                        sendOpts: sendOpts\n                                    }), _this._wallet)\n                                ];\n                            case 2:\n                                success = _state.sent();\n                                switch(txType){\n                                    case TransactionType.token:\n                                        return [\n                                            2,\n                                            {\n                                                kind: TransactionMessageKind.success,\n                                                type: txType,\n                                                payload: _object_spread_props(_object_spread({}, success), {\n                                                    originPayload: req\n                                                })\n                                            }\n                                        ];\n                                    case TransactionType.nft:\n                                        return [\n                                            2,\n                                            {\n                                                kind: TransactionMessageKind.success,\n                                                type: txType,\n                                                payload: {\n                                                    success: true,\n                                                    originPayload: req\n                                                }\n                                            }\n                                        ];\n                                }\n                                return [\n                                    3,\n                                    4\n                                ];\n                            case 3:\n                                e = _state.sent();\n                                _JSON_parse = JSON.parse(e.message), code = _JSON_parse.code, message = _JSON_parse.message;\n                                return [\n                                    2,\n                                    BridgeErrors.fromErrorCode(code, TransactionMessageKind.fail, message)\n                                ];\n                            case 4:\n                                return [\n                                    2\n                                ];\n                        }\n                    });\n                })();\n            }\n        },\n        {\n            key: \"queryBalance\",\n            value: function queryBalance() {\n                var _this = this;\n                return _async_to_generator(function() {\n                    return _ts_generator(this, function(_state) {\n                        switch(_state.label){\n                            case 0:\n                                _this._assertEnv();\n                                return [\n                                    4,\n                                    _ms.queryBalance.invoke(_object_spread({}, _this.wallet))\n                                ];\n                            case 1:\n                                return [\n                                    2,\n                                    _state.sent()\n                                ];\n                        }\n                    });\n                })();\n            }\n        },\n        {\n            key: \"address\",\n            value: function address() {\n                return _object_spread({}, this.wallet);\n            }\n        },\n        {\n            key: \"init\",\n            value: function init() {\n                var _this = this;\n                return _async_to_generator(function() {\n                    return _ts_generator(this, function(_state) {\n                        switch(_state.label){\n                            case 0:\n                                return [\n                                    4,\n                                    _this._initBridge()\n                                ];\n                            case 1:\n                                _state.sent();\n                                _this._assertEnv();\n                                return [\n                                    2\n                                ];\n                        }\n                    });\n                })();\n            }\n        }\n    ]);\n    return AstroXWebViewHandler;\n}();\n","var getDefaultParent = function (originalTarget) {\n    if (typeof document === 'undefined') {\n        return null;\n    }\n    var sampleTarget = Array.isArray(originalTarget) ? originalTarget[0] : originalTarget;\n    return sampleTarget.ownerDocument.body;\n};\nvar counterMap = new WeakMap();\nvar uncontrolledNodes = new WeakMap();\nvar markerMap = {};\nvar lockCount = 0;\nvar unwrapHost = function (node) {\n    return node && (node.host || unwrapHost(node.parentNode));\n};\nvar correctTargets = function (parent, targets) {\n    return targets\n        .map(function (target) {\n        if (parent.contains(target)) {\n            return target;\n        }\n        var correctedTarget = unwrapHost(target);\n        if (correctedTarget && parent.contains(correctedTarget)) {\n            return correctedTarget;\n        }\n        console.error('aria-hidden', target, 'in not contained inside', parent, '. Doing nothing');\n        return null;\n    })\n        .filter(function (x) { return Boolean(x); });\n};\n/**\n * Marks everything except given node(or nodes) as aria-hidden\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @param {String} [controlAttribute] - html Attribute to control\n * @return {Undo} undo command\n */\nvar applyAttributeToOthers = function (originalTarget, parentNode, markerName, controlAttribute) {\n    var targets = correctTargets(parentNode, Array.isArray(originalTarget) ? originalTarget : [originalTarget]);\n    if (!markerMap[markerName]) {\n        markerMap[markerName] = new WeakMap();\n    }\n    var markerCounter = markerMap[markerName];\n    var hiddenNodes = [];\n    var elementsToKeep = new Set();\n    var elementsToStop = new Set(targets);\n    var keep = function (el) {\n        if (!el || elementsToKeep.has(el)) {\n            return;\n        }\n        elementsToKeep.add(el);\n        keep(el.parentNode);\n    };\n    targets.forEach(keep);\n    var deep = function (parent) {\n        if (!parent || elementsToStop.has(parent)) {\n            return;\n        }\n        Array.prototype.forEach.call(parent.children, function (node) {\n            if (elementsToKeep.has(node)) {\n                deep(node);\n            }\n            else {\n                try {\n                    var attr = node.getAttribute(controlAttribute);\n                    var alreadyHidden = attr !== null && attr !== 'false';\n                    var counterValue = (counterMap.get(node) || 0) + 1;\n                    var markerValue = (markerCounter.get(node) || 0) + 1;\n                    counterMap.set(node, counterValue);\n                    markerCounter.set(node, markerValue);\n                    hiddenNodes.push(node);\n                    if (counterValue === 1 && alreadyHidden) {\n                        uncontrolledNodes.set(node, true);\n                    }\n                    if (markerValue === 1) {\n                        node.setAttribute(markerName, 'true');\n                    }\n                    if (!alreadyHidden) {\n                        node.setAttribute(controlAttribute, 'true');\n                    }\n                }\n                catch (e) {\n                    console.error('aria-hidden: cannot operate on ', node, e);\n                }\n            }\n        });\n    };\n    deep(parentNode);\n    elementsToKeep.clear();\n    lockCount++;\n    return function () {\n        hiddenNodes.forEach(function (node) {\n            var counterValue = counterMap.get(node) - 1;\n            var markerValue = markerCounter.get(node) - 1;\n            counterMap.set(node, counterValue);\n            markerCounter.set(node, markerValue);\n            if (!counterValue) {\n                if (!uncontrolledNodes.has(node)) {\n                    node.removeAttribute(controlAttribute);\n                }\n                uncontrolledNodes.delete(node);\n            }\n            if (!markerValue) {\n                node.removeAttribute(markerName);\n            }\n        });\n        lockCount--;\n        if (!lockCount) {\n            // clear\n            counterMap = new WeakMap();\n            counterMap = new WeakMap();\n            uncontrolledNodes = new WeakMap();\n            markerMap = {};\n        }\n    };\n};\n/**\n * Marks everything except given node(or nodes) as aria-hidden\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @return {Undo} undo command\n */\nexport var hideOthers = function (originalTarget, parentNode, markerName) {\n    if (markerName === void 0) { markerName = 'data-aria-hidden'; }\n    var targets = Array.from(Array.isArray(originalTarget) ? originalTarget : [originalTarget]);\n    var activeParentNode = parentNode || getDefaultParent(originalTarget);\n    if (!activeParentNode) {\n        return function () { return null; };\n    }\n    // we should not hide ariaLive elements - https://github.com/theKashey/aria-hidden/issues/10\n    targets.push.apply(targets, Array.from(activeParentNode.querySelectorAll('[aria-live]')));\n    return applyAttributeToOthers(targets, activeParentNode, markerName, 'aria-hidden');\n};\n/**\n * Marks everything except given node(or nodes) as inert\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @return {Undo} undo command\n */\nexport var inertOthers = function (originalTarget, parentNode, markerName) {\n    if (markerName === void 0) { markerName = 'data-inert-ed'; }\n    var activeParentNode = parentNode || getDefaultParent(originalTarget);\n    if (!activeParentNode) {\n        return function () { return null; };\n    }\n    return applyAttributeToOthers(originalTarget, activeParentNode, markerName, 'inert');\n};\n/**\n * @returns if current browser supports inert\n */\nexport var supportsInert = function () {\n    return typeof HTMLElement !== 'undefined' && HTMLElement.prototype.hasOwnProperty('inert');\n};\n/**\n * Automatic function to \"suppress\" DOM elements - _hide_ or _inert_ in the best possible way\n * @param {Element | Element[]} originalTarget - elements to keep on the page\n * @param [parentNode] - top element, defaults to document.body\n * @param {String} [markerName] - a special attribute to mark every node\n * @return {Undo} undo command\n */\nexport var suppressOthers = function (originalTarget, parentNode, markerName) {\n    if (markerName === void 0) { markerName = 'data-suppressed'; }\n    return (supportsInert() ? inertOthers : hideOthers)(originalTarget, parentNode, markerName);\n};\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","'use strict'\nvar ALPHABET = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l'\n\n// pre-compute lookup table\nvar ALPHABET_MAP = {}\nfor (var z = 0; z < ALPHABET.length; z++) {\n  var x = ALPHABET.charAt(z)\n\n  if (ALPHABET_MAP[x] !== undefined) throw new TypeError(x + ' is ambiguous')\n  ALPHABET_MAP[x] = z\n}\n\nfunction polymodStep (pre) {\n  var b = pre >> 25\n  return ((pre & 0x1FFFFFF) << 5) ^\n    (-((b >> 0) & 1) & 0x3b6a57b2) ^\n    (-((b >> 1) & 1) & 0x26508e6d) ^\n    (-((b >> 2) & 1) & 0x1ea119fa) ^\n    (-((b >> 3) & 1) & 0x3d4233dd) ^\n    (-((b >> 4) & 1) & 0x2a1462b3)\n}\n\nfunction prefixChk (prefix) {\n  var chk = 1\n  for (var i = 0; i < prefix.length; ++i) {\n    var c = prefix.charCodeAt(i)\n    if (c < 33 || c > 126) return 'Invalid prefix (' + prefix + ')'\n\n    chk = polymodStep(chk) ^ (c >> 5)\n  }\n  chk = polymodStep(chk)\n\n  for (i = 0; i < prefix.length; ++i) {\n    var v = prefix.charCodeAt(i)\n    chk = polymodStep(chk) ^ (v & 0x1f)\n  }\n  return chk\n}\n\nfunction encode (prefix, words, LIMIT) {\n  LIMIT = LIMIT || 90\n  if ((prefix.length + 7 + words.length) > LIMIT) throw new TypeError('Exceeds length limit')\n\n  prefix = prefix.toLowerCase()\n\n  // determine chk mod\n  var chk = prefixChk(prefix)\n  if (typeof chk === 'string') throw new Error(chk)\n\n  var result = prefix + '1'\n  for (var i = 0; i < words.length; ++i) {\n    var x = words[i]\n    if ((x >> 5) !== 0) throw new Error('Non 5-bit word')\n\n    chk = polymodStep(chk) ^ x\n    result += ALPHABET.charAt(x)\n  }\n\n  for (i = 0; i < 6; ++i) {\n    chk = polymodStep(chk)\n  }\n  chk ^= 1\n\n  for (i = 0; i < 6; ++i) {\n    var v = (chk >> ((5 - i) * 5)) & 0x1f\n    result += ALPHABET.charAt(v)\n  }\n\n  return result\n}\n\nfunction __decode (str, LIMIT) {\n  LIMIT = LIMIT || 90\n  if (str.length < 8) return str + ' too short'\n  if (str.length > LIMIT) return 'Exceeds length limit'\n\n  // don't allow mixed case\n  var lowered = str.toLowerCase()\n  var uppered = str.toUpperCase()\n  if (str !== lowered && str !== uppered) return 'Mixed-case string ' + str\n  str = lowered\n\n  var split = str.lastIndexOf('1')\n  if (split === -1) return 'No separator character for ' + str\n  if (split === 0) return 'Missing prefix for ' + str\n\n  var prefix = str.slice(0, split)\n  var wordChars = str.slice(split + 1)\n  if (wordChars.length < 6) return 'Data too short'\n\n  var chk = prefixChk(prefix)\n  if (typeof chk === 'string') return chk\n\n  var words = []\n  for (var i = 0; i < wordChars.length; ++i) {\n    var c = wordChars.charAt(i)\n    var v = ALPHABET_MAP[c]\n    if (v === undefined) return 'Unknown character ' + c\n    chk = polymodStep(chk) ^ v\n\n    // not in the checksum?\n    if (i + 6 >= wordChars.length) continue\n    words.push(v)\n  }\n\n  if (chk !== 1) return 'Invalid checksum for ' + str\n  return { prefix: prefix, words: words }\n}\n\nfunction decodeUnsafe () {\n  var res = __decode.apply(null, arguments)\n  if (typeof res === 'object') return res\n}\n\nfunction decode (str) {\n  var res = __decode.apply(null, arguments)\n  if (typeof res === 'object') return res\n\n  throw new Error(res)\n}\n\nfunction convert (data, inBits, outBits, pad) {\n  var value = 0\n  var bits = 0\n  var maxV = (1 << outBits) - 1\n\n  var result = []\n  for (var i = 0; i < data.length; ++i) {\n    value = (value << inBits) | data[i]\n    bits += inBits\n\n    while (bits >= outBits) {\n      bits -= outBits\n      result.push((value >> bits) & maxV)\n    }\n  }\n\n  if (pad) {\n    if (bits > 0) {\n      result.push((value << (outBits - bits)) & maxV)\n    }\n  } else {\n    if (bits >= inBits) return 'Excess padding'\n    if ((value << (outBits - bits)) & maxV) return 'Non-zero padding'\n  }\n\n  return result\n}\n\nfunction toWordsUnsafe (bytes) {\n  var res = convert(bytes, 8, 5, true)\n  if (Array.isArray(res)) return res\n}\n\nfunction toWords (bytes) {\n  var res = convert(bytes, 8, 5, true)\n  if (Array.isArray(res)) return res\n\n  throw new Error(res)\n}\n\nfunction fromWordsUnsafe (words) {\n  var res = convert(words, 5, 8, false)\n  if (Array.isArray(res)) return res\n}\n\nfunction fromWords (words) {\n  var res = convert(words, 5, 8, false)\n  if (Array.isArray(res)) return res\n\n  throw new Error(res)\n}\n\nmodule.exports = {\n  decodeUnsafe: decodeUnsafe,\n  decode: decode,\n  encode: encode,\n  toWordsUnsafe: toWordsUnsafe,\n  toWords: toWords,\n  fromWordsUnsafe: fromWordsUnsafe,\n  fromWords: fromWords\n}\n",";(function (globalObject) {\r\n  'use strict';\r\n\r\n/*\r\n *      bignumber.js v9.1.2\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, -1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the minimum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.minimum = BigNumber.min = function () {\r\n      return maxOrMin(arguments, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\r\n     * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\r\n     * zeros are produced).\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'\r\n     * '[BigNumber Error] crypto unavailable'\r\n     */\r\n    BigNumber.random = (function () {\r\n      var pow2_53 = 0x20000000000000;\r\n\r\n      // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\r\n      // Check if Math.random() produces more than 32 bits of randomness.\r\n      // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\r\n      // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\r\n      var random53bitInt = (Math.random() * pow2_53) & 0x1fffff\r\n       ? function () { return mathfloor(Math.random() * pow2_53); }\r\n       : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +\r\n         (Math.random() * 0x800000 | 0); };\r\n\r\n      return function (dp) {\r\n        var a, b, e, k, v,\r\n          i = 0,\r\n          c = [],\r\n          rand = new BigNumber(ONE);\r\n\r\n        if (dp == null) dp = DECIMAL_PLACES;\r\n        else intCheck(dp, 0, MAX);\r\n\r\n        k = mathceil(dp / LOG_BASE);\r\n\r\n        if (CRYPTO) {\r\n\r\n          // Browsers supporting crypto.getRandomValues.\r\n          if (crypto.getRandomValues) {\r\n\r\n            a = crypto.getRandomValues(new Uint32Array(k *= 2));\r\n\r\n            for (; i < k;) {\r\n\r\n              // 53 bits:\r\n              // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\r\n              // 11111 11111111 11111111 11111111 11100000 00000000 00000000\r\n              // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\r\n              //                                     11111 11111111 11111111\r\n              // 0x20000 is 2^21.\r\n              v = a[i] * 0x20000 + (a[i + 1] >>> 11);\r\n\r\n              // Rejection sampling:\r\n              // 0 <= v < 9007199254740992\r\n              // Probability that v >= 9e15, is\r\n              // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\r\n              if (v >= 9e15) {\r\n                b = crypto.getRandomValues(new Uint32Array(2));\r\n                a[i] = b[0];\r\n                a[i + 1] = b[1];\r\n              } else {\r\n\r\n                // 0 <= v <= 8999999999999999\r\n                // 0 <= (v % 1e14) <= 99999999999999\r\n                c.push(v % 1e14);\r\n                i += 2;\r\n              }\r\n            }\r\n            i = k / 2;\r\n\r\n          // Node.js supporting crypto.randomBytes.\r\n          } else if (crypto.randomBytes) {\r\n\r\n            // buffer\r\n            a = crypto.randomBytes(k *= 7);\r\n\r\n            for (; i < k;) {\r\n\r\n              // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\r\n              // 0x100000000 is 2^32, 0x1000000 is 2^24\r\n              // 11111 11111111 11111111 11111111 11111111 11111111 11111111\r\n              // 0 <= v < 9007199254740992\r\n              v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +\r\n                 (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +\r\n                 (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];\r\n\r\n              if (v >= 9e15) {\r\n                crypto.randomBytes(7).copy(a, i);\r\n              } else {\r\n\r\n                // 0 <= (v % 1e14) <= 99999999999999\r\n                c.push(v % 1e14);\r\n                i += 7;\r\n              }\r\n            }\r\n            i = k / 7;\r\n          } else {\r\n            CRYPTO = false;\r\n            throw Error\r\n             (bignumberError + 'crypto unavailable');\r\n          }\r\n        }\r\n\r\n        // Use Math.random.\r\n        if (!CRYPTO) {\r\n\r\n          for (; i < k;) {\r\n            v = random53bitInt();\r\n            if (v < 9e15) c[i++] = v % 1e14;\r\n          }\r\n        }\r\n\r\n        k = c[--i];\r\n        dp %= LOG_BASE;\r\n\r\n        // Convert trailing digits to zeros according to dp.\r\n        if (k && dp) {\r\n          v = POWS_TEN[LOG_BASE - dp];\r\n          c[i] = mathfloor(k / v) * v;\r\n        }\r\n\r\n        // Remove trailing elements which are zero.\r\n        for (; c[i] === 0; c.pop(), i--);\r\n\r\n        // Zero?\r\n        if (i < 0) {\r\n          c = [e = 0];\r\n        } else {\r\n\r\n          // Remove leading elements which are zero and adjust exponent accordingly.\r\n          for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);\r\n\r\n          // Count the digits of the first element of c to determine leading zeros, and...\r\n          for (i = 1, v = c[0]; v >= 10; v /= 10, i++);\r\n\r\n          // adjust the exponent accordingly.\r\n          if (i < LOG_BASE) e -= LOG_BASE - i;\r\n        }\r\n\r\n        rand.e = e;\r\n        rand.c = c;\r\n        return rand;\r\n      };\r\n    })();\r\n\r\n\r\n    /*\r\n     * Return a BigNumber whose value is the sum of the arguments.\r\n     *\r\n     * arguments {number|string|BigNumber}\r\n     */\r\n    BigNumber.sum = function () {\r\n      var i = 1,\r\n        args = arguments,\r\n        sum = new BigNumber(args[0]);\r\n      for (; i < args.length;) sum = sum.plus(args[i++]);\r\n      return sum;\r\n    };\r\n\r\n\r\n    // PRIVATE FUNCTIONS\r\n\r\n\r\n    // Called by BigNumber and BigNumber.prototype.toString.\r\n    convertBase = (function () {\r\n      var decimal = '0123456789';\r\n\r\n      /*\r\n       * Convert string of baseIn to an array of numbers of baseOut.\r\n       * Eg. toBaseOut('255', 10, 16) returns [15, 15].\r\n       * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].\r\n       */\r\n      function toBaseOut(str, baseIn, baseOut, alphabet) {\r\n        var j,\r\n          arr = [0],\r\n          arrL,\r\n          i = 0,\r\n          len = str.length;\r\n\r\n        for (; i < len;) {\r\n          for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);\r\n\r\n          arr[0] += alphabet.indexOf(str.charAt(i++));\r\n\r\n          for (j = 0; j < arr.length; j++) {\r\n\r\n            if (arr[j] > baseOut - 1) {\r\n              if (arr[j + 1] == null) arr[j + 1] = 0;\r\n              arr[j + 1] += arr[j] / baseOut | 0;\r\n              arr[j] %= baseOut;\r\n            }\r\n          }\r\n        }\r\n\r\n        return arr.reverse();\r\n      }\r\n\r\n      // Convert a numeric string of baseIn to a numeric string of baseOut.\r\n      // If the caller is toString, we are converting from base 10 to baseOut.\r\n      // If the caller is BigNumber, we are converting from baseIn to base 10.\r\n      return function (str, baseIn, baseOut, sign, callerIsToString) {\r\n        var alphabet, d, e, k, r, x, xc, y,\r\n          i = str.indexOf('.'),\r\n          dp = DECIMAL_PLACES,\r\n          rm = ROUNDING_MODE;\r\n\r\n        // Non-integer.\r\n        if (i >= 0) {\r\n          k = POW_PRECISION;\r\n\r\n          // Unlimited precision.\r\n          POW_PRECISION = 0;\r\n          str = str.replace('.', '');\r\n          y = new BigNumber(baseIn);\r\n          x = y.pow(str.length - i);\r\n          POW_PRECISION = k;\r\n\r\n          // Convert str as if an integer, then restore the fraction part by dividing the\r\n          // result by its base raised to a power.\r\n\r\n          y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),\r\n           10, baseOut, decimal);\r\n          y.e = y.c.length;\r\n        }\r\n\r\n        // Convert the number as integer.\r\n\r\n        xc = toBaseOut(str, baseIn, baseOut, callerIsToString\r\n         ? (alphabet = ALPHABET, decimal)\r\n         : (alphabet = decimal, ALPHABET));\r\n\r\n        // xc now represents str as an integer and converted to baseOut. e is the exponent.\r\n        e = k = xc.length;\r\n\r\n        // Remove trailing zeros.\r\n        for (; xc[--k] == 0; xc.pop());\r\n\r\n        // Zero?\r\n        if (!xc[0]) return alphabet.charAt(0);\r\n\r\n        // Does str represent an integer? If so, no need for the division.\r\n        if (i < 0) {\r\n          --e;\r\n        } else {\r\n          x.c = xc;\r\n          x.e = e;\r\n\r\n          // The sign is needed for correct rounding.\r\n          x.s = sign;\r\n          x = div(x, y, dp, rm, baseOut);\r\n          xc = x.c;\r\n          r = x.r;\r\n          e = x.e;\r\n        }\r\n\r\n        // xc now represents str converted to baseOut.\r\n\r\n        // THe index of the rounding digit.\r\n        d = e + dp + 1;\r\n\r\n        // The rounding digit: the digit to the right of the digit that may be rounded up.\r\n        i = xc[d];\r\n\r\n        // Look at the rounding digits and mode to determine whether to round up.\r\n\r\n        k = baseOut / 2;\r\n        r = r || d < 0 || xc[d + 1] != null;\r\n\r\n        r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n              : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||\r\n               rm == (x.s < 0 ? 8 : 7));\r\n\r\n        // If the index of the rounding digit is not greater than zero, or xc represents\r\n        // zero, then the result of the base conversion is zero or, if rounding up, a value\r\n        // such as 0.00001.\r\n        if (d < 1 || !xc[0]) {\r\n\r\n          // 1^-dp or 0\r\n          str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);\r\n        } else {\r\n\r\n          // Truncate xc to the required number of decimal places.\r\n          xc.length = d;\r\n\r\n          // Round up?\r\n          if (r) {\r\n\r\n            // Rounding up may mean the previous digit has to be rounded up and so on.\r\n            for (--baseOut; ++xc[--d] > baseOut;) {\r\n              xc[d] = 0;\r\n\r\n              if (!d) {\r\n                ++e;\r\n                xc = [1].concat(xc);\r\n              }\r\n            }\r\n          }\r\n\r\n          // Determine trailing zeros.\r\n          for (k = xc.length; !xc[--k];);\r\n\r\n          // E.g. [4, 11, 15] becomes 4bf.\r\n          for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));\r\n\r\n          // Add leading zeros, decimal point and trailing zeros as required.\r\n          str = toFixedPoint(str, e, alphabet.charAt(0));\r\n        }\r\n\r\n        // The caller will add the sign.\r\n        return str;\r\n      };\r\n    })();\r\n\r\n\r\n    // Perform division in the specified base. Called by div and convertBase.\r\n    div = (function () {\r\n\r\n      // Assume non-zero x and k.\r\n      function multiply(x, k, base) {\r\n        var m, temp, xlo, xhi,\r\n          carry = 0,\r\n          i = x.length,\r\n          klo = k % SQRT_BASE,\r\n          khi = k / SQRT_BASE | 0;\r\n\r\n        for (x = x.slice(); i--;) {\r\n          xlo = x[i] % SQRT_BASE;\r\n          xhi = x[i] / SQRT_BASE | 0;\r\n          m = khi * xlo + xhi * klo;\r\n          temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;\r\n          carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;\r\n          x[i] = temp % base;\r\n        }\r\n\r\n        if (carry) x = [carry].concat(x);\r\n\r\n        return x;\r\n      }\r\n\r\n      function compare(a, b, aL, bL) {\r\n        var i, cmp;\r\n\r\n        if (aL != bL) {\r\n          cmp = aL > bL ? 1 : -1;\r\n        } else {\r\n\r\n          for (i = cmp = 0; i < aL; i++) {\r\n\r\n            if (a[i] != b[i]) {\r\n              cmp = a[i] > b[i] ? 1 : -1;\r\n              break;\r\n            }\r\n          }\r\n        }\r\n\r\n        return cmp;\r\n      }\r\n\r\n      function subtract(a, b, aL, base) {\r\n        var i = 0;\r\n\r\n        // Subtract b from a.\r\n        for (; aL--;) {\r\n          a[aL] -= i;\r\n          i = a[aL] < b[aL] ? 1 : 0;\r\n          a[aL] = i * base + a[aL] - b[aL];\r\n        }\r\n\r\n        // Remove leading zeros.\r\n        for (; !a[0] && a.length > 1; a.splice(0, 1));\r\n      }\r\n\r\n      // x: dividend, y: divisor.\r\n      return function (x, y, dp, rm, base) {\r\n        var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,\r\n          yL, yz,\r\n          s = x.s == y.s ? 1 : -1,\r\n          xc = x.c,\r\n          yc = y.c;\r\n\r\n        // Either NaN, Infinity or 0?\r\n        if (!xc || !xc[0] || !yc || !yc[0]) {\r\n\r\n          return new BigNumber(\r\n\r\n           // Return NaN if either NaN, or both Infinity or 0.\r\n           !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :\r\n\r\n            // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\r\n            xc && xc[0] == 0 || !yc ? s * 0 : s / 0\r\n         );\r\n        }\r\n\r\n        q = new BigNumber(s);\r\n        qc = q.c = [];\r\n        e = x.e - y.e;\r\n        s = dp + e + 1;\r\n\r\n        if (!base) {\r\n          base = BASE;\r\n          e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);\r\n          s = s / LOG_BASE | 0;\r\n        }\r\n\r\n        // Result exponent may be one less then the current value of e.\r\n        // The coefficients of the BigNumbers from convertBase may have trailing zeros.\r\n        for (i = 0; yc[i] == (xc[i] || 0); i++);\r\n\r\n        if (yc[i] > (xc[i] || 0)) e--;\r\n\r\n        if (s < 0) {\r\n          qc.push(1);\r\n          more = true;\r\n        } else {\r\n          xL = xc.length;\r\n          yL = yc.length;\r\n          i = 0;\r\n          s += 2;\r\n\r\n          // Normalise xc and yc so highest order digit of yc is >= base / 2.\r\n\r\n          n = mathfloor(base / (yc[0] + 1));\r\n\r\n          // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.\r\n          // if (n > 1 || n++ == 1 && yc[0] < base / 2) {\r\n          if (n > 1) {\r\n            yc = multiply(yc, n, base);\r\n            xc = multiply(xc, n, base);\r\n            yL = yc.length;\r\n            xL = xc.length;\r\n          }\r\n\r\n          xi = yL;\r\n          rem = xc.slice(0, yL);\r\n          remL = rem.length;\r\n\r\n          // Add zeros to make remainder as long as divisor.\r\n          for (; remL < yL; rem[remL++] = 0);\r\n          yz = yc.slice();\r\n          yz = [0].concat(yz);\r\n          yc0 = yc[0];\r\n          if (yc[1] >= base / 2) yc0++;\r\n          // Not necessary, but to prevent trial digit n > base, when using base 3.\r\n          // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;\r\n\r\n          do {\r\n            n = 0;\r\n\r\n            // Compare divisor and remainder.\r\n            cmp = compare(yc, rem, yL, remL);\r\n\r\n            // If divisor < remainder.\r\n            if (cmp < 0) {\r\n\r\n              // Calculate trial digit, n.\r\n\r\n              rem0 = rem[0];\r\n              if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n              // n is how many times the divisor goes into the current remainder.\r\n              n = mathfloor(rem0 / yc0);\r\n\r\n              //  Algorithm:\r\n              //  product = divisor multiplied by trial digit (n).\r\n              //  Compare product and remainder.\r\n              //  If product is greater than remainder:\r\n              //    Subtract divisor from product, decrement trial digit.\r\n              //  Subtract product from remainder.\r\n              //  If product was less than remainder at the last compare:\r\n              //    Compare new remainder and divisor.\r\n              //    If remainder is greater than divisor:\r\n              //      Subtract divisor from remainder, increment trial digit.\r\n\r\n              if (n > 1) {\r\n\r\n                // n may be > base only when base is 3.\r\n                if (n >= base) n = base - 1;\r\n\r\n                // product = divisor * trial digit.\r\n                prod = multiply(yc, n, base);\r\n                prodL = prod.length;\r\n                remL = rem.length;\r\n\r\n                // Compare product and remainder.\r\n                // If product > remainder then trial digit n too high.\r\n                // n is 1 too high about 5% of the time, and is not known to have\r\n                // ever been more than 1 too high.\r\n                while (compare(prod, rem, prodL, remL) == 1) {\r\n                  n--;\r\n\r\n                  // Subtract divisor from product.\r\n                  subtract(prod, yL < prodL ? yz : yc, prodL, base);\r\n                  prodL = prod.length;\r\n                  cmp = 1;\r\n                }\r\n              } else {\r\n\r\n                // n is 0 or 1, cmp is -1.\r\n                // If n is 0, there is no need to compare yc and rem again below,\r\n                // so change cmp to 1 to avoid it.\r\n                // If n is 1, leave cmp as -1, so yc and rem are compared again.\r\n                if (n == 0) {\r\n\r\n                  // divisor < remainder, so n must be at least 1.\r\n                  cmp = n = 1;\r\n                }\r\n\r\n                // product = divisor\r\n                prod = yc.slice();\r\n                prodL = prod.length;\r\n              }\r\n\r\n              if (prodL < remL) prod = [0].concat(prod);\r\n\r\n              // Subtract product from remainder.\r\n              subtract(rem, prod, remL, base);\r\n              remL = rem.length;\r\n\r\n               // If product was < remainder.\r\n              if (cmp == -1) {\r\n\r\n                // Compare divisor and new remainder.\r\n                // If divisor < new remainder, subtract divisor from remainder.\r\n                // Trial digit n too low.\r\n                // n is 1 too low about 5% of the time, and very rarely 2 too low.\r\n                while (compare(yc, rem, yL, remL) < 1) {\r\n                  n++;\r\n\r\n                  // Subtract divisor from remainder.\r\n                  subtract(rem, yL < remL ? yz : yc, remL, base);\r\n                  remL = rem.length;\r\n                }\r\n              }\r\n            } else if (cmp === 0) {\r\n              n++;\r\n              rem = [0];\r\n            } // else cmp === 1 and n will be 0\r\n\r\n            // Add the next digit, n, to the result array.\r\n            qc[i++] = n;\r\n\r\n            // Update the remainder.\r\n            if (rem[0]) {\r\n              rem[remL++] = xc[xi] || 0;\r\n            } else {\r\n              rem = [xc[xi]];\r\n              remL = 1;\r\n            }\r\n          } while ((xi++ < xL || rem[0] != null) && s--);\r\n\r\n          more = rem[0] != null;\r\n\r\n          // Leading zero?\r\n          if (!qc[0]) qc.splice(0, 1);\r\n        }\r\n\r\n        if (base == BASE) {\r\n\r\n          // To calculate q.e, first get the number of digits of qc[0].\r\n          for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);\r\n\r\n          round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);\r\n\r\n        // Caller is convertBase.\r\n        } else {\r\n          q.e = e;\r\n          q.r = +more;\r\n        }\r\n\r\n        return q;\r\n      };\r\n    })();\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of BigNumber n in fixed-point or exponential\r\n     * notation rounded to the specified decimal places or significant digits.\r\n     *\r\n     * n: a BigNumber.\r\n     * i: the index of the last digit required (i.e. the digit that may be rounded up).\r\n     * rm: the rounding mode.\r\n     * id: 1 (toExponential) or 2 (toPrecision).\r\n     */\r\n    function format(n, i, rm, id) {\r\n      var c0, e, ne, len, str;\r\n\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n\r\n      if (!n.c) return n.toString();\r\n\r\n      c0 = n.c[0];\r\n      ne = n.e;\r\n\r\n      if (i == null) {\r\n        str = coeffToString(n.c);\r\n        str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS)\r\n         ? toExponential(str, ne)\r\n         : toFixedPoint(str, ne, '0');\r\n      } else {\r\n        n = round(new BigNumber(n), i, rm);\r\n\r\n        // n.e may have changed if the value was rounded up.\r\n        e = n.e;\r\n\r\n        str = coeffToString(n.c);\r\n        len = str.length;\r\n\r\n        // toPrecision returns exponential notation if the number of significant digits\r\n        // specified is less than the number of digits necessary to represent the integer\r\n        // part of the value in fixed-point notation.\r\n\r\n        // Exponential notation.\r\n        if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {\r\n\r\n          // Append zeros?\r\n          for (; len < i; str += '0', len++);\r\n          str = toExponential(str, e);\r\n\r\n        // Fixed-point notation.\r\n        } else {\r\n          i -= ne;\r\n          str = toFixedPoint(str, e, '0');\r\n\r\n          // Append zeros?\r\n          if (e + 1 > len) {\r\n            if (--i > 0) for (str += '.'; i--; str += '0');\r\n          } else {\r\n            i += e - len;\r\n            if (i > 0) {\r\n              if (e + 1 == len) str += '.';\r\n              for (; i--; str += '0');\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return n.s < 0 && c0 ? '-' + str : str;\r\n    }\r\n\r\n\r\n    // Handle BigNumber.max and BigNumber.min.\r\n    // If any number is NaN, return NaN.\r\n    function maxOrMin(args, n) {\r\n      var k, y,\r\n        i = 1,\r\n        x = new BigNumber(args[0]);\r\n\r\n      for (; i < args.length; i++) {\r\n        y = new BigNumber(args[i]);\r\n        if (!y.s || (k = compare(x, y)) === n || k === 0 && x.s === n) {\r\n          x = y;\r\n        }\r\n      }\r\n\r\n      return x;\r\n    }\r\n\r\n\r\n    /*\r\n     * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\r\n     * Called by minus, plus and times.\r\n     */\r\n    function normalise(n, c, e) {\r\n      var i = 1,\r\n        j = c.length;\r\n\r\n       // Remove trailing zeros.\r\n      for (; !c[--j]; c.pop());\r\n\r\n      // Calculate the base 10 exponent. First get the number of digits of c[0].\r\n      for (j = c[0]; j >= 10; j /= 10, i++);\r\n\r\n      // Overflow?\r\n      if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {\r\n\r\n        // Infinity.\r\n        n.c = n.e = null;\r\n\r\n      // Underflow?\r\n      } else if (e < MIN_EXP) {\r\n\r\n        // Zero.\r\n        n.c = [n.e = 0];\r\n      } else {\r\n        n.e = e;\r\n        n.c = c;\r\n      }\r\n\r\n      return n;\r\n    }\r\n\r\n\r\n    // Handle values that fail the validity test in BigNumber.\r\n    parseNumeric = (function () {\r\n      var basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i,\r\n        dotAfter = /^([^.]+)\\.$/,\r\n        dotBefore = /^\\.([^.]+)$/,\r\n        isInfinityOrNaN = /^-?(Infinity|NaN)$/,\r\n        whitespaceOrPlus = /^\\s*\\+(?=[\\w.])|^\\s+|\\s+$/g;\r\n\r\n      return function (x, str, isNum, b) {\r\n        var base,\r\n          s = isNum ? str : str.replace(whitespaceOrPlus, '');\r\n\r\n        // No exception on ±Infinity or NaN.\r\n        if (isInfinityOrNaN.test(s)) {\r\n          x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\r\n        } else {\r\n          if (!isNum) {\r\n\r\n            // basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i\r\n            s = s.replace(basePrefix, function (m, p1, p2) {\r\n              base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\r\n              return !b || b == base ? p1 : m;\r\n            });\r\n\r\n            if (b) {\r\n              base = b;\r\n\r\n              // E.g. '1.' to '1', '.1' to '0.1'\r\n              s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');\r\n            }\r\n\r\n            if (str != s) return new BigNumber(s, base);\r\n          }\r\n\r\n          // '[BigNumber Error] Not a number: {n}'\r\n          // '[BigNumber Error] Not a base {b} number: {n}'\r\n          if (BigNumber.DEBUG) {\r\n            throw Error\r\n              (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);\r\n          }\r\n\r\n          // NaN\r\n          x.s = null;\r\n        }\r\n\r\n        x.c = x.e = null;\r\n      }\r\n    })();\r\n\r\n\r\n    /*\r\n     * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\r\n     * If r is truthy, it is known that there are more digits after the rounding digit.\r\n     */\r\n    function round(x, sd, rm, r) {\r\n      var d, i, j, k, n, ni, rd,\r\n        xc = x.c,\r\n        pows10 = POWS_TEN;\r\n\r\n      // if x is not Infinity or NaN...\r\n      if (xc) {\r\n\r\n        // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n        // n is a base 1e14 number, the value of the element of array x.c containing rd.\r\n        // ni is the index of n within x.c.\r\n        // d is the number of digits of n.\r\n        // i is the index of rd within n including leading zeros.\r\n        // j is the actual index of rd within n (if < 0, rd is a leading zero).\r\n        out: {\r\n\r\n          // Get the number of digits of the first element of xc.\r\n          for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);\r\n          i = sd - d;\r\n\r\n          // If the rounding digit is in the first element of xc...\r\n          if (i < 0) {\r\n            i += LOG_BASE;\r\n            j = sd;\r\n            n = xc[ni = 0];\r\n\r\n            // Get the rounding digit at index j of n.\r\n            rd = mathfloor(n / pows10[d - j - 1] % 10);\r\n          } else {\r\n            ni = mathceil((i + 1) / LOG_BASE);\r\n\r\n            if (ni >= xc.length) {\r\n\r\n              if (r) {\r\n\r\n                // Needed by sqrt.\r\n                for (; xc.length <= ni; xc.push(0));\r\n                n = rd = 0;\r\n                d = 1;\r\n                i %= LOG_BASE;\r\n                j = i - LOG_BASE + 1;\r\n              } else {\r\n                break out;\r\n              }\r\n            } else {\r\n              n = k = xc[ni];\r\n\r\n              // Get the number of digits of n.\r\n              for (d = 1; k >= 10; k /= 10, d++);\r\n\r\n              // Get the index of rd within n.\r\n              i %= LOG_BASE;\r\n\r\n              // Get the index of rd within n, adjusted for leading zeros.\r\n              // The number of leading zeros of n is given by LOG_BASE - d.\r\n              j = i - LOG_BASE + d;\r\n\r\n              // Get the rounding digit at index j of n.\r\n              rd = j < 0 ? 0 : mathfloor(n / pows10[d - j - 1] % 10);\r\n            }\r\n          }\r\n\r\n          r = r || sd < 0 ||\r\n\r\n          // Are there any non-zero digits after the rounding digit?\r\n          // The expression  n % pows10[d - j - 1]  returns all digits of n to the right\r\n          // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\r\n           xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);\r\n\r\n          r = rm < 4\r\n           ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n           : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&\r\n\r\n            // Check whether the digit to the left of the rounding digit is odd.\r\n            ((i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||\r\n             rm == (x.s < 0 ? 8 : 7));\r\n\r\n          if (sd < 1 || !xc[0]) {\r\n            xc.length = 0;\r\n\r\n            if (r) {\r\n\r\n              // Convert sd to decimal places.\r\n              sd -= x.e + 1;\r\n\r\n              // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n              xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];\r\n              x.e = -sd || 0;\r\n            } else {\r\n\r\n              // Zero.\r\n              xc[0] = x.e = 0;\r\n            }\r\n\r\n            return x;\r\n          }\r\n\r\n          // Remove excess digits.\r\n          if (i == 0) {\r\n            xc.length = ni;\r\n            k = 1;\r\n            ni--;\r\n          } else {\r\n            xc.length = ni + 1;\r\n            k = pows10[LOG_BASE - i];\r\n\r\n            // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n            // j > 0 means i > number of leading zeros of n.\r\n            xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;\r\n          }\r\n\r\n          // Round up?\r\n          if (r) {\r\n\r\n            for (; ;) {\r\n\r\n              // If the digit to be rounded up is in the first element of xc...\r\n              if (ni == 0) {\r\n\r\n                // i will be the length of xc[0] before k is added.\r\n                for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);\r\n                j = xc[0] += k;\r\n                for (k = 1; j >= 10; j /= 10, k++);\r\n\r\n                // if i != k the length has increased.\r\n                if (i != k) {\r\n                  x.e++;\r\n                  if (xc[0] == BASE) xc[0] = 1;\r\n                }\r\n\r\n                break;\r\n              } else {\r\n                xc[ni] += k;\r\n                if (xc[ni] != BASE) break;\r\n                xc[ni--] = 0;\r\n                k = 1;\r\n              }\r\n            }\r\n          }\r\n\r\n          // Remove trailing zeros.\r\n          for (i = xc.length; xc[--i] === 0; xc.pop());\r\n        }\r\n\r\n        // Overflow? Infinity.\r\n        if (x.e > MAX_EXP) {\r\n          x.c = x.e = null;\r\n\r\n        // Underflow? Zero.\r\n        } else if (x.e < MIN_EXP) {\r\n          x.c = [x.e = 0];\r\n        }\r\n      }\r\n\r\n      return x;\r\n    }\r\n\r\n\r\n    function valueOf(n) {\r\n      var str,\r\n        e = n.e;\r\n\r\n      if (e === null) return n.toString();\r\n\r\n      str = coeffToString(n.c);\r\n\r\n      str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n        ? toExponential(str, e)\r\n        : toFixedPoint(str, e, '0');\r\n\r\n      return n.s < 0 ? '-' + str : str;\r\n    }\r\n\r\n\r\n    // PROTOTYPE/INSTANCE METHODS\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the absolute value of this BigNumber.\r\n     */\r\n    P.absoluteValue = P.abs = function () {\r\n      var x = new BigNumber(this);\r\n      if (x.s < 0) x.s = 1;\r\n      return x;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return\r\n     *   1 if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n     *   -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n     *   0 if they have the same value,\r\n     *   or null if the value of either is NaN.\r\n     */\r\n    P.comparedTo = function (y, b) {\r\n      return compare(this, new BigNumber(y, b));\r\n    };\r\n\r\n\r\n    /*\r\n     * If dp is undefined or null or true or false, return the number of decimal places of the\r\n     * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n     *\r\n     * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this\r\n     * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or\r\n     * ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * [dp] {number} Decimal places: integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.decimalPlaces = P.dp = function (dp, rm) {\r\n      var c, n, v,\r\n        x = this;\r\n\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        if (rm == null) rm = ROUNDING_MODE;\r\n        else intCheck(rm, 0, 8);\r\n\r\n        return round(new BigNumber(x), dp + x.e + 1, rm);\r\n      }\r\n\r\n      if (!(c = x.c)) return null;\r\n      n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n      // Subtract the number of trailing zeros of the last number.\r\n      if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);\r\n      if (n < 0) n = 0;\r\n\r\n      return n;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n / 0 = I\r\n     *  n / N = N\r\n     *  n / I = 0\r\n     *  0 / n = 0\r\n     *  0 / 0 = N\r\n     *  0 / N = N\r\n     *  0 / I = 0\r\n     *  N / n = N\r\n     *  N / 0 = N\r\n     *  N / N = N\r\n     *  N / I = N\r\n     *  I / n = I\r\n     *  I / 0 = I\r\n     *  I / N = N\r\n     *  I / I = N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\r\n     * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     */\r\n    P.dividedBy = P.div = function (y, b) {\r\n      return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the integer part of dividing the value of this\r\n     * BigNumber by the value of BigNumber(y, b).\r\n     */\r\n    P.dividedToIntegerBy = P.idiv = function (y, b) {\r\n      return div(this, new BigNumber(y, b), 0, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.\r\n     *\r\n     * If m is present, return the result modulo m.\r\n     * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.\r\n     *\r\n     * The modular power operation works efficiently when x, n, and m are integers, otherwise it\r\n     * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.\r\n     *\r\n     * n {number|string|BigNumber} The exponent. An integer.\r\n     * [m] {number|string|BigNumber} The modulus.\r\n     *\r\n     * '[BigNumber Error] Exponent not an integer: {n}'\r\n     */\r\n    P.exponentiatedBy = P.pow = function (n, m) {\r\n      var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y,\r\n        x = this;\r\n\r\n      n = new BigNumber(n);\r\n\r\n      // Allow NaN and ±Infinity, but not other non-integers.\r\n      if (n.c && !n.isInteger()) {\r\n        throw Error\r\n          (bignumberError + 'Exponent not an integer: ' + valueOf(n));\r\n      }\r\n\r\n      if (m != null) m = new BigNumber(m);\r\n\r\n      // Exponent of MAX_SAFE_INTEGER is 15.\r\n      nIsBig = n.e > 14;\r\n\r\n      // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.\r\n      if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {\r\n\r\n        // The sign of the result of pow when x is negative depends on the evenness of n.\r\n        // If +n overflows to ±Infinity, the evenness of n would be not be known.\r\n        y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? n.s * (2 - isOdd(n)) : +valueOf(n)));\r\n        return m ? y.mod(m) : y;\r\n      }\r\n\r\n      nIsNeg = n.s < 0;\r\n\r\n      if (m) {\r\n\r\n        // x % m returns NaN if abs(m) is zero, or m is NaN.\r\n        if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);\r\n\r\n        isModExp = !nIsNeg && x.isInteger() && m.isInteger();\r\n\r\n        if (isModExp) x = x.mod(m);\r\n\r\n      // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.\r\n      // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.\r\n      } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0\r\n        // [1, 240000000]\r\n        ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7\r\n        // [80000000000000]  [99999750000000]\r\n        : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {\r\n\r\n        // If x is negative and n is odd, k = -0, else k = 0.\r\n        k = x.s < 0 && isOdd(n) ? -0 : 0;\r\n\r\n        // If x >= 1, k = ±Infinity.\r\n        if (x.e > -1) k = 1 / k;\r\n\r\n        // If n is negative return ±0, else return ±Infinity.\r\n        return new BigNumber(nIsNeg ? 1 / k : k);\r\n\r\n      } else if (POW_PRECISION) {\r\n\r\n        // Truncating each coefficient array to a length of k after each multiplication\r\n        // equates to truncating significant digits to POW_PRECISION + [28, 41],\r\n        // i.e. there will be a minimum of 28 guard digits retained.\r\n        k = mathceil(POW_PRECISION / LOG_BASE + 2);\r\n      }\r\n\r\n      if (nIsBig) {\r\n        half = new BigNumber(0.5);\r\n        if (nIsNeg) n.s = 1;\r\n        nIsOdd = isOdd(n);\r\n      } else {\r\n        i = Math.abs(+valueOf(n));\r\n        nIsOdd = i % 2;\r\n      }\r\n\r\n      y = new BigNumber(ONE);\r\n\r\n      // Performs 54 loop iterations for n of 9007199254740991.\r\n      for (; ;) {\r\n\r\n        if (nIsOdd) {\r\n          y = y.times(x);\r\n          if (!y.c) break;\r\n\r\n          if (k) {\r\n            if (y.c.length > k) y.c.length = k;\r\n          } else if (isModExp) {\r\n            y = y.mod(m);    //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));\r\n          }\r\n        }\r\n\r\n        if (i) {\r\n          i = mathfloor(i / 2);\r\n          if (i === 0) break;\r\n          nIsOdd = i % 2;\r\n        } else {\r\n          n = n.times(half);\r\n          round(n, n.e + 1, 1);\r\n\r\n          if (n.e > 14) {\r\n            nIsOdd = isOdd(n);\r\n          } else {\r\n            i = +valueOf(n);\r\n            if (i === 0) break;\r\n            nIsOdd = i % 2;\r\n          }\r\n        }\r\n\r\n        x = x.times(x);\r\n\r\n        if (k) {\r\n          if (x.c && x.c.length > k) x.c.length = k;\r\n        } else if (isModExp) {\r\n          x = x.mod(m);    //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));\r\n        }\r\n      }\r\n\r\n      if (isModExp) return y;\r\n      if (nIsNeg) y = ONE.div(y);\r\n\r\n      return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer\r\n     * using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'\r\n     */\r\n    P.integerValue = function (rm) {\r\n      var n = new BigNumber(this);\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n      return round(n, n.e + 1, rm);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isEqualTo = P.eq = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) === 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is a finite number, otherwise return false.\r\n     */\r\n    P.isFinite = function () {\r\n      return !!this.c;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isGreaterThan = P.gt = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) > 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is greater than or equal to the value of\r\n     * BigNumber(y, b), otherwise return false.\r\n     */\r\n    P.isGreaterThanOrEqualTo = P.gte = function (y, b) {\r\n      return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;\r\n\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is an integer, otherwise return false.\r\n     */\r\n    P.isInteger = function () {\r\n      return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n     * otherwise return false.\r\n     */\r\n    P.isLessThan = P.lt = function (y, b) {\r\n      return compare(this, new BigNumber(y, b)) < 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is less than or equal to the value of\r\n     * BigNumber(y, b), otherwise return false.\r\n     */\r\n    P.isLessThanOrEqualTo = P.lte = function (y, b) {\r\n      return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is NaN, otherwise return false.\r\n     */\r\n    P.isNaN = function () {\r\n      return !this.s;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is negative, otherwise return false.\r\n     */\r\n    P.isNegative = function () {\r\n      return this.s < 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is positive, otherwise return false.\r\n     */\r\n    P.isPositive = function () {\r\n      return this.s > 0;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return true if the value of this BigNumber is 0 or -0, otherwise return false.\r\n     */\r\n    P.isZero = function () {\r\n      return !!this.c && this.c[0] == 0;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n - 0 = n\r\n     *  n - N = N\r\n     *  n - I = -I\r\n     *  0 - n = -n\r\n     *  0 - 0 = 0\r\n     *  0 - N = N\r\n     *  0 - I = -I\r\n     *  N - n = N\r\n     *  N - 0 = N\r\n     *  N - N = N\r\n     *  N - I = N\r\n     *  I - n = I\r\n     *  I - 0 = I\r\n     *  I - N = N\r\n     *  I - I = N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber minus the value of\r\n     * BigNumber(y, b).\r\n     */\r\n    P.minus = function (y, b) {\r\n      var i, j, t, xLTy,\r\n        x = this,\r\n        a = x.s;\r\n\r\n      y = new BigNumber(y, b);\r\n      b = y.s;\r\n\r\n      // Either NaN?\r\n      if (!a || !b) return new BigNumber(NaN);\r\n\r\n      // Signs differ?\r\n      if (a != b) {\r\n        y.s = -b;\r\n        return x.plus(y);\r\n      }\r\n\r\n      var xe = x.e / LOG_BASE,\r\n        ye = y.e / LOG_BASE,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      if (!xe || !ye) {\r\n\r\n        // Either Infinity?\r\n        if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);\r\n\r\n        // Either zero?\r\n        if (!xc[0] || !yc[0]) {\r\n\r\n          // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n          return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :\r\n\r\n           // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\r\n           ROUNDING_MODE == 3 ? -0 : 0);\r\n        }\r\n      }\r\n\r\n      xe = bitFloor(xe);\r\n      ye = bitFloor(ye);\r\n      xc = xc.slice();\r\n\r\n      // Determine which is the bigger number.\r\n      if (a = xe - ye) {\r\n\r\n        if (xLTy = a < 0) {\r\n          a = -a;\r\n          t = xc;\r\n        } else {\r\n          ye = xe;\r\n          t = yc;\r\n        }\r\n\r\n        t.reverse();\r\n\r\n        // Prepend zeros to equalise exponents.\r\n        for (b = a; b--; t.push(0));\r\n        t.reverse();\r\n      } else {\r\n\r\n        // Exponents equal. Check digit by digit.\r\n        j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;\r\n\r\n        for (a = b = 0; b < j; b++) {\r\n\r\n          if (xc[b] != yc[b]) {\r\n            xLTy = xc[b] < yc[b];\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      // x < y? Point xc to the array of the bigger number.\r\n      if (xLTy) {\r\n        t = xc;\r\n        xc = yc;\r\n        yc = t;\r\n        y.s = -y.s;\r\n      }\r\n\r\n      b = (j = yc.length) - (i = xc.length);\r\n\r\n      // Append zeros to xc if shorter.\r\n      // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\r\n      if (b > 0) for (; b--; xc[i++] = 0);\r\n      b = BASE - 1;\r\n\r\n      // Subtract yc from xc.\r\n      for (; j > a;) {\r\n\r\n        if (xc[--j] < yc[j]) {\r\n          for (i = j; i && !xc[--i]; xc[i] = b);\r\n          --xc[i];\r\n          xc[j] += BASE;\r\n        }\r\n\r\n        xc[j] -= yc[j];\r\n      }\r\n\r\n      // Remove leading zeros and adjust exponent accordingly.\r\n      for (; xc[0] == 0; xc.splice(0, 1), --ye);\r\n\r\n      // Zero?\r\n      if (!xc[0]) {\r\n\r\n        // Following IEEE 754 (2008) 6.3,\r\n        // n - n = +0  but  n - n = -0  when rounding towards -Infinity.\r\n        y.s = ROUNDING_MODE == 3 ? -1 : 1;\r\n        y.c = [y.e = 0];\r\n        return y;\r\n      }\r\n\r\n      // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\r\n      // for finite x and y.\r\n      return normalise(y, xc, ye);\r\n    };\r\n\r\n\r\n    /*\r\n     *   n % 0 =  N\r\n     *   n % N =  N\r\n     *   n % I =  n\r\n     *   0 % n =  0\r\n     *  -0 % n = -0\r\n     *   0 % 0 =  N\r\n     *   0 % N =  N\r\n     *   0 % I =  0\r\n     *   N % n =  N\r\n     *   N % 0 =  N\r\n     *   N % N =  N\r\n     *   N % I =  N\r\n     *   I % n =  N\r\n     *   I % 0 =  N\r\n     *   I % N =  N\r\n     *   I % I =  N\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\r\n     * BigNumber(y, b). The result depends on the value of MODULO_MODE.\r\n     */\r\n    P.modulo = P.mod = function (y, b) {\r\n      var q, s,\r\n        x = this;\r\n\r\n      y = new BigNumber(y, b);\r\n\r\n      // Return NaN if x is Infinity or NaN, or y is NaN or zero.\r\n      if (!x.c || !y.s || y.c && !y.c[0]) {\r\n        return new BigNumber(NaN);\r\n\r\n      // Return x if y is Infinity or x is zero.\r\n      } else if (!y.c || x.c && !x.c[0]) {\r\n        return new BigNumber(x);\r\n      }\r\n\r\n      if (MODULO_MODE == 9) {\r\n\r\n        // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n        // r = x - qy    where  0 <= r < abs(y)\r\n        s = y.s;\r\n        y.s = 1;\r\n        q = div(x, y, 0, 3);\r\n        y.s = s;\r\n        q.s *= s;\r\n      } else {\r\n        q = div(x, y, 0, MODULO_MODE);\r\n      }\r\n\r\n      y = x.minus(q.times(y));\r\n\r\n      // To match JavaScript %, ensure sign of zero is sign of dividend.\r\n      if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;\r\n\r\n      return y;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n * 0 = 0\r\n     *  n * N = N\r\n     *  n * I = I\r\n     *  0 * n = 0\r\n     *  0 * 0 = 0\r\n     *  0 * N = N\r\n     *  0 * I = N\r\n     *  N * n = N\r\n     *  N * 0 = N\r\n     *  N * N = N\r\n     *  N * I = N\r\n     *  I * n = I\r\n     *  I * 0 = N\r\n     *  I * N = N\r\n     *  I * I = I\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value\r\n     * of BigNumber(y, b).\r\n     */\r\n    P.multipliedBy = P.times = function (y, b) {\r\n      var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,\r\n        base, sqrtBase,\r\n        x = this,\r\n        xc = x.c,\r\n        yc = (y = new BigNumber(y, b)).c;\r\n\r\n      // Either NaN, ±Infinity or ±0?\r\n      if (!xc || !yc || !xc[0] || !yc[0]) {\r\n\r\n        // Return NaN if either is NaN, or one is 0 and the other is Infinity.\r\n        if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {\r\n          y.c = y.e = y.s = null;\r\n        } else {\r\n          y.s *= x.s;\r\n\r\n          // Return ±Infinity if either is ±Infinity.\r\n          if (!xc || !yc) {\r\n            y.c = y.e = null;\r\n\r\n          // Return ±0 if either is ±0.\r\n          } else {\r\n            y.c = [0];\r\n            y.e = 0;\r\n          }\r\n        }\r\n\r\n        return y;\r\n      }\r\n\r\n      e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);\r\n      y.s *= x.s;\r\n      xcL = xc.length;\r\n      ycL = yc.length;\r\n\r\n      // Ensure xc points to longer array and xcL to its length.\r\n      if (xcL < ycL) {\r\n        zc = xc;\r\n        xc = yc;\r\n        yc = zc;\r\n        i = xcL;\r\n        xcL = ycL;\r\n        ycL = i;\r\n      }\r\n\r\n      // Initialise the result array with zeros.\r\n      for (i = xcL + ycL, zc = []; i--; zc.push(0));\r\n\r\n      base = BASE;\r\n      sqrtBase = SQRT_BASE;\r\n\r\n      for (i = ycL; --i >= 0;) {\r\n        c = 0;\r\n        ylo = yc[i] % sqrtBase;\r\n        yhi = yc[i] / sqrtBase | 0;\r\n\r\n        for (k = xcL, j = i + k; j > i;) {\r\n          xlo = xc[--k] % sqrtBase;\r\n          xhi = xc[k] / sqrtBase | 0;\r\n          m = yhi * xlo + xhi * ylo;\r\n          xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;\r\n          c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;\r\n          zc[j--] = xlo % base;\r\n        }\r\n\r\n        zc[j] = c;\r\n      }\r\n\r\n      if (c) {\r\n        ++e;\r\n      } else {\r\n        zc.splice(0, 1);\r\n      }\r\n\r\n      return normalise(y, zc, e);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber negated,\r\n     * i.e. multiplied by -1.\r\n     */\r\n    P.negated = function () {\r\n      var x = new BigNumber(this);\r\n      x.s = -x.s || null;\r\n      return x;\r\n    };\r\n\r\n\r\n    /*\r\n     *  n + 0 = n\r\n     *  n + N = N\r\n     *  n + I = I\r\n     *  0 + n = n\r\n     *  0 + 0 = 0\r\n     *  0 + N = N\r\n     *  0 + I = I\r\n     *  N + n = N\r\n     *  N + 0 = N\r\n     *  N + N = N\r\n     *  N + I = N\r\n     *  I + n = I\r\n     *  I + 0 = I\r\n     *  I + N = N\r\n     *  I + I = I\r\n     *\r\n     * Return a new BigNumber whose value is the value of this BigNumber plus the value of\r\n     * BigNumber(y, b).\r\n     */\r\n    P.plus = function (y, b) {\r\n      var t,\r\n        x = this,\r\n        a = x.s;\r\n\r\n      y = new BigNumber(y, b);\r\n      b = y.s;\r\n\r\n      // Either NaN?\r\n      if (!a || !b) return new BigNumber(NaN);\r\n\r\n      // Signs differ?\r\n       if (a != b) {\r\n        y.s = -b;\r\n        return x.minus(y);\r\n      }\r\n\r\n      var xe = x.e / LOG_BASE,\r\n        ye = y.e / LOG_BASE,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      if (!xe || !ye) {\r\n\r\n        // Return ±Infinity if either ±Infinity.\r\n        if (!xc || !yc) return new BigNumber(a / 0);\r\n\r\n        // Either zero?\r\n        // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n        if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);\r\n      }\r\n\r\n      xe = bitFloor(xe);\r\n      ye = bitFloor(ye);\r\n      xc = xc.slice();\r\n\r\n      // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\r\n      if (a = xe - ye) {\r\n        if (a > 0) {\r\n          ye = xe;\r\n          t = yc;\r\n        } else {\r\n          a = -a;\r\n          t = xc;\r\n        }\r\n\r\n        t.reverse();\r\n        for (; a--; t.push(0));\r\n        t.reverse();\r\n      }\r\n\r\n      a = xc.length;\r\n      b = yc.length;\r\n\r\n      // Point xc to the longer array, and b to the shorter length.\r\n      if (a - b < 0) {\r\n        t = yc;\r\n        yc = xc;\r\n        xc = t;\r\n        b = a;\r\n      }\r\n\r\n      // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\r\n      for (a = 0; b;) {\r\n        a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;\r\n        xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;\r\n      }\r\n\r\n      if (a) {\r\n        xc = [a].concat(xc);\r\n        ++ye;\r\n      }\r\n\r\n      // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n      // ye = MAX_EXP + 1 possible\r\n      return normalise(y, xc, ye);\r\n    };\r\n\r\n\r\n    /*\r\n     * If sd is undefined or null or true or false, return the number of significant digits of\r\n     * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n     * If sd is true include integer-part trailing zeros in the count.\r\n     *\r\n     * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this\r\n     * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or\r\n     * ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.\r\n     *                     boolean: whether to count integer-part trailing zeros: true or false.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n     */\r\n    P.precision = P.sd = function (sd, rm) {\r\n      var c, n, v,\r\n        x = this;\r\n\r\n      if (sd != null && sd !== !!sd) {\r\n        intCheck(sd, 1, MAX);\r\n        if (rm == null) rm = ROUNDING_MODE;\r\n        else intCheck(rm, 0, 8);\r\n\r\n        return round(new BigNumber(x), sd, rm);\r\n      }\r\n\r\n      if (!(c = x.c)) return null;\r\n      v = c.length - 1;\r\n      n = v * LOG_BASE + 1;\r\n\r\n      if (v = c[v]) {\r\n\r\n        // Subtract the number of trailing zeros of the last element.\r\n        for (; v % 10 == 0; v /= 10, n--);\r\n\r\n        // Add the number of digits of the first element.\r\n        for (v = c[0]; v >= 10; v /= 10, n++);\r\n      }\r\n\r\n      if (sd && x.e + 1 > n) n = x.e + 1;\r\n\r\n      return n;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\r\n     * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\r\n     *\r\n     * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'\r\n     */\r\n    P.shiftedBy = function (k) {\r\n      intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);\r\n      return this.times('1e' + k);\r\n    };\r\n\r\n\r\n    /*\r\n     *  sqrt(-n) =  N\r\n     *  sqrt(N) =  N\r\n     *  sqrt(-I) =  N\r\n     *  sqrt(I) =  I\r\n     *  sqrt(0) =  0\r\n     *  sqrt(-0) = -0\r\n     *\r\n     * Return a new BigNumber whose value is the square root of the value of this BigNumber,\r\n     * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n     */\r\n    P.squareRoot = P.sqrt = function () {\r\n      var m, n, r, rep, t,\r\n        x = this,\r\n        c = x.c,\r\n        s = x.s,\r\n        e = x.e,\r\n        dp = DECIMAL_PLACES + 4,\r\n        half = new BigNumber('0.5');\r\n\r\n      // Negative/NaN/Infinity/zero?\r\n      if (s !== 1 || !c || !c[0]) {\r\n        return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);\r\n      }\r\n\r\n      // Initial estimate.\r\n      s = Math.sqrt(+valueOf(x));\r\n\r\n      // Math.sqrt underflow/overflow?\r\n      // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n      if (s == 0 || s == 1 / 0) {\r\n        n = coeffToString(c);\r\n        if ((n.length + e) % 2 == 0) n += '0';\r\n        s = Math.sqrt(+n);\r\n        e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n        if (s == 1 / 0) {\r\n          n = '5e' + e;\r\n        } else {\r\n          n = s.toExponential();\r\n          n = n.slice(0, n.indexOf('e') + 1) + e;\r\n        }\r\n\r\n        r = new BigNumber(n);\r\n      } else {\r\n        r = new BigNumber(s + '');\r\n      }\r\n\r\n      // Check for zero.\r\n      // r could be zero if MIN_EXP is changed after the this value was created.\r\n      // This would cause a division by zero (x/t) and hence Infinity below, which would cause\r\n      // coeffToString to throw.\r\n      if (r.c[0]) {\r\n        e = r.e;\r\n        s = e + dp;\r\n        if (s < 3) s = 0;\r\n\r\n        // Newton-Raphson iteration.\r\n        for (; ;) {\r\n          t = r;\r\n          r = half.times(t.plus(div(x, t, dp, 1)));\r\n\r\n          if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {\r\n\r\n            // The exponent of r may here be one less than the final result exponent,\r\n            // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\r\n            // are indexed correctly.\r\n            if (r.e < e) --s;\r\n            n = n.slice(s - 3, s + 1);\r\n\r\n            // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\r\n            // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\r\n            // iteration.\r\n            if (n == '9999' || !rep && n == '4999') {\r\n\r\n              // On the first iteration only, check to see if rounding up gives the\r\n              // exact result as the nines may infinitely repeat.\r\n              if (!rep) {\r\n                round(t, t.e + DECIMAL_PLACES + 2, 0);\r\n\r\n                if (t.times(t).eq(x)) {\r\n                  r = t;\r\n                  break;\r\n                }\r\n              }\r\n\r\n              dp += 4;\r\n              s += 4;\r\n              rep = 1;\r\n            } else {\r\n\r\n              // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\r\n              // result. If not, then there are further digits and m will be truthy.\r\n              if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n                // Truncate to the first rounding digit.\r\n                round(r, r.e + DECIMAL_PLACES + 2, 1);\r\n                m = !r.times(r).eq(x);\r\n              }\r\n\r\n              break;\r\n            }\r\n          }\r\n        }\r\n      }\r\n\r\n      return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in exponential notation and\r\n     * rounded using ROUNDING_MODE to dp fixed decimal places.\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.toExponential = function (dp, rm) {\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        dp++;\r\n      }\r\n      return format(this, dp, rm, 1);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in fixed-point notation rounding\r\n     * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n     *\r\n     * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\r\n     * but e.g. (-0.00001).toFixed(0) is '-0'.\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     */\r\n    P.toFixed = function (dp, rm) {\r\n      if (dp != null) {\r\n        intCheck(dp, 0, MAX);\r\n        dp = dp + this.e + 1;\r\n      }\r\n      return format(this, dp, rm);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in fixed-point notation rounded\r\n     * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\r\n     * of the format or FORMAT object (see BigNumber.set).\r\n     *\r\n     * The formatting object may contain some or all of the properties shown below.\r\n     *\r\n     * FORMAT = {\r\n     *   prefix: '',\r\n     *   groupSize: 3,\r\n     *   secondaryGroupSize: 0,\r\n     *   groupSeparator: ',',\r\n     *   decimalSeparator: '.',\r\n     *   fractionGroupSize: 0,\r\n     *   fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n     *   suffix: ''\r\n     * };\r\n     *\r\n     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     * [format] {object} Formatting options. See FORMAT pbject above.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n     * '[BigNumber Error] Argument not an object: {format}'\r\n     */\r\n    P.toFormat = function (dp, rm, format) {\r\n      var str,\r\n        x = this;\r\n\r\n      if (format == null) {\r\n        if (dp != null && rm && typeof rm == 'object') {\r\n          format = rm;\r\n          rm = null;\r\n        } else if (dp && typeof dp == 'object') {\r\n          format = dp;\r\n          dp = rm = null;\r\n        } else {\r\n          format = FORMAT;\r\n        }\r\n      } else if (typeof format != 'object') {\r\n        throw Error\r\n          (bignumberError + 'Argument not an object: ' + format);\r\n      }\r\n\r\n      str = x.toFixed(dp, rm);\r\n\r\n      if (x.c) {\r\n        var i,\r\n          arr = str.split('.'),\r\n          g1 = +format.groupSize,\r\n          g2 = +format.secondaryGroupSize,\r\n          groupSeparator = format.groupSeparator || '',\r\n          intPart = arr[0],\r\n          fractionPart = arr[1],\r\n          isNeg = x.s < 0,\r\n          intDigits = isNeg ? intPart.slice(1) : intPart,\r\n          len = intDigits.length;\r\n\r\n        if (g2) {\r\n          i = g1;\r\n          g1 = g2;\r\n          g2 = i;\r\n          len -= i;\r\n        }\r\n\r\n        if (g1 > 0 && len > 0) {\r\n          i = len % g1 || g1;\r\n          intPart = intDigits.substr(0, i);\r\n          for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);\r\n          if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);\r\n          if (isNeg) intPart = '-' + intPart;\r\n        }\r\n\r\n        str = fractionPart\r\n         ? intPart + (format.decimalSeparator || '') + ((g2 = +format.fractionGroupSize)\r\n          ? fractionPart.replace(new RegExp('\\\\d{' + g2 + '}\\\\B', 'g'),\r\n           '$&' + (format.fractionGroupSeparator || ''))\r\n          : fractionPart)\r\n         : intPart;\r\n      }\r\n\r\n      return (format.prefix || '') + str + (format.suffix || '');\r\n    };\r\n\r\n\r\n    /*\r\n     * Return an array of two BigNumbers representing the value of this BigNumber as a simple\r\n     * fraction with an integer numerator and an integer denominator.\r\n     * The denominator will be a positive non-zero value less than or equal to the specified\r\n     * maximum denominator. If a maximum denominator is not specified, the denominator will be\r\n     * the lowest value necessary to represent the number exactly.\r\n     *\r\n     * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.\r\n     *\r\n     * '[BigNumber Error] Argument {not an integer|out of range} : {md}'\r\n     */\r\n    P.toFraction = function (md) {\r\n      var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s,\r\n        x = this,\r\n        xc = x.c;\r\n\r\n      if (md != null) {\r\n        n = new BigNumber(md);\r\n\r\n        // Throw if md is less than one or is not an integer, unless it is Infinity.\r\n        if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {\r\n          throw Error\r\n            (bignumberError + 'Argument ' +\r\n              (n.isInteger() ? 'out of range: ' : 'not an integer: ') + valueOf(n));\r\n        }\r\n      }\r\n\r\n      if (!xc) return new BigNumber(x);\r\n\r\n      d = new BigNumber(ONE);\r\n      n1 = d0 = new BigNumber(ONE);\r\n      d1 = n0 = new BigNumber(ONE);\r\n      s = coeffToString(xc);\r\n\r\n      // Determine initial denominator.\r\n      // d is a power of 10 and the minimum max denominator that specifies the value exactly.\r\n      e = d.e = s.length - x.e - 1;\r\n      d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];\r\n      md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;\r\n\r\n      exp = MAX_EXP;\r\n      MAX_EXP = 1 / 0;\r\n      n = new BigNumber(s);\r\n\r\n      // n0 = d1 = 0\r\n      n0.c[0] = 0;\r\n\r\n      for (; ;)  {\r\n        q = div(n, d, 0, 1);\r\n        d2 = d0.plus(q.times(d1));\r\n        if (d2.comparedTo(md) == 1) break;\r\n        d0 = d1;\r\n        d1 = d2;\r\n        n1 = n0.plus(q.times(d2 = n1));\r\n        n0 = d2;\r\n        d = n.minus(q.times(d2 = d));\r\n        n = d2;\r\n      }\r\n\r\n      d2 = div(md.minus(d0), d1, 0, 1);\r\n      n0 = n0.plus(d2.times(n1));\r\n      d0 = d0.plus(d2.times(d1));\r\n      n0.s = n1.s = x.s;\r\n      e = e * 2;\r\n\r\n      // Determine which fraction is closer to x, n0/d0 or n1/d1\r\n      r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(\r\n          div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];\r\n\r\n      MAX_EXP = exp;\r\n\r\n      return r;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return the value of this BigNumber converted to a number primitive.\r\n     */\r\n    P.toNumber = function () {\r\n      return +valueOf(this);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber rounded to sd significant digits\r\n     * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\r\n     * necessary to represent the integer part of the value in fixed-point notation, then use\r\n     * exponential notation.\r\n     *\r\n     * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n     *\r\n     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n     */\r\n    P.toPrecision = function (sd, rm) {\r\n      if (sd != null) intCheck(sd, 1, MAX);\r\n      return format(this, sd, rm, 2);\r\n    };\r\n\r\n\r\n    /*\r\n     * Return a string representing the value of this BigNumber in base b, or base 10 if b is\r\n     * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\r\n     * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\r\n     * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\r\n     * TO_EXP_NEG, return exponential notation.\r\n     *\r\n     * [b] {number} Integer, 2 to ALPHABET.length inclusive.\r\n     *\r\n     * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n     */\r\n    P.toString = function (b) {\r\n      var str,\r\n        n = this,\r\n        s = n.s,\r\n        e = n.e;\r\n\r\n      // Infinity or NaN?\r\n      if (e === null) {\r\n        if (s) {\r\n          str = 'Infinity';\r\n          if (s < 0) str = '-' + str;\r\n        } else {\r\n          str = 'NaN';\r\n        }\r\n      } else {\r\n        if (b == null) {\r\n          str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n           ? toExponential(coeffToString(n.c), e)\r\n           : toFixedPoint(coeffToString(n.c), e, '0');\r\n        } else if (b === 10 && alphabetHasNormalDecimalDigits) {\r\n          n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);\r\n          str = toFixedPoint(coeffToString(n.c), n.e, '0');\r\n        } else {\r\n          intCheck(b, 2, ALPHABET.length, 'Base');\r\n          str = convertBase(toFixedPoint(coeffToString(n.c), e, '0'), 10, b, s, true);\r\n        }\r\n\r\n        if (s < 0 && n.c[0]) str = '-' + str;\r\n      }\r\n\r\n      return str;\r\n    };\r\n\r\n\r\n    /*\r\n     * Return as toString, but do not accept a base argument, and include the minus sign for\r\n     * negative zero.\r\n     */\r\n    P.valueOf = P.toJSON = function () {\r\n      return valueOf(this);\r\n    };\r\n\r\n\r\n    P._isBigNumber = true;\r\n\r\n    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","function _assertThisInitialized(e) {\n  if (void 0 === e) throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  return e;\n}\nexport { _assertThisInitialized as default };","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperties(e, r) {\n  for (var t = 0; t < r.length; t++) {\n    var o = r[t];\n    o.enumerable = o.enumerable || !1, o.configurable = !0, \"value\" in o && (o.writable = !0), Object.defineProperty(e, toPropertyKey(o.key), o);\n  }\n}\nfunction _createClass(e, r, t) {\n  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, \"prototype\", {\n    writable: !1\n  }), e;\n}\nexport { _createClass as default };","function _extends() {\n  return _extends = Object.assign ? Object.assign.bind() : function (n) {\n    for (var e = 1; e < arguments.length; e++) {\n      var t = arguments[e];\n      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);\n    }\n    return n;\n  }, _extends.apply(null, arguments);\n}\nexport { _extends as default };","import setPrototypeOf from \"./setPrototypeOf.js\";\nfunction _inheritsLoose(t, o) {\n  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, setPrototypeOf(t, o);\n}\nexport { _inheritsLoose as default };","import toPropertyKey from \"./toPropertyKey.js\";\nfunction _defineProperty(e, r, t) {\n  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {\n    value: t,\n    enumerable: !0,\n    configurable: !0,\n    writable: !0\n  }) : e[r] = t, e;\n}\nexport { _defineProperty as default };","import defineProperty from \"./defineProperty.js\";\nfunction ownKeys(e, r) {\n  var t = Object.keys(e);\n  if (Object.getOwnPropertySymbols) {\n    var o = Object.getOwnPropertySymbols(e);\n    r && (o = o.filter(function (r) {\n      return Object.getOwnPropertyDescriptor(e, r).enumerable;\n    })), t.push.apply(t, o);\n  }\n  return t;\n}\nfunction _objectSpread2(e) {\n  for (var r = 1; r < arguments.length; r++) {\n    var t = null != arguments[r] ? arguments[r] : {};\n    r % 2 ? ownKeys(Object(t), !0).forEach(function (r) {\n      defineProperty(e, r, t[r]);\n    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {\n      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));\n    });\n  }\n  return e;\n}\nexport { _objectSpread2 as default };","function _objectWithoutPropertiesLoose(r, e) {\n  if (null == r) return {};\n  var t = {};\n  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {\n    if (e.includes(n)) continue;\n    t[n] = r[n];\n  }\n  return t;\n}\nexport { _objectWithoutPropertiesLoose as default };","function _setPrototypeOf(t, e) {\n  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {\n    return t.__proto__ = e, t;\n  }, _setPrototypeOf(t, e);\n}\nexport { _setPrototypeOf as default };","function _arrayLikeToArray(r, a) {\n  (null == a || a > r.length) && (a = r.length);\n  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];\n  return n;\n}\nexport { _arrayLikeToArray as default };","import arrayWithoutHoles from \"./arrayWithoutHoles.js\";\nimport iterableToArray from \"./iterableToArray.js\";\nimport unsupportedIterableToArray from \"./unsupportedIterableToArray.js\";\nimport nonIterableSpread from \"./nonIterableSpread.js\";\nfunction _toConsumableArray(r) {\n  return arrayWithoutHoles(r) || iterableToArray(r) || unsupportedIterableToArray(r) || nonIterableSpread();\n}\nexport { _toConsumableArray as default };","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nfunction _arrayWithoutHoles(r) {\n  if (Array.isArray(r)) return arrayLikeToArray(r);\n}\nexport { _arrayWithoutHoles as default };","function _iterableToArray(r) {\n  if (\"undefined\" != typeof Symbol && null != r[Symbol.iterator] || null != r[\"@@iterator\"]) return Array.from(r);\n}\nexport { _iterableToArray as default };","import arrayLikeToArray from \"./arrayLikeToArray.js\";\nfunction _unsupportedIterableToArray(r, a) {\n  if (r) {\n    if (\"string\" == typeof r) return arrayLikeToArray(r, a);\n    var t = {}.toString.call(r).slice(8, -1);\n    return \"Object\" === t && r.constructor && (t = r.constructor.name), \"Map\" === t || \"Set\" === t ? Array.from(r) : \"Arguments\" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0;\n  }\n}\nexport { _unsupportedIterableToArray as default };","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nexport { _nonIterableSpread as default };","function _typeof(o) {\n  \"@babel/helpers - typeof\";\n\n  return _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (o) {\n    return typeof o;\n  } : function (o) {\n    return o && \"function\" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? \"symbol\" : typeof o;\n  }, _typeof(o);\n}\nexport { _typeof as default };","import _typeof from \"./typeof.js\";\nimport toPrimitive from \"./toPrimitive.js\";\nfunction toPropertyKey(t) {\n  var i = toPrimitive(t, \"string\");\n  return \"symbol\" == _typeof(i) ? i : i + \"\";\n}\nexport { toPropertyKey as default };","import _typeof from \"./typeof.js\";\nfunction toPrimitive(t, r) {\n  if (\"object\" != _typeof(t) || !t) return t;\n  var e = t[Symbol.toPrimitive];\n  if (void 0 !== e) {\n    var i = e.call(t, r || \"default\");\n    if (\"object\" != _typeof(i)) return i;\n    throw new TypeError(\"@@toPrimitive must return a primitive value.\");\n  }\n  return (\"string\" === r ? String : Number)(t);\n}\nexport { toPrimitive as default };","// created 2024-09-13T06:42:45.675Z\n// compressed base64-encoded blob for include-ens data\n// source: https://github.com/adraffy/ens-normalize.js/blob/main/src/make.js\n// see: https://github.com/adraffy/ens-normalize.js#security\n// SHA-256: 0ca3917bee1eee342d64c631cb1dbaac37b167d848887d59f6d68328dc99ac09\nvar COMPRESSED$1 = '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';\nconst FENCED = new Map([[8217,\"apostrophe\"],[8260,\"fraction slash\"],[12539,\"middle dot\"]]);\nconst NSM_MAX = 4;\n\nfunction decode_arithmetic(bytes) {\r\n\tlet pos = 0;\r\n\tfunction u16() { return (bytes[pos++] << 8) | bytes[pos++]; }\r\n\t\r\n\t// decode the frequency table\r\n\tlet symbol_count = u16();\r\n\tlet total = 1;\r\n\tlet acc = [0, 1]; // first symbol has frequency 1\r\n\tfor (let i = 1; i < symbol_count; i++) {\r\n\t\tacc.push(total += u16());\r\n\t}\r\n\r\n\t// skip the sized-payload that the last 3 symbols index into\r\n\tlet skip = u16();\r\n\tlet pos_payload = pos;\r\n\tpos += skip;\r\n\r\n\tlet read_width = 0;\r\n\tlet read_buffer = 0; \r\n\tfunction read_bit() {\r\n\t\tif (read_width == 0) {\r\n\t\t\t// this will read beyond end of buffer\r\n\t\t\t// but (undefined|0) => zero pad\r\n\t\t\tread_buffer = (read_buffer << 8) | bytes[pos++];\r\n\t\t\tread_width = 8;\r\n\t\t}\r\n\t\treturn (read_buffer >> --read_width) & 1;\r\n\t}\r\n\r\n\tconst N = 31;\r\n\tconst FULL = 2**N;\r\n\tconst HALF = FULL >>> 1;\r\n\tconst QRTR = HALF >> 1;\r\n\tconst MASK = FULL - 1;\r\n\r\n\t// fill register\r\n\tlet register = 0;\r\n\tfor (let i = 0; i < N; i++) register = (register << 1) | read_bit();\r\n\r\n\tlet symbols = [];\r\n\tlet low = 0;\r\n\tlet range = FULL; // treat like a float\r\n\twhile (true) {\r\n\t\tlet value = Math.floor((((register - low + 1) * total) - 1) / range);\r\n\t\tlet start = 0;\r\n\t\tlet end = symbol_count;\r\n\t\twhile (end - start > 1) { // binary search\r\n\t\t\tlet mid = (start + end) >>> 1;\r\n\t\t\tif (value < acc[mid]) {\r\n\t\t\t\tend = mid;\r\n\t\t\t} else {\r\n\t\t\t\tstart = mid;\r\n\t\t\t}\r\n\t\t}\r\n\t\tif (start == 0) break; // first symbol is end mark\r\n\t\tsymbols.push(start);\r\n\t\tlet a = low + Math.floor(range * acc[start]   / total);\r\n\t\tlet b = low + Math.floor(range * acc[start+1] / total) - 1;\r\n\t\twhile (((a ^ b) & HALF) == 0) {\r\n\t\t\tregister = (register << 1) & MASK | read_bit();\r\n\t\t\ta = (a << 1) & MASK;\r\n\t\t\tb = (b << 1) & MASK | 1;\r\n\t\t}\r\n\t\twhile (a & ~b & QRTR) {\r\n\t\t\tregister = (register & HALF) | ((register << 1) & (MASK >>> 1)) | read_bit();\r\n\t\t\ta = (a << 1) ^ HALF;\r\n\t\t\tb = ((b ^ HALF) << 1) | HALF | 1;\r\n\t\t}\r\n\t\tlow = a;\r\n\t\trange = 1 + b - a;\r\n\t}\r\n\tlet offset = symbol_count - 4;\r\n\treturn symbols.map(x => { // index into payload\r\n\t\tswitch (x - offset) {\r\n\t\t\tcase 3: return offset + 0x10100 + ((bytes[pos_payload++] << 16) | (bytes[pos_payload++] << 8) | bytes[pos_payload++]);\r\n\t\t\tcase 2: return offset + 0x100 + ((bytes[pos_payload++] << 8) | bytes[pos_payload++]);\r\n\t\t\tcase 1: return offset + bytes[pos_payload++];\r\n\t\t\tdefault: return x - 1;\r\n\t\t}\r\n\t});\r\n}\t\r\n\r\n// returns an iterator which returns the next symbol\r\nfunction read_payload(v) {\r\n\tlet pos = 0;\r\n\treturn () => v[pos++];\r\n}\r\nfunction read_compressed_payload(s) {\r\n\treturn read_payload(decode_arithmetic(unsafe_atob(s)));\r\n}\r\n\r\n// unsafe in the sense:\r\n// expected well-formed Base64 w/o padding \r\n// 20220922: added for https://github.com/adraffy/ens-normalize.js/issues/4\r\nfunction unsafe_atob(s) {\r\n\tlet lookup = [];\r\n\t[...'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'].forEach((c, i) => lookup[c.charCodeAt(0)] = i);\r\n\tlet n = s.length;\r\n\tlet ret = new Uint8Array((6 * n) >> 3);\r\n\tfor (let i = 0, pos = 0, width = 0, carry = 0; i < n; i++) {\r\n\t\tcarry = (carry << 6) | lookup[s.charCodeAt(i)];\r\n\t\twidth += 6;\r\n\t\tif (width >= 8) {\r\n\t\t\tret[pos++] = (carry >> (width -= 8));\r\n\t\t}\r\n\t}\r\n\treturn ret;\r\n}\r\n\r\n// eg. [0,1,2,3...] => [0,-1,1,-2,...]\r\nfunction signed(i) { \r\n\treturn (i & 1) ? (~i >> 1) : (i >> 1);\r\n}\r\n\r\nfunction read_deltas(n, next) {\r\n\tlet v = Array(n);\r\n\tfor (let i = 0, x = 0; i < n; i++) v[i] = x += signed(next());\r\n\treturn v;\r\n}\r\n\r\n// [123][5] => [0 3] [1 1] [0 0]\r\nfunction read_sorted(next, prev = 0) {\r\n\tlet ret = [];\r\n\twhile (true) {\r\n\t\tlet x = next();\r\n\t\tlet n = next();\r\n\t\tif (!n) break;\r\n\t\tprev += x;\r\n\t\tfor (let i = 0; i < n; i++) {\r\n\t\t\tret.push(prev + i);\r\n\t\t}\r\n\t\tprev += n + 1;\r\n\t}\r\n\treturn ret;\r\n}\r\n\r\nfunction read_sorted_arrays(next) {\r\n\treturn read_array_while(() => { \r\n\t\tlet v = read_sorted(next);\r\n\t\tif (v.length) return v;\r\n\t});\r\n}\r\n\r\n// returns map of x => ys\r\nfunction read_mapped(next) {\r\n\tlet ret = [];\r\n\twhile (true) {\r\n\t\tlet w = next();\r\n\t\tif (w == 0) break;\r\n\t\tret.push(read_linear_table(w, next));\r\n\t}\r\n\twhile (true) {\r\n\t\tlet w = next() - 1;\r\n\t\tif (w < 0) break;\r\n\t\tret.push(read_replacement_table(w, next));\r\n\t}\r\n\treturn ret.flat();\r\n}\r\n\r\n// read until next is falsy\r\n// return array of read values\r\nfunction read_array_while(next) {\r\n\tlet v = [];\r\n\twhile (true) {\r\n\t\tlet x = next(v.length);\r\n\t\tif (!x) break;\r\n\t\tv.push(x);\r\n\t}\r\n\treturn v;\r\n}\r\n\r\n// read w columns of length n\r\n// return as n rows of length w\r\nfunction read_transposed(n, w, next) {\r\n\tlet m = Array(n).fill().map(() => []);\r\n\tfor (let i = 0; i < w; i++) {\r\n\t\tread_deltas(n, next).forEach((x, j) => m[j].push(x));\r\n\t}\r\n\treturn m;\r\n}\r\n \r\n// returns [[x, ys], [x+dx, ys+dy], [x+2*dx, ys+2*dy], ...]\r\n// where dx/dy = steps, n = run size, w = length of y\r\nfunction read_linear_table(w, next) {\r\n\tlet dx = 1 + next();\r\n\tlet dy = next();\r\n\tlet vN = read_array_while(next);\r\n\tlet m = read_transposed(vN.length, 1+w, next);\r\n\treturn m.flatMap((v, i) => {\r\n\t\tlet [x, ...ys] = v;\r\n\t\treturn Array(vN[i]).fill().map((_, j) => {\r\n\t\t\tlet j_dy = j * dy;\r\n\t\t\treturn [x + j * dx, ys.map(y => y + j_dy)];\r\n\t\t});\r\n\t});\r\n}\r\n\r\n// return [[x, ys...], ...]\r\n// where w = length of y\r\nfunction read_replacement_table(w, next) { \r\n\tlet n = 1 + next();\r\n\tlet m = read_transposed(n, 1+w, next);\r\n\treturn m.map(v => [v[0], v.slice(1)]);\r\n}\r\n\r\n\r\nfunction read_trie(next) {\r\n\tlet ret = [];\r\n\tlet sorted = read_sorted(next); \r\n\texpand(decode([]), []);\r\n\treturn ret; // not sorted\r\n\tfunction decode(Q) { // characters that lead into this node\r\n\t\tlet S = next(); // state: valid, save, check\r\n\t\tlet B = read_array_while(() => { // buckets leading to new nodes\r\n\t\t\tlet cps = read_sorted(next).map(i => sorted[i]);\r\n\t\t\tif (cps.length) return decode(cps);\r\n\t\t});\r\n\t\treturn {S, B, Q};\r\n\t}\r\n\tfunction expand({S, B}, cps, saved) {\r\n\t\tif (S & 4 && saved === cps[cps.length-1]) return;\r\n\t\tif (S & 2) saved = cps[cps.length-1];\r\n\t\tif (S & 1) ret.push(cps); \r\n\t\tfor (let br of B) {\r\n\t\t\tfor (let cp of br.Q) {\r\n\t\t\t\texpand(br, [...cps, cp], saved);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n}\n\nfunction hex_cp(cp) {\r\n\treturn cp.toString(16).toUpperCase().padStart(2, '0');\r\n}\r\n\r\nfunction quote_cp(cp) {\r\n\treturn `{${hex_cp(cp)}}`; // raffy convention: like \"\\u{X}\" w/o the \"\\u\"\r\n}\r\n\r\n/*\r\nexport function explode_cp(s) {\r\n\treturn [...s].map(c => c.codePointAt(0));\r\n}\r\n*/\r\nfunction explode_cp(s) { // this is about 2x faster\r\n\tlet cps = [];\r\n\tfor (let pos = 0, len = s.length; pos < len; ) {\r\n\t\tlet cp = s.codePointAt(pos);\r\n\t\tpos += cp < 0x10000 ? 1 : 2;\r\n\t\tcps.push(cp);\r\n\t}\r\n\treturn cps;\r\n}\r\n\r\nfunction str_from_cps(cps) {\r\n\tconst chunk = 4096;\r\n\tlet len = cps.length;\r\n\tif (len < chunk) return String.fromCodePoint(...cps);\r\n\tlet buf = [];\r\n\tfor (let i = 0; i < len; ) {\r\n\t\tbuf.push(String.fromCodePoint(...cps.slice(i, i += chunk)));\r\n\t}\r\n\treturn buf.join('');\r\n}\r\n\r\nfunction compare_arrays(a, b) {\r\n\tlet n = a.length;\r\n\tlet c = n - b.length;\r\n\tfor (let i = 0; c == 0 && i < n; i++) c = a[i] - b[i];\r\n\treturn c;\r\n}\r\n\r\nfunction array_replace(v, a, b) {\r\n\tlet prev = 0;\r\n\twhile (true) {\r\n\t\tlet next = v.indexOf(a, prev);\r\n\t\tif (next < 0) break;\r\n\t\tv[next] = b; \r\n\t\tprev = next + 1;\r\n\t}\r\n}\n\n// created 2024-09-13T06:42:45.675Z\n// compressed base64-encoded blob for include-nf data\n// source: https://github.com/adraffy/ens-normalize.js/blob/main/src/make.js\n// see: https://github.com/adraffy/ens-normalize.js#security\n// SHA-256: a79d5f9b1879a7b416aa659f4a3d788f80a8cf5f0ab955a456592c02f556a28c\nvar COMPRESSED = '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';\n\n// https://unicode.org/reports/tr15/\r\n// for reference implementation\r\n// see: /derive/nf.js\r\n\r\n\r\n// algorithmic hangul\r\n// https://www.unicode.org/versions/Unicode15.0.0/ch03.pdf (page 144)\r\nconst S0 = 0xAC00;\r\nconst L0 = 0x1100;\r\nconst V0 = 0x1161;\r\nconst T0 = 0x11A7;\r\nconst L_COUNT = 19;\r\nconst V_COUNT = 21;\r\nconst T_COUNT = 28;\r\nconst N_COUNT = V_COUNT * T_COUNT;\r\nconst S_COUNT = L_COUNT * N_COUNT;\r\nconst S1 = S0 + S_COUNT;\r\nconst L1 = L0 + L_COUNT;\r\nconst V1 = V0 + V_COUNT;\r\nconst T1 = T0 + T_COUNT;\r\n\r\nfunction unpack_cc(packed) {\r\n\treturn (packed >> 24) & 0xFF;\r\n}\r\nfunction unpack_cp(packed) {\r\n\treturn packed & 0xFFFFFF;\r\n}\r\n\r\nlet SHIFTED_RANK, EXCLUSIONS, DECOMP, RECOMP;\r\n\r\n// export function nf_deinit() {\r\n// \tif (!SHIFTED_RANK) return;\r\n// \tSHIFTED_RANK = EXCLUSIONS = DECOMP = RECOMP = undefined;\r\n// }\r\n\r\nfunction init$1() {\r\n\t//console.time('nf');\r\n\tlet r = read_compressed_payload(COMPRESSED);\r\n\tSHIFTED_RANK = new Map(read_sorted_arrays(r).flatMap((v, i) => v.map(x => [x, (i+1) << 24]))); // pre-shifted\r\n\tEXCLUSIONS = new Set(read_sorted(r));\r\n\tDECOMP = new Map();\r\n\tRECOMP = new Map();\r\n\tfor (let [cp, cps] of read_mapped(r)) {\r\n\t\tif (!EXCLUSIONS.has(cp) && cps.length == 2) {\r\n\t\t\tlet [a, b] = cps;\r\n\t\t\tlet bucket = RECOMP.get(a);\r\n\t\t\tif (!bucket) {\r\n\t\t\t\tbucket = new Map();\r\n\t\t\t\tRECOMP.set(a, bucket);\r\n\t\t\t}\r\n\t\t\tbucket.set(b, cp);\r\n\t\t}\r\n\t\tDECOMP.set(cp, cps.reverse()); // stored reversed\r\n\t}\r\n\t//console.timeEnd('nf');\r\n\t// 20230905: 11ms\r\n}\r\n\r\nfunction is_hangul(cp) {\r\n\treturn cp >= S0 && cp < S1;\r\n}\r\n\r\nfunction compose_pair(a, b) {\r\n\tif (a >= L0 && a < L1 && b >= V0 && b < V1) {\r\n\t\treturn S0 + (a - L0) * N_COUNT + (b - V0) * T_COUNT;\r\n\t} else if (is_hangul(a) && b > T0 && b < T1 && (a - S0) % T_COUNT == 0) {\r\n\t\treturn a + (b - T0);\r\n\t} else {\r\n\t\tlet recomp = RECOMP.get(a);\r\n\t\tif (recomp) {\r\n\t\t\trecomp = recomp.get(b);\r\n\t\t\tif (recomp) {\r\n\t\t\t\treturn recomp;\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn -1;\r\n\t}\r\n}\r\n\r\nfunction decomposed(cps) {\r\n\tif (!SHIFTED_RANK) init$1();\r\n\tlet ret = [];\r\n\tlet buf = [];\r\n\tlet check_order = false;\r\n\tfunction add(cp) {\r\n\t\tlet cc = SHIFTED_RANK.get(cp);\r\n\t\tif (cc) {\r\n\t\t\tcheck_order = true;\r\n\t\t\tcp |= cc;\r\n\t\t}\r\n\t\tret.push(cp);\r\n\t}\r\n\tfor (let cp of cps) {\r\n\t\twhile (true) {\r\n\t\t\tif (cp < 0x80) {\r\n\t\t\t\tret.push(cp);\r\n\t\t\t} else if (is_hangul(cp)) {\r\n\t\t\t\tlet s_index = cp - S0;\r\n\t\t\t\tlet l_index = s_index / N_COUNT | 0;\r\n\t\t\t\tlet v_index = (s_index % N_COUNT) / T_COUNT | 0;\r\n\t\t\t\tlet t_index = s_index % T_COUNT;\r\n\t\t\t\tadd(L0 + l_index);\r\n\t\t\t\tadd(V0 + v_index);\r\n\t\t\t\tif (t_index > 0) add(T0 + t_index);\r\n\t\t\t} else {\r\n\t\t\t\tlet mapped = DECOMP.get(cp);\r\n\t\t\t\tif (mapped) {\r\n\t\t\t\t\tbuf.push(...mapped);\r\n\t\t\t\t} else {\r\n\t\t\t\t\tadd(cp);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tif (!buf.length) break;\r\n\t\t\tcp = buf.pop();\r\n\t\t}\r\n\t}\r\n\tif (check_order && ret.length > 1) {\r\n\t\tlet prev_cc = unpack_cc(ret[0]);\r\n\t\tfor (let i = 1; i < ret.length; i++) {\r\n\t\t\tlet cc = unpack_cc(ret[i]);\r\n\t\t\tif (cc == 0 || prev_cc <= cc) {\r\n\t\t\t\tprev_cc = cc;\r\n\t\t\t\tcontinue;\r\n\t\t\t}\r\n\t\t\tlet j = i-1;\r\n\t\t\twhile (true) {\r\n\t\t\t\tlet tmp = ret[j+1];\r\n\t\t\t\tret[j+1] = ret[j];\r\n\t\t\t\tret[j] = tmp;\r\n\t\t\t\tif (!j) break;\r\n\t\t\t\tprev_cc = unpack_cc(ret[--j]);\r\n\t\t\t\tif (prev_cc <= cc) break;\r\n\t\t\t}\r\n\t\t\tprev_cc = unpack_cc(ret[i]);\r\n\t\t}\r\n\t}\r\n\treturn ret;\r\n}\r\n\r\nfunction composed_from_decomposed(v) {\r\n\tlet ret = [];\r\n\tlet stack = [];\r\n\tlet prev_cp = -1;\r\n\tlet prev_cc = 0;\r\n\tfor (let packed of v) {\r\n\t\tlet cc = unpack_cc(packed);\r\n\t\tlet cp = unpack_cp(packed);\r\n\t\tif (prev_cp == -1) {\r\n\t\t\tif (cc == 0) {\r\n\t\t\t\tprev_cp = cp;\r\n\t\t\t} else {\r\n\t\t\t\tret.push(cp);\r\n\t\t\t}\r\n\t\t} else if (prev_cc > 0 && prev_cc >= cc) {\r\n\t\t\tif (cc == 0) {\r\n\t\t\t\tret.push(prev_cp, ...stack);\r\n\t\t\t\tstack.length = 0;\r\n\t\t\t\tprev_cp = cp;\r\n\t\t\t} else {\r\n\t\t\t\tstack.push(cp);\r\n\t\t\t}\r\n\t\t\tprev_cc = cc;\r\n\t\t} else {\r\n\t\t\tlet composed = compose_pair(prev_cp, cp);\r\n\t\t\tif (composed >= 0) {\r\n\t\t\t\tprev_cp = composed;\r\n\t\t\t} else if (prev_cc == 0 && cc == 0) {\r\n\t\t\t\tret.push(prev_cp);\r\n\t\t\t\tprev_cp = cp;\r\n\t\t\t} else {\r\n\t\t\t\tstack.push(cp);\r\n\t\t\t\tprev_cc = cc;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\tif (prev_cp >= 0) {\r\n\t\tret.push(prev_cp, ...stack);\t\r\n\t}\r\n\treturn ret;\r\n}\r\n\r\n// note: cps can be iterable\r\nfunction nfd(cps) {\r\n\treturn decomposed(cps).map(unpack_cp);\r\n}\r\nfunction nfc(cps) {\r\n\treturn composed_from_decomposed(decomposed(cps));\r\n}\n\nconst HYPHEN = 0x2D;\r\nconst STOP = 0x2E;\r\nconst STOP_CH = '.';\r\nconst FE0F = 0xFE0F;\r\nconst UNIQUE_PH = 1;\r\n\r\n// 20230913: replace [...v] with Array_from(v) to avoid large spreads\r\nconst Array_from = x => Array.from(x); // Array.from.bind(Array);\r\n\r\nfunction group_has_cp(g, cp) {\r\n\t// 20230913: keep primary and secondary distinct instead of creating valid union\r\n\treturn g.P.has(cp) || g.Q.has(cp);\r\n}\r\n\r\nclass Emoji extends Array {\r\n\tget is_emoji() { return true; } // free tagging system\r\n}\r\n\r\nlet MAPPED, IGNORED, CM, NSM, ESCAPE, NFC_CHECK, GROUPS, WHOLE_VALID, WHOLE_MAP, VALID, EMOJI_LIST, EMOJI_ROOT;\r\n\r\n// export function ens_deinit() {\r\n// \tnf_deinit();\r\n// \tif (!MAPPED) return;\r\n// \tMAPPED = IGNORED = CM = NSM = ESCAPE = NFC_CHECK = GROUPS = WHOLE_VALID = WHOLE_MAP = VALID = EMOJI_LIST = EMOJI_ROOT = undefined;\r\n// }\r\n\r\nfunction init() {\r\n\tif (MAPPED) return;\r\n\t\r\n\tlet r = read_compressed_payload(COMPRESSED$1);\r\n\tconst read_sorted_array = () => read_sorted(r);\r\n\tconst read_sorted_set = () => new Set(read_sorted_array());\r\n\tconst set_add_many = (set, v) => v.forEach(x => set.add(x));\r\n\r\n\tMAPPED = new Map(read_mapped(r)); \r\n\tIGNORED = read_sorted_set(); // ignored characters are not valid, so just read raw codepoints\r\n\r\n\t/*\r\n\t// direct include from payload is smaller than the decompression code\r\n\tconst FENCED = new Map(read_array_while(() => {\r\n\t\tlet cp = r();\r\n\t\tif (cp) return [cp, read_str(r())];\r\n\t}));\r\n\t*/\r\n\t// 20230217: we still need all CM for proper error formatting\r\n\t// but norm only needs NSM subset that are potentially-valid\r\n\tCM = read_sorted_array();\r\n\tNSM = new Set(read_sorted_array().map(i => CM[i]));\r\n\tCM = new Set(CM);\r\n\t\r\n\tESCAPE = read_sorted_set(); // characters that should not be printed\r\n\tNFC_CHECK = read_sorted_set(); // only needed to illustrate ens_tokenize() transformations\r\n\r\n\tlet chunks = read_sorted_arrays(r);\r\n\tlet unrestricted = r();\r\n\t//const read_chunked = () => new Set(read_sorted_array().flatMap(i => chunks[i]).concat(read_sorted_array()));\r\n\tconst read_chunked = () => {\r\n\t\t// 20230921: build set in parts, 2x faster\r\n\t\tlet set = new Set();\r\n\t\tread_sorted_array().forEach(i => set_add_many(set, chunks[i]));\r\n\t\tset_add_many(set, read_sorted_array());\r\n\t\treturn set; \r\n\t};\r\n\tGROUPS = read_array_while(i => {\r\n\t\t// minifier property mangling seems unsafe\r\n\t\t// so these are manually renamed to single chars\r\n\t\tlet N = read_array_while(r).map(x => x+0x60);\r\n\t\tif (N.length) {\r\n\t\t\tlet R = i >= unrestricted; // unrestricted then restricted\r\n\t\t\tN[0] -= 32; // capitalize\r\n\t\t\tN = str_from_cps(N);\r\n\t\t\tif (R) N=`Restricted[${N}]`;\r\n\t\t\tlet P = read_chunked(); // primary\r\n\t\t\tlet Q = read_chunked(); // secondary\r\n\t\t\tlet M = !r(); // not-whitelisted, check for NSM\r\n\t\t\t// *** this code currently isn't needed ***\r\n\t\t\t/*\r\n\t\t\tlet V = [...P, ...Q].sort((a, b) => a-b); // derive: sorted valid\r\n\t\t\tlet M = r()-1; // number of combining mark\r\n\t\t\tif (M < 0) { // whitelisted\r\n\t\t\t\tM = new Map(read_array_while(() => {\r\n\t\t\t\t\tlet i = r();\r\n\t\t\t\t\tif (i) return [V[i-1], read_array_while(() => {\r\n\t\t\t\t\t\tlet v = read_array_while(r);\r\n\t\t\t\t\t\tif (v.length) return v.map(x => x-1);\r\n\t\t\t\t\t})];\r\n\t\t\t\t}));\r\n\t\t\t}*/\r\n\t\t\treturn {N, P, Q, M, R};\r\n\t\t}\r\n\t});\r\n\r\n\t// decode compressed wholes\r\n\tWHOLE_VALID = read_sorted_set();\r\n\tWHOLE_MAP = new Map();\r\n\tlet wholes = read_sorted_array().concat(Array_from(WHOLE_VALID)).sort((a, b) => a-b); // must be sorted\r\n\twholes.forEach((cp, i) => {\r\n\t\tlet d = r(); \r\n\t\tlet w = wholes[i] = d ? wholes[i-d] : {V: [], M: new Map()};\r\n\t\tw.V.push(cp); // add to member set\r\n\t\tif (!WHOLE_VALID.has(cp)) {\r\n\t\t\tWHOLE_MAP.set(cp, w);  // register with whole map\r\n\t\t}\r\n\t});\r\n\r\n\t// compute confusable-extent complements\r\n\t// usage: WHOLE_MAP.get(cp).M.get(cp) = complement set\r\n\tfor (let {V, M} of new Set(WHOLE_MAP.values())) {\r\n\t\t// connect all groups that have each whole character\r\n\t\tlet recs = [];\r\n\t\tfor (let cp of V) {\r\n\t\t\tlet gs = GROUPS.filter(g => group_has_cp(g, cp));\r\n\t\t\tlet rec = recs.find(({G}) => gs.some(g => G.has(g)));\r\n\t\t\tif (!rec) {\r\n\t\t\t\trec = {G: new Set(), V: []};\r\n\t\t\t\trecs.push(rec);\r\n\t\t\t}\r\n\t\t\trec.V.push(cp);\r\n\t\t\tset_add_many(rec.G, gs);\r\n\t\t}\r\n\t\t// per character cache groups which are not a member of the extent\r\n\t\tlet union = recs.flatMap(x => Array_from(x.G)); // all of the groups used by this whole\r\n\t\tfor (let {G, V} of recs) {\r\n\t\t\tlet complement = new Set(union.filter(g => !G.has(g))); // groups not covered by the extent\r\n\t\t\tfor (let cp of V) {\r\n\t\t\t\tM.set(cp, complement); // this is the same reference\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\t// compute valid set\r\n\t// 20230924: VALID was union but can be re-used\r\n\tVALID = new Set(); // exists in 1+ groups\r\n\tlet multi = new Set(); // exists in 2+ groups\r\n\tconst add_to_union = cp => VALID.has(cp) ? multi.add(cp) : VALID.add(cp);\r\n\tfor (let g of GROUPS) {\r\n\t\tfor (let cp of g.P) add_to_union(cp);\r\n\t\tfor (let cp of g.Q) add_to_union(cp);\r\n\t}\r\n\t// dual purpose WHOLE_MAP: return placeholder if unique non-confusable\r\n\tfor (let cp of VALID) {\r\n\t\tif (!WHOLE_MAP.has(cp) && !multi.has(cp)) {\r\n\t\t\tWHOLE_MAP.set(cp, UNIQUE_PH);\r\n\t\t}\r\n\t}\r\n\t// add all decomposed parts\r\n\t// see derive: \"Valid is Closed (via Brute-force)\"\r\n\tset_add_many(VALID, nfd(VALID));\r\n\t\r\n\t// decode emoji\r\n\t// 20230719: emoji are now fully-expanded to avoid quirk logic \r\n\tEMOJI_LIST = read_trie(r).map(v => Emoji.from(v)).sort(compare_arrays);\r\n\tEMOJI_ROOT = new Map(); // this has approx 7K nodes (2+ per emoji)\r\n\tfor (let cps of EMOJI_LIST) {\r\n\t\t// 20230719: change to *slightly* stricter algorithm which disallows \r\n\t\t// insertion of misplaced FE0F in emoji sequences (matching ENSIP-15)\r\n\t\t// example: beautified [A B] (eg. flag emoji) \r\n\t\t//  before: allow: [A FE0F B], error: [A FE0F FE0F B] \r\n\t\t//   after: error: both\r\n\t\t// note: this code now matches ENSNormalize.{cs,java} logic\r\n\t\tlet prev = [EMOJI_ROOT];\r\n\t\tfor (let cp of cps) {\r\n\t\t\tlet next = prev.map(node => {\r\n\t\t\t\tlet child = node.get(cp);\r\n\t\t\t\tif (!child) {\r\n\t\t\t\t\t// should this be object? \r\n\t\t\t\t\t// (most have 1-2 items, few have many)\r\n\t\t\t\t\t// 20230719: no, v8 default map is 4?\r\n\t\t\t\t\tchild = new Map();\r\n\t\t\t\t\tnode.set(cp, child);\r\n\t\t\t\t}\r\n\t\t\t\treturn child;\r\n\t\t\t});\r\n\t\t\tif (cp === FE0F) {\r\n\t\t\t\tprev.push(...next); // less than 20 elements\r\n\t\t\t} else {\r\n\t\t\t\tprev = next;\r\n\t\t\t}\r\n\t\t}\r\n\t\tfor (let x of prev) {\r\n\t\t\tx.V = cps;\r\n\t\t}\r\n\t}\r\n}\r\n\r\n// if escaped: {HEX}\r\n//       else: \"x\" {HEX}\r\nfunction quoted_cp(cp) {\r\n\treturn (should_escape(cp) ? '' : `${bidi_qq(safe_str_from_cps([cp]))} `) + quote_cp(cp);\r\n}\r\n\r\n// 20230211: some messages can be mixed-directional and result in spillover\r\n// use 200E after a quoted string to force the remainder of a string from \r\n// acquring the direction of the quote\r\n// https://www.w3.org/International/questions/qa-bidi-unicode-controls#exceptions\r\nfunction bidi_qq(s) {\r\n\treturn `\"${s}\"\\u200E`; // strong LTR\r\n}\r\n\r\nfunction check_label_extension(cps) {\r\n\tif (cps.length >= 4 && cps[2] == HYPHEN && cps[3] == HYPHEN) {\r\n\t\tthrow new Error(`invalid label extension: \"${str_from_cps(cps.slice(0, 4))}\"`); // this can only be ascii so cant be bidi\r\n\t}\r\n}\r\nfunction check_leading_underscore(cps) {\r\n\tconst UNDERSCORE = 0x5F;\r\n\tfor (let i = cps.lastIndexOf(UNDERSCORE); i > 0; ) {\r\n\t\tif (cps[--i] !== UNDERSCORE) {\r\n\t\t\tthrow new Error('underscore allowed only at start');\r\n\t\t}\r\n\t}\r\n}\r\n// check that a fenced cp is not leading, trailing, or touching another fenced cp\r\nfunction check_fenced(cps) {\r\n\tlet cp = cps[0];\r\n\tlet prev = FENCED.get(cp);\r\n\tif (prev) throw error_placement(`leading ${prev}`);\r\n\tlet n = cps.length;\r\n\tlet last = -1; // prevents trailing from throwing\r\n\tfor (let i = 1; i < n; i++) {\r\n\t\tcp = cps[i];\r\n\t\tlet match = FENCED.get(cp);\r\n\t\tif (match) {\r\n\t\t\t// since cps[0] isn't fenced, cps[1] cannot throw\r\n\t\t\tif (last == i) throw error_placement(`${prev} + ${match}`);\r\n\t\t\tlast = i + 1;\r\n\t\t\tprev = match;\r\n\t\t}\r\n\t}\r\n\tif (last == n) throw error_placement(`trailing ${prev}`);\r\n}\r\n\r\n// create a safe to print string \r\n// invisibles are escaped\r\n// leading cm uses placeholder\r\n// if cps exceed max, middle truncate with ellipsis\r\n// quoter(cp) => string, eg. 3000 => \"{3000}\"\r\n// note: in html, you'd call this function then replace [<>&] with entities\r\nfunction safe_str_from_cps(cps, max = Infinity, quoter = quote_cp) {\r\n\t//if (Number.isInteger(cps)) cps = [cps];\r\n\t//if (!Array.isArray(cps)) throw new TypeError(`expected codepoints`);\r\n\tlet buf = [];\r\n\tif (is_combining_mark(cps[0])) buf.push('◌');\r\n\tif (cps.length > max) {\r\n\t\tmax >>= 1;\r\n\t\tcps = [...cps.slice(0, max), 0x2026, ...cps.slice(-max)];\r\n\t}\r\n\tlet prev = 0;\r\n\tlet n = cps.length;\r\n\tfor (let i = 0; i < n; i++) {\r\n\t\tlet cp = cps[i];\r\n\t\tif (should_escape(cp)) {\r\n\t\t\tbuf.push(str_from_cps(cps.slice(prev, i)));\r\n\t\t\tbuf.push(quoter(cp));\r\n\t\t\tprev = i + 1;\r\n\t\t}\r\n\t}\r\n\tbuf.push(str_from_cps(cps.slice(prev, n)));\r\n\treturn buf.join('');\r\n}\r\n\r\n// note: set(s) cannot be exposed because they can be modified\r\n// note: Object.freeze() doesn't work\r\nfunction is_combining_mark(cp, only_nsm) { // 20240127: add extra argument\r\n\tinit();\r\n\treturn only_nsm ? NSM.has(cp) : CM.has(cp);\r\n}\r\nfunction should_escape(cp) {\r\n\tinit();\r\n\treturn ESCAPE.has(cp);\r\n}\r\n\r\n// return all supported emoji as fully-qualified emoji \r\n// ordered by length then lexicographic \r\nfunction ens_emoji() {\r\n\tinit();\r\n\treturn EMOJI_LIST.map(x => x.slice()); // emoji are exposed so copy\r\n}\r\n\r\nfunction ens_normalize_fragment(frag, decompose) {\r\n\tinit();\r\n\tlet nf = decompose ? nfd : nfc;\r\n\treturn frag.split(STOP_CH).map(label => str_from_cps(tokens_from_str(explode_cp(label), nf, filter_fe0f).flat())).join(STOP_CH);\r\n}\r\n\r\nfunction ens_normalize(name) {\r\n\treturn flatten(split(name, nfc, filter_fe0f));\r\n}\r\n\r\nfunction ens_beautify(name) {\r\n\tlet labels = split(name, nfc, x => x); // emoji not exposed\r\n\tfor (let {type, output, error} of labels) {\r\n\t\tif (error) break; // flatten will throw\r\n\r\n\t\t// replace leading/trailing hyphen\r\n\t\t// 20230121: consider beautifing all or leading/trailing hyphen to unicode variant\r\n\t\t// not exactly the same in every font, but very similar: \"-\" vs \"‐\"\r\n\t\t/*\r\n\t\tconst UNICODE_HYPHEN = 0x2010;\r\n\t\t// maybe this should replace all for visual consistancy?\r\n\t\t// `node tools/reg-count.js regex ^-\\{2,\\}` => 592\r\n\t\t//for (let i = 0; i < output.length; i++) if (output[i] == 0x2D) output[i] = 0x2010;\r\n\t\tif (output[0] == HYPHEN) output[0] = UNICODE_HYPHEN;\r\n\t\tlet end = output.length-1;\r\n\t\tif (output[end] == HYPHEN) output[end] = UNICODE_HYPHEN;\r\n\t\t*/\r\n\t\t// 20230123: WHATWG URL uses \"CheckHyphens\" false\r\n\t\t// https://url.spec.whatwg.org/#idna\r\n\r\n\t\t// update ethereum symbol\r\n\t\t// ξ => Ξ if not greek\r\n\t\tif (type !== 'Greek') array_replace(output, 0x3BE, 0x39E);\r\n\r\n\t\t// 20221213: fixes bidi subdomain issue, but breaks invariant (200E is disallowed)\r\n\t\t// could be fixed with special case for: 2D (.) + 200E (LTR)\r\n\t\t// https://discuss.ens.domains/t/bidi-label-ordering-spoof/15824\r\n\t\t//output.splice(0, 0, 0x200E);\r\n\t}\r\n\treturn flatten(labels);\r\n}\r\n\r\nfunction ens_split(name, preserve_emoji) {\r\n\treturn split(name, nfc, preserve_emoji ? x => x.slice() : filter_fe0f); // emoji are exposed so copy\r\n}\r\n\r\nfunction split(name, nf, ef) {\r\n\tif (!name) return []; // 20230719: empty name allowance\r\n\tinit();\r\n\tlet offset = 0;\r\n\t// https://unicode.org/reports/tr46/#Validity_Criteria\r\n\t// 4.) \"The label must not contain a U+002E ( . ) FULL STOP.\"\r\n\treturn name.split(STOP_CH).map(label => {\r\n\t\tlet input = explode_cp(label);\r\n\t\tlet info = {\r\n\t\t\tinput,\r\n\t\t\toffset, // codepoint, not substring!\r\n\t\t};\r\n\t\toffset += input.length + 1; // + stop\r\n\t\ttry {\r\n\t\t\t// 1.) \"The label must be in Unicode Normalization Form NFC\"\r\n\t\t\tlet tokens = info.tokens = tokens_from_str(input, nf, ef);\r\n\t\t\tlet token_count = tokens.length;\r\n\t\t\tlet type;\r\n\t\t\tif (!token_count) { // the label was effectively empty (could of had ignored characters)\r\n\t\t\t\t//norm = [];\r\n\t\t\t\t//type = 'None'; // use this instead of next match, \"ASCII\"\r\n\t\t\t\t// 20230120: change to strict\r\n\t\t\t\t// https://discuss.ens.domains/t/ens-name-normalization-2nd/14564/59\r\n\t\t\t\tthrow new Error(`empty label`);\r\n\t\t\t} \r\n\t\t\tlet norm = info.output = tokens.flat();\r\n\t\t\tcheck_leading_underscore(norm);\r\n\t\t\tlet emoji = info.emoji = token_count > 1 || tokens[0].is_emoji; // same as: tokens.some(x => x.is_emoji);\r\n\t\t\tif (!emoji && norm.every(cp => cp < 0x80)) { // special case for ascii\r\n\t\t\t\t// 20230123: matches matches WHATWG, see note 3.3\r\n\t\t\t\tcheck_label_extension(norm); // only needed for ascii\r\n\t\t\t\t// cant have fenced\r\n\t\t\t\t// cant have cm\r\n\t\t\t\t// cant have wholes\r\n\t\t\t\t// see derive: \"Fastpath ASCII\"\r\n\t\t\t\ttype = 'ASCII';\r\n\t\t\t} else {\r\n\t\t\t\tlet chars = tokens.flatMap(x => x.is_emoji ? [] : x); // all of the nfc tokens concat together\r\n\t\t\t\tif (!chars.length) { // theres no text, just emoji\r\n\t\t\t\t\ttype = 'Emoji';\r\n\t\t\t\t} else {\r\n\t\t\t\t\t// 5.) \"The label must not begin with a combining mark, that is: General_Category=Mark.\"\r\n\t\t\t\t\tif (CM.has(norm[0])) throw error_placement('leading combining mark');\r\n\t\t\t\t\tfor (let i = 1; i < token_count; i++) { // we've already checked the first token\r\n\t\t\t\t\t\tlet cps = tokens[i];\r\n\t\t\t\t\t\tif (!cps.is_emoji && CM.has(cps[0])) { // every text token has emoji neighbors, eg. EtEEEtEt...\r\n\t\t\t\t\t\t\t// bidi_qq() not needed since emoji is LTR and cps is a CM\r\n\t\t\t\t\t\t\tthrow error_placement(`emoji + combining mark: \"${str_from_cps(tokens[i-1])} + ${safe_str_from_cps([cps[0]])}\"`); \r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\tcheck_fenced(norm);\r\n\t\t\t\t\tlet unique = Array_from(new Set(chars));\r\n\t\t\t\t\tlet [g] = determine_group(unique); // take the first match\r\n\t\t\t\t\t// see derive: \"Matching Groups have Same CM Style\"\r\n\t\t\t\t\t// alternative: could form a hybrid type: Latin/Japanese/...\t\r\n\t\t\t\t\tcheck_group(g, chars); // need text in order\r\n\t\t\t\t\tcheck_whole(g, unique); // only need unique text (order would be required for multiple-char confusables)\r\n\t\t\t\t\ttype = g.N;\r\n\t\t\t\t\t// 20230121: consider exposing restricted flag\r\n\t\t\t\t\t// it's simpler to just check for 'Restricted'\r\n\t\t\t\t\t// or even better: type.endsWith(']')\r\n\t\t\t\t\t//if (g.R) info.restricted = true;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tinfo.type = type;\r\n\t\t} catch (err) {\r\n\t\t\tinfo.error = err; // use full error object\r\n\t\t}\r\n\t\treturn info;\r\n\t});\r\n}\r\n\r\nfunction check_whole(group, unique) {\r\n\tlet maker;\r\n\tlet shared = [];\r\n\tfor (let cp of unique) {\r\n\t\tlet whole = WHOLE_MAP.get(cp);\r\n\t\tif (whole === UNIQUE_PH) return; // unique, non-confusable\r\n\t\tif (whole) {\r\n\t\t\tlet set = whole.M.get(cp); // groups which have a character that look-like this character\r\n\t\t\tmaker = maker ? maker.filter(g => set.has(g)) : Array_from(set);\r\n\t\t\tif (!maker.length) return; // confusable intersection is empty\r\n\t\t} else {\r\n\t\t\tshared.push(cp); \r\n\t\t}\r\n\t}\r\n\tif (maker) {\r\n\t\t// we have 1+ confusable\r\n\t\t// check if any of the remaining groups\r\n\t\t// contain the shared characters too\r\n\t\tfor (let g of maker) {\r\n\t\t\tif (shared.every(cp => group_has_cp(g, cp))) {\r\n\t\t\t\tthrow new Error(`whole-script confusable: ${group.N}/${g.N}`);\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n}\r\n\r\n// assumption: unique.size > 0\r\n// returns list of matching groups\r\nfunction determine_group(unique) {\r\n\tlet groups = GROUPS;\r\n\tfor (let cp of unique) {\r\n\t\t// note: we need to dodge CM that are whitelisted\r\n\t\t// but that code isn't currently necessary\r\n\t\tlet gs = groups.filter(g => group_has_cp(g, cp));\r\n\t\tif (!gs.length) {\r\n\t\t\tif (!GROUPS.some(g => group_has_cp(g, cp))) { \r\n\t\t\t\t// the character was composed of valid parts\r\n\t\t\t\t// but it's NFC form is invalid\r\n\t\t\t\t// 20230716: change to more exact statement, see: ENSNormalize.{cs,java}\r\n\t\t\t\t// note: this doesn't have to be a composition\r\n\t\t\t\t// 20230720: change to full check\r\n\t\t\t\tthrow error_disallowed(cp); // this should be rare\r\n\t\t\t} else {\r\n\t\t\t\t// there is no group that contains all these characters\r\n\t\t\t\t// throw using the highest priority group that matched\r\n\t\t\t\t// https://www.unicode.org/reports/tr39/#mixed_script_confusables\r\n\t\t\t\tthrow error_group_member(groups[0], cp);\r\n\t\t\t}\r\n\t\t}\r\n\t\tgroups = gs;\r\n\t\tif (gs.length == 1) break; // there is only one group left\r\n\t}\r\n\t// there are at least 1 group(s) with all of these characters\r\n\treturn groups;\r\n}\r\n\r\n// throw on first error\r\nfunction flatten(split) {\r\n\treturn split.map(({input, error, output}) => {\r\n\t\tif (error) {\r\n\t\t\t// don't print label again if just a single label\r\n\t\t\tlet msg = error.message;\r\n\t\t\t// bidi_qq() only necessary if msg is digits\r\n\t\t\tthrow new Error(split.length == 1 ? msg : `Invalid label ${bidi_qq(safe_str_from_cps(input, 63))}: ${msg}`); \r\n\t\t}\r\n\t\treturn str_from_cps(output);\r\n\t}).join(STOP_CH);\r\n}\r\n\r\nfunction error_disallowed(cp) {\r\n\t// TODO: add cp to error?\r\n\treturn new Error(`disallowed character: ${quoted_cp(cp)}`); \r\n}\r\nfunction error_group_member(g, cp) {\r\n\tlet quoted = quoted_cp(cp);\r\n\tlet gg = GROUPS.find(g => g.P.has(cp)); // only check primary\r\n\tif (gg) {\r\n\t\tquoted = `${gg.N} ${quoted}`;\r\n\t}\r\n\treturn new Error(`illegal mixture: ${g.N} + ${quoted}`);\r\n}\r\nfunction error_placement(where) {\r\n\treturn new Error(`illegal placement: ${where}`);\r\n}\r\n\r\n// assumption: cps.length > 0\r\n// assumption: cps[0] isn't a CM\r\n// assumption: the previous character isn't an emoji\r\nfunction check_group(g, cps) {\r\n\tfor (let cp of cps) {\r\n\t\tif (!group_has_cp(g, cp)) {\r\n\t\t\t// for whitelisted scripts, this will throw illegal mixture on invalid cm, eg. \"e{300}{300}\"\r\n\t\t\t// at the moment, it's unnecessary to introduce an extra error type\r\n\t\t\t// until there exists a whitelisted multi-character\r\n\t\t\t//   eg. if (M < 0 && is_combining_mark(cp)) { ... }\r\n\t\t\t// there are 3 cases:\r\n\t\t\t//   1. illegal cm for wrong group => mixture error\r\n\t\t\t//   2. illegal cm for same group => cm error\r\n\t\t\t//       requires set of whitelist cm per group: \r\n\t\t\t//        eg. new Set([...g.P, ...g.Q].flatMap(nfc).filter(cp => CM.has(cp)))\r\n\t\t\t//   3. wrong group => mixture error\r\n\t\t\tthrow error_group_member(g, cp);\r\n\t\t}\r\n\t}\r\n\t//if (M >= 0) { // we have a known fixed cm count\r\n\tif (g.M) { // we need to check for NSM\r\n\t\tlet decomposed = nfd(cps);\r\n\t\tfor (let i = 1, e = decomposed.length; i < e; i++) { // see: assumption\r\n\t\t\t// 20230210: bugfix: using cps instead of decomposed h/t Carbon225\r\n\t\t\t/*\r\n\t\t\tif (CM.has(decomposed[i])) {\r\n\t\t\t\tlet j = i + 1;\r\n\t\t\t\twhile (j < e && CM.has(decomposed[j])) j++;\r\n\t\t\t\tif (j - i > M) {\r\n\t\t\t\t\tthrow new Error(`too many combining marks: ${g.N} ${bidi_qq(str_from_cps(decomposed.slice(i-1, j)))} (${j-i}/${M})`);\r\n\t\t\t\t}\r\n\t\t\t\ti = j;\r\n\t\t\t}\r\n\t\t\t*/\r\n\t\t\t// 20230217: switch to NSM counting\r\n\t\t\t// https://www.unicode.org/reports/tr39/#Optional_Detection\r\n\t\t\tif (NSM.has(decomposed[i])) {\r\n\t\t\t\tlet j = i + 1;\r\n\t\t\t\tfor (let cp; j < e && NSM.has(cp = decomposed[j]); j++) {\r\n\t\t\t\t\t// a. Forbid sequences of the same nonspacing mark.\r\n\t\t\t\t\tfor (let k = i; k < j; k++) { // O(n^2) but n < 100\r\n\t\t\t\t\t\tif (decomposed[k] == cp) {\r\n\t\t\t\t\t\t\tthrow new Error(`duplicate non-spacing marks: ${quoted_cp(cp)}`);\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\t// parse to end so we have full nsm count\r\n\t\t\t\t// b. Forbid sequences of more than 4 nonspacing marks (gc=Mn or gc=Me).\r\n\t\t\t\tif (j - i > NSM_MAX) {\r\n\t\t\t\t\t// note: this slice starts with a base char or spacing-mark cm\r\n\t\t\t\t\tthrow new Error(`excessive non-spacing marks: ${bidi_qq(safe_str_from_cps(decomposed.slice(i-1, j)))} (${j-i}/${NSM_MAX})`);\r\n\t\t\t\t}\r\n\t\t\t\ti = j;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\t// *** this code currently isn't needed ***\r\n\t/*\r\n\tlet cm_whitelist = M instanceof Map;\r\n\tfor (let i = 0, e = cps.length; i < e; ) {\r\n\t\tlet cp = cps[i++];\r\n\t\tlet seqs = cm_whitelist && M.get(cp);\r\n\t\tif (seqs) { \r\n\t\t\t// list of codepoints that can follow\r\n\t\t\t// if this exists, this will always be 1+\r\n\t\t\tlet j = i;\r\n\t\t\twhile (j < e && CM.has(cps[j])) j++;\r\n\t\t\tlet cms = cps.slice(i, j);\r\n\t\t\tlet match = seqs.find(seq => !compare_arrays(seq, cms));\r\n\t\t\tif (!match) throw new Error(`disallowed combining mark sequence: \"${safe_str_from_cps([cp, ...cms])}\"`);\r\n\t\t\ti = j;\r\n\t\t} else if (!V.has(cp)) {\r\n\t\t\t// https://www.unicode.org/reports/tr39/#mixed_script_confusables\r\n\t\t\tlet quoted = quoted_cp(cp);\r\n\t\t\tfor (let cp of cps) {\r\n\t\t\t\tlet u = UNIQUE.get(cp);\r\n\t\t\t\tif (u && u !== g) {\r\n\t\t\t\t\t// if both scripts are restricted this error is confusing\r\n\t\t\t\t\t// because we don't differentiate RestrictedA from RestrictedB \r\n\t\t\t\t\tif (!u.R) quoted = `${quoted} is ${u.N}`;\r\n\t\t\t\t\tbreak;\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t\tthrow new Error(`disallowed ${g.N} character: ${quoted}`);\r\n\t\t\t//throw new Error(`disallowed character: ${quoted} (expected ${g.N})`);\r\n\t\t\t//throw new Error(`${g.N} does not allow: ${quoted}`);\r\n\t\t}\r\n\t}\r\n\tif (!cm_whitelist) {\r\n\t\tlet decomposed = nfd(cps);\r\n\t\tfor (let i = 1, e = decomposed.length; i < e; i++) { // we know it can't be cm leading\r\n\t\t\tif (CM.has(decomposed[i])) {\r\n\t\t\t\tlet j = i + 1;\r\n\t\t\t\twhile (j < e && CM.has(decomposed[j])) j++;\r\n\t\t\t\tif (j - i > M) {\r\n\t\t\t\t\tthrow new Error(`too many combining marks: \"${str_from_cps(decomposed.slice(i-1, j))}\" (${j-i}/${M})`);\r\n\t\t\t\t}\r\n\t\t\t\ti = j;\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\t*/\r\n}\r\n\r\n// given a list of codepoints\r\n// returns a list of lists, where emoji are a fully-qualified (as Array subclass)\r\n// eg. explode_cp(\"abc💩d\") => [[61, 62, 63], Emoji[1F4A9, FE0F], [64]]\r\n// 20230818: rename for 'process' name collision h/t Javarome\r\n// https://github.com/adraffy/ens-normalize.js/issues/23\r\nfunction tokens_from_str(input, nf, ef) {\r\n\tlet ret = [];\r\n\tlet chars = [];\r\n\tinput = input.slice().reverse(); // flip so we can pop\r\n\twhile (input.length) {\r\n\t\tlet emoji = consume_emoji_reversed(input);\r\n\t\tif (emoji) {\r\n\t\t\tif (chars.length) {\r\n\t\t\t\tret.push(nf(chars));\r\n\t\t\t\tchars = [];\r\n\t\t\t}\r\n\t\t\tret.push(ef(emoji));\r\n\t\t} else {\r\n\t\t\tlet cp = input.pop();\r\n\t\t\tif (VALID.has(cp)) {\r\n\t\t\t\tchars.push(cp);\r\n\t\t\t} else {\r\n\t\t\t\tlet cps = MAPPED.get(cp);\r\n\t\t\t\tif (cps) {\r\n\t\t\t\t\tchars.push(...cps); // less than 10 elements\r\n\t\t\t\t} else if (!IGNORED.has(cp)) {\r\n\t\t\t\t\t// 20230912: unicode 15.1 changed the order of processing such that\r\n\t\t\t\t\t// disallowed parts are only rejected after NFC\r\n\t\t\t\t\t// https://unicode.org/reports/tr46/#Validity_Criteria\r\n\t\t\t\t\t// this doesn't impact normalization as of today\r\n\t\t\t\t\t// technically, this error can be removed as the group logic will apply similar logic\r\n\t\t\t\t\t// however the error type might be less clear\r\n\t\t\t\t\tthrow error_disallowed(cp);\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\tif (chars.length) {\r\n\t\tret.push(nf(chars));\r\n\t}\r\n\treturn ret;\r\n}\r\n\r\nfunction filter_fe0f(cps) {\r\n\treturn cps.filter(cp => cp != FE0F);\r\n}\r\n\r\n// given array of codepoints\r\n// returns the longest valid emoji sequence (or undefined if no match)\r\n// *MUTATES* the supplied array\r\n// disallows interleaved ignored characters\r\n// fills (optional) eaten array with matched codepoints\r\nfunction consume_emoji_reversed(cps, eaten) {\r\n\tlet node = EMOJI_ROOT;\r\n\tlet emoji;\r\n\tlet pos = cps.length;\r\n\twhile (pos) {\r\n\t\tnode = node.get(cps[--pos]);\r\n\t\tif (!node) break;\r\n\t\tlet {V} = node;\r\n\t\tif (V) { // this is a valid emoji (so far)\r\n\t\t\temoji = V;\r\n\t\t\tif (eaten) eaten.push(...cps.slice(pos).reverse()); // (optional) copy input, used for ens_tokenize()\r\n\t\t\tcps.length = pos; // truncate\r\n\t\t}\r\n\t}\r\n\treturn emoji;\r\n}\r\n\r\n// ************************************************************\r\n// tokenizer \r\n\r\nconst TY_VALID = 'valid';\r\nconst TY_MAPPED = 'mapped';\r\nconst TY_IGNORED = 'ignored';\r\nconst TY_DISALLOWED = 'disallowed';\r\nconst TY_EMOJI = 'emoji';\r\nconst TY_NFC = 'nfc';\r\nconst TY_STOP = 'stop';\r\n\r\nfunction ens_tokenize(name, {\r\n\tnf = true, // collapse unnormalized runs into a single token\r\n} = {}) {\r\n\tinit();\r\n\tlet input = explode_cp(name).reverse();\r\n\tlet eaten = [];\r\n\tlet tokens = [];\r\n\twhile (input.length) {\r\n\t\tlet emoji = consume_emoji_reversed(input, eaten);\r\n\t\tif (emoji) {\r\n\t\t\ttokens.push({\r\n\t\t\t\ttype: TY_EMOJI,\r\n\t\t\t\temoji: emoji.slice(), // copy emoji\r\n\t\t\t\tinput: eaten,\r\n\t\t\t\tcps: filter_fe0f(emoji)\r\n\t\t\t});\r\n\t\t\teaten = []; // reset buffer\r\n\t\t} else {\r\n\t\t\tlet cp = input.pop();\r\n\t\t\tif (cp == STOP) {\r\n\t\t\t\ttokens.push({type: TY_STOP, cp});\r\n\t\t\t} else if (VALID.has(cp)) {\r\n\t\t\t\ttokens.push({type: TY_VALID, cps: [cp]});\r\n\t\t\t} else if (IGNORED.has(cp)) {\r\n\t\t\t\ttokens.push({type: TY_IGNORED, cp});\r\n\t\t\t} else {\r\n\t\t\t\tlet cps = MAPPED.get(cp);\r\n\t\t\t\tif (cps) {\r\n\t\t\t\t\ttokens.push({type: TY_MAPPED, cp, cps: cps.slice()});\r\n\t\t\t\t} else {\r\n\t\t\t\t\ttokens.push({type: TY_DISALLOWED, cp});\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\tif (nf) {\r\n\t\tfor (let i = 0, start = -1; i < tokens.length; i++) {\r\n\t\t\tlet token = tokens[i];\r\n\t\t\tif (is_valid_or_mapped(token.type)) {\r\n\t\t\t\tif (requires_check(token.cps)) { // normalization might be needed\r\n\t\t\t\t\tlet end = i + 1;\r\n\t\t\t\t\tfor (let pos = end; pos < tokens.length; pos++) { // find adjacent text\r\n\t\t\t\t\t\tlet {type, cps} = tokens[pos];\r\n\t\t\t\t\t\tif (is_valid_or_mapped(type)) {\r\n\t\t\t\t\t\t\tif (!requires_check(cps)) break;\r\n\t\t\t\t\t\t\tend = pos + 1;\r\n\t\t\t\t\t\t} else if (type !== TY_IGNORED) { // || type !== TY_DISALLOWED) { \r\n\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t\tif (start < 0) start = i;\r\n\t\t\t\t\tlet slice = tokens.slice(start, end);\r\n\t\t\t\t\tlet cps0 = slice.flatMap(x => is_valid_or_mapped(x.type) ? x.cps : []); // strip junk tokens\r\n\t\t\t\t\tlet cps = nfc(cps0);\r\n\t\t\t\t\tif (compare_arrays(cps, cps0)) { // bundle into an nfc token\r\n\t\t\t\t\t\ttokens.splice(start, end - start, {\r\n\t\t\t\t\t\t\ttype: TY_NFC, \r\n\t\t\t\t\t\t\tinput: cps0, // there are 3 states: tokens0 ==(process)=> input ==(nfc)=> tokens/cps\r\n\t\t\t\t\t\t\tcps, \r\n\t\t\t\t\t\t\ttokens0: collapse_valid_tokens(slice),\r\n\t\t\t\t\t\t\ttokens: ens_tokenize(str_from_cps(cps), {nf: false})\r\n\t\t\t\t\t\t});\r\n\t\t\t\t\t\ti = start;\r\n\t\t\t\t\t} else { \r\n\t\t\t\t\t\ti = end - 1; // skip to end of slice\r\n\t\t\t\t\t}\r\n\t\t\t\t\tstart = -1; // reset\r\n\t\t\t\t} else {\r\n\t\t\t\t\tstart = i; // remember last\r\n\t\t\t\t}\r\n\t\t\t} else if (token.type !== TY_IGNORED) { // 20221024: is this correct?\r\n\t\t\t\tstart = -1; // reset\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\treturn collapse_valid_tokens(tokens);\r\n}\r\n\r\nfunction is_valid_or_mapped(type) {\r\n\treturn type == TY_VALID || type == TY_MAPPED;\r\n}\r\n\r\nfunction requires_check(cps) {\r\n\treturn cps.some(cp => NFC_CHECK.has(cp));\r\n}\r\n\r\nfunction collapse_valid_tokens(tokens) {\r\n\tfor (let i = 0; i < tokens.length; i++) {\r\n\t\tif (tokens[i].type == TY_VALID) {\r\n\t\t\tlet j = i + 1;\r\n\t\t\twhile (j < tokens.length && tokens[j].type == TY_VALID) j++;\r\n\t\t\ttokens.splice(i, j - i, {type: TY_VALID, cps: tokens.slice(i, j).flatMap(x => x.cps)});\r\n\t\t}\r\n\t}\r\n\treturn tokens;\r\n}\n\nexport { ens_beautify, ens_emoji, ens_normalize, ens_normalize_fragment, ens_split, ens_tokenize, is_combining_mark, nfc, nfd, safe_str_from_cps, should_escape };\n","// src/regex.ts\nfunction execTyped(regex, string) {\n  const match = regex.exec(string);\n  return match?.groups;\n}\nvar bytesRegex = /^bytes([1-9]|1[0-9]|2[0-9]|3[0-2])?$/;\nvar integerRegex = /^u?int(8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?$/;\nvar isTupleRegex = /^\\(.+?\\).*?$/;\n\nexport {\n  execTyped,\n  bytesRegex,\n  integerRegex,\n  isTupleRegex\n};\n","var __defProp = Object.defineProperty;\nvar __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;\nvar __publicField = (obj, key, value) => {\n  __defNormalProp(obj, typeof key !== \"symbol\" ? key + \"\" : key, value);\n  return value;\n};\n\nexport {\n  __publicField\n};\n","import {\n  bytesRegex,\n  execTyped,\n  integerRegex,\n  isTupleRegex\n} from \"./chunk-WP7KDV47.mjs\";\nimport {\n  __publicField\n} from \"./chunk-NHABU752.mjs\";\n\n// package.json\nvar name = \"abitype\";\nvar version = \"0.7.1\";\n\n// src/errors.ts\nvar BaseError = class extends Error {\n  constructor(shortMessage, args = {}) {\n    const details = args.cause instanceof BaseError ? args.cause.details : args.cause?.message ? args.cause.message : args.details;\n    const docsPath = args.cause instanceof BaseError ? args.cause.docsPath || args.docsPath : args.docsPath;\n    const message = [\n      shortMessage || \"An error occurred.\",\n      \"\",\n      ...args.metaMessages ? [...args.metaMessages, \"\"] : [],\n      ...docsPath ? [`Docs: https://abitype.dev${docsPath}`] : [],\n      ...details ? [`Details: ${details}`] : [],\n      `Version: ${name}@${version}`\n    ].join(\"\\n\");\n    super(message);\n    __publicField(this, \"details\");\n    __publicField(this, \"docsPath\");\n    __publicField(this, \"metaMessages\");\n    __publicField(this, \"shortMessage\");\n    __publicField(this, \"name\", \"AbiTypeError\");\n    if (args.cause)\n      this.cause = args.cause;\n    this.details = details;\n    this.docsPath = docsPath;\n    this.metaMessages = args.metaMessages;\n    this.shortMessage = shortMessage;\n  }\n};\n\n// src/narrow.ts\nfunction narrow(value) {\n  return value;\n}\n\n// src/human-readable/runtime/signatures.ts\nvar errorSignatureRegex = /^error (?<name>[a-zA-Z0-9_]+)\\((?<parameters>.*?)\\)$/;\nfunction isErrorSignature(signature) {\n  return errorSignatureRegex.test(signature);\n}\nfunction execErrorSignature(signature) {\n  return execTyped(\n    errorSignatureRegex,\n    signature\n  );\n}\nvar eventSignatureRegex = /^event (?<name>[a-zA-Z0-9_]+)\\((?<parameters>.*?)\\)$/;\nfunction isEventSignature(signature) {\n  return eventSignatureRegex.test(signature);\n}\nfunction execEventSignature(signature) {\n  return execTyped(\n    eventSignatureRegex,\n    signature\n  );\n}\nvar functionSignatureRegex = /^function (?<name>[a-zA-Z0-9_]+)\\((?<parameters>.*?)\\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns \\((?<returns>.*?)\\))?$/;\nfunction isFunctionSignature(signature) {\n  return functionSignatureRegex.test(signature);\n}\nfunction execFunctionSignature(signature) {\n  return execTyped(functionSignatureRegex, signature);\n}\nvar structSignatureRegex = /^struct (?<name>[a-zA-Z0-9_]+) \\{(?<properties>.*?)\\}$/;\nfunction isStructSignature(signature) {\n  return structSignatureRegex.test(signature);\n}\nfunction execStructSignature(signature) {\n  return execTyped(\n    structSignatureRegex,\n    signature\n  );\n}\nvar constructorSignatureRegex = /^constructor\\((?<parameters>.*?)\\)(?:\\s(?<stateMutability>payable{1}))?$/;\nfunction isConstructorSignature(signature) {\n  return constructorSignatureRegex.test(signature);\n}\nfunction execConstructorSignature(signature) {\n  return execTyped(constructorSignatureRegex, signature);\n}\nvar fallbackSignatureRegex = /^fallback\\(\\)$/;\nfunction isFallbackSignature(signature) {\n  return fallbackSignatureRegex.test(signature);\n}\nvar receiveSignatureRegex = /^receive\\(\\) external payable$/;\nfunction isReceiveSignature(signature) {\n  return receiveSignatureRegex.test(signature);\n}\nvar modifiers = /* @__PURE__ */ new Set([\n  \"memory\",\n  \"indexed\",\n  \"storage\",\n  \"calldata\"\n]);\nvar eventModifiers = /* @__PURE__ */ new Set([\"indexed\"]);\nvar functionModifiers = /* @__PURE__ */ new Set([\n  \"calldata\",\n  \"memory\",\n  \"storage\"\n]);\n\n// src/human-readable/runtime/cache.ts\nfunction getParameterCacheKey(param, type) {\n  if (type)\n    return `${type}:${param}`;\n  return param;\n}\nvar parameterCache = /* @__PURE__ */ new Map([\n  // Unnamed\n  [\"address\", { type: \"address\" }],\n  [\"bool\", { type: \"bool\" }],\n  [\"bytes\", { type: \"bytes\" }],\n  [\"bytes32\", { type: \"bytes32\" }],\n  [\"int\", { type: \"int256\" }],\n  [\"int256\", { type: \"int256\" }],\n  [\"string\", { type: \"string\" }],\n  [\"uint\", { type: \"uint256\" }],\n  [\"uint8\", { type: \"uint8\" }],\n  [\"uint16\", { type: \"uint16\" }],\n  [\"uint24\", { type: \"uint24\" }],\n  [\"uint32\", { type: \"uint32\" }],\n  [\"uint64\", { type: \"uint64\" }],\n  [\"uint96\", { type: \"uint96\" }],\n  [\"uint112\", { type: \"uint112\" }],\n  [\"uint160\", { type: \"uint160\" }],\n  [\"uint192\", { type: \"uint192\" }],\n  [\"uint256\", { type: \"uint256\" }],\n  // Named\n  [\"address owner\", { type: \"address\", name: \"owner\" }],\n  [\"address to\", { type: \"address\", name: \"to\" }],\n  [\"bool approved\", { type: \"bool\", name: \"approved\" }],\n  [\"bytes _data\", { type: \"bytes\", name: \"_data\" }],\n  [\"bytes data\", { type: \"bytes\", name: \"data\" }],\n  [\"bytes signature\", { type: \"bytes\", name: \"signature\" }],\n  [\"bytes32 hash\", { type: \"bytes32\", name: \"hash\" }],\n  [\"bytes32 r\", { type: \"bytes32\", name: \"r\" }],\n  [\"bytes32 root\", { type: \"bytes32\", name: \"root\" }],\n  [\"bytes32 s\", { type: \"bytes32\", name: \"s\" }],\n  [\"string name\", { type: \"string\", name: \"name\" }],\n  [\"string symbol\", { type: \"string\", name: \"symbol\" }],\n  [\"string tokenURI\", { type: \"string\", name: \"tokenURI\" }],\n  [\"uint tokenId\", { type: \"uint256\", name: \"tokenId\" }],\n  [\"uint8 v\", { type: \"uint8\", name: \"v\" }],\n  [\"uint256 balance\", { type: \"uint256\", name: \"balance\" }],\n  [\"uint256 tokenId\", { type: \"uint256\", name: \"tokenId\" }],\n  [\"uint256 value\", { type: \"uint256\", name: \"value\" }],\n  // Indexed\n  [\n    \"event:address indexed from\",\n    { type: \"address\", name: \"from\", indexed: true }\n  ],\n  [\"event:address indexed to\", { type: \"address\", name: \"to\", indexed: true }],\n  [\n    \"event:uint indexed tokenId\",\n    { type: \"uint256\", name: \"tokenId\", indexed: true }\n  ],\n  [\n    \"event:uint256 indexed tokenId\",\n    { type: \"uint256\", name: \"tokenId\", indexed: true }\n  ]\n]);\n\n// src/human-readable/runtime/utils.ts\nfunction parseSignature(signature, structs = {}) {\n  if (isFunctionSignature(signature)) {\n    const match = execFunctionSignature(signature);\n    if (!match)\n      throw new BaseError(\"Invalid function signature.\", {\n        details: signature\n      });\n    const inputParams = splitParameters(match.parameters);\n    const inputs = [];\n    const inputLength = inputParams.length;\n    for (let i = 0; i < inputLength; i++) {\n      inputs.push(\n        parseAbiParameter(inputParams[i], {\n          modifiers: functionModifiers,\n          structs,\n          type: \"function\"\n        })\n      );\n    }\n    const outputs = [];\n    if (match.returns) {\n      const outputParams = splitParameters(match.returns);\n      const outputLength = outputParams.length;\n      for (let i = 0; i < outputLength; i++) {\n        outputs.push(\n          parseAbiParameter(outputParams[i], {\n            modifiers: functionModifiers,\n            structs,\n            type: \"function\"\n          })\n        );\n      }\n    }\n    return {\n      name: match.name,\n      type: \"function\",\n      stateMutability: match.stateMutability ?? \"nonpayable\",\n      inputs,\n      outputs\n    };\n  }\n  if (isEventSignature(signature)) {\n    const match = execEventSignature(signature);\n    if (!match)\n      throw new BaseError(\"Invalid event signature.\", {\n        details: signature\n      });\n    const params = splitParameters(match.parameters);\n    const abiParameters = [];\n    const length = params.length;\n    for (let i = 0; i < length; i++) {\n      abiParameters.push(\n        parseAbiParameter(params[i], {\n          modifiers: eventModifiers,\n          structs,\n          type: \"event\"\n        })\n      );\n    }\n    return { name: match.name, type: \"event\", inputs: abiParameters };\n  }\n  if (isErrorSignature(signature)) {\n    const match = execErrorSignature(signature);\n    if (!match)\n      throw new BaseError(\"Invalid error signature.\", {\n        details: signature\n      });\n    const params = splitParameters(match.parameters);\n    const abiParameters = [];\n    const length = params.length;\n    for (let i = 0; i < length; i++) {\n      abiParameters.push(\n        parseAbiParameter(params[i], { structs, type: \"error\" })\n      );\n    }\n    return { name: match.name, type: \"error\", inputs: abiParameters };\n  }\n  if (isConstructorSignature(signature)) {\n    const match = execConstructorSignature(signature);\n    if (!match)\n      throw new BaseError(\"Invalid constructor signature.\", {\n        details: signature\n      });\n    const params = splitParameters(match.parameters);\n    const abiParameters = [];\n    const length = params.length;\n    for (let i = 0; i < length; i++) {\n      abiParameters.push(\n        parseAbiParameter(params[i], { structs, type: \"constructor\" })\n      );\n    }\n    return {\n      type: \"constructor\",\n      stateMutability: match.stateMutability ?? \"nonpayable\",\n      inputs: abiParameters\n    };\n  }\n  if (isFallbackSignature(signature))\n    return { type: \"fallback\" };\n  if (isReceiveSignature(signature))\n    return {\n      type: \"receive\",\n      stateMutability: \"payable\"\n    };\n  throw new BaseError(\"Unknown signature.\", {\n    details: signature\n  });\n}\nvar abiParameterWithoutTupleRegex = /^(?<type>[a-zA-Z0-9_]+?)(?<array>(?:\\[\\d*?\\])+?)?(?:\\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\\s(?<name>[a-zA-Z0-9_]+))?$/;\nvar abiParameterWithTupleRegex = /^\\((?<type>.+?)\\)(?<array>(?:\\[\\d*?\\])+?)?(?:\\s(?<modifier>calldata|indexed|memory|storage{1}))?(?:\\s(?<name>[a-zA-Z0-9_]+))?$/;\nvar dynamicIntegerRegex = /^u?int$/;\nfunction parseAbiParameter(param, options) {\n  const parameterCacheKey = getParameterCacheKey(param, options?.type);\n  if (parameterCache.has(parameterCacheKey))\n    return parameterCache.get(parameterCacheKey);\n  const isTuple = isTupleRegex.test(param);\n  const match = execTyped(\n    isTuple ? abiParameterWithTupleRegex : abiParameterWithoutTupleRegex,\n    param\n  );\n  if (!match)\n    throw new BaseError(\"Invalid ABI parameter.\", {\n      details: param\n    });\n  if (match.name && isSolidityKeyword(match.name))\n    throw new BaseError(\"Invalid ABI parameter.\", {\n      details: param,\n      metaMessages: [\n        `\"${match.name}\" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`\n      ]\n    });\n  const name2 = match.name ? { name: match.name } : {};\n  const indexed = match.modifier === \"indexed\" ? { indexed: true } : {};\n  const structs = options?.structs ?? {};\n  let type;\n  let components = {};\n  if (isTuple) {\n    type = \"tuple\";\n    const params = splitParameters(match.type);\n    const components_ = [];\n    const length = params.length;\n    for (let i = 0; i < length; i++) {\n      components_.push(parseAbiParameter(params[i], { structs }));\n    }\n    components = { components: components_ };\n  } else if (match.type in structs) {\n    type = \"tuple\";\n    components = { components: structs[match.type] };\n  } else if (dynamicIntegerRegex.test(match.type)) {\n    type = `${match.type}256`;\n  } else {\n    type = match.type;\n    if (!(options?.type === \"struct\") && !isSolidityType(type))\n      throw new BaseError(\"Unknown type.\", {\n        metaMessages: [`Type \"${type}\" is not a valid ABI type.`]\n      });\n  }\n  if (match.modifier) {\n    if (!options?.modifiers?.has?.(match.modifier))\n      throw new BaseError(\"Invalid ABI parameter.\", {\n        details: param,\n        metaMessages: [\n          `Modifier \"${match.modifier}\" not allowed${options?.type ? ` in \"${options.type}\" type` : \"\"}.`\n        ]\n      });\n    if (functionModifiers.has(match.modifier) && !isValidDataLocation(type, !!match.array))\n      throw new BaseError(\"Invalid ABI parameter.\", {\n        details: param,\n        metaMessages: [\n          `Modifier \"${match.modifier}\" not allowed${options?.type ? ` in \"${options.type}\" type` : \"\"}.`,\n          `Data location can only be specified for array, struct, or mapping types, but \"${match.modifier}\" was given.`\n        ]\n      });\n  }\n  const abiParameter = {\n    type: `${type}${match.array ?? \"\"}`,\n    ...name2,\n    ...indexed,\n    ...components\n  };\n  parameterCache.set(parameterCacheKey, abiParameter);\n  return abiParameter;\n}\nfunction splitParameters(params, result = [], current = \"\", depth = 0) {\n  if (params === \"\") {\n    if (current === \"\")\n      return result;\n    if (depth !== 0)\n      throw new BaseError(\"Unbalanced parentheses.\", {\n        metaMessages: [\n          `\"${current.trim()}\" has too many ${depth > 0 ? \"opening\" : \"closing\"} parentheses.`\n        ],\n        details: `Depth \"${depth}\"`\n      });\n    return [...result, current.trim()];\n  }\n  const length = params.length;\n  for (let i = 0; i < length; i++) {\n    const char = params[i];\n    const tail = params.slice(i + 1);\n    switch (char) {\n      case \",\":\n        return depth === 0 ? splitParameters(tail, [...result, current.trim()]) : splitParameters(tail, result, `${current}${char}`, depth);\n      case \"(\":\n        return splitParameters(tail, result, `${current}${char}`, depth + 1);\n      case \")\":\n        return splitParameters(tail, result, `${current}${char}`, depth - 1);\n      default:\n        return splitParameters(tail, result, `${current}${char}`, depth);\n    }\n  }\n  return [];\n}\nfunction isSolidityType(type) {\n  return type === \"address\" || type === \"bool\" || type === \"function\" || type === \"string\" || bytesRegex.test(type) || integerRegex.test(type);\n}\nvar protectedKeywordsRegex = /^(?:after|alias|anonymous|apply|auto|byte|calldata|case|catch|constant|copyof|default|defined|error|event|external|false|final|function|immutable|implements|in|indexed|inline|internal|let|mapping|match|memory|mutable|null|of|override|partial|private|promise|public|pure|reference|relocatable|return|returns|sizeof|static|storage|struct|super|supports|switch|this|true|try|typedef|typeof|var|view|virtual)$/;\nfunction isSolidityKeyword(name2) {\n  return name2 === \"address\" || name2 === \"bool\" || name2 === \"function\" || name2 === \"string\" || name2 === \"tuple\" || bytesRegex.test(name2) || integerRegex.test(name2) || protectedKeywordsRegex.test(name2);\n}\nfunction isValidDataLocation(type, isArray) {\n  return isArray || type === \"bytes\" || type === \"string\" || type === \"tuple\";\n}\n\n// src/human-readable/runtime/structs.ts\nfunction parseStructs(signatures) {\n  const shallowStructs = {};\n  const signaturesLength = signatures.length;\n  for (let i = 0; i < signaturesLength; i++) {\n    const signature = signatures[i];\n    if (!isStructSignature(signature))\n      continue;\n    const match = execStructSignature(signature);\n    if (!match)\n      throw new BaseError(\"Invalid struct signature.\", {\n        details: signature\n      });\n    const properties = match.properties.split(\";\");\n    const components = [];\n    const propertiesLength = properties.length;\n    for (let k = 0; k < propertiesLength; k++) {\n      const property = properties[k];\n      const trimmed = property.trim();\n      if (!trimmed)\n        continue;\n      const abiParameter = parseAbiParameter(trimmed, {\n        type: \"struct\"\n      });\n      components.push(abiParameter);\n    }\n    if (!components.length)\n      throw new BaseError(\"Invalid struct signature.\", {\n        details: signature,\n        metaMessages: [\"No properties exist.\"]\n      });\n    shallowStructs[match.name] = components;\n  }\n  const resolvedStructs = {};\n  const entries = Object.entries(shallowStructs);\n  const entriesLength = entries.length;\n  for (let i = 0; i < entriesLength; i++) {\n    const [name2, parameters] = entries[i];\n    resolvedStructs[name2] = resolveStructs(parameters, shallowStructs);\n  }\n  return resolvedStructs;\n}\nvar typeWithoutTupleRegex = /^(?<type>[a-zA-Z0-9_]+?)(?<array>(?:\\[\\d*?\\])+?)?$/;\nfunction resolveStructs(abiParameters, structs, ancestors = /* @__PURE__ */ new Set()) {\n  const components = [];\n  const length = abiParameters.length;\n  for (let i = 0; i < length; i++) {\n    const abiParameter = abiParameters[i];\n    const isTuple = isTupleRegex.test(abiParameter.type);\n    if (isTuple)\n      components.push(abiParameter);\n    else {\n      const match = execTyped(\n        typeWithoutTupleRegex,\n        abiParameter.type\n      );\n      if (!match?.type)\n        throw new BaseError(\"Invalid ABI parameter.\", {\n          details: JSON.stringify(abiParameter, null, 2),\n          metaMessages: [\"ABI parameter type is invalid.\"]\n        });\n      const { array, type } = match;\n      if (type in structs) {\n        if (ancestors.has(type))\n          throw new BaseError(\"Circular reference detected.\", {\n            metaMessages: [`Struct \"${type}\" is a circular reference.`]\n          });\n        components.push({\n          ...abiParameter,\n          type: `tuple${array ?? \"\"}`,\n          components: resolveStructs(\n            structs[type] ?? [],\n            structs,\n            /* @__PURE__ */ new Set([...ancestors, type])\n          )\n        });\n      } else {\n        if (isSolidityType(type))\n          components.push(abiParameter);\n        else\n          throw new BaseError(\"Unknown type.\", {\n            metaMessages: [\n              `Type \"${type}\" is not a valid ABI type. Perhaps you forgot to include a struct signature?`\n            ]\n          });\n      }\n    }\n  }\n  return components;\n}\n\n// src/human-readable/parseAbi.ts\nfunction parseAbi(signatures) {\n  const structs = parseStructs(signatures);\n  const abi = [];\n  const length = signatures.length;\n  for (let i = 0; i < length; i++) {\n    const signature = signatures[i];\n    if (isStructSignature(signature))\n      continue;\n    abi.push(parseSignature(signature, structs));\n  }\n  return abi;\n}\n\n// src/human-readable/parseAbiItem.ts\nfunction parseAbiItem(signature) {\n  let abiItem;\n  if (typeof signature === \"string\")\n    abiItem = parseSignature(signature);\n  else {\n    const structs = parseStructs(signature);\n    const length = signature.length;\n    for (let i = 0; i < length; i++) {\n      const signature_ = signature[i];\n      if (isStructSignature(signature_))\n        continue;\n      abiItem = parseSignature(signature_, structs);\n      break;\n    }\n  }\n  if (!abiItem)\n    throw new BaseError(\"Failed to parse ABI item.\", {\n      details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,\n      docsPath: \"/api/human.html#parseabiitem-1\"\n    });\n  return abiItem;\n}\n\n// src/human-readable/parseAbiParameter.ts\nfunction parseAbiParameter2(param) {\n  let abiParameter;\n  if (typeof param === \"string\")\n    abiParameter = parseAbiParameter(param, {\n      modifiers\n    });\n  else {\n    const structs = parseStructs(param);\n    const length = param.length;\n    for (let i = 0; i < length; i++) {\n      const signature = param[i];\n      if (isStructSignature(signature))\n        continue;\n      abiParameter = parseAbiParameter(signature, { modifiers, structs });\n      break;\n    }\n  }\n  if (!abiParameter)\n    throw new BaseError(\"Failed to parse ABI parameter.\", {\n      details: `parseAbiParameter(${JSON.stringify(param, null, 2)})`,\n      docsPath: \"/api/human.html#parseabiparameter-1\"\n    });\n  return abiParameter;\n}\n\n// src/human-readable/parseAbiParameters.ts\nfunction parseAbiParameters(params) {\n  const abiParameters = [];\n  if (typeof params === \"string\") {\n    const parameters = splitParameters(params);\n    const length = parameters.length;\n    for (let i = 0; i < length; i++) {\n      abiParameters.push(parseAbiParameter(parameters[i], { modifiers }));\n    }\n  } else {\n    const structs = parseStructs(params);\n    const length = params.length;\n    for (let i = 0; i < length; i++) {\n      const signature = params[i];\n      if (isStructSignature(signature))\n        continue;\n      const parameters = splitParameters(signature);\n      const length2 = parameters.length;\n      for (let k = 0; k < length2; k++) {\n        abiParameters.push(\n          parseAbiParameter(parameters[k], { modifiers, structs })\n        );\n      }\n    }\n  }\n  if (abiParameters.length === 0)\n    throw new BaseError(\"Failed to parse ABI parameters.\", {\n      details: `parseAbiParameters(${JSON.stringify(params, null, 2)})`,\n      docsPath: \"/api/human.html#parseabiparameters-1\"\n    });\n  return abiParameters;\n}\nexport {\n  BaseError,\n  narrow,\n  parseAbi,\n  parseAbiItem,\n  parseAbiParameter2 as parseAbiParameter,\n  parseAbiParameters\n};\n","/*\r\n *  big.js v6.2.2\r\n *  A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.\r\n *  Copyright (c) 2024 Michael Mclaughlin\r\n *  https://github.com/MikeMcl/big.js/LICENCE.md\r\n */\r\n\r\n\r\n/************************************** EDITABLE DEFAULTS *****************************************/\r\n\r\n\r\n  // The default values below must be integers within the stated ranges.\r\n\r\n  /*\r\n   * The maximum number of decimal places (DP) of the results of operations involving division:\r\n   * div and sqrt, and pow with negative exponents.\r\n   */\r\nvar DP = 20,          // 0 to MAX_DP\r\n\r\n  /*\r\n   * The rounding mode (RM) used when rounding to the above decimal places.\r\n   *\r\n   *  0  Towards zero (i.e. truncate, no rounding).       (ROUND_DOWN)\r\n   *  1  To nearest neighbour. If equidistant, round up.  (ROUND_HALF_UP)\r\n   *  2  To nearest neighbour. If equidistant, to even.   (ROUND_HALF_EVEN)\r\n   *  3  Away from zero.                                  (ROUND_UP)\r\n   */\r\n  RM = 1,             // 0, 1, 2 or 3\r\n\r\n  // The maximum value of DP and Big.DP.\r\n  MAX_DP = 1E6,       // 0 to 1000000\r\n\r\n  // The maximum magnitude of the exponent argument to the pow method.\r\n  MAX_POWER = 1E6,    // 1 to 1000000\r\n\r\n  /*\r\n   * The negative exponent (NE) at and beneath which toString returns exponential notation.\r\n   * (JavaScript numbers: -7)\r\n   * -1000000 is the minimum recommended exponent value of a Big.\r\n   */\r\n  NE = -7,            // 0 to -1000000\r\n\r\n  /*\r\n   * The positive exponent (PE) at and above which toString returns exponential notation.\r\n   * (JavaScript numbers: 21)\r\n   * 1000000 is the maximum recommended exponent value of a Big, but this limit is not enforced.\r\n   */\r\n  PE = 21,            // 0 to 1000000\r\n\r\n  /*\r\n   * When true, an error will be thrown if a primitive number is passed to the Big constructor,\r\n   * or if valueOf is called, or if toNumber is called on a Big which cannot be converted to a\r\n   * primitive number without a loss of precision.\r\n   */\r\n  STRICT = false,     // true or false\r\n\r\n\r\n/**************************************************************************************************/\r\n\r\n\r\n  // Error messages.\r\n  NAME = '[big.js] ',\r\n  INVALID = NAME + 'Invalid ',\r\n  INVALID_DP = INVALID + 'decimal places',\r\n  INVALID_RM = INVALID + 'rounding mode',\r\n  DIV_BY_ZERO = NAME + 'Division by zero',\r\n\r\n  // The shared prototype object.\r\n  P = {},\r\n  UNDEFINED = void 0,\r\n  NUMERIC = /^-?(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i;\r\n\r\n\r\n/*\r\n * Create and return a Big constructor.\r\n */\r\nfunction _Big_() {\r\n\r\n  /*\r\n   * The Big constructor and exported function.\r\n   * Create and return a new instance of a Big number object.\r\n   *\r\n   * n {number|string|Big} A numeric value.\r\n   */\r\n  function Big(n) {\r\n    var x = this;\r\n\r\n    // Enable constructor usage without new.\r\n    if (!(x instanceof Big)) return n === UNDEFINED ? _Big_() : new Big(n);\r\n\r\n    // Duplicate.\r\n    if (n instanceof Big) {\r\n      x.s = n.s;\r\n      x.e = n.e;\r\n      x.c = n.c.slice();\r\n    } else {\r\n      if (typeof n !== 'string') {\r\n        if (Big.strict === true && typeof n !== 'bigint') {\r\n          throw TypeError(INVALID + 'value');\r\n        }\r\n\r\n        // Minus zero?\r\n        n = n === 0 && 1 / n < 0 ? '-0' : String(n);\r\n      }\r\n\r\n      parse(x, n);\r\n    }\r\n\r\n    // Retain a reference to this Big constructor.\r\n    // Shadow Big.prototype.constructor which points to Object.\r\n    x.constructor = Big;\r\n  }\r\n\r\n  Big.prototype = P;\r\n  Big.DP = DP;\r\n  Big.RM = RM;\r\n  Big.NE = NE;\r\n  Big.PE = PE;\r\n  Big.strict = STRICT;\r\n  Big.roundDown = 0;\r\n  Big.roundHalfUp = 1;\r\n  Big.roundHalfEven = 2;\r\n  Big.roundUp = 3;\r\n\r\n  return Big;\r\n}\r\n\r\n\r\n/*\r\n * Parse the number or string value passed to a Big constructor.\r\n *\r\n * x {Big} A Big number instance.\r\n * n {number|string} A numeric value.\r\n */\r\nfunction parse(x, n) {\r\n  var e, i, nl;\r\n\r\n  if (!NUMERIC.test(n)) {\r\n    throw Error(INVALID + 'number');\r\n  }\r\n\r\n  // Determine sign.\r\n  x.s = n.charAt(0) == '-' ? (n = n.slice(1), -1) : 1;\r\n\r\n  // Decimal point?\r\n  if ((e = n.indexOf('.')) > -1) n = n.replace('.', '');\r\n\r\n  // Exponential form?\r\n  if ((i = n.search(/e/i)) > 0) {\r\n\r\n    // Determine exponent.\r\n    if (e < 0) e = i;\r\n    e += +n.slice(i + 1);\r\n    n = n.substring(0, i);\r\n  } else if (e < 0) {\r\n\r\n    // Integer.\r\n    e = n.length;\r\n  }\r\n\r\n  nl = n.length;\r\n\r\n  // Determine leading zeros.\r\n  for (i = 0; i < nl && n.charAt(i) == '0';) ++i;\r\n\r\n  if (i == nl) {\r\n\r\n    // Zero.\r\n    x.c = [x.e = 0];\r\n  } else {\r\n\r\n    // Determine trailing zeros.\r\n    for (; nl > 0 && n.charAt(--nl) == '0';);\r\n    x.e = e - i - 1;\r\n    x.c = [];\r\n\r\n    // Convert string to array of digits without leading/trailing zeros.\r\n    for (e = 0; i <= nl;) x.c[e++] = +n.charAt(i++);\r\n  }\r\n\r\n  return x;\r\n}\r\n\r\n\r\n/*\r\n * Round Big x to a maximum of sd significant digits using rounding mode rm.\r\n *\r\n * x {Big} The Big to round.\r\n * sd {number} Significant digits: integer, 0 to MAX_DP inclusive.\r\n * rm {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n * [more] {boolean} Whether the result of division was truncated.\r\n */\r\nfunction round(x, sd, rm, more) {\r\n  var xc = x.c;\r\n\r\n  if (rm === UNDEFINED) rm = x.constructor.RM;\r\n  if (rm !== 0 && rm !== 1 && rm !== 2 && rm !== 3) {\r\n    throw Error(INVALID_RM);\r\n  }\r\n\r\n  if (sd < 1) {\r\n    more =\r\n      rm === 3 && (more || !!xc[0]) || sd === 0 && (\r\n      rm === 1 && xc[0] >= 5 ||\r\n      rm === 2 && (xc[0] > 5 || xc[0] === 5 && (more || xc[1] !== UNDEFINED))\r\n    );\r\n\r\n    xc.length = 1;\r\n\r\n    if (more) {\r\n\r\n      // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n      x.e = x.e - sd + 1;\r\n      xc[0] = 1;\r\n    } else {\r\n\r\n      // Zero.\r\n      xc[0] = x.e = 0;\r\n    }\r\n  } else if (sd < xc.length) {\r\n\r\n    // xc[sd] is the digit after the digit that may be rounded up.\r\n    more =\r\n      rm === 1 && xc[sd] >= 5 ||\r\n      rm === 2 && (xc[sd] > 5 || xc[sd] === 5 &&\r\n        (more || xc[sd + 1] !== UNDEFINED || xc[sd - 1] & 1)) ||\r\n      rm === 3 && (more || !!xc[0]);\r\n\r\n    // Remove any digits after the required precision.\r\n    xc.length = sd;\r\n\r\n    // Round up?\r\n    if (more) {\r\n\r\n      // Rounding up may mean the previous digit has to be rounded up.\r\n      for (; ++xc[--sd] > 9;) {\r\n        xc[sd] = 0;\r\n        if (sd === 0) {\r\n          ++x.e;\r\n          xc.unshift(1);\r\n          break;\r\n        }\r\n      }\r\n    }\r\n\r\n    // Remove trailing zeros.\r\n    for (sd = xc.length; !xc[--sd];) xc.pop();\r\n  }\r\n\r\n  return x;\r\n}\r\n\r\n\r\n/*\r\n * Return a string representing the value of Big x in normal or exponential notation.\r\n * Handles P.toExponential, P.toFixed, P.toJSON, P.toPrecision, P.toString and P.valueOf.\r\n */\r\nfunction stringify(x, doExponential, isNonzero) {\r\n  var e = x.e,\r\n    s = x.c.join(''),\r\n    n = s.length;\r\n\r\n  // Exponential notation?\r\n  if (doExponential) {\r\n    s = s.charAt(0) + (n > 1 ? '.' + s.slice(1) : '') + (e < 0 ? 'e' : 'e+') + e;\r\n\r\n  // Normal notation.\r\n  } else if (e < 0) {\r\n    for (; ++e;) s = '0' + s;\r\n    s = '0.' + s;\r\n  } else if (e > 0) {\r\n    if (++e > n) {\r\n      for (e -= n; e--;) s += '0';\r\n    } else if (e < n) {\r\n      s = s.slice(0, e) + '.' + s.slice(e);\r\n    }\r\n  } else if (n > 1) {\r\n    s = s.charAt(0) + '.' + s.slice(1);\r\n  }\r\n\r\n  return x.s < 0 && isNonzero ? '-' + s : s;\r\n}\r\n\r\n\r\n// Prototype/instance methods\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the absolute value of this Big.\r\n */\r\nP.abs = function () {\r\n  var x = new this.constructor(this);\r\n  x.s = 1;\r\n  return x;\r\n};\r\n\r\n\r\n/*\r\n * Return 1 if the value of this Big is greater than the value of Big y,\r\n *       -1 if the value of this Big is less than the value of Big y, or\r\n *        0 if they have the same value.\r\n */\r\nP.cmp = function (y) {\r\n  var isneg,\r\n    x = this,\r\n    xc = x.c,\r\n    yc = (y = new x.constructor(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 zero?\r\n  if (!xc[0] || !yc[0]) return !xc[0] ? !yc[0] ? 0 : -j : i;\r\n\r\n  // Signs differ?\r\n  if (i != j) return i;\r\n\r\n  isneg = i < 0;\r\n\r\n  // Compare exponents.\r\n  if (k != l) return k > l ^ isneg ? 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 = -1; ++i < j;) {\r\n    if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;\r\n  }\r\n\r\n  // Compare lengths.\r\n  return k == l ? 0 : k > l ^ isneg ? 1 : -1;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big divided by the value of Big y, rounded,\r\n * if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.\r\n */\r\nP.div = function (y) {\r\n  var x = this,\r\n    Big = x.constructor,\r\n    a = x.c,                  // dividend\r\n    b = (y = new Big(y)).c,   // divisor\r\n    k = x.s == y.s ? 1 : -1,\r\n    dp = Big.DP;\r\n\r\n  if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {\r\n    throw Error(INVALID_DP);\r\n  }\r\n\r\n  // Divisor is zero?\r\n  if (!b[0]) {\r\n    throw Error(DIV_BY_ZERO);\r\n  }\r\n\r\n  // Dividend is 0? Return +-0.\r\n  if (!a[0]) {\r\n    y.s = k;\r\n    y.c = [y.e = 0];\r\n    return y;\r\n  }\r\n\r\n  var bl, bt, n, cmp, ri,\r\n    bz = b.slice(),\r\n    ai = bl = b.length,\r\n    al = a.length,\r\n    r = a.slice(0, bl),   // remainder\r\n    rl = r.length,\r\n    q = y,                // quotient\r\n    qc = q.c = [],\r\n    qi = 0,\r\n    p = dp + (q.e = x.e - y.e) + 1;    // precision of the result\r\n\r\n  q.s = k;\r\n  k = p < 0 ? 0 : p;\r\n\r\n  // Create version of divisor with leading zero.\r\n  bz.unshift(0);\r\n\r\n  // Add zeros to make remainder as long as divisor.\r\n  for (; rl++ < bl;) r.push(0);\r\n\r\n  do {\r\n\r\n    // n is how many times the divisor goes into current remainder.\r\n    for (n = 0; n < 10; n++) {\r\n\r\n      // Compare divisor and remainder.\r\n      if (bl != (rl = r.length)) {\r\n        cmp = bl > rl ? 1 : -1;\r\n      } else {\r\n        for (ri = -1, cmp = 0; ++ri < bl;) {\r\n          if (b[ri] != r[ri]) {\r\n            cmp = b[ri] > r[ri] ? 1 : -1;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      // If divisor < remainder, subtract divisor from remainder.\r\n      if (cmp < 0) {\r\n\r\n        // Remainder can't be more than 1 digit longer than divisor.\r\n        // Equalise lengths using divisor with extra leading zero?\r\n        for (bt = rl == bl ? b : bz; rl;) {\r\n          if (r[--rl] < bt[rl]) {\r\n            ri = rl;\r\n            for (; ri && !r[--ri];) r[ri] = 9;\r\n            --r[ri];\r\n            r[rl] += 10;\r\n          }\r\n          r[rl] -= bt[rl];\r\n        }\r\n\r\n        for (; !r[0];) r.shift();\r\n      } else {\r\n        break;\r\n      }\r\n    }\r\n\r\n    // Add the digit n to the result array.\r\n    qc[qi++] = cmp ? n : ++n;\r\n\r\n    // Update the remainder.\r\n    if (r[0] && cmp) r[rl] = a[ai] || 0;\r\n    else r = [a[ai]];\r\n\r\n  } while ((ai++ < al || r[0] !== UNDEFINED) && k--);\r\n\r\n  // Leading zero? Do not remove if result is simply zero (qi == 1).\r\n  if (!qc[0] && qi != 1) {\r\n\r\n    // There can't be more than one zero.\r\n    qc.shift();\r\n    q.e--;\r\n    p--;\r\n  }\r\n\r\n  // Round?\r\n  if (qi > p) round(q, p, Big.RM, r[0] !== UNDEFINED);\r\n\r\n  return q;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Big is equal to the value of Big y, otherwise return false.\r\n */\r\nP.eq = 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 Big is greater than the value of Big y, otherwise return\r\n * false.\r\n */\r\nP.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 Big is greater than or equal to the value of Big y, otherwise\r\n * return false.\r\n */\r\nP.gte = function (y) {\r\n  return this.cmp(y) > -1;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Big is less than the value of Big y, otherwise return false.\r\n */\r\nP.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 Big is less than or equal to the value of Big y, otherwise\r\n * return false.\r\n */\r\nP.lte = function (y) {\r\n  return this.cmp(y) < 1;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big minus the value of Big y.\r\n */\r\nP.minus = P.sub = function (y) {\r\n  var i, j, t, xlty,\r\n    x = this,\r\n    Big = x.constructor,\r\n    a = x.s,\r\n    b = (y = new Big(y)).s;\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 xc = x.c.slice(),\r\n    xe = x.e,\r\n    yc = y.c,\r\n    ye = y.e;\r\n\r\n  // Either zero?\r\n  if (!xc[0] || !yc[0]) {\r\n    if (yc[0]) {\r\n      y.s = -b;\r\n    } else if (xc[0]) {\r\n      y = new Big(x);\r\n    } else {\r\n      y.s = 1;\r\n    }\r\n    return y;\r\n  }\r\n\r\n  // Determine which is the bigger number. Prepend zeros to equalise exponents.\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    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 = xc.length < yc.length) ? xc : yc).length;\r\n\r\n    for (a = b = 0; b < j; b++) {\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  /*\r\n   * Append zeros to xc if shorter. No need to add zeros to yc if shorter as subtraction only\r\n   * needs to start at yc.length.\r\n   */\r\n  if ((b = (j = yc.length) - (i = xc.length)) > 0) for (; b--;) xc[i++] = 0;\r\n\r\n  // Subtract yc from xc.\r\n  for (b = i; j > a;) {\r\n    if (xc[--j] < yc[j]) {\r\n      for (i = j; i && !xc[--i];) xc[i] = 9;\r\n      --xc[i];\r\n      xc[j] += 10;\r\n    }\r\n\r\n    xc[j] -= yc[j];\r\n  }\r\n\r\n  // Remove trailing zeros.\r\n  for (; xc[--b] === 0;) xc.pop();\r\n\r\n  // Remove leading zeros and adjust exponent accordingly.\r\n  for (; xc[0] === 0;) {\r\n    xc.shift();\r\n    --ye;\r\n  }\r\n\r\n  if (!xc[0]) {\r\n\r\n    // n - n = +0\r\n    y.s = 1;\r\n\r\n    // Result must be zero.\r\n    xc = [ye = 0];\r\n  }\r\n\r\n  y.c = xc;\r\n  y.e = ye;\r\n\r\n  return y;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big modulo the value of Big y.\r\n */\r\nP.mod = function (y) {\r\n  var ygtx,\r\n    x = this,\r\n    Big = x.constructor,\r\n    a = x.s,\r\n    b = (y = new Big(y)).s;\r\n\r\n  if (!y.c[0]) {\r\n    throw Error(DIV_BY_ZERO);\r\n  }\r\n\r\n  x.s = y.s = 1;\r\n  ygtx = y.cmp(x) == 1;\r\n  x.s = a;\r\n  y.s = b;\r\n\r\n  if (ygtx) return new Big(x);\r\n\r\n  a = Big.DP;\r\n  b = Big.RM;\r\n  Big.DP = Big.RM = 0;\r\n  x = x.div(y);\r\n  Big.DP = a;\r\n  Big.RM = b;\r\n\r\n  return this.minus(x.times(y));\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big negated.\r\n */\r\nP.neg = function () {\r\n  var x = new this.constructor(this);\r\n  x.s = -x.s;\r\n  return x;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big plus the value of Big y.\r\n */\r\nP.plus = P.add = function (y) {\r\n  var e, k, t,\r\n    x = this,\r\n    Big = x.constructor;\r\n\r\n  y = new Big(y);\r\n\r\n  // 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  var xe = x.e,\r\n    xc = x.c,\r\n    ye = y.e,\r\n    yc = y.c;\r\n\r\n  // Either zero?\r\n  if (!xc[0] || !yc[0]) {\r\n    if (!yc[0]) {\r\n      if (xc[0]) {\r\n        y = new Big(x);\r\n      } else {\r\n        y.s = x.s;\r\n      }\r\n    }\r\n    return y;\r\n  }\r\n\r\n  xc = xc.slice();\r\n\r\n  // Prepend zeros to equalise exponents.\r\n  // Note: reverse faster than unshifts.\r\n  if (e = xe - ye) {\r\n    if (e > 0) {\r\n      ye = xe;\r\n      t = yc;\r\n    } else {\r\n      e = -e;\r\n      t = xc;\r\n    }\r\n\r\n    t.reverse();\r\n    for (; e--;) t.push(0);\r\n    t.reverse();\r\n  }\r\n\r\n  // Point xc to the longer array.\r\n  if (xc.length - yc.length < 0) {\r\n    t = yc;\r\n    yc = xc;\r\n    xc = t;\r\n  }\r\n\r\n  e = yc.length;\r\n\r\n  // Only start adding at yc.length - 1 as the further digits of xc can be left as they are.\r\n  for (k = 0; e; xc[e] %= 10) k = (xc[--e] = xc[e] + yc[e] + k) / 10 | 0;\r\n\r\n  // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n\r\n  if (k) {\r\n    xc.unshift(k);\r\n    ++ye;\r\n  }\r\n\r\n  // Remove trailing zeros.\r\n  for (e = xc.length; xc[--e] === 0;) xc.pop();\r\n\r\n  y.c = xc;\r\n  y.e = ye;\r\n\r\n  return y;\r\n};\r\n\r\n\r\n/*\r\n * Return a Big whose value is the value of this Big raised to the power n.\r\n * If n is negative, round to a maximum of Big.DP decimal places using rounding\r\n * mode Big.RM.\r\n *\r\n * n {number} Integer, -MAX_POWER to MAX_POWER inclusive.\r\n */\r\nP.pow = function (n) {\r\n  var x = this,\r\n    one = new x.constructor('1'),\r\n    y = one,\r\n    isneg = n < 0;\r\n\r\n  if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) {\r\n    throw Error(INVALID + 'exponent');\r\n  }\r\n\r\n  if (isneg) n = -n;\r\n\r\n  for (;;) {\r\n    if (n & 1) y = y.times(x);\r\n    n >>= 1;\r\n    if (!n) break;\r\n    x = x.times(x);\r\n  }\r\n\r\n  return isneg ? one.div(y) : y;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big rounded to a maximum precision of sd\r\n * significant digits using rounding mode rm, or Big.RM if rm is not specified.\r\n *\r\n * sd {number} Significant digits: integer, 1 to MAX_DP inclusive.\r\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n */\r\nP.prec = function (sd, rm) {\r\n  if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {\r\n    throw Error(INVALID + 'precision');\r\n  }\r\n  return round(new this.constructor(this), sd, rm);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big rounded to a maximum of dp decimal places\r\n * using rounding mode rm, or Big.RM if rm is not specified.\r\n * If dp is negative, round to an integer which is a multiple of 10**-dp.\r\n * If dp is not specified, round to 0 decimal places.\r\n *\r\n * dp? {number} Integer, -MAX_DP to MAX_DP inclusive.\r\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n */\r\nP.round = function (dp, rm) {\r\n  if (dp === UNDEFINED) dp = 0;\r\n  else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) {\r\n    throw Error(INVALID_DP);\r\n  }\r\n  return round(new this.constructor(this), dp + this.e + 1, rm);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the square root of the value of this Big, rounded, if\r\n * necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.\r\n */\r\nP.sqrt = function () {\r\n  var r, c, t,\r\n    x = this,\r\n    Big = x.constructor,\r\n    s = x.s,\r\n    e = x.e,\r\n    half = new Big('0.5');\r\n\r\n  // Zero?\r\n  if (!x.c[0]) return new Big(x);\r\n\r\n  // Negative?\r\n  if (s < 0) {\r\n    throw Error(NAME + 'No square root');\r\n  }\r\n\r\n  // Estimate.\r\n  s = Math.sqrt(+stringify(x, true, true));\r\n\r\n  // Math.sqrt underflow/overflow?\r\n  // Re-estimate: pass x coefficient to Math.sqrt as integer, then adjust the result exponent.\r\n  if (s === 0 || s === 1 / 0) {\r\n    c = x.c.join('');\r\n    if (!(c.length + e & 1)) c += '0';\r\n    s = Math.sqrt(c);\r\n    e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);\r\n    r = new Big((s == 1 / 0 ? '5e' : (s = s.toExponential()).slice(0, s.indexOf('e') + 1)) + e);\r\n  } else {\r\n    r = new Big(s + '');\r\n  }\r\n\r\n  e = r.e + (Big.DP += 4);\r\n\r\n  // Newton-Raphson iteration.\r\n  do {\r\n    t = r;\r\n    r = half.times(t.plus(x.div(t)));\r\n  } while (t.c.slice(0, e).join('') !== r.c.slice(0, e).join(''));\r\n\r\n  return round(r, (Big.DP -= 4) + r.e + 1, Big.RM);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big times the value of Big y.\r\n */\r\nP.times = P.mul = function (y) {\r\n  var c,\r\n    x = this,\r\n    Big = x.constructor,\r\n    xc = x.c,\r\n    yc = (y = new Big(y)).c,\r\n    a = xc.length,\r\n    b = yc.length,\r\n    i = x.e,\r\n    j = y.e;\r\n\r\n  // Determine sign of result.\r\n  y.s = x.s == y.s ? 1 : -1;\r\n\r\n  // Return signed 0 if either 0.\r\n  if (!xc[0] || !yc[0]) {\r\n    y.c = [y.e = 0];\r\n    return y;\r\n  }\r\n\r\n  // Initialise exponent of result as x.e + y.e.\r\n  y.e = i + j;\r\n\r\n  // If array xc has fewer digits than yc, swap xc and yc, and lengths.\r\n  if (a < b) {\r\n    c = xc;\r\n    xc = yc;\r\n    yc = c;\r\n    j = a;\r\n    a = b;\r\n    b = j;\r\n  }\r\n\r\n  // Initialise coefficient array of result with zeros.\r\n  for (c = new Array(j = a + b); j--;) c[j] = 0;\r\n\r\n  // Multiply.\r\n\r\n  // i is initially xc.length.\r\n  for (i = b; i--;) {\r\n    b = 0;\r\n\r\n    // a is yc.length.\r\n    for (j = a + i; j > i;) {\r\n\r\n      // Current sum of products at this digit position, plus carry.\r\n      b = c[j] + yc[i] * xc[j - i - 1] + b;\r\n      c[j--] = b % 10;\r\n\r\n      // carry\r\n      b = b / 10 | 0;\r\n    }\r\n\r\n    c[j] = b;\r\n  }\r\n\r\n  // Increment result exponent if there is a final carry, otherwise remove leading zero.\r\n  if (b) ++y.e;\r\n  else c.shift();\r\n\r\n  // Remove trailing zeros.\r\n  for (i = c.length; !c[--i];) c.pop();\r\n  y.c = c;\r\n\r\n  return y;\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Big in exponential notation rounded to dp fixed\r\n * decimal places using rounding mode rm, or Big.RM if rm is not specified.\r\n *\r\n * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.\r\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n */\r\nP.toExponential = function (dp, rm) {\r\n  var x = this,\r\n    n = x.c[0];\r\n\r\n  if (dp !== UNDEFINED) {\r\n    if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {\r\n      throw Error(INVALID_DP);\r\n    }\r\n    x = round(new x.constructor(x), ++dp, rm);\r\n    for (; x.c.length < dp;) x.c.push(0);\r\n  }\r\n\r\n  return stringify(x, true, !!n);\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Big in normal notation rounded to dp fixed\r\n * decimal places using rounding mode rm, or Big.RM if rm is not specified.\r\n *\r\n * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.\r\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\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 */\r\nP.toFixed = function (dp, rm) {\r\n  var x = this,\r\n    n = x.c[0];\r\n\r\n  if (dp !== UNDEFINED) {\r\n    if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {\r\n      throw Error(INVALID_DP);\r\n    }\r\n    x = round(new x.constructor(x), dp + x.e + 1, rm);\r\n\r\n    // x.e may have changed if the value is rounded up.\r\n    for (dp = dp + x.e + 1; x.c.length < dp;) x.c.push(0);\r\n  }\r\n\r\n  return stringify(x, false, !!n);\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Big.\r\n * Return exponential notation if this Big has a positive exponent equal to or greater than\r\n * Big.PE, or a negative exponent equal to or less than Big.NE.\r\n * Omit the sign for negative zero.\r\n */\r\nP[Symbol.for('nodejs.util.inspect.custom')] = P.toJSON = P.toString = function () {\r\n  var x = this,\r\n    Big = x.constructor;\r\n  return stringify(x, x.e <= Big.NE || x.e >= Big.PE, !!x.c[0]);\r\n};\r\n\r\n\r\n/*\r\n * Return the value of this Big as a primitve number.\r\n */\r\nP.toNumber = function () {\r\n  var n = +stringify(this, true, true);\r\n  if (this.constructor.strict === true && !this.eq(n.toString())) {\r\n    throw Error(NAME + 'Imprecise conversion');\r\n  }\r\n  return n;\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Big rounded to sd significant digits using\r\n * rounding mode rm, or Big.RM if rm is not specified.\r\n * Use 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_DP inclusive.\r\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n */\r\nP.toPrecision = function (sd, rm) {\r\n  var x = this,\r\n    Big = x.constructor,\r\n    n = x.c[0];\r\n\r\n  if (sd !== UNDEFINED) {\r\n    if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {\r\n      throw Error(INVALID + 'precision');\r\n    }\r\n    x = round(new Big(x), sd, rm);\r\n    for (; x.c.length < sd;) x.c.push(0);\r\n  }\r\n\r\n  return stringify(x, sd <= x.e || x.e <= Big.NE || x.e >= Big.PE, !!n);\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Big.\r\n * Return exponential notation if this Big has a positive exponent equal to or greater than\r\n * Big.PE, or a negative exponent equal to or less than Big.NE.\r\n * Include the sign for negative zero.\r\n */\r\nP.valueOf = function () {\r\n  var x = this,\r\n    Big = x.constructor;\r\n  if (Big.strict === true) {\r\n    throw Error(NAME + 'valueOf disallowed');\r\n  }\r\n  return stringify(x, x.e <= Big.NE || x.e >= Big.PE, true);\r\n};\r\n\r\n\r\n// Export\r\n\r\n\r\nexport var Big = _Big_();\r\n\r\n/// <reference types=\"https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/master/types/big.js/index.d.ts\" />\r\nexport default Big;\r\n","/*\r\n *      bignumber.js v9.1.2\r\n *      A JavaScript library for arbitrary-precision arithmetic.\r\n *      https://github.com/MikeMcl/bignumber.js\r\n *      Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>\r\n *      MIT Licensed.\r\n *\r\n *      BigNumber.prototype methods     |  BigNumber methods\r\n *                                      |\r\n *      absoluteValue            abs    |  clone\r\n *      comparedTo                      |  config               set\r\n *      decimalPlaces            dp     |      DECIMAL_PLACES\r\n *      dividedBy                div    |      ROUNDING_MODE\r\n *      dividedToIntegerBy       idiv   |      EXPONENTIAL_AT\r\n *      exponentiatedBy          pow    |      RANGE\r\n *      integerValue                    |      CRYPTO\r\n *      isEqualTo                eq     |      MODULO_MODE\r\n *      isFinite                        |      POW_PRECISION\r\n *      isGreaterThan            gt     |      FORMAT\r\n *      isGreaterThanOrEqualTo   gte    |      ALPHABET\r\n *      isInteger                       |  isBigNumber\r\n *      isLessThan               lt     |  maximum              max\r\n *      isLessThanOrEqualTo      lte    |  minimum              min\r\n *      isNaN                           |  random\r\n *      isNegative                      |  sum\r\n *      isPositive                      |\r\n *      isZero                          |\r\n *      minus                           |\r\n *      modulo                   mod    |\r\n *      multipliedBy             times  |\r\n *      negated                         |\r\n *      plus                            |\r\n *      precision                sd     |\r\n *      shiftedBy                       |\r\n *      squareRoot               sqrt   |\r\n *      toExponential                   |\r\n *      toFixed                         |\r\n *      toFormat                        |\r\n *      toFraction                      |\r\n *      toJSON                          |\r\n *      toNumber                        |\r\n *      toPrecision                     |\r\n *      toString                        |\r\n *      valueOf                         |\r\n *\r\n */\r\n\r\n\r\nvar\r\n  isNumeric = /^-?(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?$/i,\r\n  mathceil = Math.ceil,\r\n  mathfloor = Math.floor,\r\n\r\n  bignumberError = '[BigNumber Error] ',\r\n  tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',\r\n\r\n  BASE = 1e14,\r\n  LOG_BASE = 14,\r\n  MAX_SAFE_INTEGER = 0x1fffffffffffff,         // 2^53 - 1\r\n  // MAX_INT32 = 0x7fffffff,                   // 2^31 - 1\r\n  POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],\r\n  SQRT_BASE = 1e7,\r\n\r\n  // EDITABLE\r\n  // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and\r\n  // the arguments to toExponential, toFixed, toFormat, and toPrecision.\r\n  MAX = 1E9;                                   // 0 to MAX_INT32\r\n\r\n\r\n/*\r\n * Create and return a BigNumber constructor.\r\n */\r\nfunction clone(configObject) {\r\n  var div, convertBase, parseNumeric,\r\n    P = BigNumber.prototype = { constructor: BigNumber, toString: null, valueOf: null },\r\n    ONE = new BigNumber(1),\r\n\r\n\r\n    //----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------\r\n\r\n\r\n    // The default values below must be integers within the inclusive ranges stated.\r\n    // The values can also be changed at run-time using BigNumber.set.\r\n\r\n    // The maximum number of decimal places for operations involving division.\r\n    DECIMAL_PLACES = 20,                     // 0 to MAX\r\n\r\n    // The rounding mode used when rounding to the above decimal places, and when using\r\n    // toExponential, toFixed, toFormat and toPrecision, and round (default value).\r\n    // UP         0 Away from zero.\r\n    // DOWN       1 Towards zero.\r\n    // CEIL       2 Towards +Infinity.\r\n    // FLOOR      3 Towards -Infinity.\r\n    // HALF_UP    4 Towards nearest neighbour. If equidistant, up.\r\n    // HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.\r\n    // HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.\r\n    // HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.\r\n    // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.\r\n    ROUNDING_MODE = 4,                       // 0 to 8\r\n\r\n    // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]\r\n\r\n    // The exponent value at and beneath which toString returns exponential notation.\r\n    // Number type: -7\r\n    TO_EXP_NEG = -7,                         // 0 to -MAX\r\n\r\n    // The exponent value at and above which toString returns exponential notation.\r\n    // Number type: 21\r\n    TO_EXP_POS = 21,                         // 0 to MAX\r\n\r\n    // RANGE : [MIN_EXP, MAX_EXP]\r\n\r\n    // The minimum exponent value, beneath which underflow to zero occurs.\r\n    // Number type: -324  (5e-324)\r\n    MIN_EXP = -1e7,                          // -1 to -MAX\r\n\r\n    // The maximum exponent value, above which overflow to Infinity occurs.\r\n    // Number type:  308  (1.7976931348623157e+308)\r\n    // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.\r\n    MAX_EXP = 1e7,                           // 1 to MAX\r\n\r\n    // Whether to use cryptographically-secure random number generation, if available.\r\n    CRYPTO = false,                          // true or false\r\n\r\n    // The modulo mode used when calculating the modulus: a mod n.\r\n    // The quotient (q = a / n) is calculated according to the corresponding rounding mode.\r\n    // The remainder (r) is calculated as: r = a - n * q.\r\n    //\r\n    // UP        0 The remainder is positive if the dividend is negative, else is negative.\r\n    // DOWN      1 The remainder has the same sign as the dividend.\r\n    //             This modulo mode is commonly known as 'truncated division' and is\r\n    //             equivalent to (a % n) in JavaScript.\r\n    // FLOOR     3 The remainder has the same sign as the divisor (Python %).\r\n    // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.\r\n    // EUCLID    9 Euclidian division. q = sign(n) * floor(a / abs(n)).\r\n    //             The remainder is always positive.\r\n    //\r\n    // The truncated division, floored division, Euclidian division and IEEE 754 remainder\r\n    // modes are commonly used for the modulus operation.\r\n    // Although the other rounding modes can also be used, they may not give useful results.\r\n    MODULO_MODE = 1,                         // 0 to 9\r\n\r\n    // The maximum number of significant digits of the result of the exponentiatedBy operation.\r\n    // If POW_PRECISION is 0, there will be unlimited significant digits.\r\n    POW_PRECISION = 0,                       // 0 to MAX\r\n\r\n    // The format specification used by the BigNumber.prototype.toFormat method.\r\n    FORMAT = {\r\n      prefix: '',\r\n      groupSize: 3,\r\n      secondaryGroupSize: 0,\r\n      groupSeparator: ',',\r\n      decimalSeparator: '.',\r\n      fractionGroupSize: 0,\r\n      fractionGroupSeparator: '\\xA0',        // non-breaking space\r\n      suffix: ''\r\n    },\r\n\r\n    // The alphabet used for base conversion. It must be at least 2 characters long, with no '+',\r\n    // '-', '.', whitespace, or repeated character.\r\n    // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'\r\n    ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz',\r\n    alphabetHasNormalDecimalDigits = true;\r\n\r\n\r\n  //------------------------------------------------------------------------------------------\r\n\r\n\r\n  // CONSTRUCTOR\r\n\r\n\r\n  /*\r\n   * The BigNumber constructor and exported function.\r\n   * Create and return a new instance of a BigNumber object.\r\n   *\r\n   * v {number|string|BigNumber} A numeric value.\r\n   * [b] {number} The base of v. Integer, 2 to ALPHABET.length inclusive.\r\n   */\r\n  function BigNumber(v, b) {\r\n    var alphabet, c, caseChanged, e, i, isNum, len, str,\r\n      x = this;\r\n\r\n    // Enable constructor call without `new`.\r\n    if (!(x instanceof BigNumber)) return new BigNumber(v, b);\r\n\r\n    if (b == null) {\r\n\r\n      if (v && v._isBigNumber === true) {\r\n        x.s = v.s;\r\n\r\n        if (!v.c || v.e > MAX_EXP) {\r\n          x.c = x.e = null;\r\n        } else if (v.e < MIN_EXP) {\r\n          x.c = [x.e = 0];\r\n        } else {\r\n          x.e = v.e;\r\n          x.c = v.c.slice();\r\n        }\r\n\r\n        return;\r\n      }\r\n\r\n      if ((isNum = typeof v == 'number') && v * 0 == 0) {\r\n\r\n        // Use `1 / n` to handle minus zero also.\r\n        x.s = 1 / v < 0 ? (v = -v, -1) : 1;\r\n\r\n        // Fast path for integers, where n < 2147483648 (2**31).\r\n        if (v === ~~v) {\r\n          for (e = 0, i = v; i >= 10; i /= 10, e++);\r\n\r\n          if (e > MAX_EXP) {\r\n            x.c = x.e = null;\r\n          } else {\r\n            x.e = e;\r\n            x.c = [v];\r\n          }\r\n\r\n          return;\r\n        }\r\n\r\n        str = String(v);\r\n      } else {\r\n\r\n        if (!isNumeric.test(str = String(v))) return parseNumeric(x, str, isNum);\r\n\r\n        x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;\r\n      }\r\n\r\n      // Decimal point?\r\n      if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n\r\n      // Exponential form?\r\n      if ((i = str.search(/e/i)) > 0) {\r\n\r\n        // Determine exponent.\r\n        if (e < 0) e = i;\r\n        e += +str.slice(i + 1);\r\n        str = str.substring(0, i);\r\n      } else if (e < 0) {\r\n\r\n        // Integer.\r\n        e = str.length;\r\n      }\r\n\r\n    } else {\r\n\r\n      // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n      intCheck(b, 2, ALPHABET.length, 'Base');\r\n\r\n      // Allow exponential notation to be used with base 10 argument, while\r\n      // also rounding to DECIMAL_PLACES as with other bases.\r\n      if (b == 10 && alphabetHasNormalDecimalDigits) {\r\n        x = new BigNumber(v);\r\n        return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);\r\n      }\r\n\r\n      str = String(v);\r\n\r\n      if (isNum = typeof v == 'number') {\r\n\r\n        // Avoid potential interpretation of Infinity and NaN as base 44+ values.\r\n        if (v * 0 != 0) return parseNumeric(x, str, isNum, b);\r\n\r\n        x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;\r\n\r\n        // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n        if (BigNumber.DEBUG && str.replace(/^0\\.0*|\\./, '').length > 15) {\r\n          throw Error\r\n           (tooManyDigits + v);\r\n        }\r\n      } else {\r\n        x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;\r\n      }\r\n\r\n      alphabet = ALPHABET.slice(0, b);\r\n      e = i = 0;\r\n\r\n      // Check that str is a valid base b number.\r\n      // Don't use RegExp, so alphabet can contain special characters.\r\n      for (len = str.length; i < len; i++) {\r\n        if (alphabet.indexOf(c = str.charAt(i)) < 0) {\r\n          if (c == '.') {\r\n\r\n            // If '.' is not the first character and it has not be found before.\r\n            if (i > e) {\r\n              e = len;\r\n              continue;\r\n            }\r\n          } else if (!caseChanged) {\r\n\r\n            // Allow e.g. hexadecimal 'FF' as well as 'ff'.\r\n            if (str == str.toUpperCase() && (str = str.toLowerCase()) ||\r\n                str == str.toLowerCase() && (str = str.toUpperCase())) {\r\n              caseChanged = true;\r\n              i = -1;\r\n              e = 0;\r\n              continue;\r\n            }\r\n          }\r\n\r\n          return parseNumeric(x, String(v), isNum, b);\r\n        }\r\n      }\r\n\r\n      // Prevent later check for length on converted number.\r\n      isNum = false;\r\n      str = convertBase(str, b, 10, x.s);\r\n\r\n      // Decimal point?\r\n      if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');\r\n      else e = str.length;\r\n    }\r\n\r\n    // Determine leading zeros.\r\n    for (i = 0; str.charCodeAt(i) === 48; i++);\r\n\r\n    // Determine trailing zeros.\r\n    for (len = str.length; str.charCodeAt(--len) === 48;);\r\n\r\n    if (str = str.slice(i, ++len)) {\r\n      len -= i;\r\n\r\n      // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'\r\n      if (isNum && BigNumber.DEBUG &&\r\n        len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {\r\n          throw Error\r\n           (tooManyDigits + (x.s * v));\r\n      }\r\n\r\n       // Overflow?\r\n      if ((e = e - i - 1) > MAX_EXP) {\r\n\r\n        // Infinity.\r\n        x.c = x.e = null;\r\n\r\n      // Underflow?\r\n      } else if (e < MIN_EXP) {\r\n\r\n        // Zero.\r\n        x.c = [x.e = 0];\r\n      } else {\r\n        x.e = e;\r\n        x.c = [];\r\n\r\n        // Transform base\r\n\r\n        // e is the base 10 exponent.\r\n        // i is where to slice str to get the first element of the coefficient array.\r\n        i = (e + 1) % LOG_BASE;\r\n        if (e < 0) i += LOG_BASE;  // i < 1\r\n\r\n        if (i < len) {\r\n          if (i) x.c.push(+str.slice(0, i));\r\n\r\n          for (len -= LOG_BASE; i < len;) {\r\n            x.c.push(+str.slice(i, i += LOG_BASE));\r\n          }\r\n\r\n          i = LOG_BASE - (str = str.slice(i)).length;\r\n        } else {\r\n          i -= len;\r\n        }\r\n\r\n        for (; i--; str += '0');\r\n        x.c.push(+str);\r\n      }\r\n    } else {\r\n\r\n      // Zero.\r\n      x.c = [x.e = 0];\r\n    }\r\n  }\r\n\r\n\r\n  // CONSTRUCTOR PROPERTIES\r\n\r\n\r\n  BigNumber.clone = clone;\r\n\r\n  BigNumber.ROUND_UP = 0;\r\n  BigNumber.ROUND_DOWN = 1;\r\n  BigNumber.ROUND_CEIL = 2;\r\n  BigNumber.ROUND_FLOOR = 3;\r\n  BigNumber.ROUND_HALF_UP = 4;\r\n  BigNumber.ROUND_HALF_DOWN = 5;\r\n  BigNumber.ROUND_HALF_EVEN = 6;\r\n  BigNumber.ROUND_HALF_CEIL = 7;\r\n  BigNumber.ROUND_HALF_FLOOR = 8;\r\n  BigNumber.EUCLID = 9;\r\n\r\n\r\n  /*\r\n   * Configure infrequently-changing library-wide settings.\r\n   *\r\n   * Accept an object with the following optional properties (if the value of a property is\r\n   * a number, it must be an integer within the inclusive range stated):\r\n   *\r\n   *   DECIMAL_PLACES   {number}           0 to MAX\r\n   *   ROUNDING_MODE    {number}           0 to 8\r\n   *   EXPONENTIAL_AT   {number|number[]}  -MAX to MAX  or  [-MAX to 0, 0 to MAX]\r\n   *   RANGE            {number|number[]}  -MAX to MAX (not zero)  or  [-MAX to -1, 1 to MAX]\r\n   *   CRYPTO           {boolean}          true or false\r\n   *   MODULO_MODE      {number}           0 to 9\r\n   *   POW_PRECISION       {number}           0 to MAX\r\n   *   ALPHABET         {string}           A string of two or more unique characters which does\r\n   *                                       not contain '.'.\r\n   *   FORMAT           {object}           An object with some of the following properties:\r\n   *     prefix                 {string}\r\n   *     groupSize              {number}\r\n   *     secondaryGroupSize     {number}\r\n   *     groupSeparator         {string}\r\n   *     decimalSeparator       {string}\r\n   *     fractionGroupSize      {number}\r\n   *     fractionGroupSeparator {string}\r\n   *     suffix                 {string}\r\n   *\r\n   * (The values assigned to the above FORMAT object properties are not checked for validity.)\r\n   *\r\n   * E.g.\r\n   * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })\r\n   *\r\n   * Ignore properties/parameters set to null or undefined, except for ALPHABET.\r\n   *\r\n   * Return an object with the properties current values.\r\n   */\r\n  BigNumber.config = BigNumber.set = function (obj) {\r\n    var p, v;\r\n\r\n    if (obj != null) {\r\n\r\n      if (typeof obj == 'object') {\r\n\r\n        // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.\r\n        // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'\r\n        if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {\r\n          v = obj[p];\r\n          intCheck(v, 0, MAX, p);\r\n          DECIMAL_PLACES = v;\r\n        }\r\n\r\n        // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.\r\n        // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n        if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {\r\n          v = obj[p];\r\n          intCheck(v, 0, 8, p);\r\n          ROUNDING_MODE = v;\r\n        }\r\n\r\n        // EXPONENTIAL_AT {number|number[]}\r\n        // Integer, -MAX to MAX inclusive or\r\n        // [integer -MAX to 0 inclusive, 0 to MAX inclusive].\r\n        // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'\r\n        if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {\r\n          v = obj[p];\r\n          if (v && v.pop) {\r\n            intCheck(v[0], -MAX, 0, p);\r\n            intCheck(v[1], 0, MAX, p);\r\n            TO_EXP_NEG = v[0];\r\n            TO_EXP_POS = v[1];\r\n          } else {\r\n            intCheck(v, -MAX, MAX, p);\r\n            TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);\r\n          }\r\n        }\r\n\r\n        // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or\r\n        // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].\r\n        // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'\r\n        if (obj.hasOwnProperty(p = 'RANGE')) {\r\n          v = obj[p];\r\n          if (v && v.pop) {\r\n            intCheck(v[0], -MAX, -1, p);\r\n            intCheck(v[1], 1, MAX, p);\r\n            MIN_EXP = v[0];\r\n            MAX_EXP = v[1];\r\n          } else {\r\n            intCheck(v, -MAX, MAX, p);\r\n            if (v) {\r\n              MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);\r\n            } else {\r\n              throw Error\r\n               (bignumberError + p + ' cannot be zero: ' + v);\r\n            }\r\n          }\r\n        }\r\n\r\n        // CRYPTO {boolean} true or false.\r\n        // '[BigNumber Error] CRYPTO not true or false: {v}'\r\n        // '[BigNumber Error] crypto unavailable'\r\n        if (obj.hasOwnProperty(p = 'CRYPTO')) {\r\n          v = obj[p];\r\n          if (v === !!v) {\r\n            if (v) {\r\n              if (typeof crypto != 'undefined' && crypto &&\r\n               (crypto.getRandomValues || crypto.randomBytes)) {\r\n                CRYPTO = v;\r\n              } else {\r\n                CRYPTO = !v;\r\n                throw Error\r\n                 (bignumberError + 'crypto unavailable');\r\n              }\r\n            } else {\r\n              CRYPTO = v;\r\n            }\r\n          } else {\r\n            throw Error\r\n             (bignumberError + p + ' not true or false: ' + v);\r\n          }\r\n        }\r\n\r\n        // MODULO_MODE {number} Integer, 0 to 9 inclusive.\r\n        // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'\r\n        if (obj.hasOwnProperty(p = 'MODULO_MODE')) {\r\n          v = obj[p];\r\n          intCheck(v, 0, 9, p);\r\n          MODULO_MODE = v;\r\n        }\r\n\r\n        // POW_PRECISION {number} Integer, 0 to MAX inclusive.\r\n        // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'\r\n        if (obj.hasOwnProperty(p = 'POW_PRECISION')) {\r\n          v = obj[p];\r\n          intCheck(v, 0, MAX, p);\r\n          POW_PRECISION = v;\r\n        }\r\n\r\n        // FORMAT {object}\r\n        // '[BigNumber Error] FORMAT not an object: {v}'\r\n        if (obj.hasOwnProperty(p = 'FORMAT')) {\r\n          v = obj[p];\r\n          if (typeof v == 'object') FORMAT = v;\r\n          else throw Error\r\n           (bignumberError + p + ' not an object: ' + v);\r\n        }\r\n\r\n        // ALPHABET {string}\r\n        // '[BigNumber Error] ALPHABET invalid: {v}'\r\n        if (obj.hasOwnProperty(p = 'ALPHABET')) {\r\n          v = obj[p];\r\n\r\n          // Disallow if less than two characters,\r\n          // or if it contains '+', '-', '.', whitespace, or a repeated character.\r\n          if (typeof v == 'string' && !/^.?$|[+\\-.\\s]|(.).*\\1/.test(v)) {\r\n            alphabetHasNormalDecimalDigits = v.slice(0, 10) == '0123456789';\r\n            ALPHABET = v;\r\n          } else {\r\n            throw Error\r\n             (bignumberError + p + ' invalid: ' + v);\r\n          }\r\n        }\r\n\r\n      } else {\r\n\r\n        // '[BigNumber Error] Object expected: {v}'\r\n        throw Error\r\n         (bignumberError + 'Object expected: ' + obj);\r\n      }\r\n    }\r\n\r\n    return {\r\n      DECIMAL_PLACES: DECIMAL_PLACES,\r\n      ROUNDING_MODE: ROUNDING_MODE,\r\n      EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],\r\n      RANGE: [MIN_EXP, MAX_EXP],\r\n      CRYPTO: CRYPTO,\r\n      MODULO_MODE: MODULO_MODE,\r\n      POW_PRECISION: POW_PRECISION,\r\n      FORMAT: FORMAT,\r\n      ALPHABET: ALPHABET\r\n    };\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if v is a BigNumber instance, otherwise return false.\r\n   *\r\n   * If BigNumber.DEBUG is true, throw if a BigNumber instance is not well-formed.\r\n   *\r\n   * v {any}\r\n   *\r\n   * '[BigNumber Error] Invalid BigNumber: {v}'\r\n   */\r\n  BigNumber.isBigNumber = function (v) {\r\n    if (!v || v._isBigNumber !== true) return false;\r\n    if (!BigNumber.DEBUG) return true;\r\n\r\n    var i, n,\r\n      c = v.c,\r\n      e = v.e,\r\n      s = v.s;\r\n\r\n    out: if ({}.toString.call(c) == '[object Array]') {\r\n\r\n      if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {\r\n\r\n        // If the first element is zero, the BigNumber value must be zero.\r\n        if (c[0] === 0) {\r\n          if (e === 0 && c.length === 1) return true;\r\n          break out;\r\n        }\r\n\r\n        // Calculate number of digits that c[0] should have, based on the exponent.\r\n        i = (e + 1) % LOG_BASE;\r\n        if (i < 1) i += LOG_BASE;\r\n\r\n        // Calculate number of digits of c[0].\r\n        //if (Math.ceil(Math.log(c[0] + 1) / Math.LN10) == i) {\r\n        if (String(c[0]).length == i) {\r\n\r\n          for (i = 0; i < c.length; i++) {\r\n            n = c[i];\r\n            if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;\r\n          }\r\n\r\n          // Last element cannot be zero, unless it is the only element.\r\n          if (n !== 0) return true;\r\n        }\r\n      }\r\n\r\n    // Infinity/NaN\r\n    } else if (c === null && e === null && (s === null || s === 1 || s === -1)) {\r\n      return true;\r\n    }\r\n\r\n    throw Error\r\n      (bignumberError + 'Invalid BigNumber: ' + v);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the maximum of the arguments.\r\n   *\r\n   * arguments {number|string|BigNumber}\r\n   */\r\n  BigNumber.maximum = BigNumber.max = function () {\r\n    return maxOrMin(arguments, -1);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the minimum of the arguments.\r\n   *\r\n   * arguments {number|string|BigNumber}\r\n   */\r\n  BigNumber.minimum = BigNumber.min = function () {\r\n    return maxOrMin(arguments, 1);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,\r\n   * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing\r\n   * zeros are produced).\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'\r\n   * '[BigNumber Error] crypto unavailable'\r\n   */\r\n  BigNumber.random = (function () {\r\n    var pow2_53 = 0x20000000000000;\r\n\r\n    // Return a 53 bit integer n, where 0 <= n < 9007199254740992.\r\n    // Check if Math.random() produces more than 32 bits of randomness.\r\n    // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.\r\n    // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.\r\n    var random53bitInt = (Math.random() * pow2_53) & 0x1fffff\r\n     ? function () { return mathfloor(Math.random() * pow2_53); }\r\n     : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +\r\n       (Math.random() * 0x800000 | 0); };\r\n\r\n    return function (dp) {\r\n      var a, b, e, k, v,\r\n        i = 0,\r\n        c = [],\r\n        rand = new BigNumber(ONE);\r\n\r\n      if (dp == null) dp = DECIMAL_PLACES;\r\n      else intCheck(dp, 0, MAX);\r\n\r\n      k = mathceil(dp / LOG_BASE);\r\n\r\n      if (CRYPTO) {\r\n\r\n        // Browsers supporting crypto.getRandomValues.\r\n        if (crypto.getRandomValues) {\r\n\r\n          a = crypto.getRandomValues(new Uint32Array(k *= 2));\r\n\r\n          for (; i < k;) {\r\n\r\n            // 53 bits:\r\n            // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)\r\n            // 11111 11111111 11111111 11111111 11100000 00000000 00000000\r\n            // ((Math.pow(2, 32) - 1) >>> 11).toString(2)\r\n            //                                     11111 11111111 11111111\r\n            // 0x20000 is 2^21.\r\n            v = a[i] * 0x20000 + (a[i + 1] >>> 11);\r\n\r\n            // Rejection sampling:\r\n            // 0 <= v < 9007199254740992\r\n            // Probability that v >= 9e15, is\r\n            // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251\r\n            if (v >= 9e15) {\r\n              b = crypto.getRandomValues(new Uint32Array(2));\r\n              a[i] = b[0];\r\n              a[i + 1] = b[1];\r\n            } else {\r\n\r\n              // 0 <= v <= 8999999999999999\r\n              // 0 <= (v % 1e14) <= 99999999999999\r\n              c.push(v % 1e14);\r\n              i += 2;\r\n            }\r\n          }\r\n          i = k / 2;\r\n\r\n        // Node.js supporting crypto.randomBytes.\r\n        } else if (crypto.randomBytes) {\r\n\r\n          // buffer\r\n          a = crypto.randomBytes(k *= 7);\r\n\r\n          for (; i < k;) {\r\n\r\n            // 0x1000000000000 is 2^48, 0x10000000000 is 2^40\r\n            // 0x100000000 is 2^32, 0x1000000 is 2^24\r\n            // 11111 11111111 11111111 11111111 11111111 11111111 11111111\r\n            // 0 <= v < 9007199254740992\r\n            v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +\r\n               (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +\r\n               (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];\r\n\r\n            if (v >= 9e15) {\r\n              crypto.randomBytes(7).copy(a, i);\r\n            } else {\r\n\r\n              // 0 <= (v % 1e14) <= 99999999999999\r\n              c.push(v % 1e14);\r\n              i += 7;\r\n            }\r\n          }\r\n          i = k / 7;\r\n        } else {\r\n          CRYPTO = false;\r\n          throw Error\r\n           (bignumberError + 'crypto unavailable');\r\n        }\r\n      }\r\n\r\n      // Use Math.random.\r\n      if (!CRYPTO) {\r\n\r\n        for (; i < k;) {\r\n          v = random53bitInt();\r\n          if (v < 9e15) c[i++] = v % 1e14;\r\n        }\r\n      }\r\n\r\n      k = c[--i];\r\n      dp %= LOG_BASE;\r\n\r\n      // Convert trailing digits to zeros according to dp.\r\n      if (k && dp) {\r\n        v = POWS_TEN[LOG_BASE - dp];\r\n        c[i] = mathfloor(k / v) * v;\r\n      }\r\n\r\n      // Remove trailing elements which are zero.\r\n      for (; c[i] === 0; c.pop(), i--);\r\n\r\n      // Zero?\r\n      if (i < 0) {\r\n        c = [e = 0];\r\n      } else {\r\n\r\n        // Remove leading elements which are zero and adjust exponent accordingly.\r\n        for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);\r\n\r\n        // Count the digits of the first element of c to determine leading zeros, and...\r\n        for (i = 1, v = c[0]; v >= 10; v /= 10, i++);\r\n\r\n        // adjust the exponent accordingly.\r\n        if (i < LOG_BASE) e -= LOG_BASE - i;\r\n      }\r\n\r\n      rand.e = e;\r\n      rand.c = c;\r\n      return rand;\r\n    };\r\n  })();\r\n\r\n\r\n   /*\r\n   * Return a BigNumber whose value is the sum of the arguments.\r\n   *\r\n   * arguments {number|string|BigNumber}\r\n   */\r\n  BigNumber.sum = function () {\r\n    var i = 1,\r\n      args = arguments,\r\n      sum = new BigNumber(args[0]);\r\n    for (; i < args.length;) sum = sum.plus(args[i++]);\r\n    return sum;\r\n  };\r\n\r\n\r\n  // PRIVATE FUNCTIONS\r\n\r\n\r\n  // Called by BigNumber and BigNumber.prototype.toString.\r\n  convertBase = (function () {\r\n    var decimal = '0123456789';\r\n\r\n    /*\r\n     * Convert string of baseIn to an array of numbers of baseOut.\r\n     * Eg. toBaseOut('255', 10, 16) returns [15, 15].\r\n     * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].\r\n     */\r\n    function toBaseOut(str, baseIn, baseOut, alphabet) {\r\n      var j,\r\n        arr = [0],\r\n        arrL,\r\n        i = 0,\r\n        len = str.length;\r\n\r\n      for (; i < len;) {\r\n        for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);\r\n\r\n        arr[0] += alphabet.indexOf(str.charAt(i++));\r\n\r\n        for (j = 0; j < arr.length; j++) {\r\n\r\n          if (arr[j] > baseOut - 1) {\r\n            if (arr[j + 1] == null) arr[j + 1] = 0;\r\n            arr[j + 1] += arr[j] / baseOut | 0;\r\n            arr[j] %= baseOut;\r\n          }\r\n        }\r\n      }\r\n\r\n      return arr.reverse();\r\n    }\r\n\r\n    // Convert a numeric string of baseIn to a numeric string of baseOut.\r\n    // If the caller is toString, we are converting from base 10 to baseOut.\r\n    // If the caller is BigNumber, we are converting from baseIn to base 10.\r\n    return function (str, baseIn, baseOut, sign, callerIsToString) {\r\n      var alphabet, d, e, k, r, x, xc, y,\r\n        i = str.indexOf('.'),\r\n        dp = DECIMAL_PLACES,\r\n        rm = ROUNDING_MODE;\r\n\r\n      // Non-integer.\r\n      if (i >= 0) {\r\n        k = POW_PRECISION;\r\n\r\n        // Unlimited precision.\r\n        POW_PRECISION = 0;\r\n        str = str.replace('.', '');\r\n        y = new BigNumber(baseIn);\r\n        x = y.pow(str.length - i);\r\n        POW_PRECISION = k;\r\n\r\n        // Convert str as if an integer, then restore the fraction part by dividing the\r\n        // result by its base raised to a power.\r\n\r\n        y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),\r\n         10, baseOut, decimal);\r\n        y.e = y.c.length;\r\n      }\r\n\r\n      // Convert the number as integer.\r\n\r\n      xc = toBaseOut(str, baseIn, baseOut, callerIsToString\r\n       ? (alphabet = ALPHABET, decimal)\r\n       : (alphabet = decimal, ALPHABET));\r\n\r\n      // xc now represents str as an integer and converted to baseOut. e is the exponent.\r\n      e = k = xc.length;\r\n\r\n      // Remove trailing zeros.\r\n      for (; xc[--k] == 0; xc.pop());\r\n\r\n      // Zero?\r\n      if (!xc[0]) return alphabet.charAt(0);\r\n\r\n      // Does str represent an integer? If so, no need for the division.\r\n      if (i < 0) {\r\n        --e;\r\n      } else {\r\n        x.c = xc;\r\n        x.e = e;\r\n\r\n        // The sign is needed for correct rounding.\r\n        x.s = sign;\r\n        x = div(x, y, dp, rm, baseOut);\r\n        xc = x.c;\r\n        r = x.r;\r\n        e = x.e;\r\n      }\r\n\r\n      // xc now represents str converted to baseOut.\r\n\r\n      // THe index of the rounding digit.\r\n      d = e + dp + 1;\r\n\r\n      // The rounding digit: the digit to the right of the digit that may be rounded up.\r\n      i = xc[d];\r\n\r\n      // Look at the rounding digits and mode to determine whether to round up.\r\n\r\n      k = baseOut / 2;\r\n      r = r || d < 0 || xc[d + 1] != null;\r\n\r\n      r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n            : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||\r\n             rm == (x.s < 0 ? 8 : 7));\r\n\r\n      // If the index of the rounding digit is not greater than zero, or xc represents\r\n      // zero, then the result of the base conversion is zero or, if rounding up, a value\r\n      // such as 0.00001.\r\n      if (d < 1 || !xc[0]) {\r\n\r\n        // 1^-dp or 0\r\n        str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);\r\n      } else {\r\n\r\n        // Truncate xc to the required number of decimal places.\r\n        xc.length = d;\r\n\r\n        // Round up?\r\n        if (r) {\r\n\r\n          // Rounding up may mean the previous digit has to be rounded up and so on.\r\n          for (--baseOut; ++xc[--d] > baseOut;) {\r\n            xc[d] = 0;\r\n\r\n            if (!d) {\r\n              ++e;\r\n              xc = [1].concat(xc);\r\n            }\r\n          }\r\n        }\r\n\r\n        // Determine trailing zeros.\r\n        for (k = xc.length; !xc[--k];);\r\n\r\n        // E.g. [4, 11, 15] becomes 4bf.\r\n        for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));\r\n\r\n        // Add leading zeros, decimal point and trailing zeros as required.\r\n        str = toFixedPoint(str, e, alphabet.charAt(0));\r\n      }\r\n\r\n      // The caller will add the sign.\r\n      return str;\r\n    };\r\n  })();\r\n\r\n\r\n  // Perform division in the specified base. Called by div and convertBase.\r\n  div = (function () {\r\n\r\n    // Assume non-zero x and k.\r\n    function multiply(x, k, base) {\r\n      var m, temp, xlo, xhi,\r\n        carry = 0,\r\n        i = x.length,\r\n        klo = k % SQRT_BASE,\r\n        khi = k / SQRT_BASE | 0;\r\n\r\n      for (x = x.slice(); i--;) {\r\n        xlo = x[i] % SQRT_BASE;\r\n        xhi = x[i] / SQRT_BASE | 0;\r\n        m = khi * xlo + xhi * klo;\r\n        temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;\r\n        carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;\r\n        x[i] = temp % base;\r\n      }\r\n\r\n      if (carry) x = [carry].concat(x);\r\n\r\n      return x;\r\n    }\r\n\r\n    function compare(a, b, aL, bL) {\r\n      var i, cmp;\r\n\r\n      if (aL != bL) {\r\n        cmp = aL > bL ? 1 : -1;\r\n      } else {\r\n\r\n        for (i = cmp = 0; i < aL; i++) {\r\n\r\n          if (a[i] != b[i]) {\r\n            cmp = a[i] > b[i] ? 1 : -1;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      return cmp;\r\n    }\r\n\r\n    function subtract(a, b, aL, base) {\r\n      var i = 0;\r\n\r\n      // Subtract b from a.\r\n      for (; aL--;) {\r\n        a[aL] -= i;\r\n        i = a[aL] < b[aL] ? 1 : 0;\r\n        a[aL] = i * base + a[aL] - b[aL];\r\n      }\r\n\r\n      // Remove leading zeros.\r\n      for (; !a[0] && a.length > 1; a.splice(0, 1));\r\n    }\r\n\r\n    // x: dividend, y: divisor.\r\n    return function (x, y, dp, rm, base) {\r\n      var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,\r\n        yL, yz,\r\n        s = x.s == y.s ? 1 : -1,\r\n        xc = x.c,\r\n        yc = y.c;\r\n\r\n      // Either NaN, Infinity or 0?\r\n      if (!xc || !xc[0] || !yc || !yc[0]) {\r\n\r\n        return new BigNumber(\r\n\r\n         // Return NaN if either NaN, or both Infinity or 0.\r\n         !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :\r\n\r\n          // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.\r\n          xc && xc[0] == 0 || !yc ? s * 0 : s / 0\r\n       );\r\n      }\r\n\r\n      q = new BigNumber(s);\r\n      qc = q.c = [];\r\n      e = x.e - y.e;\r\n      s = dp + e + 1;\r\n\r\n      if (!base) {\r\n        base = BASE;\r\n        e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);\r\n        s = s / LOG_BASE | 0;\r\n      }\r\n\r\n      // Result exponent may be one less then the current value of e.\r\n      // The coefficients of the BigNumbers from convertBase may have trailing zeros.\r\n      for (i = 0; yc[i] == (xc[i] || 0); i++);\r\n\r\n      if (yc[i] > (xc[i] || 0)) e--;\r\n\r\n      if (s < 0) {\r\n        qc.push(1);\r\n        more = true;\r\n      } else {\r\n        xL = xc.length;\r\n        yL = yc.length;\r\n        i = 0;\r\n        s += 2;\r\n\r\n        // Normalise xc and yc so highest order digit of yc is >= base / 2.\r\n\r\n        n = mathfloor(base / (yc[0] + 1));\r\n\r\n        // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.\r\n        // if (n > 1 || n++ == 1 && yc[0] < base / 2) {\r\n        if (n > 1) {\r\n          yc = multiply(yc, n, base);\r\n          xc = multiply(xc, n, base);\r\n          yL = yc.length;\r\n          xL = xc.length;\r\n        }\r\n\r\n        xi = yL;\r\n        rem = xc.slice(0, yL);\r\n        remL = rem.length;\r\n\r\n        // Add zeros to make remainder as long as divisor.\r\n        for (; remL < yL; rem[remL++] = 0);\r\n        yz = yc.slice();\r\n        yz = [0].concat(yz);\r\n        yc0 = yc[0];\r\n        if (yc[1] >= base / 2) yc0++;\r\n        // Not necessary, but to prevent trial digit n > base, when using base 3.\r\n        // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;\r\n\r\n        do {\r\n          n = 0;\r\n\r\n          // Compare divisor and remainder.\r\n          cmp = compare(yc, rem, yL, remL);\r\n\r\n          // If divisor < remainder.\r\n          if (cmp < 0) {\r\n\r\n            // Calculate trial digit, n.\r\n\r\n            rem0 = rem[0];\r\n            if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);\r\n\r\n            // n is how many times the divisor goes into the current remainder.\r\n            n = mathfloor(rem0 / yc0);\r\n\r\n            //  Algorithm:\r\n            //  product = divisor multiplied by trial digit (n).\r\n            //  Compare product and remainder.\r\n            //  If product is greater than remainder:\r\n            //    Subtract divisor from product, decrement trial digit.\r\n            //  Subtract product from remainder.\r\n            //  If product was less than remainder at the last compare:\r\n            //    Compare new remainder and divisor.\r\n            //    If remainder is greater than divisor:\r\n            //      Subtract divisor from remainder, increment trial digit.\r\n\r\n            if (n > 1) {\r\n\r\n              // n may be > base only when base is 3.\r\n              if (n >= base) n = base - 1;\r\n\r\n              // product = divisor * trial digit.\r\n              prod = multiply(yc, n, base);\r\n              prodL = prod.length;\r\n              remL = rem.length;\r\n\r\n              // Compare product and remainder.\r\n              // If product > remainder then trial digit n too high.\r\n              // n is 1 too high about 5% of the time, and is not known to have\r\n              // ever been more than 1 too high.\r\n              while (compare(prod, rem, prodL, remL) == 1) {\r\n                n--;\r\n\r\n                // Subtract divisor from product.\r\n                subtract(prod, yL < prodL ? yz : yc, prodL, base);\r\n                prodL = prod.length;\r\n                cmp = 1;\r\n              }\r\n            } else {\r\n\r\n              // n is 0 or 1, cmp is -1.\r\n              // If n is 0, there is no need to compare yc and rem again below,\r\n              // so change cmp to 1 to avoid it.\r\n              // If n is 1, leave cmp as -1, so yc and rem are compared again.\r\n              if (n == 0) {\r\n\r\n                // divisor < remainder, so n must be at least 1.\r\n                cmp = n = 1;\r\n              }\r\n\r\n              // product = divisor\r\n              prod = yc.slice();\r\n              prodL = prod.length;\r\n            }\r\n\r\n            if (prodL < remL) prod = [0].concat(prod);\r\n\r\n            // Subtract product from remainder.\r\n            subtract(rem, prod, remL, base);\r\n            remL = rem.length;\r\n\r\n             // If product was < remainder.\r\n            if (cmp == -1) {\r\n\r\n              // Compare divisor and new remainder.\r\n              // If divisor < new remainder, subtract divisor from remainder.\r\n              // Trial digit n too low.\r\n              // n is 1 too low about 5% of the time, and very rarely 2 too low.\r\n              while (compare(yc, rem, yL, remL) < 1) {\r\n                n++;\r\n\r\n                // Subtract divisor from remainder.\r\n                subtract(rem, yL < remL ? yz : yc, remL, base);\r\n                remL = rem.length;\r\n              }\r\n            }\r\n          } else if (cmp === 0) {\r\n            n++;\r\n            rem = [0];\r\n          } // else cmp === 1 and n will be 0\r\n\r\n          // Add the next digit, n, to the result array.\r\n          qc[i++] = n;\r\n\r\n          // Update the remainder.\r\n          if (rem[0]) {\r\n            rem[remL++] = xc[xi] || 0;\r\n          } else {\r\n            rem = [xc[xi]];\r\n            remL = 1;\r\n          }\r\n        } while ((xi++ < xL || rem[0] != null) && s--);\r\n\r\n        more = rem[0] != null;\r\n\r\n        // Leading zero?\r\n        if (!qc[0]) qc.splice(0, 1);\r\n      }\r\n\r\n      if (base == BASE) {\r\n\r\n        // To calculate q.e, first get the number of digits of qc[0].\r\n        for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);\r\n\r\n        round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);\r\n\r\n      // Caller is convertBase.\r\n      } else {\r\n        q.e = e;\r\n        q.r = +more;\r\n      }\r\n\r\n      return q;\r\n    };\r\n  })();\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of BigNumber n in fixed-point or exponential\r\n   * notation rounded to the specified decimal places or significant digits.\r\n   *\r\n   * n: a BigNumber.\r\n   * i: the index of the last digit required (i.e. the digit that may be rounded up).\r\n   * rm: the rounding mode.\r\n   * id: 1 (toExponential) or 2 (toPrecision).\r\n   */\r\n  function format(n, i, rm, id) {\r\n    var c0, e, ne, len, str;\r\n\r\n    if (rm == null) rm = ROUNDING_MODE;\r\n    else intCheck(rm, 0, 8);\r\n\r\n    if (!n.c) return n.toString();\r\n\r\n    c0 = n.c[0];\r\n    ne = n.e;\r\n\r\n    if (i == null) {\r\n      str = coeffToString(n.c);\r\n      str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS)\r\n       ? toExponential(str, ne)\r\n       : toFixedPoint(str, ne, '0');\r\n    } else {\r\n      n = round(new BigNumber(n), i, rm);\r\n\r\n      // n.e may have changed if the value was rounded up.\r\n      e = n.e;\r\n\r\n      str = coeffToString(n.c);\r\n      len = str.length;\r\n\r\n      // toPrecision returns exponential notation if the number of significant digits\r\n      // specified is less than the number of digits necessary to represent the integer\r\n      // part of the value in fixed-point notation.\r\n\r\n      // Exponential notation.\r\n      if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {\r\n\r\n        // Append zeros?\r\n        for (; len < i; str += '0', len++);\r\n        str = toExponential(str, e);\r\n\r\n      // Fixed-point notation.\r\n      } else {\r\n        i -= ne;\r\n        str = toFixedPoint(str, e, '0');\r\n\r\n        // Append zeros?\r\n        if (e + 1 > len) {\r\n          if (--i > 0) for (str += '.'; i--; str += '0');\r\n        } else {\r\n          i += e - len;\r\n          if (i > 0) {\r\n            if (e + 1 == len) str += '.';\r\n            for (; i--; str += '0');\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    return n.s < 0 && c0 ? '-' + str : str;\r\n  }\r\n\r\n\r\n  // Handle BigNumber.max and BigNumber.min.\r\n  // If any number is NaN, return NaN.\r\n  function maxOrMin(args, n) {\r\n    var k, y,\r\n      i = 1,\r\n      x = new BigNumber(args[0]);\r\n\r\n    for (; i < args.length; i++) {\r\n      y = new BigNumber(args[i]);\r\n      if (!y.s || (k = compare(x, y)) === n || k === 0 && x.s === n) {\r\n        x = y;\r\n      }\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  /*\r\n   * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.\r\n   * Called by minus, plus and times.\r\n   */\r\n  function normalise(n, c, e) {\r\n    var i = 1,\r\n      j = c.length;\r\n\r\n     // Remove trailing zeros.\r\n    for (; !c[--j]; c.pop());\r\n\r\n    // Calculate the base 10 exponent. First get the number of digits of c[0].\r\n    for (j = c[0]; j >= 10; j /= 10, i++);\r\n\r\n    // Overflow?\r\n    if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {\r\n\r\n      // Infinity.\r\n      n.c = n.e = null;\r\n\r\n    // Underflow?\r\n    } else if (e < MIN_EXP) {\r\n\r\n      // Zero.\r\n      n.c = [n.e = 0];\r\n    } else {\r\n      n.e = e;\r\n      n.c = c;\r\n    }\r\n\r\n    return n;\r\n  }\r\n\r\n\r\n  // Handle values that fail the validity test in BigNumber.\r\n  parseNumeric = (function () {\r\n    var basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i,\r\n      dotAfter = /^([^.]+)\\.$/,\r\n      dotBefore = /^\\.([^.]+)$/,\r\n      isInfinityOrNaN = /^-?(Infinity|NaN)$/,\r\n      whitespaceOrPlus = /^\\s*\\+(?=[\\w.])|^\\s+|\\s+$/g;\r\n\r\n    return function (x, str, isNum, b) {\r\n      var base,\r\n        s = isNum ? str : str.replace(whitespaceOrPlus, '');\r\n\r\n      // No exception on ±Infinity or NaN.\r\n      if (isInfinityOrNaN.test(s)) {\r\n        x.s = isNaN(s) ? null : s < 0 ? -1 : 1;\r\n      } else {\r\n        if (!isNum) {\r\n\r\n          // basePrefix = /^(-?)0([xbo])(?=\\w[\\w.]*$)/i\r\n          s = s.replace(basePrefix, function (m, p1, p2) {\r\n            base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;\r\n            return !b || b == base ? p1 : m;\r\n          });\r\n\r\n          if (b) {\r\n            base = b;\r\n\r\n            // E.g. '1.' to '1', '.1' to '0.1'\r\n            s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');\r\n          }\r\n\r\n          if (str != s) return new BigNumber(s, base);\r\n        }\r\n\r\n        // '[BigNumber Error] Not a number: {n}'\r\n        // '[BigNumber Error] Not a base {b} number: {n}'\r\n        if (BigNumber.DEBUG) {\r\n          throw Error\r\n            (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);\r\n        }\r\n\r\n        // NaN\r\n        x.s = null;\r\n      }\r\n\r\n      x.c = x.e = null;\r\n    }\r\n  })();\r\n\r\n\r\n  /*\r\n   * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.\r\n   * If r is truthy, it is known that there are more digits after the rounding digit.\r\n   */\r\n  function round(x, sd, rm, r) {\r\n    var d, i, j, k, n, ni, rd,\r\n      xc = x.c,\r\n      pows10 = POWS_TEN;\r\n\r\n    // if x is not Infinity or NaN...\r\n    if (xc) {\r\n\r\n      // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.\r\n      // n is a base 1e14 number, the value of the element of array x.c containing rd.\r\n      // ni is the index of n within x.c.\r\n      // d is the number of digits of n.\r\n      // i is the index of rd within n including leading zeros.\r\n      // j is the actual index of rd within n (if < 0, rd is a leading zero).\r\n      out: {\r\n\r\n        // Get the number of digits of the first element of xc.\r\n        for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);\r\n        i = sd - d;\r\n\r\n        // If the rounding digit is in the first element of xc...\r\n        if (i < 0) {\r\n          i += LOG_BASE;\r\n          j = sd;\r\n          n = xc[ni = 0];\r\n\r\n          // Get the rounding digit at index j of n.\r\n          rd = mathfloor(n / pows10[d - j - 1] % 10);\r\n        } else {\r\n          ni = mathceil((i + 1) / LOG_BASE);\r\n\r\n          if (ni >= xc.length) {\r\n\r\n            if (r) {\r\n\r\n              // Needed by sqrt.\r\n              for (; xc.length <= ni; xc.push(0));\r\n              n = rd = 0;\r\n              d = 1;\r\n              i %= LOG_BASE;\r\n              j = i - LOG_BASE + 1;\r\n            } else {\r\n              break out;\r\n            }\r\n          } else {\r\n            n = k = xc[ni];\r\n\r\n            // Get the number of digits of n.\r\n            for (d = 1; k >= 10; k /= 10, d++);\r\n\r\n            // Get the index of rd within n.\r\n            i %= LOG_BASE;\r\n\r\n            // Get the index of rd within n, adjusted for leading zeros.\r\n            // The number of leading zeros of n is given by LOG_BASE - d.\r\n            j = i - LOG_BASE + d;\r\n\r\n            // Get the rounding digit at index j of n.\r\n            rd = j < 0 ? 0 : mathfloor(n / pows10[d - j - 1] % 10);\r\n          }\r\n        }\r\n\r\n        r = r || sd < 0 ||\r\n\r\n        // Are there any non-zero digits after the rounding digit?\r\n        // The expression  n % pows10[d - j - 1]  returns all digits of n to the right\r\n        // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.\r\n         xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);\r\n\r\n        r = rm < 4\r\n         ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))\r\n         : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&\r\n\r\n          // Check whether the digit to the left of the rounding digit is odd.\r\n          ((i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||\r\n           rm == (x.s < 0 ? 8 : 7));\r\n\r\n        if (sd < 1 || !xc[0]) {\r\n          xc.length = 0;\r\n\r\n          if (r) {\r\n\r\n            // Convert sd to decimal places.\r\n            sd -= x.e + 1;\r\n\r\n            // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n            xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];\r\n            x.e = -sd || 0;\r\n          } else {\r\n\r\n            // Zero.\r\n            xc[0] = x.e = 0;\r\n          }\r\n\r\n          return x;\r\n        }\r\n\r\n        // Remove excess digits.\r\n        if (i == 0) {\r\n          xc.length = ni;\r\n          k = 1;\r\n          ni--;\r\n        } else {\r\n          xc.length = ni + 1;\r\n          k = pows10[LOG_BASE - i];\r\n\r\n          // E.g. 56700 becomes 56000 if 7 is the rounding digit.\r\n          // j > 0 means i > number of leading zeros of n.\r\n          xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;\r\n        }\r\n\r\n        // Round up?\r\n        if (r) {\r\n\r\n          for (; ;) {\r\n\r\n            // If the digit to be rounded up is in the first element of xc...\r\n            if (ni == 0) {\r\n\r\n              // i will be the length of xc[0] before k is added.\r\n              for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);\r\n              j = xc[0] += k;\r\n              for (k = 1; j >= 10; j /= 10, k++);\r\n\r\n              // if i != k the length has increased.\r\n              if (i != k) {\r\n                x.e++;\r\n                if (xc[0] == BASE) xc[0] = 1;\r\n              }\r\n\r\n              break;\r\n            } else {\r\n              xc[ni] += k;\r\n              if (xc[ni] != BASE) break;\r\n              xc[ni--] = 0;\r\n              k = 1;\r\n            }\r\n          }\r\n        }\r\n\r\n        // Remove trailing zeros.\r\n        for (i = xc.length; xc[--i] === 0; xc.pop());\r\n      }\r\n\r\n      // Overflow? Infinity.\r\n      if (x.e > MAX_EXP) {\r\n        x.c = x.e = null;\r\n\r\n      // Underflow? Zero.\r\n      } else if (x.e < MIN_EXP) {\r\n        x.c = [x.e = 0];\r\n      }\r\n    }\r\n\r\n    return x;\r\n  }\r\n\r\n\r\n  function valueOf(n) {\r\n    var str,\r\n      e = n.e;\r\n\r\n    if (e === null) return n.toString();\r\n\r\n    str = coeffToString(n.c);\r\n\r\n    str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n      ? toExponential(str, e)\r\n      : toFixedPoint(str, e, '0');\r\n\r\n    return n.s < 0 ? '-' + str : str;\r\n  }\r\n\r\n\r\n  // PROTOTYPE/INSTANCE METHODS\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the absolute value of this BigNumber.\r\n   */\r\n  P.absoluteValue = P.abs = function () {\r\n    var x = new BigNumber(this);\r\n    if (x.s < 0) x.s = 1;\r\n    return x;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return\r\n   *   1 if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n   *   -1 if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n   *   0 if they have the same value,\r\n   *   or null if the value of either is NaN.\r\n   */\r\n  P.comparedTo = function (y, b) {\r\n    return compare(this, new BigNumber(y, b));\r\n  };\r\n\r\n\r\n  /*\r\n   * If dp is undefined or null or true or false, return the number of decimal places of the\r\n   * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n   *\r\n   * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this\r\n   * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or\r\n   * ROUNDING_MODE if rm is omitted.\r\n   *\r\n   * [dp] {number} Decimal places: integer, 0 to MAX inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n   */\r\n  P.decimalPlaces = P.dp = function (dp, rm) {\r\n    var c, n, v,\r\n      x = this;\r\n\r\n    if (dp != null) {\r\n      intCheck(dp, 0, MAX);\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n\r\n      return round(new BigNumber(x), dp + x.e + 1, rm);\r\n    }\r\n\r\n    if (!(c = x.c)) return null;\r\n    n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;\r\n\r\n    // Subtract the number of trailing zeros of the last number.\r\n    if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);\r\n    if (n < 0) n = 0;\r\n\r\n    return n;\r\n  };\r\n\r\n\r\n  /*\r\n   *  n / 0 = I\r\n   *  n / N = N\r\n   *  n / I = 0\r\n   *  0 / n = 0\r\n   *  0 / 0 = N\r\n   *  0 / N = N\r\n   *  0 / I = 0\r\n   *  N / n = N\r\n   *  N / 0 = N\r\n   *  N / N = N\r\n   *  N / I = N\r\n   *  I / n = I\r\n   *  I / 0 = I\r\n   *  I / N = N\r\n   *  I / I = N\r\n   *\r\n   * Return a new BigNumber whose value is the value of this BigNumber divided by the value of\r\n   * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n   */\r\n  P.dividedBy = P.div = function (y, b) {\r\n    return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the integer part of dividing the value of this\r\n   * BigNumber by the value of BigNumber(y, b).\r\n   */\r\n  P.dividedToIntegerBy = P.idiv = function (y, b) {\r\n    return div(this, new BigNumber(y, b), 0, 1);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.\r\n   *\r\n   * If m is present, return the result modulo m.\r\n   * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.\r\n   * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.\r\n   *\r\n   * The modular power operation works efficiently when x, n, and m are integers, otherwise it\r\n   * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.\r\n   *\r\n   * n {number|string|BigNumber} The exponent. An integer.\r\n   * [m] {number|string|BigNumber} The modulus.\r\n   *\r\n   * '[BigNumber Error] Exponent not an integer: {n}'\r\n   */\r\n  P.exponentiatedBy = P.pow = function (n, m) {\r\n    var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y,\r\n      x = this;\r\n\r\n    n = new BigNumber(n);\r\n\r\n    // Allow NaN and ±Infinity, but not other non-integers.\r\n    if (n.c && !n.isInteger()) {\r\n      throw Error\r\n        (bignumberError + 'Exponent not an integer: ' + valueOf(n));\r\n    }\r\n\r\n    if (m != null) m = new BigNumber(m);\r\n\r\n    // Exponent of MAX_SAFE_INTEGER is 15.\r\n    nIsBig = n.e > 14;\r\n\r\n    // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.\r\n    if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {\r\n\r\n      // The sign of the result of pow when x is negative depends on the evenness of n.\r\n      // If +n overflows to ±Infinity, the evenness of n would be not be known.\r\n      y = new BigNumber(Math.pow(+valueOf(x), nIsBig ? n.s * (2 - isOdd(n)) : +valueOf(n)));\r\n      return m ? y.mod(m) : y;\r\n    }\r\n\r\n    nIsNeg = n.s < 0;\r\n\r\n    if (m) {\r\n\r\n      // x % m returns NaN if abs(m) is zero, or m is NaN.\r\n      if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);\r\n\r\n      isModExp = !nIsNeg && x.isInteger() && m.isInteger();\r\n\r\n      if (isModExp) x = x.mod(m);\r\n\r\n    // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.\r\n    // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.\r\n    } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0\r\n      // [1, 240000000]\r\n      ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7\r\n      // [80000000000000]  [99999750000000]\r\n      : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {\r\n\r\n      // If x is negative and n is odd, k = -0, else k = 0.\r\n      k = x.s < 0 && isOdd(n) ? -0 : 0;\r\n\r\n      // If x >= 1, k = ±Infinity.\r\n      if (x.e > -1) k = 1 / k;\r\n\r\n      // If n is negative return ±0, else return ±Infinity.\r\n      return new BigNumber(nIsNeg ? 1 / k : k);\r\n\r\n    } else if (POW_PRECISION) {\r\n\r\n      // Truncating each coefficient array to a length of k after each multiplication\r\n      // equates to truncating significant digits to POW_PRECISION + [28, 41],\r\n      // i.e. there will be a minimum of 28 guard digits retained.\r\n      k = mathceil(POW_PRECISION / LOG_BASE + 2);\r\n    }\r\n\r\n    if (nIsBig) {\r\n      half = new BigNumber(0.5);\r\n      if (nIsNeg) n.s = 1;\r\n      nIsOdd = isOdd(n);\r\n    } else {\r\n      i = Math.abs(+valueOf(n));\r\n      nIsOdd = i % 2;\r\n    }\r\n\r\n    y = new BigNumber(ONE);\r\n\r\n    // Performs 54 loop iterations for n of 9007199254740991.\r\n    for (; ;) {\r\n\r\n      if (nIsOdd) {\r\n        y = y.times(x);\r\n        if (!y.c) break;\r\n\r\n        if (k) {\r\n          if (y.c.length > k) y.c.length = k;\r\n        } else if (isModExp) {\r\n          y = y.mod(m);    //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));\r\n        }\r\n      }\r\n\r\n      if (i) {\r\n        i = mathfloor(i / 2);\r\n        if (i === 0) break;\r\n        nIsOdd = i % 2;\r\n      } else {\r\n        n = n.times(half);\r\n        round(n, n.e + 1, 1);\r\n\r\n        if (n.e > 14) {\r\n          nIsOdd = isOdd(n);\r\n        } else {\r\n          i = +valueOf(n);\r\n          if (i === 0) break;\r\n          nIsOdd = i % 2;\r\n        }\r\n      }\r\n\r\n      x = x.times(x);\r\n\r\n      if (k) {\r\n        if (x.c && x.c.length > k) x.c.length = k;\r\n      } else if (isModExp) {\r\n        x = x.mod(m);    //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));\r\n      }\r\n    }\r\n\r\n    if (isModExp) return y;\r\n    if (nIsNeg) y = ONE.div(y);\r\n\r\n    return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer\r\n   * using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n   *\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'\r\n   */\r\n  P.integerValue = function (rm) {\r\n    var n = new BigNumber(this);\r\n    if (rm == null) rm = ROUNDING_MODE;\r\n    else intCheck(rm, 0, 8);\r\n    return round(n, n.e + 1, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),\r\n   * otherwise return false.\r\n   */\r\n  P.isEqualTo = P.eq = function (y, b) {\r\n    return compare(this, new BigNumber(y, b)) === 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is a finite number, otherwise return false.\r\n   */\r\n  P.isFinite = function () {\r\n    return !!this.c;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),\r\n   * otherwise return false.\r\n   */\r\n  P.isGreaterThan = P.gt = function (y, b) {\r\n    return compare(this, new BigNumber(y, b)) > 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is greater than or equal to the value of\r\n   * BigNumber(y, b), otherwise return false.\r\n   */\r\n  P.isGreaterThanOrEqualTo = P.gte = function (y, b) {\r\n    return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;\r\n\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is an integer, otherwise return false.\r\n   */\r\n  P.isInteger = function () {\r\n    return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),\r\n   * otherwise return false.\r\n   */\r\n  P.isLessThan = P.lt = function (y, b) {\r\n    return compare(this, new BigNumber(y, b)) < 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is less than or equal to the value of\r\n   * BigNumber(y, b), otherwise return false.\r\n   */\r\n  P.isLessThanOrEqualTo = P.lte = function (y, b) {\r\n    return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is NaN, otherwise return false.\r\n   */\r\n  P.isNaN = function () {\r\n    return !this.s;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is negative, otherwise return false.\r\n   */\r\n  P.isNegative = function () {\r\n    return this.s < 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is positive, otherwise return false.\r\n   */\r\n  P.isPositive = function () {\r\n    return this.s > 0;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return true if the value of this BigNumber is 0 or -0, otherwise return false.\r\n   */\r\n  P.isZero = function () {\r\n    return !!this.c && this.c[0] == 0;\r\n  };\r\n\r\n\r\n  /*\r\n   *  n - 0 = n\r\n   *  n - N = N\r\n   *  n - I = -I\r\n   *  0 - n = -n\r\n   *  0 - 0 = 0\r\n   *  0 - N = N\r\n   *  0 - I = -I\r\n   *  N - n = N\r\n   *  N - 0 = N\r\n   *  N - N = N\r\n   *  N - I = N\r\n   *  I - n = I\r\n   *  I - 0 = I\r\n   *  I - N = N\r\n   *  I - I = N\r\n   *\r\n   * Return a new BigNumber whose value is the value of this BigNumber minus the value of\r\n   * BigNumber(y, b).\r\n   */\r\n  P.minus = function (y, b) {\r\n    var i, j, t, xLTy,\r\n      x = this,\r\n      a = x.s;\r\n\r\n    y = new BigNumber(y, b);\r\n    b = y.s;\r\n\r\n    // Either NaN?\r\n    if (!a || !b) return new BigNumber(NaN);\r\n\r\n    // Signs differ?\r\n    if (a != b) {\r\n      y.s = -b;\r\n      return x.plus(y);\r\n    }\r\n\r\n    var xe = x.e / LOG_BASE,\r\n      ye = y.e / LOG_BASE,\r\n      xc = x.c,\r\n      yc = y.c;\r\n\r\n    if (!xe || !ye) {\r\n\r\n      // Either Infinity?\r\n      if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);\r\n\r\n      // Either zero?\r\n      if (!xc[0] || !yc[0]) {\r\n\r\n        // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n        return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :\r\n\r\n         // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity\r\n         ROUNDING_MODE == 3 ? -0 : 0);\r\n      }\r\n    }\r\n\r\n    xe = bitFloor(xe);\r\n    ye = bitFloor(ye);\r\n    xc = xc.slice();\r\n\r\n    // Determine which is the bigger number.\r\n    if (a = xe - ye) {\r\n\r\n      if (xLTy = a < 0) {\r\n        a = -a;\r\n        t = xc;\r\n      } else {\r\n        ye = xe;\r\n        t = yc;\r\n      }\r\n\r\n      t.reverse();\r\n\r\n      // Prepend zeros to equalise exponents.\r\n      for (b = a; b--; t.push(0));\r\n      t.reverse();\r\n    } else {\r\n\r\n      // Exponents equal. Check digit by digit.\r\n      j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;\r\n\r\n      for (a = b = 0; b < j; b++) {\r\n\r\n        if (xc[b] != yc[b]) {\r\n          xLTy = xc[b] < yc[b];\r\n          break;\r\n        }\r\n      }\r\n    }\r\n\r\n    // x < y? Point xc to the array of the bigger number.\r\n    if (xLTy) {\r\n      t = xc;\r\n      xc = yc;\r\n      yc = t;\r\n      y.s = -y.s;\r\n    }\r\n\r\n    b = (j = yc.length) - (i = xc.length);\r\n\r\n    // Append zeros to xc if shorter.\r\n    // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.\r\n    if (b > 0) for (; b--; xc[i++] = 0);\r\n    b = BASE - 1;\r\n\r\n    // Subtract yc from xc.\r\n    for (; j > a;) {\r\n\r\n      if (xc[--j] < yc[j]) {\r\n        for (i = j; i && !xc[--i]; xc[i] = b);\r\n        --xc[i];\r\n        xc[j] += BASE;\r\n      }\r\n\r\n      xc[j] -= yc[j];\r\n    }\r\n\r\n    // Remove leading zeros and adjust exponent accordingly.\r\n    for (; xc[0] == 0; xc.splice(0, 1), --ye);\r\n\r\n    // Zero?\r\n    if (!xc[0]) {\r\n\r\n      // Following IEEE 754 (2008) 6.3,\r\n      // n - n = +0  but  n - n = -0  when rounding towards -Infinity.\r\n      y.s = ROUNDING_MODE == 3 ? -1 : 1;\r\n      y.c = [y.e = 0];\r\n      return y;\r\n    }\r\n\r\n    // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity\r\n    // for finite x and y.\r\n    return normalise(y, xc, ye);\r\n  };\r\n\r\n\r\n  /*\r\n   *   n % 0 =  N\r\n   *   n % N =  N\r\n   *   n % I =  n\r\n   *   0 % n =  0\r\n   *  -0 % n = -0\r\n   *   0 % 0 =  N\r\n   *   0 % N =  N\r\n   *   0 % I =  0\r\n   *   N % n =  N\r\n   *   N % 0 =  N\r\n   *   N % N =  N\r\n   *   N % I =  N\r\n   *   I % n =  N\r\n   *   I % 0 =  N\r\n   *   I % N =  N\r\n   *   I % I =  N\r\n   *\r\n   * Return a new BigNumber whose value is the value of this BigNumber modulo the value of\r\n   * BigNumber(y, b). The result depends on the value of MODULO_MODE.\r\n   */\r\n  P.modulo = P.mod = function (y, b) {\r\n    var q, s,\r\n      x = this;\r\n\r\n    y = new BigNumber(y, b);\r\n\r\n    // Return NaN if x is Infinity or NaN, or y is NaN or zero.\r\n    if (!x.c || !y.s || y.c && !y.c[0]) {\r\n      return new BigNumber(NaN);\r\n\r\n    // Return x if y is Infinity or x is zero.\r\n    } else if (!y.c || x.c && !x.c[0]) {\r\n      return new BigNumber(x);\r\n    }\r\n\r\n    if (MODULO_MODE == 9) {\r\n\r\n      // Euclidian division: q = sign(y) * floor(x / abs(y))\r\n      // r = x - qy    where  0 <= r < abs(y)\r\n      s = y.s;\r\n      y.s = 1;\r\n      q = div(x, y, 0, 3);\r\n      y.s = s;\r\n      q.s *= s;\r\n    } else {\r\n      q = div(x, y, 0, MODULO_MODE);\r\n    }\r\n\r\n    y = x.minus(q.times(y));\r\n\r\n    // To match JavaScript %, ensure sign of zero is sign of dividend.\r\n    if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;\r\n\r\n    return y;\r\n  };\r\n\r\n\r\n  /*\r\n   *  n * 0 = 0\r\n   *  n * N = N\r\n   *  n * I = I\r\n   *  0 * n = 0\r\n   *  0 * 0 = 0\r\n   *  0 * N = N\r\n   *  0 * I = N\r\n   *  N * n = N\r\n   *  N * 0 = N\r\n   *  N * N = N\r\n   *  N * I = N\r\n   *  I * n = I\r\n   *  I * 0 = N\r\n   *  I * N = N\r\n   *  I * I = I\r\n   *\r\n   * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value\r\n   * of BigNumber(y, b).\r\n   */\r\n  P.multipliedBy = P.times = function (y, b) {\r\n    var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,\r\n      base, sqrtBase,\r\n      x = this,\r\n      xc = x.c,\r\n      yc = (y = new BigNumber(y, b)).c;\r\n\r\n    // Either NaN, ±Infinity or ±0?\r\n    if (!xc || !yc || !xc[0] || !yc[0]) {\r\n\r\n      // Return NaN if either is NaN, or one is 0 and the other is Infinity.\r\n      if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {\r\n        y.c = y.e = y.s = null;\r\n      } else {\r\n        y.s *= x.s;\r\n\r\n        // Return ±Infinity if either is ±Infinity.\r\n        if (!xc || !yc) {\r\n          y.c = y.e = null;\r\n\r\n        // Return ±0 if either is ±0.\r\n        } else {\r\n          y.c = [0];\r\n          y.e = 0;\r\n        }\r\n      }\r\n\r\n      return y;\r\n    }\r\n\r\n    e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);\r\n    y.s *= x.s;\r\n    xcL = xc.length;\r\n    ycL = yc.length;\r\n\r\n    // Ensure xc points to longer array and xcL to its length.\r\n    if (xcL < ycL) {\r\n      zc = xc;\r\n      xc = yc;\r\n      yc = zc;\r\n      i = xcL;\r\n      xcL = ycL;\r\n      ycL = i;\r\n    }\r\n\r\n    // Initialise the result array with zeros.\r\n    for (i = xcL + ycL, zc = []; i--; zc.push(0));\r\n\r\n    base = BASE;\r\n    sqrtBase = SQRT_BASE;\r\n\r\n    for (i = ycL; --i >= 0;) {\r\n      c = 0;\r\n      ylo = yc[i] % sqrtBase;\r\n      yhi = yc[i] / sqrtBase | 0;\r\n\r\n      for (k = xcL, j = i + k; j > i;) {\r\n        xlo = xc[--k] % sqrtBase;\r\n        xhi = xc[k] / sqrtBase | 0;\r\n        m = yhi * xlo + xhi * ylo;\r\n        xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;\r\n        c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;\r\n        zc[j--] = xlo % base;\r\n      }\r\n\r\n      zc[j] = c;\r\n    }\r\n\r\n    if (c) {\r\n      ++e;\r\n    } else {\r\n      zc.splice(0, 1);\r\n    }\r\n\r\n    return normalise(y, zc, e);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the value of this BigNumber negated,\r\n   * i.e. multiplied by -1.\r\n   */\r\n  P.negated = function () {\r\n    var x = new BigNumber(this);\r\n    x.s = -x.s || null;\r\n    return x;\r\n  };\r\n\r\n\r\n  /*\r\n   *  n + 0 = n\r\n   *  n + N = N\r\n   *  n + I = I\r\n   *  0 + n = n\r\n   *  0 + 0 = 0\r\n   *  0 + N = N\r\n   *  0 + I = I\r\n   *  N + n = N\r\n   *  N + 0 = N\r\n   *  N + N = N\r\n   *  N + I = N\r\n   *  I + n = I\r\n   *  I + 0 = I\r\n   *  I + N = N\r\n   *  I + I = I\r\n   *\r\n   * Return a new BigNumber whose value is the value of this BigNumber plus the value of\r\n   * BigNumber(y, b).\r\n   */\r\n  P.plus = function (y, b) {\r\n    var t,\r\n      x = this,\r\n      a = x.s;\r\n\r\n    y = new BigNumber(y, b);\r\n    b = y.s;\r\n\r\n    // Either NaN?\r\n    if (!a || !b) return new BigNumber(NaN);\r\n\r\n    // Signs differ?\r\n     if (a != b) {\r\n      y.s = -b;\r\n      return x.minus(y);\r\n    }\r\n\r\n    var xe = x.e / LOG_BASE,\r\n      ye = y.e / LOG_BASE,\r\n      xc = x.c,\r\n      yc = y.c;\r\n\r\n    if (!xe || !ye) {\r\n\r\n      // Return ±Infinity if either ±Infinity.\r\n      if (!xc || !yc) return new BigNumber(a / 0);\r\n\r\n      // Either zero?\r\n      // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.\r\n      if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);\r\n    }\r\n\r\n    xe = bitFloor(xe);\r\n    ye = bitFloor(ye);\r\n    xc = xc.slice();\r\n\r\n    // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.\r\n    if (a = xe - ye) {\r\n      if (a > 0) {\r\n        ye = xe;\r\n        t = yc;\r\n      } else {\r\n        a = -a;\r\n        t = xc;\r\n      }\r\n\r\n      t.reverse();\r\n      for (; a--; t.push(0));\r\n      t.reverse();\r\n    }\r\n\r\n    a = xc.length;\r\n    b = yc.length;\r\n\r\n    // Point xc to the longer array, and b to the shorter length.\r\n    if (a - b < 0) {\r\n      t = yc;\r\n      yc = xc;\r\n      xc = t;\r\n      b = a;\r\n    }\r\n\r\n    // Only start adding at yc.length - 1 as the further digits of xc can be ignored.\r\n    for (a = 0; b;) {\r\n      a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;\r\n      xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;\r\n    }\r\n\r\n    if (a) {\r\n      xc = [a].concat(xc);\r\n      ++ye;\r\n    }\r\n\r\n    // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n    // ye = MAX_EXP + 1 possible\r\n    return normalise(y, xc, ye);\r\n  };\r\n\r\n\r\n  /*\r\n   * If sd is undefined or null or true or false, return the number of significant digits of\r\n   * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.\r\n   * If sd is true include integer-part trailing zeros in the count.\r\n   *\r\n   * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this\r\n   * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or\r\n   * ROUNDING_MODE if rm is omitted.\r\n   *\r\n   * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.\r\n   *                     boolean: whether to count integer-part trailing zeros: true or false.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n   */\r\n  P.precision = P.sd = function (sd, rm) {\r\n    var c, n, v,\r\n      x = this;\r\n\r\n    if (sd != null && sd !== !!sd) {\r\n      intCheck(sd, 1, MAX);\r\n      if (rm == null) rm = ROUNDING_MODE;\r\n      else intCheck(rm, 0, 8);\r\n\r\n      return round(new BigNumber(x), sd, rm);\r\n    }\r\n\r\n    if (!(c = x.c)) return null;\r\n    v = c.length - 1;\r\n    n = v * LOG_BASE + 1;\r\n\r\n    if (v = c[v]) {\r\n\r\n      // Subtract the number of trailing zeros of the last element.\r\n      for (; v % 10 == 0; v /= 10, n--);\r\n\r\n      // Add the number of digits of the first element.\r\n      for (v = c[0]; v >= 10; v /= 10, n++);\r\n    }\r\n\r\n    if (sd && x.e + 1 > n) n = x.e + 1;\r\n\r\n    return n;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a new BigNumber whose value is the value of this BigNumber shifted by k places\r\n   * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.\r\n   *\r\n   * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'\r\n   */\r\n  P.shiftedBy = function (k) {\r\n    intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);\r\n    return this.times('1e' + k);\r\n  };\r\n\r\n\r\n  /*\r\n   *  sqrt(-n) =  N\r\n   *  sqrt(N) =  N\r\n   *  sqrt(-I) =  N\r\n   *  sqrt(I) =  I\r\n   *  sqrt(0) =  0\r\n   *  sqrt(-0) = -0\r\n   *\r\n   * Return a new BigNumber whose value is the square root of the value of this BigNumber,\r\n   * rounded according to DECIMAL_PLACES and ROUNDING_MODE.\r\n   */\r\n  P.squareRoot = P.sqrt = function () {\r\n    var m, n, r, rep, t,\r\n      x = this,\r\n      c = x.c,\r\n      s = x.s,\r\n      e = x.e,\r\n      dp = DECIMAL_PLACES + 4,\r\n      half = new BigNumber('0.5');\r\n\r\n    // Negative/NaN/Infinity/zero?\r\n    if (s !== 1 || !c || !c[0]) {\r\n      return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);\r\n    }\r\n\r\n    // Initial estimate.\r\n    s = Math.sqrt(+valueOf(x));\r\n\r\n    // Math.sqrt underflow/overflow?\r\n    // Pass x to Math.sqrt as integer, then adjust the exponent of the result.\r\n    if (s == 0 || s == 1 / 0) {\r\n      n = coeffToString(c);\r\n      if ((n.length + e) % 2 == 0) n += '0';\r\n      s = Math.sqrt(+n);\r\n      e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);\r\n\r\n      if (s == 1 / 0) {\r\n        n = '5e' + e;\r\n      } else {\r\n        n = s.toExponential();\r\n        n = n.slice(0, n.indexOf('e') + 1) + e;\r\n      }\r\n\r\n      r = new BigNumber(n);\r\n    } else {\r\n      r = new BigNumber(s + '');\r\n    }\r\n\r\n    // Check for zero.\r\n    // r could be zero if MIN_EXP is changed after the this value was created.\r\n    // This would cause a division by zero (x/t) and hence Infinity below, which would cause\r\n    // coeffToString to throw.\r\n    if (r.c[0]) {\r\n      e = r.e;\r\n      s = e + dp;\r\n      if (s < 3) s = 0;\r\n\r\n      // Newton-Raphson iteration.\r\n      for (; ;) {\r\n        t = r;\r\n        r = half.times(t.plus(div(x, t, dp, 1)));\r\n\r\n        if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {\r\n\r\n          // The exponent of r may here be one less than the final result exponent,\r\n          // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits\r\n          // are indexed correctly.\r\n          if (r.e < e) --s;\r\n          n = n.slice(s - 3, s + 1);\r\n\r\n          // The 4th rounding digit may be in error by -1 so if the 4 rounding digits\r\n          // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the\r\n          // iteration.\r\n          if (n == '9999' || !rep && n == '4999') {\r\n\r\n            // On the first iteration only, check to see if rounding up gives the\r\n            // exact result as the nines may infinitely repeat.\r\n            if (!rep) {\r\n              round(t, t.e + DECIMAL_PLACES + 2, 0);\r\n\r\n              if (t.times(t).eq(x)) {\r\n                r = t;\r\n                break;\r\n              }\r\n            }\r\n\r\n            dp += 4;\r\n            s += 4;\r\n            rep = 1;\r\n          } else {\r\n\r\n            // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact\r\n            // result. If not, then there are further digits and m will be truthy.\r\n            if (!+n || !+n.slice(1) && n.charAt(0) == '5') {\r\n\r\n              // Truncate to the first rounding digit.\r\n              round(r, r.e + DECIMAL_PLACES + 2, 1);\r\n              m = !r.times(r).eq(x);\r\n            }\r\n\r\n            break;\r\n          }\r\n        }\r\n      }\r\n    }\r\n\r\n    return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this BigNumber in exponential notation and\r\n   * rounded using ROUNDING_MODE to dp fixed decimal places.\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n   */\r\n  P.toExponential = function (dp, rm) {\r\n    if (dp != null) {\r\n      intCheck(dp, 0, MAX);\r\n      dp++;\r\n    }\r\n    return format(this, dp, rm, 1);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this BigNumber in fixed-point notation rounding\r\n   * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.\r\n   *\r\n   * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',\r\n   * but e.g. (-0.00001).toFixed(0) is '-0'.\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n   */\r\n  P.toFixed = function (dp, rm) {\r\n    if (dp != null) {\r\n      intCheck(dp, 0, MAX);\r\n      dp = dp + this.e + 1;\r\n    }\r\n    return format(this, dp, rm);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this BigNumber in fixed-point notation rounded\r\n   * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties\r\n   * of the format or FORMAT object (see BigNumber.set).\r\n   *\r\n   * The formatting object may contain some or all of the properties shown below.\r\n   *\r\n   * FORMAT = {\r\n   *   prefix: '',\r\n   *   groupSize: 3,\r\n   *   secondaryGroupSize: 0,\r\n   *   groupSeparator: ',',\r\n   *   decimalSeparator: '.',\r\n   *   fractionGroupSize: 0,\r\n   *   fractionGroupSeparator: '\\xA0',      // non-breaking space\r\n   *   suffix: ''\r\n   * };\r\n   *\r\n   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   * [format] {object} Formatting options. See FORMAT pbject above.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'\r\n   * '[BigNumber Error] Argument not an object: {format}'\r\n   */\r\n  P.toFormat = function (dp, rm, format) {\r\n    var str,\r\n      x = this;\r\n\r\n    if (format == null) {\r\n      if (dp != null && rm && typeof rm == 'object') {\r\n        format = rm;\r\n        rm = null;\r\n      } else if (dp && typeof dp == 'object') {\r\n        format = dp;\r\n        dp = rm = null;\r\n      } else {\r\n        format = FORMAT;\r\n      }\r\n    } else if (typeof format != 'object') {\r\n      throw Error\r\n        (bignumberError + 'Argument not an object: ' + format);\r\n    }\r\n\r\n    str = x.toFixed(dp, rm);\r\n\r\n    if (x.c) {\r\n      var i,\r\n        arr = str.split('.'),\r\n        g1 = +format.groupSize,\r\n        g2 = +format.secondaryGroupSize,\r\n        groupSeparator = format.groupSeparator || '',\r\n        intPart = arr[0],\r\n        fractionPart = arr[1],\r\n        isNeg = x.s < 0,\r\n        intDigits = isNeg ? intPart.slice(1) : intPart,\r\n        len = intDigits.length;\r\n\r\n      if (g2) {\r\n        i = g1;\r\n        g1 = g2;\r\n        g2 = i;\r\n        len -= i;\r\n      }\r\n\r\n      if (g1 > 0 && len > 0) {\r\n        i = len % g1 || g1;\r\n        intPart = intDigits.substr(0, i);\r\n        for (; i < len; i += g1) intPart += groupSeparator + intDigits.substr(i, g1);\r\n        if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);\r\n        if (isNeg) intPart = '-' + intPart;\r\n      }\r\n\r\n      str = fractionPart\r\n       ? intPart + (format.decimalSeparator || '') + ((g2 = +format.fractionGroupSize)\r\n        ? fractionPart.replace(new RegExp('\\\\d{' + g2 + '}\\\\B', 'g'),\r\n         '$&' + (format.fractionGroupSeparator || ''))\r\n        : fractionPart)\r\n       : intPart;\r\n    }\r\n\r\n    return (format.prefix || '') + str + (format.suffix || '');\r\n  };\r\n\r\n\r\n  /*\r\n   * Return an array of two BigNumbers representing the value of this BigNumber as a simple\r\n   * fraction with an integer numerator and an integer denominator.\r\n   * The denominator will be a positive non-zero value less than or equal to the specified\r\n   * maximum denominator. If a maximum denominator is not specified, the denominator will be\r\n   * the lowest value necessary to represent the number exactly.\r\n   *\r\n   * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.\r\n   *\r\n   * '[BigNumber Error] Argument {not an integer|out of range} : {md}'\r\n   */\r\n  P.toFraction = function (md) {\r\n    var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s,\r\n      x = this,\r\n      xc = x.c;\r\n\r\n    if (md != null) {\r\n      n = new BigNumber(md);\r\n\r\n      // Throw if md is less than one or is not an integer, unless it is Infinity.\r\n      if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {\r\n        throw Error\r\n          (bignumberError + 'Argument ' +\r\n            (n.isInteger() ? 'out of range: ' : 'not an integer: ') + valueOf(n));\r\n      }\r\n    }\r\n\r\n    if (!xc) return new BigNumber(x);\r\n\r\n    d = new BigNumber(ONE);\r\n    n1 = d0 = new BigNumber(ONE);\r\n    d1 = n0 = new BigNumber(ONE);\r\n    s = coeffToString(xc);\r\n\r\n    // Determine initial denominator.\r\n    // d is a power of 10 and the minimum max denominator that specifies the value exactly.\r\n    e = d.e = s.length - x.e - 1;\r\n    d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];\r\n    md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;\r\n\r\n    exp = MAX_EXP;\r\n    MAX_EXP = 1 / 0;\r\n    n = new BigNumber(s);\r\n\r\n    // n0 = d1 = 0\r\n    n0.c[0] = 0;\r\n\r\n    for (; ;)  {\r\n      q = div(n, d, 0, 1);\r\n      d2 = d0.plus(q.times(d1));\r\n      if (d2.comparedTo(md) == 1) break;\r\n      d0 = d1;\r\n      d1 = d2;\r\n      n1 = n0.plus(q.times(d2 = n1));\r\n      n0 = d2;\r\n      d = n.minus(q.times(d2 = d));\r\n      n = d2;\r\n    }\r\n\r\n    d2 = div(md.minus(d0), d1, 0, 1);\r\n    n0 = n0.plus(d2.times(n1));\r\n    d0 = d0.plus(d2.times(d1));\r\n    n0.s = n1.s = x.s;\r\n    e = e * 2;\r\n\r\n    // Determine which fraction is closer to x, n0/d0 or n1/d1\r\n    r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(\r\n        div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];\r\n\r\n    MAX_EXP = exp;\r\n\r\n    return r;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return the value of this BigNumber converted to a number primitive.\r\n   */\r\n  P.toNumber = function () {\r\n    return +valueOf(this);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this BigNumber rounded to sd significant digits\r\n   * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits\r\n   * necessary to represent the integer part of the value in fixed-point notation, then use\r\n   * exponential notation.\r\n   *\r\n   * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.\r\n   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.\r\n   *\r\n   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'\r\n   */\r\n  P.toPrecision = function (sd, rm) {\r\n    if (sd != null) intCheck(sd, 1, MAX);\r\n    return format(this, sd, rm, 2);\r\n  };\r\n\r\n\r\n  /*\r\n   * Return a string representing the value of this BigNumber in base b, or base 10 if b is\r\n   * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and\r\n   * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent\r\n   * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than\r\n   * TO_EXP_NEG, return exponential notation.\r\n   *\r\n   * [b] {number} Integer, 2 to ALPHABET.length inclusive.\r\n   *\r\n   * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'\r\n   */\r\n  P.toString = function (b) {\r\n    var str,\r\n      n = this,\r\n      s = n.s,\r\n      e = n.e;\r\n\r\n    // Infinity or NaN?\r\n    if (e === null) {\r\n      if (s) {\r\n        str = 'Infinity';\r\n        if (s < 0) str = '-' + str;\r\n      } else {\r\n        str = 'NaN';\r\n      }\r\n    } else {\r\n      if (b == null) {\r\n        str = e <= TO_EXP_NEG || e >= TO_EXP_POS\r\n         ? toExponential(coeffToString(n.c), e)\r\n         : toFixedPoint(coeffToString(n.c), e, '0');\r\n      } else if (b === 10 && alphabetHasNormalDecimalDigits) {\r\n        n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);\r\n        str = toFixedPoint(coeffToString(n.c), n.e, '0');\r\n      } else {\r\n        intCheck(b, 2, ALPHABET.length, 'Base');\r\n        str = convertBase(toFixedPoint(coeffToString(n.c), e, '0'), 10, b, s, true);\r\n      }\r\n\r\n      if (s < 0 && n.c[0]) str = '-' + str;\r\n    }\r\n\r\n    return str;\r\n  };\r\n\r\n\r\n  /*\r\n   * Return as toString, but do not accept a base argument, and include the minus sign for\r\n   * negative zero.\r\n   */\r\n  P.valueOf = P.toJSON = function () {\r\n    return valueOf(this);\r\n  };\r\n\r\n\r\n  P._isBigNumber = true;\r\n\r\n  P[Symbol.toStringTag] = 'BigNumber';\r\n\r\n  // Node.js v10.12.0+\r\n  P[Symbol.for('nodejs.util.inspect.custom')] = P.valueOf;\r\n\r\n  if (configObject != null) BigNumber.set(configObject);\r\n\r\n  return BigNumber;\r\n}\r\n\r\n\r\n// PRIVATE HELPER FUNCTIONS\r\n\r\n// These functions don't need access to variables,\r\n// e.g. DECIMAL_PLACES, in the scope of the `clone` function above.\r\n\r\n\r\nfunction bitFloor(n) {\r\n  var i = n | 0;\r\n  return n > 0 || n === i ? i : i - 1;\r\n}\r\n\r\n\r\n// Return a coefficient array as a string of base 10 digits.\r\nfunction coeffToString(a) {\r\n  var s, z,\r\n    i = 1,\r\n    j = a.length,\r\n    r = a[0] + '';\r\n\r\n  for (; i < j;) {\r\n    s = a[i++] + '';\r\n    z = LOG_BASE - s.length;\r\n    for (; z--; s = '0' + s);\r\n    r += s;\r\n  }\r\n\r\n  // Determine trailing zeros.\r\n  for (j = r.length; r.charCodeAt(--j) === 48;);\r\n\r\n  return r.slice(0, j + 1 || 1);\r\n}\r\n\r\n\r\n// Compare the value of BigNumbers x and y.\r\nfunction compare(x, y) {\r\n  var a, b,\r\n    xc = x.c,\r\n    yc = y.c,\r\n    i = x.s,\r\n    j = y.s,\r\n    k = x.e,\r\n    l = y.e;\r\n\r\n  // Either NaN?\r\n  if (!i || !j) return null;\r\n\r\n  a = xc && !xc[0];\r\n  b = yc && !yc[0];\r\n\r\n  // Either zero?\r\n  if (a || b) return a ? b ? 0 : -j : i;\r\n\r\n  // Signs differ?\r\n  if (i != j) return i;\r\n\r\n  a = i < 0;\r\n  b = k == l;\r\n\r\n  // Either Infinity?\r\n  if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;\r\n\r\n  // Compare exponents.\r\n  if (!b) return k > l ^ a ? 1 : -1;\r\n\r\n  j = (k = xc.length) < (l = yc.length) ? k : l;\r\n\r\n  // Compare digit by digit.\r\n  for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;\r\n\r\n  // Compare lengths.\r\n  return k == l ? 0 : k > l ^ a ? 1 : -1;\r\n}\r\n\r\n\r\n/*\r\n * Check that n is a primitive number, an integer, and in range, otherwise throw.\r\n */\r\nfunction intCheck(n, min, max, name) {\r\n  if (n < min || n > max || n !== mathfloor(n)) {\r\n    throw Error\r\n     (bignumberError + (name || 'Argument') + (typeof n == 'number'\r\n       ? n < min || n > max ? ' out of range: ' : ' not an integer: '\r\n       : ' not a primitive number: ') + String(n));\r\n  }\r\n}\r\n\r\n\r\n// Assumes finite n.\r\nfunction isOdd(n) {\r\n  var k = n.c.length - 1;\r\n  return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;\r\n}\r\n\r\n\r\nfunction toExponential(str, e) {\r\n  return (str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str) +\r\n   (e < 0 ? 'e' : 'e+') + e;\r\n}\r\n\r\n\r\nfunction toFixedPoint(str, e, z) {\r\n  var len, zs;\r\n\r\n  // Negative exponent?\r\n  if (e < 0) {\r\n\r\n    // Prepend zeros.\r\n    for (zs = z + '.'; ++e; zs += z);\r\n    str = zs + str;\r\n\r\n  // Positive exponent\r\n  } else {\r\n    len = str.length;\r\n\r\n    // Append zeros.\r\n    if (++e > len) {\r\n      for (zs = z, e -= len; --e; zs += z);\r\n      str += zs;\r\n    } else if (e < len) {\r\n      str = str.slice(0, e) + '.' + str.slice(e);\r\n    }\r\n  }\r\n\r\n  return str;\r\n}\r\n\r\n\r\n// EXPORT\r\n\r\n\r\nexport var BigNumber = clone();\r\n\r\nexport default BigNumber;\r\n"],"names":["async","_createActor","interfaceFactory","canisterId","identity","host","agent","HttpAgent","process","II_ENV","fetchRootKey","actor","Actor","createActor","BaseConnection","delegationIdentity","constructor","this","getActor","Error","_getActor","date","delegation","getDelegation","delegations","Date","Number","expiration","BigInt","now","undefined","_ref","sessionKey","Ed25519KeyIdentity","generate","chain","DelegationChain","create","getPublicKey","parse","targets","Principal","fromText","DelegationIdentity","fromDelegation","requestDelegation","executeWithLogging","func","e","console","log","IDL","AccountIdentifier","Text","Duration","Record","secs","Nat64","nanos","Nat32","ArchiveOptions","max_message_size_bytes","Opt","node_max_memory_size_bytes","controller_id","ICPTs","e8s","AccountBalanceArgs","send_whitelist","Vec","Tuple","minting_account","transaction_window","archive_options","initial_values","account","CanisterId","HeaderField","HttpRequest","url","method","body","Nat8","headers","HttpResponse","status_code","Nat16","SubAccount","BlockHeight","NotifyCanisterArgs","to_subaccount","from_subaccount","to_canister","max_fee","block_height","Memo","TimeStamp","timestamp_nanos","SendArgs","to","fee","memo","created_at_time","amount","Service","account_balance_dfx","Func","get_nodes","http_request","notify_dfx","send_dfx","LEDGER_CANISTER_ID","LedgerConnection","legerCanisterId","super","ledger_idl","createConnection","ledgerCanisterId","createConnectionWithII","actorResult","actorGetBalance","actorSend","sendOpts","defaultFee","defaultMemo","Math","floor","random","subAccount","Array","from","createAtTime","getTime","sendArgs","getLedgerActor","getBalance","send","_ref2","WalletType","TokenSymbol","AddressType","PermissionsType","SignerMessageKind","TransactionMessageKind","KEY_ICSTORAGE_KEY","KEY_ICSTORAGE_DELEGATION","KEY_ICSTORAGE_WALLET","KEY_DELEGATION_PARAMS","IDENTITY_PROVIDER_DEFAULT","_deleteStorage","storage","remove","ICStorage","prefix","_localStorage","arguments","length","get","key","Promise","resolve","_getICStorage","getItem","set","value","setItem","removeItem","ls","window","global","self","localStorage","AuthClient","_identity","_key","_chain","_storage","_wallet","_appId","_delegationIdentity","_delegationTargets","_lastRequest","_confirm","_idpWindowOption","_idpWindow","_eventHandler","options","appId","maybeIdentityStorage","fromJSON","wallet","lastRequest","delegationParams","AnonymousIdentity","delegationTargets","confirm","chainStorage","walletString","JSON","forEach","signedDelegation","Set","concat","map","toText","isDelegationValid","error","delegationParamsString","maxTimeToLive","idpWindowOption","_handleSuccess","message","onSuccess","idDelegations","t","Delegation","pubkey","buffer","signature","idDelegationChain","fromDelegations","userPublicKey","iiDelegations","iiDelegationChain","close","_removeEventListener","getIdentity","getLastRequest","getDelegationIdentity","getInnerKey","getDelegationChain","getConfirm","setWallet","data","getDelegateTargets","setDelegationTargets","isAuthenticated","getPrincipal","isAnonymous","login","stringify","identityProviderUrl","URL","identityProvider","toString","hash","open","reject","_getEventHandler","addEventListener","event","origin","kind","request","authType","sessionPublicKey","Uint8Array","toDer","permissions","delegationModes","noUnify","customDomain","postMessage","toJSON","params","err","_handleFailure","onError","text","errorMessage","removeEventListener","logout","returnTo","history","pushState","location","href","ICWindow","_window","_openWindow","target","feature","_remove","days","hours","nanoseconds","targetsFilter","arr","filter","trim","FRAME_SETTING_PAYMENT","IC","authClient","injectWindow","config","whitelist","useFrame","dev","newIC","_setWalletProvider","walletProviderUrl","_setSignerProvider","signerProviderUrl","_setUseFrame","handleAuthenticated","ledgerHost","onAuthenticated","provider","_setConnectOptions","_setLoginOptions","connect","connectOptions","modes","some","v","includes","getAuthClient","handleError","principal","loginOption","disconnect","_this","queryBalance","accountId","ic","astrox","_appendAuth","currentTargets","newTargets","idlFactory","requestTransfer","standard","toUpperCase","isArray","assert","walletProvider","signMessage","signerProvider","_getSignerHandler","ready","client","maxTimeout","successTimeout","success","fail","sendData","delay","setTimeout","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_step","_iterator","Symbol","iterator","next","done","parseInt","return","_defineProperties","props","i","descriptor","enumerable","configurable","writable","Object","defineProperty","_define_property","obj","instance","Constructor","TypeError","_class_call_check","protoProps","staticProps","prototype","_array_like_to_array","len","arr2","_to_consumable_array","_array_without_holes","iter","_iterable_to_array","o","minLen","n","call","slice","name","test","_unsupported_iterable_to_array","_non_iterable_spread","_len","buffers","result","reduce","acc","curr","byteLength","index","b","hexRe","RegExp","fromHex","hex","x","_create_class","_get_prototype_of","setPrototypeOf","getPrototypeOf","__proto__","_possible_constructor_return","_type_of","ReferenceError","_assert_this_initialized","_set_prototype_of","p","_create_super","Derived","hasNativeReflectConstruct","Reflect","construct","sham","Proxy","Boolean","valueOf","_is_native_reflect_construct","Super","NewTarget","apply","CborTag","BufferEncoder","left","right","ArrayBuffer","hasInstance","isView","bytes","BigIntEncoder","tagged","serializer","SelfDescribeCborSerializer","withDefaultEncoders","decodePositiveBigInt","buf","res","addEncoder","Uint8ArrayDecoder","_borc_Decoder","subClass","superClass","_inherits","_super","raw","start","end","_heap","borc","fromHexString","hexString","_hexString_match","match","byte","toHexString","str","padStart","encodeRequest","rpc","value1","serialize","decodeResponse","decoded","input","size","tags","val","Semantic","decodeFirst","Cbor","rpcBuilder","jsonrpc","id","injectBridgeIfNeed","_astrox_bridge_","bridgeCall","webkit","messageHandlers","bridgeName","encodedParams","_callHandlerID","nextId","handlerName","args","_windowId","_","astrox_webview","top","_callHandler","asyncGeneratorStep","gen","_next","_throw","arg","info","then","_ts_generator","thisArg","f","y","g","label","sent","trys","ops","verb","op","pop","push","step","TransactionType","MethodBuilder","bridge","fn","_state","bridgeHandler","isConnected","appendAuth","supportedStandardList","_async_to_generator","_class_extract_field_descriptor","receiver","privateMap","action","has","_class_private_field_get","_class_apply_descriptor_get","_class_private_field_init","privateCollection","_check_private_redeclaration","_class_private_field_set","_class_apply_descriptor_set","_object_spread","source","ownKeys","keys","getOwnPropertySymbols","sym","getOwnPropertyDescriptor","_object_spread_props","getOwnPropertyDescriptors","defineProperties","object","enumerableOnly","symbols","_object_without_properties","excluded","sourceKeys","indexOf","_object_without_properties_loose","sourceSymbolKeys","propertyIsEnumerable","_principal","WeakMap","AstroXIdentity","SignIdentity1","_cacheKey","publicKey","selfAuthenticating","blob","_ms","invoke","fields","requestId","requestDomainSeparator","_tmp","_tmp1","_tmp2","requestIdOf","TextEncoder","encode","content","sign","sender_sig","sender_delegation","sender_pubkey","SignIdentity","BridgeErrors","code","defaultErrorKind","defaultErrorMessage","defaultReturn","bridgeUnknownError","bridgeIllegalArguments","bridgeIllegalState","bridgeUnsupportedError","bridgeIdentityNotFound","bridgeIdentityExpired","bridgeWalletNotFound","bridgeOperationCancelled","bridgeNFTIdentifierError","bridgeUnknownMethod","PrincipalEncoder","_isPrincipal","toUint8Array","KEY_ICSTORAGE_CACHEKEY","KEY_ICSTORAGE_CHAIN","KEY_ICSTORAGE_CONFIRM","KEY_ICSTORAGE_HOST","KEY_CUSTOM_DOMAIN","AstroXWebViewHandler","_agent","_host","_customDomain","_isReady","_assertEnv","_handleWebViewConnectResponse","_injectWindow","_value","String","icx","fromStorage","cacheKey","chainString","walletJson","hostString","customDomainString","setStorage","clear","setHost","setCacheKey","setChain","setConfirm","setIdentity","setAgent","setCustomDomain","_this__identity","isReady","reconnect","_params_delegationTargets","_params_customDomain","chainObject","authorized","payload","req","rawSendOpts","createdAtTime","txType","_JSON_parse","fromErrorCode","symbol","token","nft","type","originPayload","_initBridge","getDefaultParent","originalTarget","document","ownerDocument","counterMap","uncontrolledNodes","markerMap","lockCount","unwrapHost","node","parentNode","applyAttributeToOthers","markerName","controlAttribute","parent","contains","correctedTarget","correctTargets","markerCounter","hiddenNodes","elementsToKeep","elementsToStop","keep","el","add","deep","children","attr","getAttribute","alreadyHidden","counterValue","markerValue","setAttribute","removeAttribute","delete","hideOthers","activeParentNode","querySelectorAll","exports","b64","lens","getLens","validLen","placeHoldersLen","toByteArray","tmp","Arr","_byteLength","curByte","revLookup","charCodeAt","fromByteArray","uint8","extraBytes","parts","maxChunkLength","len2","encodeChunk","lookup","join","num","output","ALPHABET","ALPHABET_MAP","z","charAt","polymodStep","pre","prefixChk","chk","c","__decode","LIMIT","lowered","toLowerCase","uppered","split","lastIndexOf","wordChars","words","convert","inBits","outBits","pad","bits","maxV","module","decodeUnsafe","decode","toWordsUnsafe","toWords","fromWordsUnsafe","fromWords","BigNumber","isNumeric","mathceil","ceil","mathfloor","bignumberError","tooManyDigits","BASE","LOG_BASE","MAX_SAFE_INTEGER","POWS_TEN","SQRT_BASE","MAX","bitFloor","coeffToString","a","s","j","r","compare","xc","yc","k","l","intCheck","min","max","isOdd","toExponential","toFixedPoint","zs","clone","configObject","div","convertBase","parseNumeric","P","ONE","DECIMAL_PLACES","ROUNDING_MODE","TO_EXP_NEG","TO_EXP_POS","MIN_EXP","MAX_EXP","CRYPTO","MODULO_MODE","POW_PRECISION","FORMAT","groupSize","secondaryGroupSize","groupSeparator","decimalSeparator","fractionGroupSize","fractionGroupSeparator","suffix","alphabetHasNormalDecimalDigits","alphabet","caseChanged","isNum","_isBigNumber","replace","search","substring","round","DEBUG","format","rm","c0","ne","maxOrMin","normalise","sd","d","ni","rd","pows10","out","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","hasOwnProperty","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","maximum","minimum","pow2_53","random53bitInt","dp","rand","Uint32Array","copy","splice","sum","plus","decimal","toBaseOut","baseIn","baseOut","arrL","reverse","callerIsToString","pow","multiply","base","m","temp","xlo","xhi","carry","klo","khi","aL","bL","cmp","subtract","more","prod","prodL","q","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","NaN","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","isNaN","p1","p2","absoluteValue","abs","comparedTo","decimalPlaces","dividedBy","dividedToIntegerBy","idiv","exponentiatedBy","half","isModExp","nIsBig","nIsNeg","nIsOdd","isInteger","mod","times","integerValue","isEqualTo","eq","isFinite","isGreaterThan","gt","isGreaterThanOrEqualTo","gte","isLessThan","lt","isLessThanOrEqualTo","lte","isNegative","isPositive","isZero","minus","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","substr","toFraction","md","d0","d1","d2","exp","n0","n1","toNumber","toPrecision","define","_assertThisInitialized","_createClass","_extends","assign","bind","_inheritsLoose","_defineProperty","toPropertyKey","_objectSpread2","_objectWithoutPropertiesLoose","_setPrototypeOf","_arrayLikeToArray","_toConsumableArray","_typeof","toPrimitive","COMPRESSED$1","FENCED","Map","NSM_MAX","read_compressed_payload","pos","read_payload","u16","symbol_count","total","skip","pos_payload","read_width","read_buffer","read_bit","FULL","HALF","QRTR","MASK","register","low","range","mid","offset","decode_arithmetic","ret","width","unsafe_atob","signed","read_deltas","read_sorted","prev","read_sorted_arrays","read_array_while","read_mapped","w","read_linear_table","read_replacement_table","flat","read_transposed","fill","dx","dy","vN","flatMap","ys","j_dy","quote_cp","cp","hex_cp","explode_cp","cps","codePointAt","str_from_cps","fromCodePoint","compare_arrays","COMPRESSED","S0","L0","V0","T0","T_COUNT","N_COUNT","S1","L1","V1","T1","unpack_cc","packed","unpack_cp","SHIFTED_RANK","EXCLUSIONS","DECOMP","RECOMP","is_hangul","compose_pair","recomp","decomposed","bucket","init$1","check_order","cc","s_index","v_index","t_index","mapped","prev_cc","nfd","nfc","stack","prev_cp","composed","composed_from_decomposed","HYPHEN","STOP_CH","FE0F","UNIQUE_PH","Array_from","group_has_cp","Q","Emoji","is_emoji","MAPPED","IGNORED","CM","NSM","ESCAPE","NFC_CHECK","GROUPS","WHOLE_VALID","WHOLE_MAP","VALID","EMOJI_LIST","EMOJI_ROOT","init","read_sorted_array","read_sorted_set","set_add_many","chunks","unrestricted","read_chunked","N","R","M","wholes","sort","V","values","recs","gs","rec","find","G","union","complement","multi","add_to_union","sorted","expand","saved","S","B","br","read_trie","child","quoted_cp","should_escape","bidi_qq","safe_str_from_cps","Infinity","quoter","only_nsm","ens_normalize","flatten","filter_fe0f","nf","ef","tokens","tokens_from_str","token_count","norm","check_leading_underscore","emoji","every","check_label_extension","chars","error_placement","last","check_fenced","unique","groups","error_group_member","error_disallowed","determine_group","check_group","group","maker","shared","whole","check_whole","_ref3","msg","quoted","gg","where","consume_emoji_reversed","eaten","execTyped","regex","string","exec","bytesRegex","integerRegex","isTupleRegex","__defProp","__publicField","__defNormalProp","BaseError","shortMessage","details","cause","docsPath","metaMessages","structSignatureRegex","isStructSignature","execStructSignature","modifiers","functionModifiers","parameterCache","indexed","abiParameterWithoutTupleRegex","abiParameterWithTupleRegex","dynamicIntegerRegex","parseAbiParameter","param","parameterCacheKey","getParameterCacheKey","isTuple","name2","protectedKeywordsRegex","isSolidityKeyword","modifier","structs","components","splitParameters","components_","isSolidityType","isValidDataLocation","array","abiParameter","current","depth","char","tail","parseStructs","signatures","shallowStructs","signaturesLength","properties","propertiesLength","trimmed","resolvedStructs","entries","entriesLength","parameters","resolveStructs","typeWithoutTupleRegex","abiParameters","ancestors","parseAbiParameter2","MAX_DP","MAX_POWER","NAME","INVALID","INVALID_DP","INVALID_RM","DIV_BY_ZERO","UNDEFINED","NUMERIC","RM","unshift","doExponential","isNonzero","isneg","Big","DP","bl","bt","ri","bz","ai","al","rl","qi","shift","sub","xlty","ygtx","neg","one","prec","mul","for","NE","PE","strict","_Big_","nl","roundDown","roundHalfUp","roundHalfEven","roundUp","toStringTag"],"sourceRoot":""}