@reliverse/relico 1.3.0 → 1.3.2

package/package.json

@@ -1,43 +1,38 @@
 {
-  "dependencies": {},
-  "description": "@reliverse/relico is a themeable, chainable, typed, truecolor-powered, modern terminal styling toolkit. Designed to make your CLI output colorful, accessible, and human-friendly. It gives you a flexible way to apply colors and styles — with reliability and a smart developer experience baked in. Built for humans, not just terminals.",
-  "homepage": "https://docs.reliverse.org",
-  "license": "MIT",
   "name": "@reliverse/relico",
-  "type": "module",
-  "version": "1.3.0",
-  "keywords": [
-    "reliverse",
-    "cli",
-    "command-line",
-    "dler"
-  ],
   "author": "reliverse",
-  "bugs": {
-    "email": "blefnk@gmail.com",
-    "url": "https://github.com/reliverse/relico/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/reliverse/relico.git"
-  },
-  "bin": {
-    "dler": "bin/cli.js"
-  },
-  "devDependencies": {},
+  "version": "1.3.2",
+  "type": "module",
+  "description": "@reliverse/relico is a themeable, chainable, typed, truecolor-powered, modern terminal styling toolkit. Designed to make your CLI output colorful, accessible, and human-friendly. It gives you a flexible way to apply colors and styles — with reliability and a smart developer experience baked in. Built for humans, not just terminals.",
   "exports": {
-    ".": "./bin/mod.js"
+    ".": "./src/mod.ts"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "files": [
-    "bin",
     "package.json",
     "README.md",
     "LICENSE",
-    "LICENSES"
+    "src"
   ],
-  "main": "./bin/mod.js",
-  "module": "./bin/mod.js",
-  "publishConfig": {
-    "access": "public"
+  "scripts": {
+    "pub": "dler pub",
+    "dev": "bun examples/core.ts",
+    "latest": "bun update --latest && bun check",
+    "check": "tsc --noEmit && biome check --fix --unsafe",
+    "bench": "bun examples/benchmarks/performance.ts",
+    "size": "bun examples/benchmarks/bundle-size.ts",
+    "perf": "bun bench && bun size"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.2.0",
+    "@reliverse/dler": "^1.7.92",
+    "@reliverse/rse-cfg": "^1.7.12",
+    "@total-typescript/ts-reset": "^0.6.1",
+    "@types/bun": "^1.2.20",
+    "@types/node": "^24.3.0",
+    "typescript": "^5.9.2",
+    "ultracite": "^5.1.5"
   }
-}
+}

package/src/mod.ts

@@ -0,0 +1,492 @@
+/* @reliverse/relico - Tiny, type-safe terminal color library with chainable API
+   - Levels: 0 (off), 1 (ANSI 8/bright), 2 (ANSI 256), 3 (Truecolor)
+   - Named palettes (std, web, grayscale), Bright & Pastel variants, bg-variants
+   - Chainable: re.bold.red.underline("text"), chain(re.bold, re.red)("text")
+   - Multiline-safe: styles applied per line with reset to prevent bleed
+*/
+
+type ColorLevel = 0 | 1 | 2 | 3;
+
+interface Rgb {
+  r: number;
+  g: number;
+  b: number;
+}
+
+type SgrOp =
+  | { kind: "style"; open: number[] } // closed by global reset at line end
+  | { kind: "fg-basic"; idx: number; bright: boolean }
+  | { kind: "bg-basic"; idx: number; bright: boolean }
+  | { kind: "fg-256"; code: number }
+  | { kind: "bg-256"; code: number }
+  | { kind: "fg-true"; rgb: Rgb }
+  | { kind: "bg-true"; rgb: Rgb };
+
+type ApplyInput = string | number;
+
+type FormatCallable = ((input: ApplyInput) => string) & { readonly [OP_SYMBOL]: SgrOp[] };
+
+type BaseColorName =
+  | "black"
+  | "red"
+  | "green"
+  | "yellow"
+  | "blue"
+  | "magenta"
+  | "cyan"
+  | "white"
+  | "gray"
+  | "orange"
+  | "pink"
+  | "purple"
+  | "teal"
+  | "lime"
+  | "brown"
+  | "navy"
+  | "maroon"
+  | "olive"
+  | "silver";
+
+type ColorName = BaseColorName | BrightColorName | BgColorName;
+
+type BrightColorName =
+  | "blackBright"
+  | "redBright"
+  | "greenBright"
+  | "yellowBright"
+  | "blueBright"
+  | "magentaBright"
+  | "cyanBright"
+  | "whiteBright"
+  | "orangeBright"
+  | "pinkBright"
+  | "purpleBright"
+  | "tealBright"
+  | "limeBright"
+  | "brownBright"
+  | "navyBright"
+  | "maroonBright"
+  | "oliveBright"
+  | "silverBright";
+
+type BgColorName = `bg${Capitalize<BaseColorName>}` | `bg${Capitalize<BrightColorName>}`;
+
+type ReStyleKey =
+  | "reset"
+  | "bold"
+  | "dim"
+  | "italic"
+  | "underline"
+  | "inverse"
+  | "hidden"
+  | "strikethrough";
+
+type Re = FormatCallable & {
+  readonly [K in ReStyleKey]: Re;
+} & {
+  readonly [K in ColorName]: Re;
+} & {
+  readonly [K in BgColorName]: Re;
+};
+
+const ESC = "\x1B[";
+const RESET = `${ESC}0m`;
+const OP_SYMBOL: unique symbol = Symbol("re.ops");
+
+// Color level constants
+const COLOR_LEVEL_OFF = 0;
+const COLOR_LEVEL_BASIC = 1;
+const COLOR_LEVEL_256 = 2;
+const COLOR_LEVEL_TRUECOLOR = 3;
+
+// RGB and byte constants
+const MIN_BYTE = 0;
+const MAX_BYTE = 255;
+const WHITE_RGB = 255;
+
+// ANSI 256 color constants
+const ANSI_256_GRAYSCALE_MIN = 8;
+const ANSI_256_GRAYSCALE_MAX = 248;
+const ANSI_256_BASE_OFFSET = 16;
+const ANSI_256_GRAYSCALE_BASE = 232;
+const ANSI_256_GRAYSCALE_RANGE = 247;
+const ANSI_256_GRAYSCALE_STEPS = 24;
+const ANSI_256_BRIGHT_THRESHOLD = 231;
+const ANSI_256_RGB_LEVELS = 5;
+const ANSI_256_RGB_RED_MULTIPLIER = 36;
+const ANSI_256_RGB_GREEN_MULTIPLIER = 6;
+
+// SGR code constants
+const SGR_FG_BASE = 30;
+const SGR_BG_BASE = 40;
+const SGR_FG_BRIGHT_BASE = 90;
+const SGR_BG_BRIGHT_BASE = 100;
+
+// Style SGR codes
+const SGR_RESET = 0;
+const SGR_BOLD = 1;
+const SGR_DIM = 2;
+const SGR_ITALIC = 3;
+const SGR_UNDERLINE = 4;
+const SGR_INVERSE = 7;
+const SGR_HIDDEN = 8;
+const SGR_STRIKETHROUGH = 9;
+
+// Hex parsing constants
+const HEX_BYTE_LENGTH = 2;
+const HEX_RED_START = 0;
+const HEX_GREEN_START = 2;
+const HEX_BLUE_START = 4;
+const HEX_BLUE_END = 6;
+const HEX_RADIX = 16;
+
+// String processing constants
+const BRIGHT_SUFFIX_LENGTH = 6;
+const BG_PREFIX_LENGTH = 2;
+const BG_COLOR_START = 3;
+
+// Color mixing constants
+const BRIGHT_MIX_FACTOR = 0.25;
+
+// Regex constants
+const BRIGHT_SUFFIX_REGEX = /Bright$/u;
+
+let CURRENT_LEVEL: ColorLevel = COLOR_LEVEL_TRUECOLOR;
+
+export const setColorLevel = (level: ColorLevel): void => {
+  if (
+    level !== COLOR_LEVEL_OFF &&
+    level !== COLOR_LEVEL_BASIC &&
+    level !== COLOR_LEVEL_256 &&
+    level !== COLOR_LEVEL_TRUECOLOR
+  ) {
+    throw new Error("Invalid color level");
+  }
+  CURRENT_LEVEL = level;
+};
+
+const clampByte = (n: number): number => {
+  if (!Number.isFinite(n)) {
+    return MIN_BYTE;
+  }
+  if (n < MIN_BYTE) {
+    return MIN_BYTE;
+  }
+  if (n > MAX_BYTE) {
+    return MAX_BYTE;
+  }
+  return Math.round(n);
+};
+
+// Base 8-color RGB anchors (non-bright)
+const BASIC8: Rgb[] = [
+  { r: 0, g: 0, b: 0 }, // black
+  { r: 205, g: 0, b: 0 }, // red
+  { r: 0, g: 205, b: 0 }, // green
+  { r: 205, g: 205, b: 0 }, // yellow
+  { r: 0, g: 0, b: 238 }, // blue
+  { r: 205, g: 0, b: 205 }, // magenta
+  { r: 0, g: 205, b: 205 }, // cyan
+  { r: 229, g: 229, b: 229 }, // white (light gray)
+];
+
+// SGR code builders
+const sgr = (codes: number[]): string => `${ESC}${codes.join(";")}m`;
+
+// RGB → closest of BASIC8 index (0..7)
+const nearestBasicIndex = (rgb: Rgb): number => {
+  let best = 0;
+  let bestDist = Number.POSITIVE_INFINITY;
+  for (let i = 0; i < BASIC8.length; i++) {
+    const c = BASIC8[i];
+    const dr = c.r - rgb.r;
+    const dg = c.g - rgb.g;
+    const db = c.b - rgb.b;
+    const d = dr * dr + dg * dg + db * db;
+    if (d < bestDist) {
+      bestDist = d;
+      best = i;
+    }
+  }
+  return best;
+};
+
+// RGB → ANSI 256 index
+const rgbToAnsi256 = (rgb: Rgb): number => {
+  // Try grayscale if r≈g≈b
+  if (rgb.r === rgb.g && rgb.g === rgb.b) {
+    if (rgb.r < ANSI_256_GRAYSCALE_MIN) {
+      return ANSI_256_BASE_OFFSET;
+    }
+    if (rgb.r > ANSI_256_GRAYSCALE_MAX) {
+      return ANSI_256_BRIGHT_THRESHOLD;
+    }
+    const step = Math.round(
+      ((rgb.r - ANSI_256_GRAYSCALE_MIN) / ANSI_256_GRAYSCALE_RANGE) * ANSI_256_GRAYSCALE_STEPS,
+    );
+    return ANSI_256_GRAYSCALE_BASE + step;
+  }
+  const r = Math.round((rgb.r / MAX_BYTE) * ANSI_256_RGB_LEVELS);
+  const g = Math.round((rgb.g / MAX_BYTE) * ANSI_256_RGB_LEVELS);
+  const b = Math.round((rgb.b / MAX_BYTE) * ANSI_256_RGB_LEVELS);
+  return (
+    ANSI_256_BASE_OFFSET + ANSI_256_RGB_RED_MULTIPLIER * r + ANSI_256_RGB_GREEN_MULTIPLIER * g + b
+  );
+};
+
+// Color data
+const NAMED_COLORS: Record<BaseColorName, string> = {
+  black: "#000000",
+  red: "#ff0000",
+  green: "#00ff00",
+  yellow: "#ffff00",
+  blue: "#0000ff",
+  magenta: "#ff00ff",
+  cyan: "#00ffff",
+  white: "#ffffff",
+  gray: "#808080",
+  orange: "#ffa500",
+  pink: "#ffc0cb",
+  purple: "#800080",
+  teal: "#008080",
+  lime: "#00ff00",
+  brown: "#a52a2a",
+  navy: "#000080",
+  maroon: "#800000",
+  olive: "#808000",
+  silver: "#c0c0c0",
+};
+
+const mixWithWhite = (rgb: Rgb, factor: number): Rgb => {
+  const t = factor;
+  return {
+    r: clampByte(rgb.r * (1 - t) + WHITE_RGB * t),
+    g: clampByte(rgb.g * (1 - t) + WHITE_RGB * t),
+    b: clampByte(rgb.b * (1 - t) + WHITE_RGB * t),
+  };
+};
+
+const fromNamed = (name: BaseColorName): Rgb => {
+  const hex = NAMED_COLORS[name];
+  // Simple hex to RGB conversion for named colors only
+  const clean = hex.startsWith("#") ? hex.slice(1) : hex;
+  const r = Number.parseInt(clean.slice(HEX_RED_START, HEX_BYTE_LENGTH), HEX_RADIX);
+  const g = Number.parseInt(clean.slice(HEX_GREEN_START, HEX_BLUE_START), HEX_RADIX);
+  const b = Number.parseInt(clean.slice(HEX_BLUE_START, HEX_BLUE_END), HEX_RADIX);
+  return { r, g, b };
+};
+
+const toBaseName = (compound: BrightColorName): BaseColorName => {
+  const base = compound.replace(BRIGHT_SUFFIX_REGEX, "");
+  const key = base.charAt(0).toLowerCase() + base.slice(1);
+  return key as BaseColorName;
+};
+
+const parseColorName = (name: ColorName): { rgb: Rgb; wantBright: boolean } => {
+  if ((name as string).endsWith("Bright")) {
+    const base = toBaseName(name as BrightColorName);
+    const rgb = fromNamed(base);
+    // Lighten a bit in high levels; level 1 will use bright SGR
+    const rgbAdj = mixWithWhite(rgb, BRIGHT_MIX_FACTOR);
+    return { rgb: rgbAdj, wantBright: true };
+  }
+  return { rgb: fromNamed(name as BaseColorName), wantBright: false };
+};
+
+const openForOp = (op: SgrOp): string => {
+  if (CURRENT_LEVEL === COLOR_LEVEL_OFF) {
+    return "";
+  }
+  switch (op.kind) {
+    case "style":
+      return sgr(op.open);
+    case "fg-basic":
+      return sgr([(op.bright ? SGR_FG_BRIGHT_BASE : SGR_FG_BASE) + op.idx]);
+    case "bg-basic":
+      return sgr([(op.bright ? SGR_BG_BRIGHT_BASE : SGR_BG_BASE) + op.idx]);
+    case "fg-256":
+      return `${ESC}38;5;${op.code}m`;
+    case "bg-256":
+      return `${ESC}48;5;${op.code}m`;
+    case "fg-true":
+      return `${ESC}38;2;${op.rgb.r};${op.rgb.g};${op.rgb.b}m`;
+    case "bg-true":
+      return `${ESC}48;2;${op.rgb.r};${op.rgb.g};${op.rgb.b}m`;
+    default:
+      return "";
+  }
+};
+
+const opsToOpen = (ops: SgrOp[]): string => {
+  if (CURRENT_LEVEL === COLOR_LEVEL_OFF) {
+    return "";
+  }
+  let out = "";
+  for (const op of ops) {
+    out += openForOp(op);
+  }
+  return out;
+};
+
+// Optimized multiline processing with fewer allocations and branches
+const applyOpsToText = (ops: SgrOp[], input: ApplyInput): string => {
+  const text = String(input);
+  if (CURRENT_LEVEL === COLOR_LEVEL_OFF || ops.length === 0 || text.length === 0) {
+    return text;
+  }
+
+  const open = opsToOpen(ops);
+
+  // Fast path for single-line text (most common case)
+  if (!text.includes("\n")) {
+    return `${open}${text}${RESET}`;
+  }
+
+  // Optimized multiline handling with pre-calculated string lengths
+  const lines = text.split("\n");
+  const result = new Array(lines.length);
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.endsWith("\r")) {
+      result[i] = `${open}${line.slice(0, -1)}\r${RESET}`;
+    } else {
+      result[i] = `${open}${line}${RESET}`;
+    }
+  }
+
+  return result.join("\n");
+};
+
+// Build operations for a color request according to CURRENT_LEVEL
+const mkFgOpsFromRgb = (rgb: Rgb, wantBright = false): SgrOp[] => {
+  if (CURRENT_LEVEL === COLOR_LEVEL_BASIC) {
+    const idx = nearestBasicIndex(rgb);
+    return [{ kind: "fg-basic", idx, bright: wantBright }];
+  }
+  if (CURRENT_LEVEL === COLOR_LEVEL_256) {
+    return [{ kind: "fg-256", code: rgbToAnsi256(rgb) }];
+  }
+  return [{ kind: "fg-true", rgb }];
+};
+
+const mkBgOpsFromRgb = (rgb: Rgb, wantBright = false): SgrOp[] => {
+  if (CURRENT_LEVEL === COLOR_LEVEL_BASIC) {
+    const idx = nearestBasicIndex(rgb);
+    return [{ kind: "bg-basic", idx, bright: wantBright }];
+  }
+  if (CURRENT_LEVEL === COLOR_LEVEL_256) {
+    return [{ kind: "bg-256", code: rgbToAnsi256(rgb) }];
+  }
+  return [{ kind: "bg-true", rgb }];
+};
+
+// Style ops
+const STYLE_TABLE: Record<ReStyleKey, SgrOp> = {
+  reset: { kind: "style", open: [SGR_RESET] },
+  bold: { kind: "style", open: [SGR_BOLD] },
+  dim: { kind: "style", open: [SGR_DIM] },
+  italic: { kind: "style", open: [SGR_ITALIC] },
+  underline: { kind: "style", open: [SGR_UNDERLINE] },
+  inverse: { kind: "style", open: [SGR_INVERSE] },
+  hidden: { kind: "style", open: [SGR_HIDDEN] },
+  strikethrough: { kind: "style", open: [SGR_STRIKETHROUGH] },
+};
+
+// Lookup maps
+const STYLE_KEYS = new Set([
+  "reset",
+  "bold",
+  "dim",
+  "italic",
+  "underline",
+  "inverse",
+  "hidden",
+  "strikethrough",
+]);
+
+// Direct color/bg key checks
+const isColorKey = (key: string): boolean => {
+  // Base colors and extended colors
+  if (key in NAMED_COLORS) {
+    return true;
+  }
+  // Bright variants
+  if (key.endsWith("Bright") && isColorKey(key.slice(0, -BRIGHT_SUFFIX_LENGTH))) {
+    return true;
+  }
+  return false;
+};
+
+const isBgKey = (key: string): boolean => {
+  if (!key.startsWith("bg") || key.length <= BG_PREFIX_LENGTH) {
+    return false;
+  }
+  const colorPart = key.charAt(BG_PREFIX_LENGTH).toLowerCase() + key.slice(BG_COLOR_START);
+  return isColorKey(colorPart);
+};
+
+// Proxy with performance through pre-computed lookups
+const callableProxy = (ops: SgrOp[]): Re => {
+  const base = ((input: ApplyInput) => applyOpsToText(ops, input)) as FormatCallable;
+  Object.defineProperty(base, OP_SYMBOL, {
+    value: ops,
+    enumerable: false,
+    configurable: false,
+    writable: false,
+  });
+
+  return new Proxy(base as unknown as Re, {
+    apply(_target, _thisArg, argArray) {
+      const [input] = argArray as [ApplyInput];
+      return applyOpsToText(ops, input);
+    },
+    get(_target, prop) {
+      const key = String(prop);
+
+      // Ops extractor for chain()
+      if (prop === OP_SYMBOL) {
+        return ops;
+      }
+
+      // Fast path for styles using Set lookup
+      if (STYLE_KEYS.has(key)) {
+        const op = STYLE_TABLE[key as ReStyleKey];
+        return callableProxy([...ops, op]);
+      }
+
+      // Fast path for colors
+      if (isBgKey(key)) {
+        const raw = key.slice(BG_PREFIX_LENGTH); // remove 'bg'
+        const colorName = raw.charAt(0).toLowerCase() + raw.slice(1);
+        const { rgb, wantBright } = parseColorName(colorName as ColorName);
+        return callableProxy([...ops, ...mkBgOpsFromRgb(rgb, wantBright)]);
+      }
+
+      if (isColorKey(key)) {
+        const { rgb, wantBright } = parseColorName(key as ColorName);
+        return callableProxy([...ops, ...mkFgOpsFromRgb(rgb, wantBright)]);
+      }
+
+      // Unknown key → return self (no-op), keeps chain resilient
+      return callableProxy(ops);
+    },
+  });
+};
+
+// Public root
+export const re: Re = callableProxy([]);
+
+// chain(re.bold, re.red, re.underline)("text")
+export const chain = (...parts: FormatCallable[]): Re => {
+  const collected: SgrOp[] = [];
+  for (const p of parts) {
+    const ops = (p as FormatCallable)[OP_SYMBOL] as SgrOp[] | undefined;
+    if (ops && ops.length > 0) {
+      for (const op of ops) {
+        collected.push(op);
+      }
+    }
+  }
+  return callableProxy(collected);
+};

