@hashgraphonline/standards-sdk 0.0.65 → 0.0.66

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

@@ -1,412 +1,441 @@
-import process$1 from "./standards-sdk.es33.js";
-var pathBrowserify;
-var hasRequiredPathBrowserify;
-function requirePathBrowserify() {
-  if (hasRequiredPathBrowserify) return pathBrowserify;
-  hasRequiredPathBrowserify = 1;
-  function assertPath(path) {
-    if (typeof path !== "string") {
-      throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
-    }
-  }
-  function normalizeStringPosix(path, allowAboveRoot) {
-    var res = "";
-    var lastSegmentLength = 0;
-    var lastSlash = -1;
-    var dots = 0;
-    var code;
-    for (var i = 0; i <= path.length; ++i) {
-      if (i < path.length)
-        code = path.charCodeAt(i);
-      else if (code === 47)
-        break;
-      else
-        code = 47;
-      if (code === 47) {
-        if (lastSlash === i - 1 || dots === 1) ;
-        else if (lastSlash !== i - 1 && dots === 2) {
-          if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
-            if (res.length > 2) {
-              var lastSlashIndex = res.lastIndexOf("/");
-              if (lastSlashIndex !== res.length - 1) {
-                if (lastSlashIndex === -1) {
-                  res = "";
-                  lastSegmentLength = 0;
-                } else {
-                  res = res.slice(0, lastSlashIndex);
-                  lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
-                }
-                lastSlash = i;
-                dots = 0;
-                continue;
-              }
-            } else if (res.length === 2 || res.length === 1) {
-              res = "";
-              lastSegmentLength = 0;
-              lastSlash = i;
-              dots = 0;
-              continue;
-            }
-          }
-          if (allowAboveRoot) {
-            if (res.length > 0)
-              res += "/..";
-            else
-              res = "..";
-            lastSegmentLength = 2;
-          }
-        } else {
-          if (res.length > 0)
-            res += "/" + path.slice(lastSlash + 1, i);
-          else
-            res = path.slice(lastSlash + 1, i);
-          lastSegmentLength = i - lastSlash - 1;
-        }
-        lastSlash = i;
-        dots = 0;
-      } else if (code === 46 && dots !== -1) {
-        ++dots;
-      } else {
-        dots = -1;
+var __defProp = Object.defineProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+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 __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _names, _data, _dataLength, _Writer_instances, writeData_fn, _data2, _offset, _bytesRead, _parent, _maxInflation, _Reader_instances, incrementBytesRead_fn, peekBytes_fn;
+import { getNumber, toBigInt, toNumber, toBeArray } from "./standards-sdk.es51.js";
+import { assert, assertArgument } from "./standards-sdk.es35.js";
+import { concat, getBytesCopy, hexlify } from "./standards-sdk.es36.js";
+import { defineProperties } from "./standards-sdk.es49.js";
+const WordSize = 32;
+const Padding = new Uint8Array(WordSize);
+const passProperties = ["then"];
+const _guard = {};
+const resultNames = /* @__PURE__ */ new WeakMap();
+function getNames(result) {
+  return resultNames.get(result);
+}
+function setNames(result, names) {
+  resultNames.set(result, names);
+}
+function throwError(name, error) {
+  const wrapped = new Error(`deferred error during ABI decoding triggered accessing ${name}`);
+  wrapped.error = error;
+  throw wrapped;
+}
+function toObject(names, items, deep) {
+  if (names.indexOf(null) >= 0) {
+    return items.map((item, index) => {
+      if (item instanceof Result) {
+        return toObject(getNames(item), item, deep);
       }
-    }
-    return res;
+      return item;
+    });
   }
-  function _format(sep, pathObject) {
-    var dir = pathObject.dir || pathObject.root;
-    var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
-    if (!dir) {
-      return base;
+  return names.reduce((accum, name, index) => {
+    let item = items.getValue(name);
+    if (!(name in accum)) {
+      if (deep && item instanceof Result) {
+        item = toObject(getNames(item), item, deep);
+      }
+      accum[name] = item;
     }
-    if (dir === pathObject.root) {
-      return dir + base;
+    return accum;
+  }, {});
+}
+const _Result = class _Result extends Array {
+  /**
+   *  @private
+   */
+  constructor(...args) {
+    const guard = args[0];
+    let items = args[1];
+    let names = (args[2] || []).slice();
+    let wrap = true;
+    if (guard !== _guard) {
+      items = args;
+      names = [];
+      wrap = false;
     }
-    return dir + sep + base;
-  }
-  var posix = {
-    // path.resolve([from ...], to)
-    resolve: function resolve() {
-      var resolvedPath = "";
-      var resolvedAbsolute = false;
-      var cwd;
-      for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-        var path;
-        if (i >= 0)
-          path = arguments[i];
-        else {
-          if (cwd === void 0)
-            cwd = process$1.cwd();
-          path = cwd;
-        }
-        assertPath(path);
-        if (path.length === 0) {
-          continue;
-        }
-        resolvedPath = path + "/" + resolvedPath;
-        resolvedAbsolute = path.charCodeAt(0) === 47;
-      }
-      resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
-      if (resolvedAbsolute) {
-        if (resolvedPath.length > 0)
-          return "/" + resolvedPath;
-        else
-          return "/";
-      } else if (resolvedPath.length > 0) {
-        return resolvedPath;
-      } else {
-        return ".";
-      }
-    },
-    normalize: function normalize(path) {
-      assertPath(path);
-      if (path.length === 0) return ".";
-      var isAbsolute = path.charCodeAt(0) === 47;
-      var trailingSeparator = path.charCodeAt(path.length - 1) === 47;
-      path = normalizeStringPosix(path, !isAbsolute);
-      if (path.length === 0 && !isAbsolute) path = ".";
-      if (path.length > 0 && trailingSeparator) path += "/";
-      if (isAbsolute) return "/" + path;
-      return path;
-    },
-    isAbsolute: function isAbsolute(path) {
-      assertPath(path);
-      return path.length > 0 && path.charCodeAt(0) === 47;
-    },
-    join: function join() {
-      if (arguments.length === 0)
-        return ".";
-      var joined;
-      for (var i = 0; i < arguments.length; ++i) {
-        var arg = arguments[i];
-        assertPath(arg);
-        if (arg.length > 0) {
-          if (joined === void 0)
-            joined = arg;
-          else
-            joined += "/" + arg;
-        }
+    super(items.length);
+    // No longer used; but cannot be removed as it will remove the
+    // #private field from the .d.ts which may break backwards
+    // compatibility
+    __privateAdd(this, _names);
+    items.forEach((item, index) => {
+      this[index] = item;
+    });
+    const nameCounts = names.reduce((accum, name) => {
+      if (typeof name === "string") {
+        accum.set(name, (accum.get(name) || 0) + 1);
       }
-      if (joined === void 0)
-        return ".";
-      return posix.normalize(joined);
-    },
-    relative: function relative(from, to) {
-      assertPath(from);
-      assertPath(to);
-      if (from === to) return "";
-      from = posix.resolve(from);
-      to = posix.resolve(to);
-      if (from === to) return "";
-      var fromStart = 1;
-      for (; fromStart < from.length; ++fromStart) {
-        if (from.charCodeAt(fromStart) !== 47)
-          break;
-      }
-      var fromEnd = from.length;
-      var fromLen = fromEnd - fromStart;
-      var toStart = 1;
-      for (; toStart < to.length; ++toStart) {
-        if (to.charCodeAt(toStart) !== 47)
-          break;
-      }
-      var toEnd = to.length;
-      var toLen = toEnd - toStart;
-      var length = fromLen < toLen ? fromLen : toLen;
-      var lastCommonSep = -1;
-      var i = 0;
-      for (; i <= length; ++i) {
-        if (i === length) {
-          if (toLen > length) {
-            if (to.charCodeAt(toStart + i) === 47) {
-              return to.slice(toStart + i + 1);
-            } else if (i === 0) {
-              return to.slice(toStart + i);
-            }
-          } else if (fromLen > length) {
-            if (from.charCodeAt(fromStart + i) === 47) {
-              lastCommonSep = i;
-            } else if (i === 0) {
-              lastCommonSep = 0;
-            }
-          }
-          break;
-        }
-        var fromCode = from.charCodeAt(fromStart + i);
-        var toCode = to.charCodeAt(toStart + i);
-        if (fromCode !== toCode)
-          break;
-        else if (fromCode === 47)
-          lastCommonSep = i;
+      return accum;
+    }, /* @__PURE__ */ new Map());
+    setNames(this, Object.freeze(items.map((item, index) => {
+      const name = names[index];
+      if (name != null && nameCounts.get(name) === 1) {
+        return name;
       }
-      var out = "";
-      for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
-        if (i === fromEnd || from.charCodeAt(i) === 47) {
-          if (out.length === 0)
-            out += "..";
-          else
-            out += "/..";
-        }
-      }
-      if (out.length > 0)
-        return out + to.slice(toStart + lastCommonSep);
-      else {
-        toStart += lastCommonSep;
-        if (to.charCodeAt(toStart) === 47)
-          ++toStart;
-        return to.slice(toStart);
-      }
-    },
-    _makeLong: function _makeLong(path) {
-      return path;
-    },
-    dirname: function dirname(path) {
-      assertPath(path);
-      if (path.length === 0) return ".";
-      var code = path.charCodeAt(0);
-      var hasRoot = code === 47;
-      var end = -1;
-      var matchedSlash = true;
-      for (var i = path.length - 1; i >= 1; --i) {
-        code = path.charCodeAt(i);
-        if (code === 47) {
-          if (!matchedSlash) {
-            end = i;
-            break;
-          }
-        } else {
-          matchedSlash = false;
-        }
-      }
-      if (end === -1) return hasRoot ? "/" : ".";
-      if (hasRoot && end === 1) return "//";
-      return path.slice(0, end);
-    },
-    basename: function basename(path, ext) {
-      if (ext !== void 0 && typeof ext !== "string") throw new TypeError('"ext" argument must be a string');
-      assertPath(path);
-      var start = 0;
-      var end = -1;
-      var matchedSlash = true;
-      var i;
-      if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) {
-        if (ext.length === path.length && ext === path) return "";
-        var extIdx = ext.length - 1;
-        var firstNonSlashEnd = -1;
-        for (i = path.length - 1; i >= 0; --i) {
-          var code = path.charCodeAt(i);
-          if (code === 47) {
-            if (!matchedSlash) {
-              start = i + 1;
-              break;
-            }
-          } else {
-            if (firstNonSlashEnd === -1) {
-              matchedSlash = false;
-              firstNonSlashEnd = i + 1;
+      return null;
+    })));
+    __privateSet(this, _names, []);
+    if (__privateGet(this, _names) == null) {
+      void __privateGet(this, _names);
+    }
+    if (!wrap) {
+      return;
+    }
+    Object.freeze(this);
+    const proxy = new Proxy(this, {
+      get: (target, prop, receiver) => {
+        if (typeof prop === "string") {
+          if (prop.match(/^[0-9]+$/)) {
+            const index = getNumber(prop, "%index");
+            if (index < 0 || index >= this.length) {
+              throw new RangeError("out of result range");
             }
-            if (extIdx >= 0) {
-              if (code === ext.charCodeAt(extIdx)) {
-                if (--extIdx === -1) {
-                  end = i;
-                }
-              } else {
-                extIdx = -1;
-                end = firstNonSlashEnd;
-              }
+            const item = target[index];
+            if (item instanceof Error) {
+              throwError(`index ${index}`, item);
             }
+            return item;
           }
-        }
-        if (start === end) end = firstNonSlashEnd;
-        else if (end === -1) end = path.length;
-        return path.slice(start, end);
-      } else {
-        for (i = path.length - 1; i >= 0; --i) {
-          if (path.charCodeAt(i) === 47) {
-            if (!matchedSlash) {
-              start = i + 1;
-              break;
-            }
-          } else if (end === -1) {
-            matchedSlash = false;
-            end = i + 1;
+          if (passProperties.indexOf(prop) >= 0) {
+            return Reflect.get(target, prop, receiver);
           }
-        }
-        if (end === -1) return "";
-        return path.slice(start, end);
-      }
-    },
-    extname: function extname(path) {
-      assertPath(path);
-      var startDot = -1;
-      var startPart = 0;
-      var end = -1;
-      var matchedSlash = true;
-      var preDotState = 0;
-      for (var i = path.length - 1; i >= 0; --i) {
-        var code = path.charCodeAt(i);
-        if (code === 47) {
-          if (!matchedSlash) {
-            startPart = i + 1;
-            break;
+          const value = target[prop];
+          if (value instanceof Function) {
+            return function(...args2) {
+              return value.apply(this === receiver ? target : this, args2);
+            };
+          } else if (!(prop in target)) {
+            return target.getValue.apply(this === receiver ? target : this, [prop]);
           }
-          continue;
-        }
-        if (end === -1) {
-          matchedSlash = false;
-          end = i + 1;
-        }
-        if (code === 46) {
-          if (startDot === -1)
-            startDot = i;
-          else if (preDotState !== 1)
-            preDotState = 1;
-        } else if (startDot !== -1) {
-          preDotState = -1;
         }
+        return Reflect.get(target, prop, receiver);
       }
-      if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
-      preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
-      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
-        return "";
+    });
+    setNames(proxy, getNames(this));
+    return proxy;
+  }
+  /**
+   *  Returns the Result as a normal Array. If %%deep%%, any children
+   *  which are Result objects are also converted to a normal Array.
+   *
+   *  This will throw if there are any outstanding deferred
+   *  errors.
+   */
+  toArray(deep) {
+    const result = [];
+    this.forEach((item, index) => {
+      if (item instanceof Error) {
+        throwError(`index ${index}`, item);
       }
-      return path.slice(startDot, end);
-    },
-    format: function format(pathObject) {
-      if (pathObject === null || typeof pathObject !== "object") {
-        throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+      if (deep && item instanceof _Result) {
+        item = item.toArray(deep);
       }
-      return _format("/", pathObject);
-    },
-    parse: function parse(path) {
-      assertPath(path);
-      var ret = { root: "", dir: "", base: "", ext: "", name: "" };
-      if (path.length === 0) return ret;
-      var code = path.charCodeAt(0);
-      var isAbsolute = code === 47;
-      var start;
-      if (isAbsolute) {
-        ret.root = "/";
-        start = 1;
-      } else {
+      result.push(item);
+    });
+    return result;
+  }
+  /**
+   *  Returns the Result as an Object with each name-value pair. If
+   *  %%deep%%, any children which are Result objects are also
+   *  converted to an Object.
+   *
+   *  This will throw if any value is unnamed, or if there are
+   *  any outstanding deferred errors.
+   */
+  toObject(deep) {
+    const names = getNames(this);
+    return names.reduce((accum, name, index) => {
+      assert(name != null, `value at index ${index} unnamed`, "UNSUPPORTED_OPERATION", {
+        operation: "toObject()"
+      });
+      return toObject(names, this, deep);
+    }, {});
+  }
+  /**
+   *  @_ignore
+   */
+  slice(start, end) {
+    if (start == null) {
+      start = 0;
+    }
+    if (start < 0) {
+      start += this.length;
+      if (start < 0) {
         start = 0;
       }
-      var startDot = -1;
-      var startPart = 0;
-      var end = -1;
-      var matchedSlash = true;
-      var i = path.length - 1;
-      var preDotState = 0;
-      for (; i >= start; --i) {
-        code = path.charCodeAt(i);
-        if (code === 47) {
-          if (!matchedSlash) {
-            startPart = i + 1;
-            break;
-          }
-          continue;
-        }
-        if (end === -1) {
-          matchedSlash = false;
-          end = i + 1;
-        }
-        if (code === 46) {
-          if (startDot === -1) startDot = i;
-          else if (preDotState !== 1) preDotState = 1;
-        } else if (startDot !== -1) {
-          preDotState = -1;
-        }
+    }
+    if (end == null) {
+      end = this.length;
+    }
+    if (end < 0) {
+      end += this.length;
+      if (end < 0) {
+        end = 0;
       }
-      if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
-      preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
-      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
-        if (end !== -1) {
-          if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);
-          else ret.base = ret.name = path.slice(startPart, end);
-        }
-      } else {
-        if (startPart === 0 && isAbsolute) {
-          ret.name = path.slice(1, startDot);
-          ret.base = path.slice(1, end);
-        } else {
-          ret.name = path.slice(startPart, startDot);
-          ret.base = path.slice(startPart, end);
-        }
-        ret.ext = path.slice(startDot, end);
+    }
+    if (end > this.length) {
+      end = this.length;
+    }
+    const _names2 = getNames(this);
+    const result = [], names = [];
+    for (let i = start; i < end; i++) {
+      result.push(this[i]);
+      names.push(_names2[i]);
+    }
+    return new _Result(_guard, result, names);
+  }
+  /**
+   *  @_ignore
+   */
+  filter(callback, thisArg) {
+    const _names2 = getNames(this);
+    const result = [], names = [];
+    for (let i = 0; i < this.length; i++) {
+      const item = this[i];
+      if (item instanceof Error) {
+        throwError(`index ${i}`, item);
+      }
+      if (callback.call(thisArg, item, i, this)) {
+        result.push(item);
+        names.push(_names2[i]);
+      }
+    }
+    return new _Result(_guard, result, names);
+  }
+  /**
+   *  @_ignore
+   */
+  map(callback, thisArg) {
+    const result = [];
+    for (let i = 0; i < this.length; i++) {
+      const item = this[i];
+      if (item instanceof Error) {
+        throwError(`index ${i}`, item);
       }
-      if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
-      else if (isAbsolute) ret.dir = "/";
-      return ret;
-    },
-    sep: "/",
-    delimiter: ":",
-    win32: null,
-    posix: null
-  };
-  posix.posix = posix;
-  pathBrowserify = posix;
-  return pathBrowserify;
+      result.push(callback.call(thisArg, item, i, this));
+    }
+    return result;
+  }
+  /**
+   *  Returns the value for %%name%%.
+   *
+   *  Since it is possible to have a key whose name conflicts with
+   *  a method on a [[Result]] or its superclass Array, or any
+   *  JavaScript keyword, this ensures all named values are still
+   *  accessible by name.
+   */
+  getValue(name) {
+    const index = getNames(this).indexOf(name);
+    if (index === -1) {
+      return void 0;
+    }
+    const value = this[index];
+    if (value instanceof Error) {
+      throwError(`property ${JSON.stringify(name)}`, value.error);
+    }
+    return value;
+  }
+  /**
+   *  Creates a new [[Result]] for %%items%% with each entry
+   *  also accessible by its corresponding name in %%keys%%.
+   */
+  static fromItems(items, keys) {
+    return new _Result(_guard, items, keys);
+  }
+};
+_names = new WeakMap();
+let Result = _Result;
+function getValue(value) {
+  let bytes = toBeArray(value);
+  assert(bytes.length <= WordSize, "value out-of-bounds", "BUFFER_OVERRUN", { buffer: bytes, length: WordSize, offset: bytes.length });
+  if (bytes.length !== WordSize) {
+    bytes = getBytesCopy(concat([Padding.slice(bytes.length % WordSize), bytes]));
+  }
+  return bytes;
+}
+class Coder {
+  constructor(name, type, localName, dynamic) {
+    // The coder name:
+    //   - address, uint256, tuple, array, etc.
+    __publicField(this, "name");
+    // The fully expanded type, including composite types:
+    //   - address, uint256, tuple(address,bytes), uint256[3][4][],  etc.
+    __publicField(this, "type");
+    // The localName bound in the signature, in this example it is "baz":
+    //   - tuple(address foo, uint bar) baz
+    __publicField(this, "localName");
+    // Whether this type is dynamic:
+    //  - Dynamic: bytes, string, address[], tuple(boolean[]), etc.
+    //  - Not Dynamic: address, uint256, boolean[3], tuple(address, uint8)
+    __publicField(this, "dynamic");
+    defineProperties(this, { name, type, localName, dynamic }, {
+      name: "string",
+      type: "string",
+      localName: "string",
+      dynamic: "boolean"
+    });
+  }
+  _throwError(message, value) {
+    assertArgument(false, message, this.localName, value);
+  }
+}
+class Writer {
+  constructor() {
+    __privateAdd(this, _Writer_instances);
+    // An array of WordSize lengthed objects to concatenation
+    __privateAdd(this, _data);
+    __privateAdd(this, _dataLength);
+    __privateSet(this, _data, []);
+    __privateSet(this, _dataLength, 0);
+  }
+  get data() {
+    return concat(__privateGet(this, _data));
+  }
+  get length() {
+    return __privateGet(this, _dataLength);
+  }
+  appendWriter(writer) {
+    return __privateMethod(this, _Writer_instances, writeData_fn).call(this, getBytesCopy(writer.data));
+  }
+  // Arrayish item; pad on the right to *nearest* WordSize
+  writeBytes(value) {
+    let bytes = getBytesCopy(value);
+    const paddingOffset = bytes.length % WordSize;
+    if (paddingOffset) {
+      bytes = getBytesCopy(concat([bytes, Padding.slice(paddingOffset)]));
+    }
+    return __privateMethod(this, _Writer_instances, writeData_fn).call(this, bytes);
+  }
+  // Numeric item; pad on the left *to* WordSize
+  writeValue(value) {
+    return __privateMethod(this, _Writer_instances, writeData_fn).call(this, getValue(value));
+  }
+  // Inserts a numeric place-holder, returning a callback that can
+  // be used to asjust the value later
+  writeUpdatableValue() {
+    const offset = __privateGet(this, _data).length;
+    __privateGet(this, _data).push(Padding);
+    __privateSet(this, _dataLength, __privateGet(this, _dataLength) + WordSize);
+    return (value) => {
+      __privateGet(this, _data)[offset] = getValue(value);
+    };
+  }
 }
+_data = new WeakMap();
+_dataLength = new WeakMap();
+_Writer_instances = new WeakSet();
+writeData_fn = function(data) {
+  __privateGet(this, _data).push(data);
+  __privateSet(this, _dataLength, __privateGet(this, _dataLength) + data.length);
+  return data.length;
+};
+const _Reader = class _Reader {
+  constructor(data, allowLoose, maxInflation) {
+    __privateAdd(this, _Reader_instances);
+    // Allows incomplete unpadded data to be read; otherwise an error
+    // is raised if attempting to overrun the buffer. This is required
+    // to deal with an old Solidity bug, in which event data for
+    // external (not public thoguh) was tightly packed.
+    __publicField(this, "allowLoose");
+    __privateAdd(this, _data2);
+    __privateAdd(this, _offset);
+    __privateAdd(this, _bytesRead);
+    __privateAdd(this, _parent);
+    __privateAdd(this, _maxInflation);
+    defineProperties(this, { allowLoose: !!allowLoose });
+    __privateSet(this, _data2, getBytesCopy(data));
+    __privateSet(this, _bytesRead, 0);
+    __privateSet(this, _parent, null);
+    __privateSet(this, _maxInflation, maxInflation != null ? maxInflation : 1024);
+    __privateSet(this, _offset, 0);
+  }
+  get data() {
+    return hexlify(__privateGet(this, _data2));
+  }
+  get dataLength() {
+    return __privateGet(this, _data2).length;
+  }
+  get consumed() {
+    return __privateGet(this, _offset);
+  }
+  get bytes() {
+    return new Uint8Array(__privateGet(this, _data2));
+  }
+  // Create a sub-reader with the same underlying data, but offset
+  subReader(offset) {
+    const reader = new _Reader(__privateGet(this, _data2).slice(__privateGet(this, _offset) + offset), this.allowLoose, __privateGet(this, _maxInflation));
+    __privateSet(reader, _parent, this);
+    return reader;
+  }
+  // Read bytes
+  readBytes(length, loose) {
+    let bytes = __privateMethod(this, _Reader_instances, peekBytes_fn).call(this, 0, length, !!loose);
+    __privateMethod(this, _Reader_instances, incrementBytesRead_fn).call(this, length);
+    __privateSet(this, _offset, __privateGet(this, _offset) + bytes.length);
+    return bytes.slice(0, length);
+  }
+  // Read a numeric values
+  readValue() {
+    return toBigInt(this.readBytes(WordSize));
+  }
+  readIndex() {
+    return toNumber(this.readBytes(WordSize));
+  }
+};
+_data2 = new WeakMap();
+_offset = new WeakMap();
+_bytesRead = new WeakMap();
+_parent = new WeakMap();
+_maxInflation = new WeakMap();
+_Reader_instances = new WeakSet();
+incrementBytesRead_fn = function(count) {
+  var _a;
+  if (__privateGet(this, _parent)) {
+    return __privateMethod(_a = __privateGet(this, _parent), _Reader_instances, incrementBytesRead_fn).call(_a, count);
+  }
+  __privateSet(this, _bytesRead, __privateGet(this, _bytesRead) + count);
+  assert(__privateGet(this, _maxInflation) < 1 || __privateGet(this, _bytesRead) <= __privateGet(this, _maxInflation) * this.dataLength, `compressed ABI data exceeds inflation ratio of ${__privateGet(this, _maxInflation)} ( see: https://github.com/ethers-io/ethers.js/issues/4537 )`, "BUFFER_OVERRUN", {
+    buffer: getBytesCopy(__privateGet(this, _data2)),
+    offset: __privateGet(this, _offset),
+    length: count,
+    info: {
+      bytesRead: __privateGet(this, _bytesRead),
+      dataLength: this.dataLength
+    }
+  });
+};
+peekBytes_fn = function(offset, length, loose) {
+  let alignedLength = Math.ceil(length / WordSize) * WordSize;
+  if (__privateGet(this, _offset) + alignedLength > __privateGet(this, _data2).length) {
+    if (this.allowLoose && loose && __privateGet(this, _offset) + length <= __privateGet(this, _data2).length) {
+      alignedLength = length;
+    } else {
+      assert(false, "data out-of-bounds", "BUFFER_OVERRUN", {
+        buffer: getBytesCopy(__privateGet(this, _data2)),
+        length: __privateGet(this, _data2).length,
+        offset: __privateGet(this, _offset) + alignedLength
+      });
+    }
+  }
+  return __privateGet(this, _data2).slice(__privateGet(this, _offset), __privateGet(this, _offset) + alignedLength);
+};
+let Reader = _Reader;
 export {
-  requirePathBrowserify as __require
+  Coder,
+  Reader,
+  Result,
+  WordSize,
+  Writer
 };
 //# sourceMappingURL=standards-sdk.es38.js.map