@hashgraphonline/standards-sdk 0.0.87 → 0.0.89

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

@@ -1,412 +1,422 @@
-import process$1 from "./standards-sdk.es76.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));
-    }
+import { __module as browser } from "./standards-sdk.es96.js";
+import { __require as requireQuickFormatUnescaped } from "./standards-sdk.es97.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];
   }
-  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;
-      }
+  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;
+  }
+  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 res;
+    return false;
   }
-  function _format(sep, pathObject) {
-    var dir = pathObject.dir || pathObject.root;
-    var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
-    if (!dir) {
-      return base;
+  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");
     }
-    if (dir === pathObject.root) {
-      return dir + base;
+    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 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;
-        }
+    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
+    });
+    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);
       }
-      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;
+      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);
+      });
+    }
+    function child(setOpts2, bindings, childOptions) {
+      if (!bindings) {
+        throw new Error("missing bindings for child Pino");
       }
-      var fromEnd = from.length;
-      var fromLen = fromEnd - fromStart;
-      var toStart = 1;
-      for (; toStart < to.length; ++toStart) {
-        if (to.charCodeAt(toStart) !== 47)
-          break;
+      childOptions = childOptions || {};
+      if (serialize && bindings.serializers) {
+        childOptions.serializers = bindings.serializers;
       }
-      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;
+      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);
       }
-      var out = "";
-      for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
-        if (i === fromEnd || from.charCodeAt(i) === 47) {
-          if (out.length === 0)
-            out += "..";
-          else
-            out += "/..";
+      function Child(parent) {
+        this._childLevel = (parent._childLevel | 0) + 1;
+        this.bindings = bindings;
+        if (childSerializers) {
+          this.serializers = childSerializers;
+          this._serialize = childSerialize;
         }
-      }
-      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 (transmit2) {
+          this._logEvent = createLogEventShape(
+            [].concat(parent._logEvent.bindings, bindings)
+          );
         }
       }
-      if (end === -1) return hasRoot ? "/" : ".";
-      if (hasRoot && end === 1) return "//";
-      return path.slice(0, end);
+      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
     },
-    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;
-            }
-            if (extIdx >= 0) {
-              if (code === ext.charCodeAt(extIdx)) {
-                if (--extIdx === -1) {
-                  end = i;
-                }
-              } else {
-                extIdx = -1;
-                end = firstNonSlashEnd;
-              }
-            }
-          }
-        }
-        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 (end === -1) return "";
-        return path.slice(start, end);
+    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);
       }
-    },
-    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;
-          }
-          continue;
-        }
-        if (end === -1) {
-          matchedSlash = false;
-          end = i + 1;
+    }
+    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
+    });
+    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 (code === 46) {
-          if (startDot === -1)
-            startDot = i;
-          else if (preDotState !== 1)
-            preDotState = 1;
-        } else if (startDot !== -1) {
-          preDotState = -1;
+        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());
       }
-      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 "";
-      }
-      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);
-      }
-      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 {
-        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;
+      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]);
           }
-          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 (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);
+    }
+  }
+  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);
+  }
+  function createLogEventShape(bindings) {
+    return {
+      ts: 0,
+      messages: [],
+      bindings: bindings || [],
+      level: { label: "", value: 0 }
+    };
+  }
+  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];
       }
-      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;
+    }
+    return obj;
+  }
+  function getTimeFunction(opts) {
+    if (typeof opts.timestamp === "function") {
+      return opts.timestamp;
+    }
+    if (opts.timestamp === false) {
+      return nullTime;
+    }
+    return epochTime;
+  }
+  function mock() {
+    return {};
+  }
+  function passthrough(a) {
+    return a;
+  }
+  function noop() {
+  }
+  function nullTime() {
+    return false;
+  }
+  function epochTime() {
+    return Date.now();
+  }
+  function unixTime() {
+    return Math.round(Date.now() / 1e3);
+  }
+  function isoTime() {
+    return new Date(Date.now()).toISOString();
+  }
+  function pfGlobalThisOrFallback() {
+    function defd(o) {
+      return typeof o !== "undefined" && o;
+    }
+    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) || {};
+    }
+  }
+  browser.exports.default = pino;
+  browser.exports.pino = pino;
+  return browser.exports;
 }
 export {
-  requirePathBrowserify as __require
+  requireBrowser as __require
 };
 //# sourceMappingURL=standards-sdk.es95.js.map