@visulima/pail 4.0.0-alpha.1 → 4.0.0-alpha.10

package/dist/index.server.js

@@ -4,23 +4,1758 @@ const __cjs_require = __cjs_createRequire(import.meta.url);
 
 const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
 
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
 const {
   stdout,
   stderr,
   env
 } = __cjs_getProcess;
-import InteractiveManager from './packem_shared/InteractiveManager-CZ85hGNW.js';
-import { I as InteractiveStreamHook, c as clearTerminal } from './packem_shared/interactive-stream-hook-DG4BtN12.js';
-import { a as PailBrowserImpl, m as mergeTypes, b as arrayify } from './packem_shared/pail.browser-u2CSR_af.js';
-import { ProgressBar, applyStyleToOptions, MultiProgressBar } from './progress-bar.js';
-export { getBarChar } from './progress-bar.js';
-import { i as inspect } from './packem_shared/format-label-De49vNPd.js';
-import { E as EMPTY_SYMBOL } from './packem_shared/constants-omsTHUWB.js';
-import { w as writeStream } from './packem_shared/write-stream-BG8fhcs3.js';
-import { Spinner, MultiSpinner } from './spinner.js';
-import { g as getLongestLabel } from './packem_shared/get-longest-label-C9PWeyKq.js';
-import MessageFormatterProcessor from './processor/message-formatter-processor.js';
-import { PrettyReporter } from './packem_shared/PrettyReporter-DgZB2eBG.js';
+import { t as terminalSize, w as wordWrap, W as WrapMode, g as getLongestLabel, E as EXTENDED_RFC_5424_LOG_LEVELS, a as EMPTY_SYMBOL, L as LOG_TYPES, i as inspect, b as writeStream, A as AbstractPrettyReporter, d as defaultInspectorConfig, c as getLongestBadge, e as getStringWidth, f as formatLabel, r as renderError } from './packem_shared/abstract-pretty-reporter-szQO-IgK.js';
+const {
+  StringDecoder
+} = __cjs_getBuiltinModule("node:string_decoder");
+import { ProgressBar, applyStyleToOptions, MultiProgressBar } from './packem_shared/getBarChar-D7JfmdTr.js';
+export { getBarChar } from './packem_shared/getBarChar-D7JfmdTr.js';
+import { Spinner, MultiSpinner } from './packem_shared/Spinner-Cokext9b.js';
+import colorize, { red, greenBright, cyan, green, grey, bgGrey, underline, white } from '@visulima/colorize';
+export { PailError, createPailError } from './packem_shared/createPailError-B_sgL0nF.js';
+
+class InteractiveManager {
+  #stream;
+  #isActive = false;
+  #isSuspended = false;
+  #lastLength = 0;
+  #outside = 0;
+  /**
+   * Creates a new InteractiveManager with the given stream hooks.
+   * @param stdout Hook for stdout stream
+   * @param stderr Hook for stderr stream
+   */
+  constructor(stdout, stderr) {
+    this.#stream = {
+      stderr,
+      stdout
+    };
+  }
+  /**
+   * Last printed rows count.
+   *
+   * Tracks the number of rows that were last written to the terminal.
+   * Used internally for managing cursor positioning and output updates.
+   */
+  get lastLength() {
+    return this.#lastLength;
+  }
+  /**
+   * Rows count outside editable area.
+   *
+   * Tracks the number of rows that extend beyond the current terminal height.
+   * Used for managing scrolling and ensuring all output remains visible.
+   */
+  get outside() {
+    return this.#outside;
+  }
+  /**
+   * Hook activity status.
+   *
+   * Indicates whether the interactive hooks are currently active.
+   * When true, streams are being intercepted for interactive output.
+   */
+  get isHooked() {
+    return this.#isActive;
+  }
+  /**
+   * Suspend status for active hooks.
+   *
+   * Indicates whether interactive mode is temporarily suspended.
+   * When suspended, external output can be written without interference.
+   */
+  get isSuspended() {
+    return this.#isSuspended;
+  }
+  /**
+   * Removes lines from the terminal output.
+   *
+   * Erases the specified number of lines from the bottom of the output,
+   * moving the cursor up and clearing the lines. Useful for removing
+   * previous interactive output before displaying new content.
+   * @param stream The stream to erase lines from ("stdout" or "stderr")
+   * @param count Number of lines to remove (defaults to lastLength)
+   * @throws {TypeError} If the specified stream is not available
+   */
+  erase(stream, count = this.#lastLength) {
+    this.#stream[stream].erase(count);
+  }
+  /**
+   * Hook stdout and stderr streams.
+   * @returns Success status
+   */
+  hook() {
+    if (!this.#isActive) {
+      const hooks = Object.values(this.#stream);
+      for (let i = 0; i < hooks.length; i += 1) {
+        hooks[i].active();
+      }
+      this.#clear(true);
+    }
+    return this.#isActive;
+  }
+  /**
+   * Resume suspend hooks.
+   * @param stream Stream to resume
+   * @param eraseRowCount erase output rows count
+   */
+  resume(stream, eraseRowCount) {
+    if (this.#isSuspended) {
+      this.#isSuspended = false;
+      if (eraseRowCount) {
+        this.erase(stream, eraseRowCount);
+      }
+      this.#lastLength = 0;
+      const hooks = Object.values(this.#stream);
+      for (let i = 0; i < hooks.length; i += 1) {
+        hooks[i].active();
+      }
+    }
+  }
+  /**
+   * Suspend active hooks for external output.
+   * @param stream Stream to suspend
+   * @param erase erase output
+   */
+  suspend(stream, erase = true) {
+    if (!this.#isSuspended) {
+      this.#isSuspended = true;
+      if (erase) {
+        this.erase(stream);
+      }
+      const hooks = Object.values(this.#stream);
+      for (let i = 0; i < hooks.length; i += 1) {
+        hooks[i].renew();
+      }
+    }
+  }
+  /**
+   * Unhooks both stdout and stderr streams and print their story of logs.
+   * @param separateHistory If `true`, will add an empty line to the history output for individual recorded lines and console logs
+   * @returns Success status
+   */
+  unhook(separateHistory = true) {
+    if (this.#isActive) {
+      const hooks = Object.values(this.#stream);
+      for (let i = 0; i < hooks.length; i += 1) {
+        hooks[i].inactive(separateHistory);
+      }
+      this.#clear();
+    }
+    return !this.#isActive;
+  }
+  /**
+   * Update output.
+   * @param stream Stream to write to
+   * @param rows Text lines to write to standard output
+   * @param from Index of the line starting from which the contents of the terminal are being overwritten
+   */
+  update(stream, rows, from = 0) {
+    if (rows.length > 0) {
+      const hook = this.#stream[stream];
+      const { columns: width, rows: height } = terminalSize();
+      const position = from > height ? height - 1 : Math.max(0, Math.min(height - 1, from));
+      const actualLength = this.lastLength - position;
+      const outside = Math.max(actualLength - height, this.outside);
+      let output = rows.reduce(
+        (accumulator, row) => [
+          ...accumulator,
+          wordWrap(row, {
+            trim: false,
+            width,
+            wrapMode: WrapMode.STRICT_WIDTH
+          })
+        ],
+        []
+      );
+      if (height <= actualLength) {
+        hook.erase(height);
+        if (position < outside) {
+          output = output.slice(outside - position + 1);
+        }
+      } else if (actualLength) {
+        hook.erase(actualLength);
+      }
+      hook.write(`${output.join("\n")}
+`);
+      this.#lastLength = outside ? outside + output.length + 1 : output.length;
+      this.#outside = Math.max(this.lastLength - height, this.outside);
+    }
+  }
+  #clear(status = false) {
+    this.#isActive = status;
+    this.#lastLength = 0;
+    this.#outside = 0;
+  }
+}
+
+const ESC = "\x1B[";
+const eraseScreen = `${ESC}2J`;
+const eraseLine = `${ESC}2K`;
+const cursorLeft = `${ESC}G`;
+const cursorUp = (count = 1) => `${ESC}${String(count)}A`;
+const clearTerminal = process.platform === "win32" ? `${eraseScreen}${ESC}0f` : (
+  // 1. Erases the screen (Only done in case `2` is not supported)
+  // 2. Erases the whole screen including scrollback buffer
+  // 3. Moves cursor to the top-left position
+  // More info: https://www.real-world-systems.com/docs/ANSIcode.html
+  `${eraseScreen}${ESC}3J${ESC}H`
+);
+const cursorHide = `${ESC}?25l`;
+const cursorShow = `${ESC}?25h`;
+const eraseLines = (count) => {
+  let clear = "";
+  for (let index = 0; index < count; index++) {
+    clear += eraseLine + (index < count - 1 ? cursorUp() : "");
+  }
+  if (count) {
+    clear += cursorLeft;
+  }
+  return clear;
+};
+
+class InteractiveStreamHook {
+  /** Constant indicating the stream write operation was successful */
+  static DRAIN = true;
+  #decoder = new StringDecoder();
+  #history = [];
+  #method;
+  #stream;
+  /**
+   * Creates a new InteractiveStreamHook for the given stream.
+   * @param stream The Node.js WriteStream to hook into (usually stdout or stderr)
+   */
+  constructor(stream) {
+    this.#method = stream.write.bind(stream);
+    this.#stream = stream;
+  }
+  /**
+   * Activates the stream hook.
+   *
+   * When active, all writes to the stream are captured in history instead of
+   * being written immediately. This allows for interactive features like
+   * progress bars that can update dynamically.
+   */
+  active() {
+    this.write(cursorHide);
+    this.#stream.write = (data, ...arguments_) => {
+      const callback = arguments_.at(-1);
+      this.#history.push(
+        // prettier-ignore
+        this.#decoder.write(
+          typeof data === "string" ? Buffer.from(data, typeof arguments_[0] === "string" ? arguments_[0] : void 0) : Buffer.from(data)
+        )
+      );
+      if (typeof callback === "function") {
+        callback();
+      }
+      return InteractiveStreamHook.DRAIN;
+    };
+  }
+  /**
+   * Erases the specified number of lines from the terminal.
+   *
+   * Uses ANSI escape sequences to remove lines from the current cursor position
+   * upwards, which is useful for clearing previous output in interactive applications.
+   * @param count Number of lines to erase (including the current line)
+   */
+  erase(count) {
+    if (count > 0) {
+      this.write(eraseLines(count + 1));
+    }
+  }
+  /**
+   * Deactivates the stream hook and replays captured output.
+   *
+   * Restores normal stream operation and outputs all captured history.
+   * Optionally adds a newline separator before replaying the history.
+   * @param separateHistory Whether to add a newline before replaying history
+   */
+  inactive(separateHistory = false) {
+    if (this.#history.length > 0) {
+      if (separateHistory) {
+        this.write("\n");
+      }
+      this.#history.forEach((element) => {
+        this.write(element);
+      });
+      this.#history = [];
+    }
+    this.renew();
+  }
+  /**
+   * Renews the stream hook state.
+   *
+   * Restores the original stream write method and shows the cursor.
+   * This is typically called when temporarily suspending interactive mode.
+   */
+  renew() {
+    this.#stream.write = this.#method;
+    this.write(cursorShow);
+  }
+  /**
+   * Writes a message directly to the underlying stream.
+   *
+   * Bypasses the hook mechanism and writes directly using the original
+   * stream write method. Useful for writing control sequences or
+   * messages that should not be captured in history.
+   * @param message The message to write to the stream
+   */
+  write(message) {
+    this.#method.apply(this.#stream, [message]);
+  }
+}
+
+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;
+
+const writeConsoleLogBasedOnLevel = (level) => {
+  const c = console;
+  if (level === "error") {
+    return c.__error ?? console.error;
+  }
+  if (level === "warn") {
+    return c.__warn ?? console.warn;
+  }
+  if (level === "trace") {
+    return c.__trace ?? console.trace;
+  }
+  return c.__log ?? console.log;
+};
+
+let RawReporter$1 = 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$1());
+    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 (let i = 0; i < queue.length; i += 1) {
+      const { messageObject, raw, type } = queue[i];
+      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
+   * ```
+   */
+  child(options) {
+    const typesChanged = options?.types !== void 0;
+    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 ? `${String(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 ? `${String(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}: ${String(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 (let i = 0; i < reporters.length; i += 1) {
+      this.reporters.add(this.extendReporter(reporters[i]));
+    }
+  }
+  registerProcessors(processors) {
+    for (let i = 0; i < processors.length; i += 1) {
+      const processor = processors[i];
+      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];
+    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);
+    }
+  }
+}
 
 class RawReporter {
   #stdout;
@@ -58,7 +1793,7 @@ class RawReporter {
           if (typeof value === "object") {
             return ` ${inspect(value, this.#inspectOptions)}`;
           }
-          return ` ${value}`;
+          return ` ${String(value)}`;
         })
       );
     }
