@reliverse/relico 1.4.2 → 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

@@ -48,4 +48,13 @@ 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

@@ -1,6 +1,5 @@
-const ESC = "\x1B[";
-const RESET = `${ESC}0m`;
-const OP_SYMBOL = Symbol("re.ops");
+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;
@@ -30,17 +29,12 @@ const SGR_UNDERLINE = 4;
 const SGR_INVERSE = 7;
 const SGR_HIDDEN = 8;
 const SGR_STRIKETHROUGH = 9;
-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;
 const BRIGHT_SUFFIX_LENGTH = 6;
 const BG_PREFIX_LENGTH = 2;
-const BG_COLOR_START = 3;
 const BRIGHT_MIX_FACTOR = 0.25;
-const BRIGHT_SUFFIX_REGEX = /Bright$/u;
+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) {
@@ -49,44 +43,55 @@ export const setColorLevel = (level) => {
   CURRENT_LEVEL = level;
 };
 const clampByte = (n) => {
-  if (!Number.isFinite(n)) {
-    return MIN_BYTE;
-  }
-  if (n < MIN_BYTE) {
-    return MIN_BYTE;
-  }
-  if (n > MAX_BYTE) {
-    return MAX_BYTE;
-  }
+  if (n <= MIN_BYTE || !Number.isFinite(n)) return MIN_BYTE;
+  if (n >= MAX_BYTE) return MAX_BYTE;
   return Math.round(n);
 };
-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 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 < BASIC8.length; i++) {
+  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;
@@ -96,22 +101,27 @@ const nearestBasicIndex = (rgb) => {
   return best;
 };
 const rgbToAnsi256 = (rgb) => {
-  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;
+  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 = 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;
+  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",
@@ -134,57 +144,70 @@ const NAMED_COLORS = {
   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 t = factor;
+  const invFactor = 1 - 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)
+    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 || typeof hex !== "string") {
-    return { r: 0, g: 0, b: 0 };
-  }
-  const clean = hex.startsWith("#") ? hex.slice(1) : hex;
-  if (clean.length !== HEX_BLUE_END && clean.length !== 3) {
-    return { r: 0, g: 0, b: 0 };
+  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;
+    }
   }
-  let rHex, gHex, bHex;
-  if (clean.length === 3) {
-    rHex = clean[0].repeat(2);
-    gHex = clean[1].repeat(2);
-    bHex = clean[2].repeat(2);
+  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 {
-    rHex = clean.slice(HEX_RED_START, HEX_BYTE_LENGTH);
-    gHex = clean.slice(HEX_GREEN_START, HEX_BLUE_START);
-    bHex = clean.slice(HEX_BLUE_START, HEX_BLUE_END);
+    return { r: 0, g: 0, b: 0 };
   }
-  const r = Number.parseInt(rHex, HEX_RADIX);
-  const g = Number.parseInt(gHex, HEX_RADIX);
-  const b = Number.parseInt(bHex, HEX_RADIX);
   if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) {
     return { r: 0, g: 0, b: 0 };
   }
-  return { r, g, b };
+  const result = Object.freeze({ r, g, b });
+  rgbCache.set(name, result);
+  return result;
 };
 const toBaseName = (compound) => {
-  if (!compound || typeof compound !== "string") {
-    return "black";
-  }
-  const base = compound.replace(BRIGHT_SUFFIX_REGEX, "");
-  if (!base) {
-    return "black";
-  }
-  const key = base.charAt(0).toLowerCase() + base.slice(1);
-  return key;
+  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 || typeof name !== "string") {
-    return { rgb: { r: 0, g: 0, b: 0 }, wantBright: false };
-  }
-  if (name.endsWith("Bright")) {
+  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);
@@ -193,63 +216,110 @@ const parseColorName = (name) => {
   return { rgb: fromNamed(name), wantBright: false };
 };
 const openForOp = (op) => {
-  if (CURRENT_LEVEL === COLOR_LEVEL_OFF) {
-    return "";
-  }
+  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`;
+    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 "";
-  }
-  let out = "";
-  for (const op of ops) {
-    out += openForOp(op);
+  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 out;
+  return result;
 };
 const applyOpsToText = (ops, input) => {
   const text = String(input);
-  if (CURRENT_LEVEL === COLOR_LEVEL_OFF || ops.length === 0 || text.length === 0) {
+  const textLen = text.length;
+  if (CURRENT_LEVEL === COLOR_LEVEL_OFF || ops.length === 0 || textLen === 0) {
     return text;
   }
   const open = opsToOpen(ops);
-  if (!text.includes("\n")) {
+  if (!open) return text;
+  const nlIdx = text.indexOf("\n");
+  if (nlIdx === -1) {
     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}`;
+  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[i] = `${open}${line}${RESET}`;
+      result += `${open}${RESET}`;
     }
+    start = end + 1;
   }
