@hashgraphonline/standards-sdk 0.0.93 → 0.0.95

package/dist/es/standards-sdk.es56.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es56.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/array.js"],"sourcesContent":["import { defineProperties, isError, assert, assertArgument, assertArgumentCount } from \"../../utils/index.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder, Result, WordSize, Writer } from \"./abstract-coder.js\";\nimport { AnonymousCoder } from \"./anonymous.js\";\n/**\n *  @_ignore\n */\nexport function pack(writer, coders, values) {\n    let arrayValues = [];\n    if (Array.isArray(values)) {\n        arrayValues = values;\n    }\n    else if (values && typeof (values) === \"object\") {\n        let unique = {};\n        arrayValues = coders.map((coder) => {\n            const name = coder.localName;\n            assert(name, \"cannot encode object for signature with missing names\", \"INVALID_ARGUMENT\", { argument: \"values\", info: { coder }, value: values });\n            assert(!unique[name], \"cannot encode object for signature with duplicate names\", \"INVALID_ARGUMENT\", { argument: \"values\", info: { coder }, value: values });\n            unique[name] = true;\n            return values[name];\n        });\n    }\n    else {\n        assertArgument(false, \"invalid tuple value\", \"tuple\", values);\n    }\n    assertArgument(coders.length === arrayValues.length, \"types/value length mismatch\", \"tuple\", values);\n    let staticWriter = new Writer();\n    let dynamicWriter = new Writer();\n    let updateFuncs = [];\n    coders.forEach((coder, index) => {\n        let value = arrayValues[index];\n        if (coder.dynamic) {\n            // Get current dynamic offset (for the future pointer)\n            let dynamicOffset = dynamicWriter.length;\n            // Encode the dynamic value into the dynamicWriter\n            coder.encode(dynamicWriter, value);\n            // Prepare to populate the correct offset once we are done\n            let updateFunc = staticWriter.writeUpdatableValue();\n            updateFuncs.push((baseOffset) => {\n                updateFunc(baseOffset + dynamicOffset);\n            });\n        }\n        else {\n            coder.encode(staticWriter, value);\n        }\n    });\n    // Backfill all the dynamic offsets, now that we know the static length\n    updateFuncs.forEach((func) => { func(staticWriter.length); });\n    let length = writer.appendWriter(staticWriter);\n    length += writer.appendWriter(dynamicWriter);\n    return length;\n}\n/**\n *  @_ignore\n */\nexport function unpack(reader, coders) {\n    let values = [];\n    let keys = [];\n    // A reader anchored to this base\n    let baseReader = reader.subReader(0);\n    coders.forEach((coder) => {\n        let value = null;\n        if (coder.dynamic) {\n            let offset = reader.readIndex();\n            let offsetReader = baseReader.subReader(offset);\n            try {\n                value = coder.decode(offsetReader);\n            }\n            catch (error) {\n                // Cannot recover from this\n                if (isError(error, \"BUFFER_OVERRUN\")) {\n                    throw error;\n                }\n                value = error;\n                value.baseType = coder.name;\n                value.name = coder.localName;\n                value.type = coder.type;\n            }\n        }\n        else {\n            try {\n                value = coder.decode(reader);\n            }\n            catch (error) {\n                // Cannot recover from this\n                if (isError(error, \"BUFFER_OVERRUN\")) {\n                    throw error;\n                }\n                value = error;\n                value.baseType = coder.name;\n                value.name = coder.localName;\n                value.type = coder.type;\n            }\n        }\n        if (value == undefined) {\n            throw new Error(\"investigate\");\n        }\n        values.push(value);\n        keys.push(coder.localName || null);\n    });\n    return Result.fromItems(values, keys);\n}\n/**\n *  @_ignore\n */\nexport class ArrayCoder extends Coder {\n    coder;\n    length;\n    constructor(coder, length, localName) {\n        const type = (coder.type + \"[\" + (length >= 0 ? length : \"\") + \"]\");\n        const dynamic = (length === -1 || coder.dynamic);\n        super(\"array\", type, localName, dynamic);\n        defineProperties(this, { coder, length });\n    }\n    defaultValue() {\n        // Verifies the child coder is valid (even if the array is dynamic or 0-length)\n        const defaultChild = this.coder.defaultValue();\n        const result = [];\n        for (let i = 0; i < this.length; i++) {\n            result.push(defaultChild);\n        }\n        return result;\n    }\n    encode(writer, _value) {\n        const value = Typed.dereference(_value, \"array\");\n        if (!Array.isArray(value)) {\n            this._throwError(\"expected array value\", value);\n        }\n        let count = this.length;\n        if (count === -1) {\n            count = value.length;\n            writer.writeValue(value.length);\n        }\n        assertArgumentCount(value.length, count, \"coder array\" + (this.localName ? (\" \" + this.localName) : \"\"));\n        let coders = [];\n        for (let i = 0; i < value.length; i++) {\n            coders.push(this.coder);\n        }\n        return pack(writer, coders, value);\n    }\n    decode(reader) {\n        let count = this.length;\n        if (count === -1) {\n            count = reader.readIndex();\n            // Check that there is *roughly* enough data to ensure\n            // stray random data is not being read as a length. Each\n            // slot requires at least 32 bytes for their value (or 32\n            // bytes as a link to the data). This could use a much\n            // tighter bound, but we are erroring on the side of safety.\n            assert(count * WordSize <= reader.dataLength, \"insufficient data length\", \"BUFFER_OVERRUN\", { buffer: reader.bytes, offset: count * WordSize, length: reader.dataLength });\n        }\n        let coders = [];\n        for (let i = 0; i < count; i++) {\n            coders.push(new AnonymousCoder(this.coder));\n        }\n        return unpack(reader, coders);\n    }\n}\n//# sourceMappingURL=array.js.map"],"names":[],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es56.js","sources":["../../node_modules/ethers/lib.esm/abi/typed.js"],"sourcesContent":["/**\n *  A Typed object allows a value to have its type explicitly\n *  specified.\n *\n *  For example, in Solidity, the value ``45`` could represent a\n *  ``uint8`` or a ``uint256``. The value ``0x1234`` could represent\n *  a ``bytes2`` or ``bytes``.\n *\n *  Since JavaScript has no meaningful way to explicitly inform any\n *  APIs which what the type is, this allows transparent interoperation\n *  with Soldity.\n *\n *  @_subsection: api/abi:Typed Values\n */\nimport { assertPrivate, defineProperties } from \"../utils/index.js\";\nconst _gaurd = {};\nfunction n(value, width) {\n    let signed = false;\n    if (width < 0) {\n        signed = true;\n        width *= -1;\n    }\n    // @TODO: Check range is valid for value\n    return new Typed(_gaurd, `${signed ? \"\" : \"u\"}int${width}`, value, { signed, width });\n}\nfunction b(value, size) {\n    // @TODO: Check range is valid for value\n    return new Typed(_gaurd, `bytes${(size) ? size : \"\"}`, value, { size });\n}\nconst _typedSymbol = Symbol.for(\"_ethers_typed\");\n/**\n *  The **Typed** class to wrap values providing explicit type information.\n */\nexport class Typed {\n    /**\n     *  The type, as a Solidity-compatible type.\n     */\n    type;\n    /**\n     *  The actual value.\n     */\n    value;\n    #options;\n    /**\n     *  @_ignore:\n     */\n    _typedSymbol;\n    /**\n     *  @_ignore:\n     */\n    constructor(gaurd, type, value, options) {\n        if (options == null) {\n            options = null;\n        }\n        assertPrivate(_gaurd, gaurd, \"Typed\");\n        defineProperties(this, { _typedSymbol, type, value });\n        this.#options = options;\n        // Check the value is valid\n        this.format();\n    }\n    /**\n     *  Format the type as a Human-Readable type.\n     */\n    format() {\n        if (this.type === \"array\") {\n            throw new Error(\"\");\n        }\n        else if (this.type === \"dynamicArray\") {\n            throw new Error(\"\");\n        }\n        else if (this.type === \"tuple\") {\n            return `tuple(${this.value.map((v) => v.format()).join(\",\")})`;\n        }\n        return this.type;\n    }\n    /**\n     *  The default value returned by this type.\n     */\n    defaultValue() {\n        return 0;\n    }\n    /**\n     *  The minimum value for numeric types.\n     */\n    minValue() {\n        return 0;\n    }\n    /**\n     *  The maximum value for numeric types.\n     */\n    maxValue() {\n        return 0;\n    }\n    /**\n     *  Returns ``true`` and provides a type guard is this is a [[TypedBigInt]].\n     */\n    isBigInt() {\n        return !!(this.type.match(/^u?int[0-9]+$/));\n    }\n    /**\n     *  Returns ``true`` and provides a type guard is this is a [[TypedData]].\n     */\n    isData() {\n        return this.type.startsWith(\"bytes\");\n    }\n    /**\n     *  Returns ``true`` and provides a type guard is this is a [[TypedString]].\n     */\n    isString() {\n        return (this.type === \"string\");\n    }\n    /**\n     *  Returns the tuple name, if this is a tuple. Throws otherwise.\n     */\n    get tupleName() {\n        if (this.type !== \"tuple\") {\n            throw TypeError(\"not a tuple\");\n        }\n        return this.#options;\n    }\n    // Returns the length of this type as an array\n    // - `null` indicates the length is unforced, it could be dynamic\n    // - `-1` indicates the length is dynamic\n    // - any other value indicates it is a static array and is its length\n    /**\n     *  Returns the length of the array type or ``-1`` if it is dynamic.\n     *\n     *  Throws if the type is not an array.\n     */\n    get arrayLength() {\n        if (this.type !== \"array\") {\n            throw TypeError(\"not an array\");\n        }\n        if (this.#options === true) {\n            return -1;\n        }\n        if (this.#options === false) {\n            return (this.value).length;\n        }\n        return null;\n    }\n    /**\n     *  Returns a new **Typed** of %%type%% with the %%value%%.\n     */\n    static from(type, value) {\n        return new Typed(_gaurd, type, value);\n    }\n    /**\n     *  Return a new ``uint8`` type for %%v%%.\n     */\n    static uint8(v) { return n(v, 8); }\n    /**\n     *  Return a new ``uint16`` type for %%v%%.\n     */\n    static uint16(v) { return n(v, 16); }\n    /**\n     *  Return a new ``uint24`` type for %%v%%.\n     */\n    static uint24(v) { return n(v, 24); }\n    /**\n     *  Return a new ``uint32`` type for %%v%%.\n     */\n    static uint32(v) { return n(v, 32); }\n    /**\n     *  Return a new ``uint40`` type for %%v%%.\n     */\n    static uint40(v) { return n(v, 40); }\n    /**\n     *  Return a new ``uint48`` type for %%v%%.\n     */\n    static uint48(v) { return n(v, 48); }\n    /**\n     *  Return a new ``uint56`` type for %%v%%.\n     */\n    static uint56(v) { return n(v, 56); }\n    /**\n     *  Return a new ``uint64`` type for %%v%%.\n     */\n    static uint64(v) { return n(v, 64); }\n    /**\n     *  Return a new ``uint72`` type for %%v%%.\n     */\n    static uint72(v) { return n(v, 72); }\n    /**\n     *  Return a new ``uint80`` type for %%v%%.\n     */\n    static uint80(v) { return n(v, 80); }\n    /**\n     *  Return a new ``uint88`` type for %%v%%.\n     */\n    static uint88(v) { return n(v, 88); }\n    /**\n     *  Return a new ``uint96`` type for %%v%%.\n     */\n    static uint96(v) { return n(v, 96); }\n    /**\n     *  Return a new ``uint104`` type for %%v%%.\n     */\n    static uint104(v) { return n(v, 104); }\n    /**\n     *  Return a new ``uint112`` type for %%v%%.\n     */\n    static uint112(v) { return n(v, 112); }\n    /**\n     *  Return a new ``uint120`` type for %%v%%.\n     */\n    static uint120(v) { return n(v, 120); }\n    /**\n     *  Return a new ``uint128`` type for %%v%%.\n     */\n    static uint128(v) { return n(v, 128); }\n    /**\n     *  Return a new ``uint136`` type for %%v%%.\n     */\n    static uint136(v) { return n(v, 136); }\n    /**\n     *  Return a new ``uint144`` type for %%v%%.\n     */\n    static uint144(v) { return n(v, 144); }\n    /**\n     *  Return a new ``uint152`` type for %%v%%.\n     */\n    static uint152(v) { return n(v, 152); }\n    /**\n     *  Return a new ``uint160`` type for %%v%%.\n     */\n    static uint160(v) { return n(v, 160); }\n    /**\n     *  Return a new ``uint168`` type for %%v%%.\n     */\n    static uint168(v) { return n(v, 168); }\n    /**\n     *  Return a new ``uint176`` type for %%v%%.\n     */\n    static uint176(v) { return n(v, 176); }\n    /**\n     *  Return a new ``uint184`` type for %%v%%.\n     */\n    static uint184(v) { return n(v, 184); }\n    /**\n     *  Return a new ``uint192`` type for %%v%%.\n     */\n    static uint192(v) { return n(v, 192); }\n    /**\n     *  Return a new ``uint200`` type for %%v%%.\n     */\n    static uint200(v) { return n(v, 200); }\n    /**\n     *  Return a new ``uint208`` type for %%v%%.\n     */\n    static uint208(v) { return n(v, 208); }\n    /**\n     *  Return a new ``uint216`` type for %%v%%.\n     */\n    static uint216(v) { return n(v, 216); }\n    /**\n     *  Return a new ``uint224`` type for %%v%%.\n     */\n    static uint224(v) { return n(v, 224); }\n    /**\n     *  Return a new ``uint232`` type for %%v%%.\n     */\n    static uint232(v) { return n(v, 232); }\n    /**\n     *  Return a new ``uint240`` type for %%v%%.\n     */\n    static uint240(v) { return n(v, 240); }\n    /**\n     *  Return a new ``uint248`` type for %%v%%.\n     */\n    static uint248(v) { return n(v, 248); }\n    /**\n     *  Return a new ``uint256`` type for %%v%%.\n     */\n    static uint256(v) { return n(v, 256); }\n    /**\n     *  Return a new ``uint256`` type for %%v%%.\n     */\n    static uint(v) { return n(v, 256); }\n    /**\n     *  Return a new ``int8`` type for %%v%%.\n     */\n    static int8(v) { return n(v, -8); }\n    /**\n     *  Return a new ``int16`` type for %%v%%.\n     */\n    static int16(v) { return n(v, -16); }\n    /**\n     *  Return a new ``int24`` type for %%v%%.\n     */\n    static int24(v) { return n(v, -24); }\n    /**\n     *  Return a new ``int32`` type for %%v%%.\n     */\n    static int32(v) { return n(v, -32); }\n    /**\n     *  Return a new ``int40`` type for %%v%%.\n     */\n    static int40(v) { return n(v, -40); }\n    /**\n     *  Return a new ``int48`` type for %%v%%.\n     */\n    static int48(v) { return n(v, -48); }\n    /**\n     *  Return a new ``int56`` type for %%v%%.\n     */\n    static int56(v) { return n(v, -56); }\n    /**\n     *  Return a new ``int64`` type for %%v%%.\n     */\n    static int64(v) { return n(v, -64); }\n    /**\n     *  Return a new ``int72`` type for %%v%%.\n     */\n    static int72(v) { return n(v, -72); }\n    /**\n     *  Return a new ``int80`` type for %%v%%.\n     */\n    static int80(v) { return n(v, -80); }\n    /**\n     *  Return a new ``int88`` type for %%v%%.\n     */\n    static int88(v) { return n(v, -88); }\n    /**\n     *  Return a new ``int96`` type for %%v%%.\n     */\n    static int96(v) { return n(v, -96); }\n    /**\n     *  Return a new ``int104`` type for %%v%%.\n     */\n    static int104(v) { return n(v, -104); }\n    /**\n     *  Return a new ``int112`` type for %%v%%.\n     */\n    static int112(v) { return n(v, -112); }\n    /**\n     *  Return a new ``int120`` type for %%v%%.\n     */\n    static int120(v) { return n(v, -120); }\n    /**\n     *  Return a new ``int128`` type for %%v%%.\n     */\n    static int128(v) { return n(v, -128); }\n    /**\n     *  Return a new ``int136`` type for %%v%%.\n     */\n    static int136(v) { return n(v, -136); }\n    /**\n     *  Return a new ``int144`` type for %%v%%.\n     */\n    static int144(v) { return n(v, -144); }\n    /**\n     *  Return a new ``int52`` type for %%v%%.\n     */\n    static int152(v) { return n(v, -152); }\n    /**\n     *  Return a new ``int160`` type for %%v%%.\n     */\n    static int160(v) { return n(v, -160); }\n    /**\n     *  Return a new ``int168`` type for %%v%%.\n     */\n    static int168(v) { return n(v, -168); }\n    /**\n     *  Return a new ``int176`` type for %%v%%.\n     */\n    static int176(v) { return n(v, -176); }\n    /**\n     *  Return a new ``int184`` type for %%v%%.\n     */\n    static int184(v) { return n(v, -184); }\n    /**\n     *  Return a new ``int92`` type for %%v%%.\n     */\n    static int192(v) { return n(v, -192); }\n    /**\n     *  Return a new ``int200`` type for %%v%%.\n     */\n    static int200(v) { return n(v, -200); }\n    /**\n     *  Return a new ``int208`` type for %%v%%.\n     */\n    static int208(v) { return n(v, -208); }\n    /**\n     *  Return a new ``int216`` type for %%v%%.\n     */\n    static int216(v) { return n(v, -216); }\n    /**\n     *  Return a new ``int224`` type for %%v%%.\n     */\n    static int224(v) { return n(v, -224); }\n    /**\n     *  Return a new ``int232`` type for %%v%%.\n     */\n    static int232(v) { return n(v, -232); }\n    /**\n     *  Return a new ``int240`` type for %%v%%.\n     */\n    static int240(v) { return n(v, -240); }\n    /**\n     *  Return a new ``int248`` type for %%v%%.\n     */\n    static int248(v) { return n(v, -248); }\n    /**\n     *  Return a new ``int256`` type for %%v%%.\n     */\n    static int256(v) { return n(v, -256); }\n    /**\n     *  Return a new ``int256`` type for %%v%%.\n     */\n    static int(v) { return n(v, -256); }\n    /**\n     *  Return a new ``bytes1`` type for %%v%%.\n     */\n    static bytes1(v) { return b(v, 1); }\n    /**\n     *  Return a new ``bytes2`` type for %%v%%.\n     */\n    static bytes2(v) { return b(v, 2); }\n    /**\n     *  Return a new ``bytes3`` type for %%v%%.\n     */\n    static bytes3(v) { return b(v, 3); }\n    /**\n     *  Return a new ``bytes4`` type for %%v%%.\n     */\n    static bytes4(v) { return b(v, 4); }\n    /**\n     *  Return a new ``bytes5`` type for %%v%%.\n     */\n    static bytes5(v) { return b(v, 5); }\n    /**\n     *  Return a new ``bytes6`` type for %%v%%.\n     */\n    static bytes6(v) { return b(v, 6); }\n    /**\n     *  Return a new ``bytes7`` type for %%v%%.\n     */\n    static bytes7(v) { return b(v, 7); }\n    /**\n     *  Return a new ``bytes8`` type for %%v%%.\n     */\n    static bytes8(v) { return b(v, 8); }\n    /**\n     *  Return a new ``bytes9`` type for %%v%%.\n     */\n    static bytes9(v) { return b(v, 9); }\n    /**\n     *  Return a new ``bytes10`` type for %%v%%.\n     */\n    static bytes10(v) { return b(v, 10); }\n    /**\n     *  Return a new ``bytes11`` type for %%v%%.\n     */\n    static bytes11(v) { return b(v, 11); }\n    /**\n     *  Return a new ``bytes12`` type for %%v%%.\n     */\n    static bytes12(v) { return b(v, 12); }\n    /**\n     *  Return a new ``bytes13`` type for %%v%%.\n     */\n    static bytes13(v) { return b(v, 13); }\n    /**\n     *  Return a new ``bytes14`` type for %%v%%.\n     */\n    static bytes14(v) { return b(v, 14); }\n    /**\n     *  Return a new ``bytes15`` type for %%v%%.\n     */\n    static bytes15(v) { return b(v, 15); }\n    /**\n     *  Return a new ``bytes16`` type for %%v%%.\n     */\n    static bytes16(v) { return b(v, 16); }\n    /**\n     *  Return a new ``bytes17`` type for %%v%%.\n     */\n    static bytes17(v) { return b(v, 17); }\n    /**\n     *  Return a new ``bytes18`` type for %%v%%.\n     */\n    static bytes18(v) { return b(v, 18); }\n    /**\n     *  Return a new ``bytes19`` type for %%v%%.\n     */\n    static bytes19(v) { return b(v, 19); }\n    /**\n     *  Return a new ``bytes20`` type for %%v%%.\n     */\n    static bytes20(v) { return b(v, 20); }\n    /**\n     *  Return a new ``bytes21`` type for %%v%%.\n     */\n    static bytes21(v) { return b(v, 21); }\n    /**\n     *  Return a new ``bytes22`` type for %%v%%.\n     */\n    static bytes22(v) { return b(v, 22); }\n    /**\n     *  Return a new ``bytes23`` type for %%v%%.\n     */\n    static bytes23(v) { return b(v, 23); }\n    /**\n     *  Return a new ``bytes24`` type for %%v%%.\n     */\n    static bytes24(v) { return b(v, 24); }\n    /**\n     *  Return a new ``bytes25`` type for %%v%%.\n     */\n    static bytes25(v) { return b(v, 25); }\n    /**\n     *  Return a new ``bytes26`` type for %%v%%.\n     */\n    static bytes26(v) { return b(v, 26); }\n    /**\n     *  Return a new ``bytes27`` type for %%v%%.\n     */\n    static bytes27(v) { return b(v, 27); }\n    /**\n     *  Return a new ``bytes28`` type for %%v%%.\n     */\n    static bytes28(v) { return b(v, 28); }\n    /**\n     *  Return a new ``bytes29`` type for %%v%%.\n     */\n    static bytes29(v) { return b(v, 29); }\n    /**\n     *  Return a new ``bytes30`` type for %%v%%.\n     */\n    static bytes30(v) { return b(v, 30); }\n    /**\n     *  Return a new ``bytes31`` type for %%v%%.\n     */\n    static bytes31(v) { return b(v, 31); }\n    /**\n     *  Return a new ``bytes32`` type for %%v%%.\n     */\n    static bytes32(v) { return b(v, 32); }\n    /**\n     *  Return a new ``address`` type for %%v%%.\n     */\n    static address(v) { return new Typed(_gaurd, \"address\", v); }\n    /**\n     *  Return a new ``bool`` type for %%v%%.\n     */\n    static bool(v) { return new Typed(_gaurd, \"bool\", !!v); }\n    /**\n     *  Return a new ``bytes`` type for %%v%%.\n     */\n    static bytes(v) { return new Typed(_gaurd, \"bytes\", v); }\n    /**\n     *  Return a new ``string`` type for %%v%%.\n     */\n    static string(v) { return new Typed(_gaurd, \"string\", v); }\n    /**\n     *  Return a new ``array`` type for %%v%%, allowing %%dynamic%% length.\n     */\n    static array(v, dynamic) {\n        throw new Error(\"not implemented yet\");\n        return new Typed(_gaurd, \"array\", v, dynamic);\n    }\n    /**\n     *  Return a new ``tuple`` type for %%v%%, with the optional %%name%%.\n     */\n    static tuple(v, name) {\n        throw new Error(\"not implemented yet\");\n        return new Typed(_gaurd, \"tuple\", v, name);\n    }\n    /**\n     *  Return a new ``uint8`` type for %%v%%.\n     */\n    static overrides(v) {\n        return new Typed(_gaurd, \"overrides\", Object.assign({}, v));\n    }\n    /**\n     *  Returns true only if %%value%% is a [[Typed]] instance.\n     */\n    static isTyped(value) {\n        return (value\n            && typeof (value) === \"object\"\n            && \"_typedSymbol\" in value\n            && value._typedSymbol === _typedSymbol);\n    }\n    /**\n     *  If the value is a [[Typed]] instance, validates the underlying value\n     *  and returns it, otherwise returns value directly.\n     *\n     *  This is useful for functions that with to accept either a [[Typed]]\n     *  object or values.\n     */\n    static dereference(value, type) {\n        if (Typed.isTyped(value)) {\n            if (value.type !== type) {\n                throw new Error(`invalid type: expecetd ${type}, got ${value.type}`);\n            }\n            return value.value;\n        }\n        return value;\n    }\n}\n//# sourceMappingURL=typed.js.map"],"names":[],"mappings":"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AAG;AAAE,WAAO,EAAE,GAAG,EAAE;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAInC,OAAO,OAAO,GAAG;AAAE,WAAO,EAAE,GAAG,EAAE;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAInC,OAAO,OAAO,GAAG;AAAE,WAAO,EAAE,GAAG,EAAE;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAInC,OAAO,OAAO,GAAG;AAAE,WAAO,EAAE,GAAG,EAAE;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAInC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,EAIrC,OAAO,QAAQ,GAAG;AAAE,WAAO,EAAE,GAAG,GAAG;AAAA,EAAE;AAAA;AAAA;AAAA;AAAA,E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","x_google_ignoreList":[0]}

