@mks2508/better-logger 0.0.2-alpha.2 → 0.11.0-alpha.1

package/dist/chunks/Logger-CVwk8cgA.js

@@ -0,0 +1,2159 @@
+import { f as formatTimestamp, a as StyleBuilder, B as BUFFER_LIMITS, b as parseTimeInput, c as formatDisplayTime, E as EXPORT_FORMATS, D as DEFAULT_CONFIG, p as parseStackTrace, S as StylePresets } from "./StyleBuilder-BoJTmskd.js";
+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("");
+}
+function createStyledOutput(level, levelStyles, prefix, message, stackInfo) {
+  const levelConfig = levelStyles[level];
+  const timestamp = formatTimestamp();
+  const timestampStyle = new StyleBuilder().color("#666").size("11px").font("Monaco, Consolas, monospace").build();
+  const levelStyle = new StyleBuilder().bg(levelConfig.background).color(levelConfig.color).border(levelConfig.border).shadow(levelConfig.shadow).padding("2px 8px").rounded("4px").bold().font("Monaco, Consolas, monospace").size("12px").build();
+  const prefixStyle = new StyleBuilder().bg("#2d3748").color("#e2e8f0").padding("2px 6px").rounded("3px").bold().font("Monaco, Consolas, monospace").size("11px").build();
+  const messageStyle = new StyleBuilder().color("#2d3748").font("system-ui, -apple-system, sans-serif").size("14px").build();
+  const locationStyle = new StyleBuilder().color("#718096").size("11px").font("Monaco, Consolas, monospace").build();
+  let format = `%c${timestamp.slice(11, 23)} %c${levelConfig.emoji} ${levelConfig.label}`;
+  const styles = [timestampStyle, levelStyle];
+  if (prefix) {
+    format += ` %c${prefix}`;
+    styles.push(prefixStyle);
+  }
+  format += ` %c${message}`;
+  styles.push(messageStyle);
+  if (stackInfo) {
+    format += ` %c(${stackInfo.file}:${stackInfo.line}:${stackInfo.column})`;
+    styles.push(locationStyle);
+  }
+  return [format, ...styles];
+}
+function generateLogId() {
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function escapeHtml(text) {
+  const div = document.createElement("div");
+  div.textContent = text;
+  return div.innerHTML;
+}
+function safeStringify(obj, _maxDepth = 3) {
+  try {
+    return JSON.stringify(obj, (_key, value) => {
+      if (typeof value === "function") return "[Function]";
+      if (value instanceof Error) return `[Error: ${value.message}]`;
+      if (value instanceof Date) return value.toISOString();
+      if (typeof value === "undefined") return "[undefined]";
+      return value;
+    }, 2);
+  } catch (error) {
+    return String(obj);
+  }
+}
+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;
+  /**
+   * Creates a new Logger instance
+   */
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    if (this.config.bufferSize) {
+      this.exportHandler = new ExportLogHandler(this.config.bufferSize);
+      this.handlers.push(this.exportHandler);
+    }
+    this.cliProcessor = createDefaultCLI();
+  }
+  // ===== CONFIGURATION METHODS =====
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration
+   */
+  updateConfig(updates) {
+    this.config = { ...this.config, ...updates };
+  }
+  /**
+   * Sets the global prefix for all log messages
+   */
+  setGlobalPrefix(prefix) {
+    this.config.globalPrefix = prefix;
+  }
+  /**
+   * Sets the verbosity level for filtering log output
+   */
+  setVerbosity(level) {
+    this.config.verbosity = level;
+  }
+  /**
+   * Sets the logger theme
+   */
+  setTheme(theme) {
+    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 themes:`, Object.keys(THEME_PRESETS));
+    }
+  }
+  /**
+   * Set banner type for initialization display
+   */
+  setBannerType(bannerType) {
+    this.config.bannerType = bannerType;
+    this.success(`Banner type changed to: ${bannerType}`);
+  }
+  /**
+   * Reset logger to default configuration
+   */
+  resetConfig() {
+    this.config = { ...DEFAULT_CONFIG };
+    LEVEL_STYLES = THEME_PRESETS.default;
+    this.success("Logger configuration reset to defaults");
+  }
+  // ===== SCOPED LOGGER =====
+  /**
+   * Creates a scoped logger with a specific prefix
+   */
+  createScopedLogger(prefix) {
+    const scopedLogger = new Logger(this.config);
+    scopedLogger.scopedPrefix = prefix;
+    scopedLogger.handlers = [...this.handlers];
+    scopedLogger.exportHandler = this.exportHandler;
+    return scopedLogger;
+  }
+  // ===== HANDLER MANAGEMENT =====
+  /**
+   * Adds a custom log handler for extensibility
+   */
+  addHandler(handler) {
+    this.handlers.push(handler);
+  }
+  /**
+   * Get all registered handlers
+   */
+  getHandlers() {
+    return [...this.handlers];
+  }
+  /**
+   * Get export handler if available
+   */
+  getExportHandler() {
+    return this.exportHandler;
+  }
+  // ===== CORE LOGGING METHODS =====
+  /**
+   * Checks if a log level should be output based on current verbosity
+   */
+  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];
+  }
+  /**
+   * Gets the effective prefix (global + scoped)
+   */
+  getEffectivePrefix() {
+    const parts = [this.config.globalPrefix, this.scopedPrefix].filter(Boolean);
+    return parts.length > 0 ? parts.join(":") : void 0;
+  }
+  /**
+   * Core logging method that handles styling and formatting
+   */
+  log(level, ...args) {
+    if (!this.shouldLog(level)) 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, ...styles] = createStyledOutput(level, LEVEL_STYLES, prefix, message, stackInfo);
+    const groupIndent = "  ".repeat(this.groupDepth);
+    const finalFormat = groupIndent + format;
+    if (additionalArgs.length > 0) {
+      console.log(finalFormat, ...styles, ...additionalArgs);
+    } else {
+      console.log(finalFormat, ...styles);
+    }
+    if (this.exportHandler) {
+      this.exportHandler.setGroupInfo(this.groupDepth);
+    }
+    const metadata = {
+      timestamp: formatTimestamp(),
+      level,
+      prefix,
+      stackInfo: stackInfo ? stackInfo : void 0
+    };
+    this.handlers.forEach((handler) => {
+      try {
+        handler.handle(level, message, args, metadata);
+      } catch (error2) {
+        console.error("Log handler failed:", error2);
+      }
+    });
+  }
+  /**
+   * Logs debug information (lowest priority)
+   */
+  debug(...args) {
+    this.log("debug", ...args);
+  }
+  /**
+   * Logs informational messages
+   */
+  info(...args) {
+    this.log("info", ...args);
+  }
+  /**
+   * Logs warning messages
+   */
+  warn(...args) {
+    this.log("warn", ...args);
+  }
+  /**
+   * Logs error messages
+   */
+  error(...args) {
+    this.log("error", ...args);
+  }
+  /**
+   * Logs success messages (special info level)
+   */
+  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, ...styles] = createStyledOutput("info", LEVEL_STYLES, prefix, message, stackInfo);
+    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, ...styles, ...additionalArgs);
+    } else {
+      console.log(finalFormat, ...styles);
+    }
+    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);
+      }
+    });
+  }
+  /**
+   * Logs trace information (detailed debugging)
+   */
+  trace(...args) {
+    this.log("debug", ...args);
+    if (this.shouldLog("debug")) {
+      console.trace(...args);
+    }
+  }
+  /**
+   * Logs critical errors (highest priority)
+   */
+  critical(...args) {
+    this.log("critical", ...args);
+  }
+  // ===== ADVANCED LOGGING FEATURES =====
+  /**
+   * Displays data in a table format
+   */
+  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);
+    }
+  }
+  /**
+   * Starts a collapsible group in the console
+   */
+  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++;
+  }
+  /**
+   * Ends the current console group
+   */
+  groupEnd() {
+    if (this.groupDepth > 0) {
+      console.groupEnd();
+      this.groupDepth--;
+    }
+  }
+  // ===== PERFORMANCE TIMING =====
+  /**
+   * Starts a timer with the given label
+   */
+  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);
+  }
+  /**
+   * Ends a timer and logs the elapsed time
+   */
+  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 =====
+  /**
+   * Display banner with specified or configured type
+   */
+  showBanner(bannerType) {
+    const effectiveBannerType = bannerType ? bannerType : this.config.bannerType;
+    displayInitBanner(effectiveBannerType);
+  }
+  /**
+   * Log with SVG background image
+   */
+  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);
+  }
+  /**
+   * Log with animated background gradient
+   */
+  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);
+  }
+  /**
+   * Groups logs by a specific property using modern Object.groupBy (when available)
+   */
+  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 =====
+  /**
+   * CLI command processor for logger configuration and export
+   */
+  async cli(command) {
+    if (!this.cliProcessor) {
+      this.error("CLI processor not initialized");
+      return;
+    }
+    await this.cliProcessor.processCommand(command, this);
+  }
+}
+new Logger({
+  verbosity: "info",
+  enableColors: true,
+  enableTimestamps: true,
+  enableStackTrace: true,
+  bufferSize: 1e3
+  // Enable export functionality by default
+});
+displayInitBanner();
+export {
+  BANNER_VARIANTS as B,
+  ExportLogHandler as E,
+  Logger as L,
+  THEME_PRESETS as T,
+  THEME_BANNERS as a,
+  displayInitBanner as d
+};
+//# sourceMappingURL=Logger-CVwk8cgA.js.map