@hashgraphonline/standards-sdk 0.0.67 → 0.0.69

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

@@ -1,796 +1,367 @@
-var __defProp = Object.defineProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
+import global from "./standards-sdk.es32.js";
+import process$1 from "./standards-sdk.es33.js";
+import bind from "./standards-sdk.es63.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;
 };
-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);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var _options;
-import { assertPrivate } from "./standards-sdk.es43.js";
-import { defineProperties } from "./standards-sdk.es60.js";
-const _gaurd = {};
-function n(value, width) {
-  let signed = false;
-  if (width < 0) {
-    signed = true;
-    width *= -1;
-  }
-  return new Typed(_gaurd, `${signed ? "" : "u"}int${width}`, value, { signed, width });
+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);
 }
-function b(value, size) {
-  return new Typed(_gaurd, `bytes${size ? size : ""}`, value, { size });
+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 _typedSymbol = Symbol.for("_ethers_typed");
-const _Typed = class _Typed {
-  /**
-   *  @_ignore:
-   */
-  constructor(gaurd, type, value, options) {
-    /**
-     *  The type, as a Solidity-compatible type.
-     */
-    __publicField(this, "type");
-    /**
-     *  The actual value.
-     */
-    __publicField(this, "value");
-    __privateAdd(this, _options);
-    /**
-     *  @_ignore:
-     */
-    __publicField(this, "_typedSymbol");
-    if (options == null) {
-      options = null;
+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);
     }
-    assertPrivate(_gaurd, gaurd, "Typed");
-    defineProperties(this, { _typedSymbol, type, value });
-    __privateSet(this, _options, options);
-    this.format();
-  }
-  /**
-   *  Format the type as a Human-Readable type.
-   */
-  format() {
-    if (this.type === "array") {
-      throw new Error("");
-    } else if (this.type === "dynamicArray") {
-      throw new Error("");
-    } else if (this.type === "tuple") {
-      return `tuple(${this.value.map((v) => v.format()).join(",")})`;
+  } 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);
     }
-    return this.type;
-  }
-  /**
-   *  The default value returned by this type.
-   */
-  defaultValue() {
-    return 0;
   }
-  /**
-   *  The minimum value for numeric types.
-   */
-  minValue() {
-    return 0;
+}
+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;
+    }
   }
-  /**
-   *  The maximum value for numeric types.
-   */
-  maxValue() {
-    return 0;
+  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);
   }
-  /**
-   *  Returns ``true`` and provides a type guard is this is a [[TypedBigInt]].
-   */
-  isBigInt() {
-    return !!this.type.match(/^u?int[0-9]+$/);
+  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);
   }
-  /**
-   *  Returns ``true`` and provides a type guard is this is a [[TypedData]].
-   */
-  isData() {
-    return this.type.startsWith("bytes");
+  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;
+      }
+    }
+    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];
+  }
+  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]);
   }
-  /**
-   *  Returns ``true`` and provides a type guard is this is a [[TypedString]].
-   */
-  isString() {
-    return this.type === "string";
+};
+const matchAll = (regExp, str) => {
+  let matches;
+  const arr = [];
+  while ((matches = regExp.exec(str)) !== null) {
+    arr.push(matches);
   }
-  /**
-   *  Returns the tuple name, if this is a tuple. Throws otherwise.
-   */
-  get tupleName() {
-    if (this.type !== "tuple") {
-      throw TypeError("not a tuple");
+  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;
     }
-    return __privateGet(this, _options);
-  }
-  // Returns the length of this type as an array
-  // - `null` indicates the length is unforced, it could be dynamic
-  // - `-1` indicates the length is dynamic
-  // - any other value indicates it is a static array and is its length
-  /**
-   *  Returns the length of the array type or ``-1`` if it is dynamic.
-   *
-   *  Throws if the type is not an array.
-   */
-  get arrayLength() {
-    if (this.type !== "array") {
-      throw TypeError("not an array");
+  );
+};
+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;
     }
