@hashgraphonline/standards-sdk 0.0.95 → 0.0.96

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

@@ -1,1292 +1,422 @@
-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 __privateWrapper = (obj, member, setter, getter) => ({
-  set _(value) {
-    __privateSet(obj, member, value, setter);
-  },
-  get _() {
-    return __privateGet(obj, member, getter);
-  }
-});
-var _offset, _tokens, _TokenString_instances, subTokenString_fn, _ParamType_instances, walkAsync_fn;
-import { assertPrivate, assert, assertArgument } from "./standards-sdk.es49.js";
-import { defineProperties } from "./standards-sdk.es52.js";
-import { id } from "./standards-sdk.es53.js";
-import { getNumber, getBigInt } from "./standards-sdk.es54.js";
-function setify(items) {
-  const result = /* @__PURE__ */ new Set();
-  items.forEach((k) => result.add(k));
-  return Object.freeze(result);
-}
-const _kwVisibDeploy = "external public payable override";
-const KwVisibDeploy = setify(_kwVisibDeploy.split(" "));
-const _kwVisib = "constant external internal payable private public pure view override";
-const KwVisib = setify(_kwVisib.split(" "));
-const _kwTypes = "constructor error event fallback function receive struct";
-const KwTypes = setify(_kwTypes.split(" "));
-const _kwModifiers = "calldata memory storage payable indexed";
-const KwModifiers = setify(_kwModifiers.split(" "));
-const _kwOther = "tuple returns";
-const _keywords = [_kwTypes, _kwModifiers, _kwOther, _kwVisib].join(" ");
-const Keywords = setify(_keywords.split(" "));
-const SimpleTokens = {
-  "(": "OPEN_PAREN",
-  ")": "CLOSE_PAREN",
-  "[": "OPEN_BRACKET",
-  "]": "CLOSE_BRACKET",
-  ",": "COMMA",
-  "@": "AT"
-};
-const regexWhitespacePrefix = new RegExp("^(\\s*)");
-const regexNumberPrefix = new RegExp("^([0-9]+)");
-const regexIdPrefix = new RegExp("^([a-zA-Z$_][a-zA-Z0-9$_]*)");
-const regexId = new RegExp("^([a-zA-Z$_][a-zA-Z0-9$_]*)$");
-const regexType = new RegExp("^(address|bool|bytes([0-9]*)|string|u?int([0-9]*))$");
-const _TokenString = class _TokenString {
-  constructor(tokens) {
-    __privateAdd(this, _TokenString_instances);
-    __privateAdd(this, _offset);
-    __privateAdd(this, _tokens);
-    __privateSet(this, _offset, 0);
-    __privateSet(this, _tokens, tokens.slice());
-  }
-  get offset() {
-    return __privateGet(this, _offset);
-  }
-  get length() {
-    return __privateGet(this, _tokens).length - __privateGet(this, _offset);
-  }
-  clone() {
-    return new _TokenString(__privateGet(this, _tokens));
-  }
-  reset() {
-    __privateSet(this, _offset, 0);
-  }
-  // Pops and returns the value of the next token, if it is a keyword in allowed; throws if out of tokens
-  popKeyword(allowed) {
-    const top = this.peek();
-    if (top.type !== "KEYWORD" || !allowed.has(top.text)) {
-      throw new Error(`expected keyword ${top.text}`);
-    }
-    return this.pop().text;
-  }
-  // Pops and returns the value of the next token if it is `type`; throws if out of tokens
-  popType(type) {
-    if (this.peek().type !== type) {
-      const top = this.peek();
-      throw new Error(`expected ${type}; got ${top.type} ${JSON.stringify(top.text)}`);
-    }
-    return this.pop().text;
-  }
-  // Pops and returns a "(" TOKENS ")"
-  popParen() {
-    const top = this.peek();
-    if (top.type !== "OPEN_PAREN") {
-      throw new Error("bad start");
-    }
-    const result = __privateMethod(this, _TokenString_instances, subTokenString_fn).call(this, __privateGet(this, _offset) + 1, top.match + 1);
-    __privateSet(this, _offset, top.match + 1);
-    return result;
-  }
-  // Pops and returns the items within "(" ITEM1 "," ITEM2 "," ... ")"
-  popParams() {
-    const top = this.peek();
-    if (top.type !== "OPEN_PAREN") {
-      throw new Error("bad start");
-    }
-    const result = [];
-    while (__privateGet(this, _offset) < top.match - 1) {
-      const link = this.peek().linkNext;
-      result.push(__privateMethod(this, _TokenString_instances, subTokenString_fn).call(this, __privateGet(this, _offset) + 1, link));
-      __privateSet(this, _offset, link);
-    }
-    __privateSet(this, _offset, top.match + 1);
-    return result;
-  }
-  // Returns the top Token, throwing if out of tokens
-  peek() {
-    if (__privateGet(this, _offset) >= __privateGet(this, _tokens).length) {
-      throw new Error("out-of-bounds");
-    }
-    return __privateGet(this, _tokens)[__privateGet(this, _offset)];
-  }
-  // Returns the next value, if it is a keyword in `allowed`
-  peekKeyword(allowed) {
-    const top = this.peekType("KEYWORD");
-    return top != null && allowed.has(top) ? top : null;
-  }
-  // Returns the value of the next token if it is `type`
-  peekType(type) {
-    if (this.length === 0) {
-      return null;
-    }
-    const top = this.peek();
-    return top.type === type ? top.text : null;
-  }
-  // Returns the next token; throws if out of tokens
-  pop() {
-    const result = this.peek();
-    __privateWrapper(this, _offset)._++;
-    return result;
-  }
-  toString() {
-    const tokens = [];
-    for (let i = __privateGet(this, _offset); i < __privateGet(this, _tokens).length; i++) {
-      const token = __privateGet(this, _tokens)[i];
-      tokens.push(`${token.type}:${token.text}`);
-    }
-    return `<TokenString ${tokens.join(" ")}>`;
-  }
-};
-_offset = new WeakMap();
-_tokens = new WeakMap();
-_TokenString_instances = new WeakSet();
-subTokenString_fn = function(from = 0, to = 0) {
-  return new _TokenString(__privateGet(this, _tokens).slice(from, to).map((t) => {
-    return Object.freeze(Object.assign({}, t, {
-      match: t.match - from,
-      linkBack: t.linkBack - from,
-      linkNext: t.linkNext - from
-    }));
-  }));
-};
-let TokenString = _TokenString;
-function lex(text) {
-  const tokens = [];
-  const throwError = (message) => {
-    const token = offset < text.length ? JSON.stringify(text[offset]) : "$EOI";
-    throw new Error(`invalid token ${token} at ${offset}: ${message}`);
+import { __module as browser } from "./standards-sdk.es49.js";
+import { __require as requireQuickFormatUnescaped } from "./standards-sdk.es50.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
   };
-  let brackets = [];
-  let commas = [];
-  let offset = 0;
-  while (offset < text.length) {
-    let cur = text.substring(offset);
-    let match = cur.match(regexWhitespacePrefix);
-    if (match) {
-      offset += match[1].length;
-      cur = text.substring(offset);
-    }
-    const token = { depth: brackets.length, linkBack: -1, linkNext: -1, match: -1, type: "", text: "", offset, value: -1 };
-    tokens.push(token);
-    let type = SimpleTokens[cur[0]] || "";
-    if (type) {
-      token.type = type;
-      token.text = cur[0];
-      offset++;
-      if (type === "OPEN_PAREN") {
-        brackets.push(tokens.length - 1);
-        commas.push(tokens.length - 1);
-      } else if (type == "CLOSE_PAREN") {
-        if (brackets.length === 0) {
-          throwError("no matching open bracket");
-        }
-        token.match = brackets.pop();
-        tokens[token.match].match = tokens.length - 1;
-        token.depth--;
-        token.linkBack = commas.pop();
-        tokens[token.linkBack].linkNext = tokens.length - 1;
-      } else if (type === "COMMA") {
-        token.linkBack = commas.pop();
-        tokens[token.linkBack].linkNext = tokens.length - 1;
-        commas.push(tokens.length - 1);
-      } else if (type === "OPEN_BRACKET") {
-        token.type = "BRACKET";
-      } else if (type === "CLOSE_BRACKET") {
-        let suffix = tokens.pop().text;
-        if (tokens.length > 0 && tokens[tokens.length - 1].type === "NUMBER") {
-          const value = tokens.pop().text;
-          suffix = value + suffix;
-          tokens[tokens.length - 1].value = getNumber(value);
-        }
-        if (tokens.length === 0 || tokens[tokens.length - 1].type !== "BRACKET") {
-          throw new Error("missing opening bracket");
-        }
-        tokens[tokens.length - 1].text += suffix;
-      }
-      continue;
-    }
-    match = cur.match(regexIdPrefix);
-    if (match) {
-      token.text = match[1];
-      offset += token.text.length;
-      if (Keywords.has(token.text)) {
-        token.type = "KEYWORD";
-        continue;
-      }
-      if (token.text.match(regexType)) {
-        token.type = "TYPE";
-        continue;
-      }
-      token.type = "ID";
-      continue;
-    }
-    match = cur.match(regexNumberPrefix);
-    if (match) {
-      token.text = match[1];
-      token.type = "NUMBER";
-      offset += token.text.length;
-      continue;
-    }
-    throw new Error(`unexpected token ${JSON.stringify(cur[0])} at position ${offset}`);
-  }
-  return new TokenString(tokens.map((t) => Object.freeze(t)));
-}
-function allowSingle(set, allowed) {
-  let included = [];
-  for (const key in allowed.keys()) {
-    if (set.has(key)) {
-      included.push(key);
-    }
-  }
-  if (included.length > 1) {
-    throw new Error(`conflicting types: ${included.join(", ")}`);
-  }
-}
-function consumeName(type, tokens) {
-  if (tokens.peekKeyword(KwTypes)) {
-    const keyword = tokens.pop().text;
-    if (keyword !== type) {
-      throw new Error(`expected ${type}, got ${keyword}`);
-    }
-  }
-  return tokens.popType("ID");
-}
-function consumeKeywords(tokens, allowed) {
-  const keywords = /* @__PURE__ */ new Set();
-  while (true) {
-    const keyword = tokens.peekType("KEYWORD");
-    if (keyword == null || allowed && !allowed.has(keyword)) {
-      break;
-    }
-    tokens.pop();
-    if (keywords.has(keyword)) {
-      throw new Error(`duplicate keywords: ${JSON.stringify(keyword)}`);
-    }
-    keywords.add(keyword);
-  }
-  return Object.freeze(keywords);
-}
-function consumeMutability(tokens) {
-  let modifiers = consumeKeywords(tokens, KwVisib);
-  allowSingle(modifiers, setify("constant payable nonpayable".split(" ")));
-  allowSingle(modifiers, setify("pure view payable nonpayable".split(" ")));
-  if (modifiers.has("view")) {
-    return "view";
-  }
-  if (modifiers.has("pure")) {
-    return "pure";
-  }
-  if (modifiers.has("payable")) {
-    return "payable";
-  }
-  if (modifiers.has("nonpayable")) {
-    return "nonpayable";
-  }
-  if (modifiers.has("constant")) {
-    return "view";
-  }
-  return "nonpayable";
-}
-function consumeParams(tokens, allowIndexed) {
-  return tokens.popParams().map((t) => ParamType.from(t, allowIndexed));
-}
-function consumeGas(tokens) {
-  if (tokens.peekType("AT")) {
-    tokens.pop();
-    if (tokens.peekType("NUMBER")) {
-      return getBigInt(tokens.pop().text);
-    }
-    throw new Error("invalid gas");
-  }
-  return null;
-}
-function consumeEoi(tokens) {
-  if (tokens.length) {
-    throw new Error(`unexpected tokens at offset ${tokens.offset}: ${tokens.toString()}`);
-  }
-}
-const regexArrayType = new RegExp(/^(.*)\[([0-9]*)\]$/);
-function verifyBasicType(type) {
-  const match = type.match(regexType);
-  assertArgument(match, "invalid type", "type", type);
-  if (type === "uint") {
-    return "uint256";
-  }
-  if (type === "int") {
-    return "int256";
-  }
-  if (match[2]) {
-    const length = parseInt(match[2]);
-    assertArgument(length !== 0 && length <= 32, "invalid bytes length", "type", type);
-  } else if (match[3]) {
-    const size = parseInt(match[3]);
-    assertArgument(size !== 0 && size <= 256 && size % 8 === 0, "invalid numeric width", "type", type);
-  }
-  return type;
-}
-const _guard = {};
-const internal = Symbol.for("_ethers_internal");
-const ParamTypeInternal = "_ParamTypeInternal";
-const ErrorFragmentInternal = "_ErrorInternal";
-const EventFragmentInternal = "_EventInternal";
-const ConstructorFragmentInternal = "_ConstructorInternal";
-const FallbackFragmentInternal = "_FallbackInternal";
-const FunctionFragmentInternal = "_FunctionInternal";
-const StructFragmentInternal = "_StructInternal";
-const _ParamType = class _ParamType {
-  /**
-   *  @private
-   */
-  constructor(guard, name, type, baseType, indexed, components, arrayLength, arrayChildren) {
-    __privateAdd(this, _ParamType_instances);
-    /**
-     *  The local name of the parameter (or ``""`` if unbound)
-     */
-    __publicField(this, "name");
-    /**
-     *  The fully qualified type (e.g. ``"address"``, ``"tuple(address)"``,
-     *  ``"uint256[3][]"``)
-     */
-    __publicField(this, "type");
-    /**
-     *  The base type (e.g. ``"address"``, ``"tuple"``, ``"array"``)
-     */
-    __publicField(this, "baseType");
-    /**
-     *  True if the parameters is indexed.
-     *
-     *  For non-indexable types this is ``null``.
-     */
-    __publicField(this, "indexed");
-    /**
-     *  The components for the tuple.
-     *
-     *  For non-tuple types this is ``null``.
-     */
-    __publicField(this, "components");
-    /**
-     *  The array length, or ``-1`` for dynamic-lengthed arrays.
-     *
-     *  For non-array types this is ``null``.
-     */
-    __publicField(this, "arrayLength");
-    /**
-     *  The type of each child in the array.
-     *
-     *  For non-array types this is ``null``.
-     */
-    __publicField(this, "arrayChildren");
-    assertPrivate(guard, _guard, "ParamType");
-    Object.defineProperty(this, internal, { value: ParamTypeInternal });
-    if (components) {
-      components = Object.freeze(components.slice());
-    }
-    if (baseType === "array") {
-      if (arrayLength == null || arrayChildren == null) {
-        throw new Error("");
-      }
-    } else if (arrayLength != null || arrayChildren != null) {
-      throw new Error("");
-    }
-    if (baseType === "tuple") {
-      if (components == null) {
-        throw new Error("");
-      }
-    } else if (components != null) {
-      throw new Error("");
-    }
-    defineProperties(this, {
-      name,
-      type,
-      baseType,
-      indexed,
-      components,
-      arrayLength,
-      arrayChildren
+  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;
     });
+    logger[baseLogFunctionSymbol] = logFunctions;
   }
-  /**
-   *  Return a string representation of this type.
-   *
-   *  For example,
-   *
-   *  ``sighash" => "(uint256,address)"``
-   *
-   *  ``"minimal" => "tuple(uint256,address) indexed"``
-   *
-   *  ``"full" => "tuple(uint256 foo, address bar) indexed baz"``
-   */
-  format(format) {
-    if (format == null) {
-      format = "sighash";
-    }
-    if (format === "json") {
-      const name = this.name || "";
-      if (this.isArray()) {
-        const result3 = JSON.parse(this.arrayChildren.format("json"));
-        result3.name = name;
-        result3.type += `[${this.arrayLength < 0 ? "" : String(this.arrayLength)}]`;
-        return JSON.stringify(result3);
-      }
-      const result2 = {
-        type: this.baseType === "tuple" ? "tuple" : this.type,
-        name
-      };
-      if (typeof this.indexed === "boolean") {
-        result2.indexed = this.indexed;
-      }
-      if (this.isTuple()) {
-        result2.components = this.components.map((c) => JSON.parse(c.format(format)));
-      }
-      return JSON.stringify(result2);
-    }
-    let result = "";
-    if (this.isArray()) {
-      result += this.arrayChildren.format(format);
-      result += `[${this.arrayLength < 0 ? "" : String(this.arrayLength)}]`;
-    } else {
-      if (this.isTuple()) {
-        result += "(" + this.components.map((comp) => comp.format(format)).join(format === "full" ? ", " : ",") + ")";
-      } else {
-        result += this.type;
-      }
-    }
-    if (format !== "sighash") {
-      if (this.indexed === true) {
-        result += " indexed";
-      }
-      if (format === "full" && this.name) {
-        result += " " + this.name;
-      }
-    }
-    return result;
-  }
-  /**
-   *  Returns true if %%this%% is an Array type.
-   *
-   *  This provides a type gaurd ensuring that [[arrayChildren]]
-   *  and [[arrayLength]] are non-null.
-   */
-  isArray() {
-    return this.baseType === "array";
-  }
-  /**
-   *  Returns true if %%this%% is a Tuple type.
-   *
-   *  This provides a type gaurd ensuring that [[components]]
-   *  is non-null.
-   */
-  isTuple() {
-    return this.baseType === "tuple";
-  }
-  /**
-   *  Returns true if %%this%% is an Indexable type.
-   *
-   *  This provides a type gaurd ensuring that [[indexed]]
-   *  is non-null.
-   */
-  isIndexable() {
-    return this.indexed != null;
-  }
-  /**
-   *  Walks the **ParamType** with %%value%%, calling %%process%%
-   *  on each type, destructing the %%value%% recursively.
-   */
-  walk(value, process) {
-    if (this.isArray()) {
-      if (!Array.isArray(value)) {
-        throw new Error("invalid array value");
-      }
-      if (this.arrayLength !== -1 && value.length !== this.arrayLength) {
-        throw new Error("array is wrong length");
-      }
-      const _this = this;
-      return value.map((v) => _this.arrayChildren.walk(v, process));
-    }
-    if (this.isTuple()) {
-      if (!Array.isArray(value)) {
-        throw new Error("invalid tuple value");
-      }
-      if (value.length !== this.components.length) {
-        throw new Error("array is wrong length");
-      }
-      const _this = this;
-      return value.map((v, i) => _this.components[i].walk(v, process));
+  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");
+    }
+    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 process(this.type, value);
-  }
-  /**
-   *  Walks the **ParamType** with %%value%%, asynchronously calling
-   *  %%process%% on each type, destructing the %%value%% recursively.
-   *
-   *  This can be used to resolve ENS names by walking and resolving each
-   *  ``"address"`` type.
-   */
-  async walkAsync(value, process) {
-    const promises = [];
-    const result = [value];
-    __privateMethod(this, _ParamType_instances, walkAsync_fn).call(this, promises, value, process, (value2) => {
-      result[0] = value2;
+    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
     });
-    if (promises.length) {
-      await Promise.all(promises);
-    }
-    return result[0];
-  }
-  /**
-   *  Creates a new **ParamType** for %%obj%%.
-   *
-   *  If %%allowIndexed%% then the ``indexed`` keyword is permitted,
-   *  otherwise the ``indexed`` keyword will throw an error.
-   */
-  static from(obj, allowIndexed) {
-    if (_ParamType.isParamType(obj)) {
-      return obj;
+    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);
+    }
+    function getLevel() {
+      return this._level;
+    }
+    function setLevel(level2) {
+      if (level2 !== "silent" && !this.levels.values[level2]) {
+        throw Error("unknown level " + level2);
+      }
+      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);
+      });
     }
