plslog 1.1.0 → 1.2.0

package/dist/index.js

@@ -1,12 +1,1360 @@
 'use strict';
 
-var prettyFormat = require('pretty-format');
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/react-is@18.3.1/node_modules/react-is/cjs/react-is.production.min.js
+var require_react_is_production_min = __commonJS({
+  "../../node_modules/.pnpm/react-is@18.3.1/node_modules/react-is/cjs/react-is.production.min.js"(exports$1) {
+    var b = /* @__PURE__ */ Symbol.for("react.element");
+    var c = /* @__PURE__ */ Symbol.for("react.portal");
+    var d = /* @__PURE__ */ Symbol.for("react.fragment");
+    var e = /* @__PURE__ */ Symbol.for("react.strict_mode");
+    var f = /* @__PURE__ */ Symbol.for("react.profiler");
+    var g = /* @__PURE__ */ Symbol.for("react.provider");
+    var h = /* @__PURE__ */ Symbol.for("react.context");
+    var k = /* @__PURE__ */ Symbol.for("react.server_context");
+    var l = /* @__PURE__ */ Symbol.for("react.forward_ref");
+    var m = /* @__PURE__ */ Symbol.for("react.suspense");
+    var n = /* @__PURE__ */ Symbol.for("react.suspense_list");
+    var p = /* @__PURE__ */ Symbol.for("react.memo");
+    var q = /* @__PURE__ */ Symbol.for("react.lazy");
+    var t = /* @__PURE__ */ Symbol.for("react.offscreen");
+    var u;
+    u = /* @__PURE__ */ Symbol.for("react.module.reference");
+    function v(a) {
+      if ("object" === typeof a && null !== a) {
+        var r = a.$$typeof;
+        switch (r) {
+          case b:
+            switch (a = a.type, a) {
+              case d:
+              case f:
+              case e:
+              case m:
+              case n:
+                return a;
+              default:
+                switch (a = a && a.$$typeof, a) {
+                  case k:
+                  case h:
+                  case l:
+                  case q:
+                  case p:
+                  case g:
+                    return a;
+                  default:
+                    return r;
+                }
+            }
+          case c:
+            return r;
+        }
+      }
+    }
+    exports$1.ContextConsumer = h;
+    exports$1.ContextProvider = g;
+    exports$1.Element = b;
+    exports$1.ForwardRef = l;
+    exports$1.Fragment = d;
+    exports$1.Lazy = q;
+    exports$1.Memo = p;
+    exports$1.Portal = c;
+    exports$1.Profiler = f;
+    exports$1.StrictMode = e;
+    exports$1.Suspense = m;
+    exports$1.SuspenseList = n;
+    exports$1.isAsyncMode = function() {
+      return false;
+    };
+    exports$1.isConcurrentMode = function() {
+      return false;
+    };
+    exports$1.isContextConsumer = function(a) {
+      return v(a) === h;
+    };
+    exports$1.isContextProvider = function(a) {
+      return v(a) === g;
+    };
+    exports$1.isElement = function(a) {
+      return "object" === typeof a && null !== a && a.$$typeof === b;
+    };
+    exports$1.isForwardRef = function(a) {
+      return v(a) === l;
+    };
+    exports$1.isFragment = function(a) {
+      return v(a) === d;
+    };
+    exports$1.isLazy = function(a) {
+      return v(a) === q;
+    };
+    exports$1.isMemo = function(a) {
+      return v(a) === p;
+    };
+    exports$1.isPortal = function(a) {
+      return v(a) === c;
+    };
+    exports$1.isProfiler = function(a) {
+      return v(a) === f;
+    };
+    exports$1.isStrictMode = function(a) {
+      return v(a) === e;
+    };
+    exports$1.isSuspense = function(a) {
+      return v(a) === m;
+    };
+    exports$1.isSuspenseList = function(a) {
+      return v(a) === n;
+    };
+    exports$1.isValidElementType = function(a) {
+      return "string" === typeof a || "function" === typeof a || a === d || a === f || a === e || a === m || a === n || a === t || "object" === typeof a && null !== a && (a.$$typeof === q || a.$$typeof === p || a.$$typeof === g || a.$$typeof === h || a.$$typeof === l || a.$$typeof === u || void 0 !== a.getModuleId) ? true : false;
+    };
+    exports$1.typeOf = v;
+  }
+});
+
+// ../../node_modules/.pnpm/react-is@18.3.1/node_modules/react-is/cjs/react-is.development.js
+var require_react_is_development = __commonJS({
+  "../../node_modules/.pnpm/react-is@18.3.1/node_modules/react-is/cjs/react-is.development.js"(exports$1) {
+    if (process.env.NODE_ENV !== "production") {
+      (function() {
+        var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.element");
+        var REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal");
+        var REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment");
+        var REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode");
+        var REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler");
+        var REACT_PROVIDER_TYPE = /* @__PURE__ */ Symbol.for("react.provider");
+        var REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context");
+        var REACT_SERVER_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.server_context");
+        var REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
+        var REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense");
+        var REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list");
+        var REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
+        var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
+        var REACT_OFFSCREEN_TYPE = /* @__PURE__ */ Symbol.for("react.offscreen");
+        var enableScopeAPI = false;
+        var enableCacheElement = false;
+        var enableTransitionTracing = false;
+        var enableLegacyHidden = false;
+        var enableDebugTracing = false;
+        var REACT_MODULE_REFERENCE;
+        {
+          REACT_MODULE_REFERENCE = /* @__PURE__ */ Symbol.for("react.module.reference");
+        }
+        function isValidElementType(type) {
+          if (typeof type === "string" || typeof type === "function") {
+            return true;
+          }
+          if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing) {
+            return true;
+          }
+          if (typeof type === "object" && type !== null) {
+            if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
+            // types supported by any Flight configuration anywhere since
+            // we don't know which Flight build this will end up being used
+            // with.
+            type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== void 0) {
+              return true;
+            }
+          }
+          return false;
+        }
+        function typeOf(object) {
+          if (typeof object === "object" && object !== null) {
+            var $$typeof = object.$$typeof;
+            switch ($$typeof) {
+              case REACT_ELEMENT_TYPE:
+                var type = object.type;
+                switch (type) {
+                  case REACT_FRAGMENT_TYPE:
+                  case REACT_PROFILER_TYPE:
+                  case REACT_STRICT_MODE_TYPE:
+                  case REACT_SUSPENSE_TYPE:
+                  case REACT_SUSPENSE_LIST_TYPE:
+                    return type;
+                  default:
+                    var $$typeofType = type && type.$$typeof;
+                    switch ($$typeofType) {
+                      case REACT_SERVER_CONTEXT_TYPE:
+                      case REACT_CONTEXT_TYPE:
+                      case REACT_FORWARD_REF_TYPE:
+                      case REACT_LAZY_TYPE:
+                      case REACT_MEMO_TYPE:
+                      case REACT_PROVIDER_TYPE:
+                        return $$typeofType;
+                      default:
+                        return $$typeof;
+                    }
+                }
+              case REACT_PORTAL_TYPE:
+                return $$typeof;
+            }
+          }
+          return void 0;
+        }
+        var ContextConsumer = REACT_CONTEXT_TYPE;
+        var ContextProvider = REACT_PROVIDER_TYPE;
+        var Element = REACT_ELEMENT_TYPE;
+        var ForwardRef = REACT_FORWARD_REF_TYPE;
+        var Fragment = REACT_FRAGMENT_TYPE;
+        var Lazy = REACT_LAZY_TYPE;
+        var Memo = REACT_MEMO_TYPE;
+        var Portal = REACT_PORTAL_TYPE;
+        var Profiler = REACT_PROFILER_TYPE;
+        var StrictMode = REACT_STRICT_MODE_TYPE;
+        var Suspense = REACT_SUSPENSE_TYPE;
+        var SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+        var hasWarnedAboutDeprecatedIsAsyncMode = false;
+        var hasWarnedAboutDeprecatedIsConcurrentMode = false;
+        function isAsyncMode(object) {
+          {
+            if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+              hasWarnedAboutDeprecatedIsAsyncMode = true;
+              console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 18+.");
+            }
+          }
+          return false;
+        }
+        function isConcurrentMode(object) {
+          {
+            if (!hasWarnedAboutDeprecatedIsConcurrentMode) {
+              hasWarnedAboutDeprecatedIsConcurrentMode = true;
+              console["warn"]("The ReactIs.isConcurrentMode() alias has been deprecated, and will be removed in React 18+.");
+            }
+          }
+          return false;
+        }
+        function isContextConsumer(object) {
+          return typeOf(object) === REACT_CONTEXT_TYPE;
+        }
+        function isContextProvider(object) {
+          return typeOf(object) === REACT_PROVIDER_TYPE;
+        }
+        function isElement(object) {
+          return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+        }
+        function isForwardRef(object) {
+          return typeOf(object) === REACT_FORWARD_REF_TYPE;
+        }
+        function isFragment(object) {
+          return typeOf(object) === REACT_FRAGMENT_TYPE;
+        }
+        function isLazy(object) {
+          return typeOf(object) === REACT_LAZY_TYPE;
+        }
+        function isMemo(object) {
+          return typeOf(object) === REACT_MEMO_TYPE;
+        }
+        function isPortal(object) {
+          return typeOf(object) === REACT_PORTAL_TYPE;
+        }
+        function isProfiler(object) {
+          return typeOf(object) === REACT_PROFILER_TYPE;
+        }
+        function isStrictMode(object) {
+          return typeOf(object) === REACT_STRICT_MODE_TYPE;
+        }
+        function isSuspense(object) {
+          return typeOf(object) === REACT_SUSPENSE_TYPE;
+        }
+        function isSuspenseList(object) {
+          return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
+        }
+        exports$1.ContextConsumer = ContextConsumer;
+        exports$1.ContextProvider = ContextProvider;
+        exports$1.Element = Element;
+        exports$1.ForwardRef = ForwardRef;
+        exports$1.Fragment = Fragment;
+        exports$1.Lazy = Lazy;
+        exports$1.Memo = Memo;
+        exports$1.Portal = Portal;
+        exports$1.Profiler = Profiler;
+        exports$1.StrictMode = StrictMode;
+        exports$1.Suspense = Suspense;
+        exports$1.SuspenseList = SuspenseList;
+        exports$1.isAsyncMode = isAsyncMode;
+        exports$1.isConcurrentMode = isConcurrentMode;
+        exports$1.isContextConsumer = isContextConsumer;
+        exports$1.isContextProvider = isContextProvider;
+        exports$1.isElement = isElement;
+        exports$1.isForwardRef = isForwardRef;
+        exports$1.isFragment = isFragment;
+        exports$1.isLazy = isLazy;
+        exports$1.isMemo = isMemo;
+        exports$1.isPortal = isPortal;
+        exports$1.isProfiler = isProfiler;
+        exports$1.isStrictMode = isStrictMode;
+        exports$1.isSuspense = isSuspense;
+        exports$1.isSuspenseList = isSuspenseList;
+        exports$1.isValidElementType = isValidElementType;
+        exports$1.typeOf = typeOf;
+      })();
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/react-is@18.3.1/node_modules/react-is/index.js
+var require_react_is = __commonJS({
+  "../../node_modules/.pnpm/react-is@18.3.1/node_modules/react-is/index.js"(exports$1, module) {
+    if (process.env.NODE_ENV === "production") {
+      module.exports = require_react_is_production_min();
+    } else {
+      module.exports = require_react_is_development();
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/ansi-styles@5.2.0/node_modules/ansi-styles/index.js
+var require_ansi_styles = __commonJS({
+  "../../node_modules/.pnpm/ansi-styles@5.2.0/node_modules/ansi-styles/index.js"(exports$1, module) {
+    var ANSI_BACKGROUND_OFFSET = 10;
+    var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+    var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+    function assembleStyles() {
+      const codes = /* @__PURE__ */ new Map();
+      const styles = {
+        modifier: {
+          reset: [0, 0],
+          // 21 isn't widely supported and 22 does the same thing
+          bold: [1, 22],
+          dim: [2, 22],
+          italic: [3, 23],
+          underline: [4, 24],
+          overline: [53, 55],
+          inverse: [7, 27],
+          hidden: [8, 28],
+          strikethrough: [9, 29]
+        },
+        color: {
+          black: [30, 39],
+          red: [31, 39],
+          green: [32, 39],
+          yellow: [33, 39],
+          blue: [34, 39],
+          magenta: [35, 39],
+          cyan: [36, 39],
+          white: [37, 39],
+          // Bright color
+          blackBright: [90, 39],
+          redBright: [91, 39],
+          greenBright: [92, 39],
+          yellowBright: [93, 39],
+          blueBright: [94, 39],
+          magentaBright: [95, 39],
+          cyanBright: [96, 39],
+          whiteBright: [97, 39]
+        },
+        bgColor: {
+          bgBlack: [40, 49],
+          bgRed: [41, 49],
+          bgGreen: [42, 49],
+          bgYellow: [43, 49],
+          bgBlue: [44, 49],
+          bgMagenta: [45, 49],
+          bgCyan: [46, 49],
+          bgWhite: [47, 49],
+          // Bright color
+          bgBlackBright: [100, 49],
+          bgRedBright: [101, 49],
+          bgGreenBright: [102, 49],
+          bgYellowBright: [103, 49],
+          bgBlueBright: [104, 49],
+          bgMagentaBright: [105, 49],
+          bgCyanBright: [106, 49],
+          bgWhiteBright: [107, 49]
+        }
+      };
+      styles.color.gray = styles.color.blackBright;
+      styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+      styles.color.grey = styles.color.blackBright;
+      styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+      for (const [groupName, group] of Object.entries(styles)) {
+        for (const [styleName, style] of Object.entries(group)) {
+          styles[styleName] = {
+            open: `\x1B[${style[0]}m`,
+            close: `\x1B[${style[1]}m`
+          };
+          group[styleName] = styles[styleName];
+          codes.set(style[0], style[1]);
+        }
+        Object.defineProperty(styles, groupName, {
+          value: group,
+          enumerable: false
+        });
+      }
+      Object.defineProperty(styles, "codes", {
+        value: codes,
+        enumerable: false
+      });
+      styles.color.close = "\x1B[39m";
+      styles.bgColor.close = "\x1B[49m";
+      styles.color.ansi256 = wrapAnsi256();
+      styles.color.ansi16m = wrapAnsi16m();
+      styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+      styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+      Object.defineProperties(styles, {
+        rgbToAnsi256: {
+          value: (red, green, blue) => {
+            if (red === green && green === blue) {
+              if (red < 8) {
+                return 16;
+              }
+              if (red > 248) {
+                return 231;
+              }
+              return Math.round((red - 8) / 247 * 24) + 232;
+            }
+            return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+          },
+          enumerable: false
+        },
+        hexToRgb: {
+          value: (hex) => {
+            const matches = /(?<colorString>[a-f\d]{6}|[a-f\d]{3})/i.exec(hex.toString(16));
+            if (!matches) {
+              return [0, 0, 0];
+            }
+            let { colorString } = matches.groups;
+            if (colorString.length === 3) {
+              colorString = colorString.split("").map((character) => character + character).join("");
+            }
+            const integer = Number.parseInt(colorString, 16);
+            return [
+              integer >> 16 & 255,
+              integer >> 8 & 255,
+              integer & 255
+            ];
+          },
+          enumerable: false
+        },
+        hexToAnsi256: {
+          value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+          enumerable: false
+        }
+      });
+      return styles;
+    }
+    Object.defineProperty(module, "exports", {
+      enumerable: true,
+      get: assembleStyles
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/pretty-format@30.2.0/node_modules/pretty-format/build/index.js
+var require_build = __commonJS({
+  "../../node_modules/.pnpm/pretty-format@30.2.0/node_modules/pretty-format/build/index.js"(exports$1, module) {
+    (() => {
+      var __webpack_modules__ = {
+        /***/
+        "./src/collections.ts": (
+          /***/
+          ((__unused_webpack_module, exports2) => {
+            Object.defineProperty(exports2, "__esModule", {
+              value: true
+            });
+            exports2.printIteratorEntries = printIteratorEntries;
+            exports2.printIteratorValues = printIteratorValues;
+            exports2.printListItems = printListItems;
+            exports2.printObjectProperties = printObjectProperties;
+            const getKeysOfEnumerableProperties = (object, compareKeys) => {
+              const rawKeys = Object.keys(object);
+              const keys = compareKeys === null ? rawKeys : rawKeys.sort(compareKeys);
+              if (Object.getOwnPropertySymbols) {
+                for (const symbol of Object.getOwnPropertySymbols(object)) {
+                  if (Object.getOwnPropertyDescriptor(object, symbol).enumerable) {
+                    keys.push(symbol);
+                  }
+                }
+              }
+              return keys;
+            };
+            function printIteratorEntries(iterator, config, indentation, depth, refs, printer, separator = ": ") {
+              let result = "";
+              let width = 0;
+              let current = iterator.next();
+              if (!current.done) {
+                result += config.spacingOuter;
+                const indentationNext = indentation + config.indent;
+                while (!current.done) {
+                  result += indentationNext;
+                  if (width++ === config.maxWidth) {
+                    result += "\u2026";
+                    break;
+                  }
+                  const name = printer(current.value[0], config, indentationNext, depth, refs);
+                  const value = printer(current.value[1], config, indentationNext, depth, refs);
+                  result += name + separator + value;
+                  current = iterator.next();
+                  if (!current.done) {
+                    result += `,${config.spacingInner}`;
+                  } else if (!config.min) {
+                    result += ",";
+                  }
+                }
+                result += config.spacingOuter + indentation;
+              }
+              return result;
+            }
+            function printIteratorValues(iterator, config, indentation, depth, refs, printer) {
+              let result = "";
+              let width = 0;
+              let current = iterator.next();
+              if (!current.done) {
+                result += config.spacingOuter;
+                const indentationNext = indentation + config.indent;
+                while (!current.done) {
+                  result += indentationNext;
+                  if (width++ === config.maxWidth) {
+                    result += "\u2026";
+                    break;
+                  }
+                  result += printer(current.value, config, indentationNext, depth, refs);
+                  current = iterator.next();
+                  if (!current.done) {
+                    result += `,${config.spacingInner}`;
+                  } else if (!config.min) {
+                    result += ",";
+                  }
+                }
+                result += config.spacingOuter + indentation;
+              }
+              return result;
+            }
+            function printListItems(list, config, indentation, depth, refs, printer) {
+              let result = "";
+              list = list instanceof ArrayBuffer ? new DataView(list) : list;
+              const isDataView = (l) => l instanceof DataView;
+              const length = isDataView(list) ? list.byteLength : list.length;
+              if (length > 0) {
+                result += config.spacingOuter;
+                const indentationNext = indentation + config.indent;
+                for (let i = 0; i < length; i++) {
+                  result += indentationNext;
+                  if (i === config.maxWidth) {
+                    result += "\u2026";
+                    break;
+                  }
+                  if (isDataView(list) || i in list) {
+                    result += printer(isDataView(list) ? list.getInt8(i) : list[i], config, indentationNext, depth, refs);
+                  }
+                  if (i < length - 1) {
+                    result += `,${config.spacingInner}`;
+                  } else if (!config.min) {
+                    result += ",";
+                  }
+                }
+                result += config.spacingOuter + indentation;
+              }
+              return result;
+            }
+            function printObjectProperties(val, config, indentation, depth, refs, printer) {
+              let result = "";
+              const keys = getKeysOfEnumerableProperties(val, config.compareKeys);
+              if (keys.length > 0) {
+                result += config.spacingOuter;
+                const indentationNext = indentation + config.indent;
+                for (let i = 0; i < keys.length; i++) {
+                  const key = keys[i];
+                  const name = printer(key, config, indentationNext, depth, refs);
+                  const value = printer(val[key], config, indentationNext, depth, refs);
+                  result += `${indentationNext + name}: ${value}`;
+                  if (i < keys.length - 1) {
+                    result += `,${config.spacingInner}`;
+                  } else if (!config.min) {
+                    result += ",";
+                  }
+                }
+                result += config.spacingOuter + indentation;
+              }
+              return result;
+            }
+          })
+        ),
+        /***/
+        "./src/plugins/AsymmetricMatcher.ts": (
+          /***/
+          ((__unused_webpack_module, exports2, __webpack_require__2) => {
+            Object.defineProperty(exports2, "__esModule", {
+              value: true
+            });
+            exports2.test = exports2.serialize = exports2["default"] = void 0;
+            var _collections = __webpack_require__2("./src/collections.ts");
+            var Symbol2 = globalThis["jest-symbol-do-not-touch"] || globalThis.Symbol;
+            const asymmetricMatcher = typeof Symbol2 === "function" && Symbol2.for ? Symbol2.for("jest.asymmetricMatcher") : 1267621;
+            const SPACE = " ";
+            const serialize = (val, config, indentation, depth, refs, printer) => {
+              const stringedValue = val.toString();
+              if (stringedValue === "ArrayContaining" || stringedValue === "ArrayNotContaining") {
+                if (++depth > config.maxDepth) {
+                  return `[${stringedValue}]`;
+                }
+                return `${stringedValue + SPACE}[${(0, _collections.printListItems)(val.sample, config, indentation, depth, refs, printer)}]`;
+              }
+              if (stringedValue === "ObjectContaining" || stringedValue === "ObjectNotContaining") {
+                if (++depth > config.maxDepth) {
+                  return `[${stringedValue}]`;
+                }
+                return `${stringedValue + SPACE}{${(0, _collections.printObjectProperties)(val.sample, config, indentation, depth, refs, printer)}}`;
+              }
+              if (stringedValue === "StringMatching" || stringedValue === "StringNotMatching") {
+                return stringedValue + SPACE + printer(val.sample, config, indentation, depth, refs);
+              }
+              if (stringedValue === "StringContaining" || stringedValue === "StringNotContaining") {
+                return stringedValue + SPACE + printer(val.sample, config, indentation, depth, refs);
+              }
+              if (stringedValue === "ArrayOf" || stringedValue === "NotArrayOf") {
+                if (++depth > config.maxDepth) {
+                  return `[${stringedValue}]`;
+                }
+                return `${stringedValue + SPACE}${printer(val.sample, config, indentation, depth, refs)}`;
+              }
+              if (typeof val.toAsymmetricMatcher !== "function") {
+                throw new TypeError(`Asymmetric matcher ${val.constructor.name} does not implement toAsymmetricMatcher()`);
+              }
+              return val.toAsymmetricMatcher();
+            };
+            exports2.serialize = serialize;
+            const test = (val) => val && val.$$typeof === asymmetricMatcher;
+            exports2.test = test;
+            const plugin = {
+              serialize,
+              test
+            };
+            exports2["default"] = plugin;
+          })
+        ),
+        /***/
+        "./src/plugins/DOMCollection.ts": (
+          /***/
+          ((__unused_webpack_module, exports2, __webpack_require__2) => {
+            Object.defineProperty(exports2, "__esModule", {
+              value: true
+            });
+            exports2.test = exports2.serialize = exports2["default"] = void 0;
+            var _collections = __webpack_require__2("./src/collections.ts");
+            const SPACE = " ";
+            const OBJECT_NAMES = /* @__PURE__ */ new Set(["DOMStringMap", "NamedNodeMap"]);
+            const ARRAY_REGEXP = /^(HTML\w*Collection|NodeList)$/;
+            const testName = (name) => OBJECT_NAMES.has(name) || ARRAY_REGEXP.test(name);
+            const test = (val) => val && val.constructor && !!val.constructor.name && testName(val.constructor.name);
+            exports2.test = test;
+            const isNamedNodeMap = (collection) => collection.constructor.name === "NamedNodeMap";
+            const serialize = (collection, config, indentation, depth, refs, printer) => {
+              const name = collection.constructor.name;
+              if (++depth > config.maxDepth) {
+                return `[${name}]`;
+              }
+              return (config.min ? "" : name + SPACE) + (OBJECT_NAMES.has(name) ? `{${(0, _collections.printObjectProperties)(isNamedNodeMap(collection) ? [...collection].reduce((props, attribute) => {
+                props[attribute.name] = attribute.value;
+                return props;
+              }, {}) : {
+                ...collection
+              }, config, indentation, depth, refs, printer)}}` : `[${(0, _collections.printListItems)([...collection], config, indentation, depth, refs, printer)}]`);
+            };
+            exports2.serialize = serialize;
+            const plugin = {
+              serialize,
+              test
+            };
+            exports2["default"] = plugin;
+          })
+        ),
+        /***/
+        "./src/plugins/DOMElement.ts": (
+          /***/
+          ((__unused_webpack_module, exports2, __webpack_require__2) => {
+            Object.defineProperty(exports2, "__esModule", {
+              value: true
+            });
+            exports2.test = exports2.serialize = exports2["default"] = void 0;
+            var _markup = __webpack_require__2("./src/plugins/lib/markup.ts");
+            const ELEMENT_NODE = 1;
+            const TEXT_NODE = 3;
+            const COMMENT_NODE = 8;
+            const FRAGMENT_NODE = 11;
+            const ELEMENT_REGEXP = /^((HTML|SVG)\w*)?Element$/;
+            const testHasAttribute = (val) => {
+              try {
+                return typeof val.hasAttribute === "function" && val.hasAttribute("is");
+              } catch {
+                return false;
+              }
+            };
+            const isCustomElement = (val) => {
+              const tagName = val?.tagName;
+              return typeof tagName === "string" && tagName.includes("-") || testHasAttribute(val);
+            };
+            const testNode = (val) => {
+              const constructorName = val.constructor.name;
+              const {
+                nodeType
+              } = val;
+              return nodeType === ELEMENT_NODE && (ELEMENT_REGEXP.test(constructorName) || isCustomElement(val)) || nodeType === TEXT_NODE && constructorName === "Text" || nodeType === COMMENT_NODE && constructorName === "Comment" || nodeType === FRAGMENT_NODE && constructorName === "DocumentFragment";
+            };
+            const test = (val) => (val?.constructor?.name || isCustomElement(val)) && testNode(val);
+            exports2.test = test;
+            function nodeIsText(node) {
+              return node.nodeType === TEXT_NODE;
+            }
+            function nodeIsComment(node) {
+              return node.nodeType === COMMENT_NODE;
+            }
+            function nodeIsFragment(node) {
+              return node.nodeType === FRAGMENT_NODE;
+            }
+            const serialize = (node, config, indentation, depth, refs, printer) => {
+              if (nodeIsText(node)) {
+                return (0, _markup.printText)(node.data, config);
+              }
+              if (nodeIsComment(node)) {
+                return (0, _markup.printComment)(node.data, config);
+              }
+              const type = nodeIsFragment(node) ? "DocumentFragment" : node.tagName.toLowerCase();
+              if (++depth > config.maxDepth) {
+                return (0, _markup.printElementAsLeaf)(type, config);
+              }
+              return (0, _markup.printElement)(type, (0, _markup.printProps)(nodeIsFragment(node) ? [] : Array.from(node.attributes, (attr) => attr.name).sort(), nodeIsFragment(node) ? {} : [...node.attributes].reduce((props, attribute) => {
+                props[attribute.name] = attribute.value;
+                return props;
+              }, {}), config, indentation + config.indent, depth, refs, printer), (0, _markup.printChildren)(Array.prototype.slice.call(node.childNodes || node.children), config, indentation + config.indent, depth, refs, printer), config, indentation);
+            };
+            exports2.serialize = serialize;
+            const plugin = {
+              serialize,
+              test
+            };
+            exports2["default"] = plugin;
+          })
+        ),
+        /***/
+        "./src/plugins/Immutable.ts": (
+          /***/
+          ((__unused_webpack_module, exports2, __webpack_require__2) => {
+            Object.defineProperty(exports2, "__esModule", {
+              value: true
+            });
+            exports2.test = exports2.serialize = exports2["default"] = void 0;
+            var _collections = __webpack_require__2("./src/collections.ts");
+            const IS_ITERABLE_SENTINEL = "@@__IMMUTABLE_ITERABLE__@@";
+            const IS_LIST_SENTINEL = "@@__IMMUTABLE_LIST__@@";
+            const IS_KEYED_SENTINEL = "@@__IMMUTABLE_KEYED__@@";
+            const IS_MAP_SENTINEL = "@@__IMMUTABLE_MAP__@@";
+            const IS_ORDERED_SENTINEL = "@@__IMMUTABLE_ORDERED__@@";
+            const IS_RECORD_SENTINEL = "@@__IMMUTABLE_RECORD__@@";
+            const IS_SEQ_SENTINEL = "@@__IMMUTABLE_SEQ__@@";
+            const IS_SET_SENTINEL = "@@__IMMUTABLE_SET__@@";
+            const IS_STACK_SENTINEL = "@@__IMMUTABLE_STACK__@@";
+            const getImmutableName = (name) => `Immutable.${name}`;
+            const printAsLeaf = (name) => `[${name}]`;
+            const SPACE = " ";
+            const LAZY = "\u2026";
+            const printImmutableEntries = (val, config, indentation, depth, refs, printer, type) => ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : `${getImmutableName(type) + SPACE}{${(0, _collections.printIteratorEntries)(val.entries(), config, indentation, depth, refs, printer)}}`;
+            function getRecordEntries(val) {
+              let i = 0;
+              return {
+                next() {
+                  if (i < val._keys.length) {
+                    const key = val._keys[i++];
+                    return {
+                      done: false,
+                      value: [key, val.get(key)]
+                    };
+                  }
+                  return {
+                    done: true,
+                    value: void 0
+                  };
+                }
+              };
+            }
+            const printImmutableRecord = (val, config, indentation, depth, refs, printer) => {
+              const name = getImmutableName(val._name || "Record");
+              return ++depth > config.maxDepth ? printAsLeaf(name) : `${name + SPACE}{${(0, _collections.printIteratorEntries)(getRecordEntries(val), config, indentation, depth, refs, printer)}}`;
+            };
+            const printImmutableSeq = (val, config, indentation, depth, refs, printer) => {
+              const name = getImmutableName("Seq");
+              if (++depth > config.maxDepth) {
+                return printAsLeaf(name);
+              }
+              if (val[IS_KEYED_SENTINEL]) {
+                return `${name + SPACE}{${// from Immutable collection of entries or from ECMAScript object
+                val._iter || val._object ? (0, _collections.printIteratorEntries)(val.entries(), config, indentation, depth, refs, printer) : LAZY}}`;
+              }
+              return `${name + SPACE}[${val._iter || // from Immutable collection of values
+              val._array || // from ECMAScript array
+              val._collection || // from ECMAScript collection in immutable v4
+              val._iterable ? (0, _collections.printIteratorValues)(val.values(), config, indentation, depth, refs, printer) : LAZY}]`;
+            };
+            const printImmutableValues = (val, config, indentation, depth, refs, printer, type) => ++depth > config.maxDepth ? printAsLeaf(getImmutableName(type)) : `${getImmutableName(type) + SPACE}[${(0, _collections.printIteratorValues)(val.values(), config, indentation, depth, refs, printer)}]`;
+            const serialize = (val, config, indentation, depth, refs, printer) => {
+              if (val[IS_MAP_SENTINEL]) {
+                return printImmutableEntries(val, config, indentation, depth, refs, printer, val[IS_ORDERED_SENTINEL] ? "OrderedMap" : "Map");
+              }
+              if (val[IS_LIST_SENTINEL]) {
+                return printImmutableValues(val, config, indentation, depth, refs, printer, "List");
+              }
+              if (val[IS_SET_SENTINEL]) {
+                return printImmutableValues(val, config, indentation, depth, refs, printer, val[IS_ORDERED_SENTINEL] ? "OrderedSet" : "Set");
+              }
+              if (val[IS_STACK_SENTINEL]) {
+                return printImmutableValues(val, config, indentation, depth, refs, printer, "Stack");
+              }
+              if (val[IS_SEQ_SENTINEL]) {
+                return printImmutableSeq(val, config, indentation, depth, refs, printer);
+              }
+              return printImmutableRecord(val, config, indentation, depth, refs, printer);
+            };
+            exports2.serialize = serialize;
+            const test = (val) => val && (val[IS_ITERABLE_SENTINEL] === true || val[IS_RECORD_SENTINEL] === true);
+            exports2.test = test;
+            const plugin = {
+              serialize,
+              test
+            };
+            exports2["default"] = plugin;
+          })
+        ),
+        /***/
+        "./src/plugins/ReactElement.ts": (
+          /***/
+          ((__unused_webpack_module, exports2, __webpack_require__2) => {
+            Object.defineProperty(exports2, "__esModule", {
+              value: true
+            });
+            exports2.test = exports2.serialize = exports2["default"] = void 0;
+            var ReactIs = _interopRequireWildcard(require_react_is());
+            var _markup = __webpack_require__2("./src/plugins/lib/markup.ts");
+            function _interopRequireWildcard(e, t) {
+              if ("function" == typeof WeakMap) var r = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakMap();
+              return (_interopRequireWildcard = function(e2, t2) {
+                if (!t2 && e2 && e2.__esModule) return e2;
+                var o, i, f = { __proto__: null, default: e2 };
+                if (null === e2 || "object" != typeof e2 && "function" != typeof e2) return f;
+                if (o = t2 ? n : r) {
+                  if (o.has(e2)) return o.get(e2);
+                  o.set(e2, f);
+                }
+                for (const t3 in e2) "default" !== t3 && {}.hasOwnProperty.call(e2, t3) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e2, t3)) && (i.get || i.set) ? o(f, t3, i) : f[t3] = e2[t3]);
+                return f;
+              })(e, t);
+            }
+            const getChildren = (arg, children = []) => {
+              if (Array.isArray(arg)) {
+                for (const item of arg) {
+                  getChildren(item, children);
+                }
+              } else if (arg != null && arg !== false && arg !== "") {
+                children.push(arg);
+              }
+              return children;
+            };
+            const getType = (element) => {
+              const type = element.type;
+              if (typeof type === "string") {
+                return type;
+              }
+              if (typeof type === "function") {
+                return type.displayName || type.name || "Unknown";
+              }
+              if (ReactIs.isFragment(element)) {
+                return "React.Fragment";
+              }
+              if (ReactIs.isSuspense(element)) {
+                return "React.Suspense";
+              }
+              if (typeof type === "object" && type !== null) {
+                if (ReactIs.isContextProvider(element)) {
+                  return "Context.Provider";
+                }
+                if (ReactIs.isContextConsumer(element)) {
+                  return "Context.Consumer";
+                }
+                if (ReactIs.isForwardRef(element)) {
+                  if (type.displayName) {
+                    return type.displayName;
+                  }
+                  const functionName = type.render.displayName || type.render.name || "";
+                  return functionName === "" ? "ForwardRef" : `ForwardRef(${functionName})`;
+                }
+                if (ReactIs.isMemo(element)) {
+                  const functionName = type.displayName || type.type.displayName || type.type.name || "";
+                  return functionName === "" ? "Memo" : `Memo(${functionName})`;
+                }
+              }
+              return "UNDEFINED";
+            };
+            const getPropKeys = (element) => {
+              const {
+                props
+              } = element;
+              return Object.keys(props).filter((key) => key !== "children" && props[key] !== void 0).sort();
+            };
+            const serialize = (element, config, indentation, depth, refs, printer) => ++depth > config.maxDepth ? (0, _markup.printElementAsLeaf)(getType(element), config) : (0, _markup.printElement)(getType(element), (0, _markup.printProps)(getPropKeys(element), element.props, config, indentation + config.indent, depth, refs, printer), (0, _markup.printChildren)(getChildren(element.props.children), config, indentation + config.indent, depth, refs, printer), config, indentation);
+            exports2.serialize = serialize;
+            const test = (val) => val != null && ReactIs.isElement(val);
+            exports2.test = test;
+            const plugin = {
+              serialize,
+              test
+            };
+            exports2["default"] = plugin;
+          })
+        ),
+        /***/
+        "./src/plugins/ReactTestComponent.ts": (
+          /***/
+          ((__unused_webpack_module, exports2, __webpack_require__2) => {
+            Object.defineProperty(exports2, "__esModule", {
+              value: true
+            });
+            exports2.test = exports2.serialize = exports2["default"] = void 0;
+            var _markup = __webpack_require__2("./src/plugins/lib/markup.ts");
+            var Symbol2 = globalThis["jest-symbol-do-not-touch"] || globalThis.Symbol;
+            const testSymbol = typeof Symbol2 === "function" && Symbol2.for ? Symbol2.for("react.test.json") : 245830487;
+            const getPropKeys = (object) => {
+              const {
+                props
+              } = object;
+              return props ? Object.keys(props).filter((key) => props[key] !== void 0).sort() : [];
+            };
+            const serialize = (object, config, indentation, depth, refs, printer) => ++depth > config.maxDepth ? (0, _markup.printElementAsLeaf)(object.type, config) : (0, _markup.printElement)(object.type, object.props ? (0, _markup.printProps)(getPropKeys(object), object.props, config, indentation + config.indent, depth, refs, printer) : "", object.children ? (0, _markup.printChildren)(object.children, config, indentation + config.indent, depth, refs, printer) : "", config, indentation);
+            exports2.serialize = serialize;
+            const test = (val) => val && val.$$typeof === testSymbol;
+            exports2.test = test;
+            const plugin = {
+              serialize,
+              test
+            };
+            exports2["default"] = plugin;
+          })
+        ),
+        /***/
+        "./src/plugins/lib/escapeHTML.ts": (
+          /***/
+          ((__unused_webpack_module, exports2) => {
+            Object.defineProperty(exports2, "__esModule", {
+              value: true
+            });
+            exports2["default"] = escapeHTML;
+            function escapeHTML(str) {
+              return str.replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+            }
+          })
+        ),
+        /***/
+        "./src/plugins/lib/markup.ts": (
+          /***/
+          ((__unused_webpack_module, exports2, __webpack_require__2) => {
+            Object.defineProperty(exports2, "__esModule", {
+              value: true
+            });
+            exports2.printText = exports2.printProps = exports2.printElementAsLeaf = exports2.printElement = exports2.printComment = exports2.printChildren = void 0;
+            var _escapeHTML = _interopRequireDefault(__webpack_require__2("./src/plugins/lib/escapeHTML.ts"));
+            function _interopRequireDefault(e) {
+              return e && e.__esModule ? e : { default: e };
+            }
+            const printProps = (keys, props, config, indentation, depth, refs, printer) => {
+              const indentationNext = indentation + config.indent;
+              const colors = config.colors;
+              return keys.map((key) => {
+                const value = props[key];
+                let printed = printer(value, config, indentationNext, depth, refs);
+                if (typeof value !== "string") {
+                  if (printed.includes("\n")) {
+                    printed = config.spacingOuter + indentationNext + printed + config.spacingOuter + indentation;
+                  }
+                  printed = `{${printed}}`;
+                }
+                return `${config.spacingInner + indentation + colors.prop.open + key + colors.prop.close}=${colors.value.open}${printed}${colors.value.close}`;
+              }).join("");
+            };
+            exports2.printProps = printProps;
+            const printChildren = (children, config, indentation, depth, refs, printer) => children.map((child) => config.spacingOuter + indentation + (typeof child === "string" ? printText(child, config) : printer(child, config, indentation, depth, refs))).join("");
+            exports2.printChildren = printChildren;
+            const printText = (text, config) => {
+              const contentColor = config.colors.content;
+              return contentColor.open + (0, _escapeHTML.default)(text) + contentColor.close;
+            };
+            exports2.printText = printText;
+            const printComment = (comment, config) => {
+              const commentColor = config.colors.comment;
+              return `${commentColor.open}<!--${(0, _escapeHTML.default)(comment)}-->${commentColor.close}`;
+            };
+            exports2.printComment = printComment;
+            const printElement = (type, printedProps, printedChildren, config, indentation) => {
+              const tagColor = config.colors.tag;
+              return `${tagColor.open}<${type}${printedProps && tagColor.close + printedProps + config.spacingOuter + indentation + tagColor.open}${printedChildren ? `>${tagColor.close}${printedChildren}${config.spacingOuter}${indentation}${tagColor.open}</${type}` : `${printedProps && !config.min ? "" : " "}/`}>${tagColor.close}`;
+            };
+            exports2.printElement = printElement;
+            const printElementAsLeaf = (type, config) => {
+              const tagColor = config.colors.tag;
+              return `${tagColor.open}<${type}${tagColor.close} \u2026${tagColor.open} />${tagColor.close}`;
+            };
+            exports2.printElementAsLeaf = printElementAsLeaf;
+          })
+        )
+        /******/
+      };
+      var __webpack_module_cache__ = {};
+      function __webpack_require__(moduleId) {
+        var cachedModule = __webpack_module_cache__[moduleId];
+        if (cachedModule !== void 0) {
+          return cachedModule.exports;
+        }
+        var module2 = __webpack_module_cache__[moduleId] = {
+          /******/
+          // no module.id needed
+          /******/
+          // no module.loaded needed
+          /******/
+          exports: {}
+          /******/
+        };
+        __webpack_modules__[moduleId](module2, module2.exports, __webpack_require__);
+        return module2.exports;
+      }
+      var __webpack_exports__ = {};
+      (() => {
+        var exports2 = __webpack_exports__;
+        Object.defineProperty(exports2, "__esModule", {
+          value: true
+        });
+        exports2["default"] = exports2.DEFAULT_OPTIONS = void 0;
+        exports2.format = format;
+        exports2.plugins = void 0;
+        var _ansiStyles = _interopRequireDefault(require_ansi_styles());
+        var _collections = __webpack_require__("./src/collections.ts");
+        var _AsymmetricMatcher = _interopRequireDefault(__webpack_require__("./src/plugins/AsymmetricMatcher.ts"));
+        var _DOMCollection = _interopRequireDefault(__webpack_require__("./src/plugins/DOMCollection.ts"));
+        var _DOMElement = _interopRequireDefault(__webpack_require__("./src/plugins/DOMElement.ts"));
+        var _Immutable = _interopRequireDefault(__webpack_require__("./src/plugins/Immutable.ts"));
+        var _ReactElement = _interopRequireDefault(__webpack_require__("./src/plugins/ReactElement.ts"));
+        var _ReactTestComponent = _interopRequireDefault(__webpack_require__("./src/plugins/ReactTestComponent.ts"));
+        function _interopRequireDefault(e) {
+          return e && e.__esModule ? e : { default: e };
+        }
+        const src_toString = Object.prototype.toString;
+        const toISOString = Date.prototype.toISOString;
+        const errorToString = Error.prototype.toString;
+        const regExpToString = RegExp.prototype.toString;
+        const getConstructorName = (val) => typeof val.constructor === "function" && val.constructor.name || "Object";
+        const isWindow = (val) => (
+          // eslint-disable-next-line unicorn/prefer-global-this
+          typeof window !== "undefined" && val === window
+        );
+        const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+        const NEWLINE_REGEXP = /\n/gi;
+        class PrettyFormatPluginError extends Error {
+          constructor(message, stack) {
+            super(message);
+            this.stack = stack;
+            this.name = this.constructor.name;
+          }
+        }
+        function isToStringedArrayType(toStringed) {
+          return toStringed === "[object Array]" || toStringed === "[object ArrayBuffer]" || toStringed === "[object DataView]" || toStringed === "[object Float32Array]" || toStringed === "[object Float64Array]" || toStringed === "[object Int8Array]" || toStringed === "[object Int16Array]" || toStringed === "[object Int32Array]" || toStringed === "[object Uint8Array]" || toStringed === "[object Uint8ClampedArray]" || toStringed === "[object Uint16Array]" || toStringed === "[object Uint32Array]";
+        }
+        function printNumber(val) {
+          return Object.is(val, -0) ? "-0" : String(val);
+        }
+        function printBigInt(val) {
+          return String(`${val}n`);
+        }
+        function printFunction(val, printFunctionName) {
+          if (!printFunctionName) {
+            return "[Function]";
+          }
+          return `[Function ${val.name || "anonymous"}]`;
+        }
+        function printSymbol(val) {
+          return String(val).replace(SYMBOL_REGEXP, "Symbol($1)");
+        }
+        function printError(val) {
+          return `[${errorToString.call(val)}]`;
+        }
+        function printBasicValue(val, printFunctionName, escapeRegex, escapeString) {
+          if (val === true || val === false) {
+            return `${val}`;
+          }
+          if (val === void 0) {
+            return "undefined";
+          }
+          if (val === null) {
+            return "null";
+          }
+          const typeOf = typeof val;
+          if (typeOf === "number") {
+            return printNumber(val);
+          }
+          if (typeOf === "bigint") {
+            return printBigInt(val);
+          }
+          if (typeOf === "string") {
+            if (escapeString) {
+              return `"${val.replaceAll(/"|\\/g, "\\$&")}"`;
+            }
+            return `"${val}"`;
+          }
+          if (typeOf === "function") {
+            return printFunction(val, printFunctionName);
+          }
+          if (typeOf === "symbol") {
+            return printSymbol(val);
+          }
+          const toStringed = src_toString.call(val);
+          if (toStringed === "[object Promise]") {
+            return "Promise {}";
+          }
+          if (toStringed === "[object WeakMap]") {
+            return "WeakMap {}";
+          }
+          if (toStringed === "[object WeakSet]") {
+            return "WeakSet {}";
+          }
+          if (toStringed === "[object Function]" || toStringed === "[object GeneratorFunction]") {
+            return printFunction(val, printFunctionName);
+          }
+          if (toStringed === "[object Symbol]") {
+            return printSymbol(val);
+          }
+          if (toStringed === "[object Date]") {
+            return Number.isNaN(+val) ? "Date { NaN }" : toISOString.call(val);
+          }
+          if (toStringed === "[object Error]") {
+            return printError(val);
+          }
+          if (toStringed === "[object RegExp]") {
+            if (escapeRegex) {
+              return regExpToString.call(val).replaceAll(/[$()*+.?[\\\]^{|}]/g, "\\$&");
+            }
+            return regExpToString.call(val);
+          }
+          if (val instanceof Error) {
+            return printError(val);
+          }
+          return null;
+        }
+        function printComplexValue(val, config, indentation, depth, refs, hasCalledToJSON) {
+          if (refs.includes(val)) {
+            return "[Circular]";
+          }
+          refs = [...refs];
+          refs.push(val);
+          const hitMaxDepth = ++depth > config.maxDepth;
+          const min = config.min;
+          if (config.callToJSON && !hitMaxDepth && val.toJSON && typeof val.toJSON === "function" && !hasCalledToJSON) {
+            return printer(val.toJSON(), config, indentation, depth, refs, true);
+          }
+          const toStringed = src_toString.call(val);
+          if (toStringed === "[object Arguments]") {
+            return hitMaxDepth ? "[Arguments]" : `${min ? "" : "Arguments "}[${(0, _collections.printListItems)(val, config, indentation, depth, refs, printer)}]`;
+          }
+          if (isToStringedArrayType(toStringed)) {
+            return hitMaxDepth ? `[${val.constructor.name}]` : `${min ? "" : !config.printBasicPrototype && val.constructor.name === "Array" ? "" : `${val.constructor.name} `}[${(0, _collections.printListItems)(val, config, indentation, depth, refs, printer)}]`;
+          }
+          if (toStringed === "[object Map]") {
+            return hitMaxDepth ? "[Map]" : `Map {${(0, _collections.printIteratorEntries)(val.entries(), config, indentation, depth, refs, printer, " => ")}}`;
+          }
+          if (toStringed === "[object Set]") {
+            return hitMaxDepth ? "[Set]" : `Set {${(0, _collections.printIteratorValues)(val.values(), config, indentation, depth, refs, printer)}}`;
+          }
+          return hitMaxDepth || isWindow(val) ? `[${getConstructorName(val)}]` : `${min ? "" : !config.printBasicPrototype && getConstructorName(val) === "Object" ? "" : `${getConstructorName(val)} `}{${(0, _collections.printObjectProperties)(val, config, indentation, depth, refs, printer)}}`;
+        }
+        function isNewPlugin(plugin) {
+          return plugin.serialize != null;
+        }
+        function printPlugin(plugin, val, config, indentation, depth, refs) {
+          let printed;
+          try {
+            printed = isNewPlugin(plugin) ? plugin.serialize(val, config, indentation, depth, refs, printer) : plugin.print(val, (valChild) => printer(valChild, config, indentation, depth, refs), (str) => {
+              const indentationNext = indentation + config.indent;
+              return indentationNext + str.replaceAll(NEWLINE_REGEXP, `
+${indentationNext}`);
+            }, {
+              edgeSpacing: config.spacingOuter,
+              min: config.min,
+              spacing: config.spacingInner
+            }, config.colors);
+          } catch (error) {
+            throw new PrettyFormatPluginError(error.message, error.stack);
+          }
+          if (typeof printed !== "string") {
+            throw new TypeError(`pretty-format: Plugin must return type "string" but instead returned "${typeof printed}".`);
+          }
+          return printed;
+        }
+        function findPlugin(plugins2, val) {
+          for (const plugin of plugins2) {
+            try {
+              if (plugin.test(val)) {
+                return plugin;
+              }
+            } catch (error) {
+              throw new PrettyFormatPluginError(error.message, error.stack);
+            }
+          }
+          return null;
+        }
+        function printer(val, config, indentation, depth, refs, hasCalledToJSON) {
+          const plugin = findPlugin(config.plugins, val);
+          if (plugin !== null) {
+            return printPlugin(plugin, val, config, indentation, depth, refs);
+          }
+          const basicResult = printBasicValue(val, config.printFunctionName, config.escapeRegex, config.escapeString);
+          if (basicResult !== null) {
+            return basicResult;
+          }
+          return printComplexValue(val, config, indentation, depth, refs, hasCalledToJSON);
+        }
+        const DEFAULT_THEME = {
+          comment: "gray",
+          content: "reset",
+          prop: "yellow",
+          tag: "cyan",
+          value: "green"
+        };
+        const DEFAULT_THEME_KEYS = Object.keys(DEFAULT_THEME);
+        const toOptionsSubtype = (options) => options;
+        const DEFAULT_OPTIONS = exports2.DEFAULT_OPTIONS = toOptionsSubtype({
+          callToJSON: true,
+          compareKeys: void 0,
+          escapeRegex: false,
+          escapeString: true,
+          highlight: false,
+          indent: 2,
+          maxDepth: Number.POSITIVE_INFINITY,
+          maxWidth: Number.POSITIVE_INFINITY,
+          min: false,
+          plugins: [],
+          printBasicPrototype: true,
+          printFunctionName: true,
+          theme: DEFAULT_THEME
+        });
+        function validateOptions(options) {
+          for (const key of Object.keys(options)) {
+            if (!Object.prototype.hasOwnProperty.call(DEFAULT_OPTIONS, key)) {
+              throw new Error(`pretty-format: Unknown option "${key}".`);
+            }
+          }
+          if (options.min && options.indent !== void 0 && options.indent !== 0) {
+            throw new Error('pretty-format: Options "min" and "indent" cannot be used together.');
+          }
+          if (options.theme !== void 0) {
+            if (options.theme === null) {
+              throw new Error('pretty-format: Option "theme" must not be null.');
+            }
+            if (typeof options.theme !== "object") {
+              throw new TypeError(`pretty-format: Option "theme" must be of type "object" but instead received "${typeof options.theme}".`);
+            }
+          }
+        }
+        const getColorsHighlight = (options) => DEFAULT_THEME_KEYS.reduce((colors, key) => {
+          const value = options.theme && options.theme[key] !== void 0 ? options.theme[key] : DEFAULT_THEME[key];
+          const color = value && _ansiStyles.default[value];
+          if (color && typeof color.close === "string" && typeof color.open === "string") {
+            colors[key] = color;
+          } else {
+            throw new Error(`pretty-format: Option "theme" has a key "${key}" whose value "${value}" is undefined in ansi-styles.`);
+          }
+          return colors;
+        }, /* @__PURE__ */ Object.create(null));
+        const getColorsEmpty = () => DEFAULT_THEME_KEYS.reduce((colors, key) => {
+          colors[key] = {
+            close: "",
+            open: ""
+          };
+          return colors;
+        }, /* @__PURE__ */ Object.create(null));
+        const getPrintFunctionName = (options) => options?.printFunctionName ?? DEFAULT_OPTIONS.printFunctionName;
+        const getEscapeRegex = (options) => options?.escapeRegex ?? DEFAULT_OPTIONS.escapeRegex;
+        const getEscapeString = (options) => options?.escapeString ?? DEFAULT_OPTIONS.escapeString;
+        const getConfig = (options) => ({
+          callToJSON: options?.callToJSON ?? DEFAULT_OPTIONS.callToJSON,
+          colors: options?.highlight ? getColorsHighlight(options) : getColorsEmpty(),
+          compareKeys: typeof options?.compareKeys === "function" || options?.compareKeys === null ? options.compareKeys : DEFAULT_OPTIONS.compareKeys,
+          escapeRegex: getEscapeRegex(options),
+          escapeString: getEscapeString(options),
+          indent: options?.min ? "" : createIndent(options?.indent ?? DEFAULT_OPTIONS.indent),
+          maxDepth: options?.maxDepth ?? DEFAULT_OPTIONS.maxDepth,
+          maxWidth: options?.maxWidth ?? DEFAULT_OPTIONS.maxWidth,
+          min: options?.min ?? DEFAULT_OPTIONS.min,
+          plugins: options?.plugins ?? DEFAULT_OPTIONS.plugins,
+          printBasicPrototype: options?.printBasicPrototype ?? true,
+          printFunctionName: getPrintFunctionName(options),
+          spacingInner: options?.min ? " " : "\n",
+          spacingOuter: options?.min ? "" : "\n"
+        });
+        function createIndent(indent) {
+          return Array.from({
+            length: indent + 1
+          }).join(" ");
+        }
+        function format(val, options) {
+          if (options) {
+            validateOptions(options);
+            if (options.plugins) {
+              const plugin = findPlugin(options.plugins, val);
+              if (plugin !== null) {
+                return printPlugin(plugin, val, getConfig(options), "", 0, []);
+              }
+            }
+          }
+          const basicResult = printBasicValue(val, getPrintFunctionName(options), getEscapeRegex(options), getEscapeString(options));
+          if (basicResult !== null) {
+            return basicResult;
+          }
+          return printComplexValue(val, getConfig(options), "", 0, []);
+        }
+        exports2.plugins = {
+          AsymmetricMatcher: _AsymmetricMatcher.default,
+          DOMCollection: _DOMCollection.default,
+          DOMElement: _DOMElement.default,
+          Immutable: _Immutable.default,
+          ReactElement: _ReactElement.default,
+          ReactTestComponent: _ReactTestComponent.default
+        };
+        exports2["default"] = format;
+      })();
+      module.exports = __webpack_exports__;
+    })();
+  }
+});
 
 // src/utils/validates.ts
 function isBase64(link) {
   if (!link || typeof link !== "string") return false;
+  if (link.length < 18) return false;
   return link.startsWith("data:image/") && link.includes(";base64");
 }
+
+// src/formatter.ts
+var import_pretty_format = __toESM(require_build());
+var prettyFormat = typeof import_pretty_format.default === "function" ? import_pretty_format.default : import_pretty_format.default.format;
+var EXCLUDED_ERROR_PROPS = /* @__PURE__ */ new Set(["name", "message", "stack", "cause"]);
 var Formatter = class {
   /**
    * Check if a field should be filtered based on configured rules
@@ -99,23 +1447,26 @@ var Formatter = class {
    * Sanitize sensitive data from stack traces
    */
   static sanitizeStackTrace(stack, customPatterns) {
-    const defaultPatterns = [
-      /([?&])(token|key|secret|password|auth|api[_-]?key|access[_-]?token|client[_-]?secret)=[^&\s)#]*/gi,
-      /\/\/[^/]*:[^@]*@/g,
-      // Basic auth in URLs (user:pass@domain)
-      /(bearer\s+)[a-zA-Z0-9\-._~+/]+=*/gi
-      // Bearer tokens
-    ];
-    const allPatterns = [...defaultPatterns, ...customPatterns || []];
-    let sanitized = stack;
-    allPatterns.forEach((pattern) => {
-      sanitized = sanitized.replace(pattern, (match, p1) => {
-        if (p1) {
-          return `${p1}***REDACTED***`;
-        }
-        return "***REDACTED***";
-      });
+    const combinedDefaultPattern = /([?&])(token|key|secret|password|auth|api[_-]?key|access[_-]?token|client[_-]?secret)=[^&\s)#]*|\/\/[^/]*:[^@]*@|(bearer\s+)[a-zA-Z0-9\-._~+/]+=*/gi;
+    let sanitized = stack.replace(combinedDefaultPattern, (match, urlParam, _tokenKey, bearer) => {
+      if (urlParam) {
+        return `${urlParam}***REDACTED***`;
+      }
+      if (bearer) {
+        return `${bearer}***REDACTED***`;
+      }
+      return "***REDACTED***";
     });
+    if (customPatterns && customPatterns.length > 0) {
+      for (const pattern of customPatterns) {
+        sanitized = sanitized.replace(pattern, (match, p1) => {
+          if (p1) {
+            return `${p1}***REDACTED***`;
+          }
+          return "***REDACTED***";
+        });
+      }
+    }
     return sanitized;
   }
   /**
@@ -156,14 +1507,14 @@ var Formatter = class {
     if (includeCause && error.cause !== void 0) {
       if (error.cause instanceof Error) {
         const serializedCause = this.serializeError(error.cause, config, currentDepth + 1);
-        serialized.cause = typeof serializedCause === "string" ? serializedCause : serializedCause;
+        serialized.cause = typeof serializedCause === "string" ? { name: "Error", message: serializedCause } : serializedCause;
       } else {
         serialized.cause = error.cause;
       }
     }
     for (const key in error) {
       if (Object.prototype.hasOwnProperty.call(error, key)) {
-        if (!["name", "message", "stack", "cause"].includes(key)) {
+        if (!EXCLUDED_ERROR_PROPS.has(key)) {
           const errorWithCustomProps = error;
           serialized[key] = errorWithCustomProps[key];
         }
@@ -213,14 +1564,15 @@ var Formatter = class {
     if (obj instanceof Error) {
       return this.serializeError(obj, filterOptions?.errorConfig, 0);
     }
-    if (typeof obj === "string" && isBase64(obj)) {
-      return this.formatBase64String(obj);
-    }
-    if (obj instanceof Blob) {
-      return {
-        size: obj.size,
-        type: obj.type
-      };
+    if (typeof obj === "string") {
+      if (isBase64(obj)) {
+        return this.formatBase64String(obj);
+      }
+      const stringLimit = filterOptions?.truncate?.string;
+      if (stringLimit !== void 0 && obj.length > stringLimit) {
+        return `${obj.slice(0, stringLimit)}... [${obj.length} chars]`;
+      }
+      return obj;
     }
     if (obj instanceof File) {
       return {
@@ -230,8 +1582,17 @@ var Formatter = class {
         lastModified: obj.lastModified
       };
     }
+    if (obj instanceof Blob) {
+      return {
+        size: obj.size,
+        type: obj.type
+      };
+    }
     if (Array.isArray(obj)) {
-      return obj.map(
+      const arrayLimit = filterOptions?.truncate?.array;
+      const sourceItems = arrayLimit !== void 0 && obj.length > arrayLimit ? obj.slice(0, arrayLimit) : obj;
+      const remainder = obj.length - sourceItems.length;
+      const result = sourceItems.map(
         (item, index) => this.serializeSpecialObjects(
           item,
           maxDepth,
@@ -240,55 +1601,64 @@ var Formatter = class {
           [...currentPath, `[${index}]`]
         )
       );
+      if (remainder > 0) {
+        result.push(`... +${remainder} more`);
+      }
+      return result;
     }
     if (obj !== null && typeof obj === "object") {
       const serialized = {};
+      const fieldLimit = filterOptions?.truncate?.fields;
+      const includableEntries = [];
       for (const key in obj) {
         if (Object.prototype.hasOwnProperty.call(obj, key)) {
           const value = obj[key];
-          const newPath = [...currentPath, key];
-          const { include, filtered } = this.shouldIncludeField(
-            key,
+          const { include, filtered } = this.shouldIncludeField(key, value, currentPath, filterOptions);
+          if (include) {
+            includableEntries.push({ key, value, filtered });
+          }
+        }
+      }
+      const visibleCount = fieldLimit !== void 0 ? Math.min(fieldLimit, includableEntries.length) : includableEntries.length;
+      const remainder = includableEntries.length - visibleCount;
+      for (let i = 0; i < visibleCount; i++) {
+        const { key, value, filtered } = includableEntries[i];
+        const newPath = [...currentPath, key];
+        let isGloballyFiltered = false;
+        if (filterOptions?.filterFields && filterOptions.filterFields.length > 0) {
+          isGloballyFiltered = this.shouldFilterField(key, value, currentPath, filterOptions.filterFields);
+        }
+        if (isGloballyFiltered) {
+          const filteredValue = this.getFilteredValue(
             value,
-            currentPath,
-            filterOptions
+            filterOptions?.globalFilterMode,
+            filterOptions?.globalFilterReplacement
           );
-          if (!include) {
-            continue;
-          }
-          let isGloballyFiltered = false;
-          if (filterOptions?.filterFields && filterOptions.filterFields.length > 0) {
-            isGloballyFiltered = this.shouldFilterField(key, value, currentPath, filterOptions.filterFields);
-          }
-          if (isGloballyFiltered) {
-            const filteredValue = this.getFilteredValue(
-              value,
-              filterOptions?.globalFilterMode,
-              filterOptions?.globalFilterReplacement
-            );
-            if (filteredValue !== void 0) {
-              serialized[key] = filteredValue;
-            }
-          } else if (filtered) {
-            const filteredValue = this.getFilteredValue(
-              value,
-              filterOptions?.filterMode,
-              filterOptions?.filterReplacement
-            );
-            if (filteredValue !== void 0) {
-              serialized[key] = filteredValue;
-            }
-          } else {
-            serialized[key] = this.serializeSpecialObjects(
-              value,
-              maxDepth,
-              currentDepth + 1,
-              filterOptions,
-              newPath
-            );
+          if (filteredValue !== void 0) {
+            serialized[key] = filteredValue;
           }
+        } else if (filtered) {
+          const filteredValue = this.getFilteredValue(
+            value,
+            filterOptions?.filterMode,
+            filterOptions?.filterReplacement
+          );
+          if (filteredValue !== void 0) {
+            serialized[key] = filteredValue;
+          }
+        } else {
+          serialized[key] = this.serializeSpecialObjects(
+            value,
+            maxDepth,
+            currentDepth + 1,
+            filterOptions,
+            newPath
+          );
         }
       }
+      if (remainder > 0) {
+        serialized["..."] = `+${remainder} more fields`;
+      }
       return serialized;
     }
     return obj;
@@ -317,15 +1687,16 @@ var Formatter = class {
             filterReplacement: options?.filterReplacement,
             globalFilterMode: options?.globalFilterMode,
             globalFilterReplacement: options?.globalFilterReplacement,
-            errorConfig: options?.errorConfig
+            errorConfig: options?.errorConfig,
+            truncate: options?.truncate
           }
         );
-        const formatted = prettyFormat.format(serialized, {
+        const formatted = prettyFormat(serialized, {
           indent: 2,
           maxDepth,
-          // Remove Object and Array labels
           printFunctionName: false,
-          printBasicPrototype: false
+          printBasicPrototype: false,
+          compareKeys: null
         });
         const cleaned = formatted.replace(/^Object\s*/, "").replace(/^Array\s*/, "").replace(/\nObject\s*/g, "\n").replace(/\nArray\s*/g, "\n");
         return "\n" + cleaned;
@@ -392,56 +1763,41 @@ var styler_default = Styler;
 // src/namespace-matcher.ts
 var NamespaceMatcher = class {
   constructor() {
-    this.cachedPatterns = null;
+    this.cachedPositivePatterns = [];
+    this.cachedNegativePatterns = [];
     this.cachedConfig = void 0;
   }
   matches(namespace, namespaces) {
     const ns = this.normalize(namespace);
     if (this.cachedConfig !== namespaces) {
-      this.cachedPatterns = this.parsePatterns(namespaces);
+      this.parseAndCachePatterns(namespaces);
       this.cachedConfig = namespaces;
     }
-    const enabledNamespaces = this.cachedPatterns || [];
-    if (!enabledNamespaces.length) return true;
-    const positivePatterns = [];
-    const negativePatterns = [];
-    for (const pattern of enabledNamespaces) {
-      if (pattern.startsWith("-")) {
-        negativePatterns.push(pattern.slice(1));
-      } else {
-        positivePatterns.push(pattern);
-      }
-    }
-    const matches = positivePatterns.some((pattern) => {
-      if (pattern === "*") return true;
-      const normalizedPattern = this.normalize(pattern);
-      if (pattern.includes("*")) {
-        const regex = new RegExp("^" + normalizedPattern.replace(/\*/g, ".*") + "$");
-        if (regex.test(ns)) return true;
-        const basePattern = normalizedPattern.split(":")[0];
-        if (ns === basePattern && normalizedPattern.startsWith(basePattern + ":")) {
+    if (!this.cachedPositivePatterns.length) return true;
+    const matches = this.cachedPositivePatterns.some((entry) => {
+      if (entry.pattern === "*") return true;
+      if (entry.regex) {
+        if (entry.regex.test(ns)) return true;
+        if (entry.basePattern && ns === entry.basePattern) {
           return true;
         }
         return false;
       }
-      return ns === normalizedPattern;
+      return ns === entry.pattern;
     });
     if (!matches) return false;
-    for (const negPattern of negativePatterns) {
-      const neg = this.normalize(negPattern);
-      if (neg.includes("*")) {
-        const regex = new RegExp("^" + neg.replace(/\*/g, ".*") + "$");
-        if (regex.test(ns)) {
+    for (const entry of this.cachedNegativePatterns) {
+      if (entry.regex) {
+        if (entry.regex.test(ns)) {
           return false;
         }
-        const negPrefix = this.normalize(neg.replace(/\*.*$/, ""));
-        if (negPrefix) {
-          if (ns === negPrefix || ns.startsWith(negPrefix + ":")) {
+        if (entry.prefix) {
+          if (ns === entry.prefix || ns.startsWith(entry.prefix + ":")) {
             return false;
           }
         }
       } else {
-        if (ns.startsWith(neg)) {
+        if (ns.startsWith(entry.pattern)) {
           return false;
         }
       }
@@ -452,9 +1808,47 @@ var NamespaceMatcher = class {
     if (!value) return "";
     return value.replace(/:+$/, "");
   }
-  parsePatterns(namespaces) {
-    if (!namespaces) return [];
-    return namespaces.split(",").map((s) => this.normalize(s.trim()));
+  parseAndCachePatterns(namespaces) {
+    this.cachedPositivePatterns = [];
+    this.cachedNegativePatterns = [];
+    if (!namespaces) return;
+    const patterns = namespaces.split(",").map((s) => this.normalize(s.trim()));
+    for (const pattern of patterns) {
+      if (pattern.startsWith("-")) {
+        const negPattern = pattern.slice(1);
+        const normalized = this.normalize(negPattern);
+        if (normalized.includes("*")) {
+          const escaped = normalized.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+          const regex = new RegExp("^" + escaped + "$");
+          const prefix = this.normalize(normalized.replace(/\*.*$/, ""));
+          this.cachedNegativePatterns.push({
+            pattern: normalized,
+            regex,
+            prefix: prefix || void 0
+          });
+        } else {
+          this.cachedNegativePatterns.push({
+            pattern: normalized
+          });
+        }
+      } else {
+        const normalized = this.normalize(pattern);
+        if (normalized.includes("*")) {
+          const escaped = normalized.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+          const regex = new RegExp("^" + escaped + "$");
+          const basePattern = normalized.split(":")[0];
+          this.cachedPositivePatterns.push({
+            pattern: normalized,
+            regex,
+            basePattern: normalized.startsWith(basePattern + ":") ? basePattern : void 0
+          });
+        } else {
+          this.cachedPositivePatterns.push({
+            pattern: normalized
+          });
+        }
+      }
+    }
   }
 };
 var namespaceMatcher = new NamespaceMatcher();
@@ -497,6 +1891,13 @@ var dedup_hasher_default = DedupHasher;
 
 // src/logger.ts
 var globalConfig = {};
+var LEVEL_PRIORITIES = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  none: 4
+};
 function configure(options) {
   globalConfig = { ...globalConfig, ...options };
 }
@@ -513,6 +1914,7 @@ var Logger = class {
     this._namespace = options.namespace ?? DEFAULT_NAMESPACE;
     this._level = options.level ?? globalConfig.level ?? "debug";
     this._maxDepth = options.maxDepth ?? globalConfig.maxDepth ?? 10;
+    this._truncateConfig = options.truncate;
     this._context = options.context ?? {};
     this._dedupConfig = {
       ...DEFAULT_DEDUP_CONFIG,
@@ -554,6 +1956,9 @@ var Logger = class {
   assert(condition, message, ...args) {
     if (!condition) {
       this.log("error", message, ...args);
+    } else {
+      this._tempConditions = [];
+      this._tempFilterOptions = {};
     }
     return this;
   }
@@ -583,6 +1988,24 @@ var Logger = class {
     this._maxDepth = maxDepth;
     return this;
   }
+  /**
+   * Truncate large objects/arrays/strings before logging.
+   * Accepts a number (shorthand for fields limit) or a config object.
+   *
+   * @param config - Max field count (number) or { fields, string, array } limits
+   * @returns this for chaining
+   *
+   * @example
+   * // Limit to 5 fields per object
+   * logger.truncate(5).debug('User', user);
+   *
+   * // Fine-grained control
+   * logger.truncate({ fields: 5, string: 80, array: 3 }).debug('Order', order);
+   */
+  truncate(config) {
+    this._tempFilterOptions.truncate = typeof config === "number" ? { fields: config } : config;
+    return this;
+  }
   /**
    * Pick only specific fields to log (whitelist approach)
    * Supports dot notation for nested fields: 'user.name', 'user.email'
@@ -665,14 +2088,7 @@ var Logger = class {
     return this;
   }
   getLevelPriority(level) {
-    const priorities = {
-      debug: 0,
-      info: 1,
-      warn: 2,
-      error: 3,
-      none: 4
-    };
-    return priorities[level];
+    return LEVEL_PRIORITIES[level];
   }
   log(level, message, ...args) {
     if (this._tempConditions.length > 0) {
@@ -700,15 +2116,16 @@ var Logger = class {
     } else if (this.getLevelPriority(this._level) > this.getLevelPriority(level)) {
       return;
     }
-    const filterOptions = { ...this._tempFilterOptions };
+    const filterOptions = this._tempFilterOptions;
     this._tempFilterOptions = {};
+    const timestamp = Date.now();
     if (this._dedupConfig.enabled) {
-      this.logWithDedup(level, message, filterOptions, ...args);
+      this.logWithDedup(level, message, filterOptions, timestamp, ...args);
     } else {
-      this.logImmediate(level, message, filterOptions, ...args);
+      this.logImmediate(level, message, filterOptions, timestamp, ...args);
     }
   }
-  logWithDedup(level, message, filterOptions, ...args) {
+  logWithDedup(level, message, filterOptions, timestamp, ...args) {
     const key = dedup_hasher_default.generateKey(level, message, args);
     const existing = this._dedupBuffer.get(key);
     const now = Date.now();
@@ -730,7 +2147,7 @@ var Logger = class {
         message,
         args,
         count: 1,
-        firstTimestamp: now,
+        firstTimestamp: timestamp,
         lastTimestamp: now,
         filterOptions
       };
@@ -749,7 +2166,7 @@ var Logger = class {
       const lastTime = this.formatTimestamp(entry.lastTimestamp);
       displayMessage = `${entry.message} (x${entry.count}, ${firstTime} \u2192 ${lastTime})`;
     }
-    this.logImmediate(entry.level, displayMessage, entry.filterOptions || {}, ...entry.args);
+    this.logImmediate(entry.level, displayMessage, entry.filterOptions || {}, entry.firstTimestamp, ...entry.args);
     this._dedupBuffer.delete(key);
   }
   formatTimestamp(timestamp) {
@@ -760,7 +2177,19 @@ var Logger = class {
     const milliseconds = String(date.getMilliseconds()).padStart(3, "0");
     return `${hours}:${minutes}:${seconds}.${milliseconds}`;
   }
-  logImmediate(level, message, filterOptions, ...args) {
+  logImmediate(level, message, filterOptions, timestamp, ...args) {
+    const transports = globalConfig.transports;
+    if (transports && transports.length > 0) {
+      const entry = { namespace: this._namespace, level, message, args, timestamp };
+      for (const transport of transports) {
+        if (!transport.levels || transport.levels.includes(level)) {
+          try {
+            transport.write(entry);
+          } catch {
+          }
+        }
+      }
+    }
     const formattedObject = Formatter.formatObj(args, {
       maxDepth: this._maxDepth,
       // Global filter fields (always applied for security)
@@ -773,7 +2202,9 @@ var Logger = class {
       filterMode: filterOptions.filterMode,
       filterReplacement: filterOptions.filterReplacement,
       // Error serialization config
-      errorConfig: globalConfig.errorSerialization
+      errorConfig: globalConfig.errorSerialization,
+      // Truncation: per-log > instance > global
+      truncate: filterOptions.truncate ?? this._truncateConfig ?? globalConfig.truncate
     });
     const formattedMessage = formattedObject ? `${message} ${formattedObject}` : message;
     const { logMessage, logStyles } = styler_default.style({
@@ -806,6 +2237,40 @@ var plslog = ((options = {}) => {
 });
 plslog.configure = configure;
 var logger_default = plslog;
+/*! Bundled license information:
+
+react-is/cjs/react-is.production.min.js:
+  (**
+   * @license React
+   * react-is.production.min.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+
+react-is/cjs/react-is.development.js:
+  (**
+   * @license React
+   * react-is.development.js
+   *
+   * Copyright (c) Facebook, Inc. and its affiliates.
+   *
+   * This source code is licensed under the MIT license found in the
+   * LICENSE file in the root directory of this source tree.
+   *)
+
+pretty-format/build/index.js:
+  (*!
+   * /**
+   *  * Copyright (c) Meta Platforms, Inc. and affiliates.
+   *  *
+   *  * This source code is licensed under the MIT license found in the
+   *  * LICENSE file in the root directory of this source tree.
+   *  * /
+   *)
+*/
 
 module.exports = logger_default;
 //# sourceMappingURL=index.js.map