@hashgraphonline/standards-sdk 0.0.50 → 0.0.52

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

@@ -1,422 +1,441 @@
-import { __module as browser } from "./standards-sdk.es57.js";
-import { __require as requireQuickFormatUnescaped } from "./standards-sdk.es58.js";
-var hasRequiredBrowser;
-function requireBrowser() {
-  if (hasRequiredBrowser) return browser.exports;
-  hasRequiredBrowser = 1;
-  const format = requireQuickFormatUnescaped();
-  browser.exports = pino;
-  const _console = pfGlobalThisOrFallback().console || {};
-  const stdSerializers = {
-    mapHttpRequest: mock,
-    mapHttpResponse: mock,
-    wrapRequestSerializer: passthrough,
-    wrapResponseSerializer: passthrough,
-    wrapErrorSerializer: passthrough,
-    req: mock,
-    res: mock,
-    err: asErrValue,
-    errWithCause: asErrValue
-  };
-  function levelToValue(level, logger) {
-    return level === "silent" ? Infinity : logger.levels.values[level];
-  }
-  const baseLogFunctionSymbol = Symbol("pino.logFuncs");
-  const hierarchySymbol = Symbol("pino.hierarchy");
-  const logFallbackMap = {
-    error: "log",
-    fatal: "error",
-    warn: "error",
-    info: "log",
-    debug: "log",
-    trace: "log"
-  };
-  function appendChildLogger(parentLogger, childLogger) {
-    const newEntry = {
-      logger: childLogger,
-      parent: parentLogger[hierarchySymbol]
-    };
-    childLogger[hierarchySymbol] = newEntry;
-  }
-  function setupBaseLogFunctions(logger, levels, proto) {
-    const logFunctions = {};
-    levels.forEach((level) => {
-      logFunctions[level] = proto[level] ? proto[level] : _console[level] || _console[logFallbackMap[level] || "log"] || noop;
+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.es72.js";
+import { assert, assertArgument } from "./standards-sdk.es67.js";
+import { concat, getBytesCopy, hexlify } from "./standards-sdk.es68.js";
+import { defineProperties } from "./standards-sdk.es70.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 item;
     });
-    logger[baseLogFunctionSymbol] = logFunctions;
-  }
-  function shouldSerialize(serialize, serializers) {
-    if (Array.isArray(serialize)) {
-      const hasToFilter = serialize.filter(function(k) {
-        return k !== "!stdSerializers.err";
-      });
-      return hasToFilter;
-    } else if (serialize === true) {
-      return Object.keys(serializers);
-    }
-    return false;
   }
-  function pino(opts) {
-    opts = opts || {};
-    opts.browser = opts.browser || {};
-    const transmit2 = opts.browser.transmit;
-    if (transmit2 && typeof transmit2.send !== "function") {
-      throw Error("pino: transmit option must have a send function");
+  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;
     }
-    const proto = opts.browser.write || _console;
-    if (opts.browser.write) opts.browser.asObject = true;
-    const serializers = opts.serializers || {};
-    const serialize = shouldSerialize(opts.browser.serialize, serializers);
-    let stdErrSerialize = opts.browser.serialize;
-    if (Array.isArray(opts.browser.serialize) && opts.browser.serialize.indexOf("!stdSerializers.err") > -1) stdErrSerialize = false;
-    const customLevels = Object.keys(opts.customLevels || {});
-    const levels = ["error", "fatal", "warn", "info", "debug", "trace"].concat(customLevels);
-    if (typeof proto === "function") {
-      levels.forEach(function(level2) {
-        proto[level2] = proto;
-      });
+    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;
     }
-    if (opts.enabled === false || opts.browser.disabled) opts.level = "silent";
-    const level = opts.level || "info";
-    const logger = Object.create(proto);
-    if (!logger.log) logger.log = noop;
-    setupBaseLogFunctions(logger, levels, proto);
-    appendChildLogger({}, logger);
-    Object.defineProperty(logger, "levelVal", {
-      get: getLevelVal
+    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;
     });
-    Object.defineProperty(logger, "level", {
-      get: getLevel,
-      set: setLevel
-    });
-    const setOpts = {
-      transmit: transmit2,
-      serialize,
-      asObject: opts.browser.asObject,
-      formatters: opts.browser.formatters,
-      levels,
-      timestamp: getTimeFunction(opts),
-      messageKey: opts.messageKey || "msg",
-      onChild: opts.onChild || noop
-    };
-    logger.levels = getLevels(opts);
-    logger.level = level;
-    logger.setMaxListeners = logger.getMaxListeners = logger.emit = logger.addListener = logger.on = logger.prependListener = logger.once = logger.prependOnceListener = logger.removeListener = logger.removeAllListeners = logger.listeners = logger.listenerCount = logger.eventNames = logger.write = logger.flush = noop;
-    logger.serializers = serializers;
-    logger._serialize = serialize;
-    logger._stdErrSerialize = stdErrSerialize;
-    logger.child = function(...args) {
-      return child.call(this, setOpts, ...args);
-    };
-    if (transmit2) logger._logEvent = createLogEventShape();
-    function getLevelVal() {
-      return levelToValue(this.level, this);
+    const nameCounts = names.reduce((accum, name) => {
+      if (typeof name === "string") {
+        accum.set(name, (accum.get(name) || 0) + 1);
+      }
+      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;
+      }
+      return null;
+    })));
+    __privateSet(this, _names, []);
+    if (__privateGet(this, _names) == null) {
+      void __privateGet(this, _names);
     }