-    if (typeof obj === "string") {
-      try {
-        return _ParamType.from(lex(obj), allowIndexed);
-      } catch (error) {
-        assertArgument(false, "invalid param type", "obj", obj);
-      }
-    } else if (obj instanceof TokenString) {
-      let type2 = "", baseType = "";
-      let comps = null;
-      if (consumeKeywords(obj, setify(["tuple"])).has("tuple") || obj.peekType("OPEN_PAREN")) {
-        baseType = "tuple";
-        comps = obj.popParams().map((t) => _ParamType.from(t));
-        type2 = `tuple(${comps.map((c) => c.format()).join(",")})`;
-      } else {
-        type2 = verifyBasicType(obj.popType("TYPE"));
-        baseType = type2;
-      }
-      let arrayChildren = null;
-      let arrayLength = null;
-      while (obj.length && obj.peekType("BRACKET")) {
-        const bracket = obj.pop();
-        arrayChildren = new _ParamType(_guard, "", type2, baseType, null, comps, arrayLength, arrayChildren);
-        arrayLength = bracket.value;
-        type2 += bracket.text;
-        baseType = "array";
-        comps = null;
-      }
-      let indexed2 = null;
-      const keywords = consumeKeywords(obj, KwModifiers);
-      if (keywords.has("indexed")) {
-        if (!allowIndexed) {
-          throw new Error("");
+    function child(setOpts2, bindings, childOptions) {
+      if (!bindings) {
+        throw new Error("missing bindings for child Pino");
+      }
+      childOptions = childOptions || {};
+      if (serialize && bindings.serializers) {
+        childOptions.serializers = bindings.serializers;
+      }
+      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);
+      }
+      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)
+          );
         }
