@hashgraphonline/standards-sdk 0.0.74 → 0.0.75

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

@@ -1,367 +1,796 @@
-import global from "./standards-sdk.es30.js";
-import process$1 from "./standards-sdk.es31.js";
-import bind from "./standards-sdk.es56.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 __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
 };
-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);
+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.es37.js";
+import { defineProperties } from "./standards-sdk.es52.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 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;
+function b(value, size) {
+  return new Typed(_gaurd, `bytes${size ? size : ""}`, value, { size });
 }
-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);
+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;
     }
+    assertPrivate(_gaurd, gaurd, "Typed");
+    defineProperties(this, { _typedSymbol, type, value });
+    __privateSet(this, _options, options);
+    this.format();
   }
-}
-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;
+  /**
+   *  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(",")})`;
     }
+    return this.type;
   }
-  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);
+  /**
+   *  The default value returned by this type.
+   */
+  defaultValue() {
+    return 0;
   }
-  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);
+  /**
+   *  The minimum value for numeric types.
+   */
+  minValue() {
+    return 0;
   }
-  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]);
+  /**
+   *  The maximum value for numeric types.
+   */
+  maxValue() {
+    return 0;
   }
-};
-const matchAll = (regExp, str) => {
-  let matches;
-  const arr = [];
-  while ((matches = regExp.exec(str)) !== null) {
-    arr.push(matches);
+  /**
+   *  Returns ``true`` and provides a type guard is this is a [[TypedBigInt]].
+   */
+  isBigInt() {
+    return !!this.type.match(/^u?int[0-9]+$/);
   }
-  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;
+  /**
+   *  Returns ``true`` and provides a type guard is this is a [[TypedData]].
+   */
+  isData() {
+    return this.type.startsWith("bytes");
+  }
+  /**
+   *  Returns ``true`` and provides a type guard is this is a [[TypedString]].
+   */
+  isString() {
+    return this.type === "string";
+  }
+  /**
+   *  Returns the tuple name, if this is a tuple. Throws otherwise.
+   */
+  get tupleName() {
+    if (this.type !== "tuple") {
+      throw TypeError("not a tuple");
     }
-  });
-  Object.defineProperties(obj, reducedDescriptors);
-};
-const freezeMethods = (obj) => {
-  reduceDescriptors(obj, (descriptor, name) => {
-    if (isFunction(obj) && ["arguments", "caller", "callee"].indexOf(name) !== -1) {
-      return false;
+    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 value = obj[name];
-    if (!isFunction(value)) return;
-    descriptor.enumerable = false;
-    if ("writable" in descriptor) {
-      descriptor.writable = false;
-      return;
+    if (__privateGet(this, _options) === true) {
+      return -1;
     }
-    if (!descriptor.set) {
-      descriptor.set = () => {
-        throw Error("Can not rewrite read-only method '" + name + "'");
-      };
+    if (__privateGet(this, _options) === false) {
+      return this.value.length;
     }
-  });
-};
-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 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}`);
       }
+      return value.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
+    return value;
+  }
 };
+_options = new WeakMap();
+let Typed = _Typed;
 export {
-  utils as default
+  Typed
 };
 //# sourceMappingURL=standards-sdk.es55.js.map