@mks2508/better-logger 2.0.0 → 2.1.0

package/dist/chunks/environment-TI2ByCPT.js

@@ -0,0 +1,1209 @@
+function isMinifiedFile(filename) {
+  const minifiedPatterns = [
+    /\.min\.js$/,
+    /\.bundle\.js$/,
+    /\.chunk\.js$/,
+    /-[\w\d]{8,}\.js$/,
+    // Hash-based filenames
+    /Logger-[A-Za-z0-9]+\.js$/,
+    // Logger bundle files
+    /node_modules/,
+    /dist\//,
+    /build\//,
+    /\.mjs$/
+  ];
+  return minifiedPatterns.some((pattern) => pattern.test(filename));
+}
+function extractCleanFilename(fullPath) {
+  const filename = fullPath.split(/[/\\]/).pop() || fullPath;
+  return filename.replace(/\.min\.js$/, ".js").replace(/\.bundle\.js$/, ".js").replace(/\.chunk\.js$/, ".js").replace(/-[\w\d]{8,}\.js$/, ".js").replace(/Logger-[A-Za-z0-9]+\.js$/, "logger.ts");
+}
+function parseStackTrace() {
+  try {
+    const stack = new Error().stack;
+    if (!stack) {
+      return null;
+    }
+    const lines = stack.split("\n").filter((line) => line.trim());
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line) {
+        continue;
+      }
+      if (line.includes("parseStackTrace") || line.includes("Logger.") || line.includes(".log(") || line.includes("createStyledOutput")) {
+        continue;
+      }
+      let match;
+      const chromeMatch = line.match(/at\s+(?:(.+?)\s+\()?(.+?):(\d+):(\d+)\)?$/);
+      if (chromeMatch) {
+        const filename = chromeMatch[2];
+        if (filename && isMinifiedFile(filename)) {
+          continue;
+        }
+        match = chromeMatch;
+      } else {
+        const firefoxMatch = line.match(/(.+?)@(.+?):(\d+):(\d+)$/);
+        if (firefoxMatch) {
+          const filename = firefoxMatch[2];
+          if (filename && isMinifiedFile(filename)) {
+            continue;
+          }
+          match = firefoxMatch;
+        } else {
+          const safariMatch = line.match(/(\S+)?@(.+?):(\d+):(\d+)$/);
+          if (safariMatch) {
+            const filename = safariMatch[2];
+            if (filename && isMinifiedFile(filename)) {
+              continue;
+            }
+            match = safariMatch;
+          }
+        }
+      }
+      if (!match) {
+        continue;
+      }
+      const [, functionName, file, lineStr, columnStr] = match;
+      if (!file) {
+        continue;
+      }
+      const cleanFileName = extractCleanFilename(file).split("?")[0];
+      if (!cleanFileName) {
+        continue;
+      }
+      const lineNum = lineStr ? parseInt(lineStr, 10) : 0;
+      const columnNum = columnStr ? parseInt(columnStr, 10) : 0;
+      const cleanFunction = functionName && functionName.trim() ? functionName.trim() : void 0;
+      return {
+        file: cleanFileName ? cleanFileName : "unknown",
+        line: lineNum,
+        column: columnNum,
+        function: cleanFunction
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+const DEFAULT_CONFIG = {
+  verbosity: "info",
+  enableColors: true,
+  enableTimestamps: true,
+  enableStackTrace: true,
+  theme: "default",
+  bannerType: "simple",
+  bufferSize: 1e3,
+  autoDetectTheme: true,
+  outputFormat: "auto"
+};
+const LEVEL_STYLES = {
+  debug: {
+    emoji: "🔍",
+    label: "DEBUG",
+    background: "linear-gradient(90deg, #6c757d, #495057)",
+    color: "#ffffff",
+    border: "1px solid #6c757d",
+    shadow: "0 2px 4px rgba(108, 117, 125, 0.3)"
+  },
+  info: {
+    emoji: "ℹ️",
+    label: "INFO",
+    background: "linear-gradient(90deg, #007bff, #0056b3)",
+    color: "#ffffff",
+    border: "1px solid #007bff",
+    shadow: "0 2px 4px rgba(0, 123, 255, 0.3)"
+  },
+  warn: {
+    emoji: "⚠️",
+    label: "WARN",
+    background: "linear-gradient(90deg, #ffc107, #e0a800)",
+    color: "#000000",
+    border: "1px solid #ffc107",
+    shadow: "0 2px 4px rgba(255, 193, 7, 0.3)"
+  },
+  error: {
+    emoji: "❌",
+    label: "ERROR",
+    background: "linear-gradient(90deg, #dc3545, #c82333)",
+    color: "#ffffff",
+    border: "1px solid #dc3545",
+    shadow: "0 2px 4px rgba(220, 53, 69, 0.3)"
+  },
+  critical: {
+    emoji: "🚨",
+    label: "CRITICAL",
+    background: "linear-gradient(90deg, #8B0000, #FF0000)",
+    color: "#ffffff",
+    border: "2px solid #FF0000",
+    shadow: "0 4px 8px rgba(255, 0, 0, 0.4)"
+  },
+  success: {
+    emoji: "✅",
+    label: "SUCCESS",
+    background: "linear-gradient(90deg, #28a745, #1e7e34)",
+    color: "#ffffff",
+    border: "1px solid #28a745",
+    shadow: "0 2px 4px rgba(40, 167, 69, 0.3)"
+  }
+};
+const BUFFER_LIMITS = {
+  MIN_SIZE: 50,
+  DEFAULT_SIZE: 1e3,
+  MAX_SIZE: 1e4
+};
+const EXPORT_FORMATS = {
+  json: { extension: ".json", mimeType: "application/json" },
+  csv: { extension: ".csv", mimeType: "text/csv" },
+  markdown: { extension: ".md", mimeType: "text/markdown" },
+  plain: { extension: ".txt", mimeType: "text/plain" },
+  html: { extension: ".html", mimeType: "text/html" }
+};
+const TIME_UNITS = {
+  ms: 1,
+  s: 1e3,
+  m: 60 * 1e3,
+  h: 60 * 60 * 1e3,
+  d: 24 * 60 * 60 * 1e3
+};
+const ADAPTIVE_COLORS = {
+  timestamp: {
+    light: "#666666",
+    dark: "#a0a0a0"
+  },
+  messageText: {
+    light: "#2d3748",
+    dark: "#f7fafc"
+  },
+  prefix: {
+    light: "#2d3748",
+    dark: "#e2e8f0"
+  },
+  prefixBackground: {
+    light: "#2d3748",
+    dark: "#4a5568"
+  },
+  location: {
+    light: "#718096",
+    dark: "#a0aec0"
+  }
+};
+const BUILD_PRESETS = {
+  /**
+   * Configuración optimizada para Next.js builds
+   */
+  nextjs: {
+    verbosity: "info",
+    enableColors: true,
+    enableTimestamps: false,
+    enableStackTrace: false,
+    autoDetectTheme: false,
+    outputFormat: "build"
+  },
+  /**
+   * Configuración para Webpack builds
+   */
+  webpack: {
+    verbosity: "info",
+    enableColors: true,
+    enableTimestamps: true,
+    enableStackTrace: false,
+    autoDetectTheme: false,
+    outputFormat: "build"
+  },
+  /**
+   * Configuración para CI/CD environments
+   */
+  ci: {
+    verbosity: "info",
+    enableColors: false,
+    enableTimestamps: true,
+    enableStackTrace: true,
+    autoDetectTheme: false,
+    outputFormat: "ci"
+  },
+  /**
+   * Configuración para desarrollo terminal
+   */
+  terminal: {
+    verbosity: "debug",
+    enableColors: true,
+    enableTimestamps: true,
+    enableStackTrace: true,
+    autoDetectTheme: false,
+    outputFormat: "ansi"
+  }
+};
+const ENVIRONMENT_DETECTION = {
+  // Next.js detection
+  isNextJS: typeof process !== "undefined" && (process.env.NEXT_RUNTIME || process.env.NEXT_PUBLIC_VERCEL_ENV || process.argv && process.argv.some((arg) => arg.includes("next"))),
+  // Webpack detection
+  isWebpack: typeof process !== "undefined" && (process.env.WEBPACK_ENV || process.env.WEBPACK_BUILD || process.argv && process.argv.some((arg) => arg.includes("webpack"))),
+  // CI/CD detection
+  isCI: typeof process !== "undefined" && (process.env.CI || process.env.GITHUB_ACTIONS || process.env.JENKINS_URL || process.env.GITLAB_CI || process.env.TRAVIS || process.env.CIRCLECI),
+  // Build detection
+  isBuild: typeof process !== "undefined" && true,
+  // Terminal with ANSI support
+  isTerminal: typeof process !== "undefined" && (process.stdout?.isTTY === true && process.env.TERM !== "dumb")
+};
+function detectEnvironmentPreset() {
+  if (ENVIRONMENT_DETECTION.isCI) {
+    return "ci";
+  }
+  if (ENVIRONMENT_DETECTION.isNextJS) {
+    return "nextjs";
+  }
+  if (ENVIRONMENT_DETECTION.isWebpack) {
+    return "webpack";
+  }
+  if (ENVIRONMENT_DETECTION.isTerminal) {
+    return "terminal";
+  }
+  return "terminal";
+}
+function getOptimalConfig() {
+  const preset = detectEnvironmentPreset();
+  return {
+    ...DEFAULT_CONFIG,
+    ...BUILD_PRESETS[preset]
+  };
+}
+function formatTimestamp() {
+  try {
+    const now = /* @__PURE__ */ new Date();
+    return now.toISOString();
+  } catch {
+    return (/* @__PURE__ */ new Date()).toISOString();
+  }
+}
+function parseRelativeTime(timeStr) {
+  const match = timeStr.match(/^(\d+)(ms|s|m|h|d)$/);
+  if (!match) {
+    throw new Error(`Invalid time format: ${timeStr}. Use format like "2h", "30m", "1d"`);
+  }
+  const [, amount, unit] = match;
+  const multiplier = TIME_UNITS[unit];
+  return parseInt(amount || "0", 10) * multiplier;
+}
+function parseTimeInput(input) {
+  if (input instanceof Date) {
+    return input;
+  }
+  if (typeof input === "number") {
+    return new Date(Date.now() - input * TIME_UNITS.h);
+  }
+  if (typeof input === "string") {
+    const isoDate = new Date(input);
+    if (!isNaN(isoDate.getTime())) {
+      return isoDate;
+    }
+    try {
+      const ms = parseRelativeTime(input);
+      return new Date(Date.now() - ms);
+    } catch {
+      throw new Error(`Invalid time format: ${input}`);
+    }
+  }
+  throw new Error(`Unsupported time input type: ${typeof input}`);
+}
+function formatDisplayTime(date, format = "short") {
+  switch (format) {
+    case "time-only":
+      return date.toTimeString().slice(0, 8);
+    // HH:MM:SS
+    case "full":
+      return date.toISOString();
+    case "short":
+    default:
+      return date.toISOString().slice(11, 23);
+  }
+}
+class StyleBuilder {
+  styles = [];
+  constructor(baseStyle = "") {
+    if (baseStyle) this.styles.push(baseStyle);
+  }
+  /**
+   * Add background color or gradient
+   */
+  bg(background) {
+    this.styles.push(`background: ${background}`);
+    return this;
+  }
+  /**
+   * Add text color
+   */
+  color(color) {
+    this.styles.push(`color: ${color}`);
+    return this;
+  }
+  /**
+   * Add border styling
+   */
+  border(border) {
+    this.styles.push(`border: ${border}`);
+    return this;
+  }
+  /**
+   * Add box shadow
+   */
+  shadow(shadow) {
+    this.styles.push(`box-shadow: ${shadow}`);
+    return this;
+  }
+  /**
+   * Add padding
+   */
+  padding(padding) {
+    this.styles.push(`padding: ${padding}`);
+    return this;
+  }
+  /**
+   * Add margin
+   */
+  margin(margin) {
+    this.styles.push(`margin: ${margin}`);
+    return this;
+  }
+  /**
+   * Add border radius
+   */
+  rounded(radius = "4px") {
+    this.styles.push(`border-radius: ${radius}`);
+    return this;
+  }
+  /**
+   * Add font weight
+   */
+  bold() {
+    this.styles.push("font-weight: bold");
+    return this;
+  }
+  /**
+   * Add font styling
+   */
+  font(font) {
+    this.styles.push(`font-family: ${font}`);
+    return this;
+  }
+  /**
+   * Set monospace font family (alias for common monospace fonts)
+   */
+  mono() {
+    return this.font('Monaco, Consolas, "Courier New", monospace');
+  }
+  /**
+   * Set system font family (alias for system fonts)
+   */
+  system() {
+    return this.font('system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif');
+  }
+  /**
+   * Add font size
+   */
+  size(size) {
+    this.styles.push(`font-size: ${size}`);
+    return this;
+  }
+  /**
+   * Add line height
+   */
+  lineHeight(height) {
+    this.styles.push(`line-height: ${height}`);
+    return this;
+  }
+  /**
+   * Add text decoration
+   */
+  underline() {
+    this.styles.push("text-decoration: underline");
+    return this;
+  }
+  /**
+   * Add text transform
+   */
+  uppercase() {
+    this.styles.push("text-transform: uppercase");
+    return this;
+  }
+  /**
+   * Add opacity
+   */
+  opacity(value) {
+    this.styles.push(`opacity: ${value}`);
+    return this;
+  }
+  /**
+   * Add display property
+   */
+  display(value) {
+    this.styles.push(`display: ${value}`);
+    return this;
+  }
+  /**
+   * Add position property
+   */
+  position(value) {
+    this.styles.push(`position: ${value}`);
+    return this;
+  }
+  /**
+   * Add transform property
+   */
+  transform(value) {
+    this.styles.push(`transform: ${value}`);
+    return this;
+  }
+  /**
+   * Add animation property
+   */
+  animation(value) {
+    this.styles.push(`animation: ${value}`);
+    return this;
+  }
+  /**
+   * Add transition property
+   */
+  transition(value) {
+    this.styles.push(`transition: ${value}`);
+    return this;
+  }
+  /**
+   * Add cursor property
+   */
+  cursor(value) {
+    this.styles.push(`cursor: ${value}`);
+    return this;
+  }
+  /**
+   * Add any custom CSS property
+   */
+  custom(property, value) {
+    this.styles.push(`${property}: ${value}`);
+    return this;
+  }
+  /**
+   * Add any CSS property (alias for custom)
+   */
+  css(property, value) {
+    return this.custom(property, value);
+  }
+  /**
+   * Build the final CSS string
+   */
+  build() {
+    return this.styles.join("; ");
+  }
+  /**
+   * Clear all styles and start fresh
+   */
+  clear() {
+    this.styles = [];
+    return this;
+  }
+  /**
+   * Clone this StyleBuilder with the same styles
+   */
+  clone() {
+    const cloned = new StyleBuilder();
+    cloned.styles = [...this.styles];
+    return cloned;
+  }
+  /**
+   * Merge another StyleBuilder's styles into this one
+   */
+  merge(other) {
+    this.styles.push(...other.styles);
+    return this;
+  }
+}
+function createStyler() {
+  const builder = new StyleBuilder();
+  return new Proxy(builder, {
+    get(target, prop) {
+      if (prop in target) {
+        const method = target[prop];
+        if (typeof method === "function") {
+          return method.bind(target);
+        }
+        return method;
+      }
+      return void 0;
+    }
+  });
+}
+createStyler();
+const StylePresets = {
+  success: () => new StyleBuilder().bg("linear-gradient(135deg, #00b894 0%, #00a085 100%)").color("#ffffff").padding("4px 8px").rounded("4px").bold(),
+  error: () => new StyleBuilder().bg("linear-gradient(135deg, #e84393 0%, #d63031 100%)").color("#ffffff").padding("4px 8px").rounded("4px").bold(),
+  warning: () => new StyleBuilder().bg("linear-gradient(135deg, #fdcb6e 0%, #e17055 100%)").color("#2d3436").padding("4px 8px").rounded("4px").bold(),
+  info: () => new StyleBuilder().bg("linear-gradient(135deg, #74b9ff 0%, #0984e3 100%)").color("#ffffff").padding("4px 8px").rounded("4px").bold(),
+  debug: () => new StyleBuilder().bg("linear-gradient(135deg, #667eea 0%, #764ba2 100%)").color("#ffffff").padding("4px 8px").rounded("4px").bold(),
+  muted: () => new StyleBuilder().color("#6c757d").font("Monaco, Consolas, monospace").size("12px"),
+  accent: () => new StyleBuilder().bg("#f8f9fa").color("#495057").padding("2px 6px").rounded("3px").border("1px solid #dee2e6"),
+  neon: () => new StyleBuilder().bg("linear-gradient(135deg, #0f3460 0%, #e94560 100%)").color("#00ffff").padding("4px 8px").rounded("4px").bold().shadow("0 0 10px rgba(0, 255, 255, 0.5)")
+};
+function getEnvironment() {
+  if (typeof globalThis !== "undefined" && globalThis.Deno) {
+    return "deno";
+  }
+  if (typeof window === "undefined" && typeof self !== "undefined" && typeof self.importScripts === "function") {
+    return "webworker";
+  }
+  if (typeof process !== "undefined" && process.versions && process.versions.node) {
+    if (isRunningInTerminal()) {
+      return "terminal";
+    }
+    return "server";
+  }
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    return "browser";
+  }
+  return "unknown";
+}
+function isRunningInTerminal() {
+  if (typeof process === "undefined") return false;
+  const isTTY = process.stdout && process.stdout.isTTY;
+  const hasTerminalEnv = process.env && (process.env.TERM || process.env.TERM_PROGRAM || process.env.SSH_TTY || process.env.TERM_SESSION_ID);
+  const terminalPrograms = [
+    "vscode",
+    "hyper",
+    "iterm",
+    "terminal",
+    "alacritty",
+    "kitty",
+    "gnome-terminal",
+    "konsole",
+    "xterm",
+    "tmux",
+    "screen"
+  ];
+  const isTerminalProgram = hasTerminalEnv && terminalPrograms.some(
+    (program) => process.env.TERM_PROGRAM?.toLowerCase().includes(program) || process.env.TERM?.toLowerCase().includes(program)
+  );
+  return Boolean(isTTY || hasTerminalEnv || isTerminalProgram);
+}
+function supportsANSI() {
+  const env = getEnvironment();
+  if (env === "browser") return false;
+  if (env === "terminal") return true;
+  if (env === "server") return checkServerANSISupport();
+  return false;
+}
+function checkServerANSISupport() {
+  if (typeof process === "undefined") return false;
+  const supportsANSI2 = process.env && (process.env.COLORTERM || process.env.FORCE_COLOR || process.env.TERM && process.env.TERM !== "dumb" || process.env.TERM_PROGRAM);
+  return Boolean(supportsANSI2);
+}
+function getColorCapability() {
+  const env = getEnvironment();
+  if (env === "browser") {
+    return "full";
+  }
+  if (!supportsANSI()) {
+    return "none";
+  }
+  if (typeof process !== "undefined" && process.env) {
+    const hasTrueColor = process.env.COLORTERM === "truecolor" || process.env.COLORTERM === "24bit";
+    const has256Colors = process.env.TERM && process.env.TERM.includes("256");
+    if (hasTrueColor || has256Colors) {
+      return "full";
+    }
+  }
+  return "basic";
+}
+class TerminalRenderer {
+  colorCapability;
+  constructor(colorCapability = "full") {
+    this.colorCapability = colorCapability;
+  }
+  /**
+   * Get ANSI color codes for basic colors
+   */
+  getColorCode(color, background = false) {
+    const colorCodes = {
+      "black": { normal: "30", bright: "90" },
+      "red": { normal: "31", bright: "91" },
+      "green": { normal: "32", bright: "92" },
+      "yellow": { normal: "33", bright: "93" },
+      "blue": { normal: "34", bright: "94" },
+      "magenta": { normal: "35", bright: "95" },
+      "cyan": { normal: "36", bright: "96" },
+      "white": { normal: "37", bright: "97" },
+      "gray": { normal: "90", bright: "37" },
+      "grey": { normal: "90", bright: "37" }
+    };
+    const codes = colorCodes[color.toLowerCase()] || { normal: "37" };
+    return `\x1B[${codes.normal}m`;
+  }
+  /**
+   * Get ANSI style codes
+   */
+  getStyleCode(styles) {
+    const styleCodes = {
+      "bold": "1",
+      "dim": "2",
+      "italic": "3",
+      "underline": "4",
+      "reset": "0"
+    };
+    const codes = styles.map((style) => styleCodes[style] || "0").join(";");
+    return codes ? `\x1B[${codes}m` : "";
+  }
+  /**
+   * Convert log styles to ANSI formatting
+   */
+  renderTerminal(level, message, timestamp, prefix, location, styles) {
+    const reset = "\x1B[0m";
+    const result = { text: "", reset };
+    if (styles) {
+      result.timestamp = this.styleTimestamp(timestamp, styles.timestamp);
+      result.level = this.styleLevel(level, styles.level);
+      result.prefix = this.stylePrefix(prefix, styles.prefix);
+      result.message = this.styleMessage(message, styles.message);
+      result.location = this.styleLocation(location, styles.location);
+    } else {
+      result.timestamp = this.styleTimestamp(timestamp);
+      result.level = this.styleLevel(level);
+      result.prefix = this.stylePrefix(prefix);
+      result.message = this.styleMessage(message);
+      result.location = this.styleLocation(location);
+    }
+    const parts = [];
+    if (result.timestamp) parts.push(result.timestamp);
+    if (result.level) parts.push(result.level);
+    if (result.prefix) parts.push(result.prefix);
+    if (result.message) parts.push(result.message);
+    if (result.location) parts.push(result.location);
+    result.text = parts.join(" ") + reset;
+    return result;
+  }
+  /**
+   * Style timestamp based on preset or defaults
+   */
+  styleTimestamp(timestamp, style) {
+    if (!timestamp || !style?.show) return "";
+    if (this.colorCapability === "none") {
+      return timestamp;
+    }
+    const dimStyle = this.getStyleCode(["dim"]);
+    return `${dimStyle}${timestamp}${"\x1B[0m"}`;
+  }
+  /**
+   * Style level with appropriate colors and formatting
+   */
+  styleLevel(level, style) {
+    if (!style?.show) return "";
+    const levelText = this.getLevelText(level);
+    const levelColors = {
+      "debug": "magenta",
+      "info": "blue",
+      "warn": "yellow",
+      "error": "red",
+      "critical": "red"
+    };
+    if (this.colorCapability === "none") {
+      return `[${levelText}]`;
+    }
+    const color = levelColors[level] || "white";
+    const colorCode = this.getColorCode(color);
+    const boldStyle = this.getStyleCode(["bold"]);
+    if (style?.style === "compact") {
+      return `${colorCode}[${levelText}]${"\x1B[0m"}`;
+    } else {
+      return `${colorCode}${boldStyle}[${levelText}]${"\x1B[0m"}`;
+    }
+  }
+  /**
+   * Style prefix based on preset - now as a badge
+   */
+  stylePrefix(prefix, style) {
+    if (!prefix || !style?.show) return "";
+    if (this.colorCapability === "none") {
+      return `[${prefix}]`;
+    }
+    const colorCode = this.getColorCode("cyan");
+    const bgBlack = "\x1B[40m";
+    return `${bgBlack}${colorCode}[${prefix.toUpperCase()}]${"\x1B[0m"}`;
+  }
+  /**
+   * Style message based on preset
+   */
+  styleMessage(message, style) {
+    if (!style?.show) return message;
+    return message;
+  }
+  /**
+   * Style location (file:line) information
+   */
+  styleLocation(location, style) {
+    if (!location || !style?.show) return "";
+    if (this.colorCapability === "none") {
+      return `(${location})`;
+    }
+    const dimStyle = this.getStyleCode(["dim"]);
+    if (style?.style === "clickable") {
+      const underlineStyle = this.getStyleCode(["dim", "underline"]);
+      return `${underlineStyle}(${location})${"\x1B[0m"}`;
+    }
+    return `${dimStyle}(${location})${"\x1B[0m"}`;
+  }
+  /**
+   * Get text representation of log level
+   */
+  getLevelText(level) {
+    const levelMap = {
+      "debug": "DEBUG",
+      "info": "INFO",
+      "warn": "WARN",
+      "error": "ERROR",
+      "critical": "CRITICAL"
+    };
+    return levelMap[level] || String(level).toUpperCase();
+  }
+  /**
+   * Create cyberpunk-style ANSI rendering
+   */
+  renderCyberpunk(level, message, timestamp, prefix, location) {
+    const reset = "\x1B[0m";
+    const levelColors = {
+      "debug": "\x1B[95m",
+      // Bright magenta
+      "info": "\x1B[94m",
+      // Bright blue
+      "warn": "\x1B[93m",
+      // Bright yellow
+      "error": "\x1B[91m",
+      // Bright red
+      "critical": "\x1B[91m\x1B[1m"
+      // Bright red + bold
+    };
+    const parts = [];
+    if (timestamp) {
+      parts.push(`\x1B[90m${timestamp}${reset}`);
+    }
+    const levelColor = levelColors[level] || "\x1B[97m";
+    const bgBlack = "\x1B[40m";
+    parts.push(`${bgBlack}${levelColor} ${this.getLevelText(level)} ${reset}`);
+    if (prefix) {
+      const bgBlack2 = "\x1B[40m";
+      parts.push(`${bgBlack2}\x1B[96m[${prefix.toUpperCase()}]${reset}`);
+    }
+    parts.push(message);
+    if (location) {
+      parts.push(`\x1B[90m(${location})${reset}`);
+    }
+    return {
+      text: parts.join(" "),
+      reset
+    };
+  }
+  /**
+   * Create minimal ANSI rendering
+   */
+  renderMinimal(level, message, timestamp, prefix) {
+    const reset = "\x1B[0m";
+    const levelColors = {
+      "debug": "\x1B[95m",
+      // Magenta
+      "info": "\x1B[94m",
+      // Blue
+      "warn": "\x1B[93m",
+      // Yellow
+      "error": "\x1B[91m",
+      // Red
+      "critical": "\x1B[91m\x1B[1m"
+      // Red + bold
+    };
+    const parts = [];
+    if (timestamp) {
+      parts.push(`\x1B[90m${timestamp}${reset}`);
+    }
+    const levelColor = levelColors[level] || "\x1B[97m";
+    parts.push(`${levelColor}${this.getLevelText(level)}:${reset}`);
+    if (prefix) {
+      parts.push(`\x1B[96m[${prefix.toUpperCase()}]${reset}`);
+    }
+    parts.push(message);
+    return {
+      text: parts.join(" "),
+      reset
+    };
+  }
+  /**
+   * Get chalk instance for log level (for compatibility with adapter)
+   */
+  getChalkForLevel(level) {
+    const levelColors = {
+      "debug": "magenta",
+      "info": "blue",
+      "warn": "yellow",
+      "error": "red",
+      "critical": "red"
+    };
+    return {
+      color: (text) => {
+        const color = levelColors[level] || "white";
+        const colorCode = this.getColorCode(color);
+        return `${colorCode}${text}${"\x1B[0m"}`;
+      },
+      bold: (text) => {
+        const boldStyle = this.getStyleCode(["bold"]);
+        return `${boldStyle}${text}${"\x1B[0m"}`;
+      },
+      dim: (text) => {
+        const dimStyle = this.getStyleCode(["dim"]);
+        return `${dimStyle}${text}${"\x1B[0m"}`;
+      },
+      bgGray: (text) => {
+        return `\x1B[100m${text}${"\x1B[0m"}`;
+      },
+      bgBlue: (text) => {
+        return `\x1B[104m${text}${"\x1B[0m"}`;
+      },
+      reset: (text) => text,
+      cyan: {
+        bold: (text) => {
+          const cyan = this.getColorCode("cyan");
+          const bold = this.getStyleCode(["bold"]);
+          return `${cyan}${bold}${text}${"\x1B[0m"}`;
+        },
+        dim: (text) => {
+          const cyan = this.getColorCode("cyan");
+          const dim = this.getStyleCode(["dim"]);
+          return `${cyan}${dim}${text}${"\x1B[0m"}`;
+        },
+        bg: (text) => {
+          const bgBlack = "\x1B[40m";
+          const cyan = this.getColorCode("cyan");
+          return `${bgBlack}${cyan}[${text.toUpperCase()}]${"\x1B[0m"}`;
+        }
+      }
+    };
+  }
+}
+class CSS2ANSIAdapter {
+  renderer;
+  constructor() {
+    const colorCapability = getColorCapability();
+    this.renderer = new TerminalRenderer(colorCapability);
+  }
+  /**
+   * Convert LogStyles to ANSIStyle for terminal rendering
+   */
+  adaptStyles(level, message, timestamp, prefix, location, styles, presetName) {
+    if (presetName) {
+      switch (presetName) {
+        case "cyberpunk":
+          return this.renderer.renderCyberpunk(level, message, timestamp, prefix, location);
+        case "minimal":
+          return this.renderer.renderMinimal(level, message, timestamp, prefix);
+        case "production":
+          return this.adaptProductionStyles(level, message, timestamp, prefix, location, styles);
+        case "debug":
+          return this.adaptDebugStyles(level, message, timestamp, prefix, location, styles);
+        case "glassmorphism":
+          return this.adaptGlassmorphismStyles(level, message, timestamp, prefix, location, styles);
+      }
+    }
+    return this.renderer.renderTerminal(level, message, timestamp, prefix, location, styles);
+  }
+  /**
+   * Adapt production preset for terminal
+   */
+  adaptProductionStyles(level, message, timestamp, prefix, location, styles) {
+    const reset = "\x1B[0m";
+    const levelChalk = this.renderer.getChalkForLevel(level);
+    const parts = [];
+    if (timestamp && styles?.timestamp?.show) {
+      parts.push(levelChalk.dim(timestamp));
+    }
+    if (styles?.level?.show) {
+      parts.push(levelChalk.color(`[${this.renderer["getLevelText"](level)}]`));
+    }
+    if (prefix && styles?.prefix?.show) {
+      parts.push(levelChalk.dim(`[${prefix}]`));
+    }
+    if (message && styles?.message?.show) {
+      parts.push(levelChalk.reset(message));
+    }
+    if (location && styles?.location?.show) {
+      parts.push(levelChalk.dim(`(${location})`));
+    }
+    return {
+      text: parts.join(" ") + reset,
+      reset
+    };
+  }
+  /**
+   * Adapt debug preset for terminal
+   */
+  adaptDebugStyles(level, message, timestamp, prefix, location, styles) {
+    const reset = "\x1B[0m";
+    const levelChalk = this.renderer.getChalkForLevel(level);
+    const parts = [];
+    if (timestamp && styles?.timestamp?.show) {
+      parts.push(levelChalk.dim(timestamp));
+    }
+    if (styles?.level?.show) {
+      if (styles?.level?.style === "compact") {
+        parts.push(levelChalk.color(`[${this.renderer["getLevelText"](level)}]`));
+      } else {
+        parts.push(levelChalk.bold(`[${this.renderer["getLevelText"](level)}]`));
+      }
+    }
+    if (prefix && styles?.prefix?.show) {
+      if (styles?.prefix?.style === "compact") {
+        parts.push(levelChalk.cyan.dim(`[${prefix}]`));
+      } else {
+        parts.push(levelChalk.cyan.bold(`[${prefix}]`));
+      }
+    }
+    if (message && styles?.message?.show) {
+      parts.push(levelChalk.reset(message));
+    }
+    if (location && styles?.location?.show) {
+      if (styles?.location?.style === "clickable") {
+        parts.push(levelChalk.dim(`${location} (clickable)`));
+      } else {
+        parts.push(levelChalk.dim(`(${location})`));
+      }
+    }
+    return {
+      text: parts.join(" ") + reset,
+      reset
+    };
+  }
+  /**
+   * Adapt glassmorphism preset for terminal
+   */
+  adaptGlassmorphismStyles(level, message, timestamp, prefix, location, styles) {
+    const reset = "\x1B[0m";
+    const levelChalk = this.renderer.getChalkForLevel(level);
+    const parts = [];
+    if (timestamp && styles?.timestamp?.show) {
+      parts.push(levelChalk.dim(timestamp));
+    }
+    if (styles?.level?.show) {
+      parts.push(levelChalk.bgGray(` ${this.renderer["getLevelText"](level)} `));
+    }
+    if (prefix && styles?.prefix?.show) {
+      parts.push(levelChalk.bgBlue(`[${prefix}]`));
+    }
+    if (message && styles?.message?.show) {
+      parts.push(levelChalk.reset(message));
+    }
+    if (location && styles?.location?.show) {
+      parts.push(levelChalk.dim(`(${location})`));
+    }
+    return {
+      text: parts.join(" ") + reset,
+      reset
+    };
+  }
+  /**
+   * Convert CSS color values to ANSI-friendly colors
+   */
+  adaptColor(cssColor) {
+    if (cssColor.startsWith("#")) {
+      return cssColor;
+    }
+    if (cssColor.startsWith("rgb(")) {
+      return cssColor;
+    }
+    if (cssColor.includes("gradient")) {
+      return this.extractColorFromGradient(cssColor);
+    }
+    return this.cssNameToANSI(cssColor);
+  }
+  /**
+   * Extract primary color from CSS gradient
+   */
+  extractColorFromGradient(gradient) {
+    const match = gradient.match(/#[0-9a-fA-F]{6}|rgb\([^)]+\)/);
+    return match ? match[0] : "#ffffff";
+  }
+  /**
+   * Convert CSS color names to ANSI-compatible names
+   */
+  cssNameToANSI(cssColor) {
+    const colorMap = {
+      "black": "black",
+      "white": "white",
+      "red": "red",
+      "green": "green",
+      "blue": "blue",
+      "yellow": "yellow",
+      "cyan": "cyan",
+      "magenta": "magenta",
+      "gray": "gray",
+      "grey": "gray",
+      "orange": "yellow",
+      "purple": "magenta",
+      "pink": "red",
+      "brown": "yellow",
+      "lightblue": "cyan",
+      "lightgreen": "green",
+      "lightgray": "gray",
+      "lightgrey": "gray"
+    };
+    return colorMap[cssColor.toLowerCase()] || "white";
+  }
+  /**
+   * Check if a style should be rendered in terminal
+   */
+  shouldRenderStyle(styleType, styles) {
+    if (!styles) return true;
+    const styleConfig = styles[styleType];
+    return styleConfig?.show !== false;
+  }
+  /**
+   * Get renderer instance for advanced usage
+   */
+  getRenderer() {
+    return this.renderer;
+  }
+}
+const css2ansiAdapter = new CSS2ANSIAdapter();
+function adaptToTerminal(level, message, timestamp, prefix, location, styles, presetName) {
+  return css2ansiAdapter.adaptStyles(level, message, timestamp, prefix, location, styles, presetName);
+}
+function detectDevToolsTheme() {
+  try {
+    if (typeof window === "undefined" || !window.matchMedia) {
+      return "light";
+    }
+    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    return mediaQuery.matches ? "dark" : "light";
+  } catch (error) {
+    console.warn("Failed to detect DevTools theme:", error);
+    return "light";
+  }
+}
+function getAdaptiveColor(colors, theme) {
+  const currentTheme = theme ?? detectDevToolsTheme();
+  return colors[currentTheme];
+}
+function setupThemeChangeListener(callback) {
+  try {
+    if (typeof window === "undefined" || !window.matchMedia) {
+      return null;
+    }
+    const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+    const handler = (e) => {
+      callback(e.matches ? "dark" : "light");
+    };
+    if (mediaQuery.addEventListener) {
+      mediaQuery.addEventListener("change", handler);
+      return () => mediaQuery.removeEventListener("change", handler);
+    } else if (mediaQuery.addListener) {
+      mediaQuery.addListener(handler);
+      return () => mediaQuery.removeListener?.(handler);
+    }
+    return null;
+  } catch (error) {
+    console.warn("Failed to set up theme change listener:", error);
+    return null;
+  }
+}
+function createStyledOutput(level, levelStyles, prefix, message, stackInfo, autoDetectTheme = true, presetStyles, presetName) {
+  const levelConfig = levelStyles[level];
+  const timestamp = formatTimestamp();
+  const environment = getEnvironment();
+  if (environment !== "browser" && supportsANSI()) {
+    return createTerminalOutput(level, message, timestamp, prefix, stackInfo, presetStyles, presetName);
+  }
+  const currentTheme = autoDetectTheme ? detectDevToolsTheme() : "light";
+  const timestampStyle = new StyleBuilder().color(getAdaptiveColor(ADAPTIVE_COLORS.timestamp, currentTheme)).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(getAdaptiveColor(ADAPTIVE_COLORS.prefixBackground, currentTheme)).color(getAdaptiveColor(ADAPTIVE_COLORS.prefix, currentTheme)).padding("2px 6px").rounded("3px").bold().font("Monaco, Consolas, monospace").size("11px").build();
+  const messageStyle = new StyleBuilder().color(getAdaptiveColor(ADAPTIVE_COLORS.messageText, currentTheme)).font("system-ui, -apple-system, sans-serif").size("14px").build();
+  const locationStyle = new StyleBuilder().color(getAdaptiveColor(ADAPTIVE_COLORS.location, currentTheme)).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);
+  }
+}
+function createTerminalOutput(level, message, timestamp, prefix, stackInfo, presetStyles, presetName) {
+  const location = stackInfo ? `${stackInfo.file}:${stackInfo.line}:${stackInfo.column}` : void 0;
+  const ansiStyle = adaptToTerminal(
+    level,
+    message,
+    timestamp,
+    prefix,
+    location,
+    presetStyles,
+    presetName
+  );
+  return [ansiStyle.text];
+}
+const isNode = typeof process !== "undefined" && process.versions && process.versions.node;
+const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+function supportsCSSColors() {
+  return isBrowser;
+}
+function supportsANSIColors() {
+  if (isNode) {
+    return process.stdout?.isTTY === true || process.env.FORCE_COLOR === "1" || process.env.FORCE_COLOR === "true";
+  }
+  return false;
+}
+export {
+  ADAPTIVE_COLORS as A,
+  BUILD_PRESETS as B,
+  DEFAULT_CONFIG as D,
+  ENVIRONMENT_DETECTION as E,
+  LEVEL_STYLES as L,
+  StylePresets as S,
+  isBrowser as a,
+  StyleBuilder as b,
+  createStyledOutput as c,
+  detectEnvironmentPreset as d,
+  supportsANSIColors as e,
+  formatTimestamp as f,
+  getOptimalConfig as g,
+  getAdaptiveColor as h,
+  isNode as i,
+  BUFFER_LIMITS as j,
+  generateLogId as k,
+  parseTimeInput as l,
+  formatDisplayTime as m,
+  safeStringify as n,
+  escapeHtml as o,
+  parseStackTrace as p,
+  EXPORT_FORMATS as q,
+  setupThemeChangeListener as r,
+  supportsCSSColors as s,
+  getEnvironment as t
+};
+//# sourceMappingURL=environment-TI2ByCPT.js.map