@ncoderz/log-m8 1.0.1

package/dist/index.cjs

@@ -0,0 +1,1412 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LogLevel: () => LogLevel,
+  LogM8Utils: () => LogM8Utils,
+  Logging: () => Logging,
+  PluginKind: () => PluginKind
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/LogLevel.ts
+var LogLevel = {
+  off: "off",
+  // No logging
+  fatal: "fatal",
+  error: "error",
+  warn: "warn",
+  info: "info",
+  debug: "debug",
+  track: "track",
+  // Special log level for analytics
+  trace: "trace"
+};
+
+// src/PluginKind.ts
+var PluginKind = {
+  appender: "appender",
+  // Log output destinations (console, file, network, etc.)
+  filter: "filter",
+  // Event filtering logic (level, content, rate limiting, etc.)
+  formatter: "formatter"
+  // Event formatting (text, JSON, custom templates, etc.)
+};
+
+// src/appenders/ConsoleAppender.ts
+var NAME = "console";
+var VERSION = "1.0.0";
+var KIND = PluginKind.appender;
+var SUPPORTED_LEVELS = /* @__PURE__ */ new Set([
+  LogLevel.fatal,
+  LogLevel.error,
+  LogLevel.warn,
+  LogLevel.info,
+  LogLevel.debug,
+  LogLevel.track,
+  LogLevel.trace
+]);
+var ConsoleAppender = class {
+  constructor() {
+    __publicField(this, "name", NAME);
+    __publicField(this, "version", VERSION);
+    __publicField(this, "kind", KIND);
+    __publicField(this, "supportedLevels", SUPPORTED_LEVELS);
+    __publicField(this, "enabled", true);
+    __publicField(this, "priority");
+    __publicField(this, "_config");
+    __publicField(this, "_formatter");
+    __publicField(this, "_filters", []);
+    __publicField(this, "_available", true);
+    // Console method mapping with fallbacks for missing methods
+    __publicField(this, "off", () => {
+    });
+    __publicField(this, "fatal", console.error ? console.error.bind(console) : console.log.bind(console));
+    __publicField(this, "error", console.error ? console.error.bind(console) : console.log.bind(console));
+    __publicField(this, "warn", console.warn ? console.warn.bind(console) : console.log.bind(console));
+    __publicField(this, "info", console.info ? console.info.bind(console) : console.log.bind(console));
+    __publicField(this, "debug", console.debug ? console.debug.bind(console) : console.log.bind(console));
+    // Avoid console.trace as it captures stack traces and is significantly slower; prefer debug/log
+    __publicField(this, "trace", console.debug ? console.debug.bind(console) : console.log.bind(console));
+    __publicField(this, "track", console.log.bind(console));
+  }
+  init(config, formatter, filters) {
+    this._config = config;
+    this._formatter = formatter;
+    this._filters = filters || [];
+    this._available = typeof console !== "undefined" && !!console.log;
+    this.enabled = this._config?.enabled !== false;
+    this.priority = this._config?.priority;
+  }
+  dispose() {
+  }
+  write(event) {
+    if (!this._available) return;
+    for (const filter of this._filters) {
+      if (filter.enabled && !filter.filter(event)) {
+        return;
+      }
+    }
+    const data = this._formatter ? this._formatter.format(event) : [event];
+    this[event.level](...data);
+  }
+  flush() {
+  }
+  enableFilter(name) {
+    const filter = this._getFilter(name);
+    if (!filter) return;
+    filter.enabled = true;
+  }
+  disableFilter(name) {
+    const filter = this._getFilter(name);
+    if (!filter) return;
+    filter.enabled = false;
+  }
+  _getFilter(name) {
+    return this._filters.find((f) => f.name === name);
+  }
+};
+var ConsoleAppenderFactory = class {
+  constructor() {
+    __publicField(this, "name", NAME);
+    __publicField(this, "version", VERSION);
+    __publicField(this, "kind", KIND);
+  }
+  create(config) {
+    const appender = new ConsoleAppender();
+    appender.init(config);
+    return appender;
+  }
+};
+
+// src/appenders/FileAppender.ts
+var import_fs = require("fs");
+
+// src/LogM8Utils.ts
+var TIMESTAMP_TOKEN_REGEX = /(yyyy|SSS|hh|mm|ss|SS|zz|z|yy|MM|dd|A|a|h|S)/g;
+var EXCLUDED_ERROR_KEYS = /* @__PURE__ */ new Set(["name", "message", "stack", "cause"]);
+var COMMON_NON_ENUMERABLE_PROPS = ["code", "errno", "syscall", "path"];
+var LogM8Utils = class _LogM8Utils {
+  /**
+   * Detects browser environment for feature compatibility.
+   *
+   * @returns True when both window and document global objects are available
+   */
+  static isBrowser() {
+    return typeof window !== "undefined" && typeof window.document !== "undefined";
+  }
+  /**
+   * Check if an object is a string.
+   *
+   * @param obj - The object to check.
+   * @returns true if the object is a string, otherwise false.
+   */
+  static isString(obj) {
+    return typeof obj === "string" || obj instanceof String;
+  }
+  /**
+   * Traverses nested object properties using dot-separated path notation.
+   *
+   *  Supports both object property access and array indexing with numeric keys.
+   *  Also supports bracket notation for array indices which is normalized internally
+   *  (e.g., `data[0].items[2]` becomes `data.0.items.2`).
+   *  Safe navigation that returns undefined for invalid paths rather than throwing.
+   *
+   *  @param obj - Source object to traverse
+   *  @param path - Dot-separated property path (e.g., 'user.profile.name', 'items.0.id')
+   *               or a path with bracket indices (e.g., 'items[0].id')
+   *  @returns Property value at the specified path, or undefined if not found
+   *
+   *  @example
+   *  ```typescript
+   *  const data = { user: { profile: { name: 'John' } }, items: [{ id: 1 }, { id: 2 }] };
+   *  getPropertyByPath(data, 'user.profile.name'); // 'John'
+   *  getPropertyByPath(data, 'items.0.id');        // 1
+   *  getPropertyByPath(data, 'items[1].id');       // 2 (bracket notation)
+   *  getPropertyByPath(data, 'missing.path');      // undefined
+   *  ```
+   */
+  static getPropertyByPath(obj, path) {
+    let value = obj;
+    const normalized = path.replace(/\[(\d+)\]/g, ".$1");
+    const segments = normalized.split(".");
+    for (const key of segments) {
+      if (typeof value === "object" && value !== null) {
+        if (Array.isArray(value)) {
+          const idx = Number(key);
+          if (Number.isInteger(idx) && idx >= 0) {
+            value = value[idx];
+            continue;
+          }
+        }
+        value = value[key];
+      } else {
+        return void 0;
+      }
+    }
+    return value;
+  }
+  /**
+   * Formats Date objects using preset formats or custom token patterns.
+   *
+   * Supports common presets ('iso', 'locale') and flexible token-based formatting
+   * for complete control over timestamp appearance. Tokens are replaced with
+   * corresponding date/time components, while non-token text is preserved literally.
+   *
+   * Supported format tokens:
+   * - yyyy: 4-digit year (2025)
+   * - yy: 2-digit year (25)
+   * - MM: month with leading zero (01-12)
+   * - dd: day with leading zero (01-31)
+   * - hh: 24-hour format hour with leading zero (00-23)
+   * - h: 12-hour format hour (1-12)
+   * - mm: minutes with leading zero (00-59)
+   * - ss: seconds with leading zero (00-59)
+   * - SSS: milliseconds with leading zeros (000-999)
+   * - SS: centiseconds with leading zero (00-99)
+   * - S: deciseconds (0-9)
+   * - A: uppercase AM/PM
+   * - a: lowercase am/pm
+   * - z: timezone offset with colon (±HH:MM)
+   * - zz: timezone offset without colon (±HHMM)
+   *
+   * @param date - Date instance to format
+   * @param fmt - Format preset ('iso'|'locale') or custom token pattern
+   * @returns Formatted timestamp string
+   *
+   * @example
+   * ```typescript
+   * const date = new Date('2025-08-04T14:23:45.123Z');
+   *
+   * // Presets
+   * formatTimestamp(date, 'iso');    // '2025-08-04T14:23:45.123Z'
+   * formatTimestamp(date, 'locale'); // '8/4/2025, 2:23:45 PM' (locale-dependent)
+   *
+   * // Custom patterns
+   * formatTimestamp(date, 'yyyy-MM-dd hh:mm:ss');     // '2025-08-04 14:23:45'
+   * formatTimestamp(date, 'MM/dd/yyyy h:mm A');       // '08/04/2025 2:23 PM'
+   * formatTimestamp(date, 'hh:mm:ss.SSS');            // '14:23:45.123'
+   * formatTimestamp(date, 'yyyy-MM-dd hh:mm:ss z');   // '2025-08-04 14:23:45 +00:00'
+   * ```
+   */
+  static formatTimestamp(date, fmt) {
+    const fmtLower = fmt?.toLowerCase();
+    if (!fmt || fmtLower === "iso" || fmtLower === "toisostring") {
+      return date.toISOString();
+    }
+    if (fmtLower === "locale" || fmtLower === "tolocalestring") {
+      return date.toLocaleString();
+    }
+    const pad = (n, z = 2) => String(n).padStart(z, "0");
+    const hours24 = date.getHours();
+    const hours12 = hours24 % 12 === 0 ? 12 : hours24 % 12;
+    return fmt.replace(TIMESTAMP_TOKEN_REGEX, (m) => {
+      switch (m) {
+        case "yyyy":
+          return pad(date.getFullYear(), 4);
+        case "yy":
+          return pad(date.getFullYear() % 100);
+        case "MM":
+          return pad(date.getMonth() + 1);
+        case "dd":
+          return pad(date.getDate());
+        case "hh":
+          return pad(hours24);
+        case "h":
+          return pad(hours12);
+        case "mm":
+          return pad(date.getMinutes());
+        case "ss":
+          return pad(date.getSeconds());
+        case "SSS":
+          return pad(date.getMilliseconds(), 3);
+        case "SS":
+          return pad(Math.floor(date.getMilliseconds() / 10), 2);
+        case "S":
+          return pad(Math.floor(date.getMilliseconds() / 100), 1);
+        case "A":
+          return hours24 < 12 ? "AM" : "PM";
+        case "a":
+          return hours24 < 12 ? "am" : "pm";
+        case "z":
+        case "zz": {
+          const tzOffset = -date.getTimezoneOffset();
+          const tzSign = tzOffset >= 0 ? "+" : "-";
+          const tzHours = Math.floor(Math.abs(tzOffset) / 60);
+          const tzMinutes = Math.abs(tzOffset) % 60;
+          if (m === "z") {
+            return `${tzSign}${pad(tzHours)}:${pad(tzMinutes)}`;
+          }
+          return `${tzSign}${pad(tzHours)}${pad(tzMinutes)}`;
+        }
+        default:
+          return m;
+      }
+    });
+  }
+  /**
+   * Converts arbitrary values into JSON strings optimized for logging systems.
+   *
+   * This utility ensures that any JavaScript value can be safely logged without causing
+   * serialization errors or producing excessively large output. It's designed specifically
+   * for logging contexts where reliability and readability are more important than
+   * perfect fidelity.
+   *
+   * ## Key Features
+   *
+   * **Depth Protection**: Prevents stack overflows and excessive output by limiting
+   * object traversal depth. Objects/arrays beyond the limit are replaced with
+   * "[Object]" or "[Array]" placeholders.
+   *
+   * **Array Length Limiting**: Automatically truncates arrays that exceed the maximum
+   * length threshold. Truncated arrays include a message indicating how many additional
+   * items were omitted.
+   *
+   * **String Truncation**: Automatically truncates long strings to prevent log flooding.
+   * Truncated strings end with an ellipsis (…) character.
+   *
+   * **Type Safety**: Handles problematic JavaScript types that would normally cause
+   * JSON.stringify to throw:
+   * - BigInt values are converted to strings
+   * - Date objects are normalized to ISO 8601 format
+   * - Error instances are serialized to structured objects via {@link LogM8Utils.serializeError}
+   *
+   * ## Implementation Details
+   *
+   * - Uses a WeakMap to track traversal depth per object, preventing revisits to the
+   *   same instance at different depths
+   * - Respects existing `toJSON()` methods on objects
+   * - Not designed for full cycle detection - cyclic references are handled by the
+   *   depth limit rather than explicit cycle breaking
+   * - The replacer function executes in the context of the parent object, enabling
+   *   depth tracking through the traversal
+   *
+   * @param value - Any JavaScript value to stringify for logging (events, contexts, errors, etc.)
+   * @param options - Configuration for controlling output size and complexity
+   * @param options.maxDepth - Maximum nesting depth for objects/arrays (default: 3).
+   *                           Level 0 = primitive values only,
+   *                           Level 1 = top-level properties,
+   *                           Level 2 = nested properties, etc.
+   * @param options.maxArrayLength - Maximum number of array elements to include before truncation (default: 100).
+   *                                 Arrays exceeding this limit will be truncated with a message
+   *                                 indicating the number of omitted items.
+   * @param options.maxStringLength - Maximum character length for strings before truncation (default: 200)
+   * @param space - Indentation for pretty-printing. Can be a number (spaces) or string (e.g., '\t').
+   *               Pass undefined for compact output (recommended for production logs).
+   *
+   * @returns A JSON string that is guaranteed to be safe for logging systems
+   *
+   * @example
+   * // Basic usage with default options
+   * const json = LogM8Utils.stringifyLog({ message: 'User logged in', userId: 12345 });
+   * // => '{"message":"User logged in","userId":12345}'
+   *
+   * @example
+   * // Handling problematic types
+   * const data = {
+   *   bigNumber: 123456789012345678901234567890n,
+   *   timestamp: new Date('2024-01-15T10:30:00Z'),
+   *   error: new Error('Connection failed'),
+   *   longText: 'x'.repeat(500)
+   * };
+   * const json = LogM8Utils.stringifyLog(data);
+   * // => '{"bigNumber":"123456789012345678901234567890","timestamp":"2024-01-15T10:30:00.000Z","error":{...},"longText":"xxx...xxx…"}'
+   *
+   * @example
+   * // Array length limiting for large arrays
+   * const largeData = {
+   *   items: new Array(1000).fill({ id: 1, name: 'item' }),
+   *   values: Array.from({ length: 500 }, (_, i) => i)
+   * };
+   * const json = LogM8Utils.stringifyLog(largeData, { maxArrayLength: 50 });
+   * // => '{"items":[{...},{...},...,"... 950 more items"],"values":[0,1,2,...,"... 450 more items"]}'
+   *
+   * @example
+   * // Depth limiting for deeply nested objects
+   * const deepObj = {
+   *   level1: {
+   *     level2: {
+   *       level3: {
+   *         level4: {
+   *           level5: 'too deep'
+   *         }
+   *       }
+   *     }
+   *   }
+   * };
+   * const json = LogM8Utils.stringifyLog(deepObj, { maxDepth: 3 });
+   * // => '{"level1":{"level2":{"level3":{"level4":"[Object]"}}}}'
+   *
+   * @example
+   * // Custom options for verbose debugging
+   * const debugJson = LogM8Utils.stringifyLog(
+   *   complexObject,
+   *   { maxDepth: 5, maxArrayLength: 500, maxStringLength: 1000 },
+   *   2  // Pretty print with 2 spaces
+   * );
+   *
+   * @example
+   * // Production logging with minimal output
+   * const prodJson = LogM8Utils.stringifyLog(
+   *   userEvent,
+   *   { maxDepth: 2, maxArrayLength: 20, maxStringLength: 100 }  // Aggressive truncation for high-volume logs
+   * );
+   *
+   * @example
+   * // Handling arrays with mixed content
+   * const mixedArray = {
+   *   results: [
+   *     { id: 1, data: 'first' },
+   *     { id: 2, data: 'second' },
+   *     ...Array(200).fill({ id: 999, data: 'bulk' })
+   *   ]
+   * };
+   * const json = LogM8Utils.stringifyLog(mixedArray, { maxArrayLength: 10 });
+   * // First 10 items preserved, then truncation message
+   *
+   * @see {@link LogM8Utils.serializeError} - For Error serialization details
+   */
+  static stringifyLog(value, { maxDepth = 3, maxStringLength = 200, maxArrayLength = 100 } = {}, space) {
+    const levels = /* @__PURE__ */ new WeakMap();
+    function replacer(key, v) {
+      if (v && typeof v === "object") {
+        const parentLevel = levels.get(this) ?? 0;
+        if (parentLevel >= maxDepth) {
+          return Array.isArray(v) ? "[Array]" : "[Object]";
+        }
+        levels.set(v, parentLevel + 1);
+        if (Array.isArray(v) && v.length > maxArrayLength) {
+          const truncated = v.slice(0, maxArrayLength);
+          truncated.push(`... ${v.length - maxArrayLength} more items`);
+          return truncated;
+        }
+      }
+      if (_LogM8Utils.isString(v) && v.length > maxStringLength) {
+        return v.slice(0, maxStringLength) + "\u2026";
+      }
+      if (typeof v === "bigint") {
+        return v.toString();
+      }
+      if (v instanceof Date) {
+        return v.toISOString();
+      }
+      if (v instanceof Error) {
+        return _LogM8Utils.serializeError(v);
+      }
+      return v;
+    }
+    return JSON.stringify(value, replacer, space);
+  }
+  /**
+   * Serializes an Error (or Error-like) into a plain, JSON-safe object.
+   *
+   * Behavior:
+   * - Returns null for falsy inputs.
+   * - If the object provides a custom toJSON(), that result is used verbatim to
+   *   honor caller-defined serialization.
+   * - Otherwise includes standard fields: name, message, stack.
+   * - Recursively serializes the optional error.cause chain using the same rules.
+   * - Handles circular references in the cause chain safely.
+   * - Copies other own enumerable properties (excluding name, message, stack, cause),
+   *   skipping properties that throw on access or are not JSON-serializable.
+   * - Optionally includes common non-enumerable properties like 'code' if present.
+   *
+   * Important:
+   * - This function does not attempt to preserve all non-enumerable properties.
+   * - Circular references in the cause chain are detected and handled gracefully.
+   *
+   * @param error - Unknown error input (Error instance or compatible object).
+   * @returns Structured error data suitable for logging, or null when input is falsy.
+   *
+   * @example
+   * try {
+   *   throw new Error('Boom');
+   * } catch (e) {
+   *   const payload = LogM8Utils.serializeError(e);
+   *   // { name: 'Error', message: 'Boom', stack: '...', ... }
+   * }
+   */
+  static serializeError(error) {
+    const serializeErrorInternal = (error2, seen) => {
+      if (!error2) return null;
+      const errorObj = error2;
+      if (typeof errorObj === "object" && errorObj !== null) {
+        if (seen.has(errorObj)) {
+          return {
+            name: "CircularReference",
+            message: "Circular reference detected in error cause chain"
+          };
+        }
+        seen.add(errorObj);
+      }
+      if (typeof errorObj.toJSON === "function") {
+        try {
+          const result = errorObj.toJSON();
+          JSON.stringify(result);
+          return result;
+        } catch (_e) {
+        }
+      }
+      const serialized = {
+        name: errorObj.name || "Error",
+        message: errorObj.message || "",
+        stack: errorObj.stack
+      };
+      if ("cause" in errorObj && errorObj.cause !== void 0) {
+        serialized.cause = serializeErrorInternal(errorObj.cause, seen);
+      }
+      for (const key in errorObj) {
+        if (Object.prototype.hasOwnProperty.call(errorObj, key) && !EXCLUDED_ERROR_KEYS.has(key)) {
+          try {
+            const value = errorObj[key];
+            JSON.stringify(value);
+            serialized[key] = value;
+          } catch (_e) {
+          }
+        }
+      }
+      for (const prop of COMMON_NON_ENUMERABLE_PROPS) {
+        try {
+          const descriptor = Object.getOwnPropertyDescriptor(errorObj, prop);
+          if (descriptor && descriptor.value !== void 0) {
+            JSON.stringify(descriptor.value);
+            serialized[prop] = descriptor.value;
+          }
+        } catch (_e) {
+        }
+      }
+      return serialized;
+    };
+    return serializeErrorInternal(error, /* @__PURE__ */ new WeakSet());
+  }
+};
+
+// src/appenders/FileAppender.ts
+var NAME2 = "file";
+var VERSION2 = "1.0.0";
+var KIND2 = PluginKind.appender;
+var SUPPORTED_LEVELS2 = /* @__PURE__ */ new Set([
+  LogLevel.fatal,
+  LogLevel.error,
+  LogLevel.warn,
+  LogLevel.info,
+  LogLevel.debug,
+  LogLevel.track,
+  LogLevel.trace
+]);
+var FileAppender = class {
+  constructor() {
+    __publicField(this, "name", NAME2);
+    __publicField(this, "version", VERSION2);
+    __publicField(this, "kind", KIND2);
+    __publicField(this, "supportedLevels", SUPPORTED_LEVELS2);
+    __publicField(this, "enabled", true);
+    __publicField(this, "priority");
+    __publicField(this, "_config");
+    __publicField(this, "_formatter");
+    __publicField(this, "_filters", []);
+    __publicField(this, "_stream");
+  }
+  init(config, formatter, filters) {
+    this._config = config;
+    this._formatter = formatter;
+    this._filters = filters || [];
+    const flags = this._config.append ? "a" : "w";
+    this._stream = (0, import_fs.createWriteStream)(this._config.filename, { flags });
+    this.enabled = this._config?.enabled !== false;
+    this.priority = this._config?.priority;
+  }
+  dispose() {
+    this._stream?.end();
+  }
+  write(event) {
+    if (!this._stream) return;
+    for (const filter of this._filters) {
+      if (filter.enabled && !filter.filter(event)) {
+        return;
+      }
+    }
+    const data = this._formatter ? this._formatter.format(event) : [event];
+    const message = data.map((d) => {
+      if (LogM8Utils.isString(d)) return d;
+      return String(d);
+    }).join(" ");
+    this._stream.write(message + "\n");
+  }
+  flush() {
+  }
+  enableFilter(name) {
+    const filter = this._getFilter(name);
+    if (!filter) return;
+    filter.enabled = true;
+  }
+  disableFilter(name) {
+    const filter = this._getFilter(name);
+    if (!filter) return;
+    filter.enabled = false;
+  }
+  _getFilter(name) {
+    return this._filters.find((f) => f.name === name);
+  }
+};
+var FileAppenderFactory = class {
+  constructor() {
+    __publicField(this, "name", NAME2);
+    __publicField(this, "version", VERSION2);
+    __publicField(this, "kind", KIND2);
+  }
+  create(config) {
+    const appender = new FileAppender();
+    appender.init(config);
+    return appender;
+  }
+};
+
+// src/filters/MatchFilter.ts
+var MatchFilter = class {
+  constructor() {
+    __publicField(this, "name", "match-filter");
+    __publicField(this, "version", "1.0.0");
+    __publicField(this, "kind", PluginKind.filter);
+    __publicField(this, "enabled", true);
+    __publicField(this, "_allow");
+    __publicField(this, "_deny");
+  }
+  /**
+   * Initializes allow/deny rule maps. Values are compared using deep equality for
+   * arrays/objects and strict equality for primitives. Missing maps are treated as empty.
+   * @param config - Filter configuration with optional allow/deny maps
+   */
+  init(config) {
+    const cfg = config ?? {};
+    this._allow = cfg.allow ?? void 0;
+    this._deny = cfg.deny ?? void 0;
+    this.enabled = cfg.enabled !== false;
+  }
+  dispose() {
+  }
+  /**
+   * Evaluates the given event against configured rules.
+   * - allow: if provided and non-empty, ALL rules must match (AND)
+   * - deny: if provided, ANY match denies (OR); deny takes precedence over allow
+   * Returns false on unexpected errors to fail-safe.
+   * @param logEvent - Event to evaluate
+   * @returns true when the event should be logged; false to drop
+   */
+  filter(logEvent) {
+    try {
+      if (this._allow && Object.keys(this._allow).length > 0) {
+        for (const [path, expected] of Object.entries(this._allow)) {
+          const actual = LogM8Utils.getPropertyByPath(logEvent, path);
+          if (!this._isEqual(actual, expected)) return false;
+        }
+      }
+      if (this._deny && Object.keys(this._deny).length > 0) {
+        for (const [path, expected] of Object.entries(this._deny)) {
+          const actual = LogM8Utils.getPropertyByPath(logEvent, path);
+          if (this._isEqual(actual, expected)) return false;
+        }
+      }
+      return true;
+    } catch (_err) {
+      return false;
+    }
+  }
+  // Simple deep equality for primitives, arrays, plain objects, dates
+  _isEqual(a, b) {
+    if (a === b) return true;
+    if (typeof a === "number" && typeof b === "number") {
+      return Number.isNaN(a) && Number.isNaN(b);
+    }
+    if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
+    if (Array.isArray(a) && Array.isArray(b)) {
+      if (a.length !== b.length) return false;
+      for (let i = 0; i < a.length; i++) {
+        if (!this._isEqual(a[i], b[i])) return false;
+      }
+      return true;
+    }
+    if (this._isPlainObject(a) && this._isPlainObject(b)) {
+      const aKeys = Object.keys(a);
+      const bKeys = Object.keys(b);
+      if (aKeys.length !== bKeys.length) return false;
+      for (const key of aKeys) {
+        if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+        if (!this._isEqual(a[key], b[key]))
+          return false;
+      }
+      return true;
+    }
+    return false;
+  }
+  _isPlainObject(val) {
+    return typeof val === "object" && val !== null && !Array.isArray(val) && Object.getPrototypeOf(val) === Object.prototype;
+  }
+};
+var MatchFilterFactory = class {
+  constructor() {
+    __publicField(this, "name", "match-filter");
+    __publicField(this, "version", "1.0.0");
+    __publicField(this, "kind", PluginKind.filter);
+  }
+  create(config) {
+    const filter = new MatchFilter();
+    filter.init(config);
+    return filter;
+  }
+};
+
+// src/formatters/DefaultFormatter.ts
+var NAME3 = "default-formatter";
+var VERSION3 = "1.0.0";
+var KIND3 = PluginKind.formatter;
+var DEFAULT_FORMAT = ["{timestamp} {LEVEL} [{logger}]", "{message}", "{data}"];
+var DEFAULT_TIMESTAMP_FORMAT = "hh:mm:ss.SSS";
+var DefaultFormatter = class {
+  constructor() {
+    __publicField(this, "name", NAME3);
+    __publicField(this, "version", VERSION3);
+    __publicField(this, "kind", KIND3);
+    __publicField(this, "_config");
+    __publicField(this, "_format");
+    __publicField(this, "_timestampFormat", DEFAULT_TIMESTAMP_FORMAT);
+    __publicField(this, "_levelMap");
+    __publicField(this, "_colorEnabled", false);
+    // ANSI color codes for Node.js terminal output
+    __publicField(this, "_levelColorMap", {
+      trace: "\x1B[37m",
+      // White
+      track: "\x1B[38;5;208m",
+      // Orange
+      debug: "\x1B[90m",
+      // Grey
+      info: "\x1B[34m",
+      // Blue
+      warn: "\x1B[33m",
+      // Yellow
+      error: "\x1B[31m",
+      // Red
+      fatal: "\x1B[41m"
+      // Red background
+    });
+    // CSS color styles for browser console output
+    __publicField(this, "_levelCssColorMap", {
+      trace: "color: #bbb;",
+      // Light gray
+      track: "color: orange;",
+      debug: "color: grey;",
+      info: "color: blue;",
+      warn: "color: gold;",
+      error: "color: red;",
+      fatal: "background: red; color: white;"
+    });
+  }
+  init(config) {
+    const isBrowser = LogM8Utils.isBrowser();
+    this._config = Object.assign({}, config);
+    this._colorEnabled = !!this._config.color;
+    this._format = [];
+    let formatConfig = this._config.format ?? DEFAULT_FORMAT;
+    if (typeof this._config.format === "string") formatConfig = [this._config.format];
+    if (formatConfig) {
+      for (const f of formatConfig) {
+        const regex = /(\{[^}]+\})|([^{}]+)/g;
+        const parts = [];
+        let match;
+        while ((match = regex.exec(f)) !== null) {
+          if (match[1]) {
+            parts.push(match[1]);
+          } else if (match[2] !== void 0) {
+            parts.push(match[2]);
+          }
+        }
+        this._format.push(parts);
+      }
+    }
+    this._timestampFormat = this._config.timestampFormat ?? DEFAULT_TIMESTAMP_FORMAT;
+    const levelValues = Object.values(LogLevel);
+    const maxLevelLength = Math.max(...levelValues.map((l) => l.length));
+    this._levelMap = levelValues.reduce(
+      (acc, level) => {
+        let levelStr = level.toUpperCase().padEnd(maxLevelLength, " ");
+        if (this._colorEnabled) {
+          if (isBrowser) {
+            const css = this._levelCssColorMap[level] || "";
+            acc[level] = [`%c${levelStr}`, css];
+            return acc;
+          } else {
+            const color = this._levelColorMap[level] || "";
+            const reset = "\x1B[0m";
+            levelStr = color + levelStr + reset;
+          }
+        }
+        acc[level] = levelStr;
+        return acc;
+      },
+      {}
+    );
+  }
+  dispose() {
+  }
+  format(logEvent) {
+    let output;
+    const formatArr = this._format;
+    if (formatArr.length > 0) {
+      output = formatArr.map((item) => {
+        if (item.length === 1) {
+          return this.resolveToken(item[0], logEvent);
+        }
+        return item.reduce((str, part) => {
+          const val = this.resolveToken(part, logEvent);
+          return str + String(val);
+        }, "");
+      });
+      const dataIndex = output.findIndex((v) => Array.isArray(v));
+      if (dataIndex >= 0) {
+        const data = output[dataIndex];
+        if (data.length > 0) output.splice(dataIndex, 1, ...data);
+        else output.splice(dataIndex, 1);
+      }
+    } else {
+      output = [
+        LogM8Utils.formatTimestamp(logEvent.timestamp, this._timestampFormat),
+        logEvent.level,
+        logEvent.logger,
+        logEvent.message,
+        ...logEvent.data,
+        logEvent.context
+      ];
+    }
+    return output;
+  }
+  resolveToken(part, logEvent) {
+    if (part.startsWith("{") && part.endsWith("}")) {
+      const key = part.slice(1, -1);
+      if (key === "message" && typeof logEvent.message !== "string") {
+        return logEvent.message;
+      } else if (key === "LEVEL") {
+        return this._levelMap[logEvent.level] ?? logEvent.level;
+      } else if (key === "timestamp") {
+        const raw = LogM8Utils.getPropertyByPath(logEvent, key);
+        return LogM8Utils.formatTimestamp(raw, this._timestampFormat);
+      }
+      return LogM8Utils.getPropertyByPath(logEvent, key);
+    }
+    return part;
+  }
+};
+var DefaultFormatterFactory = class {
+  constructor() {
+    __publicField(this, "name", NAME3);
+    __publicField(this, "version", VERSION3);
+    __publicField(this, "kind", KIND3);
+  }
+  create(config) {
+    const appender = new DefaultFormatter();
+    appender.init(config);
+    return appender;
+  }
+};
+
+// src/formatters/JsonFormatter.ts
+var NAME4 = "json-formatter";
+var VERSION4 = "1.0.0";
+var KIND4 = PluginKind.formatter;
+var DEFAULT_FORMAT2 = ["timestamp", "level", "logger", "message", "data"];
+var DEFAULT_TIMESTAMP_FORMAT2 = "iso";
+var DEFAULT_PRETTY = 2;
+var DEFAULT_MAX_DEPTH = 3;
+var DEFAULT_MAX_STRING_LEN = 1e3;
+var DEFAULT_MAX_ARRAY_LEN = 100;
+var JsonFormatter = class {
+  constructor() {
+    __publicField(this, "name", NAME4);
+    __publicField(this, "version", VERSION4);
+    __publicField(this, "kind", KIND4);
+    __publicField(this, "_config");
+    __publicField(this, "_format");
+    __publicField(this, "_pretty");
+    __publicField(this, "_maxDepth", DEFAULT_MAX_DEPTH);
+    __publicField(this, "_maxStringLen", DEFAULT_MAX_STRING_LEN);
+    __publicField(this, "_maxArrayLen", DEFAULT_MAX_ARRAY_LEN);
+    __publicField(this, "_timestampFormat", DEFAULT_TIMESTAMP_FORMAT2);
+  }
+  init(config) {
+    this._config = Object.assign({}, config);
+    this._pretty = this._config.pretty === true ? DEFAULT_PRETTY : this._config.pretty ? this._config.pretty : void 0;
+    this._maxDepth = this._config.maxDepth ?? DEFAULT_MAX_DEPTH;
+    this._maxStringLen = this._config.maxStringLen ?? DEFAULT_MAX_STRING_LEN;
+    this._maxArrayLen = this._config.maxArrayLen ?? DEFAULT_MAX_ARRAY_LEN;
+    let formatConfig = this._config.format ?? DEFAULT_FORMAT2;
+    if (typeof this._config.format === "string") formatConfig = [this._config.format];
+    this._format = formatConfig;
+    this._timestampFormat = this._config.timestampFormat ?? DEFAULT_TIMESTAMP_FORMAT2;
+  }
+  dispose() {
+  }
+  format(logEvent) {
+    let outputObj = {};
+    const formatArr = this._format;
+    if (formatArr.length > 0) {
+      formatArr.forEach((item) => {
+        const t = this.resolveToken(item, logEvent);
+        if (t != void 0) {
+          outputObj[t.key] = t.value;
+        }
+      });
+    } else {
+      outputObj = logEvent;
+    }
+    return [
+      LogM8Utils.stringifyLog(
+        outputObj,
+        {
+          maxDepth: this._maxDepth,
+          maxStringLength: this._maxStringLen,
+          maxArrayLength: this._maxArrayLen
+        },
+        this._pretty
+      )
+    ];
+  }
+  resolveToken(part, logEvent) {
+    const key = part;
+    if (key === "LEVEL") {
+      return { key, value: logEvent.level };
+    } else if (key === "timestamp") {
+      const raw = LogM8Utils.getPropertyByPath(logEvent, key);
+      return { key, value: LogM8Utils.formatTimestamp(raw, this._timestampFormat) };
+    }
+    return { key, value: LogM8Utils.getPropertyByPath(logEvent, key) };
+  }
+};
+var JsonFormatterFactory = class {
+  constructor() {
+    __publicField(this, "name", NAME4);
+    __publicField(this, "version", VERSION4);
+    __publicField(this, "kind", KIND4);
+  }
+  create(config) {
+    const appender = new JsonFormatter();
+    appender.init(config);
+    return appender;
+  }
+};
+
+// src/PluginManager.ts
+var PluginManager = class {
+  constructor() {
+    __publicField(this, "_pluginFactories", /* @__PURE__ */ new Map());
+    __publicField(this, "_plugins", []);
+  }
+  /**
+   * Registers a plugin factory.
+   * @param pluginFactory - Factory to register for creating plugins.
+   * @throws Error if a factory with the same name is already registered.
+   */
+  registerPluginFactory(pluginFactory) {
+    if (this._pluginFactories.has(pluginFactory.name)) {
+      throw new Error(`LogM8: Plugin with name ${pluginFactory.name} is already registered.`);
+    }
+    this._pluginFactories.set(pluginFactory.name, pluginFactory);
+  }
+  /**
+   * Creates and registers a plugin instance using the matching factory.
+   * @param kind - The kind of plugin to create (appender, filter, formatter).
+   * @param nameOrConfig - Plugin name string or configuration object with plugin name.
+   * @returns The created plugin instance.
+   * @throws Error if no matching factory is found.
+   */
+  createPlugin(kind, nameOrConfig) {
+    const name = typeof nameOrConfig === "string" ? nameOrConfig : nameOrConfig.name;
+    const config = typeof nameOrConfig === "string" ? { name } : nameOrConfig;
+    const pluginFactory = this.getPluginFactory(name, kind);
+    if (!pluginFactory) {
+      throw new Error(`LogM8: Plugin factory kind '${kind}' with name '${name}' not found.`);
+    }
+    const plugin = pluginFactory.create(config);
+    this._plugins.push(plugin);
+    return plugin;
+  }
+  /**
+   * Retrieves a registered plugin factory by name and kind.
+   * @param name - The factory name.
+   * @param kind - The expected plugin kind.
+   * @returns The factory if found and matching kind, otherwise undefined.
+   */
+  getPluginFactory(name, kind) {
+    const pluginFactory = this._pluginFactories.get(name);
+    if (!pluginFactory || kind !== pluginFactory.kind) return;
+    return pluginFactory;
+  }
+  /**
+   * Disposes all created plugin instances by invoking their dispose methods.
+   * Clears the internal plugin list.
+   */
+  disposePlugins() {
+    this._plugins.forEach((plugin) => {
+      plugin.dispose();
+    });
+    this._plugins = [];
+  }
+  /**
+   * Clears all registered plugin factories without disposing instances.
+   */
+  clearFactories() {
+    this._pluginFactories.clear();
+  }
+};
+
+// src/LogM8.ts
+var MAX_LOG_BUFFER_SIZE = 100;
+var DEFAULT_APPENDERS = [
+  {
+    name: "console",
+    formatter: "default-formatter"
+  }
+];
+var LogM8 = class {
+  constructor() {
+    __publicField(this, "_initialized", false);
+    __publicField(this, "_pluginManager", new PluginManager());
+    __publicField(this, "_loggers", /* @__PURE__ */ new Map());
+    __publicField(this, "_appenders", []);
+    __publicField(this, "_filters", []);
+    __publicField(this, "_defaultLevel", LogLevel.info);
+    __publicField(this, "_logLevelValues", Object.values(LogLevel));
+    __publicField(this, "_logLevelSet", new Set(this._logLevelValues));
+    // Buffer for log events before the system is initialized
+    __publicField(this, "_logBuffer", []);
+    this._pluginManager.registerPluginFactory(new ConsoleAppenderFactory());
+    this._pluginManager.registerPluginFactory(new FileAppenderFactory());
+    this._pluginManager.registerPluginFactory(new DefaultFormatterFactory());
+    this._pluginManager.registerPluginFactory(new JsonFormatterFactory());
+    this._pluginManager.registerPluginFactory(new MatchFilterFactory());
+  }
+  /**
+   * Initializes the logging system with configuration and flushes any buffered events.
+   *
+   * Sets up default and per-logger levels, creates configured appenders with their
+   * formatters and filters, and processes any events buffered before initialization.
+   * Appenders are sorted by priority (descending) for deterministic execution order.
+   *
+   * @param config - Logging configuration object
+   * @param config.level - Default log level for all loggers ('info' if not specified)
+   * @param config.loggers - Per-logger level overrides by name
+   * @param config.appenders - Appender configurations (defaults to console if not specified)
+   *
+   * @throws {Error} When referenced plugin factories are not registered
+   *
+   * @example
+   * ```typescript
+   * Logging.init({
+   *   level: 'warn',
+   *   loggers: { 'app.database': 'debug' },
+   *   appenders: [{
+   *     name: 'console',
+   *     formatter: 'default-formatter',
+   *     filters: ['sensitive-data']
+   *   }]
+   * });
+   * ```
+   */
+  init(config) {
+    config = Object.assign({}, config);
+    this._reset();
+    this._defaultLevel = this._logLevelSet.has(config.level) ? config.level : LogLevel.info;
+    for (const [name, level] of Object.entries(config.loggers ?? {})) {
+      const logger = this.getLogger(name);
+      const l = this._logLevelSet.has(level) ? level : this._defaultLevel;
+      logger.setLevel(l);
+    }
+    const appenderConfigs = config.appenders ?? DEFAULT_APPENDERS;
+    for (const appenderConfig of appenderConfigs) {
+      const appender = this._pluginManager.createPlugin(
+        PluginKind.appender,
+        appenderConfig
+      );
+      const formatter = appenderConfig.formatter ? this._pluginManager.createPlugin(
+        PluginKind.formatter,
+        appenderConfig.formatter
+      ) : void 0;
+      const filters = [];
+      const ac = appenderConfig;
+      for (const filterConfig of ac.filters ?? []) {
+        const filter = this._pluginManager.createPlugin(PluginKind.filter, filterConfig);
+        if (filter) {
+          filters.push(filter);
+        } else {
+          if (console && console.log) {
+            console.log(
+              `LogM8: Filter '${filterConfig}' not found for appender ${appenderConfig.name}.`
+            );
+          }
+        }
+      }
+      appender.init(appenderConfig, formatter, filters);
+      this._appenders.push(appender);
+    }
+    this._sortAppenders();
+    for (const filterConfig of config.filters ?? []) {
+      const filter = this._pluginManager.createPlugin(PluginKind.filter, filterConfig);
+      if (filter) {
+        this._filters.push(filter);
+      } else {
+        if (console && console.log) {
+          console.log(`LogM8: Filter '${filterConfig}' not found (global).`);
+        }
+      }
+    }
+    this._initialized = true;
+  }
+  /**
+   * Shuts down the logging system and releases all resources.
+   *
+   * Flushes all appenders, disposes plugin instances, clears logger registry,
+   * discards buffered events, and deregisters plugin factories. The system
+   * can be reinitialized after disposal.
+   *
+   * @example
+   * ```typescript
+   * // Graceful shutdown
+   * await new Promise(resolve => {
+   *   Logging.flushAppenders();
+   *   setTimeout(() => {
+   *     Logging.dispose();
+   *     resolve();
+   *   }, 100);
+   * });
+   * ```
+   */
+  dispose() {
+    this._reset();
+    this._logBuffer = [];
+    this._pluginManager.clearFactories();
+    this._initialized = false;
+  }
+  /**
+   * Retrieves or creates a logger instance with hierarchical naming.
+   *
+   * Logger instances are cached and reused for the same name. Names can be
+   * provided as strings with dot-separation or as array segments that get
+   * joined. Each logger maintains independent level and context settings.
+   *
+   * @param name - Logger name as string ('app.service') or segments (['app', 'service'])
+   * @returns Logger instance for the specified name
+   *
+   * @example
+   * ```typescript
+   * const logger1 = Logging.getLogger('app.database');
+   * const logger2 = Logging.getLogger(['app', 'database']);
+   * // logger1 === logger2 (same instance)
+   *
+   * logger1.setLevel('debug');
+   * logger1.setContext({ service: 'postgres' });
+   * ```
+   */
+  getLogger(name) {
+    let nameStr = name;
+    if (Array.isArray(name)) {
+      nameStr = name.join(".");
+    }
+    const existingLogger = this._loggers.get(nameStr);
+    if (existingLogger) return existingLogger;
+    const logger = {
+      name: nameStr,
+      level: this._defaultLevel,
+      context: {}
+    };
+    logger.fatal = this._log.bind(this, logger, LogLevel.fatal);
+    logger.error = this._log.bind(this, logger, LogLevel.error);
+    logger.warn = this._log.bind(this, logger, LogLevel.warn);
+    logger.info = this._log.bind(this, logger, LogLevel.info);
+    logger.debug = this._log.bind(this, logger, LogLevel.debug);
+    logger.trace = this._log.bind(this, logger, LogLevel.trace);
+    logger.track = this._log.bind(this, logger, LogLevel.track);
+    logger.setLevel = this._setLevel.bind(this, logger);
+    logger.setContext = this._setContext.bind(this, logger);
+    logger.getLogger = (name2) => this.getLogger([logger.name, name2]);
+    this._setLevel(logger, this._defaultLevel);
+    this._loggers.set(logger.name, logger);
+    return logger;
+  }
+  /**
+   * Enables an appender to resume processing log events.
+   *
+   * @param name - Name of the appender to enable
+   */
+  enableAppender(name) {
+    const appender = this._getAppender(name);
+    if (!appender) return;
+    appender.enabled = true;
+  }
+  /**
+   * Disables an appender to stop processing log events.
+   *
+   * @param name - Name of the appender to disable
+   */
+  disableAppender(name) {
+    const appender = this._getAppender(name);
+    if (!appender) return;
+    appender.enabled = false;
+  }
+  /**
+   * Forces an appender to flush any buffered output.
+   *
+   * Catches and logs flush errors to console without interrupting operation.
+   * Useful for ensuring data persistence before shutdown or at intervals.
+   *
+   * @param name - Name of the appender to flush
+   */
+  flushAppender(name) {
+    const appender = this._getAppender(name);
+    if (!appender) return;
+    try {
+      appender.flush();
+    } catch (err) {
+      if (console && console.error) {
+        console.error(`LogM8: Failed to flush appender: ${appender.name}:`, err);
+      }
+    }
+  }
+  /**
+   * Flushes all configured appenders.
+   *
+   * Iterates through all appenders calling flush on each, with individual
+   * error handling per appender.
+   */
+  flushAppenders() {
+    for (const appender of this._appenders) {
+      this.flushAppender(appender.name);
+    }
+  }
+  /**
+   * Enables a filter to resume processing log events.
+   *
+   * When an appender name is provided, enables the filter only for that specific
+   * appender. When no appender is specified, enables the filter globally.
+   * Silently ignores requests for non-existent filters or appenders.
+   *
+   * @param name - Name of the filter to enable
+   * @param appenderName - Optional appender name to enable filter for specific appender only
+   *
+   * @example
+   * ```typescript
+   * // Enable filter globally
+   * Logging.enableFilter('sensitive-data');
+   *
+   * // Enable filter only for console appender
+   * Logging.enableFilter('debug-filter', 'console');
+   * ```
+   */
+  enableFilter(name, appenderName) {
+    if (appenderName) {
+      this._getAppender(appenderName)?.enableFilter(name);
+      return;
+    }
+    const filter = this._getFilter(name);
+    if (!filter) return;
+    filter.enabled = true;
+  }
+  /**
+   * Disables a filter to stop processing log events.
+   *
+   * When an appender name is provided, disables the filter only for that specific
+   * appender. When no appender is specified, disables the filter globally.
+   * Silently ignores requests for non-existent filters or appenders.
+   *
+   * @param name - Name of the filter to disable
+   * @param appenderName - Optional appender name to disable filter for specific appender only
+   *
+   * @example
+   * ```typescript
+   * // Disable filter globally
+   * Logging.disableFilter('sensitive-data');
+   *
+   * // Disable filter only for file appender
+   * Logging.disableFilter('debug-filter', 'file');
+   * ```
+   */
+  disableFilter(name, appenderName) {
+    if (appenderName) {
+      this._getAppender(appenderName)?.disableFilter(name);
+      return;
+    }
+    const filter = this._getFilter(name);
+    if (!filter) return;
+    filter.enabled = false;
+  }
+  /**
+   * Registers a custom plugin factory for appenders, formatters, or filters.
+   *
+   * Allows extending the logging system with custom implementations.
+   * Must be called before init() to be available during configuration.
+   *
+   * @param pluginFactory - Factory instance implementing the PluginFactory interface
+   *
+   * @example
+   * ```typescript
+   * class SlackAppenderFactory implements PluginFactory {
+   *   name = 'slack';
+   *   kind = PluginKind.appender;
+   *   create(config) { return new SlackAppender(config); }
+   * }
+   *
+   * Logging.registerPluginFactory(new SlackAppenderFactory());
+   * ```
+   */
+  registerPluginFactory(pluginFactory) {
+    this._pluginManager.registerPluginFactory(pluginFactory);
+  }
+  _log(logger, level, message, ...data) {
+    const levelNumber = this._logLevelValues.indexOf(level);
+    if (levelNumber > logger._levelNumber) return;
+    const logEvent = {
+      logger: logger.name,
+      level,
+      message,
+      data,
+      context: logger.context,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    if (this._initialized) {
+      if (this._logBuffer.length > 0) {
+        for (const bufferedEvent of this._logBuffer) {
+          this._processLogEvent(bufferedEvent);
+        }
+        this._logBuffer = [];
+      }
+      this._processLogEvent(logEvent);
+    } else {
+      if (this._logBuffer.length >= MAX_LOG_BUFFER_SIZE) {
+        this._logBuffer.shift();
+      }
+      this._logBuffer.push(logEvent);
+    }
+  }
+  _setLevel(logger, level) {
+    logger.level = level;
+    logger._levelNumber = this._logLevelValues.indexOf(level);
+    logger.isEnabled = level !== LogLevel.off;
+    const levelNumber = logger._levelNumber;
+    logger.isFatal = this._logLevelValues.indexOf(LogLevel.fatal) <= levelNumber;
+    logger.isError = this._logLevelValues.indexOf(LogLevel.error) <= levelNumber;
+    logger.isWarn = this._logLevelValues.indexOf(LogLevel.warn) <= levelNumber;
+    logger.isInfo = this._logLevelValues.indexOf(LogLevel.info) <= levelNumber;
+    logger.isDebug = this._logLevelValues.indexOf(LogLevel.debug) <= levelNumber;
+    logger.isTrack = this._logLevelValues.indexOf(LogLevel.track) <= levelNumber;
+    logger.isTrace = this._logLevelValues.indexOf(LogLevel.trace) <= levelNumber;
+  }
+  _setContext(logger, context) {
+    logger.context = context ?? {};
+  }
+  _processLogEvent(event) {
+    for (const filter of this._filters) {
+      if (filter.enabled && !filter.filter(event)) {
+        return;
+      }
+    }
+    for (const appender of this._appenders) {
+      try {
+        if (!appender.enabled) continue;
+        if (!appender.supportedLevels.has(event.level)) continue;
+        appender.write(event);
+      } catch (err) {
+        if (console && console.log) {
+          console.log(`LogM8: Failed to append log with '${appender.name}':`, err);
+        }
+      }
+    }
+  }
+  _getAppender(name) {
+    return this._appenders.find((a) => a.name === name);
+  }
+  _sortAppenders() {
+    this._appenders.sort((a, b) => {
+      const aPriority = a?.priority ?? 0;
+      const bPriority = b?.priority ?? 0;
+      return bPriority - aPriority;
+    });
+  }
+  _getFilter(name) {
+    return this._filters.find((f) => f.name === name);
+  }
+  _reset() {
+    this.flushAppenders();
+    this._appenders = [];
+    this._loggers.clear();
+    this._defaultLevel = LogLevel.info;
+    this._pluginManager.disposePlugins();
+  }
+};
+
+// src/index.ts
+var Logging = new LogM8();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LogLevel,
+  LogM8Utils,
+  Logging,
+  PluginKind
+});
+//# sourceMappingURL=index.cjs.map