@@ -134,6 +1869,7 @@ class PailServerImpl extends PailBrowserImpl {
       this.registerProcessors(processors);
     }
   }
+  options;
   stdout;
   stderr;
   interactiveManager;
@@ -179,7 +1915,7 @@ class PailServerImpl extends PailBrowserImpl {
    */
   // @ts-expect-error - override signature differs due to server-specific options
   child(options) {
-    const typesChanged = options?.types !== void 0 && options.types !== null;
+    const typesChanged = options?.types !== void 0;
     const mergedTypes = typesChanged ? mergeTypes(this.types, options.types) : this.types;
     const childReporters = options?.reporters ?? [];
     const allReporters = childReporters.length > 0 ? [...this.reporters, ...childReporters] : [...this.reporters];
@@ -505,6 +2241,924 @@ class PailServerImpl extends PailBrowserImpl {
 }
 const PailServer = PailServerImpl;
 
+const colorKeywords = /* @__PURE__ */ new Map([
+  ["aliceblue", "#f0f8ff"],
+  ["antiquewhite", "#faebd7"],
+  ["aqua", "#00ffff"],
+  ["aquamarine", "#7fffd4"],
+  ["azure", "#f0ffff"],
+  ["beige", "#f5f5dc"],
+  ["bisque", "#ffe4c4"],
+  ["black", "#000000"],
+  ["blanchedalmond", "#ffebcd"],
+  ["blue", "#0000ff"],
+  ["blueviolet", "#8a2be2"],
+  ["brown", "#a52a2a"],
+  ["burlywood", "#deb887"],
+  ["cadetblue", "#5f9ea0"],
+  ["chartreuse", "#7fff00"],
+  ["chocolate", "#d2691e"],
+  ["coral", "#ff7f50"],
+  ["cornflowerblue", "#6495ed"],
+  ["cornsilk", "#fff8dc"],
+  ["crimson", "#dc143c"],
+  ["cyan", "#00ffff"],
+  ["darkblue", "#00008b"],
+  ["darkcyan", "#008b8b"],
+  ["darkgoldenrod", "#b8860b"],
+  ["darkgray", "#a9a9a9"],
+  ["darkgreen", "#006400"],
+  ["darkgrey", "#a9a9a9"],
+  ["darkkhaki", "#bdb76b"],
+  ["darkmagenta", "#8b008b"],
+  ["darkolivegreen", "#556b2f"],
+  ["darkorange", "#ff8c00"],
+  ["darkorchid", "#9932cc"],
+  ["darkred", "#8b0000"],
+  ["darksalmon", "#e9967a"],
+  ["darkseagreen", "#8fbc8f"],
+  ["darkslateblue", "#483d8b"],
+  ["darkslategray", "#2f4f4f"],
+  ["darkslategrey", "#2f4f4f"],
+  ["darkturquoise", "#00ced1"],
+  ["darkviolet", "#9400d3"],
+  ["deeppink", "#ff1493"],
+  ["deepskyblue", "#00bfff"],
+  ["dimgray", "#696969"],
+  ["dimgrey", "#696969"],
+  ["dodgerblue", "#1e90ff"],
+  ["firebrick", "#b22222"],
+  ["floralwhite", "#fffaf0"],
+  ["forestgreen", "#228b22"],
+  ["fuchsia", "#ff00ff"],
+  ["gainsboro", "#dcdcdc"],
+  ["ghostwhite", "#f8f8ff"],
+  ["gold", "#ffd700"],
+  ["goldenrod", "#daa520"],
+  ["gray", "#808080"],
+  ["green", "#008000"],
+  ["greenyellow", "#adff2f"],
+  ["grey", "#808080"],
+  ["honeydew", "#f0fff0"],
+  ["hotpink", "#ff69b4"],
+  ["indianred", "#cd5c5c"],
+  ["indigo", "#4b0082"],
+  ["ivory", "#fffff0"],
+  ["khaki", "#f0e68c"],
+  ["lavender", "#e6e6fa"],
+  ["lavenderblush", "#fff0f5"],
+  ["lawngreen", "#7cfc00"],
+  ["lemonchiffon", "#fffacd"],
+  ["lightblue", "#add8e6"],
+  ["lightcoral", "#f08080"],
+  ["lightcyan", "#e0ffff"],
+  ["lightgoldenrodyellow", "#fafad2"],
+  ["lightgray", "#d3d3d3"],
+  ["lightgreen", "#90ee90"],
+  ["lightgrey", "#d3d3d3"],
+  ["lightpink", "#ffb6c1"],
+  ["lightsalmon", "#ffa07a"],
+  ["lightseagreen", "#20b2aa"],
+  ["lightskyblue", "#87cefa"],
+  ["lightslategray", "#778899"],
+  ["lightslategrey", "#778899"],
+  ["lightsteelblue", "#b0c4de"],
+  ["lightyellow", "#ffffe0"],
+  ["lime", "#00ff00"],
+  ["limegreen", "#32cd32"],
+  ["linen", "#faf0e6"],
+  ["magenta", "#ff00ff"],
+  ["maroon", "#800000"],
+  ["mediumaquamarine", "#66cdaa"],
+  ["mediumblue", "#0000cd"],
+  ["mediumorchid", "#ba55d3"],
+  ["mediumpurple", "#9370db"],
+  ["mediumseagreen", "#3cb371"],
+  ["mediumslateblue", "#7b68ee"],
+  ["mediumspringgreen", "#00fa9a"],
+  ["mediumturquoise", "#48d1cc"],
+  ["mediumvioletred", "#c71585"],
+  ["midnightblue", "#191970"],
+  ["mintcream", "#f5fffa"],
+  ["mistyrose", "#ffe4e1"],
+  ["moccasin", "#ffe4b5"],
+  ["navajowhite", "#ffdead"],
+  ["navy", "#000080"],
+  ["oldlace", "#fdf5e6"],
+  ["olive", "#808000"],
+  ["olivedrab", "#6b8e23"],
+  ["orange", "#ffa500"],
+  ["orangered", "#ff4500"],
+  ["orchid", "#da70d6"],
+  ["palegoldenrod", "#eee8aa"],
+  ["palegreen", "#98fb98"],
+  ["paleturquoise", "#afeeee"],
+  ["palevioletred", "#db7093"],
+  ["papayawhip", "#ffefd5"],
+  ["peachpuff", "#ffdab9"],
+  ["peru", "#cd853f"],
+  ["pink", "#ffc0cb"],
+  ["plum", "#dda0dd"],
+  ["powderblue", "#b0e0e6"],
+  ["purple", "#800080"],
+  ["rebeccapurple", "#663399"],
+  ["red", "#ff0000"],
+  ["rosybrown", "#bc8f8f"],
+  ["royalblue", "#4169e1"],
+  ["saddlebrown", "#8b4513"],
+  ["salmon", "#fa8072"],
+  ["sandybrown", "#f4a460"],
+  ["seagreen", "#2e8b57"],
+  ["seashell", "#fff5ee"],
+  ["sienna", "#a0522d"],
+  ["silver", "#c0c0c0"],
+  ["skyblue", "#87ceeb"],
+  ["slateblue", "#6a5acd"],
+  ["slategray", "#708090"],
+  ["slategrey", "#708090"],
+  ["snow", "#fffafa"],
+  ["springgreen", "#00ff7f"],
+  ["steelblue", "#4682b4"],
+  ["tan", "#d2b48c"],
+  ["teal", "#008080"],
+  ["thistle", "#d8bfd8"],
+  ["tomato", "#ff6347"],
+  ["turquoise", "#40e0d0"],
+  ["violet", "#ee82ee"],
+  ["wheat", "#f5deb3"],
+  ["white", "#ffffff"],
+  ["whitesmoke", "#f5f5f5"],
+  ["yellow", "#ffff00"],
+  ["yellowgreen", "#9acd32"]
+]);
+const HASH_PATTERN = /^#([\dA-F]{2})([\dA-F]{2})([\dA-F]{2})([\dA-F]{2})?$/i;
+const SMALL_HASH_PATTERN = /^#([\dA-F])([\dA-F])([\dA-F])([\dA-F])?$/i;
+const RGB_PATTERN = /^rgba?\(\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))\s*,\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))\s*,\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))\s*(,\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))\s*)?\)$/;
+const HSL_PATTERN = /^hsla?\(\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))\s*,\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))%\s*,\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))%\s*(,\s*([+-]?(?:\d+(?:\.\d+)?|\.\d+))\s*)?\)$/;
+const getDefaultCss = () => {
+  return {
+    __proto__: null,
+    backgroundColor: null,
+    color: null,
+    fontStyle: null,
+    fontWeight: null,
+    textDecorationColor: null,
+    textDecorationLine: []
+  };
+};
+const SPACE_PATTERN = /\s+/;
+const parseCssColor = (colorString) => {
+  if (colorKeywords.has(colorString)) {
+    colorString = colorKeywords.get(colorString);
+  }
+  const hashMatch = HASH_PATTERN.exec(colorString);
+  if (hashMatch) {
+    return [Number.parseInt(hashMatch[1], 16), Number.parseInt(hashMatch[2], 16), Number.parseInt(hashMatch[3], 16)];
+  }
+  const smallHashMatch = SMALL_HASH_PATTERN.exec(colorString);
+  if (smallHashMatch) {
+    return [
+      Number.parseInt(`${smallHashMatch[1]}${smallHashMatch[1]}`, 16),
+      Number.parseInt(`${smallHashMatch[2]}${smallHashMatch[2]}`, 16),
+      Number.parseInt(`${smallHashMatch[3]}${smallHashMatch[3]}`, 16)
+    ];
+  }
+  const rgbMatch = RGB_PATTERN.exec(colorString);
+  if (rgbMatch) {
+    return [
+      Math.round(Math.max(0, Math.min(255, Number(rgbMatch[1])))),
+      Math.round(Math.max(0, Math.min(255, Number(rgbMatch[2])))),
+      Math.round(Math.max(0, Math.min(255, Number(rgbMatch[3]))))
+    ];
+  }
+  const hslMatch = HSL_PATTERN.exec(colorString);
+  if (hslMatch) {
+    let h = Number(hslMatch[1]) % 360;
+    if (h < 0) {
+      h += 360;
+    }
+    const s = Math.max(0, Math.min(100, Number(hslMatch[2]))) / 100;
+    const l = Math.max(0, Math.min(100, Number(hslMatch[3]))) / 100;
+    const c = (1 - Math.abs(2 * l - 1)) * s;
+    const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+    const m = l - c / 2;
+    let r_;
+    let g_;
+    let b_;
+    if (h < 60) {
+      ({ 0: r_, 1: g_, 2: b_ } = [c, x, 0]);
+    } else if (h < 120) {
+      ({ 0: r_, 1: g_, 2: b_ } = [x, c, 0]);
+    } else if (h < 180) {
+      ({ 0: r_, 1: g_, 2: b_ } = [0, c, x]);
+    } else if (h < 240) {
+      ({ 0: r_, 1: g_, 2: b_ } = [0, x, c]);
+    } else if (h < 300) {
+      ({ 0: r_, 1: g_, 2: b_ } = [x, 0, c]);
+    } else {
+      ({ 0: r_, 1: g_, 2: b_ } = [c, 0, x]);
+    }
+    return [Math.round((r_ + m) * 255), Math.round((g_ + m) * 255), Math.round((b_ + m) * 255)];
+  }
+  return null;
+};
+const colorEquals = (color1, color2) => color1?.[0] === color2?.[0] && color1?.[1] === color2?.[1] && color1?.[2] === color2?.[2];
+const parseCss = (cssString) => {
+  const css = getDefaultCss();
+  const rawEntries = [];
+  let inValue = false;
+  let currentKey = null;
+  let parenthesesDepth = 0;
+  let currentPart = "";
+  for (const c of cssString) {
+    if (c === "(") {
+      parenthesesDepth += 1;
+    } else if (parenthesesDepth > 0) {
+      if (c === ")") {
+        parenthesesDepth -= 1;
+      }
+    } else if (inValue) {
+      if (c === ";") {
+        const value = currentPart.trim();
+        if (value !== "") {
+          rawEntries.push([currentKey, value]);
+        }
+        currentKey = null;
+        currentPart = "";
+        inValue = false;
+        continue;
+      }
+    } else if (c === ":") {
+      currentKey = currentPart.trim();
+      currentPart = "";
+      inValue = true;
+      continue;
+    }
+    currentPart += c;
+  }
+  if (inValue && parenthesesDepth === 0) {
+    const value = currentPart.trim();
+    if (value !== "") {
+      rawEntries.push([currentKey, value]);
+    }
+    currentKey = null;
+    currentPart = "";
+  }
+  for (const { 0: key, 1: value } of rawEntries) {
+    switch (key) {
+      case "background-color": {
+        if (value != void 0) {
+          css.backgroundColor = value;
+        }
+        break;
+      }
+      case "color": {
+        if (value != void 0) {
+          css.color = value;
+        }
+        break;
+      }
+      case "font-style": {
+        if (["italic", "oblique", "oblique 14deg"].includes(value)) {
+          css.fontStyle = "italic";
+        }
+        break;
+      }
+      case "font-weight": {
+        if (value === "bold") {
+          css.fontWeight = value;
+        }
+        break;
+      }
+      case "text-decoration": {
+        css.textDecorationColor = null;
+        css.textDecorationLine = [];
+        const arguments_ = value.split(SPACE_PATTERN);
+        for (const argument of arguments_) {
+          const maybeColor = parseCssColor(argument);
+          if (maybeColor != void 0) {
+            css.textDecorationColor = maybeColor;
+          } else if (["line-through", "overline", "underline"].includes(argument)) {
+            css.textDecorationLine.push(argument);
+          }
+        }
+        break;
+      }
+      case "text-decoration-color": {
+        const color = parseCssColor(value);
+        if (color != void 0) {
+          css.textDecorationColor = color;
+        }
+        break;
+      }
+      case "text-decoration-line": {
+        css.textDecorationLine = [];
+        const lineTypes = value.split(SPACE_PATTERN);
+        for (const lineType of lineTypes) {
+          if (["line-through", "overline", "underline"].includes(lineType)) {
+            css.textDecorationLine.push(lineType);
+          }
+        }
+        break;
+      }
+    }
+  }
+  return css;
+};
+const cssToAnsi = (css, previousCss = null) => {
+  previousCss = previousCss ?? getDefaultCss();
+  let ansi = "";
+  if (!colorEquals(css.backgroundColor, previousCss.backgroundColor)) {
+    if (css.backgroundColor == void 0) {
+      ansi += "\x1B[49m";
+    } else {
+      switch (css.backgroundColor) {
+        case "black": {
+          ansi += "\x1B[40m";
+          break;
+        }
+        case "blue": {
+          ansi += "\x1B[44m";
+          break;
+        }
+        case "cyan": {
+          ansi += "\x1B[46m";
+          break;
+        }
+        case "green": {
+          ansi += "\x1B[42m";
+          break;
+        }
+        case "magenta": {
+          ansi += "\x1B[45m";
+          break;
+        }
+        case "red": {
+          ansi += "\x1B[41m";
+          break;
+        }
+        case "white": {
+          ansi += "\x1B[47m";
+          break;
+        }
+        case "yellow": {
+          ansi += "\x1B[43m";
+          break;
+        }
+        default: {
+          if (Array.isArray(css.backgroundColor)) {
+            const { 0: r, 1: g, 2: b } = css.backgroundColor;
+            ansi += `\x1B[48;2;${String(r)};${String(g)};${String(b)}m`;
+          } else {
+            const parsed = parseCssColor(css.backgroundColor);
+            if (parsed === null) {
+              ansi += "\x1B[49m";
+            } else {
+              const { 0: r, 1: g, 2: b } = parsed;
+              ansi += `\x1B[48;2;${String(r)};${String(g)};${String(b)}m`;
+            }
+          }
+        }
+      }
+    }
+  }
+  if (!colorEquals(css.color, previousCss.color)) {
+    if (css.color == void 0) {
+      ansi += "\x1B[39m";
+    } else {
+      switch (css.color) {
+        case "black": {
+          ansi += "\x1B[30m";
+          break;
+        }
+        case "blue": {
+          ansi += "\x1B[34m";
+          break;
+        }
+        case "cyan": {
+          ansi += "\x1B[36m";
+          break;
+        }
+        case "green": {
+          ansi += "\x1B[32m";
+          break;
+        }
+        case "magenta": {
+          ansi += "\x1B[35m";
+          break;
+        }
+        case "red": {
+          ansi += "\x1B[31m";
+          break;
+        }
+        case "white": {
+          ansi += "\x1B[37m";
+          break;
+        }
+        case "yellow": {
+          ansi += "\x1B[33m";
+          break;
+        }
+        default: {
+          if (Array.isArray(css.color)) {
+            const { 0: r, 1: g, 2: b } = css.color;
+            ansi += `\x1B[38;2;${String(r)};${String(g)};${String(b)}m`;
+          } else {
+            const parsed = parseCssColor(css.color);
+            if (parsed === null) {
+              ansi += "\x1B[39m";
+            } else {
+              const { 0: r, 1: g, 2: b } = parsed;
+              ansi += `\x1B[38;2;${String(r)};${String(g)};${String(b)}m`;
+            }
+          }
+        }
+      }
+    }
+  }
+  if (css.fontWeight !== previousCss.fontWeight) {
+    ansi += css.fontWeight === "bold" ? "\x1B[1m" : "\x1B[22m";
+  }
+  if (css.fontStyle !== previousCss.fontStyle) {
+    ansi += css.fontStyle === "italic" ? "\x1B[3m" : "\x1B[23m";
+  }
+  if (!colorEquals(css.textDecorationColor, previousCss.textDecorationColor)) {
+    if (css.textDecorationColor == void 0) {
+      ansi += "\x1B[59m";
+    } else {
+      const { 0: r, 1: g, 2: b } = css.textDecorationColor;
+      ansi += `\x1B[58;2;${String(r)};${String(g)};${String(b)}m`;
+    }
+  }
+  if (css.textDecorationLine.includes("line-through") !== previousCss.textDecorationLine.includes("line-through")) {
+    ansi += css.textDecorationLine.includes("line-through") ? "\x1B[9m" : "\x1B[29m";
+  }
+  if (css.textDecorationLine.includes("overline") !== previousCss.textDecorationLine.includes("overline")) {
+    ansi += css.textDecorationLine.includes("overline") ? "\x1B[53m" : "\x1B[55m";
+  }
+  if (css.textDecorationLine.includes("underline") !== previousCss.textDecorationLine.includes("underline")) {
+    ansi += css.textDecorationLine.includes("underline") ? "\x1B[4m" : "\x1B[24m";
+  }
+  return ansi;
+};
+const tryStringify = (o) => {
+  try {
+    return JSON.stringify(o);
+  } catch {
+    return '"[Circular]"';
+  }
+};
+const CHAR_PERCENT = "%".codePointAt(0);
+const CHAR_s = "s".codePointAt(0);
+const CHAR_d = "d".codePointAt(0);
+const CHAR_f = "f".codePointAt(0);
+const CHAR_i = "i".codePointAt(0);
+const CHAR_O = "O".codePointAt(0);
+const CHAR_o = "o".codePointAt(0);
+const CHAR_j = "j".codePointAt(0);
+const CHAR_c = "c".codePointAt(0);
+const format = (fmt, arguments_ = [], options = {}) => {
+  if (typeof fmt !== "string" && typeof fmt !== "object" || fmt === null) {
+    throw new TypeError(`fmt must be a string or object, got ${fmt === null ? "null" : typeof fmt}`);
+  }
+  const stringify = options.stringify ?? tryStringify;
+  const offset = 1;
+  if (typeof fmt === "object") {
+    const argumentsLength = arguments_.length + offset;
+    if (argumentsLength === 1) {
+      return "{}";
+    }
+    const objects = Array.from({ length: argumentsLength });
+    objects[0] = stringify(fmt);
+    for (let index = 1; index < argumentsLength; index += 1) {
+      objects[index] = stringify(arguments_[index - offset]);
+    }
+    return objects.join(" ");
+  }
+  if (arguments_.length === 0) {
+    return fmt;
+  }
+  let result = "";
+  let a = 1 - offset;
+  let lastPosition = -1;
+  let usedStyle = false;
+  let previousCss = null;
+  for (let index = 0; index < fmt.length; ) {
+    if (fmt.codePointAt(index) === CHAR_PERCENT && index + 1 < fmt.length) {
+      lastPosition = lastPosition > -1 ? lastPosition : 0;
+      const c = fmt.codePointAt(index + 1);
+      if (c === void 0) {
+        a += 1;
+        break;
+      }
+      switch (c) {
+        case CHAR_c: {
+          if (globalThis.window === void 0) {
+            const css = parseCss(arguments_[a]);
+            if (lastPosition < index) {
+              result += fmt.slice(lastPosition, index);
+            }
+            result += cssToAnsi(css, previousCss);
+            if (result !== "") {
+              usedStyle = true;
+              previousCss = css;
+            }
+          }
+          lastPosition = index + 2;
+          index += 1;
+          break;
+        }
+        case CHAR_d:
+        case CHAR_f: {
+          if (a >= arguments_.length || arguments_[a] == void 0) {
+            break;
+          }
+          if (lastPosition < index) {
+            result += fmt.slice(lastPosition, index);
+          }
+          result += Number(arguments_[a]).toString();
+          lastPosition = index + 2;
+          index += 1;
+          break;
+        }
+        case CHAR_i: {
+          if (a >= arguments_.length || arguments_[a] == void 0) {
+            break;
+          }
+          if (lastPosition < index) {
+            result += fmt.slice(lastPosition, index);
+          }
+          result += Math.floor(Number(arguments_[a])).toString();
+          lastPosition = index + 2;
+          index += 1;
+          break;
+        }
+        case CHAR_j:
+        case CHAR_O:
+        case CHAR_o: {
+          if (a >= arguments_.length || arguments_[a] === void 0) {
+            break;
+          }
+          if (lastPosition < index) {
+            result += fmt.slice(lastPosition, index);
+          }
+          const temporaryArgument = arguments_[a];
+          const type = typeof temporaryArgument;
+          if (type === "string") {
+            result += `'${temporaryArgument}'`;
+            lastPosition = index + 2;
+            break;
+          }
+          if (type === "function") {
+            result += temporaryArgument.name ? `[Function: ${temporaryArgument.name}]` : "[Function: <anonymous>]";
+            lastPosition = index + 2;
+            break;
+          }
+          result += stringify(temporaryArgument);
+          lastPosition = index + 2;
+          index += 1;
+          break;
+        }
+        case CHAR_PERCENT: {
+          if (lastPosition < index) {
+            result += fmt.slice(lastPosition, index);
+          }
+          result += "%";
+          lastPosition = index + 2;
+          index += 1;
+          a -= 1;
+          break;
+        }
+        case CHAR_s: {
+          if (a >= arguments_.length) {
+            break;
+          }
+          if (lastPosition < index) {
+            result += fmt.slice(lastPosition, index);
+          }
+          result += typeof arguments_[a] === "object" ? stringify(arguments_[a]) : String(arguments_[a]);
+          lastPosition = index + 2;
+          index += 1;
+          break;
+        }
+        default: {
+          if (typeof options.formatters?.[c] === "function") {
+            if (lastPosition < index) {
+              result += fmt.slice(lastPosition, index);
+            }
+            result += options.formatters[c](arguments_[a]);
+            lastPosition = index + 2;
+            index += 1;
+          }
+        }
+      }
+      a += 1;
+    }
+    index += 1;
+  }
+  if (lastPosition === -1) {
+    return fmt;
+  }
+  if (lastPosition < fmt.length) {
+    result += fmt.slice(lastPosition);
+  }
+  if (usedStyle) {
+    result += "\x1B[0m";
+  }
+  return result;
+};
+const build = (options = {}) => {
+  const formatters = {};
+  if (typeof options.formatters === "object") {
+    Object.entries(options.formatters).forEach(([key, formatterFunction]) => {
+      if (key.length === 0) {
+        throw new Error(`Formatter %${key} has no characters`);
+      }
+      if (key.length > 1) {
+        throw new Error(`Formatter %${key} has more than one character`);
+      }
+      if (typeof formatterFunction !== "function") {
+        throw new TypeError(`Formatter for %${key} is not a function`);
+      }
+      const c = key.codePointAt(0);
+      if (c === void 0) {
+        throw new Error(`${key}.codePointAt(0) failed to return a value, please report this issue`);
+      }
+      formatters[c] = formatterFunction;
+    });
+  }
+  return (f, arguments_ = [], formatOptions = {}) => format(f, arguments_, { ...formatOptions, formatters });
+};
+
+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
+   */
+  #format(formatter, data, arguments_ = []) {
+    if (typeof data === "string") {
+      return formatter(data, arguments_);
+    }
+    if (typeof data === "object" && data !== null) {
+      const record = data;
+      const keys = Object.keys(record);
+      for (let i = 0; i < keys.length; i += 1) {
+        const index = keys[i];
+        const value = record[index];
+        if (typeof value === "string" || Array.isArray(value) || typeof value === "object") {
+          record[index] = this.#format(formatter, value, arguments_);
+        }
+      }
+    }
+    return data;
+  }
+}
+
+const PAIL_DIST_REGEX = /[\\/]pail[\\/]dist/;
+const pailFileFilter = (line) => !PAIL_DIST_REGEX.test(line);
+class PrettyReporter extends AbstractPrettyReporter {
+  #stdout;
+  #stderr;
+  #interactiveManager;
+  #interactive = false;
+  #inspectOptions;
+  #errorOptions;
+  /**
+   * Creates a new Server Pretty Reporter instance.
+   * @param options Configuration options for styling, error rendering, and object inspection
+   */
+  constructor(options = {}) {
+    const { error: errorOptions, inspect: inspectOptions, ...rest } = options;
+    super({
+      uppercase: {
+        label: true,
+        ...rest.uppercase
+      },
+      ...rest
+    });
+    this.#inspectOptions = { ...defaultInspectorConfig, ...inspectOptions };
+    this.#errorOptions = {
+      ...errorOptions,
+      color: {
+        fileLine: green,
+        hint: cyan,
+        marker: red,
+        message: red,
+        method: greenBright,
+        title: red
+      }
+    };
+    this.#stdout = stdout;
+    this.#stderr = stderr;
+  }
+  /**
+   * Sets the stdout stream for the reporter.
+   * @param stdout_ The writable stream to use for standard output
+   */
+  setStdout(stdout_) {
+    this.#stdout = stdout_;
+  }
+  /**
+   * Sets the stderr stream for the reporter.
+   * @param stderr_ The writable stream to use for error output
+   */
+  setStderr(stderr_) {
+    this.#stderr = stderr_;
+  }
+  /**
+   * Sets the interactive manager for handling interactive output.
+   * @param manager The interactive manager instance, or undefined to disable
+   */
+  setInteractiveManager(manager) {
+    this.#interactiveManager = manager;
+  }
+  /**
+   * Enables or disables interactive mode.
+   * @param interactive Whether to enable interactive terminal features
+   */
+  setIsInteractive(interactive) {
+    this.#interactive = interactive;
+  }
+  log(meta) {
+    this._log(this._formatMessage(meta), meta.type.level);
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity, no-underscore-dangle
+  _formatMessage(data) {
+    const { columns } = terminalSize();
+    let size = columns;
+    if (typeof this.styles.messageLength === "number") {
+      size = this.styles.messageLength;
+    }
+    const { badge, context, date, error, file, groups, label, message, prefix, repeated, scope, suffix, traceError, type } = data;
+    const { color } = this.loggerTypes[type.name];
+    const colorized = color ? colorize[color] : white;
+    const groupSpaces = groups.map(() => "    ").join("");
+    const items = [];
+    if (groups.length > 0) {
+      items.push(`${groupSpaces + grey(`[${groups.at(-1) ?? ""}]`)} `);
+    }
+    if (date) {
+      items.push(`${grey(this.styles.dateFormatter(typeof date === "string" ? new Date(date) : date))} `);
+    }
+    if (badge) {
+      items.push(colorized(badge));
+    } else {
+      const longestBadge = getLongestBadge(this.loggerTypes);
+      if (longestBadge.length > 0) {
+        items.push(`${grey(".".repeat(longestBadge.length))} `);
+      }
+    }
+    const longestLabel = getLongestLabel(this.loggerTypes);
+    if (label) {
+      const longestLabelWidth = getStringWidth(longestLabel);
+      const labelWidth = getStringWidth(label);
+      items.push(`${colorized(formatLabel(label, this.styles))} `, grey(".".repeat(Math.max(0, longestLabelWidth - labelWidth))));
+    } else {
+      items.push(grey(".".repeat(longestLabel.length + 2)));
+    }
+    if (repeated) {
+      items.push(`${bgGrey.white(`[${String(repeated)}x]`)} `);
+    }
+    if (Array.isArray(scope) && scope.length > 0) {
+      items.push(` ${grey(`[${scope.join(" > ")}]`)} `);
+    }
+    if (prefix) {
+      items.push(
+        `${grey(`${Array.isArray(scope) && scope.length > 0 ? ". " : " "}[${this.styles.underline.prefix ? underline(prefix) : prefix}]`)} `
+      );
+    }
+    const titleSize = getStringWidth(items.join(" "));
+    if (file) {
+      const fileMessage = (file.name ?? "") + (file.line ? `:${String(file.line)}` : "");
+      const fileMessageSize = getStringWidth(fileMessage);
+      if (fileMessageSize + titleSize + 2 > size) {
+        items.push(grey(` ${fileMessage}`));
+      } else {
+        const dots = Math.max(0, size - titleSize - fileMessageSize - 2);
+        items.push(grey(`${".".repeat(dots)} ${fileMessage}`));
+      }
+    } else {
+      items.push(grey(".".repeat(Math.max(0, size - titleSize - 1))));
+    }
+    if (items.length > 0) {
+      items.push("\n\n");
+    }
+    if (message !== EMPTY_SYMBOL) {
+      const formattedMessage = typeof message === "string" ? message : inspect(message, this.#inspectOptions);
+      items.push(
+        groupSpaces + wordWrap(formattedMessage, {
+          trim: false,
+          width: size - 3,
+          wrapMode: WrapMode.STRICT_WIDTH
+        })
+      );
+    }
+    if (context) {
+      let hasError = false;
+      items.push(
+        ...context.map((value) => {
+          if (value instanceof Error) {
+            hasError = true;
+            return `
+
+${renderError(value, {
+              ...this.#errorOptions,
+              filterStacktrace: pailFileFilter,
+              prefix: groupSpaces
+            })}`;
+          }
+          if (typeof value === "object") {
+            return ` ${inspect(value, this.#inspectOptions)}`;
+          }
+          const newValue = (hasError ? "\n\n" : " ") + String(value);
+          hasError = false;
+          return newValue;
+        })
+      );
+    }
+    if (error) {
+      items.push(
+        renderError(error, {
+          ...this.#errorOptions,
+          filterStacktrace: pailFileFilter,
+          prefix: groupSpaces
+        })
+      );
+    }
+    if (traceError) {
+      items.push(
+        `
+
+${renderError(traceError, {
+          ...this.#errorOptions,
+          filterStacktrace: pailFileFilter,
+          hideErrorCauseCodeView: true,
+          hideErrorCodeView: true,
+          hideErrorErrorsCodeView: true,
+          hideMessage: true,
+          prefix: groupSpaces
+        })}`
+      );
+    }
+    if (suffix) {
+      items.push("\n", groupSpaces + grey(this.styles.underline.suffix ? underline(suffix) : suffix));
+    }
+    return items.join("");
+  }
+  // eslint-disable-next-line no-underscore-dangle
+  _log(message, logLevel) {
+    const streamType = ["error", "trace", "warn"].includes(logLevel) ? "stderr" : "stdout";
+    const stream = streamType === "stderr" ? this.#stderr : this.#stdout;
+    if (this.#interactive && this.#interactiveManager !== void 0 && stream.isTTY) {
+      this.#interactiveManager.update(streamType, message.split("\n"), 0);
+    } else {
+      writeStream(`${message}
+`, stream);
+    }
+  }
+}
+
 const getDefaultLogLevel = () => {
   if (env.NODE_ENV === "debug" || env.DEBUG !== void 0) {
     return "debug";