-        indexed2 = true;
-      }
-      const name2 = obj.peekType("ID") ? obj.pop().text : "";
-      if (obj.length) {
-        throw new Error("leftover tokens");
       }
-      return new _ParamType(_guard, name2, type2, baseType, indexed2, comps, arrayLength, arrayChildren);
-    }
-    const name = obj.name;
-    assertArgument(!name || typeof name === "string" && name.match(regexId), "invalid name", "obj.name", name);
-    let indexed = obj.indexed;
-    if (indexed != null) {
-      assertArgument(allowIndexed, "parameter cannot be indexed", "obj.indexed", obj.indexed);
-      indexed = !!indexed;
-    }
-    let type = obj.type;
-    let arrayMatch = type.match(regexArrayType);
-    if (arrayMatch) {
-      const arrayLength = parseInt(arrayMatch[2] || "-1");
-      const arrayChildren = _ParamType.from({
-        type: arrayMatch[1],
-        components: obj.components
-      });
-      return new _ParamType(_guard, name || "", type, "array", indexed, null, arrayLength, arrayChildren);
-    }
-    if (type === "tuple" || type.startsWith(
-      "tuple("
-      /* fix: ) */
-    ) || type.startsWith(
-      "("
-      /* fix: ) */
-    )) {
-      const comps = obj.components != null ? obj.components.map((c) => _ParamType.from(c)) : null;
-      const tuple = new _ParamType(_guard, name || "", type, "tuple", indexed, comps, null, null);
-      return tuple;
-    }
-    type = verifyBasicType(obj.type);
-    return new _ParamType(_guard, name || "", type, type, indexed, null, null, null);
-  }
-  /**
-   *  Returns true if %%value%% is a **ParamType**.
-   */
-  static isParamType(value) {
-    return value && value[internal] === ParamTypeInternal;
-  }
-};
-_ParamType_instances = new WeakSet();
-walkAsync_fn = function(promises, value, process, setValue) {
-  if (this.isArray()) {
-    if (!Array.isArray(value)) {
-      throw new Error("invalid array value");
-    }
-    if (this.arrayLength !== -1 && value.length !== this.arrayLength) {
-      throw new Error("array is wrong length");
+      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
+    };
+  }
+  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"
     }
