@hashgraphonline/standards-sdk 0.0.91 → 0.0.92

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

@@ -1,32 +1,94 @@
-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.es54.js";
-import { Coder } from "./standards-sdk.es36.js";
-import { defineProperties } from "./standards-sdk.es50.js";
-import { getBytesCopy, hexlify } from "./standards-sdk.es48.js";
-class FixedBytesCoder extends Coder {
-  constructor(size, localName) {
-    let name = "bytes" + String(size);
-    super(name, name, localName, false);
-    __publicField(this, "size");
-    defineProperties(this, { size }, { size: "number" });
-  }
-  defaultValue() {
-    return "0x0000000000000000000000000000000000000000000000000000000000000000".substring(0, 2 + this.size * 2);
-  }
-  encode(writer, _value) {
-    let data = getBytesCopy(Typed.dereference(_value, this.type));
-    if (data.length !== this.size) {
-      this._throwError("incorrect data length", _value);
+import { assert, assertArgument } from "./standards-sdk.es40.js";
+function _getBytes(value, name, copy) {
+  if (value instanceof Uint8Array) {
+    if (copy) {
+      return new Uint8Array(value);
     }
-    return writer.writeBytes(data);
+    return value;
   }
-  decode(reader) {
-    return hexlify(reader.readBytes(this.size));
+  if (typeof value === "string" && value.match(/^0x(?:[0-9a-f][0-9a-f])*$/i)) {
+    const result = new Uint8Array((value.length - 2) / 2);
+    let offset = 2;
+    for (let i = 0; i < result.length; i++) {
+      result[i] = parseInt(value.substring(offset, offset + 2), 16);
+      offset += 2;
+    }
+    return result;
+  }
+  assertArgument(false, "invalid BytesLike value", name || "value", value);
+}
+function getBytes(value, name) {
+  return _getBytes(value, name, false);
+}
+function getBytesCopy(value, name) {
+  return _getBytes(value, name, true);
+}
+function isHexString(value, length) {
+  if (typeof value !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
+    return false;
+  }
+  if (typeof length === "number" && value.length !== 2 + 2 * length) {
+    return false;
+  }
+  if (length === true && value.length % 2 !== 0) {
+    return false;
+  }
+  return true;
+}
+const HexCharacters = "0123456789abcdef";
+function hexlify(data) {
+  const bytes = getBytes(data);
+  let result = "0x";
+  for (let i = 0; i < bytes.length; i++) {
+    const v = bytes[i];
+    result += HexCharacters[(v & 240) >> 4] + HexCharacters[v & 15];
+  }
+  return result;
+}
+function concat(datas) {
+  return "0x" + datas.map((d) => hexlify(d).substring(2)).join("");
+}
+function dataSlice(data, start, end) {
+  const bytes = getBytes(data);
+  if (end != null && end > bytes.length) {
+    assert(false, "cannot slice beyond data bounds", "BUFFER_OVERRUN", {
+      buffer: bytes,
+      length: bytes.length,
+      offset: end
+    });
   }
+  return hexlify(bytes.slice(start == null ? 0 : start, end == null ? bytes.length : end));
+}
+function zeroPad(data, length, left) {
+  const bytes = getBytes(data);
+  assert(length >= bytes.length, "padding exceeds data length", "BUFFER_OVERRUN", {
+    buffer: new Uint8Array(bytes),
+    length,
+    offset: length + 1
+  });
+  const result = new Uint8Array(length);
+  result.fill(0);
+  if (left) {
+    result.set(bytes, length - bytes.length);
+  } else {
+    result.set(bytes, 0);
+  }
+  return hexlify(result);
+}
+function zeroPadValue(data, length) {
+  return zeroPad(data, length, true);
+}
+function zeroPadBytes(data, length) {
+  return zeroPad(data, length, false);
 }
 export {
-  FixedBytesCoder
+  concat,
+  dataSlice,
+  getBytes,
+  getBytesCopy,
+  hexlify,
+  isHexString,
+  zeroPadBytes,
+  zeroPadValue
 };
 //# sourceMappingURL=standards-sdk.es41.js.map

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/fixed-bytes.js"],"sourcesContent":["import { defineProperties, getBytesCopy, hexlify } from \"../../utils/index.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder } from \"./abstract-coder.js\";\n/**\n *  @_ignore\n */\nexport class FixedBytesCoder extends Coder {\n    size;\n    constructor(size, localName) {\n        let name = \"bytes\" + String(size);\n        super(name, name, localName, false);\n        defineProperties(this, { size }, { size: \"number\" });\n    }\n    defaultValue() {\n        return (\"0x0000000000000000000000000000000000000000000000000000000000000000\").substring(0, 2 + this.size * 2);\n    }\n    encode(writer, _value) {\n        let data = getBytesCopy(Typed.dereference(_value, this.type));\n        if (data.length !== this.size) {\n            this._throwError(\"incorrect data length\", _value);\n        }\n        return writer.writeBytes(data);\n    }\n    decode(reader) {\n        return hexlify(reader.readBytes(this.size));\n    }\n}\n//# sourceMappingURL=fixed-bytes.js.map"],"names":[],"mappings":";;;;;;;AAMO,MAAM,wBAAwB,MAAM;AAAA,EAEvC,YAAY,MAAM,WAAW;AACzB,QAAI,OAAO,UAAU,OAAO,IAAI;AAChC,UAAM,MAAM,MAAM,WAAW,KAAK;AAHtC;AAII,qBAAiB,MAAM,EAAE,KAAM,GAAE,EAAE,MAAM,UAAU;AAAA,EAC3D;AAAA,EACI,eAAe;AACX,WAAQ,qEAAsE,UAAU,GAAG,IAAI,KAAK,OAAO,CAAC;AAAA,EACpH;AAAA,EACI,OAAO,QAAQ,QAAQ;AACnB,QAAI,OAAO,aAAa,MAAM,YAAY,QAAQ,KAAK,IAAI,CAAC;AAC5D,QAAI,KAAK,WAAW,KAAK,MAAM;AAC3B,WAAK,YAAY,yBAAyB,MAAM;AAAA,IAC5D;AACQ,WAAO,OAAO,WAAW,IAAI;AAAA,EACrC;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,QAAQ,OAAO,UAAU,KAAK,IAAI,CAAC;AAAA,EAClD;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es41.js","sources":["../../node_modules/ethers/lib.esm/utils/data.js"],"sourcesContent":["/**\n *  Some data helpers.\n *\n *\n *  @_subsection api/utils:Data Helpers  [about-data]\n */\nimport { assert, assertArgument } from \"./errors.js\";\nfunction _getBytes(value, name, copy) {\n    if (value instanceof Uint8Array) {\n        if (copy) {\n            return new Uint8Array(value);\n        }\n        return value;\n    }\n    if (typeof (value) === \"string\" && value.match(/^0x(?:[0-9a-f][0-9a-f])*$/i)) {\n        const result = new Uint8Array((value.length - 2) / 2);\n        let offset = 2;\n        for (let i = 0; i < result.length; i++) {\n            result[i] = parseInt(value.substring(offset, offset + 2), 16);\n            offset += 2;\n        }\n        return result;\n    }\n    assertArgument(false, \"invalid BytesLike value\", name || \"value\", value);\n}\n/**\n *  Get a typed Uint8Array for %%value%%. If already a Uint8Array\n *  the original %%value%% is returned; if a copy is required use\n *  [[getBytesCopy]].\n *\n *  @see: getBytesCopy\n */\nexport function getBytes(value, name) {\n    return _getBytes(value, name, false);\n}\n/**\n *  Get a typed Uint8Array for %%value%%, creating a copy if necessary\n *  to prevent any modifications of the returned value from being\n *  reflected elsewhere.\n *\n *  @see: getBytes\n */\nexport function getBytesCopy(value, name) {\n    return _getBytes(value, name, true);\n}\n/**\n *  Returns true if %%value%% is a valid [[HexString]].\n *\n *  If %%length%% is ``true`` or a //number//, it also checks that\n *  %%value%% is a valid [[DataHexString]] of %%length%% (if a //number//)\n *  bytes of data (e.g. ``0x1234`` is 2 bytes).\n */\nexport function isHexString(value, length) {\n    if (typeof (value) !== \"string\" || !value.match(/^0x[0-9A-Fa-f]*$/)) {\n        return false;\n    }\n    if (typeof (length) === \"number\" && value.length !== 2 + 2 * length) {\n        return false;\n    }\n    if (length === true && (value.length % 2) !== 0) {\n        return false;\n    }\n    return true;\n}\n/**\n *  Returns true if %%value%% is a valid representation of arbitrary\n *  data (i.e. a valid [[DataHexString]] or a Uint8Array).\n */\nexport function isBytesLike(value) {\n    return (isHexString(value, true) || (value instanceof Uint8Array));\n}\nconst HexCharacters = \"0123456789abcdef\";\n/**\n *  Returns a [[DataHexString]] representation of %%data%%.\n */\nexport function hexlify(data) {\n    const bytes = getBytes(data);\n    let result = \"0x\";\n    for (let i = 0; i < bytes.length; i++) {\n        const v = bytes[i];\n        result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];\n    }\n    return result;\n}\n/**\n *  Returns a [[DataHexString]] by concatenating all values\n *  within %%data%%.\n */\nexport function concat(datas) {\n    return \"0x\" + datas.map((d) => hexlify(d).substring(2)).join(\"\");\n}\n/**\n *  Returns the length of %%data%%, in bytes.\n */\nexport function dataLength(data) {\n    if (isHexString(data, true)) {\n        return (data.length - 2) / 2;\n    }\n    return getBytes(data).length;\n}\n/**\n *  Returns a [[DataHexString]] by slicing %%data%% from the %%start%%\n *  offset to the %%end%% offset.\n *\n *  By default %%start%% is 0 and %%end%% is the length of %%data%%.\n */\nexport function dataSlice(data, start, end) {\n    const bytes = getBytes(data);\n    if (end != null && end > bytes.length) {\n        assert(false, \"cannot slice beyond data bounds\", \"BUFFER_OVERRUN\", {\n            buffer: bytes, length: bytes.length, offset: end\n        });\n    }\n    return hexlify(bytes.slice((start == null) ? 0 : start, (end == null) ? bytes.length : end));\n}\n/**\n *  Return the [[DataHexString]] result by stripping all **leading**\n ** zero bytes from %%data%%.\n */\nexport function stripZerosLeft(data) {\n    let bytes = hexlify(data).substring(2);\n    while (bytes.startsWith(\"00\")) {\n        bytes = bytes.substring(2);\n    }\n    return \"0x\" + bytes;\n}\nfunction zeroPad(data, length, left) {\n    const bytes = getBytes(data);\n    assert(length >= bytes.length, \"padding exceeds data length\", \"BUFFER_OVERRUN\", {\n        buffer: new Uint8Array(bytes),\n        length: length,\n        offset: length + 1\n    });\n    const result = new Uint8Array(length);\n    result.fill(0);\n    if (left) {\n        result.set(bytes, length - bytes.length);\n    }\n    else {\n        result.set(bytes, 0);\n    }\n    return hexlify(result);\n}\n/**\n *  Return the [[DataHexString]] of %%data%% padded on the **left**\n *  to %%length%% bytes.\n *\n *  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is\n *  thrown.\n *\n *  This pads data the same as **values** are in Solidity\n *  (e.g. ``uint128``).\n */\nexport function zeroPadValue(data, length) {\n    return zeroPad(data, length, true);\n}\n/**\n *  Return the [[DataHexString]] of %%data%% padded on the **right**\n *  to %%length%% bytes.\n *\n *  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is\n *  thrown.\n *\n *  This pads data the same as **bytes** are in Solidity\n *  (e.g. ``bytes16``).\n */\nexport function zeroPadBytes(data, length) {\n    return zeroPad(data, length, false);\n}\n//# sourceMappingURL=data.js.map"],"names":[],"mappings":";AAOA,SAAS,UAAU,OAAO,MAAM,MAAM;AAClC,MAAI,iBAAiB,YAAY;AAC7B,QAAI,MAAM;AACN,aAAO,IAAI,WAAW,KAAK;AAAA,IACvC;AACQ,WAAO;AAAA,EACf;AACI,MAAI,OAAQ,UAAW,YAAY,MAAM,MAAM,4BAA4B,GAAG;AAC1E,UAAM,SAAS,IAAI,YAAY,MAAM,SAAS,KAAK,CAAC;AACpD,QAAI,SAAS;AACb,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACpC,aAAO,CAAC,IAAI,SAAS,MAAM,UAAU,QAAQ,SAAS,CAAC,GAAG,EAAE;AAC5D,gBAAU;AAAA,IACtB;AACQ,WAAO;AAAA,EACf;AACI,iBAAe,OAAO,2BAA2B,QAAQ,SAAS,KAAK;AAC3E;AAQO,SAAS,SAAS,OAAO,MAAM;AAClC,SAAO,UAAU,OAAO,MAAM,KAAK;AACvC;AAQO,SAAS,aAAa,OAAO,MAAM;AACtC,SAAO,UAAU,OAAO,MAAM,IAAI;AACtC;AAQO,SAAS,YAAY,OAAO,QAAQ;AACvC,MAAI,OAAQ,UAAW,YAAY,CAAC,MAAM,MAAM,kBAAkB,GAAG;AACjE,WAAO;AAAA,EACf;AACI,MAAI,OAAQ,WAAY,YAAY,MAAM,WAAW,IAAI,IAAI,QAAQ;AACjE,WAAO;AAAA,EACf;AACI,MAAI,WAAW,QAAS,MAAM,SAAS,MAAO,GAAG;AAC7C,WAAO;AAAA,EACf;AACI,SAAO;AACX;AAQA,MAAM,gBAAgB;AAIf,SAAS,QAAQ,MAAM;AAC1B,QAAM,QAAQ,SAAS,IAAI;AAC3B,MAAI,SAAS;AACb,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,UAAM,IAAI,MAAM,CAAC;AACjB,cAAU,eAAe,IAAI,QAAS,CAAC,IAAI,cAAc,IAAI,EAAI;AAAA,EACzE;AACI,SAAO;AACX;AAKO,SAAS,OAAO,OAAO;AAC1B,SAAO,OAAO,MAAM,IAAI,CAAC,MAAM,QAAQ,CAAC,EAAE,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE;AACnE;AAgBO,SAAS,UAAU,MAAM,OAAO,KAAK;AACxC,QAAM,QAAQ,SAAS,IAAI;AAC3B,MAAI,OAAO,QAAQ,MAAM,MAAM,QAAQ;AACnC,WAAO,OAAO,mCAAmC,kBAAkB;AAAA,MAC/D,QAAQ;AAAA,MAAO,QAAQ,MAAM;AAAA,MAAQ,QAAQ;AAAA,IACzD,CAAS;AAAA,EACT;AACI,SAAO,QAAQ,MAAM,MAAO,SAAS,OAAQ,IAAI,OAAQ,OAAO,OAAQ,MAAM,SAAS,GAAG,CAAC;AAC/F;AAYA,SAAS,QAAQ,MAAM,QAAQ,MAAM;AACjC,QAAM,QAAQ,SAAS,IAAI;AAC3B,SAAO,UAAU,MAAM,QAAQ,+BAA+B,kBAAkB;AAAA,IAC5E,QAAQ,IAAI,WAAW,KAAK;AAAA,IAC5B;AAAA,IACA,QAAQ,SAAS;AAAA,EACzB,CAAK;AACD,QAAM,SAAS,IAAI,WAAW,MAAM;AACpC,SAAO,KAAK,CAAC;AACb,MAAI,MAAM;AACN,WAAO,IAAI,OAAO,SAAS,MAAM,MAAM;AAAA,EAC/C,OACS;AACD,WAAO,IAAI,OAAO,CAAC;AAAA,EAC3B;AACI,SAAO,QAAQ,MAAM;AACzB;AAWO,SAAS,aAAa,MAAM,QAAQ;AACvC,SAAO,QAAQ,MAAM,QAAQ,IAAI;AACrC;AAWO,SAAS,aAAa,MAAM,QAAQ;AACvC,SAAO,QAAQ,MAAM,QAAQ,KAAK;AACtC;","x_google_ignoreList":[0]}

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

@@ -1,24 +1,367 @@
-import { Coder } from "./standards-sdk.es36.js";
-const Empty = new Uint8Array([]);
-class NullCoder extends Coder {
-  constructor(localName) {
-    super("null", "", localName, false);
+import global from "./standards-sdk.es37.js";
+import process$1 from "./standards-sdk.es82.js";
+import bind from "./standards-sdk.es43.js";
+const { toString } = Object.prototype;
+const { getPrototypeOf } = Object;
+const kindOf = /* @__PURE__ */ ((cache) => (thing) => {
+  const str = toString.call(thing);
+  return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());
+})(/* @__PURE__ */ Object.create(null));
+const kindOfTest = (type) => {
+  type = type.toLowerCase();
+  return (thing) => kindOf(thing) === type;
+};
+const typeOfTest = (type) => (thing) => typeof thing === type;
+const { isArray } = Array;
+const isUndefined = typeOfTest("undefined");
+function isBuffer(val) {
+  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
+}
+const isArrayBuffer = kindOfTest("ArrayBuffer");
+function isArrayBufferView(val) {
+  let result;
+  if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
+    result = ArrayBuffer.isView(val);
+  } else {
+    result = val && val.buffer && isArrayBuffer(val.buffer);
+  }
+  return result;
+}
+const isString = typeOfTest("string");
+const isFunction = typeOfTest("function");
+const isNumber = typeOfTest("number");
+const isObject = (thing) => thing !== null && typeof thing === "object";
+const isBoolean = (thing) => thing === true || thing === false;
+const isPlainObject = (val) => {
+  if (kindOf(val) !== "object") {
+    return false;
+  }
+  const prototype = getPrototypeOf(val);
+  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in val) && !(Symbol.iterator in val);
+};
+const isDate = kindOfTest("Date");
+const isFile = kindOfTest("File");
+const isBlob = kindOfTest("Blob");
+const isFileList = kindOfTest("FileList");
+const isStream = (val) => isObject(val) && isFunction(val.pipe);
+const isFormData = (thing) => {
+  let kind;
+  return thing && (typeof FormData === "function" && thing instanceof FormData || isFunction(thing.append) && ((kind = kindOf(thing)) === "formdata" || // detect form-data instance
+  kind === "object" && isFunction(thing.toString) && thing.toString() === "[object FormData]"));
+};
+const isURLSearchParams = kindOfTest("URLSearchParams");
+const [isReadableStream, isRequest, isResponse, isHeaders] = ["ReadableStream", "Request", "Response", "Headers"].map(kindOfTest);
+const trim = (str) => str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
+function forEach(obj, fn, { allOwnKeys = false } = {}) {
+  if (obj === null || typeof obj === "undefined") {
+    return;
+  }
+  let i;
+  let l;
+  if (typeof obj !== "object") {
+    obj = [obj];
+  }
+  if (isArray(obj)) {
+    for (i = 0, l = obj.length; i < l; i++) {
+      fn.call(null, obj[i], i, obj);
+    }
+  } else {
+    const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
+    const len = keys.length;
+    let key;
+    for (i = 0; i < len; i++) {
+      key = keys[i];
+      fn.call(null, obj[key], key, obj);
+    }
   }
-  defaultValue() {
-    return null;
+}
+function findKey(obj, key) {
+  key = key.toLowerCase();
+  const keys = Object.keys(obj);
+  let i = keys.length;
+  let _key;
+  while (i-- > 0) {
+    _key = keys[i];
+    if (key === _key.toLowerCase()) {
+      return _key;
+    }
+  }
+  return null;
+}
+const _global = (() => {
+  if (typeof globalThis !== "undefined") return globalThis;
+  return typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : global;
+})();
+const isContextDefined = (context) => !isUndefined(context) && context !== _global;
+function merge() {
+  const { caseless } = isContextDefined(this) && this || {};
+  const result = {};
+  const assignValue = (val, key) => {
+    const targetKey = caseless && findKey(result, key) || key;
+    if (isPlainObject(result[targetKey]) && isPlainObject(val)) {
+      result[targetKey] = merge(result[targetKey], val);
+    } else if (isPlainObject(val)) {
+      result[targetKey] = merge({}, val);
+    } else if (isArray(val)) {
+      result[targetKey] = val.slice();
+    } else {
+      result[targetKey] = val;
+    }
+  };
+  for (let i = 0, l = arguments.length; i < l; i++) {
+    arguments[i] && forEach(arguments[i], assignValue);
   }
-  encode(writer, value) {
-    if (value != null) {
-      this._throwError("not null", value);
+  return result;
+}
+const extend = (a, b, thisArg, { allOwnKeys } = {}) => {
+  forEach(b, (val, key) => {
+    if (thisArg && isFunction(val)) {
+      a[key] = bind(val, thisArg);
+    } else {
+      a[key] = val;
+    }
+  }, { allOwnKeys });
+  return a;
+};
+const stripBOM = (content) => {
+  if (content.charCodeAt(0) === 65279) {
+    content = content.slice(1);
+  }
+  return content;
+};
+const inherits = (constructor, superConstructor, props, descriptors) => {
+  constructor.prototype = Object.create(superConstructor.prototype, descriptors);
+  constructor.prototype.constructor = constructor;
+  Object.defineProperty(constructor, "super", {
+    value: superConstructor.prototype
+  });
+  props && Object.assign(constructor.prototype, props);
+};
+const toFlatObject = (sourceObj, destObj, filter, propFilter) => {
+  let props;
+  let i;
+  let prop;
+  const merged = {};
+  destObj = destObj || {};
+  if (sourceObj == null) return destObj;
+  do {
+    props = Object.getOwnPropertyNames(sourceObj);
+    i = props.length;
+    while (i-- > 0) {
+      prop = props[i];
+      if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {
+        destObj[prop] = sourceObj[prop];
+        merged[prop] = true;
+      }
     }
-    return writer.writeBytes(Empty);
+    sourceObj = filter !== false && getPrototypeOf(sourceObj);
+  } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);
+  return destObj;
+};
+const endsWith = (str, searchString, position) => {
+  str = String(str);
+  if (position === void 0 || position > str.length) {
+    position = str.length;
+  }
+  position -= searchString.length;
+  const lastIndex = str.indexOf(searchString, position);
+  return lastIndex !== -1 && lastIndex === position;
+};
+const toArray = (thing) => {
+  if (!thing) return null;
+  if (isArray(thing)) return thing;
+  let i = thing.length;
+  if (!isNumber(i)) return null;
+  const arr = new Array(i);
+  while (i-- > 0) {
+    arr[i] = thing[i];
   }
-  decode(reader) {
-    reader.readBytes(0);
-    return null;
+  return arr;
+};
+const isTypedArray = /* @__PURE__ */ ((TypedArray) => {
+  return (thing) => {
+    return TypedArray && thing instanceof TypedArray;
+  };
+})(typeof Uint8Array !== "undefined" && getPrototypeOf(Uint8Array));
+const forEachEntry = (obj, fn) => {
+  const generator = obj && obj[Symbol.iterator];
+  const iterator = generator.call(obj);
+  let result;
+  while ((result = iterator.next()) && !result.done) {
+    const pair = result.value;
+    fn.call(obj, pair[0], pair[1]);
+  }
+};
+const matchAll = (regExp, str) => {
+  let matches;
+  const arr = [];
+  while ((matches = regExp.exec(str)) !== null) {
+    arr.push(matches);
   }
+  return arr;
+};
+const isHTMLForm = kindOfTest("HTMLFormElement");
+const toCamelCase = (str) => {
+  return str.toLowerCase().replace(
+    /[-_\s]([a-z\d])(\w*)/g,
+    function replacer(m, p1, p2) {
+      return p1.toUpperCase() + p2;
+    }
+  );
+};
+const hasOwnProperty = (({ hasOwnProperty: hasOwnProperty2 }) => (obj, prop) => hasOwnProperty2.call(obj, prop))(Object.prototype);
+const isRegExp = kindOfTest("RegExp");
+const reduceDescriptors = (obj, reducer) => {
+  const descriptors = Object.getOwnPropertyDescriptors(obj);
+  const reducedDescriptors = {};
+  forEach(descriptors, (descriptor, name) => {
+    let ret;
+    if ((ret = reducer(descriptor, name, obj)) !== false) {
+      reducedDescriptors[name] = ret || descriptor;
+    }
+  });
+  Object.defineProperties(obj, reducedDescriptors);
+};
+const freezeMethods = (obj) => {
+  reduceDescriptors(obj, (descriptor, name) => {
+    if (isFunction(obj) && ["arguments", "caller", "callee"].indexOf(name) !== -1) {
+      return false;
+    }
+    const value = obj[name];
+    if (!isFunction(value)) return;
+    descriptor.enumerable = false;
+    if ("writable" in descriptor) {
+      descriptor.writable = false;
+      return;
+    }
+    if (!descriptor.set) {
+      descriptor.set = () => {
+        throw Error("Can not rewrite read-only method '" + name + "'");
+      };
+    }
+  });
+};
+const toObjectSet = (arrayOrString, delimiter) => {
+  const obj = {};
+  const define = (arr) => {
+    arr.forEach((value) => {
+      obj[value] = true;
+    });
+  };
+  isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));
+  return obj;
+};
+const noop = () => {
+};
+const toFiniteNumber = (value, defaultValue) => {
+  return value != null && Number.isFinite(value = +value) ? value : defaultValue;
+};
+function isSpecCompliantForm(thing) {
+  return !!(thing && isFunction(thing.append) && thing[Symbol.toStringTag] === "FormData" && thing[Symbol.iterator]);
 }
+const toJSONObject = (obj) => {
+  const stack = new Array(10);
+  const visit = (source, i) => {
+    if (isObject(source)) {
+      if (stack.indexOf(source) >= 0) {
+        return;
+      }
+      if (!("toJSON" in source)) {
+        stack[i] = source;
+        const target = isArray(source) ? [] : {};
+        forEach(source, (value, key) => {
+          const reducedValue = visit(value, i + 1);
+          !isUndefined(reducedValue) && (target[key] = reducedValue);
+        });
+        stack[i] = void 0;
+        return target;
+      }
+    }
+    return source;
+  };
+  return visit(obj, 0);
+};
+const isAsyncFn = kindOfTest("AsyncFunction");
+const isThenable = (thing) => thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);
+const _setImmediate = ((setImmediateSupported, postMessageSupported) => {
+  if (setImmediateSupported) {
+    return setImmediate;
+  }
+  return postMessageSupported ? ((token, callbacks) => {
+    _global.addEventListener("message", ({ source, data }) => {
+      if (source === _global && data === token) {
+        callbacks.length && callbacks.shift()();
+      }
+    }, false);
+    return (cb) => {
+      callbacks.push(cb);
+      _global.postMessage(token, "*");
+    };
+  })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
+})(
+  typeof setImmediate === "function",
+  isFunction(_global.postMessage)
+);
+const asap = typeof queueMicrotask !== "undefined" ? queueMicrotask.bind(_global) : typeof process$1 !== "undefined" && process$1.nextTick || _setImmediate;
+const utils = {
+  isArray,
+  isArrayBuffer,
+  isBuffer,
+  isFormData,
+  isArrayBufferView,
+  isString,
+  isNumber,
+  isBoolean,
+  isObject,
+  isPlainObject,
+  isReadableStream,
+  isRequest,
+  isResponse,
+  isHeaders,
+  isUndefined,
+  isDate,
+  isFile,
+  isBlob,
+  isRegExp,
+  isFunction,
+  isStream,
+  isURLSearchParams,
+  isTypedArray,
+  isFileList,
+  forEach,
+  merge,
+  extend,
+  trim,
+  stripBOM,
+  inherits,
+  toFlatObject,
+  kindOf,
+  kindOfTest,
+  endsWith,
+  toArray,
+  forEachEntry,
+  matchAll,
+  isHTMLForm,
+  hasOwnProperty,
+  hasOwnProp: hasOwnProperty,
+  // an alias to avoid ESLint no-prototype-builtins detection
+  reduceDescriptors,
+  freezeMethods,
+  toObjectSet,
+  toCamelCase,
+  noop,
+  toFiniteNumber,
+  findKey,
+  global: _global,
+  isContextDefined,
+  isSpecCompliantForm,
+  toJSONObject,
+  isAsyncFn,
+  isThenable,
+  setImmediate: _setImmediate,
+  asap
+};
 export {
-  NullCoder
+  utils 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/null.js"],"sourcesContent":["import { Coder } from \"./abstract-coder.js\";\nconst Empty = new Uint8Array([]);\n/**\n *  @_ignore\n */\nexport class NullCoder extends Coder {\n    constructor(localName) {\n        super(\"null\", \"\", localName, false);\n    }\n    defaultValue() {\n        return null;\n    }\n    encode(writer, value) {\n        if (value != null) {\n            this._throwError(\"not null\", value);\n        }\n        return writer.writeBytes(Empty);\n    }\n    decode(reader) {\n        reader.readBytes(0);\n        return null;\n    }\n}\n//# sourceMappingURL=null.js.map"],"names":[],"mappings":";AACA,MAAM,QAAQ,IAAI,WAAW,EAAE;AAIxB,MAAM,kBAAkB,MAAM;AAAA,EACjC,YAAY,WAAW;AACnB,UAAM,QAAQ,IAAI,WAAW,KAAK;AAAA,EAC1C;AAAA,EACI,eAAe;AACX,WAAO;AAAA,EACf;AAAA,EACI,OAAO,QAAQ,OAAO;AAClB,QAAI,SAAS,MAAM;AACf,WAAK,YAAY,YAAY,KAAK;AAAA,IAC9C;AACQ,WAAO,OAAO,WAAW,KAAK;AAAA,EACtC;AAAA,EACI,OAAO,QAAQ;AACX,WAAO,UAAU,CAAC;AAClB,WAAO;AAAA,EACf;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es42.js","sources":["../../node_modules/axios/lib/utils.js"],"sourcesContent":["'use strict';\n\nimport bind from './helpers/bind.js';\n\n// utils is a library of generic helper functions non-specific to axios\n\nconst {toString} = Object.prototype;\nconst {getPrototypeOf} = Object;\n\nconst kindOf = (cache => thing => {\n    const str = toString.call(thing);\n    return cache[str] || (cache[str] = str.slice(8, -1).toLowerCase());\n})(Object.create(null));\n\nconst kindOfTest = (type) => {\n  type = type.toLowerCase();\n  return (thing) => kindOf(thing) === type\n}\n\nconst typeOfTest = type => thing => typeof thing === type;\n\n/**\n * Determine if a value is an Array\n *\n * @param {Object} val The value to test\n *\n * @returns {boolean} True if value is an Array, otherwise false\n */\nconst {isArray} = Array;\n\n/**\n * Determine if a value is undefined\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if the value is undefined, otherwise false\n */\nconst isUndefined = typeOfTest('undefined');\n\n/**\n * Determine if a value is a Buffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Buffer, otherwise false\n */\nfunction isBuffer(val) {\n  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)\n    && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);\n}\n\n/**\n * Determine if a value is an ArrayBuffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is an ArrayBuffer, otherwise false\n */\nconst isArrayBuffer = kindOfTest('ArrayBuffer');\n\n\n/**\n * Determine if a value is a view on an ArrayBuffer\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a view on an ArrayBuffer, otherwise false\n */\nfunction isArrayBufferView(val) {\n  let result;\n  if ((typeof ArrayBuffer !== 'undefined') && (ArrayBuffer.isView)) {\n    result = ArrayBuffer.isView(val);\n  } else {\n    result = (val) && (val.buffer) && (isArrayBuffer(val.buffer));\n  }\n  return result;\n}\n\n/**\n * Determine if a value is a String\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a String, otherwise false\n */\nconst isString = typeOfTest('string');\n\n/**\n * Determine if a value is a Function\n *\n * @param {*} val The value to test\n * @returns {boolean} True if value is a Function, otherwise false\n */\nconst isFunction = typeOfTest('function');\n\n/**\n * Determine if a value is a Number\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Number, otherwise false\n */\nconst isNumber = typeOfTest('number');\n\n/**\n * Determine if a value is an Object\n *\n * @param {*} thing The value to test\n *\n * @returns {boolean} True if value is an Object, otherwise false\n */\nconst isObject = (thing) => thing !== null && typeof thing === 'object';\n\n/**\n * Determine if a value is a Boolean\n *\n * @param {*} thing The value to test\n * @returns {boolean} True if value is a Boolean, otherwise false\n */\nconst isBoolean = thing => thing === true || thing === false;\n\n/**\n * Determine if a value is a plain Object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a plain Object, otherwise false\n */\nconst isPlainObject = (val) => {\n  if (kindOf(val) !== 'object') {\n    return false;\n  }\n\n  const prototype = getPrototypeOf(val);\n  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(Symbol.toStringTag in val) && !(Symbol.iterator in val);\n}\n\n/**\n * Determine if a value is a Date\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Date, otherwise false\n */\nconst isDate = kindOfTest('Date');\n\n/**\n * Determine if a value is a File\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a File, otherwise false\n */\nconst isFile = kindOfTest('File');\n\n/**\n * Determine if a value is a Blob\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Blob, otherwise false\n */\nconst isBlob = kindOfTest('Blob');\n\n/**\n * Determine if a value is a FileList\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a File, otherwise false\n */\nconst isFileList = kindOfTest('FileList');\n\n/**\n * Determine if a value is a Stream\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a Stream, otherwise false\n */\nconst isStream = (val) => isObject(val) && isFunction(val.pipe);\n\n/**\n * Determine if a value is a FormData\n *\n * @param {*} thing The value to test\n *\n * @returns {boolean} True if value is an FormData, otherwise false\n */\nconst isFormData = (thing) => {\n  let kind;\n  return thing && (\n    (typeof FormData === 'function' && thing instanceof FormData) || (\n      isFunction(thing.append) && (\n        (kind = kindOf(thing)) === 'formdata' ||\n        // detect form-data instance\n        (kind === 'object' && isFunction(thing.toString) && thing.toString() === '[object FormData]')\n      )\n    )\n  )\n}\n\n/**\n * Determine if a value is a URLSearchParams object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a URLSearchParams object, otherwise false\n */\nconst isURLSearchParams = kindOfTest('URLSearchParams');\n\nconst [isReadableStream, isRequest, isResponse, isHeaders] = ['ReadableStream', 'Request', 'Response', 'Headers'].map(kindOfTest);\n\n/**\n * Trim excess whitespace off the beginning and end of a string\n *\n * @param {String} str The String to trim\n *\n * @returns {String} The String freed of excess whitespace\n */\nconst trim = (str) => str.trim ?\n  str.trim() : str.replace(/^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g, '');\n\n/**\n * Iterate over an Array or an Object invoking a function for each item.\n *\n * If `obj` is an Array callback will be called passing\n * the value, index, and complete array for each item.\n *\n * If 'obj' is an Object callback will be called passing\n * the value, key, and complete object for each property.\n *\n * @param {Object|Array} obj The object to iterate\n * @param {Function} fn The callback to invoke for each item\n *\n * @param {Boolean} [allOwnKeys = false]\n * @returns {any}\n */\nfunction forEach(obj, fn, {allOwnKeys = false} = {}) {\n  // Don't bother if no value provided\n  if (obj === null || typeof obj === 'undefined') {\n    return;\n  }\n\n  let i;\n  let l;\n\n  // Force an array if not already something iterable\n  if (typeof obj !== 'object') {\n    /*eslint no-param-reassign:0*/\n    obj = [obj];\n  }\n\n  if (isArray(obj)) {\n    // Iterate over array values\n    for (i = 0, l = obj.length; i < l; i++) {\n      fn.call(null, obj[i], i, obj);\n    }\n  } else {\n    // Iterate over object keys\n    const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);\n    const len = keys.length;\n    let key;\n\n    for (i = 0; i < len; i++) {\n      key = keys[i];\n      fn.call(null, obj[key], key, obj);\n    }\n  }\n}\n\nfunction findKey(obj, key) {\n  key = key.toLowerCase();\n  const keys = Object.keys(obj);\n  let i = keys.length;\n  let _key;\n  while (i-- > 0) {\n    _key = keys[i];\n    if (key === _key.toLowerCase()) {\n      return _key;\n    }\n  }\n  return null;\n}\n\nconst _global = (() => {\n  /*eslint no-undef:0*/\n  if (typeof globalThis !== \"undefined\") return globalThis;\n  return typeof self !== \"undefined\" ? self : (typeof window !== 'undefined' ? window : global)\n})();\n\nconst isContextDefined = (context) => !isUndefined(context) && context !== _global;\n\n/**\n * Accepts varargs expecting each argument to be an object, then\n * immutably merges the properties of each object and returns result.\n *\n * When multiple objects contain the same key the later object in\n * the arguments list will take precedence.\n *\n * Example:\n *\n * ```js\n * var result = merge({foo: 123}, {foo: 456});\n * console.log(result.foo); // outputs 456\n * ```\n *\n * @param {Object} obj1 Object to merge\n *\n * @returns {Object} Result of all merge properties\n */\nfunction merge(/* obj1, obj2, obj3, ... */) {\n  const {caseless} = isContextDefined(this) && this || {};\n  const result = {};\n  const assignValue = (val, key) => {\n    const targetKey = caseless && findKey(result, key) || key;\n    if (isPlainObject(result[targetKey]) && isPlainObject(val)) {\n      result[targetKey] = merge(result[targetKey], val);\n    } else if (isPlainObject(val)) {\n      result[targetKey] = merge({}, val);\n    } else if (isArray(val)) {\n      result[targetKey] = val.slice();\n    } else {\n      result[targetKey] = val;\n    }\n  }\n\n  for (let i = 0, l = arguments.length; i < l; i++) {\n    arguments[i] && forEach(arguments[i], assignValue);\n  }\n  return result;\n}\n\n/**\n * Extends object a by mutably adding to it the properties of object b.\n *\n * @param {Object} a The object to be extended\n * @param {Object} b The object to copy properties from\n * @param {Object} thisArg The object to bind function to\n *\n * @param {Boolean} [allOwnKeys]\n * @returns {Object} The resulting value of object a\n */\nconst extend = (a, b, thisArg, {allOwnKeys}= {}) => {\n  forEach(b, (val, key) => {\n    if (thisArg && isFunction(val)) {\n      a[key] = bind(val, thisArg);\n    } else {\n      a[key] = val;\n    }\n  }, {allOwnKeys});\n  return a;\n}\n\n/**\n * Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)\n *\n * @param {string} content with BOM\n *\n * @returns {string} content value without BOM\n */\nconst stripBOM = (content) => {\n  if (content.charCodeAt(0) === 0xFEFF) {\n    content = content.slice(1);\n  }\n  return content;\n}\n\n/**\n * Inherit the prototype methods from one constructor into another\n * @param {function} constructor\n * @param {function} superConstructor\n * @param {object} [props]\n * @param {object} [descriptors]\n *\n * @returns {void}\n */\nconst inherits = (constructor, superConstructor, props, descriptors) => {\n  constructor.prototype = Object.create(superConstructor.prototype, descriptors);\n  constructor.prototype.constructor = constructor;\n  Object.defineProperty(constructor, 'super', {\n    value: superConstructor.prototype\n  });\n  props && Object.assign(constructor.prototype, props);\n}\n\n/**\n * Resolve object with deep prototype chain to a flat object\n * @param {Object} sourceObj source object\n * @param {Object} [destObj]\n * @param {Function|Boolean} [filter]\n * @param {Function} [propFilter]\n *\n * @returns {Object}\n */\nconst toFlatObject = (sourceObj, destObj, filter, propFilter) => {\n  let props;\n  let i;\n  let prop;\n  const merged = {};\n\n  destObj = destObj || {};\n  // eslint-disable-next-line no-eq-null,eqeqeq\n  if (sourceObj == null) return destObj;\n\n  do {\n    props = Object.getOwnPropertyNames(sourceObj);\n    i = props.length;\n    while (i-- > 0) {\n      prop = props[i];\n      if ((!propFilter || propFilter(prop, sourceObj, destObj)) && !merged[prop]) {\n        destObj[prop] = sourceObj[prop];\n        merged[prop] = true;\n      }\n    }\n    sourceObj = filter !== false && getPrototypeOf(sourceObj);\n  } while (sourceObj && (!filter || filter(sourceObj, destObj)) && sourceObj !== Object.prototype);\n\n  return destObj;\n}\n\n/**\n * Determines whether a string ends with the characters of a specified string\n *\n * @param {String} str\n * @param {String} searchString\n * @param {Number} [position= 0]\n *\n * @returns {boolean}\n */\nconst endsWith = (str, searchString, position) => {\n  str = String(str);\n  if (position === undefined || position > str.length) {\n    position = str.length;\n  }\n  position -= searchString.length;\n  const lastIndex = str.indexOf(searchString, position);\n  return lastIndex !== -1 && lastIndex === position;\n}\n\n\n/**\n * Returns new array from array like object or null if failed\n *\n * @param {*} [thing]\n *\n * @returns {?Array}\n */\nconst toArray = (thing) => {\n  if (!thing) return null;\n  if (isArray(thing)) return thing;\n  let i = thing.length;\n  if (!isNumber(i)) return null;\n  const arr = new Array(i);\n  while (i-- > 0) {\n    arr[i] = thing[i];\n  }\n  return arr;\n}\n\n/**\n * Checking if the Uint8Array exists and if it does, it returns a function that checks if the\n * thing passed in is an instance of Uint8Array\n *\n * @param {TypedArray}\n *\n * @returns {Array}\n */\n// eslint-disable-next-line func-names\nconst isTypedArray = (TypedArray => {\n  // eslint-disable-next-line func-names\n  return thing => {\n    return TypedArray && thing instanceof TypedArray;\n  };\n})(typeof Uint8Array !== 'undefined' && getPrototypeOf(Uint8Array));\n\n/**\n * For each entry in the object, call the function with the key and value.\n *\n * @param {Object<any, any>} obj - The object to iterate over.\n * @param {Function} fn - The function to call for each entry.\n *\n * @returns {void}\n */\nconst forEachEntry = (obj, fn) => {\n  const generator = obj && obj[Symbol.iterator];\n\n  const iterator = generator.call(obj);\n\n  let result;\n\n  while ((result = iterator.next()) && !result.done) {\n    const pair = result.value;\n    fn.call(obj, pair[0], pair[1]);\n  }\n}\n\n/**\n * It takes a regular expression and a string, and returns an array of all the matches\n *\n * @param {string} regExp - The regular expression to match against.\n * @param {string} str - The string to search.\n *\n * @returns {Array<boolean>}\n */\nconst matchAll = (regExp, str) => {\n  let matches;\n  const arr = [];\n\n  while ((matches = regExp.exec(str)) !== null) {\n    arr.push(matches);\n  }\n\n  return arr;\n}\n\n/* Checking if the kindOfTest function returns true when passed an HTMLFormElement. */\nconst isHTMLForm = kindOfTest('HTMLFormElement');\n\nconst toCamelCase = str => {\n  return str.toLowerCase().replace(/[-_\\s]([a-z\\d])(\\w*)/g,\n    function replacer(m, p1, p2) {\n      return p1.toUpperCase() + p2;\n    }\n  );\n};\n\n/* Creating a function that will check if an object has a property. */\nconst hasOwnProperty = (({hasOwnProperty}) => (obj, prop) => hasOwnProperty.call(obj, prop))(Object.prototype);\n\n/**\n * Determine if a value is a RegExp object\n *\n * @param {*} val The value to test\n *\n * @returns {boolean} True if value is a RegExp object, otherwise false\n */\nconst isRegExp = kindOfTest('RegExp');\n\nconst reduceDescriptors = (obj, reducer) => {\n  const descriptors = Object.getOwnPropertyDescriptors(obj);\n  const reducedDescriptors = {};\n\n  forEach(descriptors, (descriptor, name) => {\n    let ret;\n    if ((ret = reducer(descriptor, name, obj)) !== false) {\n      reducedDescriptors[name] = ret || descriptor;\n    }\n  });\n\n  Object.defineProperties(obj, reducedDescriptors);\n}\n\n/**\n * Makes all methods read-only\n * @param {Object} obj\n */\n\nconst freezeMethods = (obj) => {\n  reduceDescriptors(obj, (descriptor, name) => {\n    // skip restricted props in strict mode\n    if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {\n      return false;\n    }\n\n    const value = obj[name];\n\n    if (!isFunction(value)) return;\n\n    descriptor.enumerable = false;\n\n    if ('writable' in descriptor) {\n      descriptor.writable = false;\n      return;\n    }\n\n    if (!descriptor.set) {\n      descriptor.set = () => {\n        throw Error('Can not rewrite read-only method \\'' + name + '\\'');\n      };\n    }\n  });\n}\n\nconst toObjectSet = (arrayOrString, delimiter) => {\n  const obj = {};\n\n  const define = (arr) => {\n    arr.forEach(value => {\n      obj[value] = true;\n    });\n  }\n\n  isArray(arrayOrString) ? define(arrayOrString) : define(String(arrayOrString).split(delimiter));\n\n  return obj;\n}\n\nconst noop = () => {}\n\nconst toFiniteNumber = (value, defaultValue) => {\n  return value != null && Number.isFinite(value = +value) ? value : defaultValue;\n}\n\n/**\n * If the thing is a FormData object, return true, otherwise return false.\n *\n * @param {unknown} thing - The thing to check.\n *\n * @returns {boolean}\n */\nfunction isSpecCompliantForm(thing) {\n  return !!(thing && isFunction(thing.append) && thing[Symbol.toStringTag] === 'FormData' && thing[Symbol.iterator]);\n}\n\nconst toJSONObject = (obj) => {\n  const stack = new Array(10);\n\n  const visit = (source, i) => {\n\n    if (isObject(source)) {\n      if (stack.indexOf(source) >= 0) {\n        return;\n      }\n\n      if(!('toJSON' in source)) {\n        stack[i] = source;\n        const target = isArray(source) ? [] : {};\n\n        forEach(source, (value, key) => {\n          const reducedValue = visit(value, i + 1);\n          !isUndefined(reducedValue) && (target[key] = reducedValue);\n        });\n\n        stack[i] = undefined;\n\n        return target;\n      }\n    }\n\n    return source;\n  }\n\n  return visit(obj, 0);\n}\n\nconst isAsyncFn = kindOfTest('AsyncFunction');\n\nconst isThenable = (thing) =>\n  thing && (isObject(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);\n\n// original code\n// https://github.com/DigitalBrainJS/AxiosPromise/blob/16deab13710ec09779922131f3fa5954320f83ab/lib/utils.js#L11-L34\n\nconst _setImmediate = ((setImmediateSupported, postMessageSupported) => {\n  if (setImmediateSupported) {\n    return setImmediate;\n  }\n\n  return postMessageSupported ? ((token, callbacks) => {\n    _global.addEventListener(\"message\", ({source, data}) => {\n      if (source === _global && data === token) {\n        callbacks.length && callbacks.shift()();\n      }\n    }, false);\n\n    return (cb) => {\n      callbacks.push(cb);\n      _global.postMessage(token, \"*\");\n    }\n  })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);\n})(\n  typeof setImmediate === 'function',\n  isFunction(_global.postMessage)\n);\n\nconst asap = typeof queueMicrotask !== 'undefined' ?\n  queueMicrotask.bind(_global) : ( typeof process !== 'undefined' && process.nextTick || _setImmediate);\n\n// *********************\n\nexport default {\n  isArray,\n  isArrayBuffer,\n  isBuffer,\n  isFormData,\n  isArrayBufferView,\n  isString,\n  isNumber,\n  isBoolean,\n  isObject,\n  isPlainObject,\n  isReadableStream,\n  isRequest,\n  isResponse,\n  isHeaders,\n  isUndefined,\n  isDate,\n  isFile,\n  isBlob,\n  isRegExp,\n  isFunction,\n  isStream,\n  isURLSearchParams,\n  isTypedArray,\n  isFileList,\n  forEach,\n  merge,\n  extend,\n  trim,\n  stripBOM,\n  inherits,\n  toFlatObject,\n  kindOf,\n  kindOfTest,\n  endsWith,\n  toArray,\n  forEachEntry,\n  matchAll,\n  isHTMLForm,\n  hasOwnProperty,\n  hasOwnProp: hasOwnProperty, // an alias to avoid ESLint no-prototype-builtins detection\n  reduceDescriptors,\n  freezeMethods,\n  toObjectSet,\n  toCamelCase,\n  noop,\n  toFiniteNumber,\n  findKey,\n  global: _global,\n  isContextDefined,\n  isSpecCompliantForm,\n  toJSONObject,\n  isAsyncFn,\n  isThenable,\n  setImmediate: _setImmediate,\n  asap\n};\n"],"names":["hasOwnProperty","process"],"mappings":"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","x_google_ignoreList":[0]}

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

