@mks2508/better-logger 2.0.1 → 3.0.0

package/dist/chunks/Logger-C126NTrD.js

@@ -0,0 +1,4269 @@
+import { h as getAdaptiveColor, A as ADAPTIVE_COLORS, b as StyleBuilder, j as BUFFER_LIMITS, k as generateLogId, l as parseTimeInput, m as formatDisplayTime, n as safeStringify, o as escapeHtml, q as EXPORT_FORMATS, D as DEFAULT_CONFIG$1, r as setupThemeChangeListener, t as getEnvironment, p as parseStackTrace, f as formatTimestamp, c as createStyledOutput, S as StylePresets } from "./environment-TI2ByCPT.js";
+const DEFAULT_CONFIG = {
+  maxDepth: 5,
+  circular: "placeholder",
+  preserveUndefined: false
+};
+class SerializerRegistry {
+  serializers = /* @__PURE__ */ new Map();
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.registerDefaults();
+  }
+  registerDefaults() {
+    this.add(Error, (err) => ({
+      name: err.name,
+      message: err.message,
+      stack: err.stack?.split("\n").slice(0, 10),
+      ...err.cause ? { cause: this.serialize(err.cause) } : {}
+    }), 100);
+    this.add(Date, (date) => ({
+      iso: date.toISOString(),
+      timestamp: date.getTime()
+    }), 90);
+    this.add(RegExp, (regex) => ({
+      pattern: regex.source,
+      flags: regex.flags
+    }), 90);
+    this.add(Map, (map, ctx) => {
+      const obj = {};
+      map.forEach((value, key) => {
+        const keyStr = typeof key === "object" ? JSON.stringify(key) : String(key);
+        obj[keyStr] = this.serializeInternal(value, {
+          ...ctx,
+          depth: ctx.depth + 1,
+          path: [...ctx.path, keyStr]
+        });
+      });
+      return { __type: "Map", entries: obj };
+    }, 80);
+    this.add(Set, (set, ctx) => ({
+      __type: "Set",
+      values: Array.from(set).map(
+        (v, i) => this.serializeInternal(v, {
+          ...ctx,
+          depth: ctx.depth + 1,
+          path: [...ctx.path, `[${i}]`]
+        })
+      )
+    }), 80);
+    if (typeof Buffer !== "undefined") {
+      this.add(Buffer, (buf) => ({
+        __type: "Buffer",
+        length: buf.length,
+        preview: buf.slice(0, 50).toString("hex")
+      }), 70);
+    }
+  }
+  add(type, serializer, priority = 50) {
+    this.serializers.set(type, { type, serializer, priority });
+  }
+  remove(type) {
+    return this.serializers.delete(type);
+  }
+  has(type) {
+    return this.serializers.has(type);
+  }
+  getAll() {
+    return Array.from(this.serializers.values()).sort((a, b) => (b.priority ?? 50) - (a.priority ?? 50));
+  }
+  findSerializer(value) {
+    const sorted = this.getAll();
+    for (const entry of sorted) {
+      if (value instanceof entry.type) {
+        return entry;
+      }
+    }
+    return null;
+  }
+  serializeInternal(value, context) {
+    if (value === null) return null;
+    if (value === void 0) return this.config.preserveUndefined ? void 0 : "[undefined]";
+    if (typeof value === "function") return `[Function: ${value.name || "anonymous"}]`;
+    if (typeof value !== "object") return value;
+    if (context.depth >= this.config.maxDepth) {
+      return "[Max Depth]";
+    }
+    if (context.seen.has(value)) {
+      switch (this.config.circular) {
+        case "error":
+          throw new Error(`Circular reference at ${context.path.join(".")}`);
+        case "skip":
+          return void 0;
+        case "placeholder":
+        default:
+          return "[Circular]";
+      }
+    }
+    context.seen.add(value);
+    const serializer = this.findSerializer(value);
+    if (serializer) {
+      return serializer.serializer(value, context);
+    }
+    if (Array.isArray(value)) {
+      return value.map(
+        (item, i) => this.serializeInternal(item, {
+          ...context,
+          depth: context.depth + 1,
+          path: [...context.path, `[${i}]`]
+        })
+      );
+    }
+    const result = {};
+    for (const [key, val] of Object.entries(value)) {
+      result[key] = this.serializeInternal(val, {
+        ...context,
+        depth: context.depth + 1,
+        path: [...context.path, key]
+      });
+    }
+    return result;
+  }
+  serialize(value, config) {
+    const mergedConfig = { ...this.config, ...config };
+    return this.serializeInternal(value, {
+      depth: 0,
+      maxDepth: mergedConfig.maxDepth,
+      path: [],
+      seen: /* @__PURE__ */ new WeakSet()
+    });
+  }
+}
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+class HookManager {
+  hooks = /* @__PURE__ */ new Map();
+  middlewares = [];
+  constructor() {
+    this.hooks.set("beforeLog", []);
+    this.hooks.set("afterLog", []);
+    this.hooks.set("onError", []);
+  }
+  on(event, callback, priority = 50) {
+    const registration = {
+      id: generateId(),
+      event,
+      callback,
+      priority,
+      once: false
+    };
+    const hooks = this.hooks.get(event);
+    hooks.push(registration);
+    hooks.sort((a, b) => b.priority - a.priority);
+    return () => this.removeHook(event, registration.id);
+  }
+  once(event, callback, priority = 50) {
+    const registration = {
+      id: generateId(),
+      event,
+      callback,
+      priority,
+      once: true
+    };
+    const hooks = this.hooks.get(event);
+    hooks.push(registration);
+    hooks.sort((a, b) => b.priority - a.priority);
+    return () => this.removeHook(event, registration.id);
+  }
+  off(event, callback) {
+    const hooks = this.hooks.get(event);
+    if (!hooks) return false;
+    const index = hooks.findIndex((h) => h.callback === callback);
+    if (index >= 0) {
+      hooks.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  removeHook(event, id) {
+    const hooks = this.hooks.get(event);
+    if (hooks) {
+      const index = hooks.findIndex((h) => h.id === id);
+      if (index >= 0) {
+        hooks.splice(index, 1);
+      }
+    }
+  }
+  use(middleware, priority = 50) {
+    const registration = {
+      id: generateId(),
+      fn: middleware,
+      priority
+    };
+    this.middlewares.push(registration);
+    this.middlewares.sort((a, b) => b.priority - a.priority);
+    return () => {
+      const index = this.middlewares.findIndex((m) => m.id === registration.id);
+      if (index >= 0) {
+        this.middlewares.splice(index, 1);
+      }
+    };
+  }
+  async emit(event, entry) {
+    const hooks = this.hooks.get(event) || [];
+    let currentEntry = { ...entry };
+    const toRemove = [];
+    for (const hook of hooks) {
+      try {
+        const result = await hook.callback(currentEntry);
+        if (result) {
+          currentEntry = { ...currentEntry, ...result };
+        }
+        if (hook.once) {
+          toRemove.push(hook.id);
+        }
+      } catch (error) {
+        if (event !== "onError") {
+          await this.emit("onError", {
+            ...currentEntry,
+            error,
+            hookEvent: event
+          });
+        }
+      }
+    }
+    toRemove.forEach((id) => this.removeHook(event, id));
+    return currentEntry;
+  }
+  async process(entry) {
+    let currentEntry = { ...entry };
+    currentEntry = await this.emit("beforeLog", currentEntry);
+    if (this.middlewares.length > 0) {
+      let index = 0;
+      const executeNext = async () => {
+        if (index < this.middlewares.length) {
+          const middleware = this.middlewares[index++];
+          if (middleware) {
+            await middleware.fn(currentEntry, executeNext);
+          }
+        }
+      };
+      await executeNext();
+    }
+    return currentEntry;
+  }
+  async afterProcess(entry) {
+    await this.emit("afterLog", entry);
+  }
+  clear() {
+    this.hooks.forEach((hooks) => hooks.length = 0);
+    this.middlewares.length = 0;
+  }
+  getStats() {
+    return {
+      hooks: {
+        beforeLog: this.hooks.get("beforeLog")?.length || 0,
+        afterLog: this.hooks.get("afterLog")?.length || 0,
+        onError: this.hooks.get("onError")?.length || 0
+      },
+      middlewares: this.middlewares.length
+    };
+  }
+}
+const LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  critical: 4
+};
+function generateTransportId() {
+  return `transport-${Date.now()}-${Math.random().toString(36).substr(2, 6)}`;
+}
+class TransportManager {
+  transports = /* @__PURE__ */ new Map();
+  defaultLevel = "info";
+  constructor(defaultLevel) {
+    if (defaultLevel) {
+      this.defaultLevel = defaultLevel;
+    }
+  }
+  add(target) {
+    const id = generateTransportId();
+    const level = target.level || this.defaultLevel;
+    let transport;
+    if (typeof target.target === "string") {
+      throw new Error(`String transport targets not supported. Use inline transport object.`);
+    } else {
+      transport = target.target;
+    }
+    const entry = {
+      id,
+      transport,
+      options: target.options || {},
+      level,
+      levelValue: LOG_LEVELS[level]
+    };
+    this.transports.set(id, entry);
+    return id;
+  }
+  remove(id) {
+    const entry = this.transports.get(id);
+    if (entry) {
+      entry.transport.close?.();
+      return this.transports.delete(id);
+    }
+    return false;
+  }
+  async write(record) {
+    const promises = [];
+    for (const entry of this.transports.values()) {
+      if (record.levelValue < entry.levelValue) {
+        continue;
+      }
+      let transformedRecord = record;
+      if (entry.options.transform) {
+        const result2 = entry.options.transform(record);
+        if (result2 === null) continue;
+        transformedRecord = result2;
+      }
+      const result = entry.transport.write(transformedRecord);
+      if (result instanceof Promise) {
+        promises.push(result);
+      }
+    }
+    await Promise.all(promises);
+  }
+  async flush() {
+    const promises = [];
+    for (const entry of this.transports.values()) {
+      if (entry.transport.flush) {
+        const result = entry.transport.flush();
+        if (result instanceof Promise) {
+          promises.push(result);
+        }
+      }
+    }
+    await Promise.all(promises);
+  }
+  async close() {
+    await this.flush();
+    const promises = [];
+    for (const entry of this.transports.values()) {
+      if (entry.transport.close) {
+        const result = entry.transport.close();
+        if (result instanceof Promise) {
+          promises.push(result);
+        }
+      }
+    }
+    await Promise.all(promises);
+    this.transports.clear();
+  }
+  get count() {
+    return this.transports.size;
+  }
+  list() {
+    return Array.from(this.transports.keys());
+  }
+}
+const THEME_PRESETS = {
+  default: {
+    debug: {
+      emoji: "🐞",
+      label: "DEBUG",
+      background: "linear-gradient(135deg, #667eea 0%, #764ba2 100%)",
+      color: "#ffffff",
+      border: "1px solid #667eea",
+      shadow: "0 2px 4px rgba(102, 126, 234, 0.3)"
+    },
+    info: {
+      emoji: "ℹ️",
+      label: "INFO",
+      background: "linear-gradient(135deg, #74b9ff 0%, #0984e3 100%)",
+      color: "#ffffff",
+      border: "1px solid #74b9ff",
+      shadow: "0 2px 4px rgba(116, 185, 255, 0.3)"
+    },
+    warn: {
+      emoji: "⚠️",
+      label: "WARN",
+      background: "linear-gradient(135deg, #fdcb6e 0%, #e17055 100%)",
+      color: "#2d3436",
+      border: "1px solid #fdcb6e",
+      shadow: "0 2px 4px rgba(253, 203, 110, 0.3)"
+    },
+    error: {
+      emoji: "❌",
+      label: "ERROR",
+      background: "linear-gradient(135deg, #e84393 0%, #d63031 100%)",
+      color: "#ffffff",
+      border: "1px solid #e84393",
+      shadow: "0 2px 4px rgba(232, 67, 147, 0.3)"
+    },
+    success: {
+      emoji: "✅",
+      label: "SUCCESS",
+      background: "linear-gradient(135deg, #00b894 0%, #00a085 100%)",
+      color: "#ffffff",
+      border: "1px solid #00b894",
+      shadow: "0 2px 4px rgba(0, 184, 148, 0.3)"
+    },
+    critical: {
+      emoji: "🔥",
+      label: "CRITICAL",
+      background: "linear-gradient(135deg, #ff3838 0%, #ff1744 100%)",
+      color: "#ffffff",
+      border: "2px solid #ff3838",
+      shadow: "0 4px 8px rgba(255, 56, 56, 0.5)"
+    }
+  },
+  dark: {
+    debug: {
+      emoji: "🌙",
+      label: "DEBUG",
+      background: "linear-gradient(135deg, #2d3748 0%, #4a5568 100%)",
+      color: "#e2e8f0",
+      border: "1px solid #4a5568",
+      shadow: "0 2px 4px rgba(45, 55, 72, 0.8)"
+    },
+    info: {
+      emoji: "💡",
+      label: "INFO",
+      background: "linear-gradient(135deg, #1a202c 0%, #2d3748 100%)",
+      color: "#90cdf4",
+      border: "1px solid #3182ce",
+      shadow: "0 2px 4px rgba(26, 32, 44, 0.8)"
+    },
+    warn: {
+      emoji: "⚡",
+      label: "WARN",
+      background: "linear-gradient(135deg, #744210 0%, #975a16 100%)",
+      color: "#faf089",
+      border: "1px solid #d69e2e",
+      shadow: "0 2px 4px rgba(116, 66, 16, 0.8)"
+    },
+    error: {
+      emoji: "💀",
+      label: "ERROR",
+      background: "linear-gradient(135deg, #742a2a 0%, #9b2c2c 100%)",
+      color: "#feb2b2",
+      border: "1px solid #e53e3e",
+      shadow: "0 2px 4px rgba(116, 42, 42, 0.8)"
+    },
+    success: {
+      emoji: "🎯",
+      label: "SUCCESS",
+      background: "linear-gradient(135deg, #276749 0%, #2f855a 100%)",
+      color: "#9ae6b4",
+      border: "1px solid #38a169",
+      shadow: "0 2px 4px rgba(39, 103, 73, 0.8)"
+    },
+    critical: {
+      emoji: "💥",
+      label: "CRITICAL",
+      background: "linear-gradient(135deg, #1a1a1a 0%, #ff0000 100%)",
+      color: "#ffffff",
+      border: "2px solid #ff0000",
+      shadow: "0 4px 8px rgba(255, 0, 0, 0.9)"
+    }
+  },
+  neon: {
+    debug: {
+      emoji: "⚡",
+      label: "DEBUG",
+      background: "linear-gradient(135deg, #0f3460 0%, #e94560 100%)",
+      color: "#00ffff",
+      border: "1px solid #00ffff",
+      shadow: "0 0 10px rgba(0, 255, 255, 0.5)"
+    },
+    info: {
+      emoji: "🔮",
+      label: "INFO",
+      background: "linear-gradient(135deg, #16213e 0%, #0f3460 100%)",
+      color: "#00ff41",
+      border: "1px solid #00ff41",
+      shadow: "0 0 10px rgba(0, 255, 65, 0.5)"
+    },
+    warn: {
+      emoji: "⚠️",
+      label: "WARN",
+      background: "linear-gradient(135deg, #533a03 0%, #e94560 100%)",
+      color: "#ffff00",
+      border: "1px solid #ffff00",
+      shadow: "0 0 10px rgba(255, 255, 0, 0.5)"
+    },
+    error: {
+      emoji: "💥",
+      label: "ERROR",
+      background: "linear-gradient(135deg, #5c0a0a 0%, #ff073a 100%)",
+      color: "#ff073a",
+      border: "1px solid #ff073a",
+      shadow: "0 0 10px rgba(255, 7, 58, 0.8)"
+    },
+    success: {
+      emoji: "✨",
+      label: "SUCCESS",
+      background: "linear-gradient(135deg, #0a5c0a 0%, #39ff14 100%)",
+      color: "#39ff14",
+      border: "1px solid #39ff14",
+      shadow: "0 0 10px rgba(57, 255, 20, 0.8)"
+    },
+    critical: {
+      emoji: "🌟",
+      label: "CRITICAL",
+      background: "linear-gradient(135deg, #000000 0%, #ff0080 100%)",
+      color: "#ff0080",
+      border: "2px solid #ff0080",
+      shadow: "0 0 20px rgba(255, 0, 128, 1)"
+    }
+  },
+  minimal: {
+    debug: {
+      emoji: "",
+      label: "DEBUG",
+      background: "#f7fafc",
+      color: "#4a5568",
+      border: "1px solid #e2e8f0",
+      shadow: "none"
+    },
+    info: {
+      emoji: "",
+      label: "INFO",
+      background: "#ebf8ff",
+      color: "#2b6cb0",
+      border: "1px solid #bee3f8",
+      shadow: "none"
+    },
+    warn: {
+      emoji: "",
+      label: "WARN",
+      background: "#fffbf0",
+      color: "#c05621",
+      border: "1px solid #fed7aa",
+      shadow: "none"
+    },
+    error: {
+      emoji: "",
+      label: "ERROR",
+      background: "#fef5f5",
+      color: "#c53030",
+      border: "1px solid #fca5a5",
+      shadow: "none"
+    },
+    success: {
+      emoji: "",
+      label: "SUCCESS",
+      background: "#f0fff4",
+      color: "#2f855a",
+      border: "1px solid #9ae6b4",
+      shadow: "none"
+    },
+    critical: {
+      emoji: "",
+      label: "CRITICAL",
+      background: "#fef5f5",
+      color: "#e53e3e",
+      border: "2px solid #f56565",
+      shadow: "none"
+    }
+  },
+  // Additional theme variants can be added here
+  light: {
+    debug: {
+      emoji: "🔍",
+      label: "DEBUG",
+      background: "linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%)",
+      color: "#1565c0",
+      border: "1px solid #90caf9",
+      shadow: "0 1px 3px rgba(33, 150, 243, 0.2)"
+    },
+    info: {
+      emoji: "ℹ️",
+      label: "INFO",
+      background: "linear-gradient(135deg, #f3e5f5 0%, #e1bee7 100%)",
+      color: "#7b1fa2",
+      border: "1px solid #ce93d8",
+      shadow: "0 1px 3px rgba(156, 39, 176, 0.2)"
+    },
+    warn: {
+      emoji: "⚠️",
+      label: "WARN",
+      background: "linear-gradient(135deg, #fff8e1 0%, #ffecb3 100%)",
+      color: "#f57c00",
+      border: "1px solid #ffcc02",
+      shadow: "0 1px 3px rgba(255, 152, 0, 0.2)"
+    },
+    error: {
+      emoji: "❌",
+      label: "ERROR",
+      background: "linear-gradient(135deg, #ffebee 0%, #ffcdd2 100%)",
+      color: "#d32f2f",
+      border: "1px solid #f44336",
+      shadow: "0 1px 3px rgba(244, 67, 54, 0.2)"
+    },
+    success: {
+      emoji: "✅",
+      label: "SUCCESS",
+      background: "linear-gradient(135deg, #e8f5e8 0%, #c8e6c9 100%)",
+      color: "#388e3c",
+      border: "1px solid #4caf50",
+      shadow: "0 1px 3px rgba(76, 175, 80, 0.2)"
+    },
+    critical: {
+      emoji: "🚨",
+      label: "CRITICAL",
+      background: "linear-gradient(135deg, #fce4ec 0%, #f8bbd9 100%)",
+      color: "#c2185b",
+      border: "2px solid #e91e63",
+      shadow: "0 2px 6px rgba(233, 30, 99, 0.3)"
+    }
+  },
+  cyberpunk: {
+    debug: {
+      emoji: "🤖",
+      label: "DEBUG",
+      background: "linear-gradient(135deg, #0d1b2a 0%, #415a77 100%)",
+      color: "#00d4aa",
+      border: "1px solid #00d4aa",
+      shadow: "0 0 15px rgba(0, 212, 170, 0.4)"
+    },
+    info: {
+      emoji: "🔗",
+      label: "INFO",
+      background: "linear-gradient(135deg, #1b263b 0%, #0d1b2a 100%)",
+      color: "#00b4d8",
+      border: "1px solid #00b4d8",
+      shadow: "0 0 15px rgba(0, 180, 216, 0.4)"
+    },
+    warn: {
+      emoji: "⚡",
+      label: "WARN",
+      background: "linear-gradient(135deg, #f72585 0%, #b5179e 100%)",
+      color: "#ffff3f",
+      border: "1px solid #ffff3f",
+      shadow: "0 0 15px rgba(255, 255, 63, 0.4)"
+    },
+    error: {
+      emoji: "💀",
+      label: "ERROR",
+      background: "linear-gradient(135deg, #7209b7 0%, #480ca8 100%)",
+      color: "#ff006e",
+      border: "1px solid #ff006e",
+      shadow: "0 0 15px rgba(255, 0, 110, 0.6)"
+    },
+    success: {
+      emoji: "⚡",
+      label: "SUCCESS",
+      background: "linear-gradient(135deg, #003566 0%, #001d3d 100%)",
+      color: "#00f5ff",
+      border: "1px solid #00f5ff",
+      shadow: "0 0 15px rgba(0, 245, 255, 0.4)"
+    },
+    critical: {
+      emoji: "💥",
+      label: "CRITICAL",
+      background: "linear-gradient(135deg, #000000 0%, #ff0040 100%)",
+      color: "#ff0040",
+      border: "2px solid #ff0040",
+      shadow: "0 0 25px rgba(255, 0, 64, 0.8)"
+    }
+  }
+};
+const BANNER_VARIANTS = {
+  simple: {
+    text: "🚀 ADVANCED LOGGER v2.0.0 - State-of-the-art Console Styling 🚀",
+    style: "background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 12px 20px; border-radius: 8px; font-weight: bold; font-size: 14px;"
+  },
+  ascii: {
+    text: `
+   ___     ____  _   __   ___     _   __  _____ _____ ____     __     ___    _____ _____ _____ ____  
+  / _ \\   / __ \\| | / /  / _ \\   | \\ | |/ ____| ____|  _ \\   |  |   / _ \\  / ____|  ___|  _  |  _ \\ 
+ / /_\\ \\ / / _\` | |/ /  / /_\\ \\  |  \\| | |   | |__  | | | |  |  |  / / \\ \\| |  __| |_  | |_| | |_) |
+ |  _  || | (_| |   <   |  _  |  | . \` | |   |  __| | | | |  |  | | |   | | | |_ |  _| |    /|  _ < 
+ | | | |\\ \\__,_|_|\\_\\  | | | |  | |\\  | |___| |____| |_| |  |  |__\\ \\_/ /| |__| | |___| |\\ \\| |_) |
+ \\_| |_/ \\____/        \\_| |_/  |_| \\_|\\_____|______|____/   |_____/\\___/  \\_____|_____|_| \\_|____/
+
+                            Advanced Logger v2.0.0 - Console Excellence`,
+    style: 'font-family: "Courier New", Consolas, Monaco, monospace; color: #667eea; font-size: 11px; line-height: 1.2;'
+  },
+  unicode: {
+    text: `
+╔══════════════════════════════════════════════════════════════════════════╗
+║                         🚀 ADVANCED LOGGER v2.0.0                       ║
+║                      State-of-the-art Console Styling                    ║  
+╚══════════════════════════════════════════════════════════════════════════╝`,
+    style: 'font-family: "Courier New", Consolas, Monaco, monospace; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 15px; border-radius: 8px; font-size: 12px; line-height: 1.3;'
+  },
+  svg: {
+    text: "                    ",
+    style: `
+            background-image: url("data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 400 80'><defs><linearGradient id='grad' x1='0%' y1='0%' x2='100%' y2='0%'><stop offset='0%' style='stop-color:%23667eea'/><stop offset='100%' style='stop-color:%23764ba2'/></linearGradient></defs><rect width='100%' height='100%' fill='url(%23grad)' rx='8'/><text x='200' y='30' text-anchor='middle' fill='white' font-family='monospace' font-size='14' font-weight='bold'>🚀 ADVANCED LOGGER</text><text x='200' y='50' text-anchor='middle' fill='white' font-family='monospace' font-size='12'>State-of-the-art Console Styling</text><text x='200' y='65' text-anchor='middle' fill='white' font-family='monospace' font-size='10'>v2.0.0</text></svg>");
+            background-repeat: no-repeat;
+            background-size: 400px 80px;
+            padding: 40px 200px;
+            color: transparent;
+            display: inline-block;
+            border-radius: 8px;
+        `
+  },
+  animated: {
+    text: "         🚀 ADVANCED LOGGER v2.0.0         ",
+    style: `
+            background: linear-gradient(-45deg, #667eea, #764ba2, #667eea, #764ba2);
+            background-size: 400% 400%;
+            color: white;
+            padding: 15px 25px;
+            border-radius: 10px;
+            font-weight: bold;
+            font-size: 14px;
+            font-family: monospace;
+            animation: gradientShift 3s ease infinite;
+            display: inline-block;
+        `
+  }
+};
+const THEME_BANNERS = {
+  default: {
+    simple: "🚀 ADVANCED LOGGER v2.0.0 - State-of-the-art Console Styling 🚀",
+    style: "background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 12px 20px; border-radius: 8px; font-weight: bold;"
+  },
+  dark: {
+    simple: "🌙 ADVANCED LOGGER v2.0.0 - Dark Mode Console Excellence 🌙",
+    style: "background: linear-gradient(135deg, #1a202c 0%, #2d3748 100%); color: #e2e8f0; padding: 12px 20px; border-radius: 8px; font-weight: bold; border: 1px solid #4a5568;"
+  },
+  neon: {
+    simple: "⚡ ADVANCED LOGGER v2.0.0 - Cyberpunk Console Experience ⚡",
+    style: "background: linear-gradient(135deg, #0f3460 0%, #e94560 100%); color: #00ffff; padding: 12px 20px; border-radius: 8px; font-weight: bold; text-shadow: 0 0 10px #00ffff;"
+  },
+  minimal: {
+    simple: "ADVANCED LOGGER v2.0.0 - Clean Console Styling",
+    style: "background: #f7fafc; color: #2d3748; padding: 8px 16px; border: 1px solid #e2e8f0; border-radius: 4px; font-weight: 500;"
+  },
+  light: {
+    simple: "☀️ ADVANCED LOGGER v2.0.0 - Bright Console Styling ☀️",
+    style: "background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%); color: #495057; padding: 12px 20px; border-radius: 8px; font-weight: bold; border: 1px solid #dee2e6;"
+  },
+  cyberpunk: {
+    simple: "🤖 ADVANCED LOGGER v2.0.0 - Neural Console Interface 🤖",
+    style: "background: linear-gradient(135deg, #0d1b2a 0%, #415a77 100%); color: #00d4aa; padding: 12px 20px; border-radius: 8px; font-weight: bold; text-shadow: 0 0 10px #00d4aa; border: 1px solid #00d4aa;"
+  }
+};
+function detectBannerCapabilities() {
+  const userAgent = navigator.userAgent;
+  const isChrome = /Chrome/.test(userAgent);
+  const isFirefox = /Firefox/.test(userAgent);
+  const isSafari = /Safari/.test(userAgent) && !/Chrome/.test(userAgent);
+  const supportsSVG = !!document.createElementNS && !!document.createElementNS("http://www.w3.org/2000/svg", "svg").createSVGRect;
+  const supportsAnimations = typeof document !== "undefined" && "animationName" in document.createElement("div").style;
+  if (supportsAnimations && isChrome) {
+    return "animated";
+  } else if (supportsSVG && (isChrome || isFirefox)) {
+    return "svg";
+  } else if (isChrome || isFirefox) {
+    return "unicode";
+  } else if (isSafari) {
+    return "ascii";
+  }
+  return "simple";
+}
+function displayInitBanner(bannerType) {
+  const selectedType = bannerType || detectBannerCapabilities();
+  const banner = BANNER_VARIANTS[selectedType];
+  if (selectedType === "animated") {
+    const style = document.createElement("style");
+    style.textContent = `
+            @keyframes gradientShift {
+                0% { background-position: 0% 50%; }
+                50% { background-position: 100% 50%; }
+                100% { background-position: 0% 50%; }
+            }
+        `;
+    document.head.appendChild(style);
+  }
+  console.log(`%c${banner.text}`, banner.style);
+  const features = [
+    "🎨 Advanced CSS Console Styling",
+    "📍 Automatic Stack Trace Parsing",
+    "🔧 Scoped Loggers & Prefixes",
+    "⚡ Performance Timers",
+    "🎯 Verbosity Filtering",
+    "🔌 Extensible Handlers",
+    "📱 Modern TypeScript Patterns",
+    "📤 Export & Clipboard Support"
+  ];
+  console.group(`%c✨ Features`, "background: #f8f9fa; color: #495057; padding: 4px 8px; border-radius: 4px; font-weight: bold;");
+  features.forEach((feature) => {
+    console.log(`%c${feature}`, "color: #6c757d; font-size: 13px;");
+  });
+  console.groupEnd();
+  console.log("");
+}
+class BaseStyler {
+  builder;
+  constructor(builder = new StyleBuilder()) {
+    this.builder = builder;
+  }
+  /**
+   * Primary brand color (typically blue)
+   */
+  primary() {
+    return this.color("#007bff");
+  }
+  /**
+   * Secondary color (typically gray)
+   */
+  secondary() {
+    return this.color("#6c757d");
+  }
+  /**
+   * Accent color for highlights
+   */
+  accent() {
+    return this.color("#17a2b8");
+  }
+  /**
+   * Muted/subtle color - automatically adaptive
+   */
+  muted() {
+    const mutedColors = { light: "#6c757d", dark: "#a0aec0" };
+    return this.color(getAdaptiveColor(mutedColors));
+  }
+  /**
+   * Success color (green)
+   */
+  success() {
+    return this.color("#28a745");
+  }
+  /**
+   * Warning color (yellow/orange)
+   */
+  warning() {
+    return this.color("#ffc107");
+  }
+  /**
+   * Danger/error color (red)
+   */
+  danger() {
+    return this.color("#dc3545");
+  }
+  /**
+   * Monospace font family
+   */
+  mono() {
+    this.builder.font('Monaco, Consolas, "Courier New", monospace');
+    return this;
+  }
+  /**
+   * System font family
+   */
+  system() {
+    this.builder.font('system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif');
+    return this;
+  }
+  /**
+   * Readable font optimized for text
+   */
+  readable() {
+    this.builder.font('Georgia, "Times New Roman", serif');
+    return this;
+  }
+  /**
+   * Compact spacing
+   */
+  compact() {
+    this.builder.padding("1px 4px").margin("0 1px");
+    return this;
+  }
+  /**
+   * Spacious layout
+   */
+  spacious() {
+    this.builder.padding("6px 12px").margin("2px 4px");
+    return this;
+  }
+  /**
+   * Inline display
+   */
+  inline() {
+    this.builder.display("inline-block");
+    return this;
+  }
+  /**
+   * Glass morphism effect
+   */
+  glassmorphic() {
+    this.builder.css("backdrop-filter", "blur(10px)").css("background", "rgba(255, 255, 255, 0.1)").border("1px solid rgba(255, 255, 255, 0.2)").rounded("8px");
+    return this;
+  }
+  /**
+   * Neon glow effect
+   */
+  neon() {
+    const neonColor = "#00ffff";
+    this.builder.color(neonColor).border(`1px solid ${neonColor}`).shadow(`0 0 10px ${neonColor}, 0 0 20px ${neonColor}`).css("text-shadow", `0 0 5px ${neonColor}`);
+    return this;
+  }
+  /**
+   * Gradient background
+   */
+  gradient(from = "#667eea", to = "#764ba2") {
+    this.builder.bg(`linear-gradient(135deg, ${from} 0%, ${to} 100%)`);
+    return this;
+  }
+  /**
+   * Bold text
+   */
+  bold() {
+    this.builder.bold();
+    return this;
+  }
+  /**
+   * Set color with automatic adaptation
+   */
+  color(color) {
+    this.builder.color(color);
+    return this;
+  }
+  /**
+   * Build the final CSS string
+   */
+  build() {
+    return this.builder.build();
+  }
+}
+class TimestampStyler extends BaseStyler {
+  /**
+   * Default timestamp style - subtle and informative
+   */
+  default() {
+    this.muted().mono();
+    this.builder.size("11px");
+    return this;
+  }
+  /**
+   * Hide timestamp
+   */
+  hidden() {
+    this.builder.display("none");
+    return this;
+  }
+  /**
+   * Minimal timestamp (just time, no date)
+   */
+  minimal() {
+    this.muted().mono();
+    this.builder.size("10px").opacity(0.7);
+    return this;
+  }
+  /**
+   * Set font size
+   */
+  size(size) {
+    this.builder.size(size);
+    return this;
+  }
+}
+class LevelStyler extends BaseStyler {
+  /**
+   * Colorful gradient badge
+   */
+  badge() {
+    this.builder.padding("2px 8px").rounded("4px").bold().color("#ffffff");
+    return this;
+  }
+  /**
+   * Glowing effect for dark themes
+   */
+  glowing() {
+    return this.neon().badge();
+  }
+  /**
+   * Minimal flat style
+   */
+  flat() {
+    this.builder.padding("1px 6px").rounded("2px").border("1px solid currentColor").css("background", "transparent");
+    return this;
+  }
+  /**
+   * Uppercase text
+   */
+  uppercase() {
+    this.builder.uppercase();
+    return this;
+  }
+}
+class PrefixStyler extends BaseStyler {
+  /**
+   * Dark theme prefix
+   */
+  dark() {
+    const prefixColors = { light: "#2d3748", dark: "#4a5568" };
+    const textColors = { light: "#e2e8f0", dark: "#f7fafc" };
+    this.builder.bg(getAdaptiveColor(prefixColors)).color(getAdaptiveColor(textColors)).padding("2px 6px").rounded("3px").bold().mono().size("11px");
+    return this;
+  }
+  /**
+   * Light theme prefix
+   */
+  light() {
+    this.builder.bg("#f8f9fa").color("#495057").padding("2px 6px").rounded("3px").bold().mono().size("11px").border("1px solid #dee2e6");
+    return this;
+  }
+  /**
+   * Compact prefix
+   */
+  compact() {
+    this.builder.padding("1px 4px").size("10px").rounded("2px");
+    return this;
+  }
+}
+class MessageStyler extends BaseStyler {
+  /**
+   * Readable message text - automatically adaptive
+   */
+  readable() {
+    this.builder.color(getAdaptiveColor(ADAPTIVE_COLORS.messageText)).system().size("14px");
+    return this;
+  }
+  /**
+   * Code-style monospace text
+   */
+  code() {
+    this.builder.mono().size("13px").color(getAdaptiveColor(ADAPTIVE_COLORS.messageText)).bg("rgba(0, 0, 0, 0.05)").padding("1px 4px").rounded("3px");
+    return this;
+  }
+  /**
+   * Large, prominent text
+   */
+  large() {
+    this.builder.size("16px").color(getAdaptiveColor(ADAPTIVE_COLORS.messageText));
+    return this;
+  }
+}
+class LocationStyler extends BaseStyler {
+  /**
+   * Subtle location info - automatically adaptive
+   */
+  subtle() {
+    this.builder.color(getAdaptiveColor(ADAPTIVE_COLORS.location)).mono().size("11px").opacity(0.7);
+    return this;
+  }
+  /**
+   * Hide location info
+   */
+  hidden() {
+    this.builder.display("none");
+    return this;
+  }
+  /**
+   * Clickable style (for IDE integration)
+   */
+  clickable() {
+    this.subtle();
+    this.builder.css("text-decoration", "underline").cursor("pointer");
+    return this;
+  }
+}
+class LogStyleBuilder {
+  logStyles = {};
+  logger;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  /**
+   * Configure timestamp styling
+   */
+  timestamp() {
+    return new TimestampStyleBuilderProxy(this);
+  }
+  /**
+   * Configure level badge styling
+   */
+  level() {
+    return new LevelStyleBuilderProxy(this);
+  }
+  /**
+   * Configure prefix styling
+   */
+  prefix() {
+    return new PrefixStyleBuilderProxy(this);
+  }
+  /**
+   * Configure message text styling
+   */
+  message() {
+    return new MessageStyleBuilderProxy(this);
+  }
+  /**
+   * Configure location info styling
+   */
+  location() {
+    return new LocationStyleBuilderProxy(this);
+  }
+  /**
+   * Use a predefined preset
+   */
+  usePreset(presetName) {
+    console.warn(`Preset '${presetName}' will be available in next implementation phase`);
+    return this;
+  }
+  /**
+   * Customize with partial configuration
+   */
+  customize(overrides) {
+    this.logStyles = { ...this.logStyles, ...overrides };
+    return this;
+  }
+  /**
+   * Set layout spacing
+   */
+  spacing(type) {
+    if (!this.logStyles.layout) {
+      this.logStyles.layout = { spacing: type };
+    } else {
+      this.logStyles.layout.spacing = type;
+    }
+    switch (type) {
+      case "compact":
+        this.logStyles.layout.innerPadding = "1px";
+        this.logStyles.layout.outerMargin = "0px";
+        break;
+      case "spacious":
+        this.logStyles.layout.innerPadding = "4px";
+        this.logStyles.layout.outerMargin = "2px";
+        break;
+      default:
+        this.logStyles.layout.innerPadding = "2px";
+        this.logStyles.layout.outerMargin = "1px";
+    }
+    return this;
+  }
+  /**
+   * Set backdrop filter for glassmorphism effects
+   */
+  backdrop(filter) {
+    this.logStyles.backdrop = filter;
+    return this;
+  }
+  /**
+   * Set overall transparency
+   */
+  transparency(value) {
+    this.logStyles.transparency = Math.max(0, Math.min(1, value));
+    return this;
+  }
+  /**
+   * Apply the configured styles to the logger
+   */
+  apply() {
+    this.logger._customLogStyles = this.logStyles;
+    console.log("Applied log styles:", this.logStyles);
+  }
+  /**
+   * Get current configuration (for debugging)
+   */
+  getConfig() {
+    return { ...this.logStyles };
+  }
+  /**
+   * Internal method to update part configuration
+   */
+  _updatePartConfig(part, styles) {
+    if (part === "layout" || part === "backdrop" || part === "transparency") {
+      return;
+    }
+    if (!this.logStyles[part]) {
+      this.logStyles[part] = {};
+    }
+    this.logStyles[part].style = styles;
+  }
+}
+class PartStyleBuilderProxy {
+  parentBuilder;
+  partName;
+  constructor(parentBuilder, partName) {
+    this.parentBuilder = parentBuilder;
+    this.partName = partName;
+  }
+  /**
+   * Return to the main builder for chaining other parts
+   */
+  and() {
+    return this.parentBuilder;
+  }
+  /**
+   * Apply styles and finish configuration
+   */
+  apply() {
+    this.parentBuilder.apply();
+  }
+  /**
+   * Helper to apply styles to the parent builder
+   */
+  applyStyles(styler) {
+    const styles = styler.build();
+    this.parentBuilder._updatePartConfig(this.partName, styles);
+    return this;
+  }
+}
+class TimestampStyleBuilderProxy extends PartStyleBuilderProxy {
+  constructor(parentBuilder) {
+    super(parentBuilder, "timestamp");
+  }
+  default() {
+    return this.applyStyles(new TimestampStyler().default());
+  }
+  hidden() {
+    return this.applyStyles(new TimestampStyler().hidden());
+  }
+  minimal() {
+    return this.applyStyles(new TimestampStyler().minimal());
+  }
+  muted() {
+    return this.applyStyles(new TimestampStyler().muted());
+  }
+  mono() {
+    return this.applyStyles(new TimestampStyler().mono());
+  }
+  compact() {
+    return this.applyStyles(new TimestampStyler().compact());
+  }
+}
+class LevelStyleBuilderProxy extends PartStyleBuilderProxy {
+  constructor(parentBuilder) {
+    super(parentBuilder, "level");
+  }
+  badge() {
+    return this.applyStyles(new LevelStyler().badge());
+  }
+  gradient(from, to) {
+    return this.applyStyles(new LevelStyler().gradient(from, to));
+  }
+  glowing() {
+    return this.applyStyles(new LevelStyler().glowing());
+  }
+  flat() {
+    return this.applyStyles(new LevelStyler().flat());
+  }
+  bold() {
+    return this.applyStyles(new LevelStyler().bold());
+  }
+  uppercase() {
+    return this.applyStyles(new LevelStyler().uppercase());
+  }
+  neon() {
+    return this.applyStyles(new LevelStyler().neon());
+  }
+}
+class PrefixStyleBuilderProxy extends PartStyleBuilderProxy {
+  constructor(parentBuilder) {
+    super(parentBuilder, "prefix");
+  }
+  dark() {
+    return this.applyStyles(new PrefixStyler().dark());
+  }
+  light() {
+    return this.applyStyles(new PrefixStyler().light());
+  }
+  compact() {
+    return this.applyStyles(new PrefixStyler().compact());
+  }
+  muted() {
+    return this.applyStyles(new PrefixStyler().muted());
+  }
+  mono() {
+    return this.applyStyles(new PrefixStyler().mono());
+  }
+}
+class MessageStyleBuilderProxy extends PartStyleBuilderProxy {
+  constructor(parentBuilder) {
+    super(parentBuilder, "message");
+  }
+  readable() {
+    return this.applyStyles(new MessageStyler().readable());
+  }
+  code() {
+    return this.applyStyles(new MessageStyler().code());
+  }
+  large() {
+    return this.applyStyles(new MessageStyler().large());
+  }
+  system() {
+    return this.applyStyles(new MessageStyler().system());
+  }
+  mono() {
+    return this.applyStyles(new MessageStyler().mono());
+  }
+}
+class LocationStyleBuilderProxy extends PartStyleBuilderProxy {
+  constructor(parentBuilder) {
+    super(parentBuilder, "location");
+  }
+  subtle() {
+    return this.applyStyles(new LocationStyler().subtle());
+  }
+  hidden() {
+    return this.applyStyles(new LocationStyler().hidden());
+  }
+  clickable() {
+    return this.applyStyles(new LocationStyler().clickable());
+  }
+  muted() {
+    return this.applyStyles(new LocationStyler().muted());
+  }
+  mono() {
+    return this.applyStyles(new LocationStyler().mono());
+  }
+}
+function createLogStyleBuilder(logger) {
+  return new LogStyleBuilder(logger);
+}
+const SMART_PRESETS = {
+  /**
+   * Default preset - works perfectly out-of-the-box
+   * Clean, readable, automatically adaptive to dark/light themes
+   */
+  default: {
+    layout: {
+      spacing: "normal",
+      innerPadding: "2px",
+      outerMargin: "1px"
+    },
+    timestamp: {
+      show: true,
+      color: "auto",
+      // Automatically adaptive
+      font: "Monaco, Consolas, monospace",
+      size: "11px"
+    },
+    level: {
+      show: true,
+      style: "badge",
+      uppercase: false,
+      padding: "2px 8px"
+    },
+    prefix: {
+      show: true,
+      style: "dark",
+      // Automatically adaptive
+      padding: "2px 6px"
+    },
+    message: {
+      show: true,
+      color: "auto",
+      // Automatically adaptive
+      font: "system-ui, -apple-system, sans-serif",
+      size: "14px"
+    },
+    location: {
+      show: true,
+      color: "auto",
+      // Automatically adaptive
+      font: "Monaco, Consolas, monospace",
+      size: "11px"
+    }
+  },
+  /**
+   * Cyberpunk preset - neon colors, glowing effects, dark theme
+   */
+  cyberpunk: {
+    layout: {
+      spacing: "compact",
+      innerPadding: "1px",
+      outerMargin: "0px"
+    },
+    timestamp: {
+      show: true,
+      color: "#00ffff",
+      font: "Monaco, Consolas, monospace",
+      size: "10px",
+      style: "neon"
+    },
+    level: {
+      show: true,
+      style: "glowing",
+      uppercase: true,
+      padding: "2px 8px"
+    },
+    prefix: {
+      show: true,
+      color: "#ff0080",
+      background: "rgba(255, 0, 128, 0.1)",
+      border: "1px solid #ff0080",
+      style: "neon"
+    },
+    message: {
+      show: true,
+      color: "#00ff41",
+      font: "Monaco, Consolas, monospace",
+      size: "13px"
+    },
+    location: {
+      show: false
+      // Hidden for cleaner look
+    },
+    backdrop: "blur(2px)",
+    transparency: 0.9
+  },
+  /**
+   * Glassmorphism preset - modern blur effects, transparency
+   */
+  glassmorphism: {
+    layout: {
+      spacing: "spacious",
+      innerPadding: "4px",
+      outerMargin: "2px"
+    },
+    timestamp: {
+      show: true,
+      color: "auto",
+      font: "system-ui, sans-serif",
+      size: "11px",
+      style: "glassmorphic"
+    },
+    level: {
+      show: true,
+      style: "glassmorphic",
+      uppercase: false,
+      padding: "4px 12px"
+    },
+    prefix: {
+      show: true,
+      style: "glassmorphic",
+      padding: "3px 8px"
+    },
+    message: {
+      show: true,
+      color: "auto",
+      font: "system-ui, sans-serif",
+      size: "14px"
+    },
+    location: {
+      show: true,
+      color: "auto",
+      font: "system-ui, sans-serif",
+      size: "11px",
+      style: "glassmorphic"
+    },
+    backdrop: "blur(10px)",
+    transparency: 0.8
+  },
+  /**
+   * Minimal preset - clean, no decorations, maximum readability
+   */
+  minimal: {
+    layout: {
+      spacing: "compact",
+      innerPadding: "0px",
+      outerMargin: "0px"
+    },
+    timestamp: {
+      show: false
+      // Hidden for minimal look
+    },
+    level: {
+      show: true,
+      style: "flat",
+      uppercase: true,
+      padding: "0px 4px",
+      border: "none",
+      background: "transparent"
+    },
+    prefix: {
+      show: true,
+      style: "flat",
+      padding: "0px 4px",
+      border: "none",
+      background: "transparent"
+    },
+    message: {
+      show: true,
+      color: "auto",
+      font: "system-ui, sans-serif",
+      size: "14px"
+    },
+    location: {
+      show: false
+      // Hidden for minimal look
+    }
+  },
+  /**
+   * Debug preset - monospace, detailed, compact for development
+   */
+  debug: {
+    layout: {
+      spacing: "compact",
+      innerPadding: "1px",
+      outerMargin: "0px"
+    },
+    timestamp: {
+      show: true,
+      color: "auto",
+      font: "Monaco, Consolas, monospace",
+      size: "10px"
+    },
+    level: {
+      show: true,
+      style: "compact",
+      uppercase: true,
+      padding: "1px 4px",
+      font: "Monaco, Consolas, monospace",
+      size: "10px"
+    },
+    prefix: {
+      show: true,
+      style: "compact",
+      padding: "1px 4px",
+      font: "Monaco, Consolas, monospace",
+      size: "10px"
+    },
+    message: {
+      show: true,
+      color: "auto",
+      font: "Monaco, Consolas, monospace",
+      size: "12px"
+    },
+    location: {
+      show: true,
+      color: "auto",
+      font: "Monaco, Consolas, monospace",
+      size: "10px",
+      style: "clickable"
+    }
+  },
+  /**
+   * Production preset - clean, essential info only
+   */
+  production: {
+    layout: {
+      spacing: "normal",
+      innerPadding: "2px",
+      outerMargin: "1px"
+    },
+    timestamp: {
+      show: true,
+      color: "auto",
+      font: "system-ui, sans-serif",
+      size: "11px"
+    },
+    level: {
+      show: true,
+      style: "badge",
+      uppercase: false,
+      padding: "2px 6px"
+    },
+    prefix: {
+      show: false
+      // Hidden in production
+    },
+    message: {
+      show: true,
+      color: "auto",
+      font: "system-ui, sans-serif",
+      size: "14px"
+    },
+    location: {
+      show: false
+      // Hidden in production
+    }
+  }
+};
+function getSmartPreset(name) {
+  return SMART_PRESETS[name] || null;
+}
+function getAvailablePresets() {
+  return Object.keys(SMART_PRESETS);
+}
+function hasPreset(name) {
+  return name in SMART_PRESETS;
+}
+class ScopedLogger {
+  parent;
+  scopeName;
+  badgeList = [];
+  contextStack = [];
+  _timers;
+  constructor(parent, scopeName) {
+    this.parent = parent;
+    this.scopeName = scopeName;
+  }
+  get timers() {
+    if (!this._timers) this._timers = /* @__PURE__ */ new Map();
+    return this._timers;
+  }
+  getBindings() {
+    return {
+      scope: this.getScopePrefix(),
+      badges: this.badgeList.length > 0 ? [...this.badgeList] : void 0
+    };
+  }
+  getScopePrefix() {
+    if (this.contextStack.length === 0) return this.scopeName;
+    return [this.scopeName, ...this.contextStack].join(":");
+  }
+  badges(badges) {
+    this.badgeList = [...badges];
+    return this;
+  }
+  badge(badge) {
+    if (!this.badgeList.includes(badge)) {
+      this.badgeList.push(badge);
+    }
+    return this;
+  }
+  clearBadges() {
+    this.badgeList = [];
+    return this;
+  }
+  style(presetName) {
+    this.parent.setTheme(presetName);
+    return this;
+  }
+  context(contextName) {
+    return new ContextLogger(this, contextName);
+  }
+  time(label) {
+    this.timers.set(label, {
+      label: `${this.scopeName}:${label}`,
+      startTime: performance.now()
+    });
+  }
+  timeEnd(label) {
+    const timer = this.timers.get(label);
+    if (!timer) {
+      this.warn(`Timer '${label}' not found`);
+      return void 0;
+    }
+    const elapsed = performance.now() - timer.startTime;
+    this.timers.delete(label);
+    this.success(`Timer: ${label} - ${elapsed.toFixed(2)}ms`);
+    return elapsed;
+  }
+  debug(...args) {
+    this.parent.logWithBindings(this.getBindings(), "debug", ...args);
+  }
+  info(...args) {
+    this.parent.logWithBindings(this.getBindings(), "info", ...args);
+  }
+  warn(...args) {
+    this.parent.logWithBindings(this.getBindings(), "warn", ...args);
+  }
+  error(...args) {
+    this.parent.logWithBindings(this.getBindings(), "error", ...args);
+  }
+  success(...args) {
+    const bindings = this.getBindings();
+    this.parent.logWithBindings(bindings, "info", ...args);
+  }
+  critical(...args) {
+    this.parent.logWithBindings(this.getBindings(), "critical", ...args);
+  }
+  trace(...args) {
+    this.parent.logWithBindings(this.getBindings(), "debug", ...args);
+    console.trace(`[${this.scopeName}]`);
+  }
+  _pushContext(context) {
+    this.contextStack.push(context);
+  }
+  _popContext() {
+    this.contextStack.pop();
+  }
+}
+class APILogger extends ScopedLogger {
+  constructor(parent, apiName) {
+    super(parent, `API:${apiName}`);
+    this.badge("API");
+  }
+  slow(message, duration) {
+    this.badge("SLOW");
+    const msg = duration ? `${message} (${duration}ms)` : message;
+    this.warn(msg);
+  }
+  rateLimit(message) {
+    this.badge("RATE_LIMIT");
+    this.warn(message);
+  }
+  auth(message) {
+    this.badge("AUTH");
+    this.error(message);
+  }
+  deprecated(message) {
+    this.badge("DEPRECATED");
+    this.warn(message);
+  }
+}
+class ComponentLogger extends ScopedLogger {
+  constructor(parent, componentName) {
+    super(parent, componentName);
+    this.badge("COMPONENT");
+  }
+  lifecycle(event, message) {
+    this.badge("LIFECYCLE");
+    const msg = message ? `${event}: ${message}` : event;
+    this.info(msg);
+  }
+  stateChange(from, to, data) {
+    this.badge("STATE");
+    const msg = `${from} → ${to}`;
+    if (data) {
+      this.info(msg, data);
+    } else {
+      this.info(msg);
+    }
+  }
+  propsChange(changes) {
+    this.badge("PROPS");
+    this.debug("Props changed:", changes);
+  }
+}
+class ContextLogger {
+  parentLogger;
+  contextName;
+  constructor(parentLogger, contextName) {
+    this.parentLogger = parentLogger;
+    this.contextName = contextName;
+  }
+  run(fn) {
+    this.parentLogger._pushContext(this.contextName);
+    try {
+      return fn();
+    } finally {
+      this.parentLogger._popContext();
+    }
+  }
+  async runAsync(fn) {
+    this.parentLogger._pushContext(this.contextName);
+    try {
+      return await fn();
+    } finally {
+      this.parentLogger._popContext();
+    }
+  }
+  start() {
+    this.parentLogger._pushContext(this.contextName);
+  }
+  end() {
+    this.parentLogger._popContext();
+  }
+  debug(...args) {
+    this.parentLogger.debug(...args);
+  }
+  info(...args) {
+    this.parentLogger.info(...args);
+  }
+  warn(...args) {
+    this.parentLogger.warn(...args);
+  }
+  error(...args) {
+    this.parentLogger.error(...args);
+  }
+  success(...args) {
+    this.parentLogger.success(...args);
+  }
+  critical(...args) {
+    this.parentLogger.critical(...args);
+  }
+}
+class ExportLogHandler {
+  buffer = [];
+  maxSize;
+  groupDepth = 0;
+  currentGroup;
+  constructor(maxSize = BUFFER_LIMITS.DEFAULT_SIZE) {
+    this.maxSize = Math.min(Math.max(maxSize, BUFFER_LIMITS.MIN_SIZE), BUFFER_LIMITS.MAX_SIZE);
+  }
+  /**
+   * Handle incoming log and store in buffer
+   */
+  handle(level, message, args, metadata) {
+    const entry = {
+      id: generateLogId(),
+      timestamp: metadata.timestamp,
+      level,
+      prefix: metadata.prefix,
+      message,
+      args,
+      location: metadata.stackInfo,
+      groupInfo: this.groupDepth > 0 ? {
+        depth: this.groupDepth,
+        groupName: this.currentGroup
+      } : void 0
+    };
+    this.buffer.push(entry);
+    if (this.buffer.length > this.maxSize) {
+      this.buffer.shift();
+    }
+  }
+  /**
+   * Set group tracking for nested logs
+   */
+  setGroupInfo(depth, groupName) {
+    this.groupDepth = depth;
+    this.currentGroup = groupName;
+  }
+  /**
+   * Get buffer statistics
+   */
+  getBufferStats() {
+    const levelCounts = this.buffer.reduce((acc, entry) => {
+      const currentCount = acc[entry.level] ? acc[entry.level] : 0;
+      acc[entry.level] = currentCount + 1;
+      return acc;
+    }, {});
+    let oldestLog;
+    let newestLog;
+    if (this.buffer.length > 0) {
+      const firstEntry = this.buffer[0];
+      const lastEntry = this.buffer[this.buffer.length - 1];
+      if (firstEntry && firstEntry.timestamp) {
+        oldestLog = new Date(firstEntry.timestamp);
+      }
+      if (lastEntry && lastEntry.timestamp) {
+        newestLog = new Date(lastEntry.timestamp);
+      }
+    }
+    return {
+      size: this.buffer.length,
+      maxSize: this.maxSize,
+      usage: this.buffer.length / this.maxSize * 100,
+      oldestLog,
+      newestLog,
+      levelCounts: {
+        debug: levelCounts.debug ? levelCounts.debug : 0,
+        info: levelCounts.info ? levelCounts.info : 0,
+        warn: levelCounts.warn ? levelCounts.warn : 0,
+        error: levelCounts.error ? levelCounts.error : 0,
+        critical: levelCounts.critical ? levelCounts.critical : 0
+      }
+    };
+  }
+  /**
+   * Clear the buffer
+   */
+  clearBuffer() {
+    this.buffer = [];
+  }
+  /**
+   * Set buffer size (with limits)
+   */
+  setBufferSize(size) {
+    this.maxSize = Math.min(Math.max(size, BUFFER_LIMITS.MIN_SIZE), BUFFER_LIMITS.MAX_SIZE);
+    if (this.buffer.length > this.maxSize) {
+      this.buffer = this.buffer.slice(-this.maxSize);
+    }
+  }
+  /**
+   * Filter logs based on criteria
+   */
+  filterLogs(filters = {}) {
+    let filtered = [...this.buffer];
+    if (filters.levels?.length) {
+      filtered = filtered.filter((entry) => filters.levels.includes(entry.level));
+    }
+    if (filters.prefixes?.length) {
+      filtered = filtered.filter(
+        (entry) => entry.prefix && filters.prefixes.includes(entry.prefix)
+      );
+    }
+    if (filters.excludePrefixes?.length) {
+      filtered = filtered.filter(
+        (entry) => !entry.prefix || !filters.excludePrefixes.includes(entry.prefix)
+      );
+    }
+    if (filters.since) {
+      const sinceDate = parseTimeInput(filters.since);
+      filtered = filtered.filter((entry) => new Date(entry.timestamp) >= sinceDate);
+    }
+    if (filters.until) {
+      const untilDate = parseTimeInput(filters.until);
+      filtered = filtered.filter((entry) => new Date(entry.timestamp) <= untilDate);
+    }
+    if (filters.withStackTrace) {
+      filtered = filtered.filter((entry) => entry.location);
+    }
+    if (filters.errorsOnly) {
+      filtered = filtered.filter((entry) => entry.level === "error" || entry.level === "critical");
+    }
+    if (filters.search) {
+      const searchTerm = filters.search.toLowerCase();
+      filtered = filtered.filter(
+        (entry) => entry.message.toLowerCase().includes(searchTerm) || entry.args.some(
+          (arg) => String(arg).toLowerCase().includes(searchTerm)
+        )
+      );
+    }
+    if (filters.last) {
+      filtered = filtered.slice(-filters.last);
+    }
+    if (filters.first) {
+      filtered = filtered.slice(0, filters.first);
+    }
+    return filtered;
+  }
+  /**
+   * Export logs in JSON format
+   */
+  exportJSON(logs, options) {
+    const data = logs.map((entry) => ({
+      timestamp: entry.timestamp,
+      level: entry.level,
+      prefix: entry.prefix,
+      message: entry.message,
+      ...options.minimal ? {} : {
+        args: entry.args.slice(1),
+        location: entry.location,
+        groupInfo: entry.groupInfo
+      }
+    }));
+    return options.compact ? JSON.stringify(data) : JSON.stringify(data, null, 2);
+  }
+  /**
+   * Export logs in CSV format
+   */
+  exportCSV(logs, options) {
+    const headers = options.minimal ? ["Timestamp", "Level", "Prefix", "Message"] : ["Timestamp", "Level", "Prefix", "Message", "File", "Line", "Args"];
+    const rows = logs.map((entry) => {
+      const baseRow = [
+        formatDisplayTime(new Date(entry.timestamp), "full"),
+        entry.level.toUpperCase(),
+        entry.prefix || "",
+        `"${entry.message.replace(/"/g, '""')}"`
+      ];
+      if (!options.minimal) {
+        baseRow.push(
+          entry.location?.file || "",
+          entry.location?.line?.toString() || "",
+          `"${safeStringify(entry.args.slice(1)).replace(/"/g, '""')}"`
+        );
+      }
+      return baseRow;
+    });
+    return [headers.join(","), ...rows.map((row) => row.join(","))].join("\n");
+  }
+  /**
+   * Export logs in Markdown format
+   */
+  exportMarkdown(logs, options) {
+    const now = /* @__PURE__ */ new Date();
+    let content = `# Log Export - ${formatDisplayTime(now, "full")}
+
+`;
+    if (!options.minimal) {
+      const summary = this.getBufferStats();
+      content += `## Summary
+`;
+      content += `- **Total logs**: ${logs.length}
+`;
+      content += `- **Errors**: ${summary.levelCounts.error + summary.levelCounts.critical}
+`;
+      content += `- **Warnings**: ${summary.levelCounts.warn}
+
+`;
+    }
+    if (options.groupBy === "level") {
+      const grouped = logs.reduce((acc, entry) => {
+        const level = entry.level;
+        if (!acc[level]) {
+          acc[level] = [];
+        }
+        const levelArray = acc[level];
+        if (levelArray) {
+          levelArray.push(entry);
+        }
+        return acc;
+      }, {});
+      Object.entries(grouped).forEach(([level, entries]) => {
+        const emoji = this.getLevelEmoji(level);
+        content += `## ${emoji} ${level.toUpperCase()} (${entries.length})
+
+`;
+        entries.forEach((entry) => {
+          const time = formatDisplayTime(new Date(entry.timestamp), "time-only");
+          const location = entry.location ? ` (${entry.location.file}:${entry.location.line})` : "";
+          const prefix = entry.prefix ? ` **${entry.prefix}**:` : "";
+          content += `- \`${time}\`${prefix} ${entry.message}${location}
+`;
+        });
+        content += "\n";
+      });
+    } else {
+      content += "## Logs\n\n";
+      logs.forEach((entry) => {
+        const time = formatDisplayTime(new Date(entry.timestamp), "time-only");
+        const emoji = this.getLevelEmoji(entry.level);
+        const location = entry.location ? ` (${entry.location.file}:${entry.location.line})` : "";
+        const prefix = entry.prefix ? ` **${entry.prefix}**:` : "";
+        content += `- \`${time}\` ${emoji}${prefix} ${entry.message}${location}
+`;
+      });
+    }
+    return content;
+  }
+  /**
+   * Export logs in plain text format
+   */
+  exportPlain(logs, options) {
+    return logs.map((entry) => {
+      const time = formatDisplayTime(new Date(entry.timestamp), options.minimal ? "time-only" : "short");
+      const level = entry.level.toUpperCase().padEnd(8);
+      const prefix = entry.prefix ? `[${entry.prefix}] ` : "";
+      const location = !options.minimal && entry.location ? ` (${entry.location.file}:${entry.location.line})` : "";
+      return `${time} ${level} ${prefix}${entry.message}${location}`;
+    }).join("\n");
+  }
+  /**
+   * Export logs in HTML format
+   */
+  exportHTML(logs, _options) {
+    const title = `Log Export - ${formatDisplayTime(/* @__PURE__ */ new Date(), "full")}`;
+    let html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>${title}</title>
+    <style>
+        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; margin: 20px; line-height: 1.6; }
+        .header { border-bottom: 2px solid #ddd; padding-bottom: 20px; margin-bottom: 20px; }
+        .log-entry { margin: 5px 0; padding: 8px; border-radius: 4px; font-family: 'Monaco', 'Consolas', monospace; }
+        .timestamp { color: #666; font-size: 0.9em; }
+        .level { font-weight: bold; padding: 2px 6px; border-radius: 3px; margin: 0 8px; }
+        .prefix { background: #2d3748; color: #e2e8f0; padding: 2px 6px; border-radius: 3px; margin: 0 8px; }
+        .location { color: #718096; font-size: 0.9em; }
+        .debug { background: #f0f4ff; }
+        .info { background: #f0f9ff; }
+        .warn { background: #fffbeb; }
+        .error { background: #fef2f2; }
+        .critical { background: #fef2f2; border-left: 4px solid #dc2626; }
+        .level.debug { background: #667eea; color: white; }
+        .level.info { background: #74b9ff; color: white; }
+        .level.warn { background: #fdcb6e; color: #2d3436; }
+        .level.error { background: #e84393; color: white; }
+        .level.critical { background: #ff3838; color: white; }
+    </style>
+</head>
+<body>
+    <div class="header">
+        <h1>${title}</h1>
+        <p>Generated by Advanced Logger v2.0.0</p>
+    </div>
+    <div class="logs">`;
+    logs.forEach((entry) => {
+      const time = formatDisplayTime(new Date(entry.timestamp), "full");
+      const location = entry.location ? ` <span class="location">(${escapeHtml(entry.location.file)}:${entry.location.line})</span>` : "";
+      const prefix = entry.prefix ? ` <span class="prefix">${escapeHtml(entry.prefix)}</span>` : "";
+      html += `
+        <div class="log-entry ${entry.level}">
+            <span class="timestamp">${time}</span>
+            <span class="level ${entry.level}">${entry.level.toUpperCase()}</span>
+            ${prefix}
+            <span class="message">${escapeHtml(entry.message)}</span>
+            ${location}
+        </div>`;
+    });
+    html += `
+    </div>
+</body>
+</html>`;
+    return html;
+  }
+  /**
+   * Get emoji for log level
+   */
+  getLevelEmoji(level) {
+    const emojis = {
+      debug: "🐞",
+      info: "ℹ️",
+      warn: "⚠️",
+      error: "❌",
+      critical: "🔥"
+    };
+    return emojis[level] || "";
+  }
+  /**
+   * Main export function
+   */
+  export(format, filters = {}, options = {}) {
+    const filteredLogs = this.filterLogs(filters);
+    let data;
+    switch (format) {
+      case "json":
+        data = this.exportJSON(filteredLogs, options);
+        break;
+      case "csv":
+        data = this.exportCSV(filteredLogs, options);
+        break;
+      case "markdown":
+        data = this.exportMarkdown(filteredLogs, options);
+        break;
+      case "plain":
+        data = this.exportPlain(filteredLogs, options);
+        break;
+      case "html":
+        data = this.exportHTML(filteredLogs, options);
+        break;
+      default:
+        throw new Error(`Unsupported export format: ${format}`);
+    }
+    return {
+      format,
+      data,
+      metadata: {
+        totalLogs: this.buffer.length,
+        filteredLogs: filteredLogs.length,
+        exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        filters,
+        options
+      }
+    };
+  }
+  /**
+   * Copy to clipboard with fallback
+   */
+  async copyToClipboard(format, filters = {}, options = {}) {
+    const result = this.export(format, filters, options);
+    try {
+      if (navigator.clipboard && window.isSecureContext) {
+        await navigator.clipboard.writeText(result.data);
+        return true;
+      } else {
+        const textArea = document.createElement("textarea");
+        textArea.value = result.data;
+        textArea.style.position = "fixed";
+        textArea.style.opacity = "0";
+        document.body.appendChild(textArea);
+        textArea.focus();
+        textArea.select();
+        const success = document.execCommand("copy");
+        document.body.removeChild(textArea);
+        return success;
+      }
+    } catch (error) {
+      console.error("Failed to copy to clipboard:", error);
+      return false;
+    }
+  }
+  /**
+   * Get all logs (for debugging)
+   */
+  getAllLogs() {
+    return [...this.buffer];
+  }
+  /**
+   * Save export to file with download prompt
+   */
+  async saveToFile(format, filters = {}, options = {}) {
+    try {
+      const result = this.export(format, filters, options);
+      const blob = new Blob([result.data], {
+        type: this.getMimeType(format)
+      });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      const filename = this.generateFilename(format, filters);
+      a.href = url;
+      a.download = filename;
+      a.style.display = "none";
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      URL.revokeObjectURL(url);
+      return true;
+    } catch (error) {
+      console.error("Failed to save file:", error);
+      return false;
+    }
+  }
+  /**
+   * Get MIME type for format
+   */
+  getMimeType(format) {
+    const mimeTypes = {
+      json: "application/json",
+      csv: "text/csv",
+      markdown: "text/markdown",
+      plain: "text/plain",
+      html: "text/html"
+    };
+    return mimeTypes[format] || "text/plain";
+  }
+  /**
+   * Generate filename with timestamp
+   */
+  generateFilename(format, filters) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, -5);
+    const prefix = filters.prefixes?.length === 1 ? `_${filters.prefixes[0]}` : "";
+    const extension = format === "markdown" ? "md" : format;
+    return `logs${prefix}_${timestamp}.${extension}`;
+  }
+  /**
+   * Stream logs to external endpoint
+   */
+  async streamToEndpoint(endpoint, filters = {}, options = {}) {
+    try {
+      const logs = this.filterLogs(filters);
+      const batchSize = options.batchSize || 100;
+      const format = options.format || "json";
+      for (let i = 0; i < logs.length; i += batchSize) {
+        const batch = logs.slice(i, i + batchSize);
+        const result = this.export(format, {}, { compact: true });
+        const headers = {
+          "Content-Type": "application/json"
+        };
+        if (options.apiKey) {
+          headers["Authorization"] = `Bearer ${options.apiKey}`;
+        }
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            logs: batch,
+            metadata: {
+              batchIndex: Math.floor(i / batchSize),
+              totalBatches: Math.ceil(logs.length / batchSize),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          })
+        });
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+      }
+      return true;
+    } catch (error) {
+      console.error("Failed to stream logs:", error);
+      return false;
+    }
+  }
+  /**
+   * Create export with metadata enrichment
+   */
+  exportWithMetadata(format, filters = {}, options = {}) {
+    const baseResult = this.export(format, filters, options);
+    const bufferStats = this.getBufferStats();
+    return {
+      ...baseResult,
+      metadata: {
+        ...baseResult.metadata,
+        bufferStats,
+        performance: {
+          memoryUsage: this.estimateMemoryUsage(),
+          processingTime: Date.now()
+        },
+        system: {
+          userAgent: typeof navigator !== "undefined" ? navigator.userAgent : "Node.js",
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          timezone: Intl.DateTimeFormat().resolvedOptions().timeZone
+        }
+      }
+    };
+  }
+  /**
+   * Estimate memory usage of buffer
+   */
+  estimateMemoryUsage() {
+    const sampleEntry = this.buffer[0];
+    if (!sampleEntry) return 0;
+    const sampleSize = JSON.stringify(sampleEntry).length;
+    return sampleSize * this.buffer.length;
+  }
+}
+class CommandProcessor {
+  commands = /* @__PURE__ */ new Map();
+  aliases = /* @__PURE__ */ new Map();
+  plugins = /* @__PURE__ */ new Map();
+  history = [];
+  maxHistorySize = 100;
+  isInteractiveMode = false;
+  /**
+   * Register a command
+   */
+  registerCommand(command) {
+    this.commands.set(command.name, command);
+    if (command.aliases) {
+      for (const alias of command.aliases) {
+        this.aliases.set(alias, command.name);
+      }
+    }
+  }
+  /**
+   * Register a plugin
+   */
+  registerPlugin(plugin, logger) {
+    if (this.plugins.has(plugin.name)) {
+      throw new Error(`Plugin ${plugin.name} is already registered`);
+    }
+    this.plugins.set(plugin.name, plugin);
+    for (const command of plugin.commands) {
+      this.registerCommand(command);
+    }
+    if (plugin.initialize && logger) {
+      plugin.initialize(this, logger);
+    }
+  }
+  /**
+   * Unregister a plugin
+   */
+  unregisterPlugin(pluginName) {
+    const plugin = this.plugins.get(pluginName);
+    if (!plugin) return;
+    for (const command of plugin.commands) {
+      this.commands.delete(command.name);
+      if (command.aliases) {
+        for (const alias of command.aliases) {
+          this.aliases.delete(alias);
+        }
+      }
+    }
+    if (plugin.cleanup) {
+      plugin.cleanup();
+    }
+    this.plugins.delete(pluginName);
+  }
+  /**
+   * Get all registered commands
+   */
+  getCommands() {
+    return Array.from(this.commands.values());
+  }
+  /**
+   * Get a specific command
+   */
+  getCommand(name) {
+    let command = this.commands.get(name);
+    if (command) return command;
+    const aliasTarget = this.aliases.get(name);
+    if (aliasTarget) {
+      return this.commands.get(aliasTarget);
+    }
+    return void 0;
+  }
+  /**
+   * Get command history
+   */
+  getHistory() {
+    return [...this.history];
+  }
+  /**
+   * Clear command history
+   */
+  clearHistory() {
+    this.history = [];
+  }
+  /**
+   * Get registered plugins
+   */
+  getPlugins() {
+    return Array.from(this.plugins.values());
+  }
+  /**
+   * Enter interactive mode
+   */
+  enterInteractiveMode(logger) {
+    this.isInteractiveMode = true;
+    logger.info("🔧 Interactive CLI mode activated. Type /exit to quit, /help for commands.");
+    if (typeof window !== "undefined") {
+      this.setupBrowserInteractiveMode(logger);
+    }
+  }
+  /**
+   * Exit interactive mode
+   */
+  exitInteractiveMode() {
+    this.isInteractiveMode = false;
+  }
+  /**
+   * Setup browser interactive mode
+   */
+  setupBrowserInteractiveMode(logger) {
+    window.cli = (commandString) => {
+      return this.processCommand(`/${commandString}`, logger);
+    };
+    logger.info('💡 Use cli("command") to execute CLI commands in browser console.');
+  }
+  /**
+   * Process a CLI command
+   */
+  async processCommand(commandString, logger) {
+    if (!commandString.startsWith("/")) {
+      logger.error("Invalid command. Commands must start with /");
+      this.addToHistory(commandString, false);
+      return;
+    }
+    const parts = commandString.slice(1).split(" ");
+    const commandName = parts[0] || "";
+    const args = parts.slice(1).join(" ");
+    const command = this.getCommand(commandName);
+    if (!command) {
+      logger.error(`Unknown command: ${commandName}. Type /help for available commands.`);
+      const suggestions = this.getSuggestions(commandName);
+      if (suggestions.length > 0) {
+        logger.info(`📋 Did you mean: ${suggestions.slice(0, 3).join(", ")}?`);
+      }
+      this.addToHistory(commandString, false);
+      return;
+    }
+    try {
+      await command.execute(args || "", logger);
+      this.addToHistory(commandString, true);
+    } catch (error) {
+      logger.error(`Command '${commandName}' failed:`, error);
+      this.addToHistory(commandString, false);
+    }
+  }
+  /**
+   * Add command to history
+   */
+  addToHistory(command, success) {
+    this.history.unshift({
+      command,
+      timestamp: /* @__PURE__ */ new Date(),
+      success
+    });
+    if (this.history.length > this.maxHistorySize) {
+      this.history = this.history.slice(0, this.maxHistorySize);
+    }
+  }
+  /**
+   * Get command suggestions for partial matches
+   */
+  getSuggestions(partial) {
+    const commandNames = Array.from(this.commands.keys());
+    return commandNames.filter((name) => name.startsWith(partial));
+  }
+}
+class ConfigCommand {
+  name = "config";
+  description = "Show or update logger configuration";
+  usage = "/config [json|key=value,...]";
+  execute(args, logger) {
+    if (!args) {
+      this.showStatus(logger);
+      return;
+    }
+    try {
+      if (args.startsWith("{")) {
+        const config = JSON.parse(args);
+        this.applyConfig(config, logger);
+      } else {
+        const pairs = args.split(",").map((pair) => pair.trim().split("="));
+        const config = {};
+        pairs.forEach(([key, value]) => {
+          if (key && value) {
+            config[key.trim()] = value.trim().replace(/["']/g, "");
+          }
+        });
+        this.applyConfig(config, logger);
+      }
+    } catch (error) {
+      logger.error("Invalid config format. Use JSON or key=value pairs:", error);
+      logger.info('Examples: /config {"theme":"dark"} or /config theme=neon,verbosity=debug');
+    }
+  }
+  showStatus(logger) {
+    const statusData = {
+      theme: logger.getConfig().theme || "default",
+      verbosity: logger.getConfig().verbosity,
+      colors: logger.getConfig().enableColors,
+      timestamps: logger.getConfig().enableTimestamps,
+      stackTrace: logger.getConfig().enableStackTrace,
+      globalPrefix: logger.getConfig().globalPrefix || "none",
+      bannerType: logger.getConfig().bannerType || "simple",
+      handlers: logger.getHandlers().length
+    };
+    logger.group("⚙️ Logger Configuration");
+    logger.table(statusData);
+    logger.groupEnd();
+  }
+  applyConfig(config, logger) {
+    const validKeys = ["theme", "verbosity", "enableColors", "enableTimestamps", "enableStackTrace", "globalPrefix", "bannerType"];
+    const applied = [];
+    Object.entries(config).forEach(([key, value]) => {
+      if (validKeys.includes(key)) {
+        if (key === "theme" && typeof value === "string") {
+          logger.setTheme(value);
+          applied.push(`${key}=${value}`);
+        } else if (key === "bannerType" && typeof value === "string") {
+          logger.setBannerType(value);
+          applied.push(`${key}=${value}`);
+        } else if (key === "verbosity") {
+          logger.setVerbosity(value);
+          applied.push(`${key}=${value}`);
+        } else if (key === "globalPrefix") {
+          logger.setGlobalPrefix(value);
+          applied.push(`${key}=${value}`);
+        } else {
+          logger.updateConfig({ [key]: value });
+          applied.push(`${key}=${value}`);
+        }
+      } else {
+        logger.warn(`Invalid config key: ${key}`);
+      }
+    });
+    if (applied.length > 0) {
+      logger.success(`Configuration updated: ${applied.join(", ")}`);
+    }
+  }
+}
+class ThemesCommand {
+  name = "themes";
+  description = "Show available theme presets";
+  usage = "/themes";
+  execute(_args, logger) {
+    logger.group("🎨 Available Themes");
+    Object.keys(THEME_PRESETS).forEach((themeName) => {
+      const preview = THEME_PRESETS[themeName];
+      const previewStyle = new StyleBuilder().bg(preview.info.background).color(preview.info.color).padding("4px 8px").rounded("4px").border(preview.info.border).build();
+      console.log(`%c${themeName}`, previewStyle, `- ${themeName} theme preview`);
+    });
+    logger.groupEnd();
+  }
+}
+class BannersCommand {
+  name = "banners";
+  description = "Show available banner types";
+  usage = "/banners";
+  execute(_args, logger) {
+    logger.group("🖼️ Available Banner Types");
+    Object.keys(BANNER_VARIANTS).forEach((bannerName) => {
+      const banner = BANNER_VARIANTS[bannerName];
+      console.log(`%c${bannerName}`, "font-weight: bold; color: #667eea;");
+      console.log(`%cPreview:`, "color: #666; font-size: 12px;");
+      if (bannerName === "simple") {
+        console.log(`%c${banner.text}`, banner.style);
+      } else if (bannerName === "ascii") {
+        console.log(`%c${banner.text.split("\n").slice(1, 4).join("\n")}...`, "font-family: monospace; color: #667eea; font-size: 10px;");
+      } else if (bannerName === "unicode") {
+        console.log(`%c${banner.text}`, banner.style);
+      } else {
+        console.log(`%c${bannerName} banner`, "color: #666; font-style: italic;");
+      }
+    });
+    logger.groupEnd();
+  }
+}
+class BannerCommand {
+  name = "banner";
+  description = "Change or show current banner type";
+  usage = "/banner [type]";
+  execute(args, logger) {
+    if (!args) {
+      logger.showBanner();
+      return;
+    }
+    if (args in BANNER_VARIANTS) {
+      logger.setBannerType(args);
+      logger.showBanner();
+    } else {
+      logger.error(`Invalid banner type: ${args}. Available: ${Object.keys(BANNER_VARIANTS).join(", ")}`);
+    }
+  }
+}
+class StatusCommand {
+  name = "status";
+  description = "Show current logger status and configuration";
+  usage = "/status";
+  execute(_args, logger) {
+    const config = logger.getConfig();
+    const statusData = {
+      theme: config.theme ? config.theme : "default",
+      verbosity: config.verbosity,
+      colors: config.enableColors,
+      timestamps: config.enableTimestamps,
+      stackTrace: config.enableStackTrace,
+      globalPrefix: config.globalPrefix ? config.globalPrefix : "none",
+      bannerType: config.bannerType ? config.bannerType : "simple",
+      handlers: logger.getHandlers().length,
+      bufferSize: config.bufferSize ? config.bufferSize : 1e3
+    };
+    logger.group("⚙️ Logger Configuration");
+    logger.table(statusData);
+    logger.groupEnd();
+    const exportHandler = logger.getExportHandler();
+    if (exportHandler) {
+      const bufferStats = exportHandler.getBufferStats();
+      logger.group("📊 Buffer Statistics");
+      logger.table({
+        size: `${bufferStats.size}/${bufferStats.maxSize}`,
+        usage: `${bufferStats.usage.toFixed(1)}%`,
+        oldestLog: bufferStats.oldestLog ? bufferStats.oldestLog.toISOString() : "None",
+        newestLog: bufferStats.newestLog ? bufferStats.newestLog.toISOString() : "None",
+        errorCount: bufferStats.levelCounts.error + bufferStats.levelCounts.critical,
+        warningCount: bufferStats.levelCounts.warn
+      });
+      logger.groupEnd();
+    }
+  }
+}
+class ResetCommand {
+  name = "reset";
+  description = "Reset logger configuration to defaults";
+  usage = "/reset";
+  execute(_args, logger) {
+    logger.resetConfig();
+  }
+}
+class DemoCommand {
+  name = "demo";
+  description = "Show comprehensive feature demonstration";
+  usage = "/demo";
+  execute(_args, logger) {
+    logger.group("🎪 Advanced Logger Demo");
+    logger.debug("Debug message with detailed information");
+    logger.info("Informational message about system state");
+    logger.warn("Warning about deprecated feature");
+    logger.error("Error processing user request");
+    logger.success("Operation completed successfully");
+    logger.critical("Critical system failure detected");
+    logger.group("📊 Advanced Features Demo");
+    logger.table([
+      { feature: "Styled Console", status: "✅ Active", performance: "Excellent" },
+      { feature: "Theme System", status: "✅ Active", performance: "Great" },
+      { feature: "CLI Interface", status: "✅ Active", performance: "Good" },
+      { feature: "Export System", status: "✅ Active", performance: "Excellent" }
+    ]);
+    logger.time("demo-operation");
+    setTimeout(() => {
+      logger.timeEnd("demo-operation");
+    }, 100);
+    logger.logWithSVG("SVG Demo");
+    logger.logAnimated("🌟 Animated Logger Demo 🌟", 2);
+    logger.groupEnd();
+    logger.groupEnd();
+    logger.info("Demo completed! Check the console for styled output.");
+  }
+}
+function parseArguments(args) {
+  const filters = {};
+  const options = {};
+  let format;
+  if (!args.trim()) return { filters, options };
+  const argParts = args.match(/(?:[^\s"]+|"[^"]*")+/g) || [];
+  for (let i = 0; i < argParts.length; i++) {
+    const arg = argParts[i];
+    if (!arg) {
+      continue;
+    }
+    if (i === 0 && !arg.startsWith("--") && arg in EXPORT_FORMATS) {
+      format = arg;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      const [flag, value] = arg.slice(2).split("=");
+      switch (flag) {
+        case "level":
+        case "levels":
+          if (value) {
+            filters.levels = value.split(",").map((l) => l.trim());
+          }
+          break;
+        case "since":
+          if (value) filters.since = value;
+          break;
+        case "until":
+          if (value) filters.until = value;
+          break;
+        case "prefix":
+        case "prefixes":
+          if (value) {
+            filters.prefixes = value.split(",").map((p) => p.trim());
+          }
+          break;
+        case "exclude-prefix":
+        case "exclude-prefixes":
+          if (value) {
+            filters.excludePrefixes = value.split(",").map((p) => p.trim());
+          }
+          break;
+        case "last":
+          if (value) filters.last = parseInt(value, 10);
+          break;
+        case "first":
+          if (value) filters.first = parseInt(value, 10);
+          break;
+        case "search":
+          if (value) filters.search = value.replace(/['"]/g, "");
+          break;
+        case "with-stack":
+          filters.withStackTrace = true;
+          break;
+        case "errors-only":
+          filters.errorsOnly = true;
+          break;
+        case "group-by":
+          if (value) {
+            filters.groupBy = value;
+            options.groupBy = value;
+          }
+          break;
+        case "minimal":
+          options.minimal = true;
+          break;
+        case "compact":
+          options.compact = true;
+          break;
+        case "styled":
+          options.styled = true;
+          break;
+      }
+    }
+  }
+  return { filters, options, format };
+}
+class ExportCommand {
+  name = "export";
+  description = "Export logs to various formats";
+  usage = "/export <format> [--filter=value] [--option]";
+  execute(args, logger) {
+    const exportHandler = logger.getExportHandler();
+    if (!exportHandler) {
+      logger.error("Export handler not available. Make sure ExportLogHandler is registered.");
+      return;
+    }
+    const { filters, options, format } = parseArguments(args);
+    if (!format) {
+      logger.error("Format required. Available formats: " + Object.keys(EXPORT_FORMATS).join(", "));
+      logger.info("Usage: /export <format> [--filter=value]");
+      logger.info("Example: /export json --level=error,warn --last=50");
+      return;
+    }
+    try {
+      const result = exportHandler.export(format, filters, options);
+      logger.success(`✅ Export completed: ${result.metadata.filteredLogs} logs exported in ${format} format`);
+      if (result.data.length < 1e3) {
+        logger.group(`📄 Preview (${format.toUpperCase()})`);
+        console.log(result.data);
+        logger.groupEnd();
+      } else {
+        logger.info(`📄 Export size: ${(result.data.length / 1024).toFixed(2)}KB`);
+      }
+      logger.table({
+        format: result.format,
+        totalLogs: result.metadata.totalLogs,
+        filtered: result.metadata.filteredLogs,
+        exported: result.metadata.exportedAt
+      });
+    } catch (error) {
+      logger.error("Export failed:", error);
+    }
+  }
+}
+class CopyCommand {
+  name = "copy";
+  description = "Copy logs to clipboard";
+  usage = "/copy <format> [--filter=value] [--option]";
+  async execute(args, logger) {
+    const exportHandler = logger.getExportHandler();
+    if (!exportHandler) {
+      logger.error("Export handler not available. Make sure ExportLogHandler is registered.");
+      return;
+    }
+    const { filters, options, format } = parseArguments(args);
+    if (!format) {
+      logger.error("Format required. Available formats: " + Object.keys(EXPORT_FORMATS).join(", "));
+      logger.info("Usage: /copy <format> [--filter=value]");
+      logger.info("Example: /copy plain --level=error --last=25");
+      return;
+    }
+    try {
+      const success = await exportHandler.copyToClipboard(format, filters, options);
+      if (success) {
+        const result = exportHandler.export(format, filters, options);
+        logger.success(`📋 Copied ${result.metadata.filteredLogs} logs to clipboard (${format} format)`);
+      } else {
+        logger.error("Failed to copy to clipboard. Browser may not support clipboard API.");
+      }
+    } catch (error) {
+      logger.error("Copy failed:", error);
+    }
+  }
+}
+class BufferSizeCommand {
+  name = "buffer-size";
+  description = "Set log buffer size";
+  usage = "/buffer-size <size>";
+  execute(args, logger) {
+    const exportHandler = logger.getExportHandler();
+    if (!exportHandler) {
+      logger.error("Export handler not available.");
+      return;
+    }
+    const size = parseInt(args.trim(), 10);
+    if (isNaN(size) || size <= 0) {
+      logger.error("Invalid buffer size. Must be a positive number.");
+      logger.info("Example: /buffer-size 2000");
+      return;
+    }
+    exportHandler.setBufferSize(size);
+    logger.success(`Buffer size set to ${size}`);
+  }
+}
+class ClearBufferCommand {
+  name = "clear-buffer";
+  description = "Clear the log buffer";
+  usage = "/clear-buffer";
+  execute(_args, logger) {
+    const exportHandler = logger.getExportHandler();
+    if (!exportHandler) {
+      logger.error("Export handler not available.");
+      return;
+    }
+    const stats = exportHandler.getBufferStats();
+    exportHandler.clearBuffer();
+    logger.success(`✅ Buffer cleared. Removed ${stats.size} log entries.`);
+  }
+}
+class BufferInfoCommand {
+  name = "buffer-info";
+  description = "Show buffer statistics and information";
+  usage = "/buffer-info";
+  execute(_args, logger) {
+    const exportHandler = logger.getExportHandler();
+    if (!exportHandler) {
+      logger.error("Export handler not available.");
+      return;
+    }
+    const stats = exportHandler.getBufferStats();
+    logger.group("📊 Buffer Information");
+    logger.table({
+      size: `${stats.size}/${stats.maxSize}`,
+      usage: `${stats.usage.toFixed(1)}%`,
+      oldestLog: stats.oldestLog?.toLocaleString() || "None",
+      newestLog: stats.newestLog?.toLocaleString() || "None"
+    });
+    logger.group("📈 Log Level Counts");
+    logger.table(stats.levelCounts);
+    logger.groupEnd();
+    logger.groupEnd();
+  }
+}
+class HelpCommand {
+  name = "help";
+  description = "Show CLI help and available commands";
+  usage = "/help [command]";
+  execute(_args, logger) {
+    const helpStyle = new StyleBuilder().bg("linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%)").color("#495057").padding("15px 20px").rounded("8px").border("1px solid #dee2e6").font("Monaco, Consolas, monospace").size("13px").build();
+    const helpText = `
+╭─────────────── ADVANCED LOGGER CLI COMMANDS ─────────────────╮
+│                                                             │
+│  CONFIGURATION                                              │
+│  /config            Show current configuration              │
+│  /config {json}     Apply JSON configuration                │
+│  /config key=val    Apply key-value configuration           │
+│  /themes            Show available themes                   │
+│  /banners           Show available banner types             │
+│  /banner [type]     Change/show banner type                 │
+│  /status            Show logger status & buffer stats       │
+│  /demo              Show feature demonstration              │
+│  /reset             Reset to default configuration          │
+│                                                             │
+│  EXPORT & CLIPBOARD                                         │
+│  /export <format>   Export logs (json|csv|md|plain|html)    │
+│  /copy <format>     Copy logs to clipboard                  │
+│  /buffer-size N     Set log buffer size                     │
+│  /buffer-info       Show buffer statistics                  │
+│  /clear-buffer      Clear stored logs                       │
+│                                                             │
+│  EXPORT FILTERS (for export/copy commands)                 │
+│  --level error,warn     Filter by log levels                │
+│  --since 2h             Logs from last 2 hours              │
+│  --until 1h             Logs until 1 hour ago               │
+│  --prefix API,DB        Filter by prefixes                  │
+│  --exclude-prefix INT   Exclude prefixes                    │
+│  --last 50             Last 50 logs only                    │
+│  --first 25            First 25 logs only                   │
+│  --search "error"      Search in log messages               │
+│  --with-stack          Only logs with stack traces          │
+│  --errors-only         Only error + critical logs           │
+│  --group-by level      Group by level/prefix/hour           │
+│                                                             │
+│  EXPORT OPTIONS                                             │
+│  --minimal             Minimal output format                │
+│  --compact             Remove extra whitespace              │
+│  --styled              Include styling (HTML format)        │
+│                                                             │
+├──────────────────── CONFIGURATION OPTIONS ─────────────────┤
+│                                                             │
+│  theme: default | dark | light | neon | minimal | cyberpunk│
+│  bannerType: simple | ascii | unicode | svg | animated     │
+│  verbosity: debug | info | warn | error | critical | silent│
+│  enableColors: true | false                                 │
+│  enableTimestamps: true | false                             │
+│  enableStackTrace: true | false                             │
+│  globalPrefix: "string"                                     │
+│  bufferSize: number (50-10000)                             │
+│                                                             │
+├──────────────────────── EXAMPLES ──────────────────────────┤
+│                                                             │
+│  Basic Configuration:                                       │
+│  /config {"theme":"dark","verbosity":"debug"}               │
+│  /config theme=neon,bufferSize=2000                        │
+│  /banner animated       Change to animated banner          │
+│                                                             │
+│  Export Examples:                                           │
+│  /export json --level=error,warn --last=25                 │
+│  /export csv --since=2h --prefix=API                       │
+│  /export markdown --group-by=level --errors-only           │
+│  /export html --styled --since=1h                          │
+│                                                             │
+│  Clipboard Examples:                                        │
+│  /copy plain --minimal --last=10                           │
+│  /copy json --search="authentication" --compact            │
+│  /copy csv --since=30m --exclude-prefix=DEBUG              │
+│                                                             │
+│  Buffer Management:                                         │
+│  /buffer-size 5000      Increase buffer to 5000 logs       │
+│  /buffer-info           Show detailed buffer statistics     │
+│  /clear-buffer          Clear all stored logs               │
+│                                                             │
+│  Time Formats:                                              │
+│  --since=2h            2 hours ago                          │
+│  --since=30m           30 minutes ago                       │
+│  --since=1d            1 day ago                            │
+│  --since="2024-01-01T10:00:00Z"  Specific ISO date         │
+│                                                             │
+╰─────────────────────────────────────────────────────────────╯`;
+    console.log(`%c${helpText}`, helpStyle);
+    logger.group("💡 Quick Tips");
+    const tips = [
+      "Use /demo to see all logger features in action",
+      "Logs are automatically stored in a circular buffer for export",
+      "Export formats: JSON (structured), CSV (Excel), Markdown (readable), Plain (simple), HTML (styled)",
+      "Time filters support relative (2h, 30m) and absolute (ISO) formats",
+      'Combine multiple filters: /export json --level=error --since=1h --search="auth"',
+      "Use /copy for quick clipboard access instead of /export"
+    ];
+    tips.forEach((tip) => {
+      logger.info(`• ${tip}`);
+    });
+    logger.groupEnd();
+  }
+}
+class HistoryCommand {
+  name = "history";
+  description = "Show command execution history";
+  usage = "/history [limit] - Show recent commands (default: 10)";
+  category = "system";
+  aliases = ["hist", "h"];
+  execute(args, logger) {
+    const processor = logger.cliProcessor;
+    if (!processor) {
+      logger.error("CLI processor not available");
+      return;
+    }
+    const limit = parseInt(args) || 10;
+    const history = processor.getHistory().slice(0, limit);
+    if (history.length === 0) {
+      logger.info("📝 No command history available");
+      return;
+    }
+    logger.info(`📋 Last ${history.length} commands:`);
+    history.forEach((entry, index) => {
+      const status = entry.success ? "✅" : "❌";
+      const time = entry.timestamp.toLocaleTimeString();
+      logger.info(`${status} [${time}] ${entry.command}`);
+    });
+  }
+}
+class ClearHistoryCommand {
+  name = "clearhistory";
+  description = "Clear command execution history";
+  usage = "/clearhistory - Remove all command history";
+  category = "system";
+  aliases = ["clrhist"];
+  execute(args, logger) {
+    const processor = logger.cliProcessor;
+    if (!processor) {
+      logger.error("CLI processor not available");
+      return;
+    }
+    processor.clearHistory();
+    logger.success("🗑️ Command history cleared");
+  }
+}
+class InteractiveCommand {
+  name = "interactive";
+  description = "Enter interactive CLI mode";
+  usage = "/interactive - Start interactive command mode";
+  category = "system";
+  aliases = ["i", "repl"];
+  execute(args, logger) {
+    const processor = logger.cliProcessor;
+    if (!processor) {
+      logger.error("CLI processor not available");
+      return;
+    }
+    processor.enterInteractiveMode(logger);
+  }
+}
+class PluginsCommand {
+  name = "plugins";
+  description = "List loaded CLI plugins";
+  usage = "/plugins - Show all registered plugins";
+  category = "system";
+  aliases = ["plug"];
+  execute(args, logger) {
+    const processor = logger.cliProcessor;
+    if (!processor) {
+      logger.error("CLI processor not available");
+      return;
+    }
+    const plugins = processor.getPlugins();
+    if (plugins.length === 0) {
+      logger.info("🔌 No plugins registered");
+      return;
+    }
+    logger.info(`🔌 Loaded plugins (${plugins.length}):`);
+    plugins.forEach((plugin) => {
+      logger.info(`  📦 ${plugin.name} v${plugin.version} - ${plugin.description}`);
+      logger.info(`     Commands: ${plugin.commands.map((c) => c.name).join(", ")}`);
+    });
+  }
+}
+function createDefaultCLI() {
+  const processor = new CommandProcessor();
+  processor.registerCommand(new HelpCommand());
+  processor.registerCommand(new ConfigCommand());
+  processor.registerCommand(new ThemesCommand());
+  processor.registerCommand(new BannersCommand());
+  processor.registerCommand(new BannerCommand());
+  processor.registerCommand(new StatusCommand());
+  processor.registerCommand(new ResetCommand());
+  processor.registerCommand(new DemoCommand());
+  processor.registerCommand(new ExportCommand());
+  processor.registerCommand(new CopyCommand());
+  processor.registerCommand(new BufferSizeCommand());
+  processor.registerCommand(new ClearBufferCommand());
+  processor.registerCommand(new BufferInfoCommand());
+  processor.registerCommand(new HistoryCommand());
+  processor.registerCommand(new ClearHistoryCommand());
+  processor.registerCommand(new InteractiveCommand());
+  processor.registerCommand(new PluginsCommand());
+  return processor;
+}
+let LEVEL_STYLES = THEME_PRESETS.default;
+class Logger {
+  config;
+  scopedPrefix;
+  handlers = [];
+  timers = /* @__PURE__ */ new Map();
+  groupDepth = 0;
+  exportHandler;
+  cliProcessor;
+  themeChangeListener;
+  badgeList = [];
+  displaySettings = {
+    showTimestamp: true,
+    showLocation: true,
+    showBadges: true
+  };
+  serializerRegistry;
+  hookManager;
+  transportManager;
+  /**
+   * Crea una nueva instancia del Logger
+   * 
+   * @param {Partial<LoggerConfig>} config - Configuración opcional del logger
+   * 
+   * @example
+   * // Logger con configuración personalizada
+   * const logger = new Logger({
+   *   theme: 'neon',
+   *   globalPrefix: 'MiApp',
+   *   verbosity: 'debug',
+   *   bufferSize: 1000
+   * });
+   */
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_CONFIG$1,
+      ...config
+    };
+    this.serializerRegistry = new SerializerRegistry();
+    this.hookManager = new HookManager();
+    if (this.config.bufferSize) {
+      this.exportHandler = new ExportLogHandler(this.config.bufferSize);
+      this.handlers.push(this.exportHandler);
+    }
+    this.cliProcessor = createDefaultCLI();
+    if (this.config.autoDetectTheme) {
+      this.setupAutoThemeDetection();
+    }
+  }
+  // ===== PRIVATE HELPER METHODS =====
+  /**
+   * Configura la detección automática de tema con listener de cambios
+   * @private
+   * @description Detecta automáticamente si el navegador está en modo claro u oscuro
+   */
+  setupAutoThemeDetection() {
+    if (this.themeChangeListener) {
+      this.themeChangeListener();
+      this.themeChangeListener = null;
+    }
+    this.themeChangeListener = setupThemeChangeListener((theme) => {
+      this.debug(`DevTools theme changed to: ${theme}`);
+    });
+  }
+  // ===== CONFIGURATION METHODS =====
+  /**
+   * Obtiene la configuración actual del logger
+   * 
+   * @returns {LoggerConfig} Configuración completa actual
+   * 
+   * @example
+   * const config = logger.getConfig();
+   * console.log('Verbosidad actual:', config.verbosity);
+   * console.log('Tema actual:', config.theme);
+   * 
+   * @since 0.3.0
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Actualiza la configuración del logger
+   * 
+   * @param {Partial<LoggerConfig>} updates - Propiedades a actualizar
+   * 
+   * @example
+   * logger.updateConfig({
+   *   verbosity: 'debug',
+   *   enableTimestamps: false,
+   *   theme: 'cyberpunk'
+   * });
+   * 
+   * @since 0.3.0
+   */
+  updateConfig(updates) {
+    const previousAutoDetect = this.config.autoDetectTheme;
+    this.config = { ...this.config, ...updates };
+    if (updates.autoDetectTheme !== void 0 && updates.autoDetectTheme !== previousAutoDetect) {
+      if (updates.autoDetectTheme) {
+        this.setupAutoThemeDetection();
+      } else if (this.themeChangeListener) {
+        this.themeChangeListener();
+        this.themeChangeListener = null;
+      }
+    }
+  }
+  /**
+   * Establece el prefijo global para todos los mensajes de log
+   * 
+   * @param {string} prefix - Prefijo a usar
+   * 
+   * @example
+   * logger.setGlobalPrefix('MiApp');
+   * logger.info('Iniciado'); // [MiApp] Iniciado
+   * 
+   * @since 0.3.0
+   */
+  setGlobalPrefix(prefix) {
+    this.config.globalPrefix = prefix;
+  }
+  /**
+   * Establece el nivel de verbosidad para filtrar la salida de logs
+   * 
+   * @param {Verbosity} level - Nivel mínimo a mostrar ('debug' | 'info' | 'warn' | 'error' | 'critical' | 'silent')
+   * 
+   * @example
+   * logger.setVerbosity('warn');  // Solo muestra warn, error y critical
+   * logger.setVerbosity('debug'); // Muestra todos los niveles
+   * logger.setVerbosity('silent'); // No muestra nada
+   * 
+   * @since 0.3.0
+   */
+  setVerbosity(level) {
+    this.config.verbosity = level;
+  }
+  /**
+   * Establece el tema del logger
+   * 
+   * @param {ThemeVariant} theme - Tema a aplicar ('default' | 'dark' | 'light' | 'neon' | 'minimal' | 'cyberpunk')
+   * 
+   * @example
+   * logger.setTheme('neon');      // Tema con colores neón
+   * logger.setTheme('minimal');   // Tema minimalista
+   * logger.setTheme('cyberpunk'); // Tema cyberpunk con efectos
+   * 
+   * @since 0.3.0
+   */
+  setTheme(theme) {
+    if (hasPreset(theme)) {
+      this.preset(theme);
+      return;
+    }
+    if (theme in THEME_PRESETS) {
+      LEVEL_STYLES = THEME_PRESETS[theme];
+      this.config.theme = theme;
+      if (theme in THEME_BANNERS) {
+        const themeBanner = THEME_BANNERS[theme];
+        console.log(`%c${themeBanner.simple}`, themeBanner.style);
+      }
+      this.success(`Theme changed to: ${theme}`);
+    } else {
+      this.error(`Invalid theme: ${theme}. Available:`, [...getAvailablePresets(), ...Object.keys(THEME_PRESETS)]);
+    }
+  }
+  /**
+   * Establece el tipo de banner para mostrar en la inicialización
+   * 
+   * @param {BannerType} bannerType - Tipo de banner ('simple' | 'ascii' | 'unicode' | 'svg' | 'animated')
+   * 
+   * @example
+   * logger.setBannerType('ascii');    // Banner con arte ASCII
+   * logger.setBannerType('unicode');  // Banner con caracteres Unicode
+   * logger.setBannerType('animated'); // Banner con animación
+   * 
+   * @since 0.3.0
+   */
+  setBannerType(bannerType) {
+    this.config.bannerType = bannerType;
+    this.success(`Banner type changed to: ${bannerType}`);
+  }
+  /**
+   * Reinicia el logger a la configuración por defecto
+   * 
+   * @example
+   * logger.resetConfig();
+   * // Todo vuelve a la configuración inicial
+   * 
+   * @since 0.3.0
+   */
+  resetConfig() {
+    if (this.themeChangeListener) {
+      this.themeChangeListener();
+      this.themeChangeListener = null;
+    }
+    this.config = { ...DEFAULT_CONFIG$1 };
+    LEVEL_STYLES = THEME_PRESETS.default;
+    if (this.config.autoDetectTheme) {
+      this.setupAutoThemeDetection();
+    }
+    this.success("Logger configuration reset to defaults");
+  }
+  /**
+   * Método de limpieza para eliminar listeners y liberar recursos
+   * 
+   * @example
+   * // Antes de cerrar la aplicación
+   * logger.cleanup();
+   * 
+   * @since 0.3.0
+   */
+  cleanup() {
+    if (this.themeChangeListener) {
+      this.themeChangeListener();
+      this.themeChangeListener = null;
+    }
+    this.transportManager?.close().catch(() => {
+    });
+  }
+  // ===== SIMPLIFIED API =====
+  /**
+   * Aplica un preset inteligente - funciona perfectamente sin configuración
+   * 
+   * @param {string} name - Nombre del preset a aplicar
+   * 
+   * @example
+   * // Presets disponibles
+   * logger.preset('default');       // Limpio y adaptativo
+   * logger.preset('cyberpunk');     // Colores neón, efectos brillantes
+   * logger.preset('glassmorphism'); // Efectos de blur modernos
+   * logger.preset('minimal');       // Minimalista y elegante
+   * logger.preset('debug');         // Modo desarrollo detallado
+   * logger.preset('production');    // Optimizado para producción
+   * 
+   * @since 0.3.0
+   */
+  preset(name) {
+    if (!hasPreset(name)) {
+      this.error(`Unknown preset: ${name}. Available presets:`, getAvailablePresets());
+      return;
+    }
+    const presetConfig = getSmartPreset(name);
+    if (presetConfig) {
+      this.displaySettings.showTimestamp = presetConfig.timestamp?.show ?? true;
+      this.displaySettings.showLocation = presetConfig.location?.show ?? true;
+      this._activePreset = presetConfig;
+      this._activePresetName = name;
+      if (getEnvironment() === "browser") {
+        this.success(`Applied preset: ${name}`);
+      }
+    }
+  }
+  /**
+   * Lista todos los presets disponibles
+   * 
+   * @returns {string[]} Array con nombres de presets disponibles
+   * 
+   * @example
+   * const disponibles = logger.presets();
+   * console.log(disponibles); // ['default', 'cyberpunk', 'glassmorphism', ...]
+   * 
+   * @since 0.3.0
+   */
+  presets() {
+    return getAvailablePresets();
+  }
+  // ===== TOGGLE METHODS =====
+  /**
+   * Oculta el timestamp en los logs
+   * 
+   * @example
+   * logger.hideTimestamp();
+   * logger.info('Sin marca de tiempo'); // Sin timestamp visible
+   * 
+   * @since 0.3.0
+   */
+  hideTimestamp() {
+    this.displaySettings.showTimestamp = false;
+    this.success("Timestamp hidden");
+  }
+  /**
+   * Muestra el timestamp en los logs
+   * 
+   * @example
+   * logger.showTimestamp();
+   * logger.info('Con marca de tiempo'); // [2024-01-15 10:30:45] Con marca de tiempo
+   * 
+   * @since 0.3.0
+   */
+  showTimestamp() {
+    this.displaySettings.showTimestamp = true;
+    this.success("Timestamp shown");
+  }
+  /**
+   * Oculta la información de ubicación (archivo:línea) en los logs
+   * 
+   * @example
+   * logger.hideLocation();
+   * logger.debug('Sin ubicación'); // Sin mostrar archivo:línea
+   * 
+   * @since 0.3.0
+   */
+  hideLocation() {
+    this.displaySettings.showLocation = false;
+    this.success("Location info hidden");
+  }
+  /**
+   * Muestra la información de ubicación (archivo:línea) en los logs
+   * 
+   * @example
+   * logger.showLocation();
+   * logger.debug('Con ubicación'); // app.js:42 Con ubicación
+   * 
+   * @since 0.3.0
+   */
+  showLocation() {
+    this.displaySettings.showLocation = true;
+    this.success("Location info shown");
+  }
+  /**
+   * Oculta los badges en los logs
+   * 
+   * @example
+   * logger.hideBadges();
+   * const api = logger.api('REST');
+   * api.info('Sin badges'); // Sin mostrar [API] [REST]
+   * 
+   * @since 0.3.0
+   */
+  hideBadges() {
+    this.displaySettings.showBadges = false;
+    this.success("Badges hidden");
+  }
+  /**
+   * Muestra los badges en los logs
+   *
+   * @example
+   * logger.showBadges();
+   * const api = logger.api('GraphQL');
+   * api.info('Con badges'); // [API] [GraphQL] Con badges
+   *
+   * @since 0.3.0
+   */
+  showBadges() {
+    this.displaySettings.showBadges = true;
+    this.success("Badges shown");
+  }
+  /**
+   * Establece múltiples badges para los logs
+   *
+   * @param {string[]} badges - Array de badges a mostrar
+   * @returns {this} Logger instance para encadenamiento
+   *
+   * @example
+   * logger.badges(['v3', 'stable']).info('Release publicado');
+   * logger.badges(['API', 'v2']).warn('Endpoint deprecado');
+   *
+   * @since 3.0.0
+   */
+  badges(badges2) {
+    this.badgeList = [...badges2];
+    return this;
+  }
+  /**
+   * Añade un badge individual a la lista
+   *
+   * @param {string} badge - Badge a añadir
+   * @returns {this} Logger instance para encadenamiento
+   *
+   * @example
+   * logger.badge('DEBUG').badge('AUTH').info('Token validado');
+   *
+   * @since 3.0.0
+   */
+  badge(badge2) {
+    if (!this.badgeList.includes(badge2)) {
+      this.badgeList.push(badge2);
+    }
+    return this;
+  }
+  /**
+   * Limpia todos los badges activos
+   *
+   * @returns {this} Logger instance para encadenamiento
+   *
+   * @example
+   * logger.clearBadges().info('Sin badges');
+   *
+   * @since 3.0.0
+   */
+  clearBadges() {
+    this.badgeList = [];
+    return this;
+  }
+  // ===== SCOPED LOGGERS =====
+  component(name) {
+    return new ComponentLogger(this, name);
+  }
+  api(name) {
+    return new APILogger(this, name);
+  }
+  scope(name) {
+    return new ScopedLogger(this, name);
+  }
+  // ===== SIMPLE CUSTOMIZATION =====
+  /**
+   * Personalización simple con configuración mínima
+   * 
+   * @param {Object} overrides - Opciones de personalización
+   * @param {Object} overrides.message - Configuración del mensaje
+   * @param {Object} overrides.timestamp - Configuración del timestamp
+   * @param {Object} overrides.location - Configuración de ubicación
+   * @param {Object} overrides.level - Configuración del nivel
+   * @param {Object} overrides.prefix - Configuración del prefijo
+   * @param {string} overrides.spacing - Espaciado: 'compact' | 'normal' | 'spacious'
+   * 
+   * @example
+   * logger.customize({
+   *   message: { color: '#00ff00', size: '16px' },
+   *   timestamp: { show: false },
+   *   spacing: 'compact'
+   * });
+   * 
+   * @since 0.3.0
+   */
+  customize(overrides) {
+    if (overrides.timestamp?.show !== void 0) {
+      this.displaySettings.showTimestamp = overrides.timestamp.show;
+    }
+    if (overrides.location?.show !== void 0) {
+      this.displaySettings.showLocation = overrides.location.show;
+    }
+    if (overrides.prefix?.show !== void 0) ;
+    this._customization = overrides;
+    this.success("Customization applied");
+  }
+  /**
+   * Access advanced styling API (for power users)
+   */
+  styles() {
+    return createLogStyleBuilder(this);
+  }
+  // ===== HANDLER MANAGEMENT =====
+  /**
+   * Añade un handler personalizado para extender funcionalidad
+   * 
+   * @param {ILogHandler} handler - Handler que implementa ILogHandler
+   * 
+   * @example
+   * // Handler personalizado para enviar logs a servidor
+   * const remoteHandler = new RemoteLogHandler('https://api.ejemplo.com/logs');
+   * logger.addHandler(remoteHandler);
+   * 
+   * @example
+   * // Handler para guardar en archivo
+   * const fileHandler = new FileLogHandler('./app.log');
+   * logger.addHandler(fileHandler);
+   * 
+   * @since 0.3.0
+   */
+  addHandler(handler) {
+    this.handlers.push(handler);
+  }
+  /**
+   * Obtiene todos los handlers registrados
+   * 
+   * @returns {ILogHandler[]} Array de handlers activos
+   * @since 0.3.0
+   */
+  getHandlers() {
+    return [...this.handlers];
+  }
+  /**
+   * Obtiene el handler de exportación si está disponible
+   *
+   * @returns {ExportLogHandler | undefined} Handler de exportación o undefined
+   * @since 0.3.0
+   */
+  getExportHandler() {
+    return this.exportHandler;
+  }
+  // ===== SERIALIZERS =====
+  /**
+   * Añade un serializador personalizado para un tipo específico
+   *
+   * @param type - Constructor del tipo a serializar
+   * @param serializer - Función de serialización
+   * @param priority - Prioridad (mayor = primero)
+   *
+   * @example
+   * logger.addSerializer(Error, (err) => ({
+   *   name: err.name,
+   *   message: err.message,
+   *   stack: err.stack?.split('\n').slice(0, 5)
+   * }));
+   *
+   * @since 3.0.0
+   */
+  addSerializer(type, serializer, priority) {
+    this.serializerRegistry.add(type, serializer, priority);
+  }
+  /**
+   * Elimina un serializador registrado
+   *
+   * @param type - Constructor del tipo a remover
+   * @returns true si se eliminó
+   *
+   * @since 3.0.0
+   */
+  removeSerializer(type) {
+    return this.serializerRegistry.remove(type);
+  }
+  /**
+   * Obtiene el registry de serializadores
+   *
+   * @returns SerializerRegistry
+   * @since 3.0.0
+   */
+  getSerializerRegistry() {
+    return this.serializerRegistry;
+  }
+  // ===== HOOKS & MIDDLEWARE =====
+  /**
+   * Registra un hook para un evento
+   *
+   * @param event - Evento: 'beforeLog' | 'afterLog' | 'onError'
+   * @param callback - Función a ejecutar
+   * @param priority - Prioridad (mayor = primero)
+   * @returns Función para desregistrar
+   *
+   * @example
+   * const unsubscribe = logger.on('beforeLog', (entry) => {
+   *   entry.correlationId = getCorrelationId();
+   *   return entry;
+   * });
+   *
+   * @since 3.0.0
+   */
+  on(event, callback, priority) {
+    return this.hookManager.on(event, callback, priority);
+  }
+  /**
+   * Registra un hook que se ejecuta solo una vez
+   *
+   * @param event - Evento: 'beforeLog' | 'afterLog' | 'onError'
+   * @param callback - Función a ejecutar
+   * @param priority - Prioridad (mayor = primero)
+   * @returns Función para desregistrar
+   *
+   * @since 3.0.0
+   */
+  once(event, callback, priority) {
+    return this.hookManager.once(event, callback, priority);
+  }
+  /**
+   * Elimina un hook registrado
+   *
+   * @param event - Evento del hook
+   * @param callback - Callback a remover
+   * @returns true si se eliminó
+   *
+   * @since 3.0.0
+   */
+  off(event, callback) {
+    return this.hookManager.off(event, callback);
+  }
+  /**
+   * Añade un middleware al pipeline
+   *
+   * @param middleware - Función middleware
+   * @param priority - Prioridad (mayor = primero)
+   * @returns Función para desregistrar
+   *
+   * @example
+   * logger.use((entry, next) => {
+   *   entry.requestId = asyncLocalStorage.getStore()?.requestId;
+   *   next();
+   * });
+   *
+   * @since 3.0.0
+   */
+  use(middleware, priority) {
+    return this.hookManager.use(middleware, priority);
+  }
+  /**
+   * Obtiene el HookManager
+   *
+   * @returns HookManager
+   * @since 3.0.0
+   */
+  getHookManager() {
+    return this.hookManager;
+  }
+  // ===== TRANSPORTS =====
+  /**
+   * Añade un transport para envío de logs
+   *
+   * @param target - Configuración del transport
+   * @returns ID único del transport
+   *
+   * @example
+   * // File transport
+   * logger.addTransport({
+   *   target: 'file',
+   *   options: { destination: '/var/log/app.log' }
+   * });
+   *
+   * @example
+   * // HTTP transport con batching
+   * logger.addTransport({
+   *   target: 'http',
+   *   options: {
+   *     url: 'https://logs.example.com',
+   *     batchSize: 100,
+   *     flushInterval: 5000
+   *   },
+   *   level: 'warn'
+   * });
+   *
+   * @since 3.0.0
+   */
+  addTransport(target) {
+    if (!this.transportManager) {
+      this.transportManager = new TransportManager();
+    }
+    return this.transportManager.add(target);
+  }
+  /**
+   * Elimina un transport
+   *
+   * @param id - ID del transport a remover
+   * @returns true si se eliminó
+   *
+   * @since 3.0.0
+   */
+  removeTransport(id) {
+    return this.transportManager?.remove(id) ?? false;
+  }
+  /**
+   * Fuerza el flush de todos los transports
+   *
+   * @returns Promise que resuelve cuando todos los buffers están vaciados
+   *
+   * @since 3.0.0
+   */
+  async flushTransports() {
+    await this.transportManager?.flush();
+  }
+  /**
+   * Cierra todos los transports
+   *
+   * @returns Promise que resuelve cuando todos están cerrados
+   *
+   * @since 3.0.0
+   */
+  async closeTransports() {
+    await this.transportManager?.close();
+  }
+  /**
+   * Obtiene el TransportManager
+   *
+   * @returns TransportManager o undefined si no hay transports
+   * @since 3.0.0
+   */
+  getTransportManager() {
+    return this.transportManager;
+  }
+  // ===== CORE LOGGING METHODS =====
+  /**
+   * Verifica si un nivel de log debe mostrarse según la verbosidad actual
+   * @private
+   * @param {LogLevel} level - Nivel de log a verificar
+   * @returns {boolean} True si debe mostrarse, false si no
+   */
+  shouldLog(level) {
+    if (this.config.verbosity === "silent") return false;
+    const levels = { debug: 0, info: 1, warn: 2, error: 3, critical: 4 };
+    return levels[level] >= levels[this.config.verbosity];
+  }
+  /**
+   * Obtiene el prefijo efectivo (global + scope)
+   * @private
+   * @returns {string | undefined} Prefijo combinado o undefined
+   */
+  getEffectivePrefix() {
+    const parts = [this.config.globalPrefix, this.scopedPrefix].filter(Boolean);
+    return parts.length > 0 ? parts.join(":") : void 0;
+  }
+  /**
+   * Método central de logging que maneja estilos y formato
+   * @protected
+   * @param {LogLevel} level - Nivel del log
+   * @param {...any} args - Argumentos a loggear
+   */
+  log(level, ...args) {
+    if (!this.shouldLog(level)) return;
+    const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+    const prefix = this.getEffectivePrefix();
+    const timestamp = formatTimestamp();
+    const serializedArgs = args.map((arg) => this.serializerRegistry.serialize(arg));
+    let message = serializedArgs.length > 0 ? String(serializedArgs[0]) : "";
+    if (this.badgeList.length > 0 && this.displaySettings.showBadges) {
+      const badgePrefix = this.badgeList.map((b) => `[${b}]`).join("");
+      message = badgePrefix + " " + message;
+    }
+    const additionalArgs = serializedArgs.slice(1);
+    let hookEntry = {
+      level,
+      message,
+      args: serializedArgs,
+      timestamp,
+      prefix,
+      stackInfo: stackInfo || void 0
+    };
+    this.hookManager.emit("beforeLog", hookEntry).then((processed) => {
+      message = processed.message;
+    }).catch(() => {
+    });
+    const [format, ...styles2] = createStyledOutput(
+      level,
+      LEVEL_STYLES,
+      prefix,
+      message,
+      this.displaySettings.showLocation ? stackInfo : null,
+      this.config.autoDetectTheme,
+      this._activePreset,
+      this._activePresetName
+    );
+    const groupIndent = "  ".repeat(this.groupDepth);
+    const finalFormat = groupIndent + format;
+    if (additionalArgs.length > 0) {
+      console.log(finalFormat, ...styles2, ...additionalArgs);
+    } else {
+      console.log(finalFormat, ...styles2);
+    }
+    if (this.exportHandler) {
+      this.exportHandler.setGroupInfo(this.groupDepth);
+    }
+    const metadata = {
+      timestamp,
+      level,
+      prefix,
+      stackInfo: stackInfo ? stackInfo : void 0
+    };
+    this.handlers.forEach((handler) => {
+      try {
+        handler.handle(level, message, serializedArgs, metadata);
+      } catch (error2) {
+        console.error("Log handler failed:", error2);
+      }
+    });
+    if (this.transportManager) {
+      const levelValues = {
+        debug: 0,
+        info: 1,
+        warn: 2,
+        error: 3,
+        critical: 4
+      };
+      const record = {
+        level,
+        levelValue: levelValues[level],
+        time: Date.now(),
+        msg: message,
+        prefix,
+        location: stackInfo ? {
+          file: stackInfo.file,
+          line: stackInfo.line,
+          column: stackInfo.column,
+          function: stackInfo.function
+        } : void 0
+      };
+      this.transportManager.write(record).catch(() => {
+      });
+    }
+    this.hookManager.emit("afterLog", hookEntry).catch(() => {
+    });
+  }
+  logWithBindings(bindings, level, ...args) {
+    if (!this.shouldLog(level)) return;
+    let prefix = "";
+    if (bindings.badges?.length) {
+      prefix += bindings.badges.map((b) => `[${b}]`).join("");
+    }
+    if (bindings.scope) {
+      prefix += `[${bindings.scope}] `;
+    }
+    if (prefix && args.length > 0) {
+      args[0] = prefix + String(args[0]);
+    }
+    this.log(level, ...args);
+  }
+  debug(...args) {
+    this.log("debug", ...args);
+  }
+  /**
+   * Registra mensajes informativos
+   * 
+   * @param {...any} args - Mensajes y datos informativos
+   * 
+   * @example
+   * logger.info('Servidor iniciado en puerto 3000');
+   * logger.info('Usuario conectado:', userId);
+   * logger.info('Procesando', totalItems, 'elementos');
+   * 
+   * @since 0.3.0
+   */
+  info(...args) {
+    this.log("info", ...args);
+  }
+  /**
+   * Registra mensajes de advertencia
+   * 
+   * @param {...any} args - Mensajes de advertencia
+   * 
+   * @example
+   * logger.warn('Memoria al 85% de capacidad');
+   * logger.warn('API deprecada, usar v2');
+   * logger.warn('Reintentos agotados:', maxRetries);
+   * 
+   * @since 0.3.0
+   */
+  warn(...args) {
+    this.log("warn", ...args);
+  }
+  /**
+   * Registra mensajes de error
+   * 
+   * @param {...any} args - Mensajes de error y stack traces
+   * 
+   * @example
+   * logger.error('Fallo en conexión a base de datos');
+   * logger.error('Error al procesar:', error.message, error.stack);
+   * logger.error('Código de error:', errorCode);
+   * 
+   * @since 0.3.0
+   */
+  error(...args) {
+    this.log("error", ...args);
+  }
+  /**
+   * Registra mensajes de éxito (nivel info especial)
+   * 
+   * @param {...any} args - Mensajes de operaciones exitosas
+   * 
+   * @example
+   * logger.success('Base de datos conectada');
+   * logger.success('Usuario creado con ID:', userId);
+   * logger.success('✓ Tests pasados: 42/42');
+   * 
+   * @since 0.3.0
+   */
+  success(...args) {
+    if (!this.shouldLog("info")) return;
+    const stackInfo = this.config.enableStackTrace ? parseStackTrace() : null;
+    const prefix = this.getEffectivePrefix();
+    const message = args.length > 0 ? String(args[0]) : "";
+    const additionalArgs = args.slice(1);
+    const [format, ...styles2] = createStyledOutput(
+      "info",
+      LEVEL_STYLES,
+      prefix,
+      message,
+      this.displaySettings.showLocation ? stackInfo : null,
+      this.config.autoDetectTheme,
+      this._activePreset,
+      this._activePresetName
+    );
+    const successStyle = LEVEL_STYLES.success;
+    let emoji = "✅";
+    let label = "SUCCESS";
+    if (successStyle) {
+      if (successStyle.emoji) {
+        emoji = successStyle.emoji;
+      }
+      if (successStyle.label) {
+        label = successStyle.label;
+      }
+    }
+    const successFormat = format.replace(/ℹ️ INFO/, `${emoji} ${label}`);
+    const groupIndent = "  ".repeat(this.groupDepth);
+    const finalFormat = groupIndent + successFormat;
+    if (additionalArgs.length > 0) {
+      console.log(finalFormat, ...styles2, ...additionalArgs);
+    } else {
+      console.log(finalFormat, ...styles2);
+    }
+    const metadata = {
+      timestamp: formatTimestamp(),
+      level: "info",
+      prefix,
+      stackInfo: stackInfo ? stackInfo : void 0
+    };
+    this.handlers.forEach((handler) => {
+      try {
+        handler.handle("info", message, args, metadata);
+      } catch (error2) {
+        console.error("Log handler failed:", error2);
+      }
+    });
+  }
+  /**
+   * Registra información de trace (debugging detallado)
+   * 
+   * @param {...any} args - Datos detallados para debugging
+   * 
+   * @example
+   * logger.trace('Entrando en función processData');
+   * logger.trace('Stack completo:', new Error().stack);
+   * 
+   * @since 0.3.0
+   */
+  trace(...args) {
+    this.log("debug", ...args);
+    if (this.shouldLog("debug")) {
+      console.trace(...args);
+    }
+  }
+  /**
+   * Registra errores críticos (prioridad más alta)
+   * 
+   * @param {...any} args - Errores críticos del sistema
+   * 
+   * @example
+   * logger.critical('Sistema caído - reinicio inmediato requerido');
+   * logger.critical('Pérdida de datos detectada');
+   * logger.critical('Brecha de seguridad:', securityError);
+   * 
+   * @since 0.3.0
+   */
+  critical(...args) {
+    this.log("critical", ...args);
+  }
+  // ===== ADVANCED LOGGING FEATURES =====
+  /**
+   * Muestra datos en formato de tabla
+   * 
+   * @param {any} data - Datos a mostrar (array de objetos o matriz)
+   * @param {string[]} columns - Columnas específicas a mostrar (opcional)
+   * 
+   * @example
+   * const usuarios = [
+   *   { id: 1, nombre: 'Juan', edad: 30 },
+   *   { id: 2, nombre: 'María', edad: 25 }
+   * ];
+   * logger.table(usuarios);
+   * logger.table(usuarios, ['nombre', 'edad']); // Solo estas columnas
+   * 
+   * @since 0.3.0
+   */
+  table(data, columns) {
+    if (!this.shouldLog("info")) return;
+    const prefix = this.getEffectivePrefix();
+    const tableStyle = StylePresets.accent().build();
+    const format = `%c📊 TABLE${prefix ? ` [${prefix}]` : ""}`;
+    console.log(format, tableStyle);
+    if (columns) {
+      console.table(data, columns);
+    } else {
+      console.table(data);
+    }
+  }
+  /**
+   * Inicia un grupo colapsable en la consola
+   * 
+   * @param {string} label - Etiqueta del grupo
+   * @param {boolean} collapsed - Si el grupo inicia colapsado (default: false)
+   * 
+   * @example
+   * logger.group('Procesando usuarios');
+   * logger.info('Usuario 1 procesado');
+   * logger.info('Usuario 2 procesado');
+   * logger.groupEnd();
+   * 
+   * @example
+   * // Grupo colapsado por defecto
+   * logger.group('Detalles adicionales', true);
+   * logger.debug('Información detallada aquí');
+   * logger.groupEnd();
+   * 
+   * @since 0.3.0
+   */
+  group(label, collapsed = false) {
+    const groupStyle = new StyleBuilder().bg("linear-gradient(135deg, #e3f2fd 0%, #bbdefb 100%)").color("#1565c0").border("1px solid #90caf9").padding("4px 12px").rounded("6px").bold().build();
+    const format = `%c📁 ${label}`;
+    if (collapsed) {
+      console.groupCollapsed(format, groupStyle);
+    } else {
+      console.group(format, groupStyle);
+    }
+    this.groupDepth++;
+  }
+  /**
+   * Finaliza el grupo actual de la consola
+   * 
+   * @example
+   * logger.group('Operaciones');
+   * logger.info('Operación 1');
+   * logger.info('Operación 2');
+   * logger.groupEnd(); // Cierra el grupo
+   * 
+   * @since 0.3.0
+   */
+  groupEnd() {
+    if (this.groupDepth > 0) {
+      console.groupEnd();
+      this.groupDepth--;
+    }
+  }
+  // ===== PERFORMANCE TIMING =====
+  /**
+   * Inicia un temporizador con la etiqueta dada
+   * 
+   * @param {string} label - Etiqueta identificadora del temporizador
+   * 
+   * @example
+   * logger.time('proceso-datos');
+   * // ... operación costosa ...
+   * logger.timeEnd('proceso-datos'); // ⏱️ Timer ended: proceso-datos - 1523.45ms
+   * 
+   * @since 0.3.0
+   */
+  time(label) {
+    const timer = {
+      label,
+      startTime: performance.now()
+    };
+    this.timers.set(label, timer);
+    const timerStyle = StylePresets.warning().build();
+    console.log(`%c⏱️ Timer started: ${label}`, timerStyle);
+  }
+  /**
+   * Finaliza un temporizador y muestra el tiempo transcurrido
+   * 
+   * @param {string} label - Etiqueta del temporizador a finalizar
+   * 
+   * @example
+   * logger.time('consulta-db');
+   * await consultarBaseDatos();
+   * logger.timeEnd('consulta-db'); // ⏱️ Timer ended: consulta-db - 234.56ms
+   * 
+   * @since 0.3.0
+   */
+  timeEnd(label) {
+    const timer = this.timers.get(label);
+    if (!timer) {
+      this.warn(`Timer '${label}' does not exist`);
+      return;
+    }
+    const elapsed = performance.now() - timer.startTime;
+    this.timers.delete(label);
+    const timerStyle = StylePresets.success().build();
+    console.log(`%c⏱️ Timer ended: ${label} - ${elapsed.toFixed(2)}ms`, timerStyle);
+  }
+  // ===== ADVANCED VISUAL FEATURES =====
+  /**
+   * Muestra un banner con el tipo especificado o configurado
+   * 
+   * @param {BannerType} bannerType - Tipo de banner (opcional)
+   * 
+   * @example
+   * logger.showBanner('ascii');    // Banner ASCII art
+   * logger.showBanner('unicode');  // Banner con caracteres Unicode
+   * logger.showBanner('svg');      // Banner con gráfico SVG
+   * logger.showBanner();           // Usa el tipo configurado
+   * 
+   * @since 0.3.0
+   */
+  showBanner(bannerType) {
+    const effectiveBannerType = bannerType ? bannerType : this.config.bannerType;
+    displayInitBanner(effectiveBannerType);
+  }
+  /**
+   * Registra mensaje con imagen SVG de fondo
+   * 
+   * @param {string} message - Mensaje a mostrar
+   * @param {string} svgContent - Contenido SVG personalizado (opcional)
+   * @param {StyleOptions} options - Opciones de estilo (ancho, alto, padding)
+   * 
+   * @example
+   * // SVG automático con gradiente
+   * logger.logWithSVG('🎆 Bienvenido a Better Logger');
+   * 
+   * @example
+   * // SVG personalizado
+   * const customSVG = '<svg>...</svg>';
+   * logger.logWithSVG('Logo', customSVG, { width: 400, height: 100 });
+   * 
+   * @since 0.3.0
+   */
+  logWithSVG(message, svgContent, options = {}) {
+    const { width = 300, height = 60, padding = "30px 150px" } = options;
+    let svgDataUri = "";
+    if (svgContent) {
+      const encodedSVG = encodeURIComponent(svgContent);
+      svgDataUri = `data:image/svg+xml,${encodedSVG}`;
+    } else {
+      const defaultSVG = `<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 ${width} ${height}'><defs><linearGradient id='grad' x1='0%' y1='0%' x2='100%' y2='0%'><stop offset='0%' style='stop-color:%23667eea'/><stop offset='100%' style='stop-color:%23764ba2'/></linearGradient></defs><rect width='100%' height='100%' fill='url(%23grad)' rx='4'/><text x='${width / 2}' y='${height / 2 + 5}' text-anchor='middle' fill='white' font-family='monospace' font-size='14' font-weight='bold'>${message}</text></svg>`;
+      svgDataUri = `data:image/svg+xml,${encodeURIComponent(defaultSVG)}`;
+    }
+    const svgStyle = new StyleBuilder().bg(`url("${svgDataUri}") no-repeat center center`).padding(padding).color("transparent").rounded("4px").build();
+    console.log(`%c${message}`, svgStyle);
+  }
+  /**
+   * Registra mensaje con gradiente animado de fondo
+   * 
+   * @param {string} message - Mensaje a animar
+   * @param {number} duration - Duración de la animación en segundos (default: 3)
+   * 
+   * @example
+   * logger.logAnimated('🌈 Animación en progreso');
+   * logger.logAnimated('Cargando...', 5); // Animación de 5 segundos
+   * 
+   * @since 0.3.0
+   */
+  logAnimated(message, duration = 3) {
+    if (!document.getElementById("logger-animations")) {
+      const style = document.createElement("style");
+      style.id = "logger-animations";
+      style.textContent = `
+                @keyframes loggerGradient {
+                    0% { background-position: 0% 50%; }
+                    50% { background-position: 100% 50%; }
+                    100% { background-position: 0% 50%; }
+                }
+            `;
+      document.head.appendChild(style);
+    }
+    const animatedStyle = new StyleBuilder().bg("linear-gradient(-45deg, #667eea, #764ba2, #667eea, #764ba2)").css("background-size", "400% 400%").color("#ffffff").padding("12px 20px").rounded("8px").bold().font("Monaco, Consolas, monospace").animation(`loggerGradient ${duration}s ease infinite`).display("inline-block").build();
+    console.log(`%c${message}`, animatedStyle);
+  }
+  /**
+   * Agrupa logs por una propiedad específica usando Object.groupBy (cuando esté disponible)
+   * 
+   * @param {T[]} items - Array de elementos a agrupar
+   * @param {Function} groupBy - Función que retorna la clave de agrupación
+   * 
+   * @example
+   * const ventas = [
+   *   { producto: 'Laptop', categoria: 'Electrónica', precio: 1200 },
+   *   { producto: 'Mouse', categoria: 'Electrónica', precio: 25 },
+   *   { producto: 'Libro', categoria: 'Literatura', precio: 15 }
+   * ];
+   * logger.logGrouped(ventas, item => item.categoria);
+   * 
+   * @since 0.3.0
+   */
+  logGrouped(items, groupBy) {
+    try {
+      let grouped;
+      if (Object.groupBy) {
+        grouped = Object.groupBy(items, groupBy);
+      } else {
+        grouped = items.reduce((acc, item) => {
+          const key = groupBy(item);
+          if (!acc[key]) {
+            acc[key] = [];
+          }
+          acc[key].push(item);
+          return acc;
+        }, {});
+      }
+      Object.entries(grouped).forEach(([group2, groupItems]) => {
+        this.group(`Group: ${group2}`);
+        this.table(groupItems);
+        this.groupEnd();
+      });
+    } catch {
+      this.info("Grouped data:", items);
+    }
+  }
+  // ===== CLI SYSTEM =====
+  /**
+   * Procesador de comandos CLI para configuración y exportación del logger
+   * 
+   * @param {string} command - Comando CLI a ejecutar
+   * @returns {Promise<void>}
+   * 
+   * @example
+   * // Comandos disponibles
+   * await logger.cli('export json');      // Exporta logs en JSON
+   * await logger.cli('export csv');       // Exporta logs en CSV
+   * await logger.cli('theme list');       // Lista temas disponibles
+   * await logger.cli('theme set neon');   // Cambia al tema neon
+   * await logger.cli('config show');      // Muestra configuración actual
+   * await logger.cli('history clear');    // Limpia historial de logs
+   * await logger.cli('status');           // Muestra estado del logger
+   * await logger.cli('help');             // Muestra ayuda de comandos
+   * 
+   * @since 0.3.0
+   */
+  async cli(command) {
+    if (!this.cliProcessor) {
+      this.error("CLI processor not initialized");
+      return;
+    }
+    await this.cliProcessor.processCommand(command, this);
+  }
+}
+let _defaultLogger = null;
+function getDefaultLogger() {
+  if (!_defaultLogger) {
+    _defaultLogger = new Logger({
+      verbosity: "info",
+      enableColors: true,
+      enableTimestamps: true,
+      enableStackTrace: true,
+      bufferSize: 1e3
+      // Enable export functionality by default
+    });
+    try {
+      displayInitBanner();
+    } catch (error2) {
+    }
+  }
+  return _defaultLogger;
+}
+getDefaultLogger();
+export {
+  APILogger as A,
+  BANNER_VARIANTS as B,
+  ComponentLogger as C,
+  ExportLogHandler as E,
+  HookManager as H,
+  Logger as L,
+  SerializerRegistry as S,
+  THEME_PRESETS as T,
+  THEME_BANNERS as a,
+  TransportManager as b,
+  ScopedLogger as c,
+  ContextLogger as d,
+  displayInitBanner as e
+};
+//# sourceMappingURL=Logger-C126NTrD.js.map