{"version":3,"file":"maths-fezN6w5w.js","sources":["../../node_modules/ethers/lib.esm/_version.js","../../node_modules/ethers/lib.esm/utils/properties.js","../../node_modules/ethers/lib.esm/utils/errors.js","../../node_modules/ethers/lib.esm/utils/data.js","../../node_modules/ethers/lib.esm/utils/maths.js"],"sourcesContent":["/* Do NOT modify this file; see /src.ts/_admin/update-version.ts */\n/**\n *  The current version of Ethers.\n */\nexport const version = \"6.12.0\";\n//# sourceMappingURL=_version.js.map","/**\n *  Property helper functions.\n *\n *  @_subsection api/utils:Properties  [about-properties]\n */\nfunction checkType(value, type, name) {\n    const types = type.split(\"|\").map(t => t.trim());\n    for (let i = 0; i < types.length; i++) {\n        switch (type) {\n            case \"any\":\n                return;\n            case \"bigint\":\n            case \"boolean\":\n            case \"number\":\n            case \"string\":\n                if (typeof (value) === type) {\n                    return;\n                }\n        }\n    }\n    const error = new Error(`invalid value for type ${type}`);\n    error.code = \"INVALID_ARGUMENT\";\n    error.argument = `value.${name}`;\n    error.value = value;\n    throw error;\n}\n/**\n *  Resolves to a new object that is a copy of %%value%%, but with all\n *  values resolved.\n */\nexport async function resolveProperties(value) {\n    const keys = Object.keys(value);\n    const results = await Promise.all(keys.map((k) => Promise.resolve(value[k])));\n    return results.reduce((accum, v, index) => {\n        accum[keys[index]] = v;\n        return accum;\n    }, {});\n}\n/**\n *  Assigns the %%values%% to %%target%% as read-only values.\n *\n *  It %%types%% is specified, the values are checked.\n */\nexport function defineProperties(target, values, types) {\n    for (let key in values) {\n        let value = values[key];\n        const type = (types ? types[key] : null);\n        if (type) {\n            checkType(value, type, key);\n        }\n        Object.defineProperty(target, key, { enumerable: true, value, writable: false });\n    }\n}\n//# sourceMappingURL=properties.js.map","/**\n *  All errors in ethers include properties to ensure they are both\n *  human-readable (i.e. ``.message``) and machine-readable (i.e. ``.code``).\n *\n *  The [[isError]] function can be used to check the error ``code`` and\n *  provide a type guard for the properties present on that error interface.\n *\n *  @_section: api/utils/errors:Errors  [about-errors]\n */\nimport { version } from \"../_version.js\";\nimport { defineProperties } from \"./properties.js\";\nfunction stringify(value) {\n    if (value == null) {\n        return \"null\";\n    }\n    if (Array.isArray(value)) {\n        return \"[ \" + (value.map(stringify)).join(\", \") + \" ]\";\n    }\n    if (value instanceof Uint8Array) {\n        const HEX = \"0123456789abcdef\";\n        let result = \"0x\";\n        for (let i = 0; i < value.length; i++) {\n            result += HEX[value[i] >> 4];\n            result += HEX[value[i] & 0xf];\n        }\n        return result;\n    }\n    if (typeof (value) === \"object\" && typeof (value.toJSON) === \"function\") {\n        return stringify(value.toJSON());\n    }\n    switch (typeof (value)) {\n        case \"boolean\":\n        case \"symbol\":\n            return value.toString();\n        case \"bigint\":\n            return BigInt(value).toString();\n        case \"number\":\n            return (value).toString();\n        case \"string\":\n            return JSON.stringify(value);\n        case \"object\": {\n            const keys = Object.keys(value);\n            keys.sort();\n            return \"{ \" + keys.map((k) => `${stringify(k)}: ${stringify(value[k])}`).join(\", \") + \" }\";\n        }\n    }\n    return `[ COULD NOT SERIALIZE ]`;\n}\n/**\n *  Returns true if the %%error%% matches an error thrown by ethers\n *  that matches the error %%code%%.\n *\n *  In TypeScript environments, this can be used to check that %%error%%\n *  matches an EthersError type, which means the expected properties will\n *  be set.\n *\n *  @See [ErrorCodes](api:ErrorCode)\n *  @example\n *    try {\n *      // code....\n *    } catch (e) {\n *      if (isError(e, \"CALL_EXCEPTION\")) {\n *          // The Type Guard has validated this object\n *          console.log(e.data);\n *      }\n *    }\n */\nexport function isError(error, code) {\n    return (error && error.code === code);\n}\n/**\n *  Returns true if %%error%% is a [[CallExceptionError].\n */\nexport function isCallException(error) {\n    return isError(error, \"CALL_EXCEPTION\");\n}\n/**\n *  Returns a new Error configured to the format ethers emits errors, with\n *  the %%message%%, [[api:ErrorCode]] %%code%% and additional properties\n *  for the corresponding EthersError.\n *\n *  Each error in ethers includes the version of ethers, a\n *  machine-readable [[ErrorCode]], and depending on %%code%%, additional\n *  required properties. The error message will also include the %%message%%,\n *  ethers version, %%code%% and all additional properties, serialized.\n */\nexport function makeError(message, code, info) {\n    let shortMessage = message;\n    {\n        const details = [];\n        if (info) {\n            if (\"message\" in info || \"code\" in info || \"name\" in info) {\n                throw new Error(`value will overwrite populated values: ${stringify(info)}`);\n            }\n            for (const key in info) {\n                if (key === \"shortMessage\") {\n                    continue;\n                }\n                const value = (info[key]);\n                //                try {\n                details.push(key + \"=\" + stringify(value));\n                //                } catch (error: any) {\n                //                console.log(\"MMM\", error.message);\n                //                    details.push(key + \"=[could not serialize object]\");\n                //                }\n            }\n        }\n        details.push(`code=${code}`);\n        details.push(`version=${version}`);\n        if (details.length) {\n            message += \" (\" + details.join(\", \") + \")\";\n        }\n    }\n    let error;\n    switch (code) {\n        case \"INVALID_ARGUMENT\":\n            error = new TypeError(message);\n            break;\n        case \"NUMERIC_FAULT\":\n        case \"BUFFER_OVERRUN\":\n            error = new RangeError(message);\n            break;\n        default:\n            error = new Error(message);\n    }\n    defineProperties(error, { code });\n    if (info) {\n        Object.assign(error, info);\n    }\n    if (error.shortMessage == null) {\n        defineProperties(error, { shortMessage });\n    }\n    return error;\n}\n/**\n *  Throws an EthersError with %%message%%, %%code%% and additional error\n *  %%info%% when %%check%% is falsish..\n *\n *  @see [[api:makeError]]\n */\nexport function assert(check, message, code, info) {\n    if (!check) {\n        throw makeError(message, code, info);\n    }\n}\n/**\n *  A simple helper to simply ensuring provided arguments match expected\n *  constraints, throwing if not.\n *\n *  In TypeScript environments, the %%check%% has been asserted true, so\n *  any further code does not need additional compile-time checks.\n */\nexport function assertArgument(check, message, name, value) {\n    assert(check, message, \"INVALID_ARGUMENT\", { argument: name, value: value });\n}\nexport function assertArgumentCount(count, expectedCount, message) {\n    if (message == null) {\n        message = \"\";\n    }\n    if (message) {\n        message = \": \" + message;\n    }\n    assert(count >= expectedCount, \"missing arguemnt\" + message, \"MISSING_ARGUMENT\", {\n        count: count,\n        expectedCount: expectedCount\n    });\n    assert(count <= expectedCount, \"too many arguments\" + message, \"UNEXPECTED_ARGUMENT\", {\n        count: count,\n        expectedCount: expectedCount\n    });\n}\nconst _normalizeForms = [\"NFD\", \"NFC\", \"NFKD\", \"NFKC\"].reduce((accum, form) => {\n    try {\n        // General test for normalize\n        /* c8 ignore start */\n        if (\"test\".normalize(form) !== \"test\") {\n            throw new Error(\"bad\");\n        }\n        ;\n        /* c8 ignore stop */\n        if (form === \"NFD\") {\n            const check = String.fromCharCode(0xe9).normalize(\"NFD\");\n            const expected = String.fromCharCode(0x65, 0x0301);\n            /* c8 ignore start */\n            if (check !== expected) {\n                throw new Error(\"broken\");\n            }\n            /* c8 ignore stop */\n        }\n        accum.push(form);\n    }\n    catch (error) { }\n    return accum;\n}, []);\n/**\n *  Throws if the normalization %%form%% is not supported.\n */\nexport function assertNormalize(form) {\n    assert(_normalizeForms.indexOf(form) >= 0, \"platform missing String.prototype.normalize\", \"UNSUPPORTED_OPERATION\", {\n        operation: \"String.prototype.normalize\", info: { form }\n    });\n}\n/**\n *  Many classes use file-scoped values to guard the constructor,\n *  making it effectively private. This facilitates that pattern\n *  by ensuring the %%givenGaurd%% matches the file-scoped %%guard%%,\n *  throwing if not, indicating the %%className%% if provided.\n */\nexport function assertPrivate(givenGuard, guard, className) {\n    if (className == null) {\n        className = \"\";\n    }\n    if (givenGuard !== guard) {\n        let method = className, operation = \"new\";\n        if (className) {\n            method += \".\";\n            operation += \" \" + className;\n        }\n        assert(false, `private constructor; use ${method}from* methods`, \"UNSUPPORTED_OPERATION\", {\n            operation\n        });\n    }\n}\n//# sourceMappingURL=errors.js.map","/**\n *  Some data helpers.\n *\n *\n *  @_subsection api/utils:Data Helpers  [about-data]\n */\nimport { assert, assertArgument } from \"./errors.js\";\nfunction _getBytes(value, name, copy) {\n    if (value instanceof Uint8Array) {\n        if (copy) {\n            return new Uint8Array(value);\n        }\n        return value;\n    }\n    if (typeof (value) === \"string\" && value.match(/^0x([0-9a-f][0-9a-f])*$/i)) {\n        const result = new Uint8Array((value.length - 2) / 2);\n        let offset = 2;\n        for (let i = 0; i < result.length; i++) {\n            result[i] = parseInt(value.substring(offset, offset + 2), 16);\n            offset += 2;\n        }\n        return result;\n    }\n    assertArgument(false, \"invalid BytesLike value\", name || \"value\", value);\n}\n/**\n *  Get a typed Uint8Array for %%value%%. If already a Uint8Array\n *  the original %%value%% is returned; if a copy is required use\n *  [[getBytesCopy]].\n *\n *  @see: getBytesCopy\n */\nexport function getBytes(value, name) {\n    return _getBytes(value, name, false);\n}\n/**\n *  Get a typed Uint8Array for %%value%%, creating a copy if necessary\n *  to prevent any modifications of the returned value from being\n *  reflected elsewhere.\n *\n *  @see: getBytes\n */\nexport function getBytesCopy(value, name) {\n    return _getBytes(value, name, true);\n}\n/**\n *  Returns true if %%value%% is a valid [[HexString]].\n *\n *  If %%length%% is ``true`` or a //number//, it also checks that\n *  %%value%% is a valid [[DataHexString]] of %%length%% (if a //number//)\n *  bytes of data (e.g. ``0x1234`` is 2 bytes).\n */\nexport function isHexString(value, length) {\n    if (typeof (value) !== \"string\" || !value.match(/^0x[0-9A-Fa-f]*$/)) {\n        return false;\n    }\n    if (typeof (length) === \"number\" && value.length !== 2 + 2 * length) {\n        return false;\n    }\n    if (length === true && (value.length % 2) !== 0) {\n        return false;\n    }\n    return true;\n}\n/**\n *  Returns true if %%value%% is a valid representation of arbitrary\n *  data (i.e. a valid [[DataHexString]] or a Uint8Array).\n */\nexport function isBytesLike(value) {\n    return (isHexString(value, true) || (value instanceof Uint8Array));\n}\nconst HexCharacters = \"0123456789abcdef\";\n/**\n *  Returns a [[DataHexString]] representation of %%data%%.\n */\nexport function hexlify(data) {\n    const bytes = getBytes(data);\n    let result = \"0x\";\n    for (let i = 0; i < bytes.length; i++) {\n        const v = bytes[i];\n        result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];\n    }\n    return result;\n}\n/**\n *  Returns a [[DataHexString]] by concatenating all values\n *  within %%data%%.\n */\nexport function concat(datas) {\n    return \"0x\" + datas.map((d) => hexlify(d).substring(2)).join(\"\");\n}\n/**\n *  Returns the length of %%data%%, in bytes.\n */\nexport function dataLength(data) {\n    if (isHexString(data, true)) {\n        return (data.length - 2) / 2;\n    }\n    return getBytes(data).length;\n}\n/**\n *  Returns a [[DataHexString]] by slicing %%data%% from the %%start%%\n *  offset to the %%end%% offset.\n *\n *  By default %%start%% is 0 and %%end%% is the length of %%data%%.\n */\nexport function dataSlice(data, start, end) {\n    const bytes = getBytes(data);\n    if (end != null && end > bytes.length) {\n        assert(false, \"cannot slice beyond data bounds\", \"BUFFER_OVERRUN\", {\n            buffer: bytes, length: bytes.length, offset: end\n        });\n    }\n    return hexlify(bytes.slice((start == null) ? 0 : start, (end == null) ? bytes.length : end));\n}\n/**\n *  Return the [[DataHexString]] result by stripping all **leading**\n ** zero bytes from %%data%%.\n */\nexport function stripZerosLeft(data) {\n    let bytes = hexlify(data).substring(2);\n    while (bytes.startsWith(\"00\")) {\n        bytes = bytes.substring(2);\n    }\n    return \"0x\" + bytes;\n}\nfunction zeroPad(data, length, left) {\n    const bytes = getBytes(data);\n    assert(length >= bytes.length, \"padding exceeds data length\", \"BUFFER_OVERRUN\", {\n        buffer: new Uint8Array(bytes),\n        length: length,\n        offset: length + 1\n    });\n    const result = new Uint8Array(length);\n    result.fill(0);\n    if (left) {\n        result.set(bytes, length - bytes.length);\n    }\n    else {\n        result.set(bytes, 0);\n    }\n    return hexlify(result);\n}\n/**\n *  Return the [[DataHexString]] of %%data%% padded on the **left**\n *  to %%length%% bytes.\n *\n *  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is\n *  thrown.\n *\n *  This pads data the same as **values** are in Solidity\n *  (e.g. ``uint128``).\n */\nexport function zeroPadValue(data, length) {\n    return zeroPad(data, length, true);\n}\n/**\n *  Return the [[DataHexString]] of %%data%% padded on the **right**\n *  to %%length%% bytes.\n *\n *  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is\n *  thrown.\n *\n *  This pads data the same as **bytes** are in Solidity\n *  (e.g. ``bytes16``).\n */\nexport function zeroPadBytes(data, length) {\n    return zeroPad(data, length, false);\n}\n//# sourceMappingURL=data.js.map","/**\n *  Some mathematic operations.\n *\n *  @_subsection: api/utils:Math Helpers  [about-maths]\n */\nimport { hexlify, isBytesLike } from \"./data.js\";\nimport { assert, assertArgument } from \"./errors.js\";\nconst BN_0 = BigInt(0);\nconst BN_1 = BigInt(1);\n//const BN_Max256 = (BN_1 << BigInt(256)) - BN_1;\n// IEEE 754 support 53-bits of mantissa\nconst maxValue = 0x1fffffffffffff;\n/**\n *  Convert %%value%% from a twos-compliment representation of %%width%%\n *  bits to its value.\n *\n *  If the highest bit is ``1``, the result will be negative.\n */\nexport function fromTwos(_value, _width) {\n    const value = getUint(_value, \"value\");\n    const width = BigInt(getNumber(_width, \"width\"));\n    assert((value >> width) === BN_0, \"overflow\", \"NUMERIC_FAULT\", {\n        operation: \"fromTwos\", fault: \"overflow\", value: _value\n    });\n    // Top bit set; treat as a negative value\n    if (value >> (width - BN_1)) {\n        const mask = (BN_1 << width) - BN_1;\n        return -(((~value) & mask) + BN_1);\n    }\n    return value;\n}\n/**\n *  Convert %%value%% to a twos-compliment representation of\n *  %%width%% bits.\n *\n *  The result will always be positive.\n */\nexport function toTwos(_value, _width) {\n    let value = getBigInt(_value, \"value\");\n    const width = BigInt(getNumber(_width, \"width\"));\n    const limit = (BN_1 << (width - BN_1));\n    if (value < BN_0) {\n        value = -value;\n        assert(value <= limit, \"too low\", \"NUMERIC_FAULT\", {\n            operation: \"toTwos\", fault: \"overflow\", value: _value\n        });\n        const mask = (BN_1 << width) - BN_1;\n        return ((~value) & mask) + BN_1;\n    }\n    else {\n        assert(value < limit, \"too high\", \"NUMERIC_FAULT\", {\n            operation: \"toTwos\", fault: \"overflow\", value: _value\n        });\n    }\n    return value;\n}\n/**\n *  Mask %%value%% with a bitmask of %%bits%% ones.\n */\nexport function mask(_value, _bits) {\n    const value = getUint(_value, \"value\");\n    const bits = BigInt(getNumber(_bits, \"bits\"));\n    return value & ((BN_1 << bits) - BN_1);\n}\n/**\n *  Gets a BigInt from %%value%%. If it is an invalid value for\n *  a BigInt, then an ArgumentError will be thrown for %%name%%.\n */\nexport function getBigInt(value, name) {\n    switch (typeof (value)) {\n        case \"bigint\": return value;\n        case \"number\":\n            assertArgument(Number.isInteger(value), \"underflow\", name || \"value\", value);\n            assertArgument(value >= -maxValue && value <= maxValue, \"overflow\", name || \"value\", value);\n            return BigInt(value);\n        case \"string\":\n            try {\n                if (value === \"\") {\n                    throw new Error(\"empty string\");\n                }\n                if (value[0] === \"-\" && value[1] !== \"-\") {\n                    return -BigInt(value.substring(1));\n                }\n                return BigInt(value);\n            }\n            catch (e) {\n                assertArgument(false, `invalid BigNumberish string: ${e.message}`, name || \"value\", value);\n            }\n    }\n    assertArgument(false, \"invalid BigNumberish value\", name || \"value\", value);\n}\n/**\n *  Returns %%value%% as a bigint, validating it is valid as a bigint\n *  value and that it is positive.\n */\nexport function getUint(value, name) {\n    const result = getBigInt(value, name);\n    assert(result >= BN_0, \"unsigned value cannot be negative\", \"NUMERIC_FAULT\", {\n        fault: \"overflow\", operation: \"getUint\", value\n    });\n    return result;\n}\nconst Nibbles = \"0123456789abcdef\";\n/*\n * Converts %%value%% to a BigInt. If %%value%% is a Uint8Array, it\n * is treated as Big Endian data.\n */\nexport function toBigInt(value) {\n    if (value instanceof Uint8Array) {\n        let result = \"0x0\";\n        for (const v of value) {\n            result += Nibbles[v >> 4];\n            result += Nibbles[v & 0x0f];\n        }\n        return BigInt(result);\n    }\n    return getBigInt(value);\n}\n/**\n *  Gets a //number// from %%value%%. If it is an invalid value for\n *  a //number//, then an ArgumentError will be thrown for %%name%%.\n */\nexport function getNumber(value, name) {\n    switch (typeof (value)) {\n        case \"bigint\":\n            assertArgument(value >= -maxValue && value <= maxValue, \"overflow\", name || \"value\", value);\n            return Number(value);\n        case \"number\":\n            assertArgument(Number.isInteger(value), \"underflow\", name || \"value\", value);\n            assertArgument(value >= -maxValue && value <= maxValue, \"overflow\", name || \"value\", value);\n            return value;\n        case \"string\":\n            try {\n                if (value === \"\") {\n                    throw new Error(\"empty string\");\n                }\n                return getNumber(BigInt(value), name);\n            }\n            catch (e) {\n                assertArgument(false, `invalid numeric string: ${e.message}`, name || \"value\", value);\n            }\n    }\n    assertArgument(false, \"invalid numeric value\", name || \"value\", value);\n}\n/**\n *  Converts %%value%% to a number. If %%value%% is a Uint8Array, it\n *  is treated as Big Endian data. Throws if the value is not safe.\n */\nexport function toNumber(value) {\n    return getNumber(toBigInt(value));\n}\n/**\n *  Converts %%value%% to a Big Endian hexstring, optionally padded to\n *  %%width%% bytes.\n */\nexport function toBeHex(_value, _width) {\n    const value = getUint(_value, \"value\");\n    let result = value.toString(16);\n    if (_width == null) {\n        // Ensure the value is of even length\n        if (result.length % 2) {\n            result = \"0\" + result;\n        }\n    }\n    else {\n        const width = getNumber(_width, \"width\");\n        assert(width * 2 >= result.length, `value exceeds width (${width} bytes)`, \"NUMERIC_FAULT\", {\n            operation: \"toBeHex\",\n            fault: \"overflow\",\n            value: _value\n        });\n        // Pad the value to the required width\n        while (result.length < (width * 2)) {\n            result = \"0\" + result;\n        }\n    }\n    return \"0x\" + result;\n}\n/**\n *  Converts %%value%% to a Big Endian Uint8Array.\n */\nexport function toBeArray(_value) {\n    const value = getUint(_value, \"value\");\n    if (value === BN_0) {\n        return new Uint8Array([]);\n    }\n    let hex = value.toString(16);\n    if (hex.length % 2) {\n        hex = \"0\" + hex;\n    }\n    const result = new Uint8Array(hex.length / 2);\n    for (let i = 0; i < result.length; i++) {\n        const offset = i * 2;\n        result[i] = parseInt(hex.substring(offset, offset + 2), 16);\n    }\n    return result;\n}\n/**\n *  Returns a [[HexString]] for %%value%% safe to use as a //Quantity//.\n *\n *  A //Quantity// does not have and leading 0 values unless the value is\n *  the literal value `0x0`. This is most commonly used for JSSON-RPC\n *  numeric values.\n */\nexport function toQuantity(value) {\n    let result = hexlify(isBytesLike(value) ? value : toBeArray(value)).substring(2);\n    while (result.startsWith(\"0\")) {\n        result = result.substring(1);\n    }\n    if (result === \"\") {\n        result = \"0\";\n    }\n    return \"0x\" + result;\n}\n//# sourceMappingURL=maths.js.map"],"names":["e","n","version","checkType","value","type","name","types","t","i","error","resolveProperties","keys","k","accum","v","index","defineProperties","target","values","key","stringify","HEX","result","isError","code","isCallException","makeError","message","info","shortMessage","details","assert","check","assertArgument","assertArgumentCount","count","expectedCount","_normalizeForms","form","assertNormalize","assertPrivate","givenGuard","guard","className","method","operation","_getBytes","copy","offset","getBytes","getBytesCopy","isHexString","length","isBytesLike","HexCharacters","hexlify","data","bytes","concat","datas","d","dataLength","dataSlice","start","end","stripZerosLeft","zeroPad","left","zeroPadValue","zeroPadBytes","BN_0","BN_1","maxValue","fromTwos","_value","_width","getUint","width","getNumber","mask","toTwos","getBigInt","limit","_bits","bits","Nibbles","toBigInt","toNumber","toBeHex","toBeArray","hex","toQuantity"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4]}