@reliverse/relico 1.4.1 → 2.2.7

package/README.md

@@ -1,12 +1,8 @@
 # Reliverse Relico
 
-> @reliverse/dler-colors is a themeable, chainable, typed, truecolor-powered terminal styling toolkit — built for humans, not just terminals. It makes your CLI output beautiful, accessible, and expressive — with developer-first ergonomics, smart config, and blazing-fast performance.
+> @reliverse/relico is a themeable, chainable, typed, truecolor-powered terminal styling toolkit — built for humans, not just terminals. It makes your CLI output beautiful, accessible, and expressive — with developer-first ergonomics, smart config, and blazing-fast performance.
 
-[sponsor](https://github.com/sponsors/blefnk) — [discord](https://discord.gg/Pb8uKbwpsJ) — [repo](https://github.com/reliverse/relico) — [npm](https://npmjs.com/@reliverse/dler-colors)
-
----
-
-‼️Attention! The latest implementation of `@reliverse/relico` now lives in the framework repository for building libraries — `@reliverse/dler`. Please use [@reliverse/dler-colors](https://github.com/reliverse/dler/tree/main/packages/colors) instead of `@reliverse/relico`.
+[sponsor](https://github.com/sponsors/blefnk) — [discord](https://discord.gg/Pb8uKbwpsJ) — [repo](https://github.com/reliverse/relico) — [npm](https://npmjs.com/@reliverse/relico)
 
 ## Why Relico?
 
@@ -28,7 +24,7 @@ Because terminal styling shouldn't feel like duct tape. **Relico** brings design
 ## Installation
 
 ```bash
-bun add @reliverse/dler-colors
+bun add @reliverse/relico
 # bun • pnpm • yarn • npm
 ```
 
@@ -95,7 +91,7 @@ The readme will be updated soon.
 **If you're end-user OR developer, create `relico.config.ts` in your root**:
 
 ```ts
-import { defineConfig } from "@reliverse/dler-colors";
+import { defineConfig } from "@reliverse/relico";
 
 export default defineConfig({
   colorLevel: 3, // 0 = off, 1 = basic, 2 = 256, 3 = truecolor
@@ -112,7 +108,7 @@ export default defineConfig({
 **If you're developer, initialize in your app (optional)**:
 
 ```ts
-import { initUserConfig, re } from "@reliverse/dler-colors";
+import { initUserConfig, re } from "@reliverse/relico";
 
 // Use this to override Relico's 
 // default settings for your app
@@ -124,7 +120,7 @@ console.log(re.info("Custom config loaded!"));
 ## API Sneak Peek
 
 ```ts
-import { re, rgb } from "@reliverse/dler-colors";
+import { re, rgb } from "@reliverse/relico";
 
 console.log(re.red("Red!"));
 console.log(re.bold(re.green("Bold green")));
@@ -175,7 +171,7 @@ console.log(boldRed("This text is bold and red"));
 ### Want to Get Only Certain Colors?
 
 ```ts
-import type { DefaultColorKeys } from "@reliverse/dler-colors";
+import type { DefaultColorKeys } from "@reliverse/relico";
 const brandColors: DefaultColorKeys[] = ["magentaBright", "maroon"];
 ```
 
@@ -184,7 +180,7 @@ const brandColors: DefaultColorKeys[] = ["magentaBright", "maroon"];
 Relico detects your terminal's capability:
 
 ```ts
-import { colorSupport } from "@reliverse/dler-colors";
+import { colorSupport } from "@reliverse/relico";
 
 console.log(colorSupport.terminalName); // iTerm2, Windows Terminal, etc.
 console.log(colorSupport.level); // 0, 1, 2, or 3
@@ -200,7 +196,7 @@ console.log(colorSupport.level); // 0, 1, 2, or 3
 ### Custom RGB + Hex
 
 ```ts
-import { rgb, bgHex, hex } from "@reliverse/dler-colors";
+import { rgb, bgHex, hex } from "@reliverse/relico";
 
 console.log(rgb(255, 105, 180)("Hot pink"));
 console.log(bgHex("#1e90ff")("Dodger blue background"));
@@ -209,7 +205,7 @@ console.log(bgHex("#1e90ff")("Dodger blue background"));
 ### Gradients & Rainbow
 
 ```ts
-import { gradient, multiGradient, rainbow } from "@reliverse/dler-colors";
+import { gradient, multiGradient, rainbow } from "@reliverse/relico";
 
 console.log(rainbow("🎉 Woohoo!"));
 console.log(gradient("From red to blue", "#ff0000", "#0000ff"));
@@ -222,7 +218,7 @@ This function allows you to combine multiple color formatters into a single form
 ## Basic Usage
 
 ```typescript
-import { re, chain } from "@reliverse/dler-colors";
+import { re, chain } from "@reliverse/relico";
 
 // Create a custom style that combines bold and red text
 const boldRed = chain(re.bold, re.red);
@@ -240,7 +236,7 @@ console.log(importantError("CRITICAL ERROR: System failure"));
 ## Creating Theme Combinations
 
 ```typescript
-import { re, chain } from "@reliverse/dler-colors";
+import { re, chain } from "@reliverse/relico";
 
 // Create themed message styles
 const successStyle = chain(re.bold, re.green);
@@ -258,7 +254,7 @@ console.log(warnStyle("⚠ API rate limit approaching"));
 ## Custom RGB Combinations
 
 ```typescript
-import { re, rgb, bgRgb, chain } from "@reliverse/dler-colors";
+import { re, rgb, bgRgb, chain } from "@reliverse/relico";
 
 // Create a custom color scheme with RGB values
 const customHeader = chain(
@@ -282,7 +278,7 @@ console.log(danger("Danger: High voltage detected!"));
 The `chain()` function automatically handles multiline text to prevent style leakage:
 
 ```typescript
-import { re, chain } from "@reliverse/dler-colors";
+import { re, chain } from "@reliverse/relico";
 
 const highlight = chain(re.bgYellow, re.black, re.bold);
 
@@ -297,7 +293,7 @@ console.log(highlight(multilineText));
 ## Creating a Simple Logger
 
 ```typescript
-import { re, chain } from "@reliverse/dler-colors";
+import { re, chain } from "@reliverse/relico";
 
 // Create logger styles
 const styles = {
@@ -320,7 +316,7 @@ const logger = {
 // Usage
 logger.info("Application started");
 logger.success("Data loaded successfully");
-logger.warning("Cache expired, refreshing data");
+logger.warn("Cache expired, refreshing data");
 logger.error("Failed to connect to database");
 logger.debug("Request payload: " + JSON.stringify({id: 123}));
 ```

package/dist/mod.d.ts

@@ -0,0 +1,60 @@
+type ColorLevel = 0 | 1 | 2 | 3;
+interface 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[];
+};
+export type BaseColorName = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white" | "gray" | "orange" | "pink" | "purple" | "teal" | "lime" | "brown" | "navy" | "maroon" | "olive" | "silver";
+export type ColorName = BaseColorName | BrightColorName | BgColorName;
+export type BrightColorName = "blackBright" | "redBright" | "greenBright" | "yellowBright" | "blueBright" | "magentaBright" | "cyanBright" | "whiteBright" | "orangeBright" | "pinkBright" | "purpleBright" | "tealBright" | "limeBright" | "brownBright" | "navyBright" | "maroonBright" | "oliveBright" | "silverBright";
+export type BgColorName = `bg${Capitalize<BaseColorName>}` | `bg${Capitalize<BrightColorName>}`;
+export type ReStyleKey = "reset" | "bold" | "dim" | "italic" | "underline" | "inverse" | "hidden" | "strikethrough";
+export type Re = FormatCallable & {
+    readonly [K in ReStyleKey]: Re;
+} & {
+    readonly [K in ColorName]: Re;
+} & {
+    readonly [K in BgColorName]: Re;
+};
+declare const OP_SYMBOL: unique symbol;
+export declare const setColorLevel: (level: ColorLevel) => void;
+export declare const re: Re;
+export declare const chain: (...parts: FormatCallable[]) => Re;
+type BunColorInput = {
+    r: number;
+    g: number;
+    b: number;
+    a?: number;
+} | [number, number, number] | [number, number, number, number] | string | number | {
+    toString(): string;
+};
+export declare const color: (input: BunColorInput, isBg?: boolean) => Re;
+export {};

package/dist/mod.js

@@ -0,0 +1,455 @@
+const RESET = "\x1B[0m";
+const OP_SYMBOL = /* @__PURE__ */ Symbol("re.ops");
+const COLOR_LEVEL_OFF = 0;
+const COLOR_LEVEL_BASIC = 1;
+const COLOR_LEVEL_256 = 2;
+const COLOR_LEVEL_TRUECOLOR = 3;
+const MIN_BYTE = 0;
+const MAX_BYTE = 255;
+const WHITE_RGB = 255;
+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;
+const SGR_FG_BASE = 30;
+const SGR_BG_BASE = 40;
+const SGR_FG_BRIGHT_BASE = 90;
+const SGR_BG_BRIGHT_BASE = 100;
+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;
+const HEX_RADIX = 16;
+const BRIGHT_SUFFIX_LENGTH = 6;
+const BG_PREFIX_LENGTH = 2;
+const BRIGHT_MIX_FACTOR = 0.25;
+const BRIGHT_SUFFIX = "Bright";
+const IS_BUN = typeof process !== "undefined" && process.versions?.bun !== void 0 && typeof Bun !== "undefined" && typeof Bun.color === "function";
+let CURRENT_LEVEL = COLOR_LEVEL_TRUECOLOR;
+export const setColorLevel = (level) => {
+  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) => {
+  if (n <= MIN_BYTE || !Number.isFinite(n)) return MIN_BYTE;
+  if (n >= MAX_BYTE) return MAX_BYTE;
+  return Math.round(n);
+};
+const BASIC8 = Object.freeze([
+  Object.freeze({ r: 0, g: 0, b: 0 }),
+  Object.freeze({ r: 205, g: 0, b: 0 }),
+  Object.freeze({ r: 0, g: 205, b: 0 }),
+  Object.freeze({ r: 205, g: 205, b: 0 }),
+  Object.freeze({ r: 0, g: 0, b: 238 }),
+  Object.freeze({ r: 205, g: 0, b: 205 }),
+  Object.freeze({ r: 0, g: 205, b: 205 }),
+  Object.freeze({ r: 229, g: 229, b: 229 })
+]);
+const sgrCache = /* @__PURE__ */ new Map();
+const sgr = (codes) => {
+  if (codes.length === 1) {
+    const code = codes[0];
+    const cached2 = sgrCache.get(String(code));
+    if (cached2) return cached2;
+    const seq2 = `\x1B[${code}m`;
+    sgrCache.set(String(code), seq2);
+    return seq2;
+  }
+  const key = codes.join(";");
+  const cached = sgrCache.get(key);
+  if (cached) return cached;
+  const seq = `\x1B[${key}m`;
+  sgrCache.set(key, seq);
+  return seq;
+};
+const nearestBasicIndex = (rgb) => {
+  if (IS_BUN) {
+    const ansiStr = Bun.color(rgb, "ansi-16");
+    if (ansiStr) {
+      const match = ansiStr.match(/38;5;(\d+)/);
+      if (match?.[1]) {
+        return Number.parseInt(match[1], 10) & 7;
+      }
+    }
+  }
+  let best = 0;
+  let bestDist = Number.POSITIVE_INFINITY;
+  for (let i = 0; i < 8; i++) {
+    const c = BASIC8[i];
+    const dr = c.r - rgb.r;
+    const dg = c.g - rgb.g;
+    const db = c.b - rgb.b;
+    if (dr === 0 && dg === 0 && db === 0) return i;
+    const d = dr * dr + dg * dg + db * db;
+    if (d < bestDist) {
+      bestDist = d;
+      best = i;
+    }
+  }
+  return best;
+};
+const rgbToAnsi256 = (rgb) => {
+  if (IS_BUN) {
+    const ansiStr = Bun.color(rgb, "ansi-256");
+    if (ansiStr) {
+      const match = ansiStr.match(/38;5;(\d+)/);
+      if (match?.[1]) {
+        return Number.parseInt(match[1], 10);
+      }
+    }
+  }
+  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 = (rgb.r * ANSI_256_RGB_LEVELS + 127) / MAX_BYTE | 0;
+  const g = (rgb.g * ANSI_256_RGB_LEVELS + 127) / MAX_BYTE | 0;
+  const b = (rgb.b * ANSI_256_RGB_LEVELS + 127) / MAX_BYTE | 0;
+  return ANSI_256_BASE_OFFSET + r * ANSI_256_RGB_RED_MULTIPLIER + g * ANSI_256_RGB_GREEN_MULTIPLIER + b;
+};
+const NAMED_COLORS = {
+  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 rgbCache = /* @__PURE__ */ new Map();
+for (const name of ["black", "white", "red", "green", "blue"]) {
+  const hex = NAMED_COLORS[name];
+  if (hex) {
+    const clean = hex.slice(1);
+    const r = Number.parseInt(clean.slice(0, 2), HEX_RADIX);
+    const g = Number.parseInt(clean.slice(2, 4), HEX_RADIX);
+    const b = Number.parseInt(clean.slice(4, 6), HEX_RADIX);
+    rgbCache.set(name, Object.freeze({ r, g, b }));
+  }
+}
+const mixWithWhite = (rgb, factor) => {
+  const invFactor = 1 - factor;
+  return {
+    r: clampByte(rgb.r * invFactor + WHITE_RGB * factor),
+    g: clampByte(rgb.g * invFactor + WHITE_RGB * factor),
+    b: clampByte(rgb.b * invFactor + WHITE_RGB * factor)
+  };
+};
+const fromNamed = (name) => {
+  const cached = rgbCache.get(name);
+  if (cached) return cached;
+  const hex = NAMED_COLORS[name];
+  if (!hex) return { r: 0, g: 0, b: 0 };
+  if (IS_BUN) {
+    const rgb = Bun.color(hex, "{rgb}");
+    if (rgb) {
+      rgbCache.set(name, rgb);
+      return rgb;
+    }
+  }
+  const clean = hex[0] === "#" ? hex.slice(1) : hex;
+  const len = clean.length;
+  let r, g, b;
+  if (len === 3) {
+    const rv = Number.parseInt(clean[0], HEX_RADIX);
+    const gv = Number.parseInt(clean[1], HEX_RADIX);
+    const bv = Number.parseInt(clean[2], HEX_RADIX);
+    r = rv << 4 | rv;
+    g = gv << 4 | gv;
+    b = bv << 4 | bv;
+  } else if (len === 6) {
+    r = Number.parseInt(clean.slice(0, 2), HEX_RADIX);
+    g = Number.parseInt(clean.slice(2, 4), HEX_RADIX);
+    b = Number.parseInt(clean.slice(4, 6), HEX_RADIX);
+  } else {
+    return { r: 0, g: 0, b: 0 };
+  }
+  if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) {
+    return { r: 0, g: 0, b: 0 };
+  }
+  const result = Object.freeze({ r, g, b });
+  rgbCache.set(name, result);
+  return result;
+};
+const toBaseName = (compound) => {
+  if (!compound) return "black";
+  const base = compound.slice(0, -BRIGHT_SUFFIX_LENGTH);
+  if (!base) return "black";
+  return base[0]?.toLowerCase() + base.slice(1);
+};
+const parseColorName = (name) => {
+  if (!name) return { rgb: { r: 0, g: 0, b: 0 }, wantBright: false };
+  if (name.endsWith(BRIGHT_SUFFIX)) {
+    const base = toBaseName(name);
+    const rgb = fromNamed(base);
+    const rgbAdj = mixWithWhite(rgb, BRIGHT_MIX_FACTOR);
+    return { rgb: rgbAdj, wantBright: true };
+  }
+  return { rgb: fromNamed(name), wantBright: false };
+};
+const openForOp = (op) => {
+  if (CURRENT_LEVEL === COLOR_LEVEL_OFF) return "";
+  switch (op.kind) {
+    case "style":
+      return sgr(op.open);
+    case "fg-basic": {
+      const code = (op.bright ? SGR_FG_BRIGHT_BASE : SGR_FG_BASE) + op.idx;
+      return sgr([code]);
+    }
+    case "bg-basic": {
+      const code = (op.bright ? SGR_BG_BRIGHT_BASE : SGR_BG_BASE) + op.idx;
+      return sgr([code]);
+    }
+    case "fg-256": {
+      if (IS_BUN) {
+        const ansi = Bun.color(op.code, "ansi-256");
+        if (ansi) return ansi;
+      }
+      return `\x1B[38;5;${op.code}m`;
+    }
+    case "bg-256": {
+      if (IS_BUN) {
+        const fgAnsi = Bun.color(op.code, "ansi-256");
+        if (fgAnsi) return fgAnsi.replace("38;5;", "48;5;");
+      }
+      return `\x1B[48;5;${op.code}m`;
+    }
+    case "fg-true": {
+      if (IS_BUN) {
+        const ansi = Bun.color(op.rgb, "ansi-16m");
+        if (ansi) return ansi;
+      }
+      const { r, g, b } = op.rgb;
+      return `\x1B[38;2;${r};${g};${b}m`;
+    }
+    case "bg-true": {
+      if (IS_BUN) {
+        const fgAnsi = Bun.color(op.rgb, "ansi-16m");
+        if (fgAnsi) return fgAnsi.replace("38;2;", "48;2;");
+      }
+      const { r, g, b } = op.rgb;
+      return `\x1B[48;2;${r};${g};${b}m`;
+    }
+    default:
+      return "";
+  }
+};
+const opsToOpen = (ops) => {
+  if (CURRENT_LEVEL === COLOR_LEVEL_OFF) return "";
+  const len = ops.length;
+  if (len === 0) return "";
+  if (len === 1) return openForOp(ops[0]);
+  let result = "";
+  for (let i = 0; i < len; i++) {
+    result += openForOp(ops[i]);
+  }
+  return result;
+};
+const applyOpsToText = (ops, input) => {
+  const text = String(input);
+  const textLen = text.length;
+  if (CURRENT_LEVEL === COLOR_LEVEL_OFF || ops.length === 0 || textLen === 0) {
+    return text;
+  }
+  const open = opsToOpen(ops);
+  if (!open) return text;
+  const nlIdx = text.indexOf("\n");
+  if (nlIdx === -1) {
+    return `${open}${text}${RESET}`;
+  }
+  let result = "";
+  let start = 0;
+  while (start < textLen) {
+    const end = text.indexOf("\n", start);
+    if (end === -1) {
+      const line2 = text.slice(start);
+      if (line2) {
+        if (line2.endsWith("\r")) {
+          result += `${open}${line2.slice(0, -1)}\r${RESET}`;
+        } else {
+          result += `${open}${line2}${RESET}`;
+        }
+      }
+      break;
+    }
+    if (start > 0) result += "\n";
+    const line = text.slice(start, end);
+    if (line) {
+      if (line.endsWith("\r")) {
+        result += `${open}${line.slice(0, -1)}\r${RESET}`;
+      } else {
+        result += `${open}${line}${RESET}`;
+      }
+    } else {
+      result += `${open}${RESET}`;
+    }
+    start = end + 1;
+  }
+  return result;
+};
+const mkFgOpsFromRgb = (rgb, wantBright = false) => {
+  if (CURRENT_LEVEL === COLOR_LEVEL_BASIC) {
+    return [
+      { kind: "fg-basic", idx: nearestBasicIndex(rgb), bright: wantBright }
+    ];
+  }
+  if (CURRENT_LEVEL === COLOR_LEVEL_256) {
+    return [{ kind: "fg-256", code: rgbToAnsi256(rgb) }];
+  }
+  return [{ kind: "fg-true", rgb }];
+};
+const mkBgOpsFromRgb = (rgb, wantBright = false) => {
+  if (CURRENT_LEVEL === COLOR_LEVEL_BASIC) {
+    return [
+      { kind: "bg-basic", idx: nearestBasicIndex(rgb), bright: wantBright }
+    ];
+  }
+  if (CURRENT_LEVEL === COLOR_LEVEL_256) {
+    return [{ kind: "bg-256", code: rgbToAnsi256(rgb) }];
+  }
+  return [{ kind: "bg-true", rgb }];
+};
+const STYLE_TABLE = {
+  reset: Object.freeze({ kind: "style", open: [SGR_RESET] }),
+  bold: Object.freeze({ kind: "style", open: [SGR_BOLD] }),
+  dim: Object.freeze({ kind: "style", open: [SGR_DIM] }),
+  italic: Object.freeze({ kind: "style", open: [SGR_ITALIC] }),
+  underline: Object.freeze({ kind: "style", open: [SGR_UNDERLINE] }),
+  inverse: Object.freeze({ kind: "style", open: [SGR_INVERSE] }),
+  hidden: Object.freeze({ kind: "style", open: [SGR_HIDDEN] }),
+  strikethrough: Object.freeze({ kind: "style", open: [SGR_STRIKETHROUGH] })
+};
+const STYLE_KEYS = Object.freeze(
+  /* @__PURE__ */ new Set([
+    "reset",
+    "bold",
+    "dim",
+    "italic",
+    "underline",
+    "inverse",
+    "hidden",
+    "strikethrough"
+  ])
+);
+const COLOR_KEYS = Object.freeze(new Set(Object.keys(NAMED_COLORS)));
+const BRIGHT_COLOR_KEYS = Object.freeze(
+  new Set(Object.keys(NAMED_COLORS).map((name) => `${name}Bright`))
+);
+const BG_COLOR_KEYS = Object.freeze(
+  new Set(
+    Object.keys(NAMED_COLORS).map(
+      (name) => `bg${name[0]?.toUpperCase()}${name.slice(1)}`
+    )
+  )
+);
+const BG_BRIGHT_COLOR_KEYS = Object.freeze(
+  new Set(
+    Object.keys(NAMED_COLORS).map(
+      (name) => `bg${name[0]?.toUpperCase()}${name.slice(1)}Bright`
+    )
+  )
+);
+const isColorKey = (key) => COLOR_KEYS.has(key) || BRIGHT_COLOR_KEYS.has(key);
+const isBgKey = (key) => {
+  const len = key.length;
+  if (len <= BG_PREFIX_LENGTH || key[0] !== "b" || key[1] !== "g") {
+    return false;
+  }
+  return BG_COLOR_KEYS.has(key) || BG_BRIGHT_COLOR_KEYS.has(key);
+};
+const proxyCache = /* @__PURE__ */ new WeakMap();
+const callableProxy = (ops) => {
+  const cached = proxyCache.get(ops);
+  if (cached) return cached;
+  const base = ((input) => applyOpsToText(ops, input));
+  Object.defineProperty(base, OP_SYMBOL, {
+    value: ops,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  const proxy = new Proxy(base, {
+    apply(_target, _thisArg, argArray) {
+      return applyOpsToText(ops, argArray[0]);
+    },
+    get(_target, prop) {
+      if (prop === OP_SYMBOL) return ops;
+      const key = String(prop);
+      if (STYLE_KEYS.has(key)) {
+        const op = STYLE_TABLE[key];
+        const newOps = [...ops, op];
+        return callableProxy(newOps);
+      }
+      if (isBgKey(key)) {
+        const colorName = key[2]?.toLowerCase() + key.slice(3);
+        const { rgb, wantBright } = parseColorName(colorName);
+        const bgOps = mkBgOpsFromRgb(rgb, wantBright);
+        const newOps = [...ops, ...bgOps];
+        return callableProxy(newOps);
+      }
+      if (isColorKey(key)) {
+        const { rgb, wantBright } = parseColorName(key);
+        const fgOps = mkFgOpsFromRgb(rgb, wantBright);
+        const newOps = [...ops, ...fgOps];
+        return callableProxy(newOps);
+      }
+      return proxy;
+    }
+  });
+  proxyCache.set(ops, proxy);
+  return proxy;
+};
+export const re = callableProxy([]);
+export const chain = (...parts) => {
+  if (parts.length === 0) return re;
+  if (parts.length === 1) return parts[0];
+  const collected = [];
+  for (let i = 0; i < parts.length; i++) {
+    const ops = parts[i][OP_SYMBOL];
+    if (ops?.length) {
+      collected.push(...ops);
+    }
+  }
+  return callableProxy(collected);
+};
+export const color = (input, isBg = false) => {
+  if (!IS_BUN) {
+    if (typeof input === "object" && "r" in input && "g" in input && "b" in input) {
+      const ops2 = isBg ? mkBgOpsFromRgb(input, false) : mkFgOpsFromRgb(input, false);
+      return callableProxy(ops2);
+    }
+    return re;
+  }
+  const rgb = Bun.color(input, "{rgb}");
+  if (!rgb) return re;
+  const ops = isBg ? mkBgOpsFromRgb(rgb, false) : mkFgOpsFromRgb(rgb, false);
+  return callableProxy(ops);
+};

package/package.json

@@ -1,25 +1,22 @@
 {
   "name": "@reliverse/relico",
-  "author": "reliverse",
-  "version": "1.4.1",
+  "version": "2.2.7",
+  "private": false,
   "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.",
-  "scripts": {
-    "pub": "bun rse publish",
-    "dev": "bun examples/core.ts",
-    "perf": "bun bench && bun size",
-    "latest": "bun rse update && bun install",
-    "size": "bun examples/benchmarks/bundle-size.ts",
-    "bench": "bun examples/benchmarks/performance.ts",
-    "check": "bun tsc --noEmit && bun biome check --fix --unsafe"
+  "exports": {
+    ".": {
+      "types": "./dist/mod.d.ts",
+      "default": "./dist/mod.js"
+    }
   },
-  "devDependencies": {
-    "@biomejs/biome": "2.2.2",
-    "@reliverse/rse": "^1.7.27",
-    "@total-typescript/ts-reset": "^0.6.1",
-    "@types/bun": "^1.2.21",
-    "@types/node": "^24.3.0",
-    "typescript": "^5.9.2",
-    "ultracite": "^5.2.17"
-  }
-}
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {},
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "license": "MIT"
+}