-    const childType = this.arrayChildren;
-    const result2 = value.slice();
-    result2.forEach((value2, index) => {
-      var _a;
-      __privateMethod(_a = childType, _ParamType_instances, walkAsync_fn).call(_a, promises, value2, process, (value3) => {
-        result2[index] = value3;
-      });
+  };
+  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);
+      }
+    }
+    return bindings.reverse();
+  }
+  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
     });
-    setValue(result2);
-    return;
-  }
-  if (this.isTuple()) {
-    const components = this.components;
-    let result2;
-    if (Array.isArray(value)) {
-      result2 = value.slice();
-    } else {
-      if (value == null || typeof value !== "object") {
-        throw new Error("invalid tuple value");
-      }
-      result2 = components.map((param) => {
-        if (!param.name) {
-          throw new Error("cannot use object value with unnamed components");
+    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;
+    }
+    self2[level] = createWrap(self2, opts, rootLogger, level);
+    const bindings = getBindingChain(self2);
+    if (bindings.length === 0) {
+      return;
+    }
+    self2[level] = prependBindingsInArguments(bindings, self2[level]);
+  }
+  function prependBindingsInArguments(bindings, logFunc) {
+    return function() {
+      return logFunc.apply(this, [...bindings, ...arguments]);
+    };
+  }
+  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 (!(param.name in value)) {
-          throw new Error(`missing value for component ${param.name}`);
+        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]);
+  }
+  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;
+  }
+  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]);
+          }
         }