-  return result.join("\n");
+  return result;
 };
 const mkFgOpsFromRgb = (rgb, wantBright = false) => {
   if (CURRENT_LEVEL === COLOR_LEVEL_BASIC) {
-    const idx = nearestBasicIndex(rgb);
-    return [{ kind: "fg-basic", idx, bright: wantBright }];
+    return [
+      { kind: "fg-basic", idx: nearestBasicIndex(rgb), bright: wantBright }
+    ];
   }
   if (CURRENT_LEVEL === COLOR_LEVEL_256) {
     return [{ kind: "fg-256", code: rgbToAnsi256(rgb) }];
@@ -258,8 +328,9 @@ const mkFgOpsFromRgb = (rgb, wantBright = false) => {
 };
 const mkBgOpsFromRgb = (rgb, wantBright = false) => {
   if (CURRENT_LEVEL === COLOR_LEVEL_BASIC) {
-    const idx = nearestBasicIndex(rgb);
-    return [{ kind: "bg-basic", idx, bright: wantBright }];
+    return [
+      { kind: "bg-basic", idx: nearestBasicIndex(rgb), bright: wantBright }
+    ];
   }
   if (CURRENT_LEVEL === COLOR_LEVEL_256) {
     return [{ kind: "bg-256", code: rgbToAnsi256(rgb) }];
@@ -267,46 +338,57 @@ const mkBgOpsFromRgb = (rgb, wantBright = false) => {
   return [{ kind: "bg-true", rgb }];
 };
 const STYLE_TABLE = {
-  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] }
-};
-const STYLE_KEYS = /* @__PURE__ */ new Set([
-  "reset",
-  "bold",
-  "dim",
-  "italic",
-  "underline",
-  "inverse",
-  "hidden",
-  "strikethrough"
-]);
-const isColorKey = (key) => {
-  if (!key || typeof key !== "string") {
-    return false;
-  }
-  if (key in NAMED_COLORS) {
-    return true;
-  }
-  if (key.endsWith("Bright") && key.length > BRIGHT_SUFFIX_LENGTH) {
-    const baseName = key.slice(0, -BRIGHT_SUFFIX_LENGTH);
-    return baseName in NAMED_COLORS;
-  }
-  return false;
+  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) => {
-  if (!key || typeof key !== "string" || !key.startsWith("bg") || key.length <= BG_PREFIX_LENGTH) {
+  const len = key.length;
+  if (len <= BG_PREFIX_LENGTH || key[0] !== "b" || key[1] !== "g") {
     return false;
   }
-  const colorPart = key.charAt(BG_PREFIX_LENGTH).toLowerCase() + key.slice(BG_COLOR_START);
-  return isColorKey(colorPart);
+  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,
@@ -314,47 +396,60 @@ const callableProxy = (ops) => {
     configurable: false,
     writable: false
   });
-  return new Proxy(base, {
+  const proxy = new Proxy(base, {
     apply(_target, _thisArg, argArray) {
-      const [input] = argArray;
-      return applyOpsToText(ops, input);
+      return applyOpsToText(ops, argArray[0]);
     },
     get(_target, prop) {
+      if (prop === OP_SYMBOL) return ops;
       const key = String(prop);
-      if (prop === OP_SYMBOL) {
-        return ops;
-      }
       if (STYLE_KEYS.has(key)) {
         const op = STYLE_TABLE[key];
-        return callableProxy([...ops, op]);
+        const newOps = [...ops, op];
+        return callableProxy(newOps);
       }
       if (isBgKey(key)) {
-        const raw = key.slice(BG_PREFIX_LENGTH);
-        if (!raw) {
-          return callableProxy(ops);
-        }
-        const colorName = raw.charAt(0).toLowerCase() + raw.slice(1);
+        const colorName = key[2]?.toLowerCase() + key.slice(3);
         const { rgb, wantBright } = parseColorName(colorName);
-        return callableProxy([...ops, ...mkBgOpsFromRgb(rgb, wantBright)]);
+        const bgOps = mkBgOpsFromRgb(rgb, wantBright);
+        const newOps = [...ops, ...bgOps];
+        return callableProxy(newOps);
       }
       if (isColorKey(key)) {
         const { rgb, wantBright } = parseColorName(key);
-        return callableProxy([...ops, ...mkFgOpsFromRgb(rgb, wantBright)]);
+        const fgOps = mkFgOpsFromRgb(rgb, wantBright);
+        const newOps = [...ops, ...fgOps];
+        return callableProxy(newOps);
       }
-      return callableProxy(ops);
+      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 (const p of parts) {
-    const ops = p[OP_SYMBOL];
-    if (ops && ops.length > 0) {
-      for (const op of ops) {
-        collected.push(op);
-      }
+  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,7 +1,7 @@
 {
   "name": "@reliverse/relico",
-  "author": "reliverse",
-  "version": "1.4.2",
+  "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.",
   "exports": {
@@ -10,12 +10,13 @@
       "default": "./dist/mod.js"
     }
   },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {},
   "files": [
     "dist",
     "package.json"
   ],
-  "publishConfig": {
-    "access": "public"
-  },
   "license": "MIT"
 }

package/LICENSE

@@ -1,21 +0,0 @@
-# MIT License
-
-Copyright (c) Nazar Kornienko (blefnk), Bleverse, Reliverse
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.