@hashgraphonline/standards-sdk 0.0.84 → 0.0.86

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es107.js","sources":["../../node_modules/axios/lib/helpers/resolveConfig.js"],"sourcesContent":["import platform from \"../platform/index.js\";\nimport utils from \"../utils.js\";\nimport isURLSameOrigin from \"./isURLSameOrigin.js\";\nimport cookies from \"./cookies.js\";\nimport buildFullPath from \"../core/buildFullPath.js\";\nimport mergeConfig from \"../core/mergeConfig.js\";\nimport AxiosHeaders from \"../core/AxiosHeaders.js\";\nimport buildURL from \"./buildURL.js\";\n\nexport default (config) => {\n  const newConfig = mergeConfig({}, config);\n\n  let {data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth} = newConfig;\n\n  newConfig.headers = headers = AxiosHeaders.from(headers);\n\n  newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url, newConfig.allowAbsoluteUrls), config.params, config.paramsSerializer);\n\n  // HTTP basic authentication\n  if (auth) {\n    headers.set('Authorization', 'Basic ' +\n      btoa((auth.username || '') + ':' + (auth.password ? unescape(encodeURIComponent(auth.password)) : ''))\n    );\n  }\n\n  let contentType;\n\n  if (utils.isFormData(data)) {\n    if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {\n      headers.setContentType(undefined); // Let the browser set it\n    } else if ((contentType = headers.getContentType()) !== false) {\n      // fix semicolon duplication issue for ReactNative FormData implementation\n      const [type, ...tokens] = contentType ? contentType.split(';').map(token => token.trim()).filter(Boolean) : [];\n      headers.setContentType([type || 'multipart/form-data', ...tokens].join('; '));\n    }\n  }\n\n  // Add xsrf header\n  // This is only done if running in a standard browser environment.\n  // Specifically not if we're in a web worker, or react-native.\n\n  if (platform.hasStandardBrowserEnv) {\n    withXSRFToken && utils.isFunction(withXSRFToken) && (withXSRFToken = withXSRFToken(newConfig));\n\n    if (withXSRFToken || (withXSRFToken !== false && isURLSameOrigin(newConfig.url))) {\n      // Add xsrf header\n      const xsrfValue = xsrfHeaderName && xsrfCookieName && cookies.read(xsrfCookieName);\n\n      if (xsrfValue) {\n        headers.set(xsrfHeaderName, xsrfValue);\n      }\n    }\n  }\n\n  return newConfig;\n}\n\n"],"names":[],"mappings":";;;;;;;;AASA,MAAe,gBAAA,CAAC,WAAW;AACzB,QAAM,YAAY,YAAY,CAAE,GAAE,MAAM;AAExC,MAAI,EAAC,MAAM,eAAe,gBAAgB,gBAAgB,SAAS,KAAI,IAAI;AAE3E,YAAU,UAAU,UAAU,aAAa,KAAK,OAAO;AAEvD,YAAU,MAAM,SAAS,cAAc,UAAU,SAAS,UAAU,KAAK,UAAU,iBAAiB,GAAG,OAAO,QAAQ,OAAO,gBAAgB;AAG7I,MAAI,MAAM;AACR,YAAQ;AAAA,MAAI;AAAA,MAAiB,WAC3B,MAAM,KAAK,YAAY,MAAM,OAAO,KAAK,WAAW,SAAS,mBAAmB,KAAK,QAAQ,CAAC,IAAI,GAAG;AAAA,IACtG;AAAA,EACL;AAEE,MAAI;AAEJ,MAAI,MAAM,WAAW,IAAI,GAAG;AAC1B,QAAI,SAAS,yBAAyB,SAAS,gCAAgC;AAC7E,cAAQ,eAAe,MAAS;AAAA,IACjC,YAAW,cAAc,QAAQ,eAAc,OAAQ,OAAO;AAE7D,YAAM,CAAC,MAAM,GAAG,MAAM,IAAI,cAAc,YAAY,MAAM,GAAG,EAAE,IAAI,WAAS,MAAM,KAAI,CAAE,EAAE,OAAO,OAAO,IAAI,CAAE;AAC9G,cAAQ,eAAe,CAAC,QAAQ,uBAAuB,GAAG,MAAM,EAAE,KAAK,IAAI,CAAC;AAAA,IAClF;AAAA,EACA;AAME,MAAI,SAAS,uBAAuB;AAClC,qBAAiB,MAAM,WAAW,aAAa,MAAM,gBAAgB,cAAc,SAAS;AAE5F,QAAI,iBAAkB,kBAAkB,SAAS,gBAAgB,UAAU,GAAG,GAAI;AAEhF,YAAM,YAAY,kBAAkB,kBAAkB,QAAQ,KAAK,cAAc;AAEjF,UAAI,WAAW;AACb,gBAAQ,IAAI,gBAAgB,SAAS;AAAA,MAC7C;AAAA,IACA;AAAA,EACA;AAEE,SAAO;AACT;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es107.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.es108.js

