@visulima/pail 4.0.0-alpha.3 → 4.0.0-alpha.5

package/dist/index.browser.js

@@ -1,7 +1,1493 @@
-import { P as PailBrowser } from './packem_shared/pail.browser-u2CSR_af.js';
-import MessageFormatterProcessor from './processor/message-formatter-processor.js';
+import { a as EXTENDED_RFC_5424_LOG_LEVELS, E as EMPTY_SYMBOL, L as LOG_TYPES } from './packem_shared/constants-omsTHUWB.js';
+import { w as writeConsoleLogBasedOnLevel } from './packem_shared/write-console-log-based-on-level-DBmRYXpj.js';
+import { g as getLongestLabel, b as build } from './packem_shared/index-DnkF86LQ.js';
 import JsonReporter from './packem_shared/JsonReporter-BRw4skd5.js';
 
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var safeStableStringify = {exports: {}};
+
+var hasRequiredSafeStableStringify;
+
+function requireSafeStableStringify () {
+	if (hasRequiredSafeStableStringify) return safeStableStringify.exports;
+	hasRequiredSafeStableStringify = 1;
+	(function (module, exports$1) {
+		const { hasOwnProperty } = Object.prototype;
+		const stringify = configure();
+		stringify.configure = configure;
+		stringify.stringify = stringify;
+		stringify.default = stringify;
+		exports$1.stringify = stringify;
+		exports$1.configure = configure;
+		module.exports = stringify;
+		const strEscapeSequencesRegExp = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]/;
+		function strEscape(str) {
+		  if (str.length < 5e3 && !strEscapeSequencesRegExp.test(str)) {
+		    return `"${str}"`;
+		  }
+		  return JSON.stringify(str);
+		}
+		function sort(array, comparator) {
+		  if (array.length > 200 || comparator) {
+		    return array.sort(comparator);
+		  }
+		  for (let i = 1; i < array.length; i++) {
+		    const currentValue = array[i];
+		    let position = i;
+		    while (position !== 0 && array[position - 1] > currentValue) {
+		      array[position] = array[position - 1];
+		      position--;
+		    }
+		    array[position] = currentValue;
+		  }
+		  return array;
+		}
+		const typedArrayPrototypeGetSymbolToStringTag = Object.getOwnPropertyDescriptor(
+		  Object.getPrototypeOf(
+		    Object.getPrototypeOf(
+		      new Int8Array()
+		    )
+		  ),
+		  Symbol.toStringTag
+		).get;
+		function isTypedArrayWithEntries(value) {
+		  return typedArrayPrototypeGetSymbolToStringTag.call(value) !== void 0 && value.length !== 0;
+		}
+		function stringifyTypedArray(array, separator, maximumBreadth) {
+		  if (array.length < maximumBreadth) {
+		    maximumBreadth = array.length;
+		  }
+		  const whitespace = separator === "," ? "" : " ";
+		  let res = `"0":${whitespace}${array[0]}`;
+		  for (let i = 1; i < maximumBreadth; i++) {
+		    res += `${separator}"${i}":${whitespace}${array[i]}`;
+		  }
+		  return res;
+		}
+		function getCircularValueOption(options) {
+		  if (hasOwnProperty.call(options, "circularValue")) {
+		    const circularValue = options.circularValue;
+		    if (typeof circularValue === "string") {
+		      return `"${circularValue}"`;
+		    }
+		    if (circularValue == null) {
+		      return circularValue;
+		    }
+		    if (circularValue === Error || circularValue === TypeError) {
+		      return {
+		        toString() {
+		          throw new TypeError("Converting circular structure to JSON");
+		        }
+		      };
+		    }
+		    throw new TypeError('The "circularValue" argument must be of type string or the value null or undefined');
+		  }
+		  return '"[Circular]"';
+		}
+		function getDeterministicOption(options) {
+		  let value;
+		  if (hasOwnProperty.call(options, "deterministic")) {
+		    value = options.deterministic;
+		    if (typeof value !== "boolean" && typeof value !== "function") {
+		      throw new TypeError('The "deterministic" argument must be of type boolean or comparator function');
+		    }
+		  }
+		  return value === void 0 ? true : value;
+		}
+		function getBooleanOption(options, key) {
+		  let value;
+		  if (hasOwnProperty.call(options, key)) {
+		    value = options[key];
+		    if (typeof value !== "boolean") {
+		      throw new TypeError(`The "${key}" argument must be of type boolean`);
+		    }
+		  }
+		  return value === void 0 ? true : value;
+		}
+		function getPositiveIntegerOption(options, key) {
+		  let value;
+		  if (hasOwnProperty.call(options, key)) {
+		    value = options[key];
+		    if (typeof value !== "number") {
+		      throw new TypeError(`The "${key}" argument must be of type number`);
+		    }
+		    if (!Number.isInteger(value)) {
+		      throw new TypeError(`The "${key}" argument must be an integer`);
+		    }
+		    if (value < 1) {
+		      throw new RangeError(`The "${key}" argument must be >= 1`);
+		    }
+		  }
+		  return value === void 0 ? Infinity : value;
+		}
+		function getItemCount(number) {
+		  if (number === 1) {
+		    return "1 item";
+		  }
+		  return `${number} items`;
+		}
+		function getUniqueReplacerSet(replacerArray) {
+		  const replacerSet = /* @__PURE__ */ new Set();
+		  for (const value of replacerArray) {
+		    if (typeof value === "string" || typeof value === "number") {
+		      replacerSet.add(String(value));
+		    }
+		  }
+		  return replacerSet;
+		}
+		function getStrictOption(options) {
+		  if (hasOwnProperty.call(options, "strict")) {
+		    const value = options.strict;
+		    if (typeof value !== "boolean") {
+		      throw new TypeError('The "strict" argument must be of type boolean');
+		    }
+		    if (value) {
+		      return (value2) => {
+		        let message = `Object can not safely be stringified. Received type ${typeof value2}`;
+		        if (typeof value2 !== "function") message += ` (${value2.toString()})`;
+		        throw new Error(message);
+		      };
+		    }
+		  }
+		}
+		function configure(options) {
+		  options = { ...options };
+		  const fail = getStrictOption(options);
+		  if (fail) {
+		    if (options.bigint === void 0) {
+		      options.bigint = false;
+		    }
+		    if (!("circularValue" in options)) {
+		      options.circularValue = Error;
+		    }
+		  }
+		  const circularValue = getCircularValueOption(options);
+		  const bigint = getBooleanOption(options, "bigint");
+		  const deterministic = getDeterministicOption(options);
+		  const comparator = typeof deterministic === "function" ? deterministic : void 0;
+		  const maximumDepth = getPositiveIntegerOption(options, "maximumDepth");
+		  const maximumBreadth = getPositiveIntegerOption(options, "maximumBreadth");
+		  function stringifyFnReplacer(key, parent, stack, replacer, spacer, indentation) {
+		    let value = parent[key];
+		    if (typeof value === "object" && value !== null && typeof value.toJSON === "function") {
+		      value = value.toJSON(key);
+		    }
+		    value = replacer.call(parent, key, value);
+		    switch (typeof value) {
+		      case "string":
+		        return strEscape(value);
+		      case "object": {
+		        if (value === null) {
+		          return "null";
+		        }
+		        if (stack.indexOf(value) !== -1) {
+		          return circularValue;
+		        }
+		        let res = "";
+		        let join = ",";
+		        const originalIndentation = indentation;
+		        if (Array.isArray(value)) {
+		          if (value.length === 0) {
+		            return "[]";
+		          }
+		          if (maximumDepth < stack.length + 1) {
+		            return '"[Array]"';
+		          }
+		          stack.push(value);
+		          if (spacer !== "") {
+		            indentation += spacer;
+		            res += `
+${indentation}`;
+		            join = `,
+${indentation}`;
+		          }
+		          const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+		          let i = 0;
+		          for (; i < maximumValuesToStringify - 1; i++) {
+		            const tmp2 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
+		            res += tmp2 !== void 0 ? tmp2 : "null";
+		            res += join;
+		          }
+		          const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
+		          res += tmp !== void 0 ? tmp : "null";
+		          if (value.length - 1 > maximumBreadth) {
+		            const removedKeys = value.length - maximumBreadth - 1;
+		            res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+		          }
+		          if (spacer !== "") {
+		            res += `
+${originalIndentation}`;
+		          }
+		          stack.pop();
+		          return `[${res}]`;
+		        }
+		        let keys = Object.keys(value);
+		        const keyLength = keys.length;
+		        if (keyLength === 0) {
+		          return "{}";
+		        }
+		        if (maximumDepth < stack.length + 1) {
+		          return '"[Object]"';
+		        }
+		        let whitespace = "";
+		        let separator = "";
+		        if (spacer !== "") {
+		          indentation += spacer;
+		          join = `,
+${indentation}`;
+		          whitespace = " ";
+		        }
+		        const maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+		        if (deterministic && !isTypedArrayWithEntries(value)) {
+		          keys = sort(keys, comparator);
+		        }
+		        stack.push(value);
+		        for (let i = 0; i < maximumPropertiesToStringify; i++) {
+		          const key2 = keys[i];
+		          const tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
+		          if (tmp !== void 0) {
+		            res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
+		            separator = join;
+		          }
+		        }
+		        if (keyLength > maximumBreadth) {
+		          const removedKeys = keyLength - maximumBreadth;
+		          res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
+		          separator = join;
+		        }
+		        if (spacer !== "" && separator.length > 1) {
+		          res = `
+${indentation}${res}
+${originalIndentation}`;
+		        }
+		        stack.pop();
+		        return `{${res}}`;
+		      }
+		      case "number":
+		        return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+		      case "boolean":
+		        return value === true ? "true" : "false";
+		      case "undefined":
+		        return void 0;
+		      case "bigint":
+		        if (bigint) {
+		          return String(value);
+		        }
+		      // fallthrough
+		      default:
+		        return fail ? fail(value) : void 0;
+		    }
+		  }
+		  function stringifyArrayReplacer(key, value, stack, replacer, spacer, indentation) {
+		    if (typeof value === "object" && value !== null && typeof value.toJSON === "function") {
+		      value = value.toJSON(key);
+		    }
+		    switch (typeof value) {
+		      case "string":
+		        return strEscape(value);
+		      case "object": {
+		        if (value === null) {
+		          return "null";
+		        }
+		        if (stack.indexOf(value) !== -1) {
+		          return circularValue;
+		        }
+		        const originalIndentation = indentation;
+		        let res = "";
+		        let join = ",";
+		        if (Array.isArray(value)) {
+		          if (value.length === 0) {
+		            return "[]";
+		          }
+		          if (maximumDepth < stack.length + 1) {
+		            return '"[Array]"';
+		          }
+		          stack.push(value);
+		          if (spacer !== "") {
+		            indentation += spacer;
+		            res += `
+${indentation}`;
+		            join = `,
+${indentation}`;
+		          }
+		          const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+		          let i = 0;
+		          for (; i < maximumValuesToStringify - 1; i++) {
+		            const tmp2 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
+		            res += tmp2 !== void 0 ? tmp2 : "null";
+		            res += join;
+		          }
+		          const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
+		          res += tmp !== void 0 ? tmp : "null";
+		          if (value.length - 1 > maximumBreadth) {
+		            const removedKeys = value.length - maximumBreadth - 1;
+		            res += `${join}"... ${getItemCount(removedKeys)} not stringified"`;
+		          }
+		          if (spacer !== "") {
+		            res += `
+${originalIndentation}`;
+		          }
+		          stack.pop();
+		          return `[${res}]`;
+		        }
+		        stack.push(value);
+		        let whitespace = "";
+		        if (spacer !== "") {
+		          indentation += spacer;
+		          join = `,
+${indentation}`;
+		          whitespace = " ";
+		        }
+		        let separator = "";
+		        for (const key2 of replacer) {
+		          const tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
+		          if (tmp !== void 0) {
+		            res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
+		            separator = join;
+		          }
+		        }
+		        if (spacer !== "" && separator.length > 1) {
+		          res = `
+${indentation}${res}
+${originalIndentation}`;
+		        }
+		        stack.pop();
+		        return `{${res}}`;
+		      }
+		      case "number":
+		        return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+		      case "boolean":
+		        return value === true ? "true" : "false";
+		      case "undefined":
+		        return void 0;
+		      case "bigint":
+		        if (bigint) {
+		          return String(value);
+		        }
+		      // fallthrough
+		      default:
+		        return fail ? fail(value) : void 0;
+		    }
+		  }
+		  function stringifyIndent(key, value, stack, spacer, indentation) {
+		    switch (typeof value) {
+		      case "string":
+		        return strEscape(value);
+		      case "object": {
+		        if (value === null) {
+		          return "null";
+		        }
+		        if (typeof value.toJSON === "function") {
+		          value = value.toJSON(key);
+		          if (typeof value !== "object") {
+		            return stringifyIndent(key, value, stack, spacer, indentation);
+		          }
+		          if (value === null) {
+		            return "null";
+		          }
+		        }
+		        if (stack.indexOf(value) !== -1) {
+		          return circularValue;
+		        }
+		        const originalIndentation = indentation;
+		        if (Array.isArray(value)) {
+		          if (value.length === 0) {
+		            return "[]";
+		          }
+		          if (maximumDepth < stack.length + 1) {
+		            return '"[Array]"';
+		          }
+		          stack.push(value);
+		          indentation += spacer;
+		          let res2 = `
+${indentation}`;
+		          const join2 = `,
+${indentation}`;
+		          const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+		          let i = 0;
+		          for (; i < maximumValuesToStringify - 1; i++) {
+		            const tmp2 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
+		            res2 += tmp2 !== void 0 ? tmp2 : "null";
+		            res2 += join2;
+		          }
+		          const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
+		          res2 += tmp !== void 0 ? tmp : "null";
+		          if (value.length - 1 > maximumBreadth) {
+		            const removedKeys = value.length - maximumBreadth - 1;
+		            res2 += `${join2}"... ${getItemCount(removedKeys)} not stringified"`;
+		          }
+		          res2 += `
+${originalIndentation}`;
+		          stack.pop();
+		          return `[${res2}]`;
+		        }
+		        let keys = Object.keys(value);
+		        const keyLength = keys.length;
+		        if (keyLength === 0) {
+		          return "{}";
+		        }
+		        if (maximumDepth < stack.length + 1) {
+		          return '"[Object]"';
+		        }
+		        indentation += spacer;
+		        const join = `,
+${indentation}`;
+		        let res = "";
+		        let separator = "";
+		        let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+		        if (isTypedArrayWithEntries(value)) {
+		          res += stringifyTypedArray(value, join, maximumBreadth);
+		          keys = keys.slice(value.length);
+		          maximumPropertiesToStringify -= value.length;
+		          separator = join;
+		        }
+		        if (deterministic) {
+		          keys = sort(keys, comparator);
+		        }
+		        stack.push(value);
+		        for (let i = 0; i < maximumPropertiesToStringify; i++) {
+		          const key2 = keys[i];
+		          const tmp = stringifyIndent(key2, value[key2], stack, spacer, indentation);
+		          if (tmp !== void 0) {
+		            res += `${separator}${strEscape(key2)}: ${tmp}`;
+		            separator = join;
+		          }
+		        }
+		        if (keyLength > maximumBreadth) {
+		          const removedKeys = keyLength - maximumBreadth;
+		          res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
+		          separator = join;
+		        }
+		        if (separator !== "") {
+		          res = `
+${indentation}${res}
+${originalIndentation}`;
+		        }
+		        stack.pop();
+		        return `{${res}}`;
+		      }
+		      case "number":
+		        return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+		      case "boolean":
+		        return value === true ? "true" : "false";
+		      case "undefined":
+		        return void 0;
+		      case "bigint":
+		        if (bigint) {
+		          return String(value);
+		        }
+		      // fallthrough
+		      default:
+		        return fail ? fail(value) : void 0;
+		    }
+		  }
+		  function stringifySimple(key, value, stack) {
+		    switch (typeof value) {
+		      case "string":
+		        return strEscape(value);
+		      case "object": {
+		        if (value === null) {
+		          return "null";
+		        }
+		        if (typeof value.toJSON === "function") {
+		          value = value.toJSON(key);
+		          if (typeof value !== "object") {
+		            return stringifySimple(key, value, stack);
+		          }
+		          if (value === null) {
+		            return "null";
+		          }
+		        }
+		        if (stack.indexOf(value) !== -1) {
+		          return circularValue;
+		        }
+		        let res = "";
+		        const hasLength = value.length !== void 0;
+		        if (hasLength && Array.isArray(value)) {
+		          if (value.length === 0) {
+		            return "[]";
+		          }
+		          if (maximumDepth < stack.length + 1) {
+		            return '"[Array]"';
+		          }
+		          stack.push(value);
+		          const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
+		          let i = 0;
+		          for (; i < maximumValuesToStringify - 1; i++) {
+		            const tmp2 = stringifySimple(String(i), value[i], stack);
+		            res += tmp2 !== void 0 ? tmp2 : "null";
+		            res += ",";
+		          }
+		          const tmp = stringifySimple(String(i), value[i], stack);
+		          res += tmp !== void 0 ? tmp : "null";
+		          if (value.length - 1 > maximumBreadth) {
+		            const removedKeys = value.length - maximumBreadth - 1;
+		            res += `,"... ${getItemCount(removedKeys)} not stringified"`;
+		          }
+		          stack.pop();
+		          return `[${res}]`;
+		        }
+		        let keys = Object.keys(value);
+		        const keyLength = keys.length;
+		        if (keyLength === 0) {
+		          return "{}";
+		        }
+		        if (maximumDepth < stack.length + 1) {
+		          return '"[Object]"';
+		        }
+		        let separator = "";
+		        let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
+		        if (hasLength && isTypedArrayWithEntries(value)) {
+		          res += stringifyTypedArray(value, ",", maximumBreadth);
+		          keys = keys.slice(value.length);
+		          maximumPropertiesToStringify -= value.length;
+		          separator = ",";
+		        }
+		        if (deterministic) {
+		          keys = sort(keys, comparator);
+		        }
+		        stack.push(value);
+		        for (let i = 0; i < maximumPropertiesToStringify; i++) {
+		          const key2 = keys[i];
+		          const tmp = stringifySimple(key2, value[key2], stack);
+		          if (tmp !== void 0) {
+		            res += `${separator}${strEscape(key2)}:${tmp}`;
+		            separator = ",";
+		          }
+		        }
+		        if (keyLength > maximumBreadth) {
+		          const removedKeys = keyLength - maximumBreadth;
+		          res += `${separator}"...":"${getItemCount(removedKeys)} not stringified"`;
+		        }
+		        stack.pop();
+		        return `{${res}}`;
+		      }
+		      case "number":
+		        return isFinite(value) ? String(value) : fail ? fail(value) : "null";
+		      case "boolean":
+		        return value === true ? "true" : "false";
+		      case "undefined":
+		        return void 0;
+		      case "bigint":
+		        if (bigint) {
+		          return String(value);
+		        }
+		      // fallthrough
+		      default:
+		        return fail ? fail(value) : void 0;
+		    }
+		  }
+		  function stringify2(value, replacer, space) {
+		    if (arguments.length > 1) {
+		      let spacer = "";
+		      if (typeof space === "number") {
+		        spacer = " ".repeat(Math.min(space, 10));
+		      } else if (typeof space === "string") {
+		        spacer = space.slice(0, 10);
+		      }
+		      if (replacer != null) {
+		        if (typeof replacer === "function") {
+		          return stringifyFnReplacer("", { "": value }, [], replacer, spacer, "");
+		        }
+		        if (Array.isArray(replacer)) {
+		          return stringifyArrayReplacer("", value, [], getUniqueReplacerSet(replacer), spacer, "");
+		        }
+		      }
+		      if (spacer.length !== 0) {
+		        return stringifyIndent("", value, [], spacer, "");
+		      }
+		    }
+		    return stringifySimple("", value, []);
+		  }
+		  return stringify2;
+		} 
+	} (safeStableStringify, safeStableStringify.exports));
+	return safeStableStringify.exports;
+}
+
+var safeStableStringifyExports = requireSafeStableStringify();
+const cjsModule = /*@__PURE__*/getDefaultExportFromCjs(safeStableStringifyExports);
+
+const configure = cjsModule.configure;
+
+class RawReporter {
+  // eslint-disable-next-line class-methods-use-this
+  log(meta) {
+    const { context = [], message, type } = meta;
+    const consoleLogFunction = writeConsoleLogBasedOnLevel(type.level);
+    consoleLogFunction(message, ...context);
+  }
+}
+
+const arrayify = (x) => {
+  if (x === void 0) {
+    return [];
+  }
+  return Array.isArray(x) ? x : [x];
+};
+
+const mergeTypes = (standard, custom) => {
+  const types = { ...standard };
+  Object.keys(custom).forEach((type) => {
+    types[type] = { ...types[type], ...custom[type] };
+  });
+  return types;
+};
+
+const preventLoop = (function_) => {
+  let doing = false;
+  return function(...args) {
+    if (doing) {
+      return void 0;
+    }
+    doing = true;
+    try {
+      const result = function_.apply(this, args);
+      doing = false;
+      return result;
+    } catch (error) {
+      doing = false;
+      throw error;
+    }
+  };
+};
+class PailBrowserImpl {
+  timersMap;
+  countMap;
+  seqTimers;
+  lastLog;
+  logLevels;
+  disabled;
+  paused;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  messageQueue;
+  scopeName;
+  types;
+  longestLabel;
+  processors;
+  generalLogLevel;
+  reporters;
+  throttle;
+  throttleMin;
+  stringify;
+  groups;
+  startTimerMessage;
+  endTimerMessage;
+  rawReporter;
+  force = {};
+  /**
+   * Creates a new Pail browser logger instance.
+   *
+   * Initializes the logger with the provided configuration options,
+   * setting up reporters, processors, log levels, and other internal state.
+   * @param options Configuration options for the logger
+   */
+  constructor(options) {
+    this.throttle = options.throttle ?? 1e3;
+    this.throttleMin = options.throttleMin ?? 5;
+    const parentLongestLabel = options.parentLongestLabel;
+    const parentTypes = options.parentTypes;
+    const parentStringify = options.parentStringify;
+    const parentLogLevels = options.parentLogLevels;
+    this.stringify = parentStringify ?? configure({
+      strict: true
+    });
+    this.startTimerMessage = options.messages?.timerStart ?? "Initialized timer...";
+    this.endTimerMessage = options.messages?.timerEnd ?? "Timer run for:";
+    if (parentTypes && parentLongestLabel) {
+      this.types = parentTypes;
+      this.longestLabel = parentLongestLabel;
+    } else {
+      this.types = mergeTypes(LOG_TYPES, options.types ?? {});
+      this.longestLabel = getLongestLabel(this.types);
+    }
+    this.logLevels = parentLogLevels && !options.logLevels ? parentLogLevels : { ...EXTENDED_RFC_5424_LOG_LEVELS, ...options.logLevels };
+    this.generalLogLevel = this.#normalizeLogLevel(options.logLevel);
+    this.reporters = /* @__PURE__ */ new Set();
+    this.processors = /* @__PURE__ */ new Set();
+    this.disabled = options.disabled ?? false;
+    this.paused = false;
+    this.messageQueue = [];
+    this.scopeName = arrayify(options.scope).filter(Boolean);
+    this.timersMap = /* @__PURE__ */ new Map();
+    this.countMap = /* @__PURE__ */ new Map();
+    this.groups = [];
+    this.seqTimers = /* @__PURE__ */ new Set();
+    this.lastLog = {};
+    this.logger = preventLoop(this.logger).bind(this);
+    this.#initializeBoundMethods();
+    if (Array.isArray(options.reporters)) {
+      this.registerReporters(options.reporters);
+    }
+    this.rawReporter = this.extendReporter(options.rawReporter ?? new RawReporter());
+    if (Array.isArray(options.processors)) {
+      this.registerProcessors(options.processors);
+    }
+  }
+  /**
+   * Initializes bound methods for all logger types.
+   *
+   * Creates bound methods for both regular and force logging methods.
+   * This is separated to allow reuse when types haven't changed.
+   */
+  #initializeBoundMethods() {
+    for (const type in this.types) {
+      this[type] = this.logger.bind(this, type, false, false);
+    }
+    for (const type in this.types) {
+      this.force[type] = this.logger.bind(this, type, false, true);
+    }
+  }
+  /**
+   * Wraps the global console methods to redirect them through the logger.
+   *
+   * This method replaces console methods (log, info, warn, error, etc.) with
+   * calls to the corresponding logger methods. The original console methods
+   * are backed up and can be restored using restoreConsole().
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.wrapConsole();
+   *
+   * console.log("This will go through the logger");
+   * console.error("This too!");
+   *
+   * logger.restoreConsole(); // Restore original console methods
+   * ```
+   */
+  wrapConsole() {
+    for (const type in this.types) {
+      if (!console[`__${type}`]) {
+        console[`__${type}`] = console[type];
+      }
+      console[type] = this[type];
+    }
+  }
+  /**
+   * Restores the original global console methods.
+   *
+   * This method restores the console methods that were backed up by wrapConsole().
+   * After calling this, console methods will work as they did before wrapping.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.wrapConsole();
+   *
+   * // Console methods are now wrapped
+   * logger.restoreConsole();
+   * // Console methods are restored to original behavior
+   * ```
+   */
+  restoreConsole() {
+    for (const type in this.types) {
+      if (console[`__${type}`]) {
+        console[type] = console[`__${type}`];
+        delete console[`__${type}`];
+      }
+    }
+  }
+  /**
+   * Wraps uncaught exception and unhandled rejection handlers.
+   *
+   * This method sets up global error handlers that will log uncaught exceptions
+   * and unhandled promise rejections through the logger. This is useful for
+   * capturing and logging application crashes.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.wrapException();
+   *
+   * // Now uncaught errors will be logged
+   * throw new Error("This will be logged");
+   * ```
+   */
+  wrapException() {
+    {
+      process.on("uncaughtException", (error) => {
+        this.error(error);
+      });
+      process.on("unhandledRejection", (error) => {
+        this.error(error);
+      });
+    }
+  }
+  /**
+   * Disables all logging output.
+   *
+   * When disabled, all log calls will be silently ignored and no output
+   * will be produced by any reporters. This can be useful for temporarily
+   * suppressing log output in production or during testing.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.disable();
+   * logger.info("This won't be logged"); // Silent
+   * logger.enable();
+   * logger.info("This will be logged"); // Output produced
+   * ```
+   */
+  disable() {
+    this.disabled = true;
+  }
+  /**
+   * Enables logging output.
+   *
+   * Re-enables logging after it has been disabled. All subsequent log calls
+   * will produce output according to the configured reporters.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.disable();
+   * logger.info("This won't be logged");
+   * logger.enable(); // Re-enable logging
+   * logger.info("This will be logged");
+   * ```
+   */
+  enable() {
+    this.disabled = false;
+  }
+  /**
+   * Checks if logging is currently enabled.
+   *
+   * Returns true if logging is enabled and false if it has been disabled.
+   * @returns True if logging is enabled, false if disabled
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * console.log(logger.isEnabled()); // true
+   * logger.disable();
+   * console.log(logger.isEnabled()); // false
+   * ```
+   */
+  isEnabled() {
+    return !this.disabled;
+  }
+  /**
+   * Pauses logging and starts queuing messages.
+   *
+   * When paused, all log calls will be queued instead of being output immediately.
+   * The queued messages will be processed when resume() is called. This is useful
+   * for temporarily buffering log output during critical operations.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.pause();
+   * logger.info("This will be queued"); // Queued, not output yet
+   * logger.warn("This too"); // Also queued
+   * logger.resume(); // Now both messages are output
+   * ```
+   */
+  pause() {
+    this.paused = true;
+  }
+  /**
+   * Resumes logging and flushes all queued messages.
+   *
+   * Processes all messages that were queued during the pause period and
+   * resumes normal logging behavior. Messages are output in the order
+   * they were originally called.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.pause();
+   * logger.info("Message 1"); // Queued
+   * logger.info("Message 2"); // Queued
+   * logger.resume(); // Both messages are now output in order
+   * logger.info("Message 3"); // Output immediately
+   * ```
+   */
+  resume() {
+    this.paused = false;
+    const queue = this.messageQueue.splice(0);
+    for (const { messageObject, raw, type } of queue) {
+      this.logger(type, raw, false, ...messageObject);
+    }
+  }
+  /**
+   * Creates a scoped logger instance.
+   *
+   * Returns a new logger instance that inherits all configuration but adds
+   * the specified scope names to all log messages. This is useful for
+   * categorizing logs by component, module, or feature.
+   * @template N - The new custom logger type names
+   * @param name Scope names to apply to all log messages
+   * @returns A new scoped logger instance
+   * @throws {Error} If no scope name is provided
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * const scopedLogger = logger.scope("auth", "login");
+   * scopedLogger.info("User logged in"); // Will include scope: ["auth", "login"]
+   * ```
+   */
+  scope(...name) {
+    if (name.length === 0) {
+      throw new Error("No scope name was defined.");
+    }
+    this.scopeName = name.flat();
+    return this;
+  }
+  /**
+   * Removes the current scope from the logger.
+   *
+   * Clears all scope names that were set by previous scope() calls.
+   * After calling this, log messages will no longer include scope information.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * const scopedLogger = logger.scope("auth");
+   * scopedLogger.info("Scoped message"); // Has scope
+   * scopedLogger.unscope();
+   * scopedLogger.info("Unscoped message"); // No scope
+   * ```
+   */
+  unscope() {
+    this.scopeName = [];
+  }
+  /**
+   * Creates a child logger that inherits settings from the parent.
+   *
+   * Returns a new logger instance that inherits all configuration from the parent
+   * (reporters, processors, types, log levels, throttle settings, etc.) while allowing
+   * you to override only what you need. Child loggers are independent instances with
+   * their own state (timers, counters, etc.).
+   * @template N - The new custom logger type names
+   * @template LC - The new log level types
+   * @param options Configuration options to override or extend parent settings
+   * @returns A new child logger instance
+   * @example
+   * ```typescript
+   * const parent = createPail({
+   *   logLevel: "info",
+   *   types: { http: { label: "HTTP", logLevel: "info" } },
+   *   reporters: [new PrettyReporter()],
+   * });
+   *
+   * // Child inherits parent settings but overrides log level
+   * const child = parent.child({ logLevel: "debug" });
+   * child.info("This will be logged"); // Uses debug level from child
+   * child.http("GET /api 200"); // Inherits http type from parent
+   *
+   * // Child can add new types
+   * const childWithNewType = parent.child({
+   *   types: { db: { label: "DB", logLevel: "info" } },
+   * });
+   * childWithNewType.db("Query executed"); // New type available
+   * ```
+   */
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  child(options) {
+    const typesChanged = options?.types !== void 0 && options.types !== null;
+    const mergedTypes = typesChanged ? mergeTypes(this.types, options.types) : this.types;
+    const childReporters = options?.reporters ?? [];
+    const allReporters = childReporters.length > 0 ? [...this.reporters, ...childReporters] : [...this.reporters];
+    const childProcessors = options?.processors ?? [];
+    const allProcessors = childProcessors.length > 0 ? [...this.processors, ...childProcessors] : [...this.processors];
+    const mergedLogLevels = options?.logLevels ? { ...this.logLevels, ...options.logLevels } : this.logLevels;
+    let mergedScope;
+    if (options?.scope) {
+      const childScope = arrayify(options.scope).filter(Boolean);
+      mergedScope = this.scopeName.length > 0 ? [...this.scopeName, ...childScope] : childScope;
+    } else {
+      mergedScope = this.scopeName.length > 0 ? this.scopeName : [];
+    }
+    const mergedMessages = options?.messages ? {
+      timerEnd: this.endTimerMessage,
+      timerStart: this.startTimerMessage,
+      ...options.messages
+    } : {
+      timerEnd: this.endTimerMessage,
+      timerStart: this.startTimerMessage
+    };
+    const childOptions = {
+      disabled: options?.disabled ?? this.disabled,
+      logLevel: options?.logLevel ?? this.generalLogLevel,
+      logLevels: mergedLogLevels,
+      messages: mergedMessages,
+      processors: allProcessors,
+      rawReporter: options?.rawReporter ?? this.rawReporter,
+      reporters: allReporters,
+      scope: mergedScope,
+      throttle: options?.throttle ?? this.throttle,
+      throttleMin: options?.throttleMin ?? this.throttleMin
+    };
+    if (typesChanged) {
+      childOptions.parentTypes = mergedTypes;
+      childOptions.parentLongestLabel = getLongestLabel(mergedTypes);
+    } else {
+      childOptions.parentTypes = this.types;
+      childOptions.parentLongestLabel = this.longestLabel;
+    }
+    if (!options?.logLevels) {
+      childOptions.parentLogLevels = this.logLevels;
+    }
+    if (!options?.messages) {
+      childOptions.parentMessages = {
+        timerEnd: this.endTimerMessage,
+        timerStart: this.startTimerMessage
+      };
+    }
+    childOptions.parentStringify = this.stringify;
+    return new PailBrowserImpl(childOptions);
+  }
+  /**
+   * Starts a timer with the specified label.
+   *
+   * Records the current timestamp and associates it with the given label.
+   * Multiple timers can be active simultaneously with different labels.
+   * @param label The timer label (defaults to "default")
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.time("operation");
+   * // ... some operation ...
+   * logger.timeEnd("operation"); // Logs: "Timer run for: X ms"
+   * ```
+   */
+  time(label = "default") {
+    if (this.seqTimers.has(label)) {
+      this.logger("warn", false, false, {
+        message: `Timer '${label}' already exists`,
+        prefix: label
+      });
+    } else {
+      this.seqTimers.add(label);
+      this.timersMap.set(label, Date.now());
+      this.logger("start", false, false, {
+        message: this.startTimerMessage,
+        prefix: label
+      });
+    }
+  }
+  /**
+   * Logs the current elapsed time for a timer without stopping it.
+   *
+   * Calculates and logs the time elapsed since the timer was started,
+   * but keeps the timer running. If no label is provided, uses the
+   * most recently started timer.
+   * @param label The timer label (uses last timer if not specified)
+   * @param data Additional data to include in the log message
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.time("task");
+   * // ... some work ...
+   * logger.timeLog("task"); // Logs current elapsed time
+   * // ... more work ...
+   * logger.timeEnd("task"); // Logs final time and stops timer
+   * ```
+   */
+  timeLog(label, ...data) {
+    if (!label && this.seqTimers.size > 0) {
+      label = [...this.seqTimers].pop();
+    }
+    if (label && this.timersMap.has(label)) {
+      const span = Date.now() - this.timersMap.get(label);
+      this.logger("info", false, false, {
+        context: data,
+        message: span < 1e3 ? `${span} ms` : `${(span / 1e3).toFixed(2)} s`,
+        prefix: label
+      });
+    } else {
+      this.logger("warn", false, false, {
+        context: data,
+        message: "Timer not found",
+        prefix: label
+      });
+    }
+  }
+  /**
+   * Stops a timer and logs the final elapsed time.
+   *
+   * Calculates the total time elapsed since the timer was started,
+   * logs the result, and removes the timer. If no label is provided,
+   * uses the most recently started timer.
+   * @param label The timer label (uses last timer if not specified)
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.time("operation");
+   * // ... perform operation ...
+   * logger.timeEnd("operation"); // Logs: "Timer run for: X ms"
+   * ```
+   */
+  timeEnd(label) {
+    if (!label && this.seqTimers.size > 0) {
+      label = [...this.seqTimers].pop();
+    }
+    if (label && this.timersMap.has(label)) {
+      const span = Date.now() - this.timersMap.get(label);
+      this.timersMap.delete(label);
+      this.logger("stop", false, false, {
+        message: `${this.endTimerMessage} ${span < 1e3 ? `${span} ms` : `${(span / 1e3).toFixed(2)} s`}`,
+        prefix: label
+      });
+    } else {
+      this.logger("warn", false, false, {
+        message: "Timer not found",
+        prefix: label
+      });
+    }
+  }
+  /**
+   * Starts a log group with the specified label.
+   *
+   * Groups related log messages together. In browser environments,
+   * this uses the native console.group() functionality. In other
+   * environments, it tracks group nesting internally.
+   * @param label The group label (defaults to "console.group")
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.group("Database Operations");
+   * logger.info("Connecting to database");
+   * logger.info("Running migration");
+   * logger.groupEnd(); // End the group
+   * ```
+   */
+  group(label = "console.group") {
+    if (globalThis.window === void 0) {
+      this.groups.push(label);
+    } else {
+      console.group(label);
+    }
+  }
+  /**
+   * Ends the current log group.
+   *
+   * Closes the most recently opened log group. In browser environments,
+   * this uses the native console.groupEnd() functionality.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.group("Processing");
+   * logger.info("Step 1");
+   * logger.info("Step 2");
+   * logger.groupEnd(); // Closes the "Processing" group
+   * ```
+   */
+  groupEnd() {
+    if (globalThis.window === void 0) {
+      this.groups.pop();
+    } else {
+      console.groupEnd();
+    }
+  }
+  /**
+   * Increments and logs a counter with the specified label.
+   *
+   * Maintains an internal counter for each label and logs the current count
+   * each time it's called. Useful for tracking how many times certain
+   * code paths are executed.
+   * @param label The counter label (defaults to "default")
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.count("requests"); // Logs: "requests: 1"
+   * logger.count("requests"); // Logs: "requests: 2"
+   * logger.count("errors");   // Logs: "errors: 1"
+   * ```
+   */
+  count(label = "default") {
+    const current = this.countMap.get(label) ?? 0;
+    this.countMap.set(label, current + 1);
+    this.logger("log", false, false, {
+      message: `${label}: ${current + 1}`,
+      prefix: label
+    });
+  }
+  /**
+   * Resets a counter to zero.
+   *
+   * Removes the counter with the specified label, effectively resetting
+   * it to zero. If the counter doesn't exist, logs a warning.
+   * @param label The counter label to reset (defaults to "default")
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.count("requests"); // Logs: "requests: 1"
+   * logger.countReset("requests"); // Resets counter
+   * logger.count("requests"); // Logs: "requests: 1" (starts over)
+   * ```
+   */
+  countReset(label = "default") {
+    if (this.countMap.has(label)) {
+      this.countMap.delete(label);
+    } else {
+      this.logger("warn", false, false, {
+        message: `Count for ${label} does not exist`,
+        prefix: label
+      });
+    }
+  }
+  /**
+   * Clears the console output.
+   *
+   * Calls the native console.clear() method to clear all output from
+   * the console. This is a convenience method that wraps the native
+   * console.clear() functionality.
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.info("Some message");
+   * logger.clear(); // Clears the console
+   * ```
+   */
+  // eslint-disable-next-line class-methods-use-this
+  clear() {
+    console.clear();
+  }
+  /**
+   * Logs a raw message bypassing normal processing.
+   *
+   * Sends a message directly to the raw reporter without going through
+   * the normal logging pipeline (processors, throttling, etc.). This is
+   * useful for logging that needs to bypass all formatting and processing.
+   * @param message The raw message to log
+   * @param arguments_ Additional arguments to include
+   * @example
+   * ```typescript
+   * const logger = createPail();
+   * logger.raw("Direct message", { data: "value" });
+   * ```
+   */
+  raw(message, ...arguments_) {
+    if (this.disabled) {
+      return;
+    }
+    this.logger("log", true, false, {
+      context: arguments_,
+      message
+    });
+  }
+  extendReporter(reporter) {
+    if (typeof reporter.setLoggerTypes === "function") {
+      reporter.setLoggerTypes(this.types);
+    }
+    if (typeof reporter.setStringify === "function") {
+      reporter.setStringify(this.stringify);
+    }
+    return reporter;
+  }
+  registerReporters(reporters) {
+    for (const reporter of reporters) {
+      this.reporters.add(this.extendReporter(reporter));
+    }
+  }
+  registerProcessors(processors) {
+    for (const processor of processors) {
+      if (typeof processor.setStringify === "function") {
+        processor.setStringify(this.stringify);
+      }
+      this.processors.add(processor);
+    }
+  }
+  #report(meta, raw) {
+    if (raw) {
+      this.rawReporter.log(Object.freeze(meta));
+    } else {
+      for (const reporter of this.reporters) {
+        reporter.log(Object.freeze(meta));
+      }
+    }
+  }
+  #normalizeLogLevel(level) {
+    return level && this.logLevels[level] ? level : "debug";
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  #buildMeta(typeName, type, ...arguments_) {
+    const meta = {
+      badge: void 0,
+      context: void 0,
+      error: void 0,
+      label: void 0,
+      message: EMPTY_SYMBOL,
+      prefix: void 0,
+      repeated: void 0,
+      scope: void 0,
+      suffix: void 0
+    };
+    meta.type = {
+      level: type.logLevel,
+      name: typeName
+    };
+    meta.groups = this.groups;
+    meta.scope = this.scopeName;
+    meta.date = /* @__PURE__ */ new Date();
+    if (arguments_.length > 0 && arguments_[0] instanceof Error) {
+      meta.error = arguments_[0];
+      if (arguments_.length > 1) {
+        meta.context = arguments_.slice(1);
+      }
+    } else if (arguments_.length > 0 && typeof arguments_[0] === "object" && arguments_[0] !== null && "message" in arguments_[0]) {
+      const { context, message, prefix, suffix } = arguments_[0];
+      if (context) {
+        meta.context = context;
+      }
+      if (prefix) {
+        meta.prefix = prefix;
+      }
+      if (suffix) {
+        meta.suffix = suffix;
+      }
+      meta.message = message;
+      if (arguments_.length > 1) {
+        const additionalContext = arguments_.slice(1);
+        if (meta.context) {
+          meta.context = Array.isArray(meta.context) ? [...meta.context, ...additionalContext] : [meta.context, ...additionalContext];
+        } else {
+          meta.context = additionalContext;
+        }
+      }
+    } else if (arguments_.length > 1) {
+      meta.message = arguments_[0];
+      meta.context = arguments_.slice(1);
+    } else if (arguments_.length === 1) {
+      meta.message = arguments_[0];
+    } else {
+      meta.message = void 0;
+    }
+    if (type.logLevel === "trace") {
+      meta.traceError = new Error("Trace");
+    }
+    if (type.badge) {
+      meta.badge = type.badge;
+    }
+    if (type.label) {
+      meta.label = type.label;
+    }
+    return meta;
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  logger(type, raw, force, ...messageObject) {
+    if (this.disabled) {
+      return;
+    }
+    if (this.paused) {
+      this.messageQueue.push({ messageObject, raw, type });
+      return;
+    }
+    const typeConfig = this.types[type];
+    if (!typeConfig) {
+      return;
+    }
+    const logLevel = this.#normalizeLogLevel(typeConfig.logLevel);
+    if (force || this.logLevels[logLevel] >= this.logLevels[this.generalLogLevel]) {
+      let meta = this.#buildMeta(type, typeConfig, ...messageObject);
+      const resolveLog = (newLog = false) => {
+        const repeated = (this.lastLog.count || 0) - this.throttleMin;
+        if (this.lastLog.object && repeated > 0) {
+          const lastMeta = { ...this.lastLog.object };
+          if (repeated > 1) {
+            lastMeta.repeated = repeated;
+          }
+          this.#report(lastMeta, raw);
+          this.lastLog.count = 1;
+        }
+        if (newLog) {
+          for (const processor of this.processors) {
+            meta = { ...processor.process(meta) };
+          }
+          this.lastLog.object = meta;
+          this.#report(meta, raw);
+        }
+      };
+      clearTimeout(this.lastLog.timeout);
+      const diffTime = this.lastLog.time && meta.date ? new Date(meta.date).getTime() - this.lastLog.time.getTime() : 0;
+      this.lastLog.time = new Date(meta.date);
+      if (diffTime < this.throttle) {
+        try {
+          const isSameLog = this.lastLog.object && JSON.stringify([meta.label, meta.scope, meta.type, meta.message, meta.prefix, meta.suffix, meta.context]) === JSON.stringify([
+            this.lastLog.object.label,
+            this.lastLog.object.scope,
+            this.lastLog.object.type,
+            this.lastLog.object.message,
+            this.lastLog.object.prefix,
+            this.lastLog.object.suffix,
+            this.lastLog.object.context
+          ]);
+          if (isSameLog) {
+            this.lastLog.count = (this.lastLog.count || 0) + 1;
+            if (this.lastLog.count > this.throttleMin) {
+              this.lastLog.timeout = setTimeout(resolveLog, this.throttle);
+              return;
+            }
+          }
+        } catch {
+        }
+      }
+      resolveLog(true);
+    }
+  }
+}
+const PailBrowser = PailBrowserImpl;
+
+class MessageFormatterProcessor {
+  /** Custom stringify function for object serialization */
+  #stringify;
+  /** Custom formatters for message interpolation */
+  #formatters;
+  /**
+   * Creates a new MessageFormatterProcessor instance.
+   * @param options Configuration options
+   * @param options.formatters Custom formatters for message interpolation
+   */
+  constructor(options = {}) {
+    this.#formatters = options.formatters;
+  }
+  /**
+   * Sets the stringify function for object serialization.
+   * @param function_ The stringify function to use for serializing objects
+   */
+  setStringify(function_) {
+    this.#stringify = function_;
+  }
+  /**
+   * Processes log metadata to format messages.
+   *
+   * Applies string interpolation and custom formatters to the message
+   * and contextual data in the log metadata.
+   * @param meta The log metadata to process
+   * @returns The processed metadata with formatted messages
+   */
+  process(meta) {
+    const formatter = build({
+      formatters: this.#formatters});
+    if (meta.message !== void 0) {
+      meta.message = this.#format(formatter, meta.message, meta.context ?? []);
+    }
+    return meta;
+  }
+  /**
+   * Recursively formats data using the formatter.
+   *
+   * Applies string interpolation and formatting to strings, arrays, and objects.
+   * @param formatter The formatter function to use
+   * @param data The data to format (string, array, or object)
+   * @param arguments_ Additional arguments for formatting
+   * @returns The formatted data
+   * @private
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  #format(formatter, data, arguments_ = []) {
+    if (typeof data === "string") {
+      return formatter(data, arguments_);
+    }
+    if (typeof data === "object" && data !== null) {
+      for (const index in data) {
+        const value = data[index];
+        if (typeof value === "string" || Array.isArray(value) || typeof value === "object") {
+          data[index] = this.#format(formatter, value, arguments_);
+        }
+      }
+    }
+    return data;
+  }
+}
+
 const createPail = (options) => new PailBrowser({
   processors: [new MessageFormatterProcessor()],
   reporters: [new JsonReporter()],