@visulima/pail 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/packem_shared/pail.browser-u2CSR_af.js

@@ -1,1427 +0,0 @@
-import { a as EXTENDED_RFC_5424_LOG_LEVELS, E as EMPTY_SYMBOL, L as LOG_TYPES } from './constants-omsTHUWB.js';
-import { w as writeConsoleLogBasedOnLevel } from './write-console-log-based-on-level-DBmRYXpj.js';
-import { g as getLongestLabel } from './get-longest-label-C9PWeyKq.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;
-
-export { PailBrowser as P, PailBrowserImpl as a, arrayify as b, mergeTypes as m };