package/bin/mod.d.ts

@@ -1,75 +0,0 @@
-type ColorLevel = 0 | 1 | 2 | 3;
-type Rgb = {
-    r: number;
-    g: number;
-    b: number;
-};
-type SgrOp = {
-    kind: "style";
-    open: number[];
-} | {
-    kind: "fg-basic";
-    idx: number;
-    bright: boolean;
-} | {
-    kind: "bg-basic";
-    idx: number;
-    bright: boolean;
-} | {
-    kind: "fg-256";
-    code: number;
-} | {
-    kind: "bg-256";
-    code: number;
-} | {
-    kind: "fg-true";
-    rgb: Rgb;
-} | {
-    kind: "bg-true";
-    rgb: Rgb;
-};
-type ApplyInput = string | number;
-type FormatCallable = ((input: ApplyInput) => string) & {
-    readonly [OP_SYMBOL]: SgrOp[];
-};
-type BaseColorName = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "orange" | "pink" | "purple" | "teal" | "lime" | "brown" | "navy" | "maroon" | "olive" | "silver";
-type ColorName = BaseColorName | GrayScaleName | BrightColorName | PastelColorName | BgColorName;
-type GrayScaleName = "gray10" | "gray20" | "gray30" | "gray40" | "gray50" | "gray60" | "gray70" | "gray80" | "gray90";
-type BrightColorName = "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright" | "orangeBright" | "pinkBright" | "purpleBright" | "tealBright" | "limeBright" | "brownBright" | "navyBright" | "maroonBright" | "oliveBright" | "silverBright";
-type PastelColorName = "blackPastel" | "redPastel" | "greenPastel" | "yellowPastel" | "bluePastel" | "magentaPastel" | "cyanPastel" | "whitePastel" | "grayPastel" | "orangePastel" | "pinkPastel" | "purplePastel" | "tealPastel" | "limePastel" | "brownPastel" | "navyPastel" | "maroonPastel" | "olivePastel" | "silverPastel";
-type BgColorName = `bg${Capitalize<BaseColorName>}` | `bg${Capitalize<GrayScaleName>}` | `bg${Capitalize<BrightColorName>}` | `bg${Capitalize<PastelColorName>}`;
-type MkRgbFn = (r: number, g: number, b: number) => Re;
-type MkHexFn = (hex: string) => Re;
-type MkHslFn = (h: number, s: number, l: number) => Re;
-type StyleKeys = "reset" | "bold" | "dim" | "italic" | "underline" | "inverse" | "hidden" | "strikethrough";
-type Re = FormatCallable & {
-    readonly [K in StyleKeys]: Re;
-} & {
-    readonly [K in ColorName]: Re;
-} & {
-    readonly [K in BgColorName]: Re;
-} & {
-    readonly rgb: MkRgbFn;
-    readonly hex: MkHexFn;
-    readonly hsl: MkHslFn;
-    readonly bgRgb: MkRgbFn;
-    readonly bgHex: MkHexFn;
-    readonly bgHsl: MkHslFn;
-};
-declare const OP_SYMBOL: unique symbol;
-export declare const setColorLevel: (level: ColorLevel) => void;
-export declare const re: Re;
-export declare const rgb: MkRgbFn;
-export declare const hex: MkHexFn;
-export declare const hsl: MkHslFn;
-export declare const bgRgb: MkRgbFn;
-export declare const bgHex: MkHexFn;
-export declare const bgHsl: MkHslFn;
-export declare const chain: (...parts: FormatCallable[]) => Re;
-export declare const parseRgb: (value: string) => Rgb | null;
-export declare const parseHsl: (value: string) => {
-    h: number;
-    s: number;
-    l: number;
-} | null;
-export {};

