@mks2508/better-logger 3.0.0 → 4.0.0

package/dist/chunks/{environment-TI2ByCPT.js → environment-COWvu6Wz.js}

@@ -612,29 +612,389 @@ function getColorCapability() {
   }
   return "basic";
 }
+function getTerminalWidth() {
+  if (typeof process !== "undefined" && process.stdout?.columns) {
+    return process.stdout.columns;
+  }
+  return 80;
+}
+function getTerminalHeight() {
+  if (typeof process !== "undefined" && process.stdout?.rows) {
+    return process.stdout.rows;
+  }
+  return 24;
+}
+function getEnvironmentInfo() {
+  return {
+    environment: getEnvironment(),
+    supportsANSI: supportsANSI(),
+    colorCapability: getColorCapability(),
+    isTTY: typeof process !== "undefined" ? Boolean(process.stdout?.isTTY) : false,
+    platform: typeof process !== "undefined" ? process.platform : "unknown",
+    nodeVersion: typeof process !== "undefined" ? process.versions?.node : null,
+    term: typeof process !== "undefined" ? process.env?.TERM : null,
+    colorTerm: typeof process !== "undefined" ? process.env?.COLORTERM : null,
+    terminalWidth: getTerminalWidth(),
+    terminalHeight: getTerminalHeight()
+  };
+}
+const ANSI_16_COLORS = {
+  black: { fg: "30", bg: "40", bright: { fg: "90", bg: "100" } },
+  red: { fg: "31", bg: "41", bright: { fg: "91", bg: "101" } },
+  green: { fg: "32", bg: "42", bright: { fg: "92", bg: "102" } },
+  yellow: { fg: "33", bg: "43", bright: { fg: "93", bg: "103" } },
+  blue: { fg: "34", bg: "44", bright: { fg: "94", bg: "104" } },
+  magenta: { fg: "35", bg: "45", bright: { fg: "95", bg: "105" } },
+  cyan: { fg: "36", bg: "46", bright: { fg: "96", bg: "106" } },
+  white: { fg: "37", bg: "47", bright: { fg: "97", bg: "107" } },
+  gray: { fg: "90", bg: "100", bright: { fg: "37", bg: "47" } },
+  grey: { fg: "90", bg: "100", bright: { fg: "37", bg: "47" } }
+};
+const CSS_NAMED_COLORS = {
+  aliceblue: "#f0f8ff",
+  antiquewhite: "#faebd7",
+  aqua: "#00ffff",
+  aquamarine: "#7fffd4",
+  azure: "#f0ffff",
+  beige: "#f5f5dc",
+  bisque: "#ffe4c4",
+  black: "#000000",
+  blanchedalmond: "#ffebcd",
+  blue: "#0000ff",
+  blueviolet: "#8a2be2",
+  brown: "#a52a2a",
+  burlywood: "#deb887",
+  cadetblue: "#5f9ea0",
+  chartreuse: "#7fff00",
+  chocolate: "#d2691e",
+  coral: "#ff7f50",
+  cornflowerblue: "#6495ed",
+  cornsilk: "#fff8dc",
+  crimson: "#dc143c",
+  cyan: "#00ffff",
+  darkblue: "#00008b",
+  darkcyan: "#008b8b",
+  darkgoldenrod: "#b8860b",
+  darkgray: "#a9a9a9",
+  darkgreen: "#006400",
+  darkkhaki: "#bdb76b",
+  darkmagenta: "#8b008b",
+  darkolivegreen: "#556b2f",
+  darkorange: "#ff8c00",
+  darkorchid: "#9932cc",
+  darkred: "#8b0000",
+  darksalmon: "#e9967a",
+  darkseagreen: "#8fbc8f",
+  darkslateblue: "#483d8b",
+  darkslategray: "#2f4f4f",
+  darkturquoise: "#00ced1",
+  darkviolet: "#9400d3",
+  deeppink: "#ff1493",
+  deepskyblue: "#00bfff",
+  dimgray: "#696969",
+  dodgerblue: "#1e90ff",
+  firebrick: "#b22222",
+  floralwhite: "#fffaf0",
+  forestgreen: "#228b22",
+  fuchsia: "#ff00ff",
+  gainsboro: "#dcdcdc",
+  ghostwhite: "#f8f8ff",
+  gold: "#ffd700",
+  goldenrod: "#daa520",
+  gray: "#808080",
+  green: "#008000",
+  greenyellow: "#adff2f",
+  honeydew: "#f0fff0",
+  hotpink: "#ff69b4",
+  indianred: "#cd5c5c",
+  indigo: "#4b0082",
+  ivory: "#fffff0",
+  khaki: "#f0e68c",
+  lavender: "#e6e6fa",
+  lavenderblush: "#fff0f5",
+  lawngreen: "#7cfc00",
+  lemonchiffon: "#fffacd",
+  lightblue: "#add8e6",
+  lightcoral: "#f08080",
+  lightcyan: "#e0ffff",
+  lightgoldenrodyellow: "#fafad2",
+  lightgray: "#d3d3d3",
+  lightgreen: "#90ee90",
+  lightpink: "#ffb6c1",
+  lightsalmon: "#ffa07a",
+  lightseagreen: "#20b2aa",
+  lightskyblue: "#87cefa",
+  lightslategray: "#778899",
+  lightsteelblue: "#b0c4de",
+  lightyellow: "#ffffe0",
+  lime: "#00ff00",
+  limegreen: "#32cd32",
+  linen: "#faf0e6",
+  magenta: "#ff00ff",
+  maroon: "#800000",
+  mediumaquamarine: "#66cdaa",
+  mediumblue: "#0000cd",
+  mediumorchid: "#ba55d3",
+  mediumpurple: "#9370db",
+  mediumseagreen: "#3cb371",
+  mediumslateblue: "#7b68ee",
+  mediumspringgreen: "#00fa9a",
+  mediumturquoise: "#48d1cc",
+  mediumvioletred: "#c71585",
+  midnightblue: "#191970",
+  mintcream: "#f5fffa",
+  mistyrose: "#ffe4e1",
+  moccasin: "#ffe4b5",
+  navajowhite: "#ffdead",
+  navy: "#000080",
+  oldlace: "#fdf5e6",
+  olive: "#808000",
+  olivedrab: "#6b8e23",
+  orange: "#ffa500",
+  orangered: "#ff4500",
+  orchid: "#da70d6",
+  palegoldenrod: "#eee8aa",
+  palegreen: "#98fb98",
+  paleturquoise: "#afeeee",
+  palevioletred: "#db7093",
+  papayawhip: "#ffefd5",
+  peachpuff: "#ffdab9",
+  peru: "#cd853f",
+  pink: "#ffc0cb",
+  plum: "#dda0dd",
+  powderblue: "#b0e0e6",
+  purple: "#800080",
+  rebeccapurple: "#663399",
+  red: "#ff0000",
+  rosybrown: "#bc8f8f",
+  royalblue: "#4169e1",
+  saddlebrown: "#8b4513",
+  salmon: "#fa8072",
+  sandybrown: "#f4a460",
+  seagreen: "#2e8b57",
+  seashell: "#fff5ee",
+  sienna: "#a0522d",
+  silver: "#c0c0c0",
+  skyblue: "#87ceeb",
+  slateblue: "#6a5acd",
+  slategray: "#708090",
+  snow: "#fffafa",
+  springgreen: "#00ff7f",
+  steelblue: "#4682b4",
+  tan: "#d2b48c",
+  teal: "#008080",
+  thistle: "#d8bfd8",
+  tomato: "#ff6347",
+  turquoise: "#40e0d0",
+  violet: "#ee82ee",
+  wheat: "#f5deb3",
+  white: "#ffffff",
+  whitesmoke: "#f5f5f5",
+  yellow: "#ffff00",
+  yellowgreen: "#9acd32"
+};
+function hexToRgb(hex) {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  if (!result || !result[1] || !result[2] || !result[3]) {
+    return { r: 255, g: 255, b: 255 };
+  }
+  return {
+    r: parseInt(result[1], 16),
+    g: parseInt(result[2], 16),
+    b: parseInt(result[3], 16)
+  };
+}
+function rgbToHex(r, g, b) {
+  return "#" + [r, g, b].map((x) => x.toString(16).padStart(2, "0")).join("");
+}
+function hexTo256(hex) {
+  const { r, g, b } = hexToRgb(hex);
+  if (r === g && g === b) {
+    if (r < 8) return 16;
+    if (r > 248) return 231;
+    return Math.round((r - 8) / 247 * 24) + 232;
+  }
+  const ri = Math.round(r / 255 * 5);
+  const gi = Math.round(g / 255 * 5);
+  const bi = Math.round(b / 255 * 5);
+  return 16 + 36 * ri + 6 * gi + bi;
+}
+function colorToHex(color) {
+  if (color.startsWith("#")) {
+    return color;
+  }
+  const named = CSS_NAMED_COLORS[color.toLowerCase()];
+  if (named) {
+    return named;
+  }
+  const rgbMatch = color.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+  if (rgbMatch && rgbMatch[1] && rgbMatch[2] && rgbMatch[3]) {
+    return rgbToHex(
+      parseInt(rgbMatch[1]),
+      parseInt(rgbMatch[2]),
+      parseInt(rgbMatch[3])
+    );
+  }
+  return "#ffffff";
+}
+function getANSIForeground(color, capability) {
+  if (capability === "none") return "";
+  const lowerColor = color.toLowerCase();
+  if (capability === "basic" && ANSI_16_COLORS[lowerColor]) {
+    return `\x1B[${ANSI_16_COLORS[lowerColor].fg}m`;
+  }
+  if (capability === "basic") {
+    const hex2 = colorToHex(color);
+    const nearestBasic = findNearestBasicColor(hex2);
+    const basicColor = ANSI_16_COLORS[nearestBasic];
+    return basicColor ? `\x1B[${basicColor.fg}m` : "\x1B[37m";
+  }
+  const hex = colorToHex(color);
+  const { r, g, b } = hexToRgb(hex);
+  return `\x1B[38;2;${r};${g};${b}m`;
+}
+function getANSIBackground(color, capability) {
+  if (capability === "none") return "";
+  const lowerColor = color.toLowerCase();
+  if (capability === "basic" && ANSI_16_COLORS[lowerColor]) {
+    return `\x1B[${ANSI_16_COLORS[lowerColor].bg}m`;
+  }
+  if (capability === "basic") {
+    const hex2 = colorToHex(color);
+    const nearestBasic = findNearestBasicColor(hex2);
+    const basicColor = ANSI_16_COLORS[nearestBasic];
+    return basicColor ? `\x1B[${basicColor.bg}m` : "\x1B[47m";
+  }
+  const hex = colorToHex(color);
+  const { r, g, b } = hexToRgb(hex);
+  return `\x1B[48;2;${r};${g};${b}m`;
+}
+function getANSI256Foreground(colorIndex) {
+  return `\x1B[38;5;${colorIndex}m`;
+}
+function getANSI256Background(colorIndex) {
+  return `\x1B[48;5;${colorIndex}m`;
+}
+function findNearestBasicColor(hex) {
+  const { r, g, b } = hexToRgb(hex);
+  const basicColors = {
+    black: { r: 0, g: 0, b: 0 },
+    red: { r: 205, g: 0, b: 0 },
+    green: { r: 0, g: 205, b: 0 },
+    yellow: { r: 205, g: 205, b: 0 },
+    blue: { r: 0, g: 0, b: 238 },
+    magenta: { r: 205, g: 0, b: 205 },
+    cyan: { r: 0, g: 205, b: 205 },
+    white: { r: 229, g: 229, b: 229 }
+  };
+  let nearest = "white";
+  let minDistance = Infinity;
+  for (const [name, rgb] of Object.entries(basicColors)) {
+    const distance = Math.sqrt(
+      Math.pow(r - rgb.r, 2) + Math.pow(g - rgb.g, 2) + Math.pow(b - rgb.b, 2)
+    );
+    if (distance < minDistance) {
+      minDistance = distance;
+      nearest = name;
+    }
+  }
+  return nearest;
+}
+function extractGradientColors(gradient) {
+  const hexMatches = gradient.match(/#[a-fA-F0-9]{6}/g) || [];
+  const rgbMatches = gradient.match(/rgba?\([^)]+\)/g) || [];
+  const namedMatches = gradient.match(/,\s*([a-z]+)(?:\s|,|\))/gi) || [];
+  const colors = [
+    ...hexMatches,
+    ...rgbMatches.map(colorToHex),
+    ...namedMatches.map((m) => {
+      const name = m.replace(/[,\s)]/g, "").toLowerCase();
+      return CSS_NAMED_COLORS[name] || null;
+    }).filter((c) => c !== null)
+  ];
+  return colors.length > 0 ? colors : ["#ffffff"];
+}
+function gradientToSingleColor(gradient) {
+  const colors = extractGradientColors(gradient);
+  if (colors.length === 0) return "#ffffff";
+  if (colors.length === 1) return colors[0] ?? "#ffffff";
+  const rgbs = colors.map((c) => hexToRgb(colorToHex(c)));
+  const avgR = Math.round(rgbs.reduce((sum, rgb) => sum + rgb.r, 0) / rgbs.length);
+  const avgG = Math.round(rgbs.reduce((sum, rgb) => sum + rgb.g, 0) / rgbs.length);
+  const avgB = Math.round(rgbs.reduce((sum, rgb) => sum + rgb.b, 0) / rgbs.length);
+  return rgbToHex(avgR, avgG, avgB);
+}
+function cssColorToANSI(cssColor, capability, isBackground = false) {
+  if (capability === "none") return "";
+  let resolvedColor;
+  if (cssColor.includes("gradient")) {
+    resolvedColor = gradientToSingleColor(cssColor);
+  } else {
+    resolvedColor = colorToHex(cssColor);
+  }
+  return isBackground ? getANSIBackground(resolvedColor, capability) : getANSIForeground(resolvedColor, capability);
+}
+const ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m",
+  blink: "\x1B[5m",
+  inverse: "\x1B[7m",
+  hidden: "\x1B[8m",
+  strikethrough: "\x1B[9m",
+  fg: {
+    black: "\x1B[30m",
+    red: "\x1B[31m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m",
+    blue: "\x1B[34m",
+    magenta: "\x1B[35m",
+    cyan: "\x1B[36m",
+    white: "\x1B[37m",
+    gray: "\x1B[90m",
+    brightRed: "\x1B[91m",
+    brightGreen: "\x1B[92m",
+    brightYellow: "\x1B[93m",
+    brightBlue: "\x1B[94m",
+    brightMagenta: "\x1B[95m",
+    brightCyan: "\x1B[96m",
+    brightWhite: "\x1B[97m"
+  },
+  bg: {
+    black: "\x1B[40m",
+    red: "\x1B[41m",
+    green: "\x1B[42m",
+    yellow: "\x1B[43m",
+    blue: "\x1B[44m",
+    magenta: "\x1B[45m",
+    cyan: "\x1B[46m",
+    white: "\x1B[47m",
+    gray: "\x1B[100m",
+    brightRed: "\x1B[101m",
+    brightGreen: "\x1B[102m",
+    brightYellow: "\x1B[103m",
+    brightBlue: "\x1B[104m",
+    brightMagenta: "\x1B[105m",
+    brightCyan: "\x1B[106m",
+    brightWhite: "\x1B[107m"
+  },
+  rgb: (r, g, b) => `\x1B[38;2;${r};${g};${b}m`,
+  bgRgb: (r, g, b) => `\x1B[48;2;${r};${g};${b}m`,
+  color256: (n) => `\x1B[38;5;${n}m`,
+  bgColor256: (n) => `\x1B[48;5;${n}m`
+};
 class TerminalRenderer {
   colorCapability;
   constructor(colorCapability = "full") {
     this.colorCapability = colorCapability;
   }
   /**
-   * Get ANSI color codes for basic colors
+   * Get ANSI color codes - now supports truecolor/256-color
    */
   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`;
+    return background ? getANSIBackground(color, this.colorCapability) : getANSIForeground(color, this.colorCapability);
   }
   /**
    * Get ANSI style codes
@@ -762,36 +1122,37 @@ class TerminalRenderer {
     return levelMap[level] || String(level).toUpperCase();
   }
   /**
-   * Create cyberpunk-style ANSI rendering
+   * Create cyberpunk-style ANSI rendering with truecolor support
    */
   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 reset = ANSI.reset;
+    const cyberpunkColors = {
+      "debug": "#ff00ff",
+      // Neon magenta
+      "info": "#00ffff",
+      // Neon cyan
+      "warn": "#ffff00",
+      // Neon yellow
+      "error": "#ff0040",
+      // Neon red-pink
+      "critical": "#ff0000"
+      // Pure red
     };
     const parts = [];
     if (timestamp) {
-      parts.push(`\x1B[90m${timestamp}${reset}`);
+      parts.push(`${ANSI.dim}${timestamp}${reset}`);
     }
-    const levelColor = levelColors[level] || "\x1B[97m";
-    const bgBlack = "\x1B[40m";
-    parts.push(`${bgBlack}${levelColor} ${this.getLevelText(level)} ${reset}`);
+    const levelColor = this.getColorCode(cyberpunkColors[level] || "#ffffff");
+    const bgBlack = ANSI.bg.black;
+    const bold = level === "critical" ? ANSI.bold : "";
+    parts.push(`${bgBlack}${levelColor}${bold} ${this.getLevelText(level)} ${reset}`);
     if (prefix) {
-      const bgBlack2 = "\x1B[40m";
-      parts.push(`${bgBlack2}\x1B[96m[${prefix.toUpperCase()}]${reset}`);
+      const cyanColor = this.getColorCode("#00ffff");
+      parts.push(`${bgBlack}${cyanColor}[${prefix.toUpperCase()}]${reset}`);
     }
     parts.push(message);
     if (location) {
-      parts.push(`\x1B[90m(${location})${reset}`);
+      parts.push(`${ANSI.dim}(${location})${reset}`);
     }
     return {
       text: parts.join(" "),
@@ -799,30 +1160,32 @@ class TerminalRenderer {
     };
   }
   /**
-   * Create minimal ANSI rendering
+   * Create minimal ANSI rendering with truecolor support
    */
   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 reset = ANSI.reset;
+    const minimalColors = {
+      "debug": "#c678dd",
+      // Soft purple
+      "info": "#61afef",
+      // Soft blue
+      "warn": "#e5c07b",
+      // Soft yellow
+      "error": "#e06c75",
+      // Soft red
+      "critical": "#be5046"
+      // Dark red
     };
     const parts = [];
     if (timestamp) {
-      parts.push(`\x1B[90m${timestamp}${reset}`);
+      parts.push(`${ANSI.dim}${timestamp}${reset}`);
     }
-    const levelColor = levelColors[level] || "\x1B[97m";
-    parts.push(`${levelColor}${this.getLevelText(level)}:${reset}`);
+    const levelColor = this.getColorCode(minimalColors[level] || "#abb2bf");
+    const bold = level === "critical" ? ANSI.bold : "";
+    parts.push(`${levelColor}${bold}${this.getLevelText(level)}:${reset}`);
     if (prefix) {
-      parts.push(`\x1B[96m[${prefix.toUpperCase()}]${reset}`);
+      const cyanColor = this.getColorCode("#56b6c2");
+      parts.push(`${cyanColor}[${prefix.toUpperCase()}]${reset}`);
     }
     parts.push(message);
     return {
@@ -831,52 +1194,40 @@ class TerminalRenderer {
     };
   }
   /**
-   * Get chalk instance for log level (for compatibility with adapter)
+   * Get chalk-like interface for log level with truecolor support
    */
   getChalkForLevel(level) {
     const levelColors = {
-      "debug": "magenta",
-      "info": "blue",
-      "warn": "yellow",
-      "error": "red",
-      "critical": "red"
+      "debug": "#c678dd",
+      "info": "#61afef",
+      "warn": "#e5c07b",
+      "error": "#e06c75",
+      "critical": "#be5046"
     };
+    const reset = ANSI.reset;
     return {
       color: (text) => {
-        const color = levelColors[level] || "white";
+        const color = levelColors[level] || "#abb2bf";
         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"}`;
+        return `${colorCode}${text}${reset}`;
       },
+      bold: (text) => `${ANSI.bold}${text}${reset}`,
+      dim: (text) => `${ANSI.dim}${text}${reset}`,
+      bgGray: (text) => `${ANSI.bg.gray}${text}${reset}`,
+      bgBlue: (text) => `${this.getColorCode("#1e3a5f", true)}${text}${reset}`,
       reset: (text) => text,
       cyan: {
         bold: (text) => {
-          const cyan = this.getColorCode("cyan");
-          const bold = this.getStyleCode(["bold"]);
-          return `${cyan}${bold}${text}${"\x1B[0m"}`;
+          const cyan = this.getColorCode("#00ffff");
+          return `${cyan}${ANSI.bold}${text}${reset}`;
         },
         dim: (text) => {
-          const cyan = this.getColorCode("cyan");
-          const dim = this.getStyleCode(["dim"]);
-          return `${cyan}${dim}${text}${"\x1B[0m"}`;
+          const cyan = this.getColorCode("#00ffff");
+          return `${cyan}${ANSI.dim}${text}${reset}`;
         },
         bg: (text) => {
-          const bgBlack = "\x1B[40m";
-          const cyan = this.getColorCode("cyan");
-          return `${bgBlack}${cyan}[${text.toUpperCase()}]${"\x1B[0m"}`;
+          const cyan = this.getColorCode("#00ffff");
+          return `${ANSI.bg.black}${cyan}[${text.toUpperCase()}]${reset}`;
         }
       }
     };
@@ -1179,31 +1530,48 @@ function supportsANSIColors() {
   return false;
 }
 export {
-  ADAPTIVE_COLORS as A,
+  ANSI as A,
   BUILD_PRESETS as B,
+  getAdaptiveColor as C,
   DEFAULT_CONFIG as D,
   ENVIRONMENT_DETECTION as E,
+  ADAPTIVE_COLORS as F,
+  BUFFER_LIMITS as G,
+  generateLogId as H,
+  parseTimeInput as I,
+  formatDisplayTime as J,
+  safeStringify as K,
   LEVEL_STYLES as L,
+  escapeHtml as M,
+  EXPORT_FORMATS as N,
+  setupThemeChangeListener as O,
   StylePresets as S,
+  TerminalRenderer as T,
   isBrowser as a,
   StyleBuilder as b,
-  createStyledOutput as c,
+  hexTo256 as c,
   detectEnvironmentPreset as d,
-  supportsANSIColors as e,
+  colorToHex as e,
   formatTimestamp as f,
   getOptimalConfig as g,
-  getAdaptiveColor as h,
+  hexToRgb as h,
   isNode as i,
-  BUFFER_LIMITS as j,
-  generateLogId as k,
-  parseTimeInput as l,
-  formatDisplayTime as m,
-  safeStringify as n,
-  escapeHtml as o,
+  getANSIForeground as j,
+  getANSIBackground as k,
+  getANSI256Foreground as l,
+  getANSI256Background as m,
+  cssColorToANSI as n,
+  getEnvironment as o,
   parseStackTrace as p,
-  EXPORT_FORMATS as q,
-  setupThemeChangeListener as r,
-  supportsCSSColors as s,
-  getEnvironment as t
+  isRunningInTerminal as q,
+  rgbToHex as r,
+  supportsANSI as s,
+  getColorCapability as t,
+  getTerminalWidth as u,
+  getTerminalHeight as v,
+  getEnvironmentInfo as w,
+  supportsCSSColors as x,
+  createStyledOutput as y,
+  supportsANSIColors as z
 };
-//# sourceMappingURL=environment-TI2ByCPT.js.map
+//# sourceMappingURL=environment-COWvu6Wz.js.map