@hashgraphonline/standards-sdk 0.0.82 → 0.0.84

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es41.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/abstract-coder.js"],"sourcesContent":["import { defineProperties, concat, getBytesCopy, getNumber, hexlify, toBeArray, toBigInt, toNumber, assert, assertArgument\n/*, isError*/\n } from \"../../utils/index.js\";\n/**\n * @_ignore:\n */\nexport const WordSize = 32;\nconst Padding = new Uint8Array(WordSize);\n// Properties used to immediate pass through to the underlying object\n// - `then` is used to detect if an object is a Promise for await\nconst passProperties = [\"then\"];\nconst _guard = {};\nconst resultNames = new WeakMap();\nfunction getNames(result) {\n    return resultNames.get(result);\n}\nfunction setNames(result, names) {\n    resultNames.set(result, names);\n}\nfunction throwError(name, error) {\n    const wrapped = new Error(`deferred error during ABI decoding triggered accessing ${name}`);\n    wrapped.error = error;\n    throw wrapped;\n}\nfunction toObject(names, items, deep) {\n    if (names.indexOf(null) >= 0) {\n        return items.map((item, index) => {\n            if (item instanceof Result) {\n                return toObject(getNames(item), item, deep);\n            }\n            return item;\n        });\n    }\n    return names.reduce((accum, name, index) => {\n        let item = items.getValue(name);\n        if (!(name in accum)) {\n            if (deep && item instanceof Result) {\n                item = toObject(getNames(item), item, deep);\n            }\n            accum[name] = item;\n        }\n        return accum;\n    }, {});\n}\n/**\n *  A [[Result]] is a sub-class of Array, which allows accessing any\n *  of its values either positionally by its index or, if keys are\n *  provided by its name.\n *\n *  @_docloc: api/abi\n */\nexport class Result extends Array {\n    // No longer used; but cannot be removed as it will remove the\n    // #private field from the .d.ts which may break backwards\n    // compatibility\n    #names;\n    /**\n     *  @private\n     */\n    constructor(...args) {\n        // To properly sub-class Array so the other built-in\n        // functions work, the constructor has to behave fairly\n        // well. So, in the event we are created via fromItems()\n        // we build the read-only Result object we want, but on\n        // any other input, we use the default constructor\n        // constructor(guard: any, items: Array<any>, keys?: Array<null | string>);\n        const guard = args[0];\n        let items = args[1];\n        let names = (args[2] || []).slice();\n        let wrap = true;\n        if (guard !== _guard) {\n            items = args;\n            names = [];\n            wrap = false;\n        }\n        // Can't just pass in ...items since an array of length 1\n        // is a special case in the super.\n        super(items.length);\n        items.forEach((item, index) => { this[index] = item; });\n        // Find all unique keys\n        const nameCounts = names.reduce((accum, name) => {\n            if (typeof (name) === \"string\") {\n                accum.set(name, (accum.get(name) || 0) + 1);\n            }\n            return accum;\n        }, (new Map()));\n        // Remove any key thats not unique\n        setNames(this, Object.freeze(items.map((item, index) => {\n            const name = names[index];\n            if (name != null && nameCounts.get(name) === 1) {\n                return name;\n            }\n            return null;\n        })));\n        // Dummy operations to prevent TypeScript from complaining\n        this.#names = [];\n        if (this.#names == null) {\n            void (this.#names);\n        }\n        if (!wrap) {\n            return;\n        }\n        // A wrapped Result is immutable\n        Object.freeze(this);\n        // Proxy indices and names so we can trap deferred errors\n        const proxy = new Proxy(this, {\n            get: (target, prop, receiver) => {\n                if (typeof (prop) === \"string\") {\n                    // Index accessor\n                    if (prop.match(/^[0-9]+$/)) {\n                        const index = getNumber(prop, \"%index\");\n                        if (index < 0 || index >= this.length) {\n                            throw new RangeError(\"out of result range\");\n                        }\n                        const item = target[index];\n                        if (item instanceof Error) {\n                            throwError(`index ${index}`, item);\n                        }\n                        return item;\n                    }\n                    // Pass important checks (like `then` for Promise) through\n                    if (passProperties.indexOf(prop) >= 0) {\n                        return Reflect.get(target, prop, receiver);\n                    }\n                    const value = target[prop];\n                    if (value instanceof Function) {\n                        // Make sure functions work with private variables\n                        // See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy#no_private_property_forwarding\n                        return function (...args) {\n                            return value.apply((this === receiver) ? target : this, args);\n                        };\n                    }\n                    else if (!(prop in target)) {\n                        // Possible name accessor\n                        return target.getValue.apply((this === receiver) ? target : this, [prop]);\n                    }\n                }\n                return Reflect.get(target, prop, receiver);\n            }\n        });\n        setNames(proxy, getNames(this));\n        return proxy;\n    }\n    /**\n     *  Returns the Result as a normal Array. If %%deep%%, any children\n     *  which are Result objects are also converted to a normal Array.\n     *\n     *  This will throw if there are any outstanding deferred\n     *  errors.\n     */\n    toArray(deep) {\n        const result = [];\n        this.forEach((item, index) => {\n            if (item instanceof Error) {\n                throwError(`index ${index}`, item);\n            }\n            if (deep && item instanceof Result) {\n                item = item.toArray(deep);\n            }\n            result.push(item);\n        });\n        return result;\n    }\n    /**\n     *  Returns the Result as an Object with each name-value pair. If\n     *  %%deep%%, any children which are Result objects are also\n     *  converted to an Object.\n     *\n     *  This will throw if any value is unnamed, or if there are\n     *  any outstanding deferred errors.\n     */\n    toObject(deep) {\n        const names = getNames(this);\n        return names.reduce((accum, name, index) => {\n            assert(name != null, `value at index ${index} unnamed`, \"UNSUPPORTED_OPERATION\", {\n                operation: \"toObject()\"\n            });\n            return toObject(names, this, deep);\n        }, {});\n    }\n    /**\n     *  @_ignore\n     */\n    slice(start, end) {\n        if (start == null) {\n            start = 0;\n        }\n        if (start < 0) {\n            start += this.length;\n            if (start < 0) {\n                start = 0;\n            }\n        }\n        if (end == null) {\n            end = this.length;\n        }\n        if (end < 0) {\n            end += this.length;\n            if (end < 0) {\n                end = 0;\n            }\n        }\n        if (end > this.length) {\n            end = this.length;\n        }\n        const _names = getNames(this);\n        const result = [], names = [];\n        for (let i = start; i < end; i++) {\n            result.push(this[i]);\n            names.push(_names[i]);\n        }\n        return new Result(_guard, result, names);\n    }\n    /**\n     *  @_ignore\n     */\n    filter(callback, thisArg) {\n        const _names = getNames(this);\n        const result = [], names = [];\n        for (let i = 0; i < this.length; i++) {\n            const item = this[i];\n            if (item instanceof Error) {\n                throwError(`index ${i}`, item);\n            }\n            if (callback.call(thisArg, item, i, this)) {\n                result.push(item);\n                names.push(_names[i]);\n            }\n        }\n        return new Result(_guard, result, names);\n    }\n    /**\n     *  @_ignore\n     */\n    map(callback, thisArg) {\n        const result = [];\n        for (let i = 0; i < this.length; i++) {\n            const item = this[i];\n            if (item instanceof Error) {\n                throwError(`index ${i}`, item);\n            }\n            result.push(callback.call(thisArg, item, i, this));\n        }\n        return result;\n    }\n    /**\n     *  Returns the value for %%name%%.\n     *\n     *  Since it is possible to have a key whose name conflicts with\n     *  a method on a [[Result]] or its superclass Array, or any\n     *  JavaScript keyword, this ensures all named values are still\n     *  accessible by name.\n     */\n    getValue(name) {\n        const index = getNames(this).indexOf(name);\n        if (index === -1) {\n            return undefined;\n        }\n        const value = this[index];\n        if (value instanceof Error) {\n            throwError(`property ${JSON.stringify(name)}`, value.error);\n        }\n        return value;\n    }\n    /**\n     *  Creates a new [[Result]] for %%items%% with each entry\n     *  also accessible by its corresponding name in %%keys%%.\n     */\n    static fromItems(items, keys) {\n        return new Result(_guard, items, keys);\n    }\n}\n/**\n *  Returns all errors found in a [[Result]].\n *\n *  Since certain errors encountered when creating a [[Result]] do\n *  not impact the ability to continue parsing data, they are\n *  deferred until they are actually accessed. Hence a faulty string\n *  in an Event that is never used does not impact the program flow.\n *\n *  However, sometimes it may be useful to access, identify or\n *  validate correctness of a [[Result]].\n *\n *  @_docloc api/abi\n */\nexport function checkResultErrors(result) {\n    // Find the first error (if any)\n    const errors = [];\n    const checkErrors = function (path, object) {\n        if (!Array.isArray(object)) {\n            return;\n        }\n        for (let key in object) {\n            const childPath = path.slice();\n            childPath.push(key);\n            try {\n                checkErrors(childPath, object[key]);\n            }\n            catch (error) {\n                errors.push({ path: childPath, error: error });\n            }\n        }\n    };\n    checkErrors([], result);\n    return errors;\n}\nfunction getValue(value) {\n    let bytes = toBeArray(value);\n    assert(bytes.length <= WordSize, \"value out-of-bounds\", \"BUFFER_OVERRUN\", { buffer: bytes, length: WordSize, offset: bytes.length });\n    if (bytes.length !== WordSize) {\n        bytes = getBytesCopy(concat([Padding.slice(bytes.length % WordSize), bytes]));\n    }\n    return bytes;\n}\n/**\n *  @_ignore\n */\nexport class Coder {\n    // The coder name:\n    //   - address, uint256, tuple, array, etc.\n    name;\n    // The fully expanded type, including composite types:\n    //   - address, uint256, tuple(address,bytes), uint256[3][4][],  etc.\n    type;\n    // The localName bound in the signature, in this example it is \"baz\":\n    //   - tuple(address foo, uint bar) baz\n    localName;\n    // Whether this type is dynamic:\n    //  - Dynamic: bytes, string, address[], tuple(boolean[]), etc.\n    //  - Not Dynamic: address, uint256, boolean[3], tuple(address, uint8)\n    dynamic;\n    constructor(name, type, localName, dynamic) {\n        defineProperties(this, { name, type, localName, dynamic }, {\n            name: \"string\", type: \"string\", localName: \"string\", dynamic: \"boolean\"\n        });\n    }\n    _throwError(message, value) {\n        assertArgument(false, message, this.localName, value);\n    }\n}\n/**\n *  @_ignore\n */\nexport class Writer {\n    // An array of WordSize lengthed objects to concatenation\n    #data;\n    #dataLength;\n    constructor() {\n        this.#data = [];\n        this.#dataLength = 0;\n    }\n    get data() {\n        return concat(this.#data);\n    }\n    get length() { return this.#dataLength; }\n    #writeData(data) {\n        this.#data.push(data);\n        this.#dataLength += data.length;\n        return data.length;\n    }\n    appendWriter(writer) {\n        return this.#writeData(getBytesCopy(writer.data));\n    }\n    // Arrayish item; pad on the right to *nearest* WordSize\n    writeBytes(value) {\n        let bytes = getBytesCopy(value);\n        const paddingOffset = bytes.length % WordSize;\n        if (paddingOffset) {\n            bytes = getBytesCopy(concat([bytes, Padding.slice(paddingOffset)]));\n        }\n        return this.#writeData(bytes);\n    }\n    // Numeric item; pad on the left *to* WordSize\n    writeValue(value) {\n        return this.#writeData(getValue(value));\n    }\n    // Inserts a numeric place-holder, returning a callback that can\n    // be used to asjust the value later\n    writeUpdatableValue() {\n        const offset = this.#data.length;\n        this.#data.push(Padding);\n        this.#dataLength += WordSize;\n        return (value) => {\n            this.#data[offset] = getValue(value);\n        };\n    }\n}\n/**\n *  @_ignore\n */\nexport class Reader {\n    // Allows incomplete unpadded data to be read; otherwise an error\n    // is raised if attempting to overrun the buffer. This is required\n    // to deal with an old Solidity bug, in which event data for\n    // external (not public thoguh) was tightly packed.\n    allowLoose;\n    #data;\n    #offset;\n    #bytesRead;\n    #parent;\n    #maxInflation;\n    constructor(data, allowLoose, maxInflation) {\n        defineProperties(this, { allowLoose: !!allowLoose });\n        this.#data = getBytesCopy(data);\n        this.#bytesRead = 0;\n        this.#parent = null;\n        this.#maxInflation = (maxInflation != null) ? maxInflation : 1024;\n        this.#offset = 0;\n    }\n    get data() { return hexlify(this.#data); }\n    get dataLength() { return this.#data.length; }\n    get consumed() { return this.#offset; }\n    get bytes() { return new Uint8Array(this.#data); }\n    #incrementBytesRead(count) {\n        if (this.#parent) {\n            return this.#parent.#incrementBytesRead(count);\n        }\n        this.#bytesRead += count;\n        // Check for excessive inflation (see: #4537)\n        assert(this.#maxInflation < 1 || this.#bytesRead <= this.#maxInflation * this.dataLength, `compressed ABI data exceeds inflation ratio of ${this.#maxInflation} ( see: https:/\\/github.com/ethers-io/ethers.js/issues/4537 )`, \"BUFFER_OVERRUN\", {\n            buffer: getBytesCopy(this.#data), offset: this.#offset,\n            length: count, info: {\n                bytesRead: this.#bytesRead,\n                dataLength: this.dataLength\n            }\n        });\n    }\n    #peekBytes(offset, length, loose) {\n        let alignedLength = Math.ceil(length / WordSize) * WordSize;\n        if (this.#offset + alignedLength > this.#data.length) {\n            if (this.allowLoose && loose && this.#offset + length <= this.#data.length) {\n                alignedLength = length;\n            }\n            else {\n                assert(false, \"data out-of-bounds\", \"BUFFER_OVERRUN\", {\n                    buffer: getBytesCopy(this.#data),\n                    length: this.#data.length,\n                    offset: this.#offset + alignedLength\n                });\n            }\n        }\n        return this.#data.slice(this.#offset, this.#offset + alignedLength);\n    }\n    // Create a sub-reader with the same underlying data, but offset\n    subReader(offset) {\n        const reader = new Reader(this.#data.slice(this.#offset + offset), this.allowLoose, this.#maxInflation);\n        reader.#parent = this;\n        return reader;\n    }\n    // Read bytes\n    readBytes(length, loose) {\n        let bytes = this.#peekBytes(0, length, !!loose);\n        this.#incrementBytesRead(length);\n        this.#offset += bytes.length;\n        // @TODO: Make sure the length..end bytes are all 0?\n        return bytes.slice(0, length);\n    }\n    // Read a numeric values\n    readValue() {\n        return toBigInt(this.readBytes(WordSize));\n    }\n    readIndex() {\n        return toNumber(this.readBytes(WordSize));\n    }\n}\n//# sourceMappingURL=abstract-coder.js.map"],"names":["args","_names","_data"],"mappings":"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","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es41.js","sources":["../../node_modules/axios/lib/env/data.js"],"sourcesContent":["export const VERSION = \"1.8.4\";"],"names":[],"mappings":"AAAY,MAAC,UAAU;","x_google_ignoreList":[0]}

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