package/bin/mod.js

@@ -1,455 +0,0 @@
-const ESC = "\x1B[";
-const RESET = `${ESC}0m`;
-const OP_SYMBOL = Symbol("re.ops");
-let CURRENT_LEVEL = 3;
-export const setColorLevel = (level) => {
-  if (level !== 0 && level !== 1 && level !== 2 && level !== 3) {
-    throw new Error("Invalid color level");
-  }
-  CURRENT_LEVEL = level;
-};
-const clampByte = (n) => {
-  if (!Number.isFinite(n)) return 0;
-  if (n < 0) return 0;
-  if (n > 255) return 255;
-  return Math.round(n);
-};
-const clampPct = (n) => {
-  if (!Number.isFinite(n)) return 0;
-  if (n < 0) return 0;
-  if (n > 100) return 100;
-  return n;
-};
-const hexRe = /^#?([a-fA-F0-9]{3}|[a-fA-F0-9]{6})$/;
-const hexToRgb = (hex2) => {
-  const len = hex2.length;
-  const start = hex2[0] === "#" ? 1 : 0;
-  const raw = hex2.slice(start);
-  const rawLen = raw.length;
-  if (rawLen !== 3 && rawLen !== 6) return null;
-  for (let i = 0; i < rawLen; i++) {
-    const c = raw.charCodeAt(i);
-    if (!(c >= 48 && c <= 57 || c >= 65 && c <= 70 || c >= 97 && c <= 102)) {
-      return null;
-    }
-  }
-  if (rawLen === 3) {
-    const r = parseInt(raw[0] + raw[0], 16);
-    const g = parseInt(raw[1] + raw[1], 16);
-    const b = parseInt(raw[2] + raw[2], 16);
-    return { r, g, b };
-  }
-  return {
-    r: parseInt(raw.slice(0, 2), 16),
-    g: parseInt(raw.slice(2, 4), 16),
-    b: parseInt(raw.slice(4, 6), 16)
-  };
-};
-const hslToRgb = (h, s, l) => {
-  const H = (h % 360 + 360) % 360;
-  const S = Math.min(100, Math.max(0, s)) / 100;
-  const L = Math.min(100, Math.max(0, l)) / 100;
-  if (S === 0) {
-    const v = Math.round(L * 255);
-    return { r: v, g: v, b: v };
-  }
-  const c = (1 - Math.abs(2 * L - 1)) * S;
-  const x = c * (1 - Math.abs(H / 60 % 2 - 1));
-  const m = L - c / 2;
-  const sector = Math.floor(H / 60) % 6;
-  const rgbValues = [
-    [c, x, 0],
-    [x, c, 0],
-    [0, c, x],
-    [0, x, c],
-    [x, 0, c],
-    [c, 0, x]
-  ][sector];
-  return {
-    r: Math.round((rgbValues[0] + m) * 255),
-    g: Math.round((rgbValues[1] + m) * 255),
-    b: Math.round((rgbValues[2] + m) * 255)
-  };
-};
-const BASIC8 = [
-  { r: 0, g: 0, b: 0 },
-  // black
-  { r: 205, g: 0, b: 0 },
-  // red
-  { r: 0, g: 205, b: 0 },
-  // green
-  { r: 205, g: 205, b: 0 },
-  // yellow
-  { r: 0, g: 0, b: 238 },
-  // blue
-  { r: 205, g: 0, b: 205 },
-  // magenta
-  { r: 0, g: 205, b: 205 },
-  // cyan
-  { r: 229, g: 229, b: 229 }
-  // white (light gray)
-];
-const sgr = (codes) => `${ESC}${codes.join(";")}m`;
-const nearestBasicIndex = (rgb2) => {
-  let best = 0;
-  let bestDist = Number.POSITIVE_INFINITY;
-  for (let i = 0; i < BASIC8.length; i++) {
-    const c = BASIC8[i];
-    const dr = c.r - rgb2.r;
-    const dg = c.g - rgb2.g;
-    const db = c.b - rgb2.b;
-    const d = dr * dr + dg * dg + db * db;
-    if (d < bestDist) {
-      bestDist = d;
-      best = i;
-    }
-  }
-  return best;
-};
-const rgbToAnsi256 = (rgb2) => {
-  if (rgb2.r === rgb2.g && rgb2.g === rgb2.b) {
-    if (rgb2.r < 8) return 16;
-    if (rgb2.r > 248) return 231;
-    const step = Math.round((rgb2.r - 8) / 247 * 24);
-    return 232 + step;
-  }
-  const r = Math.round(rgb2.r / 255 * 5);
-  const g = Math.round(rgb2.g / 255 * 5);
-  const b = Math.round(rgb2.b / 255 * 5);
-  return 16 + 36 * r + 6 * g + b;
-};
-const CORE_COLORS = {
-  black: "#000000",
-  red: "#ff0000",
-  green: "#00ff00",
-  yellow: "#ffff00",
-  blue: "#0000ff",
-  magenta: "#ff00ff",
-  cyan: "#00ffff",
-  white: "#ffffff",
-  gray: "#808080"
-};
-const EXTENDED_COLORS = {
-  orange: "#ffa500",
-  pink: "#ffc0cb",
-  purple: "#800080",
-  teal: "#008080",
-  lime: "#00ff00",
-  brown: "#a52a2a",
-  navy: "#000080",
-  maroon: "#800000",
-  olive: "#808000",
-  silver: "#c0c0c0"
-};
-let NAMED_HEX;
-const getNamedColors = () => {
-  if (NAMED_HEX) return NAMED_HEX;
-  NAMED_HEX = { ...CORE_COLORS, ...EXTENDED_COLORS };
-  return NAMED_HEX;
-};
-let GRAYS;
-const getGrayColors = () => {
-  if (GRAYS) return GRAYS;
-  GRAYS = {};
-  for (let i = 1; i <= 9; i++) {
-    const value = Math.round(26 * i - 10);
-    const hex2 = value.toString(16).padStart(2, "0");
-    const key = `gray${i}0`;
-    GRAYS[key] = `#${hex2}${hex2}${hex2}`;
-  }
-  return GRAYS;
-};
-const mixWithWhite = (rgb2, factor) => {
-  const t = factor;
-  return {
-    r: clampByte(rgb2.r * (1 - t) + 255 * t),
-    g: clampByte(rgb2.g * (1 - t) + 255 * t),
-    b: clampByte(rgb2.b * (1 - t) + 255 * t)
-  };
-};
-const fromNamed = (name) => {
-  const hex2 = getNamedColors()[name];
-  const rgb2 = hexToRgb(hex2);
-  return rgb2 ?? { r: 255, g: 255, b: 255 };
-};
-const fromGrayName = (name) => {
-  const hex2 = getGrayColors()[name];
-  const rgb2 = hexToRgb(hex2);
-  return rgb2 ?? { r: 128, g: 128, b: 128 };
-};
-const toBaseName = (compound) => {
-  const base = compound.replace(/(Bright|Pastel)$/u, "");
-  const key = base.charAt(0).toLowerCase() + base.slice(1);
-  return key;
-};
-const parseColorName = (name) => {
-  if (name.endsWith("Bright")) {
-    const base = toBaseName(name);
-    const rgb2 = fromNamed(base);
-    const rgbAdj = mixWithWhite(rgb2, 0.25);
-    return { rgb: rgbAdj, wantBright: true };
-  }
-  if (name.endsWith("Pastel")) {
-    const base = toBaseName(name);
-    const rgb2 = fromNamed(base);
-    const rgbAdj = mixWithWhite(rgb2, 0.6);
-    return { rgb: rgbAdj, wantBright: false };
-  }
-  if (name.startsWith("gray")) {
-    return { rgb: fromGrayName(name), wantBright: false };
-  }
-  return { rgb: fromNamed(name), wantBright: false };
-};
-const openForOp = (op) => {
-  if (CURRENT_LEVEL === 0) return "";
-  switch (op.kind) {
-    case "style":
-      return sgr(op.open);
-    case "fg-basic":
-      return sgr([(op.bright ? 90 : 30) + op.idx]);
-    case "bg-basic":
-      return sgr([(op.bright ? 100 : 40) + op.idx]);
-    case "fg-256":
-      return `${ESC}38;5;${op.code}m`;
-    case "bg-256":
-      return `${ESC}48;5;${op.code}m`;
-    case "fg-true":
-      return `${ESC}38;2;${op.rgb.r};${op.rgb.g};${op.rgb.b}m`;
-    case "bg-true":
-      return `${ESC}48;2;${op.rgb.r};${op.rgb.g};${op.rgb.b}m`;
-  }
-};
-const opsToOpen = (ops) => {
-  if (CURRENT_LEVEL === 0) return "";
-  let out = "";
-  for (const op of ops) out += openForOp(op);
-  return out;
-};
-const applyOpsToText = (ops, input) => {
-  const text = String(input);
-  if (CURRENT_LEVEL === 0 || ops.length === 0 || text.length === 0) return text;
-  const open = opsToOpen(ops);
-  if (!text.includes("\n")) {
-    return `${open}${text}${RESET}`;
-  }
-  const lines = text.split("\n");
-  const result = new Array(lines.length);
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (line.endsWith("\r")) {
-      result[i] = `${open}${line.slice(0, -1)}\r${RESET}`;
-    } else {
-      result[i] = `${open}${line}${RESET}`;
-    }
-  }
-  return result.join("\n");
-};
-const mkFgOpsFromRgb = (rgb2, wantBright = false) => {
-  if (CURRENT_LEVEL === 1) {
-    const idx = nearestBasicIndex(rgb2);
-    return [{ kind: "fg-basic", idx, bright: wantBright }];
-  }
-  if (CURRENT_LEVEL === 2) {
-    return [{ kind: "fg-256", code: rgbToAnsi256(rgb2) }];
-  }
-  return [{ kind: "fg-true", rgb: rgb2 }];
-};
-const mkBgOpsFromRgb = (rgb2, wantBright = false) => {
-  if (CURRENT_LEVEL === 1) {
-    const idx = nearestBasicIndex(rgb2);
-    return [{ kind: "bg-basic", idx, bright: wantBright }];
-  }
-  if (CURRENT_LEVEL === 2) {
-    return [{ kind: "bg-256", code: rgbToAnsi256(rgb2) }];
-  }
-  return [{ kind: "bg-true", rgb: rgb2 }];
-};
-const STYLE_TABLE = {
-  reset: { kind: "style", open: [0] },
-  bold: { kind: "style", open: [1] },
-  dim: { kind: "style", open: [2] },
-  italic: { kind: "style", open: [3] },
-  underline: { kind: "style", open: [4] },
-  inverse: { kind: "style", open: [7] },
-  hidden: { kind: "style", open: [8] },
-  strikethrough: { kind: "style", open: [9] }
-};
-const STYLE_KEYS = /* @__PURE__ */ new Set([
-  "reset",
-  "bold",
-  "dim",
-  "italic",
-  "underline",
-  "inverse",
-  "hidden",
-  "strikethrough"
-]);
-const DYNAMIC_KEYS = /* @__PURE__ */ new Set(["rgb", "hex", "hsl", "bgRgb", "bgHex", "bgHsl"]);
-let COLOR_KEY_CACHE;
-let BG_KEY_CACHE;
-const getColorKeys = () => {
-  if (COLOR_KEY_CACHE) return COLOR_KEY_CACHE;
-  const baseColors = [
-    "black",
-    "red",
-    "green",
-    "yellow",
-    "blue",
-    "magenta",
-    "cyan",
-    "white",
-    "gray"
-  ];
-  const extendedColors = [
-    "orange",
-    "pink",
-    "purple",
-    "teal",
-    "lime",
-    "brown",
-    "navy",
-    "maroon",
-    "olive",
-    "silver"
-  ];
-  const grayNames = Array.from({ length: 9 }, (_, i) => `gray${(i + 1) * 10}`);
-  COLOR_KEY_CACHE = /* @__PURE__ */ new Set([
-    ...baseColors,
-    ...extendedColors,
-    ...grayNames,
-    ...baseColors.map((c) => `${c}Bright`),
-    ...extendedColors.map((c) => `${c}Bright`),
-    ...baseColors.map((c) => `${c}Pastel`),
-    ...extendedColors.map((c) => `${c}Pastel`),
-    "grayPastel"
-  ]);
-  return COLOR_KEY_CACHE;
-};
-const getBgKeys = () => {
-  if (BG_KEY_CACHE) return BG_KEY_CACHE;
-  BG_KEY_CACHE = /* @__PURE__ */ new Set();
-  for (const colorKey of getColorKeys()) {
-    const capitalizedKey = colorKey.charAt(0).toUpperCase() + colorKey.slice(1);
-    BG_KEY_CACHE.add(`bg${capitalizedKey}`);
-  }
-  return BG_KEY_CACHE;
-};
-const callableFromOps = (ops) => {
-  const fn = ((input) => applyOpsToText(ops, input));
-  Object.defineProperty(fn, OP_SYMBOL, {
-    value: ops,
-    enumerable: false,
-    configurable: false,
-    writable: false
-  });
-  return fn;
-};
-const appendOps = (base, extra) => {
-  const out = [];
-  for (const op of base) out.push(op);
-  for (const op of extra) out.push(op);
-  return out;
-};
-const mkRgbMethod = (ops, isBg) => (r, g, b) => {
-  const rgb2 = { r: clampByte(r), g: clampByte(g), b: clampByte(b) };
-  const add = isBg ? mkBgOpsFromRgb(rgb2) : mkFgOpsFromRgb(rgb2);
-  return callableProxy(appendOps(ops, add));
-};
-const mkHexMethod = (ops, isBg) => (hex2) => {
-  const rgb2 = hexToRgb(hex2);
-  if (!rgb2) return callableProxy(ops);
-  const add = isBg ? mkBgOpsFromRgb(rgb2) : mkFgOpsFromRgb(rgb2);
-  return callableProxy(appendOps(ops, add));
-};
-const mkHslMethod = (ops, isBg) => (h, s, l) => {
-  const rgb2 = hslToRgb(h, s, l);
-  const add = isBg ? mkBgOpsFromRgb(rgb2) : mkFgOpsFromRgb(rgb2);
-  return callableProxy(appendOps(ops, add));
-};
-const callableProxy = (ops) => {
-  const base = callableFromOps(ops);
-  return new Proxy(base, {
-    apply(_target, _thisArg, argArray) {
-      const [input] = argArray;
-      return applyOpsToText(ops, input);
-    },
-    get(_target, prop) {
-      const key = String(prop);
-      if (prop === OP_SYMBOL) return ops;
-      if (STYLE_KEYS.has(key)) {
-        const op = STYLE_TABLE[key];
-        return callableProxy(appendOps(ops, [op]));
-      }
-      if (DYNAMIC_KEYS.has(key)) {
-        const isBg = key.startsWith("bg");
-        switch (key) {
-          case "rgb":
-            return mkRgbMethod(ops, false);
-          case "hex":
-            return mkHexMethod(ops, false);
-          case "hsl":
-            return mkHslMethod(ops, false);
-          case "bgRgb":
-            return mkRgbMethod(ops, true);
-          case "bgHex":
-            return mkHexMethod(ops, true);
-          case "bgHsl":
-            return mkHslMethod(ops, true);
-        }
-      }
-      const bgKeys = getBgKeys();
-      const colorKeys = getColorKeys();
-      if (bgKeys.has(key)) {
-        const raw = key.slice(2);
-        const colorName = raw.charAt(0).toLowerCase() + raw.slice(1);
-        const { rgb: rgb2, wantBright } = parseColorName(colorName);
-        return callableProxy(appendOps(ops, mkBgOpsFromRgb(rgb2, wantBright)));
-      }
-      if (colorKeys.has(key)) {
-        const { rgb: rgb2, wantBright } = parseColorName(key);
-        return callableProxy(appendOps(ops, mkFgOpsFromRgb(rgb2, wantBright)));
-      }
-      return callableProxy(ops);
-    }
-  });
-};
-export const re = callableProxy([]);
-export const rgb = (r, g, b) => re.rgb(r, g, b);
-export const hex = (h) => re.hex(h);
-export const hsl = (h, s, l) => re.hsl(h, s, l);
-export const bgRgb = (r, g, b) => re.bgRgb(r, g, b);
-export const bgHex = (h) => re.bgHex(h);
-export const bgHsl = (h, s, l) => re.bgHsl(h, s, l);
-export const chain = (...parts) => {
-  const collected = [];
-  for (const p of parts) {
-    const ops = p[OP_SYMBOL];
-    if (ops && ops.length > 0) {
-      for (const op of ops) collected.push(op);
-    }
-  }
-  return callableProxy(collected);
-};
-export const parseRgb = (value) => {
-  const v = value.trim();
-  if (!v.toLowerCase().startsWith("rgb(") || !v.endsWith(")")) return null;
-  const inner = v.slice(4, -1);
-  const parts = inner.split(",").map((s) => s.trim());
-  if (parts.length !== 3) return null;
-  const nums = parts.map((p) => Number.parseInt(p, 10));
-  if (!Number.isFinite(nums[0]) || !Number.isFinite(nums[1]) || !Number.isFinite(nums[2]))
-    return null;
-  return { r: clampByte(nums[0]), g: clampByte(nums[1]), b: clampByte(nums[2]) };
-};
-export const parseHsl = (value) => {
-  const v = value.trim().toLowerCase();
-  if (!v.startsWith("hsl(") || !v.endsWith(")")) return null;
-  const inner = v.slice(4, -1);
-  const parts = inner.split(",").map((s2) => s2.trim().replace(/%$/u, ""));
-  if (parts.length !== 3) return null;
-  const h = Number.parseFloat(parts[0]);
-  const s = Number.parseFloat(parts[1]);
-  const l = Number.parseFloat(parts[2]);
-  if (!Number.isFinite(h) || !Number.isFinite(s) || !Number.isFinite(l)) return null;
-  return { h, s, l };
-};