-    function getLevel() {
-      return this._level;
+    if (!wrap) {
+      return;
     }
-    function setLevel(level2) {
-      if (level2 !== "silent" && !this.levels.values[level2]) {
-        throw Error("unknown level " + level2);
+    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");
+            }
+            const item = target[index];
+            if (item instanceof Error) {
+              throwError(`index ${index}`, item);
+            }
+            return item;
+          }
+          if (passProperties.indexOf(prop) >= 0) {
+            return Reflect.get(target, prop, receiver);
+          }
+          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]);
+          }
+        }
+        return Reflect.get(target, prop, receiver);
+      }
+    });
+    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);
+      }
+      if (deep && item instanceof _Result) {
+        item = item.toArray(deep);
       }
-      this._level = level2;
-      set(this, setOpts, logger, "error");
-      set(this, setOpts, logger, "fatal");
-      set(this, setOpts, logger, "warn");
-      set(this, setOpts, logger, "info");
-      set(this, setOpts, logger, "debug");
-      set(this, setOpts, logger, "trace");
-      customLevels.forEach((level3) => {
-        set(this, setOpts, logger, level3);
+      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;
     }
-    function child(setOpts2, bindings, childOptions) {
-      if (!bindings) {
-        throw new Error("missing bindings for child Pino");
+    if (start < 0) {
+      start += this.length;
+      if (start < 0) {
+        start = 0;
       }
-      childOptions = childOptions || {};
-      if (serialize && bindings.serializers) {
-        childOptions.serializers = bindings.serializers;
+    }
+    if (end == null) {
+      end = this.length;
+    }
+    if (end < 0) {
+      end += this.length;
+      if (end < 0) {
+        end = 0;
       }
-      const childOptionsSerializers = childOptions.serializers;
-      if (serialize && childOptionsSerializers) {
-        var childSerializers = Object.assign({}, serializers, childOptionsSerializers);
-        var childSerialize = opts.browser.serialize === true ? Object.keys(childSerializers) : serialize;
-        delete bindings.serializers;
-        applySerializers([bindings], childSerialize, childSerializers, this._stdErrSerialize);
+    }
+    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);
       }
-      function Child(parent) {
-        this._childLevel = (parent._childLevel | 0) + 1;
-        this.bindings = bindings;
-        if (childSerializers) {
-          this.serializers = childSerializers;
-          this._serialize = childSerialize;
-        }
-        if (transmit2) {
-          this._logEvent = createLogEventShape(
-            [].concat(parent._logEvent.bindings, bindings)
-          );
-        }
+      if (callback.call(thisArg, item, i, this)) {
+        result.push(item);
+        names.push(_names2[i]);
       }
-      Child.prototype = this;
-      const newLogger = new Child(this);
-      appendChildLogger(this, newLogger);
-      newLogger.child = function(...args) {
-        return child.call(this, setOpts2, ...args);
-      };
-      newLogger.level = childOptions.level || this.level;
-      setOpts2.onChild(newLogger);
-      return newLogger;
     }
-    return logger;
-  }
-  function getLevels(opts) {
-    const customLevels = opts.customLevels || {};
-    const values = Object.assign({}, pino.levels.values, customLevels);
-    const labels = Object.assign({}, pino.levels.labels, invertObject(customLevels));
-    return {
-      values,
-      labels
-    };
+    return new _Result(_guard, result, names);
   }
-  function invertObject(obj) {
-    const inverted = {};
-    Object.keys(obj).forEach(function(key) {
-      inverted[obj[key]] = key;
-    });
-    return inverted;
-  }
-  pino.levels = {
-    values: {
-      fatal: 60,
-      error: 50,
-      warn: 40,
-      info: 30,
-      debug: 20,
-      trace: 10
-    },
-    labels: {
-      10: "trace",
-      20: "debug",
-      30: "info",
-      40: "warn",
-      50: "error",
-      60: "fatal"
-    }
-  };
-  pino.stdSerializers = stdSerializers;
-  pino.stdTimeFunctions = Object.assign({}, { nullTime, epochTime, unixTime, isoTime });
-  function getBindingChain(logger) {
-    const bindings = [];
-    if (logger.bindings) {
-      bindings.push(logger.bindings);
-    }
-    let hierarchy = logger[hierarchySymbol];
-    while (hierarchy.parent) {
-      hierarchy = hierarchy.parent;
-      if (hierarchy.logger.bindings) {
-        bindings.push(hierarchy.logger.bindings);
+  /**
+   *  @_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);
       }
+      result.push(callback.call(thisArg, item, i, this));
     }
-    return bindings.reverse();
+    return result;
   }
-  function set(self2, opts, rootLogger, level) {
-    Object.defineProperty(self2, level, {
-      value: levelToValue(self2.level, rootLogger) > levelToValue(level, rootLogger) ? noop : rootLogger[baseLogFunctionSymbol][level],
-      writable: true,
-      enumerable: true,
-      configurable: true
-    });
-    if (self2[level] === noop) {
-      if (!opts.transmit) return;
-      const transmitLevel = opts.transmit.level || self2.level;
-      const transmitValue = levelToValue(transmitLevel, rootLogger);
-      const methodValue = levelToValue(level, rootLogger);
-      if (methodValue < transmitValue) return;
+  /**
+   *  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;
     }
-    self2[level] = createWrap(self2, opts, rootLogger, level);
-    const bindings = getBindingChain(self2);
-    if (bindings.length === 0) {
-      return;
+    const value = this[index];
+    if (value instanceof Error) {
+      throwError(`property ${JSON.stringify(name)}`, value.error);
     }
-    self2[level] = prependBindingsInArguments(bindings, self2[level]);
+    return value;
   }
-  function prependBindingsInArguments(bindings, logFunc) {
-    return function() {
-      return logFunc.apply(this, [...bindings, ...arguments]);
-    };
+  /**
+   *  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);
   }
-  function createWrap(self2, opts, rootLogger, level) {
-    return /* @__PURE__ */ function(write) {
-      return function LOG() {
-        const ts = opts.timestamp();
-        const args = new Array(arguments.length);
-        const proto = Object.getPrototypeOf && Object.getPrototypeOf(this) === _console ? _console : this;
-        for (var i = 0; i < args.length; i++) args[i] = arguments[i];
-        var argsIsSerialized = false;
-        if (opts.serialize) {
-          applySerializers(args, this._serialize, this.serializers, this._stdErrSerialize);
-          argsIsSerialized = true;
-        }
-        if (opts.asObject || opts.formatters) {
-          write.call(proto, asObject(this, level, args, ts, opts));
-        } else write.apply(proto, args);
-        if (opts.transmit) {
-          const transmitLevel = opts.transmit.level || self2._level;
-          const transmitValue = levelToValue(transmitLevel, rootLogger);
-          const methodValue = levelToValue(level, rootLogger);
-          if (methodValue < transmitValue) return;
-          transmit(this, {
-            ts,
-            methodLevel: level,
-            methodValue,
-            transmitValue: rootLogger.levels.values[opts.transmit.level || self2._level],
-            send: opts.transmit.send,
-            val: levelToValue(self2._level, rootLogger)
-          }, args, argsIsSerialized);
-        }
-      };
-    }(self2[baseLogFunctionSymbol][level]);
+};
+_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]));
   }