@@ -1,28 +1,116 @@
-import { toBeHex } from "./standards-sdk.es54.js";
-import { Typed } from "./standards-sdk.es55.js";
-import { Coder } from "./standards-sdk.es41.js";
-import { getAddress } from "./standards-sdk.es35.js";
-class AddressCoder extends Coder {
-  constructor(localName) {
-    super("address", "address", localName, false);
+import Buffer from "./standards-sdk.es23.js";
+import utils from "./standards-sdk.es32.js";
+import AxiosError from "./standards-sdk.es43.js";
+function isVisitable(thing) {
+  return utils.isPlainObject(thing) || utils.isArray(thing);
+}
+function removeBrackets(key) {
+  return utils.endsWith(key, "[]") ? key.slice(0, -2) : key;
+}
+function renderKey(path, key, dots) {
+  if (!path) return key;
+  return path.concat(key).map(function each(token, i) {
+    token = removeBrackets(token);
+    return !dots && i ? "[" + token + "]" : token;
+  }).join(dots ? "." : "");
+}
+function isFlatArray(arr) {
+  return utils.isArray(arr) && !arr.some(isVisitable);
+}
+const predicates = utils.toFlatObject(utils, {}, null, function filter(prop) {
+  return /^is[A-Z]/.test(prop);
+});
+function toFormData(obj, formData, options) {
+  if (!utils.isObject(obj)) {
+    throw new TypeError("target must be an object");
+  }
+  formData = formData || new FormData();
+  options = utils.toFlatObject(options, {
+    metaTokens: true,
+    dots: false,
+    indexes: false
+  }, false, function defined(option, source) {
+    return !utils.isUndefined(source[option]);
+  });
+  const metaTokens = options.metaTokens;
+  const visitor = options.visitor || defaultVisitor;
+  const dots = options.dots;
+  const indexes = options.indexes;
+  const _Blob = options.Blob || typeof Blob !== "undefined" && Blob;
+  const useBlob = _Blob && utils.isSpecCompliantForm(formData);
+  if (!utils.isFunction(visitor)) {
+    throw new TypeError("visitor must be a function");
   }
-  defaultValue() {
-    return "0x0000000000000000000000000000000000000000";
+  function convertValue(value) {
+    if (value === null) return "";
+    if (utils.isDate(value)) {
+      return value.toISOString();
+    }
+    if (!useBlob && utils.isBlob(value)) {
+      throw new AxiosError("Blob is not supported. Use a Buffer instead.");
+    }
+    if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) {
+      return useBlob && typeof Blob === "function" ? new Blob([value]) : Buffer.from(value);
+    }
+    return value;
+  }
+  function defaultVisitor(value, key, path) {
+    let arr = value;
+    if (value && !path && typeof value === "object") {
+      if (utils.endsWith(key, "{}")) {
+        key = metaTokens ? key : key.slice(0, -2);
+        value = JSON.stringify(value);
+      } else if (utils.isArray(value) && isFlatArray(value) || (utils.isFileList(value) || utils.endsWith(key, "[]")) && (arr = utils.toArray(value))) {
+        key = removeBrackets(key);
+        arr.forEach(function each(el, index) {
+          !(utils.isUndefined(el) || el === null) && formData.append(
+            // eslint-disable-next-line no-nested-ternary
+            indexes === true ? renderKey([key], index, dots) : indexes === null ? key : key + "[]",
+            convertValue(el)
+          );
+        });
+        return false;
+      }
+    }
+    if (isVisitable(value)) {
+      return true;
+    }
+    formData.append(renderKey(path, key, dots), convertValue(value));
+    return false;
   }
-  encode(writer, _value) {
-    let value = Typed.dereference(_value, "string");
-    try {
-      value = getAddress(value);
-    } catch (error) {
-      return this._throwError(error.message, _value);
+  const stack = [];
+  const exposedHelpers = Object.assign(predicates, {
+    defaultVisitor,
+    convertValue,
+    isVisitable
+  });
+  function build(value, path) {
+    if (utils.isUndefined(value)) return;
+    if (stack.indexOf(value) !== -1) {
+      throw Error("Circular reference detected in " + path.join("."));
     }
-    return writer.writeValue(value);
+    stack.push(value);
+    utils.forEach(value, function each(el, key) {
+      const result = !(utils.isUndefined(el) || el === null) && visitor.call(
+        formData,
+        el,
+        utils.isString(key) ? key.trim() : key,
+        path,
+        exposedHelpers
+      );
+      if (result === true) {
+        build(el, path ? path.concat(key) : [key]);
+      }
+    });
+    stack.pop();
   }
-  decode(reader) {
-    return getAddress(toBeHex(reader.readValue(), 20));
+  if (!utils.isObject(obj)) {
+    throw new TypeError("data must be an object");
   }
+  build(obj);
+  return formData;
 }
 export {
-  AddressCoder
+  toFormData as default
 };
 //# sourceMappingURL=standards-sdk.es42.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es42.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/address.js"],"sourcesContent":["import { getAddress } from \"../../address/index.js\";\nimport { toBeHex } from \"../../utils/maths.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder } from \"./abstract-coder.js\";\n/**\n *  @_ignore\n */\nexport class AddressCoder extends Coder {\n    constructor(localName) {\n        super(\"address\", \"address\", localName, false);\n    }\n    defaultValue() {\n        return \"0x0000000000000000000000000000000000000000\";\n    }\n    encode(writer, _value) {\n        let value = Typed.dereference(_value, \"string\");\n        try {\n            value = getAddress(value);\n        }\n        catch (error) {\n            return this._throwError(error.message, _value);\n        }\n        return writer.writeValue(value);\n    }\n    decode(reader) {\n        return getAddress(toBeHex(reader.readValue(), 20));\n    }\n}\n//# sourceMappingURL=address.js.map"],"names":[],"mappings":";;;;AAOO,MAAM,qBAAqB,MAAM;AAAA,EACpC,YAAY,WAAW;AACnB,UAAM,WAAW,WAAW,WAAW,KAAK;AAAA,EACpD;AAAA,EACI,eAAe;AACX,WAAO;AAAA,EACf;AAAA,EACI,OAAO,QAAQ,QAAQ;AACnB,QAAI,QAAQ,MAAM,YAAY,QAAQ,QAAQ;AAC9C,QAAI;AACA,cAAQ,WAAW,KAAK;AAAA,IACpC,SACe,OAAO;AACV,aAAO,KAAK,YAAY,MAAM,SAAS,MAAM;AAAA,IACzD;AACQ,WAAO,OAAO,WAAW,KAAK;AAAA,EACtC;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,WAAW,QAAQ,OAAO,UAAW,GAAE,EAAE,CAAC;AAAA,EACzD;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es42.js","sources":["../../node_modules/axios/lib/helpers/toFormData.js"],"sourcesContent":["'use strict';\n\nimport utils from '../utils.js';\nimport AxiosError from '../core/AxiosError.js';\n// temporary hotfix to avoid circular references until AxiosURLSearchParams is refactored\nimport PlatformFormData from '../platform/node/classes/FormData.js';\n\n/**\n * Determines if the given thing is a array or js object.\n *\n * @param {string} thing - The object or array to be visited.\n *\n * @returns {boolean}\n */\nfunction isVisitable(thing) {\n  return utils.isPlainObject(thing) || utils.isArray(thing);\n}\n\n/**\n * It removes the brackets from the end of a string\n *\n * @param {string} key - The key of the parameter.\n *\n * @returns {string} the key without the brackets.\n */\nfunction removeBrackets(key) {\n  return utils.endsWith(key, '[]') ? key.slice(0, -2) : key;\n}\n\n/**\n * It takes a path, a key, and a boolean, and returns a string\n *\n * @param {string} path - The path to the current key.\n * @param {string} key - The key of the current object being iterated over.\n * @param {string} dots - If true, the key will be rendered with dots instead of brackets.\n *\n * @returns {string} The path to the current key.\n */\nfunction renderKey(path, key, dots) {\n  if (!path) return key;\n  return path.concat(key).map(function each(token, i) {\n    // eslint-disable-next-line no-param-reassign\n    token = removeBrackets(token);\n    return !dots && i ? '[' + token + ']' : token;\n  }).join(dots ? '.' : '');\n}\n\n/**\n * If the array is an array and none of its elements are visitable, then it's a flat array.\n *\n * @param {Array<any>} arr - The array to check\n *\n * @returns {boolean}\n */\nfunction isFlatArray(arr) {\n  return utils.isArray(arr) && !arr.some(isVisitable);\n}\n\nconst predicates = utils.toFlatObject(utils, {}, null, function filter(prop) {\n  return /^is[A-Z]/.test(prop);\n});\n\n/**\n * Convert a data object to FormData\n *\n * @param {Object} obj\n * @param {?Object} [formData]\n * @param {?Object} [options]\n * @param {Function} [options.visitor]\n * @param {Boolean} [options.metaTokens = true]\n * @param {Boolean} [options.dots = false]\n * @param {?Boolean} [options.indexes = false]\n *\n * @returns {Object}\n **/\n\n/**\n * It converts an object into a FormData object\n *\n * @param {Object<any, any>} obj - The object to convert to form data.\n * @param {string} formData - The FormData object to append to.\n * @param {Object<string, any>} options\n *\n * @returns\n */\nfunction toFormData(obj, formData, options) {\n  if (!utils.isObject(obj)) {\n    throw new TypeError('target must be an object');\n  }\n\n  // eslint-disable-next-line no-param-reassign\n  formData = formData || new (PlatformFormData || FormData)();\n\n  // eslint-disable-next-line no-param-reassign\n  options = utils.toFlatObject(options, {\n    metaTokens: true,\n    dots: false,\n    indexes: false\n  }, false, function defined(option, source) {\n    // eslint-disable-next-line no-eq-null,eqeqeq\n    return !utils.isUndefined(source[option]);\n  });\n\n  const metaTokens = options.metaTokens;\n  // eslint-disable-next-line no-use-before-define\n  const visitor = options.visitor || defaultVisitor;\n  const dots = options.dots;\n  const indexes = options.indexes;\n  const _Blob = options.Blob || typeof Blob !== 'undefined' && Blob;\n  const useBlob = _Blob && utils.isSpecCompliantForm(formData);\n\n  if (!utils.isFunction(visitor)) {\n    throw new TypeError('visitor must be a function');\n  }\n\n  function convertValue(value) {\n    if (value === null) return '';\n\n    if (utils.isDate(value)) {\n      return value.toISOString();\n    }\n\n    if (!useBlob && utils.isBlob(value)) {\n      throw new AxiosError('Blob is not supported. Use a Buffer instead.');\n    }\n\n    if (utils.isArrayBuffer(value) || utils.isTypedArray(value)) {\n      return useBlob && typeof Blob === 'function' ? new Blob([value]) : Buffer.from(value);\n    }\n\n    return value;\n  }\n\n  /**\n   * Default visitor.\n   *\n   * @param {*} value\n   * @param {String|Number} key\n   * @param {Array<String|Number>} path\n   * @this {FormData}\n   *\n   * @returns {boolean} return true to visit the each prop of the value recursively\n   */\n  function defaultVisitor(value, key, path) {\n    let arr = value;\n\n    if (value && !path && typeof value === 'object') {\n      if (utils.endsWith(key, '{}')) {\n        // eslint-disable-next-line no-param-reassign\n        key = metaTokens ? key : key.slice(0, -2);\n        // eslint-disable-next-line no-param-reassign\n        value = JSON.stringify(value);\n      } else if (\n        (utils.isArray(value) && isFlatArray(value)) ||\n        ((utils.isFileList(value) || utils.endsWith(key, '[]')) && (arr = utils.toArray(value))\n        )) {\n        // eslint-disable-next-line no-param-reassign\n        key = removeBrackets(key);\n\n        arr.forEach(function each(el, index) {\n          !(utils.isUndefined(el) || el === null) && formData.append(\n            // eslint-disable-next-line no-nested-ternary\n            indexes === true ? renderKey([key], index, dots) : (indexes === null ? key : key + '[]'),\n            convertValue(el)\n          );\n        });\n        return false;\n      }\n    }\n\n    if (isVisitable(value)) {\n      return true;\n    }\n\n    formData.append(renderKey(path, key, dots), convertValue(value));\n\n    return false;\n  }\n\n  const stack = [];\n\n  const exposedHelpers = Object.assign(predicates, {\n    defaultVisitor,\n    convertValue,\n    isVisitable\n  });\n\n  function build(value, path) {\n    if (utils.isUndefined(value)) return;\n\n    if (stack.indexOf(value) !== -1) {\n      throw Error('Circular reference detected in ' + path.join('.'));\n    }\n\n    stack.push(value);\n\n    utils.forEach(value, function each(el, key) {\n      const result = !(utils.isUndefined(el) || el === null) && visitor.call(\n        formData, el, utils.isString(key) ? key.trim() : key, path, exposedHelpers\n      );\n\n      if (result === true) {\n        build(el, path ? path.concat(key) : [key]);\n      }\n    });\n\n    stack.pop();\n  }\n\n  if (!utils.isObject(obj)) {\n    throw new TypeError('data must be an object');\n  }\n\n  build(obj);\n\n  return formData;\n}\n\nexport default toFormData;\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -1,142 +1,77 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { Typed } from "./standards-sdk.es55.js";
-import { Coder, WordSize, Writer, Result } from "./standards-sdk.es41.js";
-import { AnonymousCoder } from "./standards-sdk.es76.js";
-import { defineProperties } from "./standards-sdk.es52.js";
-import { assertArgumentCount, assert, assertArgument, isError } from "./standards-sdk.es37.js";
-function pack(writer, coders, values) {
-  let arrayValues = [];
-  if (Array.isArray(values)) {
-    arrayValues = values;
-  } else if (values && typeof values === "object") {
-    let unique = {};
-    arrayValues = coders.map((coder) => {
-      const name = coder.localName;
-      assert(name, "cannot encode object for signature with missing names", "INVALID_ARGUMENT", { argument: "values", info: { coder }, value: values });
-      assert(!unique[name], "cannot encode object for signature with duplicate names", "INVALID_ARGUMENT", { argument: "values", info: { coder }, value: values });
-      unique[name] = true;
-      return values[name];
-    });
+import utils from "./standards-sdk.es32.js";
+function AxiosError(message, code, config, request, response) {
+  Error.call(this);
+  if (Error.captureStackTrace) {
+    Error.captureStackTrace(this, this.constructor);
   } else {
-    assertArgument(false, "invalid tuple value", "tuple", values);
+    this.stack = new Error().stack;
   }
-  assertArgument(coders.length === arrayValues.length, "types/value length mismatch", "tuple", values);
-  let staticWriter = new Writer();
-  let dynamicWriter = new Writer();
-  let updateFuncs = [];
-  coders.forEach((coder, index) => {
-    let value = arrayValues[index];
-    if (coder.dynamic) {
-      let dynamicOffset = dynamicWriter.length;
-      coder.encode(dynamicWriter, value);
-      let updateFunc = staticWriter.writeUpdatableValue();
-      updateFuncs.push((baseOffset) => {
-        updateFunc(baseOffset + dynamicOffset);
-      });
-    } else {
-      coder.encode(staticWriter, value);
-    }
-  });
-  updateFuncs.forEach((func) => {
-    func(staticWriter.length);
-  });
-  let length = writer.appendWriter(staticWriter);
-  length += writer.appendWriter(dynamicWriter);
-  return length;
-}
-function unpack(reader, coders) {
-  let values = [];
-  let keys = [];
-  let baseReader = reader.subReader(0);
-  coders.forEach((coder) => {
-    let value = null;
-    if (coder.dynamic) {
-      let offset = reader.readIndex();
-      let offsetReader = baseReader.subReader(offset);
-      try {
-        value = coder.decode(offsetReader);
-      } catch (error) {
-        if (isError(error, "BUFFER_OVERRUN")) {
-          throw error;
-        }
-        value = error;
-        value.baseType = coder.name;
-        value.name = coder.localName;
-        value.type = coder.type;
-      }
-    } else {
-      try {
-        value = coder.decode(reader);
-      } catch (error) {
-        if (isError(error, "BUFFER_OVERRUN")) {
-          throw error;
-        }
-        value = error;
-        value.baseType = coder.name;
-        value.name = coder.localName;
-        value.type = coder.type;
-      }
-    }
-    if (value == void 0) {
-      throw new Error("investigate");
-    }
-    values.push(value);
-    keys.push(coder.localName || null);
-  });
-  return Result.fromItems(values, keys);
-}
-class ArrayCoder extends Coder {
-  constructor(coder, length, localName) {
-    const type = coder.type + "[" + (length >= 0 ? length : "") + "]";
-    const dynamic = length === -1 || coder.dynamic;
-    super("array", type, localName, dynamic);
-    __publicField(this, "coder");
-    __publicField(this, "length");
-    defineProperties(this, { coder, length });
-  }
-  defaultValue() {
-    const defaultChild = this.coder.defaultValue();
-    const result = [];
-    for (let i = 0; i < this.length; i++) {
-      result.push(defaultChild);
-    }
-    return result;
-  }
-  encode(writer, _value) {
-    const value = Typed.dereference(_value, "array");
-    if (!Array.isArray(value)) {
-      this._throwError("expected array value", value);
-    }
-    let count = this.length;
-    if (count === -1) {
-      count = value.length;
-      writer.writeValue(value.length);
-    }
-    assertArgumentCount(value.length, count, "coder array" + (this.localName ? " " + this.localName : ""));
-    let coders = [];
-    for (let i = 0; i < value.length; i++) {
-      coders.push(this.coder);
-    }
-    return pack(writer, coders, value);
-  }
-  decode(reader) {
-    let count = this.length;
-    if (count === -1) {
-      count = reader.readIndex();
-      assert(count * WordSize <= reader.dataLength, "insufficient data length", "BUFFER_OVERRUN", { buffer: reader.bytes, offset: count * WordSize, length: reader.dataLength });
-    }
-    let coders = [];
-    for (let i = 0; i < count; i++) {
-      coders.push(new AnonymousCoder(this.coder));
-    }
-    return unpack(reader, coders);
+  this.message = message;
+  this.name = "AxiosError";
+  code && (this.code = code);
+  config && (this.config = config);
+  request && (this.request = request);
+  if (response) {
+    this.response = response;
+    this.status = response.status ? response.status : null;
   }
 }
+utils.inherits(AxiosError, Error, {
+  toJSON: function toJSON() {
+    return {
+      // Standard
+      message: this.message,
+      name: this.name,
+      // Microsoft
+      description: this.description,
+      number: this.number,
+      // Mozilla
+      fileName: this.fileName,
+      lineNumber: this.lineNumber,
+      columnNumber: this.columnNumber,
+      stack: this.stack,
+      // Axios
+      config: utils.toJSONObject(this.config),
+      code: this.code,
+      status: this.status
+    };
+  }
+});
+const prototype = AxiosError.prototype;
+const descriptors = {};
+[
+  "ERR_BAD_OPTION_VALUE",
+  "ERR_BAD_OPTION",
+  "ECONNABORTED",
+  "ETIMEDOUT",
+  "ERR_NETWORK",
+  "ERR_FR_TOO_MANY_REDIRECTS",
+  "ERR_DEPRECATED",
+  "ERR_BAD_RESPONSE",
+  "ERR_BAD_REQUEST",
+  "ERR_CANCELED",
+  "ERR_NOT_SUPPORT",
+  "ERR_INVALID_URL"
+  // eslint-disable-next-line func-names
+].forEach((code) => {
+  descriptors[code] = { value: code };
+});
+Object.defineProperties(AxiosError, descriptors);
+Object.defineProperty(prototype, "isAxiosError", { value: true });
+AxiosError.from = (error, code, config, request, response, customProps) => {
+  const axiosError = Object.create(prototype);
+  utils.toFlatObject(error, axiosError, function filter(obj) {
+    return obj !== Error.prototype;
+  }, (prop) => {
+    return prop !== "isAxiosError";
+  });
+  AxiosError.call(axiosError, error.message, code, config, request, response);
+  axiosError.cause = error;
+  axiosError.name = error.name;
+  customProps && Object.assign(axiosError, customProps);
+  return axiosError;
+};
 export {
-  ArrayCoder,
-  pack,
-  unpack
+  AxiosError as default
 };
 //# sourceMappingURL=standards-sdk.es43.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es43.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.es43.js","sources":["../../node_modules/axios/lib/core/AxiosError.js"],"sourcesContent":["'use strict';\n\nimport utils from '../utils.js';\n\n/**\n * Create an Error with the specified message, config, error code, request and response.\n *\n * @param {string} message The error message.\n * @param {string} [code] The error code (for example, 'ECONNABORTED').\n * @param {Object} [config] The config.\n * @param {Object} [request] The request.\n * @param {Object} [response] The response.\n *\n * @returns {Error} The created error.\n */\nfunction AxiosError(message, code, config, request, response) {\n  Error.call(this);\n\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, this.constructor);\n  } else {\n    this.stack = (new Error()).stack;\n  }\n\n  this.message = message;\n  this.name = 'AxiosError';\n  code && (this.code = code);\n  config && (this.config = config);\n  request && (this.request = request);\n  if (response) {\n    this.response = response;\n    this.status = response.status ? response.status : null;\n  }\n}\n\nutils.inherits(AxiosError, Error, {\n  toJSON: function toJSON() {\n    return {\n      // Standard\n      message: this.message,\n      name: this.name,\n      // Microsoft\n      description: this.description,\n      number: this.number,\n      // Mozilla\n      fileName: this.fileName,\n      lineNumber: this.lineNumber,\n      columnNumber: this.columnNumber,\n      stack: this.stack,\n      // Axios\n      config: utils.toJSONObject(this.config),\n      code: this.code,\n      status: this.status\n    };\n  }\n});\n\nconst prototype = AxiosError.prototype;\nconst descriptors = {};\n\n[\n  'ERR_BAD_OPTION_VALUE',\n  'ERR_BAD_OPTION',\n  'ECONNABORTED',\n  'ETIMEDOUT',\n  'ERR_NETWORK',\n  'ERR_FR_TOO_MANY_REDIRECTS',\n  'ERR_DEPRECATED',\n  'ERR_BAD_RESPONSE',\n  'ERR_BAD_REQUEST',\n  'ERR_CANCELED',\n  'ERR_NOT_SUPPORT',\n  'ERR_INVALID_URL'\n// eslint-disable-next-line func-names\n].forEach(code => {\n  descriptors[code] = {value: code};\n});\n\nObject.defineProperties(AxiosError, descriptors);\nObject.defineProperty(prototype, 'isAxiosError', {value: true});\n\n// eslint-disable-next-line func-names\nAxiosError.from = (error, code, config, request, response, customProps) => {\n  const axiosError = Object.create(prototype);\n\n  utils.toFlatObject(error, axiosError, function filter(obj) {\n    return obj !== Error.prototype;\n  }, prop => {\n    return prop !== 'isAxiosError';\n  });\n\n  AxiosError.call(axiosError, error.message, code, config, request, response);\n\n  axiosError.cause = error;\n\n  axiosError.name = error.name;\n\n  customProps && Object.assign(axiosError, customProps);\n\n  return axiosError;\n};\n\nexport default AxiosError;\n"],"names":[],"mappings":";AAeA,SAAS,WAAW,SAAS,MAAM,QAAQ,SAAS,UAAU;AAC5D,QAAM,KAAK,IAAI;AAEf,MAAI,MAAM,mBAAmB;AAC3B,UAAM,kBAAkB,MAAM,KAAK,WAAW;AAAA,EAClD,OAAS;AACL,SAAK,QAAS,IAAI,MAAO,EAAE;AAAA,EAC/B;AAEE,OAAK,UAAU;AACf,OAAK,OAAO;AACZ,WAAS,KAAK,OAAO;AACrB,aAAW,KAAK,SAAS;AACzB,cAAY,KAAK,UAAU;AAC3B,MAAI,UAAU;AACZ,SAAK,WAAW;AAChB,SAAK,SAAS,SAAS,SAAS,SAAS,SAAS;AAAA,EACtD;AACA;AAEA,MAAM,SAAS,YAAY,OAAO;AAAA,EAChC,QAAQ,SAAS,SAAS;AACxB,WAAO;AAAA;AAAA,MAEL,SAAS,KAAK;AAAA,MACd,MAAM,KAAK;AAAA;AAAA,MAEX,aAAa,KAAK;AAAA,MAClB,QAAQ,KAAK;AAAA;AAAA,MAEb,UAAU,KAAK;AAAA,MACf,YAAY,KAAK;AAAA,MACjB,cAAc,KAAK;AAAA,MACnB,OAAO,KAAK;AAAA;AAAA,MAEZ,QAAQ,MAAM,aAAa,KAAK,MAAM;AAAA,MACtC,MAAM,KAAK;AAAA,MACX,QAAQ,KAAK;AAAA,IACd;AAAA,EACL;AACA,CAAC;AAED,MAAM,YAAY,WAAW;AAC7B,MAAM,cAAc,CAAE;AAEtB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA;AAEF,EAAE,QAAQ,UAAQ;AAChB,cAAY,IAAI,IAAI,EAAC,OAAO,KAAI;AAClC,CAAC;AAED,OAAO,iBAAiB,YAAY,WAAW;AAC/C,OAAO,eAAe,WAAW,gBAAgB,EAAC,OAAO,KAAI,CAAC;AAG9D,WAAW,OAAO,CAAC,OAAO,MAAM,QAAQ,SAAS,UAAU,gBAAgB;AACzE,QAAM,aAAa,OAAO,OAAO,SAAS;AAE1C,QAAM,aAAa,OAAO,YAAY,SAAS,OAAO,KAAK;AACzD,WAAO,QAAQ,MAAM;AAAA,EACtB,GAAE,UAAQ;AACT,WAAO,SAAS;AAAA,EACpB,CAAG;AAED,aAAW,KAAK,YAAY,MAAM,SAAS,MAAM,QAAQ,SAAS,QAAQ;AAE1E,aAAW,QAAQ;AAEnB,aAAW,OAAO,MAAM;AAExB,iBAAe,OAAO,OAAO,YAAY,WAAW;AAEpD,SAAO;AACT;","x_google_ignoreList":[0]}

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

@@ -1,21 +1,9 @@
-import { Typed } from "./standards-sdk.es55.js";
-import { Coder } from "./standards-sdk.es41.js";
-class BooleanCoder extends Coder {
-  constructor(localName) {
-    super("bool", "bool", localName, false);
-  }
-  defaultValue() {
-    return false;
-  }
-  encode(writer, _value) {
-    const value = Typed.dereference(_value, "bool");
-    return writer.writeValue(value ? 1 : 0);
-  }
-  decode(reader) {
-    return !!reader.readValue();
-  }
+function spread(callback) {
+  return function wrap(arr) {
+    return callback.apply(null, arr);
+  };
 }
 export {
-  BooleanCoder
+  spread as default
 };
 //# sourceMappingURL=standards-sdk.es44.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es44.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.es44.js","sources":["../../node_modules/axios/lib/helpers/spread.js"],"sourcesContent":["'use strict';\n\n/**\n * Syntactic sugar for invoking a function and expanding an array for arguments.\n *\n * Common use case would be to use `Function.prototype.apply`.\n *\n *  ```js\n *  function f(x, y, z) {}\n *  var args = [1, 2, 3];\n *  f.apply(null, args);\n *  ```\n *\n * With `spread` this example can be re-written.\n *\n *  ```js\n *  spread(function(x, y, z) {})([1, 2, 3]);\n *  ```\n *\n * @param {Function} callback\n *\n * @returns {Function}\n */\nexport default function spread(callback) {\n  return function wrap(arr) {\n    return callback.apply(null, arr);\n  };\n}\n"],"names":[],"mappings":"AAuBe,SAAS,OAAO,UAAU;AACvC,SAAO,SAAS,KAAK,KAAK;AACxB,WAAO,SAAS,MAAM,MAAM,GAAG;AAAA,EAChC;AACH;","x_google_ignoreList":[0]}

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

@@ -1,32 +1,8 @@
-import { Coder } from "./standards-sdk.es41.js";
-import { hexlify, getBytesCopy } from "./standards-sdk.es38.js";
-class DynamicBytesCoder extends Coder {
-  constructor(type, localName) {
-    super(type, type, localName, true);
-  }
-  defaultValue() {
-    return "0x";
-  }
-  encode(writer, value) {
-    value = getBytesCopy(value);
-    let length = writer.writeValue(value.length);
-    length += writer.writeBytes(value);
-    return length;
-  }
-  decode(reader) {
-    return reader.readBytes(reader.readIndex(), true);
-  }
-}
-class BytesCoder extends DynamicBytesCoder {
-  constructor(localName) {
-    super("bytes", localName);
-  }
-  decode(reader) {
-    return hexlify(super.decode(reader));
-  }
+import utils from "./standards-sdk.es32.js";
+function isAxiosError(payload) {
+  return utils.isObject(payload) && payload.isAxiosError === true;
 }
 export {
-  BytesCoder,
-  DynamicBytesCoder
+  isAxiosError as default
 };
 //# sourceMappingURL=standards-sdk.es45.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es45.js","sources":["../../node_modules/ethers/lib.esm/abi/coders/bytes.js"],"sourcesContent":["import { getBytesCopy, hexlify } from \"../../utils/index.js\";\nimport { Coder } from \"./abstract-coder.js\";\n/**\n *  @_ignore\n */\nexport class DynamicBytesCoder extends Coder {\n    constructor(type, localName) {\n        super(type, type, localName, true);\n    }\n    defaultValue() {\n        return \"0x\";\n    }\n    encode(writer, value) {\n        value = getBytesCopy(value);\n        let length = writer.writeValue(value.length);\n        length += writer.writeBytes(value);\n        return length;\n    }\n    decode(reader) {\n        return reader.readBytes(reader.readIndex(), true);\n    }\n}\n/**\n *  @_ignore\n */\nexport class BytesCoder extends DynamicBytesCoder {\n    constructor(localName) {\n        super(\"bytes\", localName);\n    }\n    decode(reader) {\n        return hexlify(super.decode(reader));\n    }\n}\n//# sourceMappingURL=bytes.js.map"],"names":[],"mappings":";;AAKO,MAAM,0BAA0B,MAAM;AAAA,EACzC,YAAY,MAAM,WAAW;AACzB,UAAM,MAAM,MAAM,WAAW,IAAI;AAAA,EACzC;AAAA,EACI,eAAe;AACX,WAAO;AAAA,EACf;AAAA,EACI,OAAO,QAAQ,OAAO;AAClB,YAAQ,aAAa,KAAK;AAC1B,QAAI,SAAS,OAAO,WAAW,MAAM,MAAM;AAC3C,cAAU,OAAO,WAAW,KAAK;AACjC,WAAO;AAAA,EACf;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,OAAO,UAAU,OAAO,UAAS,GAAI,IAAI;AAAA,EACxD;AACA;AAIO,MAAM,mBAAmB,kBAAkB;AAAA,EAC9C,YAAY,WAAW;AACnB,UAAM,SAAS,SAAS;AAAA,EAChC;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,QAAQ,MAAM,OAAO,MAAM,CAAC;AAAA,EAC3C;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es45.js","sources":["../../node_modules/axios/lib/helpers/isAxiosError.js"],"sourcesContent":["'use strict';\n\nimport utils from './../utils.js';\n\n/**\n * Determines whether the payload is an error thrown by Axios\n *\n * @param {*} payload The value to test\n *\n * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false\n */\nexport default function isAxiosError(payload) {\n  return utils.isObject(payload) && (payload.isAxiosError === true);\n}\n"],"names":[],"mappings":";AAWe,SAAS,aAAa,SAAS;AAC5C,SAAO,MAAM,SAAS,OAAO,KAAM,QAAQ,iBAAiB;AAC9D;","x_google_ignoreList":[0]}