plslog 1.0.0 → 1.1.1

package/dist/index.mjs

@@ -1,11 +1,1542 @@
-import { format } from '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.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  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 = format2;
+        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(plugins3, val) {
+          for (const plugin of plugins3) {
+            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_OPTIONS2 = 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_OPTIONS2, 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_OPTIONS2.printFunctionName;
+        const getEscapeRegex = (options) => options?.escapeRegex ?? DEFAULT_OPTIONS2.escapeRegex;
+        const getEscapeString = (options) => options?.escapeString ?? DEFAULT_OPTIONS2.escapeString;
+        const getConfig = (options) => ({
+          callToJSON: options?.callToJSON ?? DEFAULT_OPTIONS2.callToJSON,
+          colors: options?.highlight ? getColorsHighlight(options) : getColorsEmpty(),
+          compareKeys: typeof options?.compareKeys === "function" || options?.compareKeys === null ? options.compareKeys : DEFAULT_OPTIONS2.compareKeys,
+          escapeRegex: getEscapeRegex(options),
+          escapeString: getEscapeString(options),
+          indent: options?.min ? "" : createIndent(options?.indent ?? DEFAULT_OPTIONS2.indent),
+          maxDepth: options?.maxDepth ?? DEFAULT_OPTIONS2.maxDepth,
+          maxWidth: options?.maxWidth ?? DEFAULT_OPTIONS2.maxWidth,
+          min: options?.min ?? DEFAULT_OPTIONS2.min,
+          plugins: options?.plugins ?? DEFAULT_OPTIONS2.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 format2(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"] = format2;
+      })();
+      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");
 }
+
+// ../../node_modules/.pnpm/pretty-format@30.2.0/node_modules/pretty-format/build/index.mjs
+var import_index = __toESM(require_build());
+import_index.default.DEFAULT_OPTIONS;
+var format = import_index.default.format;
+import_index.default.plugins;
+import_index.default.default;
+
+// src/formatter.ts
+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
+   */
+  static shouldFilterField(key, value, path, filterFields) {
+    if (!filterFields || filterFields.length === 0) {
+      return false;
+    }
+    for (const filter of filterFields) {
+      if (typeof filter === "string" && key === filter) {
+        return true;
+      }
+      if (filter instanceof RegExp && filter.test(key)) {
+        return true;
+      }
+      if (typeof filter === "function") {
+        const shouldShow = filter(key, value, path);
+        if (shouldShow === false) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Check if a field should be included based on pick/omit rules
+   */
+  static shouldIncludeField(key, value, path, options) {
+    if (options?.pick && options.pick.length > 0) {
+      const pathWithoutIndices = path.filter((p) => !p.startsWith("["));
+      const fullPath = [...pathWithoutIndices, key].join(".");
+      const isInPickList = options.pick.some((pickPath) => {
+        if (pickPath.endsWith(".*")) {
+          const prefix = pickPath.slice(0, -2);
+          return fullPath.startsWith(prefix + ".") || fullPath === prefix;
+        }
+        if (!pickPath.includes(".") && key === pickPath) {
+          return true;
+        }
+        if (fullPath === pickPath) {
+          return true;
+        }
+        if (pickPath.startsWith(fullPath + ".")) {
+          return true;
+        }
+        if (fullPath.startsWith(pickPath + ".")) {
+          return true;
+        }
+        return false;
+      });
+      if (!isInPickList) {
+        return { include: false, filtered: false };
+      }
+    }
+    if (options?.omit && options.omit.length > 0) {
+      const shouldOmit = this.shouldFilterField(key, value, path, options.omit);
+      if (shouldOmit) {
+        return { include: true, filtered: true };
+      }
+    }
+    return { include: true, filtered: false };
+  }
+  /**
+   * Get the replacement value for a filtered field
+   */
+  static getFilteredValue(value, mode = "redact", replacement = "***REDACTED***") {
+    switch (mode) {
+      case "redact":
+        return replacement;
+      case "type":
+        if (value === null) return "[null]";
+        if (value === void 0) return "[undefined]";
+        if (Array.isArray(value)) return `[Array(${value.length})]`;
+        return `[${typeof value}]`;
+      case "length":
+        if (typeof value === "string") return `[${value.length} chars]`;
+        if (Array.isArray(value)) return `[${value.length} items]`;
+        if (typeof value === "object" && value !== null) {
+          return `[${Object.keys(value).length} keys]`;
+        }
+        return `[${typeof value}]`;
+      case "hide":
+        return void 0;
+      // Will be removed by caller
+      default:
+        return replacement;
+    }
+  }
+  /**
+   * Sanitize sensitive data from stack traces
+   */
+  static sanitizeStackTrace(stack, customPatterns) {
+    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;
+  }
+  /**
+   * Serialize Error objects with all relevant properties (name, message, stack, cause)
+   */
+  static serializeError(error, config, currentDepth = 0) {
+    const maxCauseDepth = config?.maxCauseDepth ?? 10;
+    if (currentDepth > maxCauseDepth) {
+      return "[Max Cause Depth Reached]";
+    }
+    const includeStack = config?.includeStack ?? true;
+    const includeCause = config?.includeCause ?? true;
+    const stackFrameLimit = config?.stackFrameLimit;
+    const sanitizeStack = config?.sanitizeStack ?? false;
+    const serialized = {
+      name: error.name,
+      message: error.message
+    };
+    if ("code" in error) {
+      const errorWithCode = error;
+      if (typeof errorWithCode.code === "number") {
+        serialized.code = errorWithCode.code;
+      }
+    }
+    if (includeStack && error.stack) {
+      let stack = error.stack;
+      if (sanitizeStack) {
+        stack = this.sanitizeStackTrace(stack, config?.sanitizePatterns);
+      }
+      if (stackFrameLimit !== void 0 && stackFrameLimit > 0) {
+        const lines = stack.split("\n");
+        if (lines.length > stackFrameLimit) {
+          stack = lines.slice(0, stackFrameLimit).join("\n") + "\n... (truncated)";
+        }
+      }
+      serialized.stack = stack;
+    }
+    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" ? { name: "Error", message: serializedCause } : serializedCause;
+      } else {
+        serialized.cause = error.cause;
+      }
+    }
+    for (const key in error) {
+      if (Object.prototype.hasOwnProperty.call(error, key)) {
+        if (!EXCLUDED_ERROR_PROPS.has(key)) {
+          const errorWithCustomProps = error;
+          serialized[key] = errorWithCustomProps[key];
+        }
+      }
+    }
+    if (error.name === "AggregateError" && "errors" in error) {
+      const aggregateError = error;
+      if (Array.isArray(aggregateError.errors)) {
+        serialized.errors = aggregateError.errors.map((e) => {
+          if (e instanceof Error) {
+            const serializedErr = this.serializeError(e, config, currentDepth + 1);
+            return typeof serializedErr === "string" ? { name: "Error", message: serializedErr } : serializedErr;
+          }
+          return e;
+        });
+      }
+    }
+    return serialized;
+  }
   /**
    * Format base64 string for logging
    */
@@ -31,17 +1562,14 @@ var Formatter = class {
   /**
    * Helper to serialize Blob and File objects for logging
    */
-  static serializeSpecialObjects(obj, maxDepth = 10, currentDepth = 0) {
+  static serializeSpecialObjects(obj, maxDepth = 10, currentDepth = 0, filterOptions, currentPath = []) {
     if (currentDepth > maxDepth) return "[Max Depth Reached]";
+    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 (obj instanceof File) {
       return {
         name: obj.name,
@@ -50,14 +1578,69 @@ var Formatter = class {
         lastModified: obj.lastModified
       };
     }
+    if (obj instanceof Blob) {
+      return {
+        size: obj.size,
+        type: obj.type
+      };
+    }
     if (Array.isArray(obj)) {
-      return obj.map((item) => this.serializeSpecialObjects(item, maxDepth, currentDepth + 1));
+      return obj.map(
+        (item, index) => this.serializeSpecialObjects(
+          item,
+          maxDepth,
+          currentDepth + 1,
+          filterOptions,
+          [...currentPath, `[${index}]`]
+        )
+      );
     }
     if (obj !== null && typeof obj === "object") {
       const serialized = {};
       for (const key in obj) {
         if (Object.prototype.hasOwnProperty.call(obj, key)) {
-          serialized[key] = this.serializeSpecialObjects(obj[key], maxDepth, currentDepth + 1);
+          const value = obj[key];
+          const newPath = [...currentPath, key];
+          const { include, filtered } = this.shouldIncludeField(
+            key,
+            value,
+            currentPath,
+            filterOptions
+          );
+          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
+            );
+          }
         }
       }
       return serialized;
@@ -76,10 +1659,23 @@ var Formatter = class {
       const isArray = Array.isArray(arg);
       if (isObject || isArray) {
         const maxDepth = options?.maxDepth ?? 5;
-        const serialized = this.serializeSpecialObjects(arg, maxDepth);
+        const serialized = this.serializeSpecialObjects(
+          arg,
+          maxDepth,
+          0,
+          {
+            pick: options?.pick,
+            omit: options?.omit,
+            filterFields: options?.filterFields,
+            filterMode: options?.filterMode,
+            filterReplacement: options?.filterReplacement,
+            globalFilterMode: options?.globalFilterMode,
+            globalFilterReplacement: options?.globalFilterReplacement,
+            errorConfig: options?.errorConfig
+          }
+        );
         const formatted = format(serialized, {
-          ...options,
-          indent: options?.indent ?? 2,
+          indent: 2,
           maxDepth,
           // Remove Object and Array labels
           printFunctionName: false,
@@ -108,6 +1704,10 @@ var LOG_COLORS = {
   none: "#fff"
 };
 var DEFAULT_NAMESPACE = "app";
+var DEFAULT_DEDUP_CONFIG = {
+  enabled: false,
+  flushInterval: 100
+};
 
 // src/styler.ts
 function getColorForLevel(level) {
@@ -146,56 +1746,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;
         }
       }
@@ -206,25 +1791,118 @@ 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();
 var namespace_matcher_default = namespaceMatcher;
 
+// src/dedup-hasher.ts
+var DedupHasher = class {
+  /**
+   * Default hash function - simple string concatenation
+   * For better performance, we use a simple approach rather than crypto hashing
+   */
+  static generateKey(level, message, args) {
+    const argsString = this.serializeArgs(args);
+    return `${level}:${message}:${argsString}`;
+  }
+  /**
+   * Serialize arguments to a consistent string representation
+   */
+  static serializeArgs(args) {
+    if (args.length === 0) return "";
+    try {
+      return JSON.stringify(args, (key, value) => {
+        if (typeof value === "function") {
+          return "[Function]";
+        }
+        if (typeof value === "symbol") {
+          return value.toString();
+        }
+        if (value === void 0) {
+          return "[undefined]";
+        }
+        return value;
+      });
+    } catch (error) {
+      return String(args);
+    }
+  }
+};
+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 };
 }
 var Logger = class {
   constructor(options = {}) {
     this._level = "debug";
+    this._dedupBuffer = /* @__PURE__ */ new Map();
+    // Temporary filter options that reset after each log
+    this._tempFilterOptions = {};
+    // Custom context for conditional logging
+    this._context = {};
+    // Temporary conditions that reset after each log
+    this._tempConditions = [];
     this._namespace = options.namespace ?? DEFAULT_NAMESPACE;
     this._level = options.level ?? globalConfig.level ?? "debug";
     this._maxDepth = options.maxDepth ?? globalConfig.maxDepth ?? 10;
+    this._context = options.context ?? {};
+    this._dedupConfig = {
+      ...DEFAULT_DEDUP_CONFIG,
+      ...globalConfig.dedup || {},
+      ...options.dedup || {}
+    };
   }
   debug(message, ...args) {
     this.log("debug", message, ...args);
@@ -242,24 +1920,156 @@ var Logger = class {
     this.log("error", message, ...args);
     return this;
   }
+  /**
+   * Assert that a condition is truthy. Logs an error if the condition is falsy.
+   * Similar to console.assert() but integrates with plslog's features.
+   * Uses JavaScript truthiness - falsy values: false, 0, '', null, undefined, NaN
+   *
+   * @param condition - The condition to assert (uses JavaScript truthiness)
+   * @param message - Error message to log if assertion fails
+   * @param args - Additional arguments to log
+   * @returns this for chaining
+   *
+   * @example
+   * logger.assert(user !== null, 'User should not be null', user);
+   * logger.assert(count > 0, 'Count must be positive', { count });
+   * logger.assert(data, 'Data is required'); // Checks if data is truthy
+   */
+  assert(condition, message, ...args) {
+    if (!condition) {
+      this.log("error", message, ...args);
+    } else {
+      this._tempConditions = [];
+      this._tempFilterOptions = {};
+    }
+    return this;
+  }
   setLevel(level) {
     this._level = level;
   }
+  /**
+   * Set the namespace for this logger instance
+   * Returns this for method chaining
+   *
+   * @param namespace - The namespace string (e.g., 'service:api', 'component')
+   * @returns this for chaining
+   *
+   * @example
+   * const log = logger().namespace('service:api');
+   * log.debug('Message'); // Logs with namespace 'service:api'
+   *
+   * // Can also be called after instantiation
+   * const log2 = logger();
+   * log2.namespace('component').debug('Message');
+   */
+  namespace(namespace) {
+    this._namespace = namespace;
+    return this;
+  }
   maxDepth(maxDepth) {
     this._maxDepth = maxDepth;
     return this;
   }
+  /**
+   * Pick only specific fields to log (whitelist approach)
+   * Supports dot notation for nested fields: 'user.name', 'user.email'
+   * Supports wildcards: 'user.*' matches all fields under user
+   */
+  pick(fields) {
+    this._tempFilterOptions.pick = fields;
+    return this;
+  }
+  /**
+   * Omit specific fields from logging (blacklist approach)
+   * Supports strings, regex patterns, and predicate functions
+   */
+  omit(fields) {
+    this._tempFilterOptions.omit = fields;
+    return this;
+  }
+  /**
+   * Set filter mode for per-log filtering
+   * - 'redact': Replace with custom string (default: '***REDACTED***')
+   * - 'hide': Remove field completely
+   * - 'type': Show type info like '[string]', '[Array(3)]'
+   * - 'length': Show length info like '[8 chars]', '[3 items]'
+   */
+  filterMode(mode, replacement) {
+    this._tempFilterOptions.filterMode = mode;
+    if (replacement !== void 0) {
+      this._tempFilterOptions.filterReplacement = replacement;
+    }
+    return this;
+  }
+  once(enabled = true) {
+    this._dedupConfig.enabled = enabled;
+    return this;
+  }
+  flushDedup() {
+    const keys = Array.from(this._dedupBuffer.keys());
+    keys.forEach((key) => this.flushDedupEntry(key));
+    return this;
+  }
+  /**
+   * Execute log only if condition is true
+   * Supports boolean values or predicate functions
+   * Multiple when() calls are AND-ed together
+   *
+   * @example
+   * // Boolean condition
+   * logger.when(isDev).debug('Dev only');
+   *
+   * // Predicate with context
+   * logger.when(ctx => ctx.namespace === 'auth').debug('Auth log');
+   *
+   * // Chaining (both must be true)
+   * logger
+   *   .when(ctx => ctx.level === 'debug')
+   *   .when(isDevMode)
+   *   .debug('Conditional');
+   */
+  when(condition) {
+    this._tempConditions.push(condition);
+    return this;
+  }
+  /**
+   * Execute log only if condition is false (inverse of when)
+   * Supports boolean values or predicate functions
+   *
+   * @example
+   * // Boolean condition
+   * logger.unless(isProd).debug('Not in production');
+   *
+   * // Predicate with context
+   * logger.unless(ctx => ctx.level === 'error').info('Non-error log');
+   */
+  unless(condition) {
+    if (typeof condition === "function") {
+      this._tempConditions.push((ctx) => !condition(ctx));
+    } else {
+      this._tempConditions.push(!condition);
+    }
+    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) {
+      const ctx = {
+        namespace: this._namespace,
+        level,
+        ...this._context
+      };
+      const conditionsMet = this._tempConditions.every(
+        (condition) => typeof condition === "function" ? condition(ctx) : condition
+      );
+      this._tempConditions = [];
+      if (!conditionsMet) {
+        this._tempFilterOptions = {};
+        return;
+      }
+    }
     if (!namespace_matcher_default.matches(this._namespace, globalConfig.namespaces)) {
       return;
     }
@@ -270,8 +2080,80 @@ var Logger = class {
     } else if (this.getLevelPriority(this._level) > this.getLevelPriority(level)) {
       return;
     }
+    const filterOptions = this._tempFilterOptions;
+    this._tempFilterOptions = {};
+    if (this._dedupConfig.enabled) {
+      this.logWithDedup(level, message, filterOptions, ...args);
+    } else {
+      this.logImmediate(level, message, filterOptions, ...args);
+    }
+  }
+  logWithDedup(level, message, filterOptions, ...args) {
+    const key = dedup_hasher_default.generateKey(level, message, args);
+    const existing = this._dedupBuffer.get(key);
+    const now = Date.now();
+    if (existing) {
+      existing.count++;
+      existing.lastTimestamp = now;
+      existing.args = args;
+      existing.filterOptions = filterOptions;
+      if (existing.flushTimeoutId !== void 0) {
+        clearTimeout(existing.flushTimeoutId);
+      }
+      existing.flushTimeoutId = setTimeout(() => {
+        this.flushDedupEntry(key);
+      }, this._dedupConfig.flushInterval);
+    } else {
+      const entry = {
+        key,
+        level,
+        message,
+        args,
+        count: 1,
+        firstTimestamp: now,
+        lastTimestamp: now,
+        filterOptions
+      };
+      this._dedupBuffer.set(key, entry);
+      entry.flushTimeoutId = setTimeout(() => {
+        this.flushDedupEntry(key);
+      }, this._dedupConfig.flushInterval);
+    }
+  }
+  flushDedupEntry(key) {
+    const entry = this._dedupBuffer.get(key);
+    if (!entry) return;
+    let displayMessage = entry.message;
+    if (entry.count > 1) {
+      const firstTime = this.formatTimestamp(entry.firstTimestamp);
+      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._dedupBuffer.delete(key);
+  }
+  formatTimestamp(timestamp) {
+    const date = new Date(timestamp);
+    const hours = String(date.getHours()).padStart(2, "0");
+    const minutes = String(date.getMinutes()).padStart(2, "0");
+    const seconds = String(date.getSeconds()).padStart(2, "0");
+    const milliseconds = String(date.getMilliseconds()).padStart(3, "0");
+    return `${hours}:${minutes}:${seconds}.${milliseconds}`;
+  }
+  logImmediate(level, message, filterOptions, ...args) {
     const formattedObject = Formatter.formatObj(args, {
-      maxDepth: this._maxDepth
+      maxDepth: this._maxDepth,
+      // Global filter fields (always applied for security)
+      filterFields: globalConfig.filterFields,
+      globalFilterMode: globalConfig.filterMode,
+      globalFilterReplacement: globalConfig.filterReplacement,
+      // Per-log pick/omit (contextual filtering)
+      pick: filterOptions.pick,
+      omit: filterOptions.omit,
+      filterMode: filterOptions.filterMode,
+      filterReplacement: filterOptions.filterReplacement,
+      // Error serialization config
+      errorConfig: globalConfig.errorSerialization
     });
     const formattedMessage = formattedObject ? `${message} ${formattedObject}` : message;
     const { logMessage, logStyles } = styler_default.style({
@@ -299,10 +2181,45 @@ var Logger = class {
   }
 };
 var plslog = ((options = {}) => {
-  return new Logger(options);
+  const normalizedOptions = typeof options === "string" ? { namespace: options } : options;
+  return new Logger(normalizedOptions);
 });
 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.
+   *  * /
+   *)
+*/
 
 export { logger_default as default };
 //# sourceMappingURL=index.mjs.map