@@ -1,40 +1,146 @@
-import CanceledError from "./standards-sdk.es38.js";
-import AxiosError from "./standards-sdk.es43.js";
-import utils from "./standards-sdk.es32.js";
-const composeSignals = (signals, timeout) => {
-  const { length } = signals = signals ? signals.filter(Boolean) : [];
-  if (timeout || length) {
-    let controller = new AbortController();
-    let aborted;
-    const onabort = function(reason) {
-      if (!aborted) {
-        aborted = true;
-        unsubscribe();
-        const err = reason instanceof Error ? reason : this.reason;
-        controller.abort(err instanceof AxiosError ? err : new CanceledError(err instanceof Error ? err.message : err));
+import { getBytes } from "./standards-sdk.es101.js";
+import { assertArgument } from "./standards-sdk.es100.js";
+function errorFunc(reason, offset, bytes, output, badCodepoint) {
+  assertArgument(false, `invalid codepoint at offset ${offset}; ${reason}`, "bytes", bytes);
+}
+function ignoreFunc(reason, offset, bytes, output, badCodepoint) {
+  if (reason === "BAD_PREFIX" || reason === "UNEXPECTED_CONTINUE") {
+    let i = 0;
+    for (let o = offset + 1; o < bytes.length; o++) {
+      if (bytes[o] >> 6 !== 2) {
+        break;
       }
-    };
-    let timer = timeout && setTimeout(() => {
-      timer = null;
-      onabort(new AxiosError(`timeout ${timeout} of ms exceeded`, AxiosError.ETIMEDOUT));
-    }, timeout);
-    const unsubscribe = () => {
-      if (signals) {
-        timer && clearTimeout(timer);
-        timer = null;
-        signals.forEach((signal2) => {
-          signal2.unsubscribe ? signal2.unsubscribe(onabort) : signal2.removeEventListener("abort", onabort);
-        });
-        signals = null;
+      i++;
+    }
+    return i;
+  }
+  if (reason === "OVERRUN") {
+    return bytes.length - offset - 1;
+  }
+  return 0;
+}
+function replaceFunc(reason, offset, bytes, output, badCodepoint) {
+  if (reason === "OVERLONG") {
+    assertArgument(typeof badCodepoint === "number", "invalid bad code point for replacement", "badCodepoint", badCodepoint);
+    output.push(badCodepoint);
+    return 0;
+  }
+  output.push(65533);
+  return ignoreFunc(reason, offset, bytes);
+}
+const Utf8ErrorFuncs = Object.freeze({
+  error: errorFunc,
+  ignore: ignoreFunc,
+  replace: replaceFunc
+});
+function getUtf8CodePoints(_bytes, onError) {
+  if (onError == null) {
+    onError = Utf8ErrorFuncs.error;
+  }
+  const bytes = getBytes(_bytes, "bytes");
+  const result = [];
+  let i = 0;
+  while (i < bytes.length) {
+    const c = bytes[i++];
+    if (c >> 7 === 0) {
+      result.push(c);
+      continue;
+    }
+    let extraLength = null;
+    let overlongMask = null;
+    if ((c & 224) === 192) {
+      extraLength = 1;
+      overlongMask = 127;
+    } else if ((c & 240) === 224) {
+      extraLength = 2;
+      overlongMask = 2047;
+    } else if ((c & 248) === 240) {
+      extraLength = 3;
+      overlongMask = 65535;
+    } else {
+      if ((c & 192) === 128) {
+        i += onError("UNEXPECTED_CONTINUE", i - 1, bytes, result);
+      } else {
+        i += onError("BAD_PREFIX", i - 1, bytes, result);
       }
-    };
-    signals.forEach((signal2) => signal2.addEventListener("abort", onabort));
-    const { signal } = controller;
-    signal.unsubscribe = () => utils.asap(unsubscribe);
-    return signal;
+      continue;
+    }
+    if (i - 1 + extraLength >= bytes.length) {
+      i += onError("OVERRUN", i - 1, bytes, result);
+      continue;
+    }
+    let res = c & (1 << 8 - extraLength - 1) - 1;
+    for (let j = 0; j < extraLength; j++) {
+      let nextChar = bytes[i];
+      if ((nextChar & 192) != 128) {
+        i += onError("MISSING_CONTINUE", i, bytes, result);
+        res = null;
+        break;
+      }
+      res = res << 6 | nextChar & 63;
+      i++;
+    }
+    if (res === null) {
+      continue;
+    }
+    if (res > 1114111) {
+      i += onError("OUT_OF_RANGE", i - 1 - extraLength, bytes, result, res);
+      continue;
+    }
+    if (res >= 55296 && res <= 57343) {
+      i += onError("UTF16_SURROGATE", i - 1 - extraLength, bytes, result, res);
+      continue;
+    }
+    if (res <= overlongMask) {
+      i += onError("OVERLONG", i - 1 - extraLength, bytes, result, res);
+      continue;
+    }
+    result.push(res);
   }
-};
+  return result;
+}
+function toUtf8Bytes(str, form) {
+  assertArgument(typeof str === "string", "invalid string value", "str", str);
+  let result = [];
+  for (let i = 0; i < str.length; i++) {
+    const c = str.charCodeAt(i);
+    if (c < 128) {
+      result.push(c);
+    } else if (c < 2048) {
+      result.push(c >> 6 | 192);
+      result.push(c & 63 | 128);
+    } else if ((c & 64512) == 55296) {
+      i++;
+      const c2 = str.charCodeAt(i);
+      assertArgument(i < str.length && (c2 & 64512) === 56320, "invalid surrogate pair", "str", str);
+      const pair = 65536 + ((c & 1023) << 10) + (c2 & 1023);
+      result.push(pair >> 18 | 240);
+      result.push(pair >> 12 & 63 | 128);
+      result.push(pair >> 6 & 63 | 128);
+      result.push(pair & 63 | 128);
+    } else {
+      result.push(c >> 12 | 224);
+      result.push(c >> 6 & 63 | 128);
+      result.push(c & 63 | 128);
+    }
+  }
+  return new Uint8Array(result);
+}
+function _toUtf8String(codePoints) {
+  return codePoints.map((codePoint) => {
+    if (codePoint <= 65535) {
+      return String.fromCharCode(codePoint);
+    }
+    codePoint -= 65536;
+    return String.fromCharCode((codePoint >> 10 & 1023) + 55296, (codePoint & 1023) + 56320);
+  }).join("");
+}
+function toUtf8String(bytes, onError) {
+  return _toUtf8String(getUtf8CodePoints(bytes, onError));
+}
 export {
-  composeSignals as default
+  Utf8ErrorFuncs,
+  toUtf8Bytes,
+  toUtf8String
 };
 //# sourceMappingURL=standards-sdk.es108.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es108.js","sources":["../../node_modules/axios/lib/helpers/composeSignals.js"],"sourcesContent":["import CanceledError from \"../cancel/CanceledError.js\";\nimport AxiosError from \"../core/AxiosError.js\";\nimport utils from '../utils.js';\n\nconst composeSignals = (signals, timeout) => {\n  const {length} = (signals = signals ? signals.filter(Boolean) : []);\n\n  if (timeout || length) {\n    let controller = new AbortController();\n\n    let aborted;\n\n    const onabort = function (reason) {\n      if (!aborted) {\n        aborted = true;\n        unsubscribe();\n        const err = reason instanceof Error ? reason : this.reason;\n        controller.abort(err instanceof AxiosError ? err : new CanceledError(err instanceof Error ? err.message : err));\n      }\n    }\n\n    let timer = timeout && setTimeout(() => {\n      timer = null;\n      onabort(new AxiosError(`timeout ${timeout} of ms exceeded`, AxiosError.ETIMEDOUT))\n    }, timeout)\n\n    const unsubscribe = () => {\n      if (signals) {\n        timer && clearTimeout(timer);\n        timer = null;\n        signals.forEach(signal => {\n          signal.unsubscribe ? signal.unsubscribe(onabort) : signal.removeEventListener('abort', onabort);\n        });\n        signals = null;\n      }\n    }\n\n    signals.forEach((signal) => signal.addEventListener('abort', onabort));\n\n    const {signal} = controller;\n\n    signal.unsubscribe = () => utils.asap(unsubscribe);\n\n    return signal;\n  }\n}\n\nexport default composeSignals;\n"],"names":["signal"],"mappings":";;;AAIK,MAAC,iBAAiB,CAAC,SAAS,YAAY;AAC3C,QAAM,EAAC,OAAM,IAAK,UAAU,UAAU,QAAQ,OAAO,OAAO,IAAI;AAEhE,MAAI,WAAW,QAAQ;AACrB,QAAI,aAAa,IAAI,gBAAiB;AAEtC,QAAI;AAEJ,UAAM,UAAU,SAAU,QAAQ;AAChC,UAAI,CAAC,SAAS;AACZ,kBAAU;AACV,oBAAa;AACb,cAAM,MAAM,kBAAkB,QAAQ,SAAS,KAAK;AACpD,mBAAW,MAAM,eAAe,aAAa,MAAM,IAAI,cAAc,eAAe,QAAQ,IAAI,UAAU,GAAG,CAAC;AAAA,MACtH;AAAA,IACA;AAEI,QAAI,QAAQ,WAAW,WAAW,MAAM;AACtC,cAAQ;AACR,cAAQ,IAAI,WAAW,WAAW,OAAO,mBAAmB,WAAW,SAAS,CAAC;AAAA,IACvF,GAAO,OAAO;AAEV,UAAM,cAAc,MAAM;AACxB,UAAI,SAAS;AACX,iBAAS,aAAa,KAAK;AAC3B,gBAAQ;AACR,gBAAQ,QAAQ,CAAAA,YAAU;AACxB,UAAAA,QAAO,cAAcA,QAAO,YAAY,OAAO,IAAIA,QAAO,oBAAoB,SAAS,OAAO;AAAA,QACxG,CAAS;AACD,kBAAU;AAAA,MAClB;AAAA,IACA;AAEI,YAAQ,QAAQ,CAACA,YAAWA,QAAO,iBAAiB,SAAS,OAAO,CAAC;AAErE,UAAM,EAAC,OAAM,IAAI;AAEjB,WAAO,cAAc,MAAM,MAAM,KAAK,WAAW;AAEjD,WAAO;AAAA,EACX;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es108.js","sources":["../../node_modules/ethers/lib.esm/utils/utf8.js"],"sourcesContent":["/**\n *  Using strings in Ethereum (or any security-basd system) requires\n *  additional care. These utilities attempt to mitigate some of the\n *  safety issues as well as provide the ability to recover and analyse\n *  strings.\n *\n *  @_subsection api/utils:Strings and UTF-8  [about-strings]\n */\nimport { getBytes } from \"./data.js\";\nimport { assertArgument, assertNormalize } from \"./errors.js\";\nfunction errorFunc(reason, offset, bytes, output, badCodepoint) {\n    assertArgument(false, `invalid codepoint at offset ${offset}; ${reason}`, \"bytes\", bytes);\n}\nfunction ignoreFunc(reason, offset, bytes, output, badCodepoint) {\n    // If there is an invalid prefix (including stray continuation), skip any additional continuation bytes\n    if (reason === \"BAD_PREFIX\" || reason === \"UNEXPECTED_CONTINUE\") {\n        let i = 0;\n        for (let o = offset + 1; o < bytes.length; o++) {\n            if (bytes[o] >> 6 !== 0x02) {\n                break;\n            }\n            i++;\n        }\n        return i;\n    }\n    // This byte runs us past the end of the string, so just jump to the end\n    // (but the first byte was read already read and therefore skipped)\n    if (reason === \"OVERRUN\") {\n        return bytes.length - offset - 1;\n    }\n    // Nothing to skip\n    return 0;\n}\nfunction replaceFunc(reason, offset, bytes, output, badCodepoint) {\n    // Overlong representations are otherwise \"valid\" code points; just non-deistingtished\n    if (reason === \"OVERLONG\") {\n        assertArgument(typeof (badCodepoint) === \"number\", \"invalid bad code point for replacement\", \"badCodepoint\", badCodepoint);\n        output.push(badCodepoint);\n        return 0;\n    }\n    // Put the replacement character into the output\n    output.push(0xfffd);\n    // Otherwise, process as if ignoring errors\n    return ignoreFunc(reason, offset, bytes, output, badCodepoint);\n}\n/**\n *  A handful of popular, built-in UTF-8 error handling strategies.\n *\n *  **``\"error\"``** - throws on ANY illegal UTF-8 sequence or\n *  non-canonical (overlong) codepoints (this is the default)\n *\n *  **``\"ignore\"``** - silently drops any illegal UTF-8 sequence\n *  and accepts non-canonical (overlong) codepoints\n *\n *  **``\"replace\"``** - replace any illegal UTF-8 sequence with the\n *  UTF-8 replacement character (i.e. ``\"\\\\ufffd\"``) and accepts\n *  non-canonical (overlong) codepoints\n *\n *  @returns: Record<\"error\" | \"ignore\" | \"replace\", Utf8ErrorFunc>\n */\nexport const Utf8ErrorFuncs = Object.freeze({\n    error: errorFunc,\n    ignore: ignoreFunc,\n    replace: replaceFunc\n});\n// http://stackoverflow.com/questions/13356493/decode-utf-8-with-javascript#13691499\nfunction getUtf8CodePoints(_bytes, onError) {\n    if (onError == null) {\n        onError = Utf8ErrorFuncs.error;\n    }\n    const bytes = getBytes(_bytes, \"bytes\");\n    const result = [];\n    let i = 0;\n    // Invalid bytes are ignored\n    while (i < bytes.length) {\n        const c = bytes[i++];\n        // 0xxx xxxx\n        if (c >> 7 === 0) {\n            result.push(c);\n            continue;\n        }\n        // Multibyte; how many bytes left for this character?\n        let extraLength = null;\n        let overlongMask = null;\n        // 110x xxxx 10xx xxxx\n        if ((c & 0xe0) === 0xc0) {\n            extraLength = 1;\n            overlongMask = 0x7f;\n            // 1110 xxxx 10xx xxxx 10xx xxxx\n        }\n        else if ((c & 0xf0) === 0xe0) {\n            extraLength = 2;\n            overlongMask = 0x7ff;\n            // 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx\n        }\n        else if ((c & 0xf8) === 0xf0) {\n            extraLength = 3;\n            overlongMask = 0xffff;\n        }\n        else {\n            if ((c & 0xc0) === 0x80) {\n                i += onError(\"UNEXPECTED_CONTINUE\", i - 1, bytes, result);\n            }\n            else {\n                i += onError(\"BAD_PREFIX\", i - 1, bytes, result);\n            }\n            continue;\n        }\n        // Do we have enough bytes in our data?\n        if (i - 1 + extraLength >= bytes.length) {\n            i += onError(\"OVERRUN\", i - 1, bytes, result);\n            continue;\n        }\n        // Remove the length prefix from the char\n        let res = c & ((1 << (8 - extraLength - 1)) - 1);\n        for (let j = 0; j < extraLength; j++) {\n            let nextChar = bytes[i];\n            // Invalid continuation byte\n            if ((nextChar & 0xc0) != 0x80) {\n                i += onError(\"MISSING_CONTINUE\", i, bytes, result);\n                res = null;\n                break;\n            }\n            ;\n            res = (res << 6) | (nextChar & 0x3f);\n            i++;\n        }\n        // See above loop for invalid continuation byte\n        if (res === null) {\n            continue;\n        }\n        // Maximum code point\n        if (res > 0x10ffff) {\n            i += onError(\"OUT_OF_RANGE\", i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        // Reserved for UTF-16 surrogate halves\n        if (res >= 0xd800 && res <= 0xdfff) {\n            i += onError(\"UTF16_SURROGATE\", i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        // Check for overlong sequences (more bytes than needed)\n        if (res <= overlongMask) {\n            i += onError(\"OVERLONG\", i - 1 - extraLength, bytes, result, res);\n            continue;\n        }\n        result.push(res);\n    }\n    return result;\n}\n// http://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array\n/**\n *  Returns the UTF-8 byte representation of %%str%%.\n *\n *  If %%form%% is specified, the string is normalized.\n */\nexport function toUtf8Bytes(str, form) {\n    assertArgument(typeof (str) === \"string\", \"invalid string value\", \"str\", str);\n    if (form != null) {\n        assertNormalize(form);\n        str = str.normalize(form);\n    }\n    let result = [];\n    for (let i = 0; i < str.length; i++) {\n        const c = str.charCodeAt(i);\n        if (c < 0x80) {\n            result.push(c);\n        }\n        else if (c < 0x800) {\n            result.push((c >> 6) | 0xc0);\n            result.push((c & 0x3f) | 0x80);\n        }\n        else if ((c & 0xfc00) == 0xd800) {\n            i++;\n            const c2 = str.charCodeAt(i);\n            assertArgument(i < str.length && ((c2 & 0xfc00) === 0xdc00), \"invalid surrogate pair\", \"str\", str);\n            // Surrogate Pair\n            const pair = 0x10000 + ((c & 0x03ff) << 10) + (c2 & 0x03ff);\n            result.push((pair >> 18) | 0xf0);\n            result.push(((pair >> 12) & 0x3f) | 0x80);\n            result.push(((pair >> 6) & 0x3f) | 0x80);\n            result.push((pair & 0x3f) | 0x80);\n        }\n        else {\n            result.push((c >> 12) | 0xe0);\n            result.push(((c >> 6) & 0x3f) | 0x80);\n            result.push((c & 0x3f) | 0x80);\n        }\n    }\n    return new Uint8Array(result);\n}\n;\n//export \nfunction _toUtf8String(codePoints) {\n    return codePoints.map((codePoint) => {\n        if (codePoint <= 0xffff) {\n            return String.fromCharCode(codePoint);\n        }\n        codePoint -= 0x10000;\n        return String.fromCharCode((((codePoint >> 10) & 0x3ff) + 0xd800), ((codePoint & 0x3ff) + 0xdc00));\n    }).join(\"\");\n}\n/**\n *  Returns the string represented by the UTF-8 data %%bytes%%.\n *\n *  When %%onError%% function is specified, it is called on UTF-8\n *  errors allowing recovery using the [[Utf8ErrorFunc]] API.\n *  (default: [error](Utf8ErrorFuncs))\n */\nexport function toUtf8String(bytes, onError) {\n    return _toUtf8String(getUtf8CodePoints(bytes, onError));\n}\n/**\n *  Returns the UTF-8 code-points for %%str%%.\n *\n *  If %%form%% is specified, the string is normalized.\n */\nexport function toUtf8CodePoints(str, form) {\n    return getUtf8CodePoints(toUtf8Bytes(str, form));\n}\n//# sourceMappingURL=utf8.js.map"],"names":[],"mappings":";;AAUA,SAAS,UAAU,QAAQ,QAAQ,OAAO,QAAQ,cAAc;AAC5D,iBAAe,OAAO,+BAA+B,MAAM,KAAK,MAAM,IAAI,SAAS,KAAK;AAC5F;AACA,SAAS,WAAW,QAAQ,QAAQ,OAAO,QAAQ,cAAc;AAE7D,MAAI,WAAW,gBAAgB,WAAW,uBAAuB;AAC7D,QAAI,IAAI;AACR,aAAS,IAAI,SAAS,GAAG,IAAI,MAAM,QAAQ,KAAK;AAC5C,UAAI,MAAM,CAAC,KAAK,MAAM,GAAM;AACxB;AAAA,MAChB;AACY;AAAA,IACZ;AACQ,WAAO;AAAA,EACf;AAGI,MAAI,WAAW,WAAW;AACtB,WAAO,MAAM,SAAS,SAAS;AAAA,EACvC;AAEI,SAAO;AACX;AACA,SAAS,YAAY,QAAQ,QAAQ,OAAO,QAAQ,cAAc;AAE9D,MAAI,WAAW,YAAY;AACvB,mBAAe,OAAQ,iBAAkB,UAAU,0CAA0C,gBAAgB,YAAY;AACzH,WAAO,KAAK,YAAY;AACxB,WAAO;AAAA,EACf;AAEI,SAAO,KAAK,KAAM;AAElB,SAAO,WAAW,QAAQ,QAAQ,KAA2B;AACjE;AAgBY,MAAC,iBAAiB,OAAO,OAAO;AAAA,EACxC,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,SAAS;AACb,CAAC;AAED,SAAS,kBAAkB,QAAQ,SAAS;AACxC,MAAI,WAAW,MAAM;AACjB,cAAU,eAAe;AAAA,EACjC;AACI,QAAM,QAAQ,SAAS,QAAQ,OAAO;AACtC,QAAM,SAAS,CAAE;AACjB,MAAI,IAAI;AAER,SAAO,IAAI,MAAM,QAAQ;AACrB,UAAM,IAAI,MAAM,GAAG;AAEnB,QAAI,KAAK,MAAM,GAAG;AACd,aAAO,KAAK,CAAC;AACb;AAAA,IACZ;AAEQ,QAAI,cAAc;AAClB,QAAI,eAAe;AAEnB,SAAK,IAAI,SAAU,KAAM;AACrB,oBAAc;AACd,qBAAe;AAAA,IAE3B,YACkB,IAAI,SAAU,KAAM;AAC1B,oBAAc;AACd,qBAAe;AAAA,IAE3B,YACkB,IAAI,SAAU,KAAM;AAC1B,oBAAc;AACd,qBAAe;AAAA,IAC3B,OACa;AACD,WAAK,IAAI,SAAU,KAAM;AACrB,aAAK,QAAQ,uBAAuB,IAAI,GAAG,OAAO,MAAM;AAAA,MACxE,OACiB;AACD,aAAK,QAAQ,cAAc,IAAI,GAAG,OAAO,MAAM;AAAA,MAC/D;AACY;AAAA,IACZ;AAEQ,QAAI,IAAI,IAAI,eAAe,MAAM,QAAQ;AACrC,WAAK,QAAQ,WAAW,IAAI,GAAG,OAAO,MAAM;AAC5C;AAAA,IACZ;AAEQ,QAAI,MAAM,KAAM,KAAM,IAAI,cAAc,KAAM;AAC9C,aAAS,IAAI,GAAG,IAAI,aAAa,KAAK;AAClC,UAAI,WAAW,MAAM,CAAC;AAEtB,WAAK,WAAW,QAAS,KAAM;AAC3B,aAAK,QAAQ,oBAAoB,GAAG,OAAO,MAAM;AACjD,cAAM;AACN;AAAA,MAChB;AAEY,YAAO,OAAO,IAAM,WAAW;AAC/B;AAAA,IACZ;AAEQ,QAAI,QAAQ,MAAM;AACd;AAAA,IACZ;AAEQ,QAAI,MAAM,SAAU;AAChB,WAAK,QAAQ,gBAAgB,IAAI,IAAI,aAAa,OAAO,QAAQ,GAAG;AACpE;AAAA,IACZ;AAEQ,QAAI,OAAO,SAAU,OAAO,OAAQ;AAChC,WAAK,QAAQ,mBAAmB,IAAI,IAAI,aAAa,OAAO,QAAQ,GAAG;AACvE;AAAA,IACZ;AAEQ,QAAI,OAAO,cAAc;AACrB,WAAK,QAAQ,YAAY,IAAI,IAAI,aAAa,OAAO,QAAQ,GAAG;AAChE;AAAA,IACZ;AACQ,WAAO,KAAK,GAAG;AAAA,EACvB;AACI,SAAO;AACX;AAOO,SAAS,YAAY,KAAK,MAAM;AACnC,iBAAe,OAAQ,QAAS,UAAU,wBAAwB,OAAO,GAAG;AAK5E,MAAI,SAAS,CAAE;AACf,WAAS,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AACjC,UAAM,IAAI,IAAI,WAAW,CAAC;AAC1B,QAAI,IAAI,KAAM;AACV,aAAO,KAAK,CAAC;AAAA,IACzB,WACiB,IAAI,MAAO;AAChB,aAAO,KAAM,KAAK,IAAK,GAAI;AAC3B,aAAO,KAAM,IAAI,KAAQ,GAAI;AAAA,IACzC,YACkB,IAAI,UAAW,OAAQ;AAC7B;AACA,YAAM,KAAK,IAAI,WAAW,CAAC;AAC3B,qBAAe,IAAI,IAAI,WAAY,KAAK,WAAY,OAAS,0BAA0B,OAAO,GAAG;AAEjG,YAAM,OAAO,UAAY,IAAI,SAAW,OAAO,KAAK;AACpD,aAAO,KAAM,QAAQ,KAAM,GAAI;AAC/B,aAAO,KAAO,QAAQ,KAAM,KAAQ,GAAI;AACxC,aAAO,KAAO,QAAQ,IAAK,KAAQ,GAAI;AACvC,aAAO,KAAM,OAAO,KAAQ,GAAI;AAAA,IAC5C,OACa;AACD,aAAO,KAAM,KAAK,KAAM,GAAI;AAC5B,aAAO,KAAO,KAAK,IAAK,KAAQ,GAAI;AACpC,aAAO,KAAM,IAAI,KAAQ,GAAI;AAAA,IACzC;AAAA,EACA;AACI,SAAO,IAAI,WAAW,MAAM;AAChC;AAGA,SAAS,cAAc,YAAY;AAC/B,SAAO,WAAW,IAAI,CAAC,cAAc;AACjC,QAAI,aAAa,OAAQ;AACrB,aAAO,OAAO,aAAa,SAAS;AAAA,IAChD;AACQ,iBAAa;AACb,WAAO,OAAO,cAAgB,aAAa,KAAM,QAAS,QAAW,YAAY,QAAS,KAAQ;AAAA,EAC1G,CAAK,EAAE,KAAK,EAAE;AACd;AAQO,SAAS,aAAa,OAAO,SAAS;AACzC,SAAO,cAAc,kBAAkB,OAAO,OAAO,CAAC;AAC1D;","x_google_ignoreList":[0]}

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

@@ -1,81 +1,177 @@
-const streamChunk = function* (chunk, chunkSize) {
-  let len = chunk.byteLength;
-  if (len < chunkSize) {
-    yield chunk;
-    return;
+import { number, exists, bytes, output } from "./standards-sdk.es115.js";
+import { rotlSH, rotlSL, rotlBH, rotlBL, split } from "./standards-sdk.es116.js";
+import { wrapConstructor, Hash, u32, toBytes } from "./standards-sdk.es117.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;
   }
-  let pos = 0;
-  let end;
-  while (pos < len) {
-    end = pos + chunkSize;
-    yield chunk.slice(pos, end);
-    pos = end;
+  _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];
   }
-};
-const readBytes = async function* (iterable, chunkSize) {
-  for await (const chunk of readStream(iterable)) {
-    yield* streamChunk(chunk, chunkSize);
+  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);
   }
-};
-const readStream = async function* (stream) {
-  if (stream[Symbol.asyncIterator]) {
-    yield* stream;
-    return;
+  keccak() {
+    keccakP(this.state32, this.rounds);
+    this.posOut = 0;
+    this.pos = 0;
   }
-  const reader = stream.getReader();
-  try {
-    for (; ; ) {
-      const { done, value } = await reader.read();
-      if (done) {
-        break;
-      }
-      yield value;
+  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();
     }
-  } finally {
-    await reader.cancel();
+    return this;
   }
-};
-const trackStream = (stream, chunkSize, onProgress, onFinish) => {
-  const iterator = readBytes(stream, chunkSize);
-  let bytes = 0;
-  let done;
-  let _onFinish = (e) => {
-    if (!done) {
-      done = true;
-      onFinish && onFinish(e);
-    }
-  };
-  return new ReadableStream({
-    async pull(controller) {
-      try {
-        const { done: done2, value } = await iterator.next();
-        if (done2) {
-          _onFinish();
-          controller.close();
-          return;
-        }
-        let len = value.byteLength;
-        if (onProgress) {
-          let loadedBytes = bytes += len;
-          onProgress(loadedBytes);
-        }
-        controller.enqueue(new Uint8Array(value));
-      } catch (err) {
-        _onFinish(err);
-        throw err;
-      }
-    },
-    cancel(reason) {
-      _onFinish(reason);
-      return iterator.return();
+  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;
     }
-  }, {
-    highWaterMark: 2
-  });
-};
+    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));
+  }
+  destroy() {
+    this.destroyed = true;
+    this.state.fill(0);
+  }
+  _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 {
-  readBytes,
-  streamChunk,
-  trackStream
+  Keccak,
+  keccakP,
+  keccak_256
 };
 //# sourceMappingURL=standards-sdk.es109.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es109.js","sources":["../../node_modules/axios/lib/helpers/trackStream.js"],"sourcesContent":["\nexport const streamChunk = function* (chunk, chunkSize) {\n  let len = chunk.byteLength;\n\n  if (!chunkSize || len < chunkSize) {\n    yield chunk;\n    return;\n  }\n\n  let pos = 0;\n  let end;\n\n  while (pos < len) {\n    end = pos + chunkSize;\n    yield chunk.slice(pos, end);\n    pos = end;\n  }\n}\n\nexport const readBytes = async function* (iterable, chunkSize) {\n  for await (const chunk of readStream(iterable)) {\n    yield* streamChunk(chunk, chunkSize);\n  }\n}\n\nconst readStream = async function* (stream) {\n  if (stream[Symbol.asyncIterator]) {\n    yield* stream;\n    return;\n  }\n\n  const reader = stream.getReader();\n  try {\n    for (;;) {\n      const {done, value} = await reader.read();\n      if (done) {\n        break;\n      }\n      yield value;\n    }\n  } finally {\n    await reader.cancel();\n  }\n}\n\nexport const trackStream = (stream, chunkSize, onProgress, onFinish) => {\n  const iterator = readBytes(stream, chunkSize);\n\n  let bytes = 0;\n  let done;\n  let _onFinish = (e) => {\n    if (!done) {\n      done = true;\n      onFinish && onFinish(e);\n    }\n  }\n\n  return new ReadableStream({\n    async pull(controller) {\n      try {\n        const {done, value} = await iterator.next();\n\n        if (done) {\n         _onFinish();\n          controller.close();\n          return;\n        }\n\n        let len = value.byteLength;\n        if (onProgress) {\n          let loadedBytes = bytes += len;\n          onProgress(loadedBytes);\n        }\n        controller.enqueue(new Uint8Array(value));\n      } catch (err) {\n        _onFinish(err);\n        throw err;\n      }\n    },\n    cancel(reason) {\n      _onFinish(reason);\n      return iterator.return();\n    }\n  }, {\n    highWaterMark: 2\n  })\n}\n"],"names":["done"],"mappings":"AACY,MAAC,cAAc,WAAW,OAAO,WAAW;AACtD,MAAI,MAAM,MAAM;AAEhB,MAAkB,MAAM,WAAW;AACjC,UAAM;AACN;AAAA,EACJ;AAEE,MAAI,MAAM;AACV,MAAI;AAEJ,SAAO,MAAM,KAAK;AAChB,UAAM,MAAM;AACZ,UAAM,MAAM,MAAM,KAAK,GAAG;AAC1B,UAAM;AAAA,EACV;AACA;AAEY,MAAC,YAAY,iBAAiB,UAAU,WAAW;AAC7D,mBAAiB,SAAS,WAAW,QAAQ,GAAG;AAC9C,WAAO,YAAY,OAAO,SAAS;AAAA,EACvC;AACA;AAEA,MAAM,aAAa,iBAAiB,QAAQ;AAC1C,MAAI,OAAO,OAAO,aAAa,GAAG;AAChC,WAAO;AACP;AAAA,EACJ;AAEE,QAAM,SAAS,OAAO,UAAW;AACjC,MAAI;AACF,eAAS;AACP,YAAM,EAAC,MAAM,MAAK,IAAI,MAAM,OAAO,KAAM;AACzC,UAAI,MAAM;AACR;AAAA,MACR;AACM,YAAM;AAAA,IACZ;AAAA,EACA,UAAY;AACR,UAAM,OAAO,OAAQ;AAAA,EACzB;AACA;AAEY,MAAC,cAAc,CAAC,QAAQ,WAAW,YAAY,aAAa;AACtE,QAAM,WAAW,UAAU,QAAQ,SAAS;AAE5C,MAAI,QAAQ;AACZ,MAAI;AACJ,MAAI,YAAY,CAAC,MAAM;AACrB,QAAI,CAAC,MAAM;AACT,aAAO;AACP,kBAAY,SAAS,CAAC;AAAA,IAC5B;AAAA,EACA;AAEE,SAAO,IAAI,eAAe;AAAA,IACxB,MAAM,KAAK,YAAY;AACrB,UAAI;AACF,cAAM,EAAC,MAAAA,OAAM,MAAK,IAAI,MAAM,SAAS,KAAM;AAE3C,YAAIA,OAAM;AACT,oBAAW;AACV,qBAAW,MAAO;AAClB;AAAA,QACV;AAEQ,YAAI,MAAM,MAAM;AAChB,YAAI,YAAY;AACd,cAAI,cAAc,SAAS;AAC3B,qBAAW,WAAW;AAAA,QAChC;AACQ,mBAAW,QAAQ,IAAI,WAAW,KAAK,CAAC;AAAA,MACzC,SAAQ,KAAK;AACZ,kBAAU,GAAG;AACb,cAAM;AAAA,MACd;AAAA,IACK;AAAA,IACD,OAAO,QAAQ;AACb,gBAAU,MAAM;AAChB,aAAO,SAAS,OAAQ;AAAA,IAC9B;AAAA,EACA,GAAK;AAAA,IACD,eAAe;AAAA,EAChB,CAAA;AACH;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es109.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":"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","x_google_ignoreList":[0]}

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