-        return value[param.name];
-      });
-    }
-    if (result2.length !== this.components.length) {
-      throw new Error("array is wrong length");
-    }
-    result2.forEach((value2, index) => {
-      var _a;
-      __privateMethod(_a = components[index], _ParamType_instances, walkAsync_fn).call(_a, promises, value2, process, (value3) => {
-        result2[index] = value3;
-      });
-    });
-    setValue(result2);
-    return;
-  }
-  const result = process(this.type, value);
-  if (result.then) {
-    promises.push(async function() {
-      setValue(await result);
-    }());
-  } else {
-    setValue(result);
-  }
-};
-let ParamType = _ParamType;
-class Fragment {
-  /**
-   *  @private
-   */
-  constructor(guard, type, inputs) {
-    /**
-     *  The type of the fragment.
-     */
-    __publicField(this, "type");
-    /**
-     *  The inputs for the fragment.
-     */
-    __publicField(this, "inputs");
-    assertPrivate(guard, _guard, "Fragment");
-    inputs = Object.freeze(inputs.slice());
-    defineProperties(this, { type, inputs });
-  }
-  /**
-   *  Creates a new **Fragment** for %%obj%%, wich can be any supported
-   *  ABI frgament type.
-   */
-  static from(obj) {
-    if (typeof obj === "string") {
-      try {
-        Fragment.from(JSON.parse(obj));
-      } catch (e) {
-      }
-      return Fragment.from(lex(obj));
-    }
-    if (obj instanceof TokenString) {
-      const type = obj.peekKeyword(KwTypes);
-      switch (type) {
-        case "constructor":
-          return ConstructorFragment.from(obj);
-        case "error":
-          return ErrorFragment.from(obj);
-        case "event":
-          return EventFragment.from(obj);
-        case "fallback":
-        case "receive":
-          return FallbackFragment.from(obj);
-        case "function":
-          return FunctionFragment.from(obj);
-        case "struct":
-          return StructFragment.from(obj);
-      }
-    } else if (typeof obj === "object") {
-      switch (obj.type) {
-        case "constructor":
-          return ConstructorFragment.from(obj);
-        case "error":
-          return ErrorFragment.from(obj);
-        case "event":
-          return EventFragment.from(obj);
-        case "fallback":
-        case "receive":
-          return FallbackFragment.from(obj);
-        case "function":
-          return FunctionFragment.from(obj);
-        case "struct":
-          return StructFragment.from(obj);
       }
-      assert(false, `unsupported type: ${obj.type}`, "UNSUPPORTED_OPERATION", {
-        operation: "Fragment.from"
-      });
-    }
-    assertArgument(false, "unsupported frgament object", "obj", obj);
-  }
-  /**
-   *  Returns true if %%value%% is a [[ConstructorFragment]].
-   */
-  static isConstructor(value) {
-    return ConstructorFragment.isFragment(value);
-  }
-  /**
-   *  Returns true if %%value%% is an [[ErrorFragment]].
-   */
-  static isError(value) {
-    return ErrorFragment.isFragment(value);
-  }
-  /**
-   *  Returns true if %%value%% is an [[EventFragment]].
-   */
-  static isEvent(value) {
-    return EventFragment.isFragment(value);
-  }
-  /**
-   *  Returns true if %%value%% is a [[FunctionFragment]].
-   */
-  static isFunction(value) {
-    return FunctionFragment.isFragment(value);
-  }
-  /**
-   *  Returns true if %%value%% is a [[StructFragment]].
-   */
-  static isStruct(value) {
-    return StructFragment.isFragment(value);
-  }
-}
-class NamedFragment extends Fragment {
-  /**
-   *  @private
-   */
-  constructor(guard, type, name, inputs) {
-    super(guard, type, inputs);
-    /**
-     *  The name of the fragment.
-     */
-    __publicField(this, "name");
-    assertArgument(typeof name === "string" && name.match(regexId), "invalid identifier", "name", name);
-    inputs = Object.freeze(inputs.slice());
-    defineProperties(this, { name });
-  }
-}
-function joinParams(format, params) {
-  return "(" + params.map((p) => p.format(format)).join(format === "full" ? ", " : ",") + ")";
-}
-class ErrorFragment extends NamedFragment {
-  /**
-   *  @private
-   */
-  constructor(guard, name, inputs) {
-    super(guard, "error", name, inputs);
-    Object.defineProperty(this, internal, { value: ErrorFragmentInternal });
-  }
-  /**
-   *  The Custom Error selector.
-   */
-  get selector() {
-    return id(this.format("sighash")).substring(0, 10);
-  }
-  /**
-   *  Returns a string representation of this fragment as %%format%%.
-   */
-  format(format) {
-    if (format == null) {
-      format = "sighash";
     }
-    if (format === "json") {
-      return JSON.stringify({
-        type: "error",
-        name: this.name,
-        inputs: this.inputs.map((input) => JSON.parse(input.format(format)))
-      });
-    }
-    const result = [];
-    if (format !== "sighash") {
-      result.push("error");
-    }
-    result.push(this.name + joinParams(format, this.inputs));
-    return result.join(" ");
-  }
-  /**
-   *  Returns a new **ErrorFragment** for %%obj%%.
-   */
-  static from(obj) {
-    if (ErrorFragment.isFragment(obj)) {
-      return obj;
-    }
-    if (typeof obj === "string") {
-      return ErrorFragment.from(lex(obj));
-    } else if (obj instanceof TokenString) {
-      const name = consumeName("error", obj);
-      const inputs = consumeParams(obj);
-      consumeEoi(obj);
-      return new ErrorFragment(_guard, name, inputs);
-    }
-    return new ErrorFragment(_guard, obj.name, obj.inputs ? obj.inputs.map(ParamType.from) : []);
-  }
-  /**
-   *  Returns ``true`` and provides a type guard if %%value%% is an
-   *  **ErrorFragment**.
-   */
-  static isFragment(value) {
-    return value && value[internal] === ErrorFragmentInternal;
   }
-}
-class EventFragment extends NamedFragment {
-  /**
-   *  @private
-   */
-  constructor(guard, name, inputs, anonymous) {
-    super(guard, "event", name, inputs);
-    /**
-     *  Whether this event is anonymous.
-     */
-    __publicField(this, "anonymous");
-    Object.defineProperty(this, internal, { value: EventFragmentInternal });
-    defineProperties(this, { anonymous });
-  }
-  /**
-   *  The Event topic hash.
-   */
-  get topicHash() {
-    return id(this.format("sighash"));
-  }
-  /**
-   *  Returns a string representation of this event as %%format%%.
-   */
-  format(format) {
-    if (format == null) {
-      format = "sighash";
-    }
-    if (format === "json") {
-      return JSON.stringify({
-        type: "event",
-        anonymous: this.anonymous,
-        name: this.name,
-        inputs: this.inputs.map((i) => JSON.parse(i.format(format)))
-      });
-    }
-    const result = [];
-    if (format !== "sighash") {
-      result.push("event");
-    }
-    result.push(this.name + joinParams(format, this.inputs));
-    if (format !== "sighash" && this.anonymous) {
-      result.push("anonymous");
-    }
-    return result.join(" ");
+  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
+      );
+    }
+    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 the topic hash for an event with %%name%% and %%params%%.
-   */
-  static getTopicHash(name, params) {
-    params = (params || []).map((p) => ParamType.from(p));
-    const fragment = new EventFragment(_guard, name, params, false);
-    return fragment.topicHash;
+  function createLogEventShape(bindings) {
+    return {
+      ts: 0,
+      messages: [],
+      bindings: bindings || [],
+      level: { label: "", value: 0 }
+    };
   }
-  /**
-   *  Returns a new **EventFragment** for %%obj%%.
-   */
-  static from(obj) {
-    if (EventFragment.isFragment(obj)) {
-      return obj;
-    }
-    if (typeof obj === "string") {
-      try {
-        return EventFragment.from(lex(obj));
-      } catch (error) {
-        assertArgument(false, "invalid event fragment", "obj", obj);
+  function asErrValue(err) {
+    const obj = {
+      type: err.constructor.name,
+      msg: err.message,
+      stack: err.stack
+    };
+    for (const key in err) {
+      if (obj[key] === void 0) {
+        obj[key] = err[key];
       }
-    } else if (obj instanceof TokenString) {
-      const name = consumeName("event", obj);
-      const inputs = consumeParams(obj, true);
-      const anonymous = !!consumeKeywords(obj, setify(["anonymous"])).has("anonymous");
-      consumeEoi(obj);
-      return new EventFragment(_guard, name, inputs, anonymous);
     }
-    return new EventFragment(_guard, obj.name, obj.inputs ? obj.inputs.map((p) => ParamType.from(p, true)) : [], !!obj.anonymous);
-  }
-  /**
-   *  Returns ``true`` and provides a type guard if %%value%% is an
-   *  **EventFragment**.
-   */
-  static isFragment(value) {
-    return value && value[internal] === EventFragmentInternal;
+    return obj;
   }
-}
-class ConstructorFragment extends Fragment {
-  /**
-   *  @private
-   */
-  constructor(guard, type, inputs, payable, gas) {
-    super(guard, type, inputs);
-    /**
-     *  Whether the constructor can receive an endowment.
-     */
-    __publicField(this, "payable");
-    /**
-     *  The recommended gas limit for deployment or ``null``.
-     */
-    __publicField(this, "gas");
-    Object.defineProperty(this, internal, { value: ConstructorFragmentInternal });
-    defineProperties(this, { payable, gas });
-  }
-  /**
-   *  Returns a string representation of this constructor as %%format%%.
-   */
-  format(format) {
-    assert(format != null && format !== "sighash", "cannot format a constructor for sighash", "UNSUPPORTED_OPERATION", { operation: "format(sighash)" });
-    if (format === "json") {
-      return JSON.stringify({
-        type: "constructor",
-        stateMutability: this.payable ? "payable" : "undefined",
-        payable: this.payable,
-        gas: this.gas != null ? this.gas : void 0,
-        inputs: this.inputs.map((i) => JSON.parse(i.format(format)))
-      });
+  function getTimeFunction(opts) {
+    if (typeof opts.timestamp === "function") {
+      return opts.timestamp;
     }
-    const result = [`constructor${joinParams(format, this.inputs)}`];
-    if (this.payable) {
-      result.push("payable");
+    if (opts.timestamp === false) {
+      return nullTime;
     }
-    if (this.gas != null) {
-      result.push(`@${this.gas.toString()}`);
-    }
-    return result.join(" ");
+    return epochTime;
   }
-  /**
-   *  Returns a new **ConstructorFragment** for %%obj%%.
-   */
-  static from(obj) {
-    if (ConstructorFragment.isFragment(obj)) {
-      return obj;
-    }
-    if (typeof obj === "string") {
-      try {
-        return ConstructorFragment.from(lex(obj));
-      } catch (error) {
-        assertArgument(false, "invalid constuctor fragment", "obj", obj);
-      }
-    } else if (obj instanceof TokenString) {
-      consumeKeywords(obj, setify(["constructor"]));
-      const inputs = consumeParams(obj);
-      const payable = !!consumeKeywords(obj, KwVisibDeploy).has("payable");
-      const gas = consumeGas(obj);
-      consumeEoi(obj);
-      return new ConstructorFragment(_guard, "constructor", inputs, payable, gas);
-    }
-    return new ConstructorFragment(_guard, "constructor", obj.inputs ? obj.inputs.map(ParamType.from) : [], !!obj.payable, obj.gas != null ? obj.gas : null);
+  function mock() {
+    return {};
   }
-  /**
-   *  Returns ``true`` and provides a type guard if %%value%% is a
-   *  **ConstructorFragment**.
-   */
-  static isFragment(value) {
-    return value && value[internal] === ConstructorFragmentInternal;
+  function passthrough(a) {
+    return a;
   }
-}
-class FallbackFragment extends Fragment {
-  constructor(guard, inputs, payable) {
-    super(guard, "fallback", inputs);
-    /**
-     *  If the function can be sent value during invocation.
-     */
-    __publicField(this, "payable");
-    Object.defineProperty(this, internal, { value: FallbackFragmentInternal });
-    defineProperties(this, { payable });
+  function noop() {
   }
-  /**
-   *  Returns a string representation of this fallback as %%format%%.
-   */
-  format(format) {
-    const type = this.inputs.length === 0 ? "receive" : "fallback";
-    if (format === "json") {
-      const stateMutability = this.payable ? "payable" : "nonpayable";
-      return JSON.stringify({ type, stateMutability });
-    }
-    return `${type}()${this.payable ? " payable" : ""}`;
+  function nullTime() {
+    return false;
   }
-  /**
-   *  Returns a new **FallbackFragment** for %%obj%%.
-   */
-  static from(obj) {
-    if (FallbackFragment.isFragment(obj)) {
-      return obj;
-    }
-    if (typeof obj === "string") {
-      try {
-        return FallbackFragment.from(lex(obj));
-      } catch (error) {
-        assertArgument(false, "invalid fallback fragment", "obj", obj);
-      }
-    } else if (obj instanceof TokenString) {
-      const errorObj = obj.toString();
-      const topIsValid = obj.peekKeyword(setify(["fallback", "receive"]));
-      assertArgument(topIsValid, "type must be fallback or receive", "obj", errorObj);
-      const type = obj.popKeyword(setify(["fallback", "receive"]));
-      if (type === "receive") {
-        const inputs2 = consumeParams(obj);
-        assertArgument(inputs2.length === 0, `receive cannot have arguments`, "obj.inputs", inputs2);
-        consumeKeywords(obj, setify(["payable"]));
-        consumeEoi(obj);
-        return new FallbackFragment(_guard, [], true);
-      }
-      let inputs = consumeParams(obj);
-      if (inputs.length) {
-        assertArgument(inputs.length === 1 && inputs[0].type === "bytes", "invalid fallback inputs", "obj.inputs", inputs.map((i) => i.format("minimal")).join(", "));
-      } else {
-        inputs = [ParamType.from("bytes")];
-      }
-      const mutability = consumeMutability(obj);
-      assertArgument(mutability === "nonpayable" || mutability === "payable", "fallback cannot be constants", "obj.stateMutability", mutability);
-      if (consumeKeywords(obj, setify(["returns"])).has("returns")) {
-        const outputs = consumeParams(obj);
-        assertArgument(outputs.length === 1 && outputs[0].type === "bytes", "invalid fallback outputs", "obj.outputs", outputs.map((i) => i.format("minimal")).join(", "));
-      }
-      consumeEoi(obj);
-      return new FallbackFragment(_guard, inputs, mutability === "payable");
-    }
-    if (obj.type === "receive") {
-      return new FallbackFragment(_guard, [], true);
-    }
-    if (obj.type === "fallback") {
-      const inputs = [ParamType.from("bytes")];
-      const payable = obj.stateMutability === "payable";
-      return new FallbackFragment(_guard, inputs, payable);
-    }
-    assertArgument(false, "invalid fallback description", "obj", obj);
-  }
-  /**
-   *  Returns ``true`` and provides a type guard if %%value%% is a
-   *  **FallbackFragment**.
-   */
-  static isFragment(value) {
-    return value && value[internal] === FallbackFragmentInternal;
+  function epochTime() {
+    return Date.now();
   }
-}
-class FunctionFragment extends NamedFragment {
-  /**
-   *  @private
-   */
-  constructor(guard, name, stateMutability, inputs, outputs, gas) {
-    super(guard, "function", name, inputs);
-    /**
-     *  If the function is constant (e.g. ``pure`` or ``view`` functions).
-     */
-    __publicField(this, "constant");
-    /**
-     *  The returned types for the result of calling this function.
-     */
-    __publicField(this, "outputs");
-    /**
-     *  The state mutability (e.g. ``payable``, ``nonpayable``, ``view``
-     *  or ``pure``)
-     */
-    __publicField(this, "stateMutability");
-    /**
-     *  If the function can be sent value during invocation.
-     */
-    __publicField(this, "payable");
-    /**
-     *  The recommended gas limit to send when calling this function.
-     */
-    __publicField(this, "gas");
-    Object.defineProperty(this, internal, { value: FunctionFragmentInternal });
-    outputs = Object.freeze(outputs.slice());
-    const constant = stateMutability === "view" || stateMutability === "pure";
-    const payable = stateMutability === "payable";
-    defineProperties(this, { constant, gas, outputs, payable, stateMutability });
+  function unixTime() {
+    return Math.round(Date.now() / 1e3);
   }
-  /**
-   *  The Function selector.
-   */
-  get selector() {
-    return id(this.format("sighash")).substring(0, 10);
+  function isoTime() {
+    return new Date(Date.now()).toISOString();
   }
-  /**
-   *  Returns a string representation of this function as %%format%%.
-   */
-  format(format) {
-    if (format == null) {
-      format = "sighash";
+  function pfGlobalThisOrFallback() {
+    function defd(o) {
+      return typeof o !== "undefined" && o;
     }
-    if (format === "json") {
-      return JSON.stringify({
-        type: "function",
-        name: this.name,
-        constant: this.constant,
-        stateMutability: this.stateMutability !== "nonpayable" ? this.stateMutability : void 0,
-        payable: this.payable,
-        gas: this.gas != null ? this.gas : void 0,
-        inputs: this.inputs.map((i) => JSON.parse(i.format(format))),
-        outputs: this.outputs.map((o) => JSON.parse(o.format(format)))
+    try {
+      if (typeof globalThis !== "undefined") return globalThis;
+      Object.defineProperty(Object.prototype, "globalThis", {
+        get: function() {
+          delete Object.prototype.globalThis;
+          return this.globalThis = this;
+        },
+        configurable: true
       });
+      return globalThis;
+    } catch (e) {
+      return defd(self) || defd(window) || defd(this) || {};
     }
-    const result = [];
-    if (format !== "sighash") {
-      result.push("function");
-    }
-    result.push(this.name + joinParams(format, this.inputs));
-    if (format !== "sighash") {
-      if (this.stateMutability !== "nonpayable") {
-        result.push(this.stateMutability);
-      }
-      if (this.outputs && this.outputs.length) {
-        result.push("returns");
-        result.push(joinParams(format, this.outputs));
-      }
-      if (this.gas != null) {
-        result.push(`@${this.gas.toString()}`);
-      }
-    }
-    return result.join(" ");
-  }
-  /**
-   *  Return the selector for a function with %%name%% and %%params%%.
-   */
-  static getSelector(name, params) {
-    params = (params || []).map((p) => ParamType.from(p));
-    const fragment = new FunctionFragment(_guard, name, "view", params, [], null);
-    return fragment.selector;
-  }
-  /**
-   *  Returns a new **FunctionFragment** for %%obj%%.
-   */
-  static from(obj) {
-    if (FunctionFragment.isFragment(obj)) {
-      return obj;
-    }
-    if (typeof obj === "string") {
-      try {
-        return FunctionFragment.from(lex(obj));
-      } catch (error) {
-        assertArgument(false, "invalid function fragment", "obj", obj);
-      }
-    } else if (obj instanceof TokenString) {
-      const name = consumeName("function", obj);
-      const inputs = consumeParams(obj);
-      const mutability = consumeMutability(obj);
-      let outputs = [];
-      if (consumeKeywords(obj, setify(["returns"])).has("returns")) {
-        outputs = consumeParams(obj);
-      }
-      const gas = consumeGas(obj);
-      consumeEoi(obj);
-      return new FunctionFragment(_guard, name, mutability, inputs, outputs, gas);
-    }
-    let stateMutability = obj.stateMutability;
-    if (stateMutability == null) {
-      stateMutability = "payable";
-      if (typeof obj.constant === "boolean") {
-        stateMutability = "view";
-        if (!obj.constant) {
-          stateMutability = "payable";
-          if (typeof obj.payable === "boolean" && !obj.payable) {
-            stateMutability = "nonpayable";
-          }
-        }
-      } else if (typeof obj.payable === "boolean" && !obj.payable) {
-        stateMutability = "nonpayable";
-      }
-    }
-    return new FunctionFragment(_guard, obj.name, stateMutability, obj.inputs ? obj.inputs.map(ParamType.from) : [], obj.outputs ? obj.outputs.map(ParamType.from) : [], obj.gas != null ? obj.gas : null);
-  }
-  /**
-   *  Returns ``true`` and provides a type guard if %%value%% is a
-   *  **FunctionFragment**.
-   */
-  static isFragment(value) {
-    return value && value[internal] === FunctionFragmentInternal;
-  }
-}
-class StructFragment extends NamedFragment {
-  /**
-   *  @private
-   */
-  constructor(guard, name, inputs) {
-    super(guard, "struct", name, inputs);
-    Object.defineProperty(this, internal, { value: StructFragmentInternal });
-  }
-  /**
-   *  Returns a string representation of this struct as %%format%%.
-   */
-  format() {
-    throw new Error("@TODO");
-  }
-  /**
-   *  Returns a new **StructFragment** for %%obj%%.
-   */
-  static from(obj) {
-    if (typeof obj === "string") {
-      try {
-        return StructFragment.from(lex(obj));
-      } catch (error) {
-        assertArgument(false, "invalid struct fragment", "obj", obj);
-      }
-    } else if (obj instanceof TokenString) {
-      const name = consumeName("struct", obj);
-      const inputs = consumeParams(obj);
-      consumeEoi(obj);
-      return new StructFragment(_guard, name, inputs);
-    }
-    return new StructFragment(_guard, obj.name, obj.inputs ? obj.inputs.map(ParamType.from) : []);
-  }
-  // @TODO: fix this return type
-  /**
-   *  Returns ``true`` and provides a type guard if %%value%% is a
-   *  **StructFragment**.
-   */
-  static isFragment(value) {
-    return value && value[internal] === StructFragmentInternal;
   }
+  browser.exports.default = pino;
+  browser.exports.pino = pino;
+  return browser.exports;
 }
 export {
-  ConstructorFragment,
-  ErrorFragment,
-  EventFragment,
-  FallbackFragment,
-  Fragment,
-  FunctionFragment,
-  NamedFragment,
-  ParamType,
-  StructFragment
+  requireBrowser as __require
 };
 //# sourceMappingURL=standards-sdk.es48.js.map