@reliverse/relico 2.2.9 → 2.3.2

package/README.md

@@ -1,366 +1,134 @@
-# Reliverse Relico
-
-> @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/relico)
-
-## Why Relico?
-
-Because terminal styling shouldn't feel like duct tape. **Relico** brings design-system-level polish to your CLI logs, banners, errors, and output — without battling your runtime, shell, or platform. Terminal styling should be *fun*, not frustrating. Relico makes it feel *right*.
-
-- ⚡ **Blazing-fast & lightweight** — type-safe, runtime-safe, build-time aware, zero bloat, zero dependencies, zero configuration
-- 🎨 **80+ built-in colors** — easily customize or override with your own [`HEX`](https://chatgpt.com/share/67fd24cd-e7b0-8008-a815-f33d01f33758) palette
-- 🧩 **Themeable by default** — end-users can configure themes+typography+colors via `relico.config.ts`, developers via `await initUserConfig({ ... })`
-- 🌈 **Smart color detection** — full support for truecolor (16M), 256-color, and fallback modes across environments
-- 🦄 **A modern alternative** to `chalk`, `kleur`, `colorette`, `gradient-string`, and legacy console hacks
-- 🧠 **Typed, chainable, DX-optimized** — with autocompletion, inline docs, and expressive API ergonomics
-- 🌿 **Respects your environment** — including `NO_COLOR`, `FORCE_COLOR`, and terminal capabilities
-- 🛡️ **Cross-platform & runtime-ready** — works everywhere — even when your users' terminals are weird — in Node.js, Bun, Deno, CI, Windows, macOS, Linux, Docker & more
-- 🎯 **Precision-crafted ANSI output** — every color, reset, and style code is finely tuned for contrast, legibility, and glitch-free rendering — even in flaky terminals (as far as Node.js permits)
-- 🦾 **Relico isn't just about color** — it's about communication — make your CLI users' output more than readable — make it feel *intentional*.
-
-<img src="./example/example.png" width="50%" alt="Available Relico colors" />
-
-## Installation
-
-```bash
-bun add @reliverse/relico
-# bun • pnpm • yarn • npm
-```
-
-## Performance
-
-```bash
-$ bun bench
-$ bun examples/benchmarks/performance.ts
-
-🚀 Relico Performance Benchmarks
-==================================================
-C:/B/R/reliverse/relico/dist-npm/bin/mod.js
-
-Basic color access: 107.02ms (934 379 ops/sec)
-Chained colors: 191.49ms (522 227 ops/sec)
-RGB color creation: 73.79ms (1 355 276 ops/sec)
-Hex color creation: 87.73ms (1 139 866 ops/sec)
-HSL color creation: 78.10ms (1 280 444 ops/sec)
-Chain function: 226.13ms (442 219 ops/sec)
-Background colors: 208.55ms (479 492 ops/sec)
-Bright colors: 124.96ms (800 282 ops/sec)
-Pastel colors: 126.03ms (793 446 ops/sec)
-Multiline text (small): 165.08ms (605 769 ops/sec)
-Multiline text (large): 1089.44ms (91 790 ops/sec)
-
-Bundle Size Test:
-Core exports imported: 5
-```
-
-```bash
-$ bun size
-$ bun examples/benchmarks/bundle-size.ts
-
-📦 Bundle Size Analysis
-==============================
-C:/B/R/reliverse/relico/dist-npm/bin/mod.js
-
-Size:
-- File size: 12.9KB
-- Declaration file size: 2.9KB
-- Total bundle size: 15.8KB
-
-Breakdown:
-- Color data: 554B (4.2%)
-- Logic: 12.4KB (95.8%)
-```
-
-## 🔥 Important Notice
-
-Relico (v1.3.0+) was recently rewritten from scratch:
-
-- To have zero dependencies and zero configuration
-- Include only the really necessary for daily usage features
-- To be as fast as possible
-
-Some missing important features may be added back in the coming future.
-
-This means everything or most of the things described below in this readme may be different now.
-
-The readme will be updated soon.
-
-## Configuration
-
-**If you're end-user OR developer, create `relico.config.ts` in your root**:
-
-```ts
-import { defineConfig } from "@reliverse/relico";
-
-export default defineConfig({
-  colorLevel: 3, // 0 = off, 1 = basic, 2 = 256, 3 = truecolor
-  theme: "primary", // or "secondary"
-  customColors: {
-    // ["primary", "secondary"]:
-    blue: ["#5f87ff", "#5f87ff"],
-    red: ["#ff5555", "#ff0000"],
-    green: ["#00ff00", "#00cc00"],
-  },
-});
-```
-
-**If you're developer, initialize in your app (optional)**:
-
-```ts
-import { initUserConfig, re } from "@reliverse/relico";
-
-// Use this to override Relico's 
-// default settings for your app
-// (relico.config.ts takes precedence)
-await initUserConfig({ ... });
-console.log(re.info("Custom config loaded!"));
-```
-
-## API Sneak Peek
-
-```ts
-import { re, rgb } from "@reliverse/relico";
-
-console.log(re.red("Red!"));
-console.log(re.bold(re.green("Bold green")));
-
-console.log(rgb(250, 128, 114)("This is salmon"));
-```
-
-## Styles Available
-
-### Text Colors
-
-- `re.red("...")`, `re.blue("...")`, `re.greenBright("...")`, ...
-- `re.gray("...")`, `re.whiteBright("...")`
-
-### Backgrounds
-
-- `re.bgRed("...")`, `re.bgBlueBright("...")`, ...
-
-### Text Effects
-
-- `re.bold("...")`, `re.italic("...")`, `re.strikethrough("...")`, ...
-
-All styles are **composable**:
-
-```ts
-// Classic way:
-re.bold(re.bgBlue(re.white("YEP!")));
-// Chained way (recommended):
-const boldRed = chain(re.bold, re.red); // go to "chain() Function Examples" section to learn more
-console.log(boldRed("This text is bold and red"));
-```
-
-### Supported Colors, Backgrounds & Modifiers
-
-| **Modifiers**   | **Base Colors**   | **Bright Colors** | **Pastel Colors** | **Extra Colors** | **Grayscale**     | **Backgrounds** | **Bright Backgrounds** | **Pastel Backgrounds** | **Extra Backgrounds** |
-|---------------- |------------------ |------------------ |------------------ |------------------|------------------ |-----------------|----------------------- |----------------------- |---------------------- |
-| `reset`         | `black`           | `blackBright`     | `redPastel`       | `orange`         | `gray10`          | `bgBlack`       | `bgBlackBright`        | `bgRedPastel`          | `bgOrange`            |
-| `bold`          | `red`             | `redBright`       | `greenPastel`     | `pink`           | `gray20`          | `bgRed`         | `bgRedBright`          | `bgGreenPastel`        | `bgPink`              |
-| `dim`           | `green`           | `greenBright`     | `yellowPastel`    | `purple`         | `gray30`          | `bgGreen`       | `bgGreenBright`        | `bgYellowPastel`       | `bgPurple`            |
-| `italic`        | `yellow`          | `yellowBright`    | `bluePastel`      | `teal`           | `gray40`          | `bgYellow`      | `bgYellowBright`       | `bgBluePastel`         | `bgTeal`              |
-| `underline`     | `blue`            | `blueBright`      | `magentaPastel`   | `lime`           | `gray50`===`gray` | `bgBlue`        | `bgBlueBright`         | `bgMagentaPastel`      | `bgLime`              |
-| `inverse`       | `magenta`         | `magentaBright`   | `cyanPastel`      | `brown`          | `gray60`          | `bgMagenta`     | `bgMagentaBright`      | `bgCyanPastel`         | `bgBrown`             |
-| `strikethrough` | `cyan`            | `cyanBright`      |                   | `navy`           | `gray70`          | `bgCyan`        | `bgCyanBright`         |                        | `bgNavy`              |
-| `hidden`        | `white`           | `whiteBright`     |                   | `maroon`         | `gray80`          | `bgWhite`       | `bgWhiteBright`        |                        | `bgMaroon`            |
-|                 | `gray`===`gray50` |                   |                   | `olive`          | `gray90`          |                 |                        |                        | `bgOlive`             |
-|                 |                   |                   |                   | `olive`          |                   |                 |                        |                        | `bgSilver`            |
-
-### Want to Get Only Certain Colors?
-
-```ts
-import type { DefaultColorKeys } from "@reliverse/relico";
-const brandColors: DefaultColorKeys[] = ["magentaBright", "maroon"];
-```
-
-## Color Detection
-
-Relico detects your terminal's capability:
-
-```ts
-import { colorSupport } from "@reliverse/relico";
-
-console.log(colorSupport.terminalName); // iTerm2, Windows Terminal, etc.
-console.log(colorSupport.level); // 0, 1, 2, or 3
-```
-
-**Supports**:
-
-- `NO_COLOR`
-- `FORCE_COLOR=1` (or 0/2/3)
-
-## Advanced Features
-
-### Custom RGB + Hex
-
-```ts
-import { rgb, bgHex, hex } from "@reliverse/relico";
-
-console.log(rgb(255, 105, 180)("Hot pink"));
-console.log(bgHex("#1e90ff")("Dodger blue background"));
-```
-
-### Gradients & Rainbow
-
-```ts
-import { gradient, multiGradient, rainbow } from "@reliverse/relico";
-
-console.log(rainbow("🎉 Woohoo!"));
-console.log(gradient("From red to blue", "#ff0000", "#0000ff"));
-```
-
-## `chain()` Function
-
-This function allows you to combine multiple color formatters into a single formatter function. This is useful for creating complex styles that apply multiple effects to text.
-
-## Basic Usage
-
-```typescript
-import { re, chain } from "@reliverse/relico";
-
-// Create a custom style that combines bold and red text
-const boldRed = chain(re.bold, re.red);
-console.log(boldRed("This text is bold and red"));
-
-// Create a warning style with yellow text on a dark background
-const warning = chain(re.yellow, re.bgBlack);
-console.log(warning("Warning: This operation might take a while"));
-
-// Chain three or more styles
-const importantError = chain(re.bold, re.underline, re.red);
-console.log(importantError("CRITICAL ERROR: System failure"));
-```
-
-## Creating Theme Combinations
-
-```typescript
-import { re, chain } from "@reliverse/relico";
-
-// Create themed message styles
-const successStyle = chain(re.bold, re.green);
-const errorStyle = chain(re.bold, re.red);
-const infoStyle = chain(re.blue, re.italic);
-const warnStyle = chain(re.yellow, re.bold);
-
-// Use them in your application
-console.log(successStyle("✓ Operation completed successfully"));
-console.log(errorStyle("✗ Failed to connect to server"));
-console.log(infoStyle("ℹ Running in development mode"));
-console.log(warnStyle("⚠ API rate limit approaching"));
-```
-
-## Custom RGB Combinations
-
-```typescript
-import { re, rgb, bgRgb, chain } from "@reliverse/relico";
-
-// Create a custom color scheme with RGB values
-const customHeader = chain(
-  rgb(255, 105, 180), // Hot pink text
-  bgRgb(25, 25, 25)   // Dark gray background
-);
-
-// Create a "danger" style with custom red and bold
-const danger = chain(
-  rgb(220, 20, 60),   // Crimson text
-  re.bold,
-  re.underline
-);
-
-console.log(customHeader(" SYSTEM STATUS "));
-console.log(danger("Danger: High voltage detected!"));
-```
-
-## Multiline Text Handling
-
-The `chain()` function automatically handles multiline text to prevent style leakage:
-
-```typescript
-import { re, chain } from "@reliverse/relico";
-
-const highlight = chain(re.bgYellow, re.black, re.bold);
-
-const multilineText = `This is line one
-This is line two
-This is line three`;
-
-// Each line is properly wrapped with start/end codes
-console.log(highlight(multilineText));
-```
-
-## Creating a Simple Logger
-
-```typescript
-import { re, chain } from "@reliverse/relico";
-
-// Create logger styles
-const styles = {
-  info: chain(re.blue, re.bold),
-  success: chain(re.green, re.bold),
-  warning: chain(re.yellow, re.bold),
-  error: chain(re.red, re.bold),
-  debug: chain(re.magenta, re.dim)
-};
-
-// Simple logger implementation
-const logger = {
-  info: (msg) => console.log(styles.info("INFO"), msg),
-  success: (msg) => console.log(styles.success("SUCCESS"), msg),
-  warning: (msg) => console.log(styles.warning("WARNING"), msg),
-  error: (msg) => console.log(styles.error("ERROR"), msg),
-  debug: (msg) => console.log(styles.debug("DEBUG"), msg)
-};
-
-// Usage
-logger.info("Application started");
-logger.success("Data loaded successfully");
-logger.warn("Cache expired, refreshing data");
-logger.error("Failed to connect to database");
-logger.debug("Request payload: " + JSON.stringify({id: 123}));
-```
-
-This allows you to create powerful, reusable style combinations for your terminal applications.
-
-## Local Playground
-
-```bash
-git clone https://github.com/reliverse/relico
-cd relico
-bun i
-bun dev
-```
-
-Check `example/e-mod.ts` for all the fun.
-
-## Use Cases
-
-- Beautiful CLI banners & success/error messages
-- Colored logger outputs
-- DX-enhanced terminal tools
-- Custom internal design systems for CLIs
-
-## Related
-
-- [`chalk`](https://github.com/chalk/chalk) — the classic
-- [`kleur`](https://github.com/lukeed/kleur) — performance-driven
-- [`colorette`](https://github.com/jorgebucaran/colorette) — super tiny
-
-Relico draws inspiration from all — and goes beyond them with modern configs, types, theming, and composability.
-
-## 🛠 Contributing
-
-We'd love your help! Bug? Feature? Example? PR it!  
-Or hop into [Discord](https://discord.gg/Pb8uKbwpsJ) to discuss CLI theming and terminal art 💜
-
-```bash
-git clone https://github.com/reliverse/relico
-cd relico
-bun i
-```
-
-## License
-
-MIT © [blefnk Nazar Kornienko](https://github.com/blefnk)  
-Part of the [Reliverse](https://github.com/reliverse) ecosystem
+# Reliverse Relico
+
+> @reliverse/relico is a simple, lightweight terminal styling toolkit with basic ANSI color support — built for simplicity and reliability.
+
+[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?
+
+**Relico** provides essential terminal styling with a focus on simplicity and zero configuration. It gives you basic ANSI colors and text styles for CLI output without the complexity.
+
+- ⚡ **Lightweight & simple** — type-safe, zero dependencies, zero configuration
+- 🎨 **Basic ANSI colors** — foreground, background, and bright color variants
+- 🧠 **Typed API** — with autocompletion and inline docs
+- 🌿 **Respects your environment** — honors `NO_COLOR` and TTY detection
+- 🛡️ **Cross-platform** — works in Node.js, Bun, and other JavaScript runtimes
+
+<img src="./example/example.png" width="50%" alt="Available Relico colors" />
+
+## Installation
+
+```bash
+bun add @reliverse/relico
+# bun • pnpm • yarn • npm
+```
+
+## Usage
+
+```ts
+import { relico } from "@reliverse/relico";
+
+console.log(relico.red("Red text"));
+console.log(relico.bold(relico.green("Bold green text")));
+console.log(relico.bgBlue(relico.white("White text on blue background")));
+```
+
+## Available Colors & Styles
+
+### Text Colors
+
+- `rc.red("...")`, `rc.blue("...")`, `rc.green("...")`
+- `rc.brightRed("...")`, `rc.brightBlue("...")`, `rc.brightGreen("...")`
+- `rc.black("...")`, `rc.white("...")`, `rc.gray("...")`
+
+### Background Colors
+
+- `rc.bgRed("...")`, `rc.bgBlue("...")`, `rc.bgGreen("...")`
+- `rc.bgYellow("...")`, `rc.bgMagenta("...")`, `rc.bgCyan("...")`
+- `rc.bgWhite("...")`
+
+### Text Styles
+
+- `rc.bold("...")`, `rc.dim("...")`, `rc.italic("...")`
+- `rc.underline("...")`, `rc.strikethrough("...")`
+
+### Utilities
+
+- `rc.reset("...")` - reset all styling
+- `rc.strip(text)` - remove ANSI codes from text
+
+Styles can be combined:
+
+```ts
+// Combine styles by nesting function calls:
+console.log(relico.bold(relico.bgRed(relico.white("Warning!"))));
+```
+
+### Available Colors & Backgrounds
+
+| **Text Colors** | **Bright Colors** | **Backgrounds** |
+| --------------- | ----------------- | --------------- |
+| `black`         | `brightRed`       | `bgRed`         |
+| `red`           | `brightGreen`     | `bgGreen`       |
+| `green`         | `brightYellow`    | `bgYellow`      |
+| `yellow`        | `brightBlue`      | `bgBlue`        |
+| `blue`          | `brightMagenta`   | `bgMagenta`     |
+| `magenta`       | `brightCyan`      | `bgCyan`        |
+| `cyan`          | `brightWhite`     | `bgWhite`       |
+| `white`         |                   |                 |
+| `gray`          |                   |                 |
+
+## Environment Support
+
+Relico respects standard environment variables:
+
+- `NO_COLOR` - disables all colors when set
+- Automatic TTY detection - colors are disabled when not in a terminal
+
+## Development
+
+This package is part of the Dler monorepo. To work with it locally:
+
+```bash
+# Clone the monorepo
+git clone https://github.com/reliverse/dler
+cd dler
+
+# Install dependencies
+bun install
+
+# Build the package
+cd packages/relico
+bun run build
+```
+
+## Use Cases
+
+- Beautiful CLI banners & success/error messages
+- Colored logger outputs
+- DX-enhanced terminal tools
+- Custom internal design systems for CLIs
+
+## Related
+
+- [`chalk`](https://github.com/chalk/chalk) — the classic
+- [`kleur`](https://github.com/lukeed/kleur) — performance-driven
+- [`colorette`](https://github.com/jorgebucaran/colorette) — super tiny
+
+Relico draws inspiration from all — and goes beyond them with modern configs, types, theming, and composability.
+
+## 🛠 Contributing
+
+We'd love your help! Bug? Feature? Example? PR it!  
+Or hop into [Discord](https://discord.gg/Pb8uKbwpsJ) to discuss CLI theming and terminal art 💜
+
+```bash
+git clone https://github.com/reliverse/relico
+cd relico
+bun i
+```
+
+## License
+
+MIT © [blefnk Nazar Kornienko](https://github.com/blefnk)  
+Part of the [Reliverse](https://github.com/reliverse) ecosystem

package/dist/mod.d.ts

@@ -1,60 +1,3 @@
-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 {};
+import type { Colors } from "./types.js";
+export declare const relico: Colors;
+export declare const re: Colors;

package/dist/mod.js

@@ -1,455 +1,85 @@
-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);
-      }
+const colorCodes = {
+  // Foreground colors
+  black: 30,
+  red: 31,
+  green: 32,
+  yellow: 33,
+  blue: 34,
+  magenta: 35,
+  cyan: 36,
+  white: 37,
+  gray: 90,
+  // Bright foreground colors
+  brightRed: 91,
+  brightGreen: 92,
+  brightYellow: 93,
+  brightBlue: 94,
+  brightMagenta: 95,
+  brightCyan: 96,
+  brightWhite: 97,
+  // Background colors
+  bgRed: 41,
+  bgGreen: 42,
+  bgYellow: 43,
+  bgBlue: 44,
+  bgMagenta: 45,
+  bgCyan: 46,
+  bgWhite: 47,
+  // Styles
+  bold: 1,
+  dim: 2,
+  italic: 3,
+  underline: 4,
+  strikethrough: 9,
+  // Reset
+  reset: 0
+};
+function createColorFunction(code) {
+  return (text) => {
+    if (!process.stdout.isTTY || process.env.NO_COLOR) {
+      return text;
     }
-  }
-  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)
+    return `\x1B[${code}m${text}\x1B[0m`;
   };
-};
-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);
-};
+}
+function stripAnsi(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "");
+}
+export const relico = {
+  // Basic colors
+  black: createColorFunction(colorCodes.black),
+  red: createColorFunction(colorCodes.red),
+  green: createColorFunction(colorCodes.green),
+  yellow: createColorFunction(colorCodes.yellow),
+  blue: createColorFunction(colorCodes.blue),
+  magenta: createColorFunction(colorCodes.magenta),
+  cyan: createColorFunction(colorCodes.cyan),
+  white: createColorFunction(colorCodes.white),
+  gray: createColorFunction(colorCodes.gray),
+  // Bright colors
+  brightRed: createColorFunction(colorCodes.brightRed),
+  brightGreen: createColorFunction(colorCodes.brightGreen),
+  brightYellow: createColorFunction(colorCodes.brightYellow),
+  brightBlue: createColorFunction(colorCodes.brightBlue),
+  brightMagenta: createColorFunction(colorCodes.brightMagenta),
+  brightCyan: createColorFunction(colorCodes.brightCyan),
+  brightWhite: createColorFunction(colorCodes.brightWhite),
+  // Background colors
+  bgRed: createColorFunction(colorCodes.bgRed),
+  bgGreen: createColorFunction(colorCodes.bgGreen),
+  bgYellow: createColorFunction(colorCodes.bgYellow),
+  bgBlue: createColorFunction(colorCodes.bgBlue),
+  bgMagenta: createColorFunction(colorCodes.bgMagenta),
+  bgCyan: createColorFunction(colorCodes.bgCyan),
+  bgWhite: createColorFunction(colorCodes.bgWhite),
+  // Styles
+  bold: createColorFunction(colorCodes.bold),
+  dim: createColorFunction(colorCodes.dim),
+  italic: createColorFunction(colorCodes.italic),
+  underline: createColorFunction(colorCodes.underline),
+  strikethrough: createColorFunction(colorCodes.strikethrough),
+  // Utilities
+  reset: createColorFunction(colorCodes.reset),
+  strip: stripAnsi
+};
+export const re = relico;

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+export type ColorFunction = (text: string) => string;
+export interface Colors {
+    black: ColorFunction;
+    red: ColorFunction;
+    green: ColorFunction;
+    yellow: ColorFunction;
+    blue: ColorFunction;
+    magenta: ColorFunction;
+    cyan: ColorFunction;
+    white: ColorFunction;
+    gray: ColorFunction;
+    brightRed: ColorFunction;
+    brightGreen: ColorFunction;
+    brightYellow: ColorFunction;
+    brightBlue: ColorFunction;
+    brightMagenta: ColorFunction;
+    brightCyan: ColorFunction;
+    brightWhite: ColorFunction;
+    bgRed: ColorFunction;
+    bgGreen: ColorFunction;
+    bgYellow: ColorFunction;
+    bgBlue: ColorFunction;
+    bgMagenta: ColorFunction;
+    bgCyan: ColorFunction;
+    bgWhite: ColorFunction;
+    bold: ColorFunction;
+    dim: ColorFunction;
+    italic: ColorFunction;
+    underline: ColorFunction;
+    strikethrough: ColorFunction;
+    reset: ColorFunction;
+    strip: (text: string) => string;
+}

package/package.json

@@ -1,22 +1,48 @@
 {
   "name": "@reliverse/relico",
-  "version": "2.2.9",
-  "private": false,
+  "version": "2.3.2",
+  "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.",
+  "keywords": [
+    "cli",
+    "prompts",
+    "rempts",
+    "spinner",
+    "terminal",
+    "utilities"
+  ],
+  "homepage": "https://github.com/reliverse/dler#readme",
+  "bugs": {
+    "url": "https://github.com/reliverse/dler/issues"
+  },
+  "license": "MIT",
+  "author": "blefnk",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/reliverse/dler.git",
+    "directory": "packages/utils"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
   "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.",
+  "module": "./dist/mod.js",
+  "types": "./dist/mod.d.ts",
   "exports": {
     ".": {
       "types": "./dist/mod.d.ts",
-      "default": "./dist/mod.js"
+      "import": "./dist/mod.js"
     }
   },
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {},
-  "files": [
-    "dist",
-    "package.json"
-  ],
-  "license": "MIT"
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0",
+    "@standard-schema/utils": "^0.3.0"
+  },
+  "engines": {
+    "bun": ">=1.3.5"
+  }
 }