@@ -1,7 +1,37 @@
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+function speedometer(samplesCount, min) {
+  samplesCount = samplesCount || 10;
+  const bytes = new Array(samplesCount);
+  const timestamps = new Array(samplesCount);
+  let head = 0;
+  let tail = 0;
+  let firstSampleTS;
+  min = min !== void 0 ? min : 1e3;
+  return function push(chunkLength) {
+    const now = Date.now();
+    const startedAt = timestamps[tail];
+    if (!firstSampleTS) {
+      firstSampleTS = now;
+    }
+    bytes[head] = chunkLength;
+    timestamps[head] = now;
+    let i = tail;
+    let bytesCount = 0;
+    while (i !== head) {
+      bytesCount += bytes[i++];
+      i = i % samplesCount;
+    }
+    head = (head + 1) % samplesCount;
+    if (head === tail) {
+      tail = (tail + 1) % samplesCount;
+    }
+    if (now - firstSampleTS < min) {
+      return;
+    }
+    const passed = startedAt && now - startedAt;
+    return passed ? Math.round(bytesCount * 1e3 / passed) : void 0;
+  };
 }
 export {
-  getDefaultExportFromCjs
+  speedometer as default
 };
 //# sourceMappingURL=standards-sdk.es110.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es110.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}
+{"version":3,"file":"standards-sdk.es110.js","sources":["../../node_modules/axios/lib/helpers/speedometer.js"],"sourcesContent":["'use strict';\n\n/**\n * Calculate data maxRate\n * @param {Number} [samplesCount= 10]\n * @param {Number} [min= 1000]\n * @returns {Function}\n */\nfunction speedometer(samplesCount, min) {\n  samplesCount = samplesCount || 10;\n  const bytes = new Array(samplesCount);\n  const timestamps = new Array(samplesCount);\n  let head = 0;\n  let tail = 0;\n  let firstSampleTS;\n\n  min = min !== undefined ? min : 1000;\n\n  return function push(chunkLength) {\n    const now = Date.now();\n\n    const startedAt = timestamps[tail];\n\n    if (!firstSampleTS) {\n      firstSampleTS = now;\n    }\n\n    bytes[head] = chunkLength;\n    timestamps[head] = now;\n\n    let i = tail;\n    let bytesCount = 0;\n\n    while (i !== head) {\n      bytesCount += bytes[i++];\n      i = i % samplesCount;\n    }\n\n    head = (head + 1) % samplesCount;\n\n    if (head === tail) {\n      tail = (tail + 1) % samplesCount;\n    }\n\n    if (now - firstSampleTS < min) {\n      return;\n    }\n\n    const passed = startedAt && now - startedAt;\n\n    return passed ? Math.round(bytesCount * 1000 / passed) : undefined;\n  };\n}\n\nexport default speedometer;\n"],"names":[],"mappings":"AAQA,SAAS,YAAY,cAAc,KAAK;AACtC,iBAAe,gBAAgB;AAC/B,QAAM,QAAQ,IAAI,MAAM,YAAY;AACpC,QAAM,aAAa,IAAI,MAAM,YAAY;AACzC,MAAI,OAAO;AACX,MAAI,OAAO;AACX,MAAI;AAEJ,QAAM,QAAQ,SAAY,MAAM;AAEhC,SAAO,SAAS,KAAK,aAAa;AAChC,UAAM,MAAM,KAAK,IAAK;AAEtB,UAAM,YAAY,WAAW,IAAI;AAEjC,QAAI,CAAC,eAAe;AAClB,sBAAgB;AAAA,IACtB;AAEI,UAAM,IAAI,IAAI;AACd,eAAW,IAAI,IAAI;AAEnB,QAAI,IAAI;AACR,QAAI,aAAa;AAEjB,WAAO,MAAM,MAAM;AACjB,oBAAc,MAAM,GAAG;AACvB,UAAI,IAAI;AAAA,IACd;AAEI,YAAQ,OAAO,KAAK;AAEpB,QAAI,SAAS,MAAM;AACjB,cAAQ,OAAO,KAAK;AAAA,IAC1B;AAEI,QAAI,MAAM,gBAAgB,KAAK;AAC7B;AAAA,IACN;AAEI,UAAM,SAAS,aAAa,MAAM;AAElC,WAAO,SAAS,KAAK,MAAM,aAAa,MAAO,MAAM,IAAI;AAAA,EAC1D;AACH;","x_google_ignoreList":[0]}