@@ -1,47 +1,9 @@
-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.es54.js";
-import { Coder, WordSize } from "./standards-sdk.es36.js";
-import { defineProperties } from "./standards-sdk.es50.js";
-import { getBigInt, mask, toTwos, fromTwos } from "./standards-sdk.es52.js";
-const BN_0 = BigInt(0);
-const BN_1 = BigInt(1);
-const BN_MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
-class NumberCoder extends Coder {
-  constructor(size, signed, localName) {
-    const name = (signed ? "int" : "uint") + size * 8;
-    super(name, name, localName, false);
-    __publicField(this, "size");
-    __publicField(this, "signed");
-    defineProperties(this, { size, signed }, { size: "number", signed: "boolean" });
-  }
-  defaultValue() {
-    return 0;
-  }
-  encode(writer, _value) {
-    let value = getBigInt(Typed.dereference(_value, this.type));
-    let maxUintValue = mask(BN_MAX_UINT256, WordSize * 8);
-    if (this.signed) {
-      let bounds = mask(maxUintValue, this.size * 8 - 1);
-      if (value > bounds || value < -(bounds + BN_1)) {
-        this._throwError("value out-of-bounds", _value);
-      }
-      value = toTwos(value, 8 * WordSize);
-    } else if (value < BN_0 || value > mask(maxUintValue, this.size * 8)) {
-      this._throwError("value out-of-bounds", _value);
-    }
-    return writer.writeValue(value);
-  }
-  decode(reader) {
-    let value = mask(reader.readValue(), this.size * 8);
-    if (this.signed) {
-      value = fromTwos(value, this.size * 8);
-    }
-    return value;
-  }
+function bind(fn, thisArg) {
+  return function wrap() {
+    return fn.apply(thisArg, arguments);
+  };
 }
 export {
-  NumberCoder
+  bind 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/number.js"],"sourcesContent":["import { defineProperties, fromTwos, getBigInt, mask, toTwos } from \"../../utils/index.js\";\nimport { Typed } from \"../typed.js\";\nimport { Coder, WordSize } from \"./abstract-coder.js\";\nconst BN_0 = BigInt(0);\nconst BN_1 = BigInt(1);\nconst BN_MAX_UINT256 = BigInt(\"0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\");\n/**\n *  @_ignore\n */\nexport class NumberCoder extends Coder {\n    size;\n    signed;\n    constructor(size, signed, localName) {\n        const name = ((signed ? \"int\" : \"uint\") + (size * 8));\n        super(name, name, localName, false);\n        defineProperties(this, { size, signed }, { size: \"number\", signed: \"boolean\" });\n    }\n    defaultValue() {\n        return 0;\n    }\n    encode(writer, _value) {\n        let value = getBigInt(Typed.dereference(_value, this.type));\n        // Check bounds are safe for encoding\n        let maxUintValue = mask(BN_MAX_UINT256, WordSize * 8);\n        if (this.signed) {\n            let bounds = mask(maxUintValue, (this.size * 8) - 1);\n            if (value > bounds || value < -(bounds + BN_1)) {\n                this._throwError(\"value out-of-bounds\", _value);\n            }\n            value = toTwos(value, 8 * WordSize);\n        }\n        else if (value < BN_0 || value > mask(maxUintValue, this.size * 8)) {\n            this._throwError(\"value out-of-bounds\", _value);\n        }\n        return writer.writeValue(value);\n    }\n    decode(reader) {\n        let value = mask(reader.readValue(), this.size * 8);\n        if (this.signed) {\n            value = fromTwos(value, this.size * 8);\n        }\n        return value;\n    }\n}\n//# sourceMappingURL=number.js.map"],"names":[],"mappings":";;;;;;;AAGA,MAAM,OAAO,OAAO,CAAC;AACrB,MAAM,OAAO,OAAO,CAAC;AACrB,MAAM,iBAAiB,OAAO,oEAAoE;AAI3F,MAAM,oBAAoB,MAAM;AAAA,EAGnC,YAAY,MAAM,QAAQ,WAAW;AACjC,UAAM,QAAS,SAAS,QAAQ,UAAW,OAAO;AAClD,UAAM,MAAM,MAAM,WAAW,KAAK;AAJtC;AACA;AAII,qBAAiB,MAAM,EAAE,MAAM,OAAM,GAAI,EAAE,MAAM,UAAU,QAAQ,WAAW;AAAA,EACtF;AAAA,EACI,eAAe;AACX,WAAO;AAAA,EACf;AAAA,EACI,OAAO,QAAQ,QAAQ;AACnB,QAAI,QAAQ,UAAU,MAAM,YAAY,QAAQ,KAAK,IAAI,CAAC;AAE1D,QAAI,eAAe,KAAK,gBAAgB,WAAW,CAAC;AACpD,QAAI,KAAK,QAAQ;AACb,UAAI,SAAS,KAAK,cAAe,KAAK,OAAO,IAAK,CAAC;AACnD,UAAI,QAAQ,UAAU,QAAQ,EAAE,SAAS,OAAO;AAC5C,aAAK,YAAY,uBAAuB,MAAM;AAAA,MAC9D;AACY,cAAQ,OAAO,OAAO,IAAI,QAAQ;AAAA,IAC9C,WACiB,QAAQ,QAAQ,QAAQ,KAAK,cAAc,KAAK,OAAO,CAAC,GAAG;AAChE,WAAK,YAAY,uBAAuB,MAAM;AAAA,IAC1D;AACQ,WAAO,OAAO,WAAW,KAAK;AAAA,EACtC;AAAA,EACI,OAAO,QAAQ;AACX,QAAI,QAAQ,KAAK,OAAO,UAAS,GAAI,KAAK,OAAO,CAAC;AAClD,QAAI,KAAK,QAAQ;AACb,cAAQ,SAAS,OAAO,KAAK,OAAO,CAAC;AAAA,IACjD;AACQ,WAAO;AAAA,EACf;AACA;","x_google_ignoreList":[0]}
+{"version":3,"file":"standards-sdk.es43.js","sources":["../../node_modules/axios/lib/helpers/bind.js"],"sourcesContent":["'use strict';\n\nexport default function bind(fn, thisArg) {\n  return function wrap() {\n    return fn.apply(thisArg, arguments);\n  };\n}\n"],"names":[],"mappings":"AAEe,SAAS,KAAK,IAAI,SAAS;AACxC,SAAO,SAAS,OAAO;AACrB,WAAO,GAAG,MAAM,SAAS,SAAS;AAAA,EACnC;AACH;","x_google_ignoreList":[0]}