-  function asObject(logger, level, args, ts, opts) {
-    const {
-      level: levelFormatter,
-      log: logObjectFormatter = (obj) => obj
-    } = opts.formatters || {};
-    const argsCloned = args.slice();
-    let msg = argsCloned[0];
-    const logObject = {};
-    if (ts) {
-      logObject.time = ts;
-    }
-    if (levelFormatter) {
-      const formattedLevel = levelFormatter(level, logger.levels.values[level]);
-      Object.assign(logObject, formattedLevel);
-    } else {
-      logObject.level = logger.levels.values[level];
-    }
-    let lvl = (logger._childLevel | 0) + 1;
-    if (lvl < 1) lvl = 1;
-    if (msg !== null && typeof msg === "object") {
-      while (lvl-- && typeof argsCloned[0] === "object") {
-        Object.assign(logObject, argsCloned.shift());
-      }
-      msg = argsCloned.length ? format(argsCloned.shift(), argsCloned) : void 0;
-    } else if (typeof msg === "string") msg = format(argsCloned.shift(), argsCloned);
-    if (msg !== void 0) logObject[opts.messageKey] = msg;
-    const formattedLogObject = logObjectFormatter(logObject);
-    return formattedLogObject;
+  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"
+    });
   }
-  function applySerializers(args, serialize, serializers, stdErrSerialize) {
-    for (const i in args) {
-      if (stdErrSerialize && args[i] instanceof Error) {
-        args[i] = pino.stdSerializers.err(args[i]);
-      } else if (typeof args[i] === "object" && !Array.isArray(args[i]) && serialize) {
-        for (const k in args[i]) {
-          if (serialize.indexOf(k) > -1 && k in serializers) {
-            args[i][k] = serializers[k](args[i][k]);
-          }
-        }
-      }
-    }
+  _throwError(message, value) {
+    assertArgument(false, message, this.localName, value);
   }
-  function transmit(logger, opts, args, argsIsSerialized = false) {
-    const send = opts.send;
-    const ts = opts.ts;
-    const methodLevel = opts.methodLevel;
-    const methodValue = opts.methodValue;
-    const val = opts.val;
-    const bindings = logger._logEvent.bindings;
-    if (!argsIsSerialized) {
-      applySerializers(
-        args,
-        logger._serialize || Object.keys(logger.serializers),
-        logger.serializers,
-        logger._stdErrSerialize === void 0 ? true : logger._stdErrSerialize
-      );
+}
+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)]));
     }