-    if (__privateGet(this, _options) === true) {
-      return -1;
+  });
+  Object.defineProperties(obj, reducedDescriptors);
+};
+const freezeMethods = (obj) => {
+  reduceDescriptors(obj, (descriptor, name) => {
+    if (isFunction(obj) && ["arguments", "caller", "callee"].indexOf(name) !== -1) {
+      return false;
     }
-    if (__privateGet(this, _options) === false) {
-      return this.value.length;
+    const value = obj[name];
+    if (!isFunction(value)) return;
+    descriptor.enumerable = false;
+    if ("writable" in descriptor) {
+      descriptor.writable = false;
+      return;
     }
-    return null;
-  }
-  /**
-   *  Returns a new **Typed** of %%type%% with the %%value%%.
-   */
-  static from(type, value) {
-    return new _Typed(_gaurd, type, value);
-  }
-  /**
-   *  Return a new ``uint8`` type for %%v%%.
-   */
-  static uint8(v) {
-    return n(v, 8);
-  }
-  /**
-   *  Return a new ``uint16`` type for %%v%%.
-   */
-  static uint16(v) {
-    return n(v, 16);
-  }
-  /**
-   *  Return a new ``uint24`` type for %%v%%.
-   */
-  static uint24(v) {
-    return n(v, 24);
-  }
-  /**
-   *  Return a new ``uint32`` type for %%v%%.
-   */
-  static uint32(v) {
-    return n(v, 32);
-  }
-  /**
-   *  Return a new ``uint40`` type for %%v%%.
-   */
-  static uint40(v) {
-    return n(v, 40);
-  }
-  /**
-   *  Return a new ``uint48`` type for %%v%%.
-   */
-  static uint48(v) {
-    return n(v, 48);
-  }
-  /**
-   *  Return a new ``uint56`` type for %%v%%.
-   */
-  static uint56(v) {
-    return n(v, 56);
-  }
-  /**
-   *  Return a new ``uint64`` type for %%v%%.
-   */
-  static uint64(v) {
-    return n(v, 64);
-  }
-  /**
-   *  Return a new ``uint72`` type for %%v%%.
-   */
-  static uint72(v) {
-    return n(v, 72);
-  }
-  /**
-   *  Return a new ``uint80`` type for %%v%%.
-   */
-  static uint80(v) {
-    return n(v, 80);
-  }
-  /**
-   *  Return a new ``uint88`` type for %%v%%.
-   */
-  static uint88(v) {
-    return n(v, 88);
-  }
-  /**
-   *  Return a new ``uint96`` type for %%v%%.
-   */
-  static uint96(v) {
-    return n(v, 96);
-  }
-  /**
-   *  Return a new ``uint104`` type for %%v%%.
-   */
-  static uint104(v) {
-    return n(v, 104);
-  }
-  /**
-   *  Return a new ``uint112`` type for %%v%%.
-   */
-  static uint112(v) {
-    return n(v, 112);
-  }
-  /**
-   *  Return a new ``uint120`` type for %%v%%.
-   */
-  static uint120(v) {
-    return n(v, 120);
-  }
-  /**
-   *  Return a new ``uint128`` type for %%v%%.
-   */
-  static uint128(v) {
-    return n(v, 128);
-  }
-  /**
-   *  Return a new ``uint136`` type for %%v%%.
-   */
-  static uint136(v) {
-    return n(v, 136);
-  }
-  /**
-   *  Return a new ``uint144`` type for %%v%%.
-   */
-  static uint144(v) {
-    return n(v, 144);
-  }
-  /**
-   *  Return a new ``uint152`` type for %%v%%.
-   */
-  static uint152(v) {
-    return n(v, 152);
-  }
-  /**
-   *  Return a new ``uint160`` type for %%v%%.
-   */
-  static uint160(v) {
-    return n(v, 160);
-  }
-  /**
-   *  Return a new ``uint168`` type for %%v%%.
-   */
-  static uint168(v) {
-    return n(v, 168);
-  }
-  /**
-   *  Return a new ``uint176`` type for %%v%%.
-   */
-  static uint176(v) {
-    return n(v, 176);
-  }
-  /**
-   *  Return a new ``uint184`` type for %%v%%.
-   */
-  static uint184(v) {
-    return n(v, 184);
-  }
-  /**
-   *  Return a new ``uint192`` type for %%v%%.
-   */
-  static uint192(v) {
-    return n(v, 192);
-  }
-  /**
-   *  Return a new ``uint200`` type for %%v%%.
-   */
-  static uint200(v) {
-    return n(v, 200);
-  }
-  /**
-   *  Return a new ``uint208`` type for %%v%%.
-   */
-  static uint208(v) {
-    return n(v, 208);
-  }
-  /**
-   *  Return a new ``uint216`` type for %%v%%.
-   */
-  static uint216(v) {
-    return n(v, 216);
-  }
-  /**
-   *  Return a new ``uint224`` type for %%v%%.
-   */
-  static uint224(v) {
-    return n(v, 224);
-  }
-  /**
-   *  Return a new ``uint232`` type for %%v%%.
-   */
-  static uint232(v) {
-    return n(v, 232);
-  }
-  /**
-   *  Return a new ``uint240`` type for %%v%%.
-   */
-  static uint240(v) {
-    return n(v, 240);
-  }
-  /**
-   *  Return a new ``uint248`` type for %%v%%.
-   */
-  static uint248(v) {
-    return n(v, 248);
-  }
-  /**
-   *  Return a new ``uint256`` type for %%v%%.
-   */
-  static uint256(v) {
-    return n(v, 256);
-  }
-  /**
-   *  Return a new ``uint256`` type for %%v%%.
-   */
-  static uint(v) {
-    return n(v, 256);
-  }
-  /**
-   *  Return a new ``int8`` type for %%v%%.
-   */
-  static int8(v) {
-    return n(v, -8);
-  }
-  /**
-   *  Return a new ``int16`` type for %%v%%.
-   */
-  static int16(v) {
-    return n(v, -16);
-  }
-  /**
-   *  Return a new ``int24`` type for %%v%%.
-   */
-  static int24(v) {
-    return n(v, -24);
-  }
-  /**
-   *  Return a new ``int32`` type for %%v%%.
-   */
-  static int32(v) {
-    return n(v, -32);
-  }
-  /**
-   *  Return a new ``int40`` type for %%v%%.
-   */
-  static int40(v) {
-    return n(v, -40);
-  }
-  /**
-   *  Return a new ``int48`` type for %%v%%.
-   */
-  static int48(v) {
-    return n(v, -48);
-  }
-  /**
-   *  Return a new ``int56`` type for %%v%%.
-   */
-  static int56(v) {
-    return n(v, -56);
-  }
-  /**
-   *  Return a new ``int64`` type for %%v%%.
-   */
-  static int64(v) {
-    return n(v, -64);
-  }
-  /**
-   *  Return a new ``int72`` type for %%v%%.
-   */
-  static int72(v) {
-    return n(v, -72);
-  }
-  /**
-   *  Return a new ``int80`` type for %%v%%.
-   */
-  static int80(v) {
-    return n(v, -80);
-  }
-  /**
-   *  Return a new ``int88`` type for %%v%%.
-   */
-  static int88(v) {
-    return n(v, -88);
-  }
-  /**
-   *  Return a new ``int96`` type for %%v%%.
-   */
-  static int96(v) {
-    return n(v, -96);
-  }
-  /**
-   *  Return a new ``int104`` type for %%v%%.
-   */
-  static int104(v) {
-    return n(v, -104);
-  }
-  /**
-   *  Return a new ``int112`` type for %%v%%.
-   */
-  static int112(v) {
-    return n(v, -112);
-  }
-  /**
-   *  Return a new ``int120`` type for %%v%%.
-   */
-  static int120(v) {
-    return n(v, -120);
-  }
-  /**
-   *  Return a new ``int128`` type for %%v%%.
-   */
-  static int128(v) {
-    return n(v, -128);
-  }
-  /**
-   *  Return a new ``int136`` type for %%v%%.
-   */
-  static int136(v) {
-    return n(v, -136);
-  }
-  /**
-   *  Return a new ``int144`` type for %%v%%.
-   */
-  static int144(v) {
-    return n(v, -144);
-  }
-  /**
-   *  Return a new ``int52`` type for %%v%%.
-   */
-  static int152(v) {
-    return n(v, -152);
-  }
-  /**
-   *  Return a new ``int160`` type for %%v%%.
-   */
-  static int160(v) {
-    return n(v, -160);
-  }
-  /**
-   *  Return a new ``int168`` type for %%v%%.
-   */
-  static int168(v) {
-    return n(v, -168);
-  }
-  /**
-   *  Return a new ``int176`` type for %%v%%.
-   */
-  static int176(v) {
-    return n(v, -176);
-  }
-  /**
-   *  Return a new ``int184`` type for %%v%%.
-   */
-  static int184(v) {
-    return n(v, -184);
-  }
-  /**
-   *  Return a new ``int92`` type for %%v%%.
-   */
-  static int192(v) {
-    return n(v, -192);
-  }
-  /**
-   *  Return a new ``int200`` type for %%v%%.
-   */
-  static int200(v) {
-    return n(v, -200);
-  }
-  /**
-   *  Return a new ``int208`` type for %%v%%.
-   */
-  static int208(v) {
-    return n(v, -208);
-  }
-  /**
-   *  Return a new ``int216`` type for %%v%%.
-   */
-  static int216(v) {
-    return n(v, -216);
-  }
-  /**
-   *  Return a new ``int224`` type for %%v%%.
-   */
-  static int224(v) {
-    return n(v, -224);
-  }
-  /**
-   *  Return a new ``int232`` type for %%v%%.
-   */
-  static int232(v) {
-    return n(v, -232);
-  }
-  /**
-   *  Return a new ``int240`` type for %%v%%.
-   */
-  static int240(v) {
-    return n(v, -240);
-  }
-  /**
-   *  Return a new ``int248`` type for %%v%%.
-   */
-  static int248(v) {
-    return n(v, -248);
-  }
-  /**
-   *  Return a new ``int256`` type for %%v%%.
-   */
-  static int256(v) {
-    return n(v, -256);
-  }
-  /**
-   *  Return a new ``int256`` type for %%v%%.
-   */
-  static int(v) {
-    return n(v, -256);
-  }
-  /**
-   *  Return a new ``bytes1`` type for %%v%%.
-   */
-  static bytes1(v) {
-    return b(v, 1);
-  }
-  /**
-   *  Return a new ``bytes2`` type for %%v%%.
-   */
-  static bytes2(v) {
-    return b(v, 2);
-  }
-  /**
-   *  Return a new ``bytes3`` type for %%v%%.
-   */
-  static bytes3(v) {
-    return b(v, 3);
-  }
-  /**
-   *  Return a new ``bytes4`` type for %%v%%.
-   */
-  static bytes4(v) {
-    return b(v, 4);
-  }
-  /**
-   *  Return a new ``bytes5`` type for %%v%%.
-   */
-  static bytes5(v) {
-    return b(v, 5);
-  }
-  /**
-   *  Return a new ``bytes6`` type for %%v%%.
-   */
-  static bytes6(v) {
-    return b(v, 6);
-  }
-  /**
-   *  Return a new ``bytes7`` type for %%v%%.
-   */
-  static bytes7(v) {
-    return b(v, 7);
-  }
-  /**
-   *  Return a new ``bytes8`` type for %%v%%.
-   */
-  static bytes8(v) {
-    return b(v, 8);
-  }
-  /**
-   *  Return a new ``bytes9`` type for %%v%%.
-   */
-  static bytes9(v) {
-    return b(v, 9);
-  }
-  /**
-   *  Return a new ``bytes10`` type for %%v%%.
-   */
-  static bytes10(v) {
-    return b(v, 10);
-  }
-  /**
-   *  Return a new ``bytes11`` type for %%v%%.
-   */
-  static bytes11(v) {
-    return b(v, 11);
-  }
-  /**
-   *  Return a new ``bytes12`` type for %%v%%.
-   */
-  static bytes12(v) {
-    return b(v, 12);
-  }
-  /**
-   *  Return a new ``bytes13`` type for %%v%%.
-   */
-  static bytes13(v) {
-    return b(v, 13);
-  }
-  /**
-   *  Return a new ``bytes14`` type for %%v%%.
-   */
-  static bytes14(v) {
-    return b(v, 14);
-  }
-  /**
-   *  Return a new ``bytes15`` type for %%v%%.
-   */
-  static bytes15(v) {
-    return b(v, 15);
-  }
-  /**
-   *  Return a new ``bytes16`` type for %%v%%.
-   */
-  static bytes16(v) {
-    return b(v, 16);
-  }
-  /**
-   *  Return a new ``bytes17`` type for %%v%%.
-   */
-  static bytes17(v) {
-    return b(v, 17);
-  }
-  /**
-   *  Return a new ``bytes18`` type for %%v%%.
-   */
-  static bytes18(v) {
-    return b(v, 18);
-  }
-  /**
-   *  Return a new ``bytes19`` type for %%v%%.
-   */
-  static bytes19(v) {
-    return b(v, 19);
-  }
-  /**
-   *  Return a new ``bytes20`` type for %%v%%.
-   */
-  static bytes20(v) {
-    return b(v, 20);
-  }
-  /**
-   *  Return a new ``bytes21`` type for %%v%%.
-   */
-  static bytes21(v) {
-    return b(v, 21);
-  }
-  /**
-   *  Return a new ``bytes22`` type for %%v%%.
-   */
-  static bytes22(v) {
-    return b(v, 22);
-  }
-  /**
-   *  Return a new ``bytes23`` type for %%v%%.
-   */
-  static bytes23(v) {
-    return b(v, 23);
-  }
-  /**
-   *  Return a new ``bytes24`` type for %%v%%.
-   */
-  static bytes24(v) {
-    return b(v, 24);
-  }
-  /**
-   *  Return a new ``bytes25`` type for %%v%%.
-   */
-  static bytes25(v) {
-    return b(v, 25);
-  }
-  /**
-   *  Return a new ``bytes26`` type for %%v%%.
-   */
-  static bytes26(v) {
-    return b(v, 26);
-  }
-  /**
-   *  Return a new ``bytes27`` type for %%v%%.
-   */
-  static bytes27(v) {
-    return b(v, 27);
-  }
-  /**
-   *  Return a new ``bytes28`` type for %%v%%.
-   */
-  static bytes28(v) {
-    return b(v, 28);
-  }
-  /**
-   *  Return a new ``bytes29`` type for %%v%%.
-   */
-  static bytes29(v) {
-    return b(v, 29);
-  }
-  /**
-   *  Return a new ``bytes30`` type for %%v%%.
-   */
-  static bytes30(v) {
-    return b(v, 30);
-  }
-  /**
-   *  Return a new ``bytes31`` type for %%v%%.
-   */
-  static bytes31(v) {
-    return b(v, 31);
-  }
-  /**
-   *  Return a new ``bytes32`` type for %%v%%.
-   */
-  static bytes32(v) {
-    return b(v, 32);
-  }
-  /**
-   *  Return a new ``address`` type for %%v%%.
-   */
-  static address(v) {
-    return new _Typed(_gaurd, "address", v);
-  }
-  /**
-   *  Return a new ``bool`` type for %%v%%.
-   */
-  static bool(v) {
-    return new _Typed(_gaurd, "bool", !!v);
-  }
-  /**
-   *  Return a new ``bytes`` type for %%v%%.
-   */
-  static bytes(v) {
-    return new _Typed(_gaurd, "bytes", v);
-  }
-  /**
-   *  Return a new ``string`` type for %%v%%.
-   */
-  static string(v) {
-    return new _Typed(_gaurd, "string", v);
-  }
-  /**
-   *  Return a new ``array`` type for %%v%%, allowing %%dynamic%% length.
-   */
-  static array(v, dynamic) {
-    throw new Error("not implemented yet");
-  }
-  /**
-   *  Return a new ``tuple`` type for %%v%%, with the optional %%name%%.
-   */
-  static tuple(v, name) {
-    throw new Error("not implemented yet");
-  }
-  /**
-   *  Return a new ``uint8`` type for %%v%%.
-   */
-  static overrides(v) {
-    return new _Typed(_gaurd, "overrides", Object.assign({}, v));
-  }
-  /**
-   *  Returns true only if %%value%% is a [[Typed]] instance.
-   */
-  static isTyped(value) {
-    return value && typeof value === "object" && "_typedSymbol" in value && value._typedSymbol === _typedSymbol;
-  }
-  /**
-   *  If the value is a [[Typed]] instance, validates the underlying value
-   *  and returns it, otherwise returns value directly.
-   *
-   *  This is useful for functions that with to accept either a [[Typed]]
-   *  object or values.
-   */
-  static dereference(value, type) {
-    if (_Typed.isTyped(value)) {
-      if (value.type !== type) {
-        throw new Error(`invalid type: expecetd ${type}, got ${value.type}`);
+    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 value.value;
     }
-    return value;
-  }
+    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
 };
-_options = new WeakMap();
-let Typed = _Typed;
 export {
-  Typed
+  utils as default
 };
 //# sourceMappingURL=standards-sdk.es62.js.map