@reliverse/relico 1.1.0 → 1.1.2

package/bin/mod.js

@@ -0,0 +1,1187 @@
+import { getCurrentTerminalName } from "@reliverse/runtime";
+import { env, isWindows } from "@reliverse/runtime";
+import { loadConfig } from "c12";
+import { shouldNeverHappen } from "./utils.js";
+export const defaultColorKeys = [
+  // Text formatting
+  "reset",
+  "bold",
+  "dim",
+  "italic",
+  "underline",
+  "inverse",
+  "hidden",
+  "strikethrough",
+  // Standard colors
+  "black",
+  "red",
+  "green",
+  "yellow",
+  "blue",
+  "magenta",
+  "cyan",
+  "white",
+  "gray",
+  // Background colors
+  "bgBlack",
+  "bgRed",
+  "bgGreen",
+  "bgYellow",
+  "bgBlue",
+  "bgMagenta",
+  "bgCyan",
+  "bgWhite",
+  // Bright colors
+  "blackBright",
+  "redBright",
+  "greenBright",
+  "yellowBright",
+  "blueBright",
+  "magentaBright",
+  "cyanBright",
+  "whiteBright",
+  // Bright background colors
+  "bgBlackBright",
+  "bgRedBright",
+  "bgGreenBright",
+  "bgYellowBright",
+  "bgBlueBright",
+  "bgMagentaBright",
+  "bgCyanBright",
+  "bgWhiteBright",
+  // Extended color palette - pastel variants
+  "redPastel",
+  "greenPastel",
+  "yellowPastel",
+  "bluePastel",
+  "magentaPastel",
+  "cyanPastel",
+  // Extended background pastels
+  "bgRedPastel",
+  "bgGreenPastel",
+  "bgYellowPastel",
+  "bgBluePastel",
+  "bgMagentaPastel",
+  "bgCyanPastel",
+  // Web colors
+  "orange",
+  "pink",
+  "purple",
+  "teal",
+  "lime",
+  "brown",
+  "navy",
+  "maroon",
+  "olive",
+  "silver",
+  // Background web colors
+  "bgOrange",
+  "bgPink",
+  "bgPurple",
+  "bgTeal",
+  "bgLime",
+  "bgBrown",
+  "bgNavy",
+  "bgMaroon",
+  "bgOlive",
+  "bgSilver",
+  // Grayscale variants
+  "gray10",
+  "gray20",
+  "gray30",
+  "gray40",
+  "gray50",
+  "gray60",
+  "gray70",
+  "gray80",
+  "gray90"
+];
+const argv = typeof process === "undefined" ? [] : process.argv;
+const isDisabled = Boolean(env.NO_COLOR) || argv.includes("--no-color");
+const isForced = Boolean(env.FORCE_COLOR) || argv.includes("--color");
+const isCI = Boolean(
+  env.CI && (env.GITHUB_ACTIONS || env.GITLAB_CI || env.CIRCLECI)
+);
+const isOtherCI = Boolean(
+  env.CI && (env.TRAVIS || env.APPVEYOR || env.JENKINS_URL || env.BITBUCKET_BUILD_NUMBER || env.TEAMCITY_VERSION)
+);
+const isCompatibleTerminal = typeof process !== "undefined" && Boolean(process.stdout?.isTTY) && env.TERM !== "dumb";
+const colorterm = (env.COLORTERM ?? "").toLowerCase();
+const term = (env.TERM ?? "").toLowerCase();
+const supportsTrueColor = colorterm === "truecolor" || colorterm === "24bit" || term === "xterm-kitty" || term === "wezterm" || term === "iterm2" || term.includes("256color");
+function detectColorLevel() {
+  if (isDisabled) return 0;
+  if (isForced) return 3;
+  if (supportsTrueColor) return 3;
+  if (isWindows && env.TERM_PROGRAM === "vscode") return 3;
+  if (isWindows && env.WT_SESSION) return 3;
+  if (isWindows) return 2;
+  if (isCI || isOtherCI) return 2;
+  if (isCompatibleTerminal) return 2;
+  return 0;
+}
+const namedColors = {
+  aliceblue: "#f0f8ff",
+  antiquewhite: "#faebd7",
+  aqua: "#00ffff",
+  aquamarine: "#7fffd4",
+  azure: "#f0ffff",
+  beige: "#f5f5dc",
+  bisque: "#ffe4c4",
+  blanchedalmond: "#ffebcd",
+  burlywood: "#deb887",
+  cadetblue: "#5f9ea0",
+  chocolate: "#d2691e",
+  coral: "#ff7f50",
+  cornflowerblue: "#6495ed",
+  crimson: "#dc143c",
+  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",
+  dodgerblue: "#1e90ff",
+  firebrick: "#b22222",
+  floralwhite: "#fffaf0",
+  forestgreen: "#228b22",
+  fuchsia: "#ff00ff",
+  gainsboro: "#dcdcdc",
+  ghostwhite: "#f8f8ff",
+  gold: "#ffd700",
+  goldenrod: "#daa520",
+  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",
+  linen: "#faf0e6",
+  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",
+  oldlace: "#fdf5e6",
+  olivedrab: "#6b8e23",
+  orangered: "#ff4500",
+  orchid: "#da70d6",
+  palegoldenrod: "#eee8aa",
+  palegreen: "#98fb98",
+  paleturquoise: "#afeeee",
+  palevioletred: "#db7093",
+  papayawhip: "#ffefd5",
+  peachpuff: "#ffdab9",
+  peru: "#cd853f",
+  plum: "#dda0dd",
+  powderblue: "#b0e0e6",
+  rosybrown: "#bc8f8f",
+  royalblue: "#4169e1",
+  saddlebrown: "#8b4513",
+  salmon: "#fa8072",
+  sandybrown: "#f4a460",
+  seagreen: "#2e8b57",
+  seashell: "#fff5ee",
+  sienna: "#a0522d",
+  skyblue: "#87ceeb",
+  slateblue: "#6a5acd",
+  slategray: "#708090",
+  snow: "#fffafa",
+  springgreen: "#00ff7f",
+  steelblue: "#4682b4",
+  tan: "#d2b48c",
+  thistle: "#d8bfd8",
+  tomato: "#ff6347",
+  turquoise: "#40e0d0",
+  violet: "#ee82ee",
+  wheat: "#f5deb3",
+  whitesmoke: "#f5f5f5",
+  yellowgreen: "#9acd32"
+};
+const baseColors = {
+  // Text formatting
+  reset: ["\x1B[0m", "\x1B[0m"],
+  bold: ["\x1B[1m", "\x1B[22m"],
+  dim: ["\x1B[2m", "\x1B[22m"],
+  italic: ["\x1B[3m", "\x1B[23m"],
+  underline: ["\x1B[4m", "\x1B[24m"],
+  inverse: ["\x1B[7m", "\x1B[27m"],
+  hidden: ["\x1B[8m", "\x1B[28m"],
+  strikethrough: ["\x1B[9m", "\x1B[29m"],
+  // Foreground colors
+  black: ["#000000", "#000000"],
+  red: ["#ff5555", "#ff0000"],
+  green: ["#00ff00", "#00ff00"],
+  yellow: ["#ffff00", "#ffff00"],
+  blue: ["#0000ff", "#0000ff"],
+  magenta: ["#ff00ff", "#ff00ff"],
+  cyan: ["#00ffff", "#00ffff"],
+  white: ["#ffffff", "#ffffff"],
+  gray: ["#808080", "#808080"],
+  // Background colors
+  bgBlack: ["#000000", "#000000"],
+  bgRed: ["#ff5555", "#ff0000"],
+  bgGreen: ["#00ff00", "#00ff00"],
+  bgYellow: ["#ffff00", "#ffff00"],
+  bgBlue: ["#0000ff", "#0000ff"],
+  bgMagenta: ["#ff00ff", "#ff00ff"],
+  bgCyan: ["#00ffff", "#00ffff"],
+  bgWhite: ["#ffffff", "#ffffff"],
+  // Bright colors
+  blackBright: ["#000000", "#000000"],
+  redBright: ["#ff5555", "#ff5555"],
+  greenBright: ["#50fa7b", "#50fa7b"],
+  yellowBright: ["#f1fa8c", "#f1fa8c"],
+  blueBright: ["#24bdff", "#24bdff"],
+  magentaBright: ["#ff79c6", "#ff79c6"],
+  cyanBright: ["#8be9fd", "#8be9fd"],
+  whiteBright: ["#ffffff", "#ffffff"],
+  // Bright background colors
+  bgBlackBright: ["#000000", "#000000"],
+  bgRedBright: ["#ff5555", "#ff5555"],
+  bgGreenBright: ["#50fa7b", "#50fa7b"],
+  bgYellowBright: ["#f1fa8c", "#f1fa8c"],
+  bgBlueBright: ["#24bdff", "#24bdff"],
+  bgMagentaBright: ["#ff79c6", "#ff79c6"],
+  bgCyanBright: ["#8be9fd", "#8be9fd"],
+  bgWhiteBright: ["#ffffff", "#ffffff"],
+  // Extended color palette - pastel variants
+  redPastel: ["#ff9999", "#ffb3b3"],
+  greenPastel: ["#99ff99", "#b3ffb3"],
+  yellowPastel: ["#ffff99", "#ffffb3"],
+  bluePastel: ["#9999ff", "#b3b3ff"],
+  magentaPastel: ["#ff99ff", "#ffb3ff"],
+  cyanPastel: ["#99ffff", "#b3ffff"],
+  // Extended background pastels
+  bgRedPastel: ["#ff9999", "#ffb3b3"],
+  bgGreenPastel: ["#99ff99", "#b3ffb3"],
+  bgYellowPastel: ["#ffff99", "#ffffb3"],
+  bgBluePastel: ["#9999ff", "#b3b3ff"],
+  bgMagentaPastel: ["#ff99ff", "#ffb3ff"],
+  bgCyanPastel: ["#99ffff", "#b3ffff"],
+  // Web colors
+  orange: ["#ffa500", "#ff8c00"],
+  pink: ["#ffc0cb", "#ffb6c1"],
+  purple: ["#800080", "#9370db"],
+  teal: ["#008080", "#20b2aa"],
+  lime: ["#00ff00", "#32cd32"],
+  brown: ["#a52a2a", "#8b4513"],
+  navy: ["#000080", "#191970"],
+  maroon: ["#800000", "#8b0000"],
+  olive: ["#808000", "#6b8e23"],
+  silver: ["#c0c0c0", "#a9a9a9"],
+  // Background web colors
+  bgOrange: ["#ffa500", "#ff8c00"],
+  bgPink: ["#ffc0cb", "#ffb6c1"],
+  bgPurple: ["#800080", "#9370db"],
+  bgTeal: ["#008080", "#20b2aa"],
+  bgLime: ["#00ff00", "#32cd32"],
+  bgBrown: ["#a52a2a", "#8b4513"],
+  bgNavy: ["#000080", "#191970"],
+  bgMaroon: ["#800000", "#8b0000"],
+  bgOlive: ["#808000", "#6b8e23"],
+  bgSilver: ["#c0c0c0", "#a9a9a9"],
+  // Grayscale variants
+  gray10: ["#1a1a1a", "#1a1a1a"],
+  gray20: ["#333333", "#333333"],
+  gray30: ["#4d4d4d", "#4d4d4d"],
+  gray40: ["#666666", "#666666"],
+  gray50: ["#808080", "#808080"],
+  gray60: ["#999999", "#999999"],
+  gray70: ["#b3b3b3", "#b3b3b3"],
+  gray80: ["#cccccc", "#cccccc"],
+  gray90: ["#e6e6e6", "#e6e6e6"]
+};
+const restrictedKeys = /* @__PURE__ */ new Set([
+  "reset",
+  "bold",
+  "dim",
+  "italic",
+  "underline",
+  "inverse",
+  "hidden",
+  "strikethrough"
+]);
+let config = {
+  colorLevel: detectColorLevel(),
+  theme: "primary",
+  // default theme; can be overridden in user config
+  autoDetect: true
+};
+let colorMap = {};
+let colorFunctions = {};
+const colorConversionCache = /* @__PURE__ */ new Map();
+const rgbCache = /* @__PURE__ */ new Map();
+const formatterCache = /* @__PURE__ */ new Map();
+const hexCache = /* @__PURE__ */ new Map();
+function normalizeColor(color) {
+  if (!color || typeof color !== "string") return "#000000";
+  const cacheKey = color.toLowerCase();
+  const cached = hexCache.get(cacheKey);
+  if (cached) return cached;
+  let result;
+  if (cacheKey in namedColors) {
+    result = namedColors[cacheKey];
+  } else {
+    if (!color.startsWith("#") && /^[0-9a-f]{3,6}$/i.test(color)) {
+      result = `#${color}`;
+    } else {
+      result = color;
+    }
+    if (!/^#[0-9a-f]{3,8}$/i.test(result)) {
+      result = "#000000";
+    }
+    if (result.length === 4) {
+      result = `#${result[1]}${result[1]}${result[2]}${result[2]}${result[3]}${result[3]}`;
+    }
+  }
+  hexCache.set(cacheKey, result);
+  return result;
+}
+function hexToRGB(hex2) {
+  const normalizedHex = normalizeColor(hex2);
+  const cacheKey = normalizedHex;
+  const cached = rgbCache.get(cacheKey);
+  if (cached) return cached;
+  try {
+    const r = Number.parseInt(normalizedHex.substring(1, 3), 16);
+    const g = Number.parseInt(normalizedHex.substring(3, 5), 16);
+    const b = Number.parseInt(normalizedHex.substring(5, 7), 16);
+    if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) {
+      return { r: 0, g: 0, b: 0 };
+    }
+    const rgb2 = { r, g, b };
+    rgbCache.set(cacheKey, rgb2);
+    return rgb2;
+  } catch (_error) {
+    return { r: 0, g: 0, b: 0 };
+  }
+}
+function hexToAnsiParts(hex2, isBg = false) {
+  const cacheKey = `${hex2}:${isBg}:truecolor`;
+  const cached = colorConversionCache.get(cacheKey);
+  if (cached) return cached;
+  const { r, g, b } = hexToRGB(hex2);
+  const open = isBg ? `\x1B[48;2;${r};${g};${b}m` : `\x1B[38;2;${r};${g};${b}m`;
+  const close = isBg ? "\x1B[49m" : "\x1B[39m";
+  const result = { open, close };
+  colorConversionCache.set(cacheKey, result);
+  return result;
+}
+function hexToAnsi256(hex2, isBg = false) {
+  const cacheKey = `${hex2}:${isBg}:256`;
+  const cached = colorConversionCache.get(cacheKey);
+  if (cached) return cached.open;
+  const { r, g, b } = hexToRGB(hex2);
+  if (r === g && g === b) {
+    let index2;
+    if (r < 8) {
+      index2 = 16;
+    } else if (r > 238) {
+      index2 = 231;
+    } else {
+      index2 = Math.round((r - 8) / 247 * 24) + 232;
+    }
+    const open2 = isBg ? `\x1B[48;5;${index2}m` : `\x1B[38;5;${index2}m`;
+    const close2 = isBg ? "\x1B[49m" : "\x1B[39m";
+    colorConversionCache.set(cacheKey, { open: open2, close: close2 });
+    return open2;
+  }
+  const r5 = Math.round(r / 51);
+  const g5 = Math.round(g / 51);
+  const b5 = Math.round(b / 51);
+  const index = 16 + 36 * r5 + 6 * g5 + b5;
+  const open = isBg ? `\x1B[48;5;${index}m` : `\x1B[38;5;${index}m`;
+  const close = isBg ? "\x1B[49m" : "\x1B[39m";
+  colorConversionCache.set(cacheKey, { open, close });
+  return open;
+}
+const basicColors = [
+  { name: "black", rgb: { r: 0, g: 0, b: 0 }, fg: 30, bg: 40 },
+  { name: "red", rgb: { r: 205, g: 0, b: 0 }, fg: 31, bg: 41 },
+  { name: "green", rgb: { r: 0, g: 205, b: 0 }, fg: 32, bg: 42 },
+  { name: "yellow", rgb: { r: 205, g: 205, b: 0 }, fg: 33, bg: 43 },
+  { name: "blue", rgb: { r: 0, g: 0, b: 238 }, fg: 34, bg: 44 },
+  { name: "magenta", rgb: { r: 205, g: 0, b: 205 }, fg: 35, bg: 45 },
+  { name: "cyan", rgb: { r: 0, g: 205, b: 205 }, fg: 36, bg: 46 },
+  { name: "white", rgb: { r: 229, g: 229, b: 229 }, fg: 37, bg: 47 }
+];
+const baseStyles = {
+  reset: ["\x1B[0m", "\x1B[0m"],
+  bold: ["\x1B[1m", "\x1B[22m"],
+  dim: ["\x1B[2m", "\x1B[22m"],
+  italic: ["\x1B[3m", "\x1B[23m"],
+  underline: ["\x1B[4m", "\x1B[24m"],
+  inverse: ["\x1B[7m", "\x1B[27m"],
+  hidden: ["\x1B[8m", "\x1B[28m"],
+  strikethrough: ["\x1B[9m", "\x1B[29m"]
+};
+const colorDistances = /* @__PURE__ */ new Map();
+function hexToAnsiBasic(hex2, isBg = false) {
+  const cacheKey = `${hex2}:${isBg}:basic`;
+  const cached = colorConversionCache.get(cacheKey);
+  if (cached) return cached.open;
+  const { r, g, b } = hexToRGB(hex2);
+  const distanceKey = `${r},${g},${b}`;
+  let distances;
+  if (colorDistances.has(distanceKey)) {
+    distances = colorDistances.get(distanceKey) ?? shouldNeverHappen(
+      "Relico expected to use a color cache, but it's missing."
+    );
+  } else {
+    distances = basicColors.map((color) => {
+      const dr = r - color.rgb.r;
+      const dg = g - color.rgb.g;
+      const db = b - color.rgb.b;
+      return dr * dr + dg * dg + db * db;
+    });
+    colorDistances.set(distanceKey, distances);
+  }
+  let bestMatchIndex = 0;
+  let bestDistance = distances[0];
+  for (let i = 1; i < distances.length; i++) {
+    if (distances[i] < bestDistance) {
+      bestDistance = distances[i];
+      bestMatchIndex = i;
+    }
+  }
+  const bestMatch = basicColors[bestMatchIndex];
+  const code = isBg ? bestMatch.bg : bestMatch.fg;
+  const open = `\x1B[${code}m`;
+  const close = isBg ? "\x1B[49m" : "\x1B[39m";
+  colorConversionCache.set(cacheKey, { open, close });
+  return open;
+}
+function convertColorDefinition(key, def) {
+  const isBg = key.toLowerCase().startsWith("bg");
+  const theme = config.theme ?? "primary";
+  const chosen = theme === "primary" ? def[0] : def[1];
+  if (config.colorLevel === 0) {
+    return ["", ""];
+  }
+  if (chosen.startsWith("\x1B[")) {
+    return [chosen, isBg ? "\x1B[49m" : "\x1B[39m"];
+  }
+  const normalizedColor = normalizeColor(chosen);
+  let open;
+  const close = isBg ? "\x1B[49m" : "\x1B[39m";
+  switch (config.colorLevel) {
+    case 3:
+      open = hexToAnsiParts(normalizedColor, isBg).open;
+      break;
+    case 2:
+      open = hexToAnsi256(normalizedColor, isBg);
+      break;
+    case 1:
+      open = hexToAnsiBasic(normalizedColor, isBg);
+      break;
+    default:
+      open = "";
+  }
+  return [open, close];
+}
+function buildColorMap(cfg) {
+  if (cfg.colorLevel === 0) {
+    const noColorMap = {};
+    for (const k of Object.keys(baseColors)) {
+      noColorMap[k] = ["", ""];
+    }
+    return noColorMap;
+  }
+  const result = {};
+  for (const [key, value] of Object.entries(baseStyles)) {
+    result[key] = value;
+  }
+  for (const [key, value] of Object.entries(baseColors)) {
+    if (key in baseStyles) continue;
+    result[key] = convertColorDefinition(key, value);
+  }
+  if (cfg.customColors) {
+    for (const [k, v] of Object.entries(cfg.customColors)) {
+      if (!restrictedKeys.has(k)) {
+        result[k] = convertColorDefinition(k, v);
+      }
+    }
+  }
+  return result;
+}
+function createFormatter(open, close) {
+  if (!open && !close) {
+    return identityColor;
+  }
+  if (open === "" || close === "") {
+    return identityColor;
+  }
+  return (input) => {
+    const text = String(input);
+    if (!text) return text;
+    if (text.includes("\n")) {
+      return text.split("\n").map((line) => line ? open + line + close : line).join("\n");
+    }
+    return open + text + close;
+  };
+}
+function identityColor(text) {
+  return String(text);
+}
+const identityObject = Object.fromEntries(
+  defaultColorKeys.map((key) => [key, identityColor])
+);
+export const re = identityObject;
+function refreshTypedRe() {
+  Object.assign(re, colorFunctions);
+}
+function initColorFunctions() {
+  colorFunctions = {};
+  if (config.colorLevel === 0) {
+    for (const k of Object.keys(baseColors)) {
+      colorFunctions[k] = identityColor;
+    }
+    return;
+  }
+  for (const [key, [open, close]] of Object.entries(colorMap)) {
+    const cacheKey = `formatter:${open}:${close}`;
+    if (formatterCache.has(cacheKey)) {
+      colorFunctions[key] = formatterCache.get(cacheKey) ?? shouldNeverHappen(
+        "Relico expected to use a formatter cache, but it's missing."
+      );
+    } else {
+      const formatter = createFormatter(open, close);
+      formatterCache.set(cacheKey, formatter);
+      colorFunctions[key] = formatter;
+    }
+  }
+}
+function rebuild() {
+  colorConversionCache.clear();
+  colorMap = buildColorMap(config);
+  initColorFunctions();
+  refreshTypedRe();
+}
+rebuild();
+export function configure(userInput) {
+  if (typeof userInput !== "object" || userInput === null) {
+    return;
+  }
+  const input = userInput;
+  const newConfig = { ...config };
+  if (typeof input.colorLevel === "number" && [0, 1, 2, 3].includes(input.colorLevel)) {
+    newConfig.colorLevel = input.colorLevel;
+  } else if (input.autoDetect === true) {
+    newConfig.colorLevel = detectColorLevel();
+  }
+  if (input.theme === "primary" || input.theme === "secondary") {
+    newConfig.theme = input.theme;
+  }
+  if (input.customColors && typeof input.customColors === "object") {
+    newConfig.customColors = { ...input.customColors };
+  }
+  if (typeof input.autoDetect === "boolean") {
+    newConfig.autoDetect = input.autoDetect;
+  }
+  if (config.colorLevel !== newConfig.colorLevel || config.theme !== newConfig.theme || JSON.stringify(config.customColors) !== JSON.stringify(newConfig.customColors)) {
+    config = newConfig;
+    rebuild();
+  } else {
+    config = newConfig;
+  }
+}
+export function getColor(name) {
+  return colorFunctions[name] || colorFunctions.reset || identityColor;
+}
+export function colorize(name, text) {
+  return getColor(name)(text);
+}
+export function setColorLevel(level) {
+  if (config.colorLevel !== level) {
+    configure({ colorLevel: level });
+  }
+}
+export function rgb(r, g, b) {
+  const nr = Math.max(0, Math.min(255, Math.round(r)));
+  const ng = Math.max(0, Math.min(255, Math.round(g)));
+  const nb = Math.max(0, Math.min(255, Math.round(b)));
+  const key = `rgb:${nr},${ng},${nb}`;
+  if (config.colorLevel === 0) {
+    return identityColor;
+  }
+  if (formatterCache.has(key)) {
+    return formatterCache.get(key);
+  }
+  let open;
+  const close = "\x1B[39m";
+  switch (config.colorLevel) {
+    case 3:
+      open = `\x1B[38;2;${nr};${ng};${nb}m`;
+      break;
+    case 2: {
+      const hexColor = `#${nr.toString(16).padStart(2, "0")}${ng.toString(16).padStart(2, "0")}${nb.toString(16).padStart(2, "0")}`;
+      open = hexToAnsi256(hexColor, false);
+      break;
+    }
+    case 1: {
+      const basicHexColor = `#${nr.toString(16).padStart(2, "0")}${ng.toString(16).padStart(2, "0")}${nb.toString(16).padStart(2, "0")}`;
+      open = hexToAnsiBasic(basicHexColor, false);
+      break;
+    }
+    default:
+      return identityColor;
+  }
+  const formatter = createFormatter(open, close);
+  formatterCache.set(key, formatter);
+  return formatter;
+}
+export function bgRgb(r, g, b) {
+  const nr = Math.max(0, Math.min(255, Math.round(r)));
+  const ng = Math.max(0, Math.min(255, Math.round(g)));
+  const nb = Math.max(0, Math.min(255, Math.round(b)));
+  const key = `bgRgb:${nr},${ng},${nb}`;
+  if (config.colorLevel === 0) {
+    return identityColor;
+  }
+  if (formatterCache.has(key)) {
+    return formatterCache.get(key);
+  }
+  let open;
+  const close = "\x1B[49m";
+  switch (config.colorLevel) {
+    case 3:
+      open = `\x1B[48;2;${nr};${ng};${nb}m`;
+      break;
+    case 2: {
+      const hexColor = `#${nr.toString(16).padStart(2, "0")}${ng.toString(16).padStart(2, "0")}${nb.toString(16).padStart(2, "0")}`;
+      open = hexToAnsi256(hexColor, true);
+      break;
+    }
+    case 1: {
+      const basicHexColor = `#${nr.toString(16).padStart(2, "0")}${ng.toString(16).padStart(2, "0")}${nb.toString(16).padStart(2, "0")}`;
+      open = hexToAnsiBasic(basicHexColor, true);
+      break;
+    }
+    default:
+      return identityColor;
+  }
+  const formatter = createFormatter(open, close);
+  formatterCache.set(key, formatter);
+  return formatter;
+}
+export function hex(color) {
+  if (config.colorLevel === 0) {
+    return identityColor;
+  }
+  const normalizedColor = normalizeColor(color);
+  const cacheKey = `hex:${normalizedColor}`;
+  if (formatterCache.has(cacheKey)) {
+    return formatterCache.get(cacheKey);
+  }
+  const { r, g, b } = hexToRGB(normalizedColor);
+  const formatter = rgb(r, g, b);
+  formatterCache.set(cacheKey, formatter);
+  return formatter;
+}
+export function bgHex(color) {
+  if (config.colorLevel === 0) {
+    return identityColor;
+  }
+  const normalizedColor = normalizeColor(color);
+  const cacheKey = `bgHex:${normalizedColor}`;
+  if (formatterCache.has(cacheKey)) {
+    return formatterCache.get(cacheKey);
+  }
+  const { r, g, b } = hexToRGB(normalizedColor);
+  const formatter = bgRgb(r, g, b);
+  formatterCache.set(cacheKey, formatter);
+  return formatter;
+}
+function hslToRgb(h, s, l) {
+  h = (h % 360 + 360) % 360;
+  s = Math.max(0, Math.min(100, s)) / 100;
+  l = Math.max(0, Math.min(100, l)) / 100;
+  if (s === 0) {
+    const val = Math.round(l * 255);
+    return { r: val, g: val, b: val };
+  }
+  const cacheKey = `hsl:${h.toFixed(1)},${s.toFixed(3)},${l.toFixed(3)}`;
+  if (rgbCache.has(cacheKey)) {
+    return rgbCache.get(cacheKey);
+  }
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = l - c / 2;
+  let r;
+  let g;
+  let b;
+  if (h < 60) {
+    [r, g, b] = [c, x, 0];
+  } else if (h < 120) {
+    [r, g, b] = [x, c, 0];
+  } else if (h < 180) {
+    [r, g, b] = [0, c, x];
+  } else if (h < 240) {
+    [r, g, b] = [0, x, c];
+  } else if (h < 300) {
+    [r, g, b] = [x, 0, c];
+  } else {
+    [r, g, b] = [c, 0, x];
+  }
+  const rgb2 = {
+    r: Math.round((r + m) * 255),
+    g: Math.round((g + m) * 255),
+    b: Math.round((b + m) * 255)
+  };
+  rgbCache.set(cacheKey, rgb2);
+  return rgb2;
+}
+export function hsl(h, s, l) {
+  if (config.colorLevel === 0) {
+    return identityColor;
+  }
+  const cacheKey = `hsl:${h},${s},${l}`;
+  if (formatterCache.has(cacheKey)) {
+    return formatterCache.get(cacheKey);
+  }
+  const { r, g, b } = hslToRgb(h, s, l);
+  const formatter = rgb(r, g, b);
+  formatterCache.set(cacheKey, formatter);
+  return formatter;
+}
+export function bgHsl(h, s, l) {
+  if (config.colorLevel === 0) {
+    return identityColor;
+  }
+  const cacheKey = `bghsl:${h},${s},${l}`;
+  if (formatterCache.has(cacheKey)) {
+    return formatterCache.get(cacheKey);
+  }
+  const { r, g, b } = hslToRgb(h, s, l);
+  const formatter = bgRgb(r, g, b);
+  formatterCache.set(cacheKey, formatter);
+  return formatter;
+}
+export function chain(...formatters) {
+  if (formatters.length === 0) return identityColor;
+  if (formatters.length === 1) return formatters[0];
+  if (config.colorLevel === 0) return identityColor;
+  const cacheKey = `chain:${formatters.map(
+    (f) => f.name || formatterCache.entries().next().value?.[0] || "custom"
+  ).join(",")}`;
+  if (formatterCache.has(cacheKey)) {
+    return formatterCache.get(cacheKey);
+  }
+  const chainedFormatter = (text) => {
+    const str = String(text);
+    if (!str) return str;
+    if (str.includes("\n")) {
+      const lines = str.split("\n");
+      return lines.map((line) => {
+        if (!line) return line;
+        return formatters.reduce((result, formatter) => {
+          return formatter(result);
+        }, line);
+      }).join("\n");
+    }
+    return formatters.reduce((result, formatter) => {
+      return formatter(result);
+    }, str);
+  };
+  formatterCache.set(cacheKey, chainedFormatter);
+  return chainedFormatter;
+}
+export function rainbow(text, saturation = 100, lightness = 50, options) {
+  if (config.colorLevel === 0) {
+    return String(text);
+  }
+  const chars = String(text).split("");
+  if (chars.length === 0) return "";
+  const startHue = options?.startHue ?? 0;
+  const endHue = options?.endHue ?? 360;
+  const hueRange = ((endHue - startHue) % 360 + 360) % 360;
+  let result = "";
+  const hueStep = chars.length > 1 ? hueRange / (chars.length - 1) : 0;
+  const colorFormatters = [];
+  for (let i = 0; i < chars.length; i++) {
+    const hue = (startHue + i * hueStep) % 360;
+    colorFormatters.push(hsl(hue, saturation, lightness));
+  }
+  for (let i = 0; i < chars.length; i++) {
+    result += colorFormatters[i](chars[i]);
+  }
+  return result;
+}
+export function multiGradient(text, colors, options) {
+  if (config.colorLevel === 0 || colors.length === 0) {
+    return String(text);
+  }
+  if (colors.length === 1) {
+    return hex(colors[0])(text);
+  }
+  const chars = String(text).split("");
+  if (chars.length === 0) return "";
+  const smoothing = options?.smoothing ?? 1;
+  const distribution = options?.distribution ?? "even";
+  const rgbColors = colors.map(
+    (color) => hexToRGB(normalizeColor(color))
+  );
+  let result = "";
+  for (let i = 0; i < chars.length; i++) {
+    let gradientPos;
+    if (distribution === "weighted") {
+      gradientPos = (chars.length > 1 ? i / (chars.length - 1) : 0) ** smoothing;
+    } else {
+      gradientPos = chars.length > 1 ? i / (chars.length - 1) : 0;
+    }
+    const segmentCount = rgbColors.length - 1;
+    const segmentPos = gradientPos * segmentCount;
+    const segmentIndex = Math.min(Math.floor(segmentPos), segmentCount - 1);
+    const segmentOffset = segmentPos - segmentIndex;
+    const startColor = rgbColors[segmentIndex];
+    const endColor = rgbColors[segmentIndex + 1];
+    const r = Math.round(
+      startColor.r + segmentOffset * (endColor.r - startColor.r)
+    );
+    const g = Math.round(
+      startColor.g + segmentOffset * (endColor.g - startColor.g)
+    );
+    const b = Math.round(
+      startColor.b + segmentOffset * (endColor.b - startColor.b)
+    );
+    const colorFn = rgb(r, g, b);
+    result += colorFn(chars[i]);
+  }
+  return result;
+}
+export function gradient(text, startColor, endColor, options) {
+  return multiGradient(text, [startColor, endColor], options);
+}
+export function blend(color1, color2, ratio = 0.5) {
+  if (config.colorLevel === 0) return identityColor;
+  ratio = Math.max(0, Math.min(1, ratio));
+  if (ratio === 0) return hex(color1);
+  if (ratio === 1) return hex(color2);
+  const cacheKey = `blend:${normalizeColor(color1)}:${normalizeColor(
+    color2
+  )}:${ratio.toFixed(3)}`;
+  if (formatterCache.has(cacheKey)) {
+    return formatterCache.get(cacheKey);
+  }
+  const rgb1 = hexToRGB(normalizeColor(color1));
+  const rgb2 = hexToRGB(normalizeColor(color2));
+  const r = Math.round(rgb1.r * (1 - ratio) + rgb2.r * ratio);
+  const g = Math.round(rgb1.g * (1 - ratio) + rgb2.g * ratio);
+  const b = Math.round(rgb1.b * (1 - ratio) + rgb2.b * ratio);
+  const formatter = rgb(r, g, b);
+  formatterCache.set(cacheKey, formatter);
+  return formatter;
+}
+function getLuminance(r, g, b) {
+  const rsRGB = r / 255;
+  const gsRGB = g / 255;
+  const bsRGB = b / 255;
+  const R = rsRGB <= 0.03928 ? rsRGB / 12.92 : ((rsRGB + 0.055) / 1.055) ** 2.4;
+  const G = gsRGB <= 0.03928 ? gsRGB / 12.92 : ((gsRGB + 0.055) / 1.055) ** 2.4;
+  const B = bsRGB <= 0.03928 ? bsRGB / 12.92 : ((bsRGB + 0.055) / 1.055) ** 2.4;
+  return 0.2126 * R + 0.7152 * G + 0.0722 * B;
+}
+export function checkContrast(foreground, background = "#ffffff") {
+  const normalizedFg = normalizeColor(foreground);
+  const normalizedBg = normalizeColor(background);
+  const fgRGB = hexToRGB(normalizedFg);
+  const { r: bgR, g: bgG, b: bgB } = hexToRGB(normalizedBg);
+  const fgLuminance = getLuminance(fgRGB.r, fgRGB.g, fgRGB.b);
+  const bgLuminance = getLuminance(bgR, bgG, bgB);
+  const ratio = (Math.max(fgLuminance, bgLuminance) + 0.05) / (Math.min(fgLuminance, bgLuminance) + 0.05);
+  const roundedRatio = Math.round(ratio * 100) / 100;
+  return {
+    ratio: roundedRatio,
+    passesAA: roundedRatio >= 4.5,
+    passesAAA: roundedRatio >= 7,
+    passesAALarge: roundedRatio >= 3,
+    passesAAALarge: roundedRatio >= 4.5
+  };
+}
+export function getAccessibleColor(color, background = "#ffffff", targetRatio = 4.5) {
+  const normalizedColor = normalizeColor(color);
+  const normalizedBg = normalizeColor(background);
+  const { ratio } = checkContrast(normalizedColor, normalizedBg);
+  if (ratio >= targetRatio) {
+    return normalizedColor;
+  }
+  const { r, g, b } = hexToRGB(normalizedColor);
+  function rgbToHsl(r2, g2, b2) {
+    r2 /= 255;
+    g2 /= 255;
+    b2 /= 255;
+    const max = Math.max(r2, g2, b2);
+    const min = Math.min(r2, g2, b2);
+    let h2 = 0;
+    let s2 = 0;
+    const l2 = (max + min) / 2;
+    if (max !== min) {
+      const d = max - min;
+      s2 = l2 > 0.5 ? d / (2 - max - min) : d / (max + min);
+      switch (max) {
+        case r2:
+          h2 = (g2 - b2) / d + (g2 < b2 ? 6 : 0);
+          break;
+        case g2:
+          h2 = (b2 - r2) / d + 2;
+          break;
+        case b2:
+          h2 = (r2 - g2) / d + 4;
+          break;
+      }
+      h2 /= 6;
+    }
+    return [h2 * 360, s2 * 100, l2 * 100];
+  }
+  const [h, s, l] = rgbToHsl(r, g, b);
+  const { r: bgR, g: bgG, b: bgB } = hexToRGB(normalizedBg);
+  const bgLuminance = getLuminance(bgR, bgG, bgB);
+  const needsDarkening = bgLuminance > 0.5;
+  let low = needsDarkening ? 0 : l;
+  let high = needsDarkening ? l : 100;
+  let newL = l;
+  const currentRatio = ratio;
+  let bestL = newL;
+  let bestRatio = currentRatio;
+  for (let i = 0; i < 8; i++) {
+    newL = (low + high) / 2;
+    const { r: newR, g: newG, b: newB } = hslToRgb(h, s, newL);
+    const newHex = `#${newR.toString(16).padStart(2, "0")}${newG.toString(16).padStart(2, "0")}${newB.toString(16).padStart(2, "0")}`;
+    const { ratio: newRatio } = checkContrast(newHex, normalizedBg);
+    if (newRatio > bestRatio) {
+      bestRatio = newRatio;
+      bestL = newL;
+    }
+    if (Math.abs(newRatio - targetRatio) < 0.1 || Math.abs(high - low) < 0.5) {
+      break;
+    }
+    if (newRatio < targetRatio) {
+      if (needsDarkening) {
+        high = newL;
+      } else {
+        low = newL;
+      }
+    } else {
+      if (needsDarkening) {
+        low = newL;
+      } else {
+        high = newL;
+      }
+    }
+  }
+  const { r: finalR, g: finalG, b: finalB } = hslToRgb(h, s, bestL);
+  return `#${finalR.toString(16).padStart(2, "0")}${finalG.toString(16).padStart(2, "0")}${finalB.toString(16).padStart(2, "0")}`;
+}
+function getConfig() {
+  return { ...config };
+}
+export const colorSupport = {
+  get isColorSupported() {
+    return getConfig().colorLevel !== 0;
+  },
+  get colorLevel() {
+    return getConfig().colorLevel;
+  },
+  isForced,
+  isDisabled,
+  terminalName: getCurrentTerminalName()
+};
+export function colorWrap(text, bgColorFn, textColorFn) {
+  if (config.colorLevel === 0) {
+    return String(text);
+  }
+  const str = String(text);
+  if (!str) return str;
+  const lines = str.split("\n");
+  return lines.map((line) => {
+    if (!line) return line;
+    return textColorFn ? bgColorFn(textColorFn(line)) : bgColorFn(line);
+  }).join("\n");
+}
+export function safeBg(color, text) {
+  const colorFn = bgHex(normalizeColor(color));
+  if (text !== void 0) {
+    return colorWrap(String(text), colorFn);
+  }
+  return (innerText) => {
+    return colorWrap(String(innerText), colorFn);
+  };
+}
+export function safeColor(bgColor, fgColor, text) {
+  const normalizedBgColor = normalizeColor(bgColor);
+  const normalizedFgColor = normalizeColor(fgColor);
+  const bgColorFn = bgHex(normalizedBgColor);
+  const fgColorFn = hex(normalizedFgColor);
+  if (text !== void 0) {
+    return colorWrap(String(text), bgColorFn, fgColorFn);
+  }
+  return (innerText) => {
+    return colorWrap(String(innerText), bgColorFn, fgColorFn);
+  };
+}
+export function autoContrast(color, background = "#ffffff", targetRatio = 4.5) {
+  if (config.colorLevel === 0) {
+    return identityColor;
+  }
+  const accessibleColor = getAccessibleColor(color, background, targetRatio);
+  return hex(accessibleColor);
+}
+export function createColorScheme(baseColor) {
+  const color = normalizeColor(baseColor);
+  const { r, g, b } = hexToRGB(color);
+  function rgbToHsl(r2, g2, b2) {
+    r2 /= 255;
+    g2 /= 255;
+    b2 /= 255;
+    const max = Math.max(r2, g2, b2);
+    const min = Math.min(r2, g2, b2);
+    let h2 = 0;
+    let s2 = 0;
+    const l2 = (max + min) / 2;
+    if (max !== min) {
+      const d = max - min;
+      s2 = l2 > 0.5 ? d / (2 - max - min) : d / (max + min);
+      switch (max) {
+        case r2:
+          h2 = (g2 - b2) / d + (g2 < b2 ? 6 : 0);
+          break;
+        case g2:
+          h2 = (b2 - r2) / d + 2;
+          break;
+        case b2:
+          h2 = (r2 - g2) / d + 4;
+          break;
+      }
+      h2 /= 6;
+    }
+    return [h2 * 360, s2 * 100, l2 * 100];
+  }
+  const [h, s, l] = rgbToHsl(r, g, b);
+  return {
+    base: hex(color),
+    light: hsl(h, Math.max(0, s - 10), Math.min(100, l + 15)),
+    dark: hsl(h, Math.min(100, s + 10), Math.max(0, l - 15)),
+    bright: hsl(h, Math.min(100, s + 20), Math.min(95, l + 5)),
+    pastel: hsl(h, Math.max(0, s - 30), Math.min(100, l + 20)),
+    bg: bgHsl(h, Math.max(0, s - 10), Math.min(100, l + 30)),
+    bgLight: bgHsl(h, Math.max(0, s - 30), Math.min(100, l + 40)),
+    accent: hsl((h + 180) % 360, s, l)
+    // Complementary color
+  };
+}
+export function highlight(text, bgColor, options) {
+  if (config.colorLevel === 0) {
+    return String(text);
+  }
+  const normalizedBg = normalizeColor(bgColor);
+  const { r, g, b } = hexToRGB(normalizedBg);
+  const bgLuminance = getLuminance(r, g, b);
+  const textColor = bgLuminance > 0.5 ? "#000000" : "#ffffff";
+  const padding = options?.padding ?? 0;
+  const paddingStr = padding > 0 ? " ".repeat(padding) : "";
+  const coloredText = safeColor(
+    normalizedBg,
+    textColor,
+    `${paddingStr}${text}${paddingStr}`
+  );
+  if (options?.border) {
+    const borderColor = options?.borderColor ?? normalizedBg;
+    const width = String(text).length + padding * 2;
+    const borderLine = bgHex(borderColor)(" ".repeat(width));
+    return `${borderLine}
+${coloredText}
+${borderLine}`;
+  }
+  return coloredText;
+}
+export function link(text, url, color) {
+  const colorFn = color ? hex(color) : re.blue;
+  const escapedUrl = url.replace(/\)/g, "%29");
+  return `\x1B]8;;${escapedUrl}\x1B\\${colorFn(text)}\x1B]8;;\x1B\\`;
+}
+export function colorizeJson(obj, options) {
+  if (config.colorLevel === 0) {
+    return JSON.stringify(obj, null, options?.indent ?? 2);
+  }
+  const indent = options?.indent ?? 2;
+  const json = JSON.stringify(obj, null, options?.compact ? 0 : indent);
+  return json.replace(/"(\\.|[^"\\])*"(?=\s*:)/g, (match) => re.cyan(match)).replace(
+    /:\s*"(\\.|[^"\\])*"/g,
+    (match) => `: ${re.green(match.slice(match.indexOf('"')))}`
+  ).replace(
+    /:\s*\b(true|false|null)\b/g,
+    (match) => `: ${re.yellow(match.slice(match.indexOf(":") + 1))}`
+  ).replace(
+    /:\s*(-?\d+\.?\d*([eE][+-]?\d+)?)/g,
+    (match) => `: ${re.magenta(match.slice(match.indexOf(":") + 1))}`
+  );
+}
+export async function initUserConfig(programmaticConfig, userSettingsPrecedence = false) {
+  try {
+    const options = {
+      name: "relico",
+      // If user settings take precedence, programmaticConfig becomes defaults
+      // Otherwise, it becomes overrides (higher priority)
+      ...userSettingsPrecedence ? { defaults: programmaticConfig || {} } : { overrides: programmaticConfig || {} },
+      // Set sensible defaults if no user settings are present
+      defaultConfig: {
+        colorLevel: detectColorLevel(),
+        theme: "primary",
+        autoDetect: true
+      }
+    };
+    const { config: mergedConfig } = await loadConfig(options);
+    if (mergedConfig && Object.keys(mergedConfig).length > 0) {
+      configure(mergedConfig);
+    }
+  } catch (err) {
+    console.warn("Failed to load user config via c12:", err);
+    if (programmaticConfig) {
+      configure(programmaticConfig);
+    }
+  }
+}
+export function defineConfig(cfg) {
+  return cfg;
+}