-    logger._logEvent.ts = ts;
-    logger._logEvent.messages = args.filter(function(arg) {
-      return bindings.indexOf(arg) === -1;
-    });
-    logger._logEvent.level.label = methodLevel;
-    logger._logEvent.level.value = methodValue;
-    send(methodLevel, logger._logEvent, val);
-    logger._logEvent = createLogEventShape(bindings);
+    return __privateMethod(this, _Writer_instances, writeData_fn).call(this, bytes);
   }
-  function createLogEventShape(bindings) {
-    return {
-      ts: 0,
-      messages: [],
-      bindings: bindings || [],
-      level: { label: "", value: 0 }
-    };
+  // Numeric item; pad on the left *to* WordSize
+  writeValue(value) {
+    return __privateMethod(this, _Writer_instances, writeData_fn).call(this, getValue(value));
   }
-  function asErrValue(err) {
-    const obj = {
-      type: err.constructor.name,
-      msg: err.message,
-      stack: err.stack
+  // 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);
     };
-    for (const key in err) {
-      if (obj[key] === void 0) {
-        obj[key] = err[key];
-      }
-    }
-    return obj;
   }
-  function getTimeFunction(opts) {
-    if (typeof opts.timestamp === "function") {
-      return opts.timestamp;
-    }
-    if (opts.timestamp === false) {
-      return nullTime;
-    }
-    return epochTime;
+}
+_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;
   }
-  function mock() {
-    return {};
+  get consumed() {
+    return __privateGet(this, _offset);
   }
-  function passthrough(a) {
-    return a;
+  get bytes() {
+    return new Uint8Array(__privateGet(this, _data2));
   }
-  function noop() {
+  // 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;
   }
-  function nullTime() {
-    return false;
+  // 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);
   }
-  function epochTime() {
-    return Date.now();
+  // Read a numeric values
+  readValue() {
+    return toBigInt(this.readBytes(WordSize));
   }
-  function unixTime() {
-    return Math.round(Date.now() / 1e3);
+  readIndex() {
+    return toNumber(this.readBytes(WordSize));
   }
-  function isoTime() {
-    return new Date(Date.now()).toISOString();
+};
+_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);
   }
-  function pfGlobalThisOrFallback() {
-    function defd(o) {
-      return typeof o !== "undefined" && o;
+  __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
     }
-    try {
-      if (typeof globalThis !== "undefined") return globalThis;
-      Object.defineProperty(Object.prototype, "globalThis", {
-        get: function() {
-          delete Object.prototype.globalThis;
-          return this.globalThis = this;
-        },
-        configurable: true
+  });
+};
+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 globalThis;
-    } catch (e) {
-      return defd(self) || defd(window) || defd(this) || {};
     }
   }
-  browser.exports.default = pino;
-  browser.exports.pino = pino;
-  return browser.exports;
-}
+  return __privateGet(this, _data2).slice(__privateGet(this, _offset), __privateGet(this, _offset) + alignedLength);
+};
+let Reader = _Reader;
 export {
-  requireBrowser as __require
+  Coder,
+  Reader,
+  Result,
+  WordSize,
+  Writer
 };
 //# sourceMappingURL=standards-sdk.es56.js.map