package/dist/es/standards-sdk.es57.js

@@ -1,21 +1,177 @@
-import { Typed } from "./standards-sdk.es68.js";
-import { Coder } from "./standards-sdk.es54.js";
-class BooleanCoder extends Coder {
-  constructor(localName) {
-    super("bool", "bool", localName, false);
+import { number, exists, bytes, output } from "./standards-sdk.es63.js";
+import { rotlSH, rotlSL, rotlBH, rotlBL, split } from "./standards-sdk.es64.js";
+import { wrapConstructor, Hash, u32, toBytes } from "./standards-sdk.es65.js";
+const [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];
+const _0n = /* @__PURE__ */ BigInt(0);
+const _1n = /* @__PURE__ */ BigInt(1);
+const _2n = /* @__PURE__ */ BigInt(2);
+const _7n = /* @__PURE__ */ BigInt(7);
+const _256n = /* @__PURE__ */ BigInt(256);
+const _0x71n = /* @__PURE__ */ BigInt(113);
+for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+  [x, y] = [y, (2 * x + 3 * y) % 5];
+  SHA3_PI.push(2 * (5 * y + x));
+  SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+  let t = _0n;
+  for (let j = 0; j < 7; j++) {
+    R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+    if (R & _2n)
+      t ^= _1n << (_1n << /* @__PURE__ */ BigInt(j)) - _1n;
   }
-  defaultValue() {
-    return false;
+  _SHA3_IOTA.push(t);
+}
+const [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);
+const rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
+const rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
+function keccakP(s, rounds = 24) {
+  const B = new Uint32Array(5 * 2);
+  for (let round = 24 - rounds; round < 24; round++) {
+    for (let x = 0; x < 10; x++)
+      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+    for (let x = 0; x < 10; x += 2) {
+      const idx1 = (x + 8) % 10;
+      const idx0 = (x + 2) % 10;
+      const B0 = B[idx0];
+      const B1 = B[idx0 + 1];
+      const Th = rotlH(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      for (let y = 0; y < 50; y += 10) {
+        s[x + y] ^= Th;
+        s[x + y + 1] ^= Tl;
+      }
+    }
+    let curH = s[2];
+    let curL = s[3];
+    for (let t = 0; t < 24; t++) {
+      const shift = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift);
+      const Tl = rotlL(curH, curL, shift);
+      const PI = SHA3_PI[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
+    }
+    for (let y = 0; y < 50; y += 10) {
+      for (let x = 0; x < 10; x++)
+        B[x] = s[y + x];
+      for (let x = 0; x < 10; x++)
+        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+    }
+    s[0] ^= SHA3_IOTA_H[round];
+    s[1] ^= SHA3_IOTA_L[round];
+  }
+  B.fill(0);
+}
+class Keccak extends Hash {
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+    super();
+    this.blockLen = blockLen;
+    this.suffix = suffix;
+    this.outputLen = outputLen;
+    this.enableXOF = enableXOF;
+    this.rounds = rounds;
+    this.pos = 0;
+    this.posOut = 0;
+    this.finished = false;
+    this.destroyed = false;
+    number(outputLen);
+    if (0 >= this.blockLen || this.blockLen >= 200)
+      throw new Error("Sha3 supports only keccak-f1600 function");
+    this.state = new Uint8Array(200);
+    this.state32 = u32(this.state);
+  }
+  keccak() {
+    keccakP(this.state32, this.rounds);
+    this.posOut = 0;
+    this.pos = 0;
+  }
+  update(data) {
+    exists(this);
+    const { blockLen, state } = this;
+    data = toBytes(data);
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      for (let i = 0; i < take; i++)
+        state[this.pos++] ^= data[pos++];
+      if (this.pos === blockLen)
+        this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = true;
+    const { state, suffix, pos, blockLen } = this;
+    state[pos] ^= suffix;
+    if ((suffix & 128) !== 0 && pos === blockLen - 1)
+      this.keccak();
+    state[blockLen - 1] ^= 128;
+    this.keccak();
+  }
+  writeInto(out) {
+    exists(this, false);
+    bytes(out);
+    this.finish();
+    const bufferOut = this.state;
+    const { blockLen } = this;
+    for (let pos = 0, len = out.length; pos < len; ) {
+      if (this.posOut >= blockLen)
+        this.keccak();
+      const take = Math.min(blockLen - this.posOut, len - pos);
+      out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+      this.posOut += take;
+      pos += take;
+    }
+    return out;
+  }
+  xofInto(out) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible for this instance");
+    return this.writeInto(out);
+  }
+  xof(bytes2) {
+    number(bytes2);
+    return this.xofInto(new Uint8Array(bytes2));
+  }
+  digestInto(out) {
+    output(out, this);
+    if (this.finished)
+      throw new Error("digest() was already called");
+    this.writeInto(out);
+    this.destroy();
+    return out;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
   }
-  encode(writer, _value) {
-    const value = Typed.dereference(_value, "bool");
-    return writer.writeValue(value ? 1 : 0);
+  destroy() {
+    this.destroyed = true;
+    this.state.fill(0);
   }
-  decode(reader) {
-    return !!reader.readValue();
+  _cloneInto(to) {
+    const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+    to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+    to.state32.set(this.state32);
+    to.pos = this.pos;
+    to.posOut = this.posOut;
+    to.finished = this.finished;
+    to.rounds = rounds;
+    to.suffix = suffix;
+    to.outputLen = outputLen;
+    to.enableXOF = enableXOF;
+    to.destroyed = this.destroyed;
+    return to;
   }
 }
+const gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
+const keccak_256 = /* @__PURE__ */ gen(1, 136, 256 / 8);
 export {
-  BooleanCoder
+  Keccak,
+  keccakP,
+  keccak_256
 };
 //# sourceMappingURL=standards-sdk.es57.js.map

package/dist/es/standards-sdk.es57.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es57.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/boolean.js"],"sourcesContent":["import { Typed } from \"../typed.js\";\nimport { Coder } from \"./abstract-coder.js\";\n/**\n *  @_ignore\n */\nexport class BooleanCoder extends Coder {\n    constructor(localName) {\n        super(\"bool\", \"bool\", localName, false);\n    }\n    defaultValue() {\n        return false;\n    }\n    encode(writer, _value) {\n        const value = Typed.dereference(_value, \"bool\");\n        return writer.writeValue(value ? 1 : 0);\n    }\n    decode(reader) {\n        return !!reader.readValue();\n    }\n}\n//# sourceMappingURL=boolean.js.map"],"names":[],"mappings":";;AAKO,MAAM,qBAAqB,MAAM;AAAA,EACpC,YAAY,WAAW;AACnB,UAAM,QAAQ,QAAQ,WAAW,KAAK;AAAA,EAC9C;AAAA,EACI,eAAe;AACX,WAAO;AAAA,EACf;AAAA,EACI,OAAO,QAAQ,QAAQ;AACnB,UAAM,QAAQ,MAAM,YAAY,QAAQ,MAAM;AAC9C,WAAO,OAAO,WAAW,QAAQ,IAAI,CAAC;AAAA,EAC9C;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,CAAC,CAAC,OAAO,UAAW;AAAA,EACnC;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es57.js","sources":["../../node_modules/@noble/hashes/esm/sha3.js"],"sourcesContent":["import { bytes, exists, number, output } from './_assert.js';\nimport { rotlBH, rotlBL, rotlSH, rotlSL, split } from './_u64.js';\nimport { Hash, u32, toBytes, wrapConstructor, wrapXOFConstructorWithOpts, } from './utils.js';\n// SHA3 (keccak) is based on a new design: basically, the internal state is bigger than output size.\n// It's called a sponge function.\n// Various per round constants calculations\nconst [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [[], [], []];\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nconst _2n = /* @__PURE__ */ BigInt(2);\nconst _7n = /* @__PURE__ */ BigInt(7);\nconst _256n = /* @__PURE__ */ BigInt(256);\nconst _0x71n = /* @__PURE__ */ BigInt(0x71);\nfor (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {\n    // Pi\n    [x, y] = [y, (2 * x + 3 * y) % 5];\n    SHA3_PI.push(2 * (5 * y + x));\n    // Rotational\n    SHA3_ROTL.push((((round + 1) * (round + 2)) / 2) % 64);\n    // Iota\n    let t = _0n;\n    for (let j = 0; j < 7; j++) {\n        R = ((R << _1n) ^ ((R >> _7n) * _0x71n)) % _256n;\n        if (R & _2n)\n            t ^= _1n << ((_1n << /* @__PURE__ */ BigInt(j)) - _1n);\n    }\n    _SHA3_IOTA.push(t);\n}\nconst [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split(_SHA3_IOTA, true);\n// Left rotation (without 0, 32, 64)\nconst rotlH = (h, l, s) => (s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s));\nconst rotlL = (h, l, s) => (s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s));\n// Same as keccakf1600, but allows to skip some rounds\nexport function keccakP(s, rounds = 24) {\n    const B = new Uint32Array(5 * 2);\n    // NOTE: all indices are x2 since we store state as u32 instead of u64 (bigints to slow in js)\n    for (let round = 24 - rounds; round < 24; round++) {\n        // Theta θ\n        for (let x = 0; x < 10; x++)\n            B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];\n        for (let x = 0; x < 10; x += 2) {\n            const idx1 = (x + 8) % 10;\n            const idx0 = (x + 2) % 10;\n            const B0 = B[idx0];\n            const B1 = B[idx0 + 1];\n            const Th = rotlH(B0, B1, 1) ^ B[idx1];\n            const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];\n            for (let y = 0; y < 50; y += 10) {\n                s[x + y] ^= Th;\n                s[x + y + 1] ^= Tl;\n            }\n        }\n        // Rho (ρ) and Pi (π)\n        let curH = s[2];\n        let curL = s[3];\n        for (let t = 0; t < 24; t++) {\n            const shift = SHA3_ROTL[t];\n            const Th = rotlH(curH, curL, shift);\n            const Tl = rotlL(curH, curL, shift);\n            const PI = SHA3_PI[t];\n            curH = s[PI];\n            curL = s[PI + 1];\n            s[PI] = Th;\n            s[PI + 1] = Tl;\n        }\n        // Chi (χ)\n        for (let y = 0; y < 50; y += 10) {\n            for (let x = 0; x < 10; x++)\n                B[x] = s[y + x];\n            for (let x = 0; x < 10; x++)\n                s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];\n        }\n        // Iota (ι)\n        s[0] ^= SHA3_IOTA_H[round];\n        s[1] ^= SHA3_IOTA_L[round];\n    }\n    B.fill(0);\n}\nexport class Keccak extends Hash {\n    // NOTE: we accept arguments in bytes instead of bits here.\n    constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {\n        super();\n        this.blockLen = blockLen;\n        this.suffix = suffix;\n        this.outputLen = outputLen;\n        this.enableXOF = enableXOF;\n        this.rounds = rounds;\n        this.pos = 0;\n        this.posOut = 0;\n        this.finished = false;\n        this.destroyed = false;\n        // Can be passed from user as dkLen\n        number(outputLen);\n        // 1600 = 5x5 matrix of 64bit.  1600 bits === 200 bytes\n        if (0 >= this.blockLen || this.blockLen >= 200)\n            throw new Error('Sha3 supports only keccak-f1600 function');\n        this.state = new Uint8Array(200);\n        this.state32 = u32(this.state);\n    }\n    keccak() {\n        keccakP(this.state32, this.rounds);\n        this.posOut = 0;\n        this.pos = 0;\n    }\n    update(data) {\n        exists(this);\n        const { blockLen, state } = this;\n        data = toBytes(data);\n        const len = data.length;\n        for (let pos = 0; pos < len;) {\n            const take = Math.min(blockLen - this.pos, len - pos);\n            for (let i = 0; i < take; i++)\n                state[this.pos++] ^= data[pos++];\n            if (this.pos === blockLen)\n                this.keccak();\n        }\n        return this;\n    }\n    finish() {\n        if (this.finished)\n            return;\n        this.finished = true;\n        const { state, suffix, pos, blockLen } = this;\n        // Do the padding\n        state[pos] ^= suffix;\n        if ((suffix & 0x80) !== 0 && pos === blockLen - 1)\n            this.keccak();\n        state[blockLen - 1] ^= 0x80;\n        this.keccak();\n    }\n    writeInto(out) {\n        exists(this, false);\n        bytes(out);\n        this.finish();\n        const bufferOut = this.state;\n        const { blockLen } = this;\n        for (let pos = 0, len = out.length; pos < len;) {\n            if (this.posOut >= blockLen)\n                this.keccak();\n            const take = Math.min(blockLen - this.posOut, len - pos);\n            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);\n            this.posOut += take;\n            pos += take;\n        }\n        return out;\n    }\n    xofInto(out) {\n        // Sha3/Keccak usage with XOF is probably mistake, only SHAKE instances can do XOF\n        if (!this.enableXOF)\n            throw new Error('XOF is not possible for this instance');\n        return this.writeInto(out);\n    }\n    xof(bytes) {\n        number(bytes);\n        return this.xofInto(new Uint8Array(bytes));\n    }\n    digestInto(out) {\n        output(out, this);\n        if (this.finished)\n            throw new Error('digest() was already called');\n        this.writeInto(out);\n        this.destroy();\n        return out;\n    }\n    digest() {\n        return this.digestInto(new Uint8Array(this.outputLen));\n    }\n    destroy() {\n        this.destroyed = true;\n        this.state.fill(0);\n    }\n    _cloneInto(to) {\n        const { blockLen, suffix, outputLen, rounds, enableXOF } = this;\n        to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, rounds));\n        to.state32.set(this.state32);\n        to.pos = this.pos;\n        to.posOut = this.posOut;\n        to.finished = this.finished;\n        to.rounds = rounds;\n        // Suffix can change in cSHAKE\n        to.suffix = suffix;\n        to.outputLen = outputLen;\n        to.enableXOF = enableXOF;\n        to.destroyed = this.destroyed;\n        return to;\n    }\n}\nconst gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));\nexport const sha3_224 = /* @__PURE__ */ gen(0x06, 144, 224 / 8);\n/**\n * SHA3-256 hash function\n * @param message - that would be hashed\n */\nexport const sha3_256 = /* @__PURE__ */ gen(0x06, 136, 256 / 8);\nexport const sha3_384 = /* @__PURE__ */ gen(0x06, 104, 384 / 8);\nexport const sha3_512 = /* @__PURE__ */ gen(0x06, 72, 512 / 8);\nexport const keccak_224 = /* @__PURE__ */ gen(0x01, 144, 224 / 8);\n/**\n * keccak-256 hash function. Different from SHA3-256.\n * @param message - that would be hashed\n */\nexport const keccak_256 = /* @__PURE__ */ gen(0x01, 136, 256 / 8);\nexport const keccak_384 = /* @__PURE__ */ gen(0x01, 104, 384 / 8);\nexport const keccak_512 = /* @__PURE__ */ gen(0x01, 72, 512 / 8);\nconst genShake = (suffix, blockLen, outputLen) => wrapXOFConstructorWithOpts((opts = {}) => new Keccak(blockLen, suffix, opts.dkLen === undefined ? outputLen : opts.dkLen, true));\nexport const shake128 = /* @__PURE__ */ genShake(0x1f, 168, 128 / 8);\nexport const shake256 = /* @__PURE__ */ genShake(0x1f, 136, 256 / 8);\n//# sourceMappingURL=sha3.js.map"],"names":["bytes"],"mappings":";;;AAMA,MAAM,CAAC,SAAS,WAAW,UAAU,IAAI,CAAC,CAAE,GAAE,CAAE,GAAE,EAAE;AACpD,MAAM,MAAsB,uBAAO,CAAC;AACpC,MAAM,MAAsB,uBAAO,CAAC;AACpC,MAAM,MAAsB,uBAAO,CAAC;AACpC,MAAM,MAAsB,uBAAO,CAAC;AACpC,MAAM,QAAwB,uBAAO,GAAG;AACxC,MAAM,SAAyB,uBAAO,GAAI;AAC1C,SAAS,QAAQ,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,GAAG,QAAQ,IAAI,SAAS;AAE5D,GAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,IAAI,KAAK,CAAC;AAChC,UAAQ,KAAK,KAAK,IAAI,IAAI,EAAE;AAE5B,YAAU,MAAQ,QAAQ,MAAM,QAAQ,KAAM,IAAK,EAAE;AAErD,MAAI,IAAI;AACR,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AACxB,SAAM,KAAK,OAAS,KAAK,OAAO,UAAW;AAC3C,QAAI,IAAI;AACJ,WAAK,QAAS,OAAuB,uBAAO,CAAC,KAAK;AAAA,EAC9D;AACI,aAAW,KAAK,CAAC;AACrB;AACA,MAAM,CAAC,aAAa,WAAW,IAAoB,sBAAM,YAAY,IAAI;AAEzE,MAAM,QAAQ,CAAC,GAAG,GAAG,MAAO,IAAI,KAAK,OAAO,GAAG,GAAG,CAAC,IAAI,OAAO,GAAG,GAAG,CAAC;AACrE,MAAM,QAAQ,CAAC,GAAG,GAAG,MAAO,IAAI,KAAK,OAAO,GAAG,GAAG,CAAC,IAAI,OAAO,GAAG,GAAG,CAAC;AAE9D,SAAS,QAAQ,GAAG,SAAS,IAAI;AACpC,QAAM,IAAI,IAAI,YAAY,IAAI,CAAC;AAE/B,WAAS,QAAQ,KAAK,QAAQ,QAAQ,IAAI,SAAS;AAE/C,aAAS,IAAI,GAAG,IAAI,IAAI;AACpB,QAAE,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE;AAC9D,aAAS,IAAI,GAAG,IAAI,IAAI,KAAK,GAAG;AAC5B,YAAM,QAAQ,IAAI,KAAK;AACvB,YAAM,QAAQ,IAAI,KAAK;AACvB,YAAM,KAAK,EAAE,IAAI;AACjB,YAAM,KAAK,EAAE,OAAO,CAAC;AACrB,YAAM,KAAK,MAAM,IAAI,IAAI,CAAC,IAAI,EAAE,IAAI;AACpC,YAAM,KAAK,MAAM,IAAI,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC;AACxC,eAAS,IAAI,GAAG,IAAI,IAAI,KAAK,IAAI;AAC7B,UAAE,IAAI,CAAC,KAAK;AACZ,UAAE,IAAI,IAAI,CAAC,KAAK;AAAA,MAChC;AAAA,IACA;AAEQ,QAAI,OAAO,EAAE,CAAC;AACd,QAAI,OAAO,EAAE,CAAC;AACd,aAAS,IAAI,GAAG,IAAI,IAAI,KAAK;AACzB,YAAM,QAAQ,UAAU,CAAC;AACzB,YAAM,KAAK,MAAM,MAAM,MAAM,KAAK;AAClC,YAAM,KAAK,MAAM,MAAM,MAAM,KAAK;AAClC,YAAM,KAAK,QAAQ,CAAC;AACpB,aAAO,EAAE,EAAE;AACX,aAAO,EAAE,KAAK,CAAC;AACf,QAAE,EAAE,IAAI;AACR,QAAE,KAAK,CAAC,IAAI;AAAA,IACxB;AAEQ,aAAS,IAAI,GAAG,IAAI,IAAI,KAAK,IAAI;AAC7B,eAAS,IAAI,GAAG,IAAI,IAAI;AACpB,UAAE,CAAC,IAAI,EAAE,IAAI,CAAC;AAClB,eAAS,IAAI,GAAG,IAAI,IAAI;AACpB,UAAE,IAAI,CAAC,KAAK,CAAC,GAAG,IAAI,KAAK,EAAE,IAAI,GAAG,IAAI,KAAK,EAAE;AAAA,IAC7D;AAEQ,MAAE,CAAC,KAAK,YAAY,KAAK;AACzB,MAAE,CAAC,KAAK,YAAY,KAAK;AAAA,EACjC;AACI,IAAE,KAAK,CAAC;AACZ;AACO,MAAM,eAAe,KAAK;AAAA;AAAA,EAE7B,YAAY,UAAU,QAAQ,WAAW,YAAY,OAAO,SAAS,IAAI;AACrE,UAAO;AACP,SAAK,WAAW;AAChB,SAAK,SAAS;AACd,SAAK,YAAY;AACjB,SAAK,YAAY;AACjB,SAAK,SAAS;AACd,SAAK,MAAM;AACX,SAAK,SAAS;AACd,SAAK,WAAW;AAChB,SAAK,YAAY;AAEjB,WAAO,SAAS;AAEhB,QAAI,KAAK,KAAK,YAAY,KAAK,YAAY;AACvC,YAAM,IAAI,MAAM,0CAA0C;AAC9D,SAAK,QAAQ,IAAI,WAAW,GAAG;AAC/B,SAAK,UAAU,IAAI,KAAK,KAAK;AAAA,EACrC;AAAA,EACI,SAAS;AACL,YAAQ,KAAK,SAAS,KAAK,MAAM;AACjC,SAAK,SAAS;AACd,SAAK,MAAM;AAAA,EACnB;AAAA,EACI,OAAO,MAAM;AACT,WAAO,IAAI;AACX,UAAM,EAAE,UAAU,MAAK,IAAK;AAC5B,WAAO,QAAQ,IAAI;AACnB,UAAM,MAAM,KAAK;AACjB,aAAS,MAAM,GAAG,MAAM,OAAM;AAC1B,YAAM,OAAO,KAAK,IAAI,WAAW,KAAK,KAAK,MAAM,GAAG;AACpD,eAAS,IAAI,GAAG,IAAI,MAAM;AACtB,cAAM,KAAK,KAAK,KAAK,KAAK,KAAK;AACnC,UAAI,KAAK,QAAQ;AACb,aAAK,OAAQ;AAAA,IAC7B;AACQ,WAAO;AAAA,EACf;AAAA,EACI,SAAS;AACL,QAAI,KAAK;AACL;AACJ,SAAK,WAAW;AAChB,UAAM,EAAE,OAAO,QAAQ,KAAK,SAAU,IAAG;AAEzC,UAAM,GAAG,KAAK;AACd,SAAK,SAAS,SAAU,KAAK,QAAQ,WAAW;AAC5C,WAAK,OAAQ;AACjB,UAAM,WAAW,CAAC,KAAK;AACvB,SAAK,OAAQ;AAAA,EACrB;AAAA,EACI,UAAU,KAAK;AACX,WAAO,MAAM,KAAK;AAClB,UAAM,GAAG;AACT,SAAK,OAAQ;AACb,UAAM,YAAY,KAAK;AACvB,UAAM,EAAE,SAAQ,IAAK;AACrB,aAAS,MAAM,GAAG,MAAM,IAAI,QAAQ,MAAM,OAAM;AAC5C,UAAI,KAAK,UAAU;AACf,aAAK,OAAQ;AACjB,YAAM,OAAO,KAAK,IAAI,WAAW,KAAK,QAAQ,MAAM,GAAG;AACvD,UAAI,IAAI,UAAU,SAAS,KAAK,QAAQ,KAAK,SAAS,IAAI,GAAG,GAAG;AAChE,WAAK,UAAU;AACf,aAAO;AAAA,IACnB;AACQ,WAAO;AAAA,EACf;AAAA,EACI,QAAQ,KAAK;AAET,QAAI,CAAC,KAAK;AACN,YAAM,IAAI,MAAM,uCAAuC;AAC3D,WAAO,KAAK,UAAU,GAAG;AAAA,EACjC;AAAA,EACI,IAAIA,QAAO;AACP,WAAOA,MAAK;AACZ,WAAO,KAAK,QAAQ,IAAI,WAAWA,MAAK,CAAC;AAAA,EACjD;AAAA,EACI,WAAW,KAAK;AACZ,WAAO,KAAK,IAAI;AAChB,QAAI,KAAK;AACL,YAAM,IAAI,MAAM,6BAA6B;AACjD,SAAK,UAAU,GAAG;AAClB,SAAK,QAAS;AACd,WAAO;AAAA,EACf;AAAA,EACI,SAAS;AACL,WAAO,KAAK,WAAW,IAAI,WAAW,KAAK,SAAS,CAAC;AAAA,EAC7D;AAAA,EACI,UAAU;AACN,SAAK,YAAY;AACjB,SAAK,MAAM,KAAK,CAAC;AAAA,EACzB;AAAA,EACI,WAAW,IAAI;AACX,UAAM,EAAE,UAAU,QAAQ,WAAW,QAAQ,UAAS,IAAK;AAC3D,WAAO,KAAK,IAAI,OAAO,UAAU,QAAQ,WAAW,WAAW,MAAM;AACrE,OAAG,QAAQ,IAAI,KAAK,OAAO;AAC3B,OAAG,MAAM,KAAK;AACd,OAAG,SAAS,KAAK;AACjB,OAAG,WAAW,KAAK;AACnB,OAAG,SAAS;AAEZ,OAAG,SAAS;AACZ,OAAG,YAAY;AACf,OAAG,YAAY;AACf,OAAG,YAAY,KAAK;AACpB,WAAO;AAAA,EACf;AACA;AACA,MAAM,MAAM,CAAC,QAAQ,UAAU,cAAc,gBAAgB,MAAM,IAAI,OAAO,UAAU,QAAQ,SAAS,CAAC;AAc9F,MAAC,aAA6B,oBAAI,GAAM,KAAK,MAAM,CAAC;","x_google_ignoreList":[0]}