colorino 0.12.7 → 0.13.0

package/README.md

@@ -20,12 +20,13 @@ Colorino automatically adapts its palette to your terminal or browser DevTools t
     - [Examples](#5-3-2)
   - [Customization](#5-4)
   - [Supported Environment Variables](#5-5)
+  - [Colorize Helper (Manual Overrides)](#5-6)
 - [Colorino vs. Chalk](#6)
 - [API Reference](#7)
   - [1. `colorino` (default instance)](#7-1)
   - [2. `createColorino(palette?, options?)` (factory)](#7-2)
 - [Extending Colorino](#8)
-  - [Use case: automatic file/context info](#8-1)
+  - [Use Case: Automatic File/Context Info](#8-1)
 - [Internals & Dependencies](#9)
   - [Why This Pattern?](#9-1)
 - [License](#10)
@@ -36,7 +37,7 @@ Colorino automatically adapts its palette to your terminal or browser DevTools t
 
 Plain `console.log` is colorless and inconsistent. Libraries like `chalk` let you style strings, but you have to decorate every message and manually manage color choices.
 
-Colorino is different: it’s a "batteries-included" logging facade with beautiful, theme-aware colors and a familiar API—no learning curve, no configuration. Instantly upgrade your logs everywhere.
+Colorino is different: it’s a "batteries-included" logging facade with beautiful, theme-aware colors and a familiar API. Instantly upgrade your logs everywhere.
 
 ## <a id="2"></a>Features
 
@@ -220,11 +221,11 @@ const darkLogger = createColorino({}, { theme: 'dark' })
 
 ### <a id="5-4"></a>Customization
 
-Use your brand colors by passing a partial palette to the `createColorino` factory. Any log levels you don't specify will use the detected **minimal** defaults (`minimal-dark` / `minimal-light`) unless you explicitly select a theme preset.
+Use your brand colors by passing a partial palette to the `createColorino` factory. Any log levels you don't specify will use the detected default colors unless you explicitly select a theme preset.
 
 Colorino always targets the highest color fidelity supported by the environment. If your palette uses hex colors but only ANSI‑16 is available, Colorino computes the nearest ANSI color so your branding stays recognizable, even on limited terminals.
 
-If you pass an invalid color value (e.g. malformed hex) in a custom palette, Colorino throws an InputValidationError at creation time so broken palettes fail fast.
+If you pass an invalid color value (e.g. malformed hex) in a custom palette, Colorino throws an `InputValidationError` at creation time so broken palettes fail fast.
 
 ```typescript
 import { createColorino } from 'colorino'
@@ -251,6 +252,21 @@ Colorino auto-detects your environment and color support, but you can override b
 | `WT_SESSION`    | Enables color detection for Windows Terminal                                             |                                      |
 | `CI`            | Many CI platforms default to no color                                                    | `CI=1 node app.js`                  |
 
+### <a id="5-6"></a>Colorize Helper (Manual Overrides)
+
+Sometimes you want full control over a single piece of text without changing your global palette, e.g. when you use a mostly neutral theme but still want to highlight a keyword.
+
+Colorino exposes a small `colorize(text, hex)` helper on every logger instance:
+
+```ts
+import { colorino } from 'colorino'
+
+const important = colorino.colorize('IMPORTANT', '#ff5733')
+colorino.info(important, 'Something happened')
+```
+
+When color is disabled (for example via `NO_COLOR=1` or lack of support), `colorize` returns the plain input string, so your logs stay readable.
+
 ## <a id="6"></a>Colorino vs. Chalk
 
 | Feature                  | 🎨 **Colorino**            | 🖍️ **Chalk**    |
@@ -289,7 +305,7 @@ A factory function to create your own customized logger instances.
 
 Colorino is designed for composition: create a base logger via `createColorino()`, then extend it by inheriting from the base and overriding only the methods you need.
 
-### <a id="8-1"></a>Use case: automatic file/context info
+### <a id="8-1"></a>Use Case: Automatic File/Context Info
 
 This example prefixes every `.info()` and `.error()` call with best‑effort caller context (file/line) derived from a synthetic `Error` stack.
 

package/dist/browser.bundle.cjs

@@ -62,6 +62,8 @@ var ColorLevel = /* @__PURE__ */ ((ColorLevel2) => {
 function isConsoleMethod(level) {
   return ["log", "info", "warn", "error", "trace", "debug"].includes(level);
 }
+const ColorinoBrowserColorized = Symbol("colorino.browserColorized");
+const ColorinoBrowserObject = Symbol("colorino.browserObject");
 
 const catppuccinMochaPalette = {
   log: "#cdd6f4",
@@ -146,6 +148,33 @@ function determineBaseTheme(themeOpt, detectedBrowserTheme) {
   return baseThemeName;
 }
 
+class TypeValidator {
+  static isNull(value) {
+    return value === null;
+  }
+  static isObject(value) {
+    return typeof value === "object" && value !== null;
+  }
+  static isString(value) {
+    return typeof value === "string";
+  }
+  static isError(value) {
+    return value instanceof Error;
+  }
+  static isBrowserColorizedArg(value) {
+    return typeof value === "object" && value !== null && ColorinoBrowserColorized in value;
+  }
+  static isBrowserObjectArg(value) {
+    return typeof value === "object" && value !== null && ColorinoBrowserObject in value;
+  }
+  static isAnsiColoredString(value) {
+    return TypeValidator.isString(value) && /\x1b\[[0-9;]*m/.test(value);
+  }
+  static isFormattableObject(value) {
+    return TypeValidator.isObject(value) && !TypeValidator.isError(value) && !TypeValidator.isBrowserColorizedArg(value);
+  }
+}
+
 class MyColorino {
   constructor(initialPalette, _userPalette, _validator, _browserColorSupportDetector, _nodeColorSupportDetector, _options = {}) {
     this._userPalette = _userPalette;
@@ -164,7 +193,7 @@ class MyColorino {
     const themeOpt = this._options.theme ?? "auto";
     if (themeOpt === "auto" && this._nodeColorSupportDetector) {
       this._nodeColorSupportDetector.onTheme((resolvedTheme) => {
-        this._appllyResolvedTheme(resolvedTheme);
+        this._applyResolvedTheme(resolvedTheme);
       });
     }
   }
@@ -172,12 +201,6 @@ class MyColorino {
   _colorLevel;
   isBrowser;
   _palette;
-  _appllyResolvedTheme(resolvedTheme) {
-    const themeOpt = this._options.theme ?? "auto";
-    const baseThemeName = determineBaseTheme(themeOpt, resolvedTheme);
-    const basePalette = themePalettes[baseThemeName];
-    this._palette = { ...basePalette, ...this._userPalette };
-  }
   log(...args) {
     this._out("log", args);
   }
@@ -196,6 +219,32 @@ class MyColorino {
   debug(...args) {
     this._out("debug", args);
   }
+  colorize(text, hex) {
+    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
+      return text;
+    }
+    if (this.isBrowser) {
+      return {
+        [ColorinoBrowserColorized]: true,
+        text,
+        hex
+      };
+    }
+    const ansiPrefix = this._toAnsiPrefix(hex);
+    if (!ansiPrefix) {
+      return text;
+    }
+    return `${ansiPrefix}${text}\x1B[0m`;
+  }
+  _isAnsiColoredString(value) {
+    return typeof value === "string" && /\x1b\[[0-9;]*m/.test(value);
+  }
+  _applyResolvedTheme(resolvedTheme) {
+    const themeOpt = this._options.theme ?? "auto";
+    const baseThemeName = determineBaseTheme(themeOpt, resolvedTheme);
+    const basePalette = themePalettes[baseThemeName];
+    this._palette = { ...basePalette, ...this._userPalette };
+  }
   _detectColorSupport() {
     if (this.isBrowser) {
       return this._browserColorSupportDetector?.getColorLevel() ?? "UnknownEnv";
@@ -215,7 +264,7 @@ class MyColorino {
   _formatValue(value, maxDepth = this._options.maxDepth ?? 5) {
     const seen = /* @__PURE__ */ new WeakSet();
     const sanitize = (val, currentDepth) => {
-      if (val === null || typeof val !== "object") return val;
+      if (val == null || typeof val !== "object") return val;
       if (seen.has(val)) return "[Circular]";
       seen.add(val);
       if (currentDepth >= maxDepth) return "[Object]";
@@ -233,21 +282,36 @@ class MyColorino {
     };
     return JSON.stringify(sanitize(value, 0), null, 2);
   }
+  _normalizeString(value) {
+    if (value instanceof String) return value.valueOf();
+    return value;
+  }
   _processArgs(args) {
     const processedArgs = [];
     let previousWasObject = false;
-    for (const arg of args) {
-      const isFormattableObject = arg !== null && typeof arg === "object" && typeof arg !== "string" && !(arg instanceof Error);
-      const isError = arg instanceof Error;
-      if (isFormattableObject) {
-        processedArgs.push(`
+    for (const rawArg of args) {
+      const arg = this._normalizeString(rawArg);
+      if (TypeValidator.isBrowserColorizedArg(arg)) {
+        processedArgs.push(arg);
+        previousWasObject = false;
+        continue;
+      }
+      if (TypeValidator.isFormattableObject(arg)) {
+        if (this.isBrowser) {
+          processedArgs.push({
+            [ColorinoBrowserObject]: true,
+            value: arg
+          });
+        } else {
+          processedArgs.push(`
 ${this._formatValue(arg)}`);
+        }
         previousWasObject = true;
-      } else if (isError) {
+      } else if (TypeValidator.isError(arg)) {
         processedArgs.push("\n", this._cleanErrorStack(arg));
         previousWasObject = true;
       } else {
-        if (typeof arg === "string" && previousWasObject) {
+        if (TypeValidator.isString(arg) && previousWasObject) {
           processedArgs.push(`
 ${arg}`);
         } else {
@@ -259,48 +323,78 @@ ${arg}`);
     return processedArgs;
   }
   _applyBrowserColors(consoleMethod, args) {
-    const hex = this._palette[consoleMethod];
-    if (typeof args[0] === "string") {
-      return [`%c${args[0]}`, `color:${hex}`, ...args.slice(1)];
+    const formatParts = [];
+    const cssArgs = [];
+    const otherArgs = [];
+    const paletteHex = this._palette[consoleMethod];
+    for (const rawArg of args) {
+      const arg = this._normalizeString(rawArg);
+      if (TypeValidator.isBrowserColorizedArg(arg)) {
+        formatParts.push(`%c${arg.text}`);
+        cssArgs.push(`color:${arg.hex}`);
+        continue;
+      }
+      if (TypeValidator.isBrowserObjectArg(arg)) {
+        formatParts.push("%o");
+        otherArgs.push(arg.value);
+        continue;
+      }
+      if (TypeValidator.isString(arg)) {
+        formatParts.push(`%c${arg}`);
+        cssArgs.push(`color:${paletteHex}`);
+        continue;
+      }
+      formatParts.push("%o");
+      otherArgs.push(arg);
     }
-    return args;
+    if (formatParts.length === 0) {
+      return args;
+    }
+    return [formatParts.join(""), ...cssArgs, ...otherArgs];
   }
-  _applyNodeColors(consoleMethod, args) {
-    const hex = this._palette[consoleMethod];
-    let ansiCode;
+  _toAnsiPrefix(hex) {
+    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
+      return "";
+    }
     switch (this._colorLevel) {
       case ColorLevel.TRUECOLOR: {
         const [r, g, b] = colorConverter.hex.toRgb(hex);
-        ansiCode = `\x1B[38;2;${r};${g};${b}m`;
-        break;
+        return `\x1B[38;2;${r};${g};${b}m`;
       }
       case ColorLevel.ANSI256: {
         const code = colorConverter.hex.toAnsi256(hex);
-        ansiCode = `\x1B[38;5;${code}m`;
-        break;
+        return `\x1B[38;5;${code}m`;
       }
       case ColorLevel.ANSI:
       default: {
         const code = colorConverter.hex.toAnsi16(hex);
-        ansiCode = `\x1B[${code}m`;
-        break;
+        return `\x1B[${code}m`;
       }
     }
+  }
+  _applyNodeColors(consoleMethod, args) {
     const coloredArgs = [...args];
     const firstStringIndex = coloredArgs.findIndex(
       (arg) => typeof arg === "string"
     );
-    if (firstStringIndex !== -1) {
-      coloredArgs[firstStringIndex] = `${ansiCode}${coloredArgs[firstStringIndex]}\x1B[0m`;
+    if (firstStringIndex === -1) {
+      return coloredArgs;
+    }
+    const first = coloredArgs[firstStringIndex];
+    if (this._isAnsiColoredString(first)) {
+      return coloredArgs;
+    }
+    const hex = this._palette[consoleMethod];
+    const ansiPrefix = this._toAnsiPrefix(hex);
+    if (!ansiPrefix) {
+      return coloredArgs;
     }
+    coloredArgs[firstStringIndex] = `${ansiPrefix}${String(first)}\x1B[0m`;
     return coloredArgs;
   }
   _output(consoleMethod, args) {
-    if (consoleMethod === "trace") {
-      this._printCleanTrace(args);
-    } else {
-      console[consoleMethod](...args);
-    }
+    if (consoleMethod === "trace") this._printCleanTrace(args);
+    else console[consoleMethod](...args);
   }
   _out(level, args) {
     const consoleMethod = isConsoleMethod(level) ? level : "log";
@@ -822,11 +916,11 @@ class Err {
 }
 Result.fromThrowable;
 
-class ColorinoError extends Error {
+class InputValidationError extends Error {
   constructor(message) {
     super(message);
-    this.name = "ColorinoError";
-    Object.setPrototypeOf(this, ColorinoError.prototype);
+    this.name = "InputValidationError";
+    Object.setPrototypeOf(this, InputValidationError.prototype);
   }
 }
 
@@ -835,7 +929,7 @@ class InputValidator {
     const trimmedHex = hex.trim();
     const isHexValid = /^#[0-9A-F]{6}$/i.test(trimmedHex);
     if (!isHexValid) {
-      return err(new ColorinoError(`Invalid hex color: '${hex}'`));
+      return err(new InputValidationError(`Invalid hex color: '${hex}'`));
     }
     return ok(true);
   }

package/dist/browser.bundle.mjs

@@ -60,6 +60,8 @@ var ColorLevel = /* @__PURE__ */ ((ColorLevel2) => {
 function isConsoleMethod(level) {
   return ["log", "info", "warn", "error", "trace", "debug"].includes(level);
 }
+const ColorinoBrowserColorized = Symbol("colorino.browserColorized");
+const ColorinoBrowserObject = Symbol("colorino.browserObject");
 
 const catppuccinMochaPalette = {
   log: "#cdd6f4",
@@ -144,6 +146,33 @@ function determineBaseTheme(themeOpt, detectedBrowserTheme) {
   return baseThemeName;
 }
 
+class TypeValidator {
+  static isNull(value) {
+    return value === null;
+  }
+  static isObject(value) {
+    return typeof value === "object" && value !== null;
+  }
+  static isString(value) {
+    return typeof value === "string";
+  }
+  static isError(value) {
+    return value instanceof Error;
+  }
+  static isBrowserColorizedArg(value) {
+    return typeof value === "object" && value !== null && ColorinoBrowserColorized in value;
+  }
+  static isBrowserObjectArg(value) {
+    return typeof value === "object" && value !== null && ColorinoBrowserObject in value;
+  }
+  static isAnsiColoredString(value) {
+    return TypeValidator.isString(value) && /\x1b\[[0-9;]*m/.test(value);
+  }
+  static isFormattableObject(value) {
+    return TypeValidator.isObject(value) && !TypeValidator.isError(value) && !TypeValidator.isBrowserColorizedArg(value);
+  }
+}
+
 class MyColorino {
   constructor(initialPalette, _userPalette, _validator, _browserColorSupportDetector, _nodeColorSupportDetector, _options = {}) {
     this._userPalette = _userPalette;
@@ -162,7 +191,7 @@ class MyColorino {
     const themeOpt = this._options.theme ?? "auto";
     if (themeOpt === "auto" && this._nodeColorSupportDetector) {
       this._nodeColorSupportDetector.onTheme((resolvedTheme) => {
-        this._appllyResolvedTheme(resolvedTheme);
+        this._applyResolvedTheme(resolvedTheme);
       });
     }
   }
@@ -170,12 +199,6 @@ class MyColorino {
   _colorLevel;
   isBrowser;
   _palette;
-  _appllyResolvedTheme(resolvedTheme) {
-    const themeOpt = this._options.theme ?? "auto";
-    const baseThemeName = determineBaseTheme(themeOpt, resolvedTheme);
-    const basePalette = themePalettes[baseThemeName];
-    this._palette = { ...basePalette, ...this._userPalette };
-  }
   log(...args) {
     this._out("log", args);
   }
@@ -194,6 +217,32 @@ class MyColorino {
   debug(...args) {
     this._out("debug", args);
   }
+  colorize(text, hex) {
+    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
+      return text;
+    }
+    if (this.isBrowser) {
+      return {
+        [ColorinoBrowserColorized]: true,
+        text,
+        hex
+      };
+    }
+    const ansiPrefix = this._toAnsiPrefix(hex);
+    if (!ansiPrefix) {
+      return text;
+    }
+    return `${ansiPrefix}${text}\x1B[0m`;
+  }
+  _isAnsiColoredString(value) {
+    return typeof value === "string" && /\x1b\[[0-9;]*m/.test(value);
+  }
+  _applyResolvedTheme(resolvedTheme) {
+    const themeOpt = this._options.theme ?? "auto";
+    const baseThemeName = determineBaseTheme(themeOpt, resolvedTheme);
+    const basePalette = themePalettes[baseThemeName];
+    this._palette = { ...basePalette, ...this._userPalette };
+  }
   _detectColorSupport() {
     if (this.isBrowser) {
       return this._browserColorSupportDetector?.getColorLevel() ?? "UnknownEnv";
@@ -213,7 +262,7 @@ class MyColorino {
   _formatValue(value, maxDepth = this._options.maxDepth ?? 5) {
     const seen = /* @__PURE__ */ new WeakSet();
     const sanitize = (val, currentDepth) => {
-      if (val === null || typeof val !== "object") return val;
+      if (val == null || typeof val !== "object") return val;
       if (seen.has(val)) return "[Circular]";
       seen.add(val);
       if (currentDepth >= maxDepth) return "[Object]";
@@ -231,21 +280,36 @@ class MyColorino {
     };
     return JSON.stringify(sanitize(value, 0), null, 2);
   }
+  _normalizeString(value) {
+    if (value instanceof String) return value.valueOf();
+    return value;
+  }
   _processArgs(args) {
     const processedArgs = [];
     let previousWasObject = false;
-    for (const arg of args) {
-      const isFormattableObject = arg !== null && typeof arg === "object" && typeof arg !== "string" && !(arg instanceof Error);
-      const isError = arg instanceof Error;
-      if (isFormattableObject) {
-        processedArgs.push(`
+    for (const rawArg of args) {
+      const arg = this._normalizeString(rawArg);
+      if (TypeValidator.isBrowserColorizedArg(arg)) {
+        processedArgs.push(arg);
+        previousWasObject = false;
+        continue;
+      }
+      if (TypeValidator.isFormattableObject(arg)) {
+        if (this.isBrowser) {
+          processedArgs.push({
+            [ColorinoBrowserObject]: true,
+            value: arg
+          });
+        } else {
+          processedArgs.push(`
 ${this._formatValue(arg)}`);
+        }
         previousWasObject = true;
-      } else if (isError) {
+      } else if (TypeValidator.isError(arg)) {
         processedArgs.push("\n", this._cleanErrorStack(arg));
         previousWasObject = true;
       } else {
-        if (typeof arg === "string" && previousWasObject) {
+        if (TypeValidator.isString(arg) && previousWasObject) {
           processedArgs.push(`
 ${arg}`);
         } else {
@@ -257,48 +321,78 @@ ${arg}`);
     return processedArgs;
   }
   _applyBrowserColors(consoleMethod, args) {
-    const hex = this._palette[consoleMethod];
-    if (typeof args[0] === "string") {
-      return [`%c${args[0]}`, `color:${hex}`, ...args.slice(1)];
+    const formatParts = [];
+    const cssArgs = [];
+    const otherArgs = [];
+    const paletteHex = this._palette[consoleMethod];
+    for (const rawArg of args) {
+      const arg = this._normalizeString(rawArg);
+      if (TypeValidator.isBrowserColorizedArg(arg)) {
+        formatParts.push(`%c${arg.text}`);
+        cssArgs.push(`color:${arg.hex}`);
+        continue;
+      }
+      if (TypeValidator.isBrowserObjectArg(arg)) {
+        formatParts.push("%o");
+        otherArgs.push(arg.value);
+        continue;
+      }
+      if (TypeValidator.isString(arg)) {
+        formatParts.push(`%c${arg}`);
+        cssArgs.push(`color:${paletteHex}`);
+        continue;
+      }
+      formatParts.push("%o");
+      otherArgs.push(arg);
     }
-    return args;
+    if (formatParts.length === 0) {
+      return args;
+    }
+    return [formatParts.join(""), ...cssArgs, ...otherArgs];
   }
-  _applyNodeColors(consoleMethod, args) {
-    const hex = this._palette[consoleMethod];
-    let ansiCode;
+  _toAnsiPrefix(hex) {
+    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
+      return "";
+    }
     switch (this._colorLevel) {
       case ColorLevel.TRUECOLOR: {
         const [r, g, b] = colorConverter.hex.toRgb(hex);
-        ansiCode = `\x1B[38;2;${r};${g};${b}m`;
-        break;
+        return `\x1B[38;2;${r};${g};${b}m`;
       }
       case ColorLevel.ANSI256: {
         const code = colorConverter.hex.toAnsi256(hex);
-        ansiCode = `\x1B[38;5;${code}m`;
-        break;
+        return `\x1B[38;5;${code}m`;
       }
       case ColorLevel.ANSI:
       default: {
         const code = colorConverter.hex.toAnsi16(hex);
-        ansiCode = `\x1B[${code}m`;
-        break;
+        return `\x1B[${code}m`;
       }
     }
+  }
+  _applyNodeColors(consoleMethod, args) {
     const coloredArgs = [...args];
     const firstStringIndex = coloredArgs.findIndex(
       (arg) => typeof arg === "string"
     );
-    if (firstStringIndex !== -1) {
-      coloredArgs[firstStringIndex] = `${ansiCode}${coloredArgs[firstStringIndex]}\x1B[0m`;
+    if (firstStringIndex === -1) {
+      return coloredArgs;
+    }
+    const first = coloredArgs[firstStringIndex];
+    if (this._isAnsiColoredString(first)) {
+      return coloredArgs;
+    }
+    const hex = this._palette[consoleMethod];
+    const ansiPrefix = this._toAnsiPrefix(hex);
+    if (!ansiPrefix) {
+      return coloredArgs;
     }
+    coloredArgs[firstStringIndex] = `${ansiPrefix}${String(first)}\x1B[0m`;
     return coloredArgs;
   }
   _output(consoleMethod, args) {
-    if (consoleMethod === "trace") {
-      this._printCleanTrace(args);
-    } else {
-      console[consoleMethod](...args);
-    }
+    if (consoleMethod === "trace") this._printCleanTrace(args);
+    else console[consoleMethod](...args);
   }
   _out(level, args) {
     const consoleMethod = isConsoleMethod(level) ? level : "log";
@@ -820,11 +914,11 @@ class Err {
 }
 Result.fromThrowable;
 
-class ColorinoError extends Error {
+class InputValidationError extends Error {
   constructor(message) {
     super(message);
-    this.name = "ColorinoError";
-    Object.setPrototypeOf(this, ColorinoError.prototype);
+    this.name = "InputValidationError";
+    Object.setPrototypeOf(this, InputValidationError.prototype);
   }
 }
 
@@ -833,7 +927,7 @@ class InputValidator {
     const trimmedHex = hex.trim();
     const isHexValid = /^#[0-9A-F]{6}$/i.test(trimmedHex);
     if (!isHexValid) {
-      return err(new ColorinoError(`Invalid hex color: '${hex}'`));
+      return err(new InputValidationError(`Invalid hex color: '${hex}'`));
     }
     return ok(true);
   }

package/dist/browser.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const inputValidator = require('./shared/colorino.BgxwS1Lc.cjs');
+const inputValidator = require('./shared/colorino.Dcy2ipG7.cjs');
 
 class BrowserColorSupportDetector {
   constructor(_window, _navigator, _overrideTheme) {

package/dist/browser.d.cts

@@ -1,5 +1,5 @@
-import { P as Palette, C as ColorinoOptions, a as Colorino } from './shared/colorino.DWWtObdr.cjs';
-export { L as LogLevel, T as ThemeName, t as themePalettes } from './shared/colorino.DWWtObdr.cjs';
+import { P as Palette, C as ColorinoOptions, a as Colorino } from './shared/colorino.FdIbpxRG.cjs';
+export { L as LogLevel, T as ThemeName, t as themePalettes } from './shared/colorino.FdIbpxRG.cjs';
 
 declare function createColorino(userPalette?: Partial<Palette>, options?: ColorinoOptions): Colorino;
 

package/dist/browser.d.mts

@@ -1,5 +1,5 @@
-import { P as Palette, C as ColorinoOptions, a as Colorino } from './shared/colorino.DWWtObdr.mjs';
-export { L as LogLevel, T as ThemeName, t as themePalettes } from './shared/colorino.DWWtObdr.mjs';
+import { P as Palette, C as ColorinoOptions, a as Colorino } from './shared/colorino.FdIbpxRG.mjs';
+export { L as LogLevel, T as ThemeName, t as themePalettes } from './shared/colorino.FdIbpxRG.mjs';
 
 declare function createColorino(userPalette?: Partial<Palette>, options?: ColorinoOptions): Colorino;
 

package/dist/browser.d.ts

@@ -1,5 +1,5 @@
-import { P as Palette, C as ColorinoOptions, a as Colorino } from './shared/colorino.DWWtObdr.js';
-export { L as LogLevel, T as ThemeName, t as themePalettes } from './shared/colorino.DWWtObdr.js';
+import { P as Palette, C as ColorinoOptions, a as Colorino } from './shared/colorino.FdIbpxRG.js';
+export { L as LogLevel, T as ThemeName, t as themePalettes } from './shared/colorino.FdIbpxRG.js';
 
 declare function createColorino(userPalette?: Partial<Palette>, options?: ColorinoOptions): Colorino;
 

package/dist/browser.mjs

@@ -1,4 +1,4 @@
-import { C as ColorLevel, t as themePalettes, M as MyColorino, I as InputValidator, d as determineBaseTheme } from './shared/colorino.ClDpLv-k.mjs';
+import { C as ColorLevel, t as themePalettes, M as MyColorino, I as InputValidator, d as determineBaseTheme } from './shared/colorino.DEvR4n1Y.mjs';
 
 class BrowserColorSupportDetector {
   constructor(_window, _navigator, _overrideTheme) {

package/dist/node.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const inputValidator = require('./shared/colorino.BgxwS1Lc.cjs');
+const inputValidator = require('./shared/colorino.Dcy2ipG7.cjs');
 const node_child_process = require('node:child_process');
 const node_url = require('node:url');
 const node_path = require('node:path');

package/dist/node.d.cts

@@ -1,5 +1,5 @@
-import { P as Palette, C as ColorinoOptions, a as Colorino } from './shared/colorino.DWWtObdr.cjs';
-export { L as LogLevel, T as ThemeName, t as themePalettes } from './shared/colorino.DWWtObdr.cjs';
+import { P as Palette, C as ColorinoOptions, a as Colorino } from './shared/colorino.FdIbpxRG.cjs';
+export { L as LogLevel, T as ThemeName, t as themePalettes } from './shared/colorino.FdIbpxRG.cjs';
 
 declare function createColorino(userPalette?: Partial<Palette>, options?: ColorinoOptions): Colorino;
 

package/dist/node.d.mts

@@ -1,5 +1,5 @@
-import { P as Palette, C as ColorinoOptions, a as Colorino } from './shared/colorino.DWWtObdr.mjs';
-export { L as LogLevel, T as ThemeName, t as themePalettes } from './shared/colorino.DWWtObdr.mjs';
+import { P as Palette, C as ColorinoOptions, a as Colorino } from './shared/colorino.FdIbpxRG.mjs';
+export { L as LogLevel, T as ThemeName, t as themePalettes } from './shared/colorino.FdIbpxRG.mjs';
 
 declare function createColorino(userPalette?: Partial<Palette>, options?: ColorinoOptions): Colorino;
 

package/dist/node.d.ts

@@ -1,5 +1,5 @@
-import { P as Palette, C as ColorinoOptions, a as Colorino } from './shared/colorino.DWWtObdr.js';
-export { L as LogLevel, T as ThemeName, t as themePalettes } from './shared/colorino.DWWtObdr.js';
+import { P as Palette, C as ColorinoOptions, a as Colorino } from './shared/colorino.FdIbpxRG.js';
+export { L as LogLevel, T as ThemeName, t as themePalettes } from './shared/colorino.FdIbpxRG.js';
 
 declare function createColorino(userPalette?: Partial<Palette>, options?: ColorinoOptions): Colorino;
 

package/dist/node.mjs

@@ -1,4 +1,4 @@
-import { C as ColorLevel, d as determineBaseTheme, t as themePalettes, M as MyColorino, I as InputValidator } from './shared/colorino.ClDpLv-k.mjs';
+import { C as ColorLevel, d as determineBaseTheme, t as themePalettes, M as MyColorino, I as InputValidator } from './shared/colorino.DEvR4n1Y.mjs';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';

package/dist/shared/{colorino.ClDpLv-k.mjs → colorino.DEvR4n1Y.mjs}

@@ -60,6 +60,8 @@ var ColorLevel = /* @__PURE__ */ ((ColorLevel2) => {
 function isConsoleMethod(level) {
   return ["log", "info", "warn", "error", "trace", "debug"].includes(level);
 }
+const ColorinoBrowserColorized = Symbol("colorino.browserColorized");
+const ColorinoBrowserObject = Symbol("colorino.browserObject");
 
 const catppuccinMochaPalette = {
   log: "#cdd6f4",
@@ -144,6 +146,33 @@ function determineBaseTheme(themeOpt, detectedBrowserTheme) {
   return baseThemeName;
 }
 
+class TypeValidator {
+  static isNull(value) {
+    return value === null;
+  }
+  static isObject(value) {
+    return typeof value === "object" && value !== null;
+  }
+  static isString(value) {
+    return typeof value === "string";
+  }
+  static isError(value) {
+    return value instanceof Error;
+  }
+  static isBrowserColorizedArg(value) {
+    return typeof value === "object" && value !== null && ColorinoBrowserColorized in value;
+  }
+  static isBrowserObjectArg(value) {
+    return typeof value === "object" && value !== null && ColorinoBrowserObject in value;
+  }
+  static isAnsiColoredString(value) {
+    return TypeValidator.isString(value) && /\x1b\[[0-9;]*m/.test(value);
+  }
+  static isFormattableObject(value) {
+    return TypeValidator.isObject(value) && !TypeValidator.isError(value) && !TypeValidator.isBrowserColorizedArg(value);
+  }
+}
+
 class MyColorino {
   constructor(initialPalette, _userPalette, _validator, _browserColorSupportDetector, _nodeColorSupportDetector, _options = {}) {
     this._userPalette = _userPalette;
@@ -162,7 +191,7 @@ class MyColorino {
     const themeOpt = this._options.theme ?? "auto";
     if (themeOpt === "auto" && this._nodeColorSupportDetector) {
       this._nodeColorSupportDetector.onTheme((resolvedTheme) => {
-        this._appllyResolvedTheme(resolvedTheme);
+        this._applyResolvedTheme(resolvedTheme);
       });
     }
   }
@@ -170,12 +199,6 @@ class MyColorino {
   _colorLevel;
   isBrowser;
   _palette;
-  _appllyResolvedTheme(resolvedTheme) {
-    const themeOpt = this._options.theme ?? "auto";
-    const baseThemeName = determineBaseTheme(themeOpt, resolvedTheme);
-    const basePalette = themePalettes[baseThemeName];
-    this._palette = { ...basePalette, ...this._userPalette };
-  }
   log(...args) {
     this._out("log", args);
   }
@@ -194,6 +217,32 @@ class MyColorino {
   debug(...args) {
     this._out("debug", args);
   }
+  colorize(text, hex) {
+    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
+      return text;
+    }
+    if (this.isBrowser) {
+      return {
+        [ColorinoBrowserColorized]: true,
+        text,
+        hex
+      };
+    }
+    const ansiPrefix = this._toAnsiPrefix(hex);
+    if (!ansiPrefix) {
+      return text;
+    }
+    return `${ansiPrefix}${text}\x1B[0m`;
+  }
+  _isAnsiColoredString(value) {
+    return typeof value === "string" && /\x1b\[[0-9;]*m/.test(value);
+  }
+  _applyResolvedTheme(resolvedTheme) {
+    const themeOpt = this._options.theme ?? "auto";
+    const baseThemeName = determineBaseTheme(themeOpt, resolvedTheme);
+    const basePalette = themePalettes[baseThemeName];
+    this._palette = { ...basePalette, ...this._userPalette };
+  }
   _detectColorSupport() {
     if (this.isBrowser) {
       return this._browserColorSupportDetector?.getColorLevel() ?? "UnknownEnv";
@@ -213,7 +262,7 @@ class MyColorino {
   _formatValue(value, maxDepth = this._options.maxDepth ?? 5) {
     const seen = /* @__PURE__ */ new WeakSet();
     const sanitize = (val, currentDepth) => {
-      if (val === null || typeof val !== "object") return val;
+      if (val == null || typeof val !== "object") return val;
       if (seen.has(val)) return "[Circular]";
       seen.add(val);
       if (currentDepth >= maxDepth) return "[Object]";
@@ -231,21 +280,36 @@ class MyColorino {
     };
     return JSON.stringify(sanitize(value, 0), null, 2);
   }
+  _normalizeString(value) {
+    if (value instanceof String) return value.valueOf();
+    return value;
+  }
   _processArgs(args) {
     const processedArgs = [];
     let previousWasObject = false;
-    for (const arg of args) {
-      const isFormattableObject = arg !== null && typeof arg === "object" && typeof arg !== "string" && !(arg instanceof Error);
-      const isError = arg instanceof Error;
-      if (isFormattableObject) {
-        processedArgs.push(`
+    for (const rawArg of args) {
+      const arg = this._normalizeString(rawArg);
+      if (TypeValidator.isBrowserColorizedArg(arg)) {
+        processedArgs.push(arg);
+        previousWasObject = false;
+        continue;
+      }
+      if (TypeValidator.isFormattableObject(arg)) {
+        if (this.isBrowser) {
+          processedArgs.push({
+            [ColorinoBrowserObject]: true,
+            value: arg
+          });
+        } else {
+          processedArgs.push(`
 ${this._formatValue(arg)}`);
+        }
         previousWasObject = true;
-      } else if (isError) {
+      } else if (TypeValidator.isError(arg)) {
         processedArgs.push("\n", this._cleanErrorStack(arg));
         previousWasObject = true;
       } else {
-        if (typeof arg === "string" && previousWasObject) {
+        if (TypeValidator.isString(arg) && previousWasObject) {
           processedArgs.push(`
 ${arg}`);
         } else {
@@ -257,48 +321,78 @@ ${arg}`);
     return processedArgs;
   }
   _applyBrowserColors(consoleMethod, args) {
-    const hex = this._palette[consoleMethod];
-    if (typeof args[0] === "string") {
-      return [`%c${args[0]}`, `color:${hex}`, ...args.slice(1)];
+    const formatParts = [];
+    const cssArgs = [];
+    const otherArgs = [];
+    const paletteHex = this._palette[consoleMethod];
+    for (const rawArg of args) {
+      const arg = this._normalizeString(rawArg);
+      if (TypeValidator.isBrowserColorizedArg(arg)) {
+        formatParts.push(`%c${arg.text}`);
+        cssArgs.push(`color:${arg.hex}`);
+        continue;
+      }
+      if (TypeValidator.isBrowserObjectArg(arg)) {
+        formatParts.push("%o");
+        otherArgs.push(arg.value);
+        continue;
+      }
+      if (TypeValidator.isString(arg)) {
+        formatParts.push(`%c${arg}`);
+        cssArgs.push(`color:${paletteHex}`);
+        continue;
+      }
+      formatParts.push("%o");
+      otherArgs.push(arg);
     }
-    return args;
+    if (formatParts.length === 0) {
+      return args;
+    }
+    return [formatParts.join(""), ...cssArgs, ...otherArgs];
   }
-  _applyNodeColors(consoleMethod, args) {
-    const hex = this._palette[consoleMethod];
-    let ansiCode;
+  _toAnsiPrefix(hex) {
+    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
+      return "";
+    }
     switch (this._colorLevel) {
       case ColorLevel.TRUECOLOR: {
         const [r, g, b] = colorConverter.hex.toRgb(hex);
-        ansiCode = `\x1B[38;2;${r};${g};${b}m`;
-        break;
+        return `\x1B[38;2;${r};${g};${b}m`;
       }
       case ColorLevel.ANSI256: {
         const code = colorConverter.hex.toAnsi256(hex);
-        ansiCode = `\x1B[38;5;${code}m`;
-        break;
+        return `\x1B[38;5;${code}m`;
       }
       case ColorLevel.ANSI:
       default: {
         const code = colorConverter.hex.toAnsi16(hex);
-        ansiCode = `\x1B[${code}m`;
-        break;
+        return `\x1B[${code}m`;
       }
     }
+  }
+  _applyNodeColors(consoleMethod, args) {
     const coloredArgs = [...args];
     const firstStringIndex = coloredArgs.findIndex(
       (arg) => typeof arg === "string"
     );
-    if (firstStringIndex !== -1) {
-      coloredArgs[firstStringIndex] = `${ansiCode}${coloredArgs[firstStringIndex]}\x1B[0m`;
+    if (firstStringIndex === -1) {
+      return coloredArgs;
+    }
+    const first = coloredArgs[firstStringIndex];
+    if (this._isAnsiColoredString(first)) {
+      return coloredArgs;
+    }
+    const hex = this._palette[consoleMethod];
+    const ansiPrefix = this._toAnsiPrefix(hex);
+    if (!ansiPrefix) {
+      return coloredArgs;
     }
+    coloredArgs[firstStringIndex] = `${ansiPrefix}${String(first)}\x1B[0m`;
     return coloredArgs;
   }
   _output(consoleMethod, args) {
-    if (consoleMethod === "trace") {
-      this._printCleanTrace(args);
-    } else {
-      console[consoleMethod](...args);
-    }
+    if (consoleMethod === "trace") this._printCleanTrace(args);
+    else console[consoleMethod](...args);
   }
   _out(level, args) {
     const consoleMethod = isConsoleMethod(level) ? level : "log";
@@ -820,11 +914,11 @@ class Err {
 }
 Result.fromThrowable;
 
-class ColorinoError extends Error {
+class InputValidationError extends Error {
   constructor(message) {
     super(message);
-    this.name = "ColorinoError";
-    Object.setPrototypeOf(this, ColorinoError.prototype);
+    this.name = "InputValidationError";
+    Object.setPrototypeOf(this, InputValidationError.prototype);
   }
 }
 
@@ -833,7 +927,7 @@ class InputValidator {
     const trimmedHex = hex.trim();
     const isHexValid = /^#[0-9A-F]{6}$/i.test(trimmedHex);
     if (!isHexValid) {
-      return err(new ColorinoError(`Invalid hex color: '${hex}'`));
+      return err(new InputValidationError(`Invalid hex color: '${hex}'`));
     }
     return ok(true);
   }

package/dist/shared/{colorino.BgxwS1Lc.cjs → colorino.Dcy2ipG7.cjs}

@@ -62,6 +62,8 @@ var ColorLevel = /* @__PURE__ */ ((ColorLevel2) => {
 function isConsoleMethod(level) {
   return ["log", "info", "warn", "error", "trace", "debug"].includes(level);
 }
+const ColorinoBrowserColorized = Symbol("colorino.browserColorized");
+const ColorinoBrowserObject = Symbol("colorino.browserObject");
 
 const catppuccinMochaPalette = {
   log: "#cdd6f4",
@@ -146,6 +148,33 @@ function determineBaseTheme(themeOpt, detectedBrowserTheme) {
   return baseThemeName;
 }
 
+class TypeValidator {
+  static isNull(value) {
+    return value === null;
+  }
+  static isObject(value) {
+    return typeof value === "object" && value !== null;
+  }
+  static isString(value) {
+    return typeof value === "string";
+  }
+  static isError(value) {
+    return value instanceof Error;
+  }
+  static isBrowserColorizedArg(value) {
+    return typeof value === "object" && value !== null && ColorinoBrowserColorized in value;
+  }
+  static isBrowserObjectArg(value) {
+    return typeof value === "object" && value !== null && ColorinoBrowserObject in value;
+  }
+  static isAnsiColoredString(value) {
+    return TypeValidator.isString(value) && /\x1b\[[0-9;]*m/.test(value);
+  }
+  static isFormattableObject(value) {
+    return TypeValidator.isObject(value) && !TypeValidator.isError(value) && !TypeValidator.isBrowserColorizedArg(value);
+  }
+}
+
 class MyColorino {
   constructor(initialPalette, _userPalette, _validator, _browserColorSupportDetector, _nodeColorSupportDetector, _options = {}) {
     this._userPalette = _userPalette;
@@ -164,7 +193,7 @@ class MyColorino {
     const themeOpt = this._options.theme ?? "auto";
     if (themeOpt === "auto" && this._nodeColorSupportDetector) {
       this._nodeColorSupportDetector.onTheme((resolvedTheme) => {
-        this._appllyResolvedTheme(resolvedTheme);
+        this._applyResolvedTheme(resolvedTheme);
       });
     }
   }
@@ -172,12 +201,6 @@ class MyColorino {
   _colorLevel;
   isBrowser;
   _palette;
-  _appllyResolvedTheme(resolvedTheme) {
-    const themeOpt = this._options.theme ?? "auto";
-    const baseThemeName = determineBaseTheme(themeOpt, resolvedTheme);
-    const basePalette = themePalettes[baseThemeName];
-    this._palette = { ...basePalette, ...this._userPalette };
-  }
   log(...args) {
     this._out("log", args);
   }
@@ -196,6 +219,32 @@ class MyColorino {
   debug(...args) {
     this._out("debug", args);
   }
+  colorize(text, hex) {
+    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
+      return text;
+    }
+    if (this.isBrowser) {
+      return {
+        [ColorinoBrowserColorized]: true,
+        text,
+        hex
+      };
+    }
+    const ansiPrefix = this._toAnsiPrefix(hex);
+    if (!ansiPrefix) {
+      return text;
+    }
+    return `${ansiPrefix}${text}\x1B[0m`;
+  }
+  _isAnsiColoredString(value) {
+    return typeof value === "string" && /\x1b\[[0-9;]*m/.test(value);
+  }
+  _applyResolvedTheme(resolvedTheme) {
+    const themeOpt = this._options.theme ?? "auto";
+    const baseThemeName = determineBaseTheme(themeOpt, resolvedTheme);
+    const basePalette = themePalettes[baseThemeName];
+    this._palette = { ...basePalette, ...this._userPalette };
+  }
   _detectColorSupport() {
     if (this.isBrowser) {
       return this._browserColorSupportDetector?.getColorLevel() ?? "UnknownEnv";
@@ -215,7 +264,7 @@ class MyColorino {
   _formatValue(value, maxDepth = this._options.maxDepth ?? 5) {
     const seen = /* @__PURE__ */ new WeakSet();
     const sanitize = (val, currentDepth) => {
-      if (val === null || typeof val !== "object") return val;
+      if (val == null || typeof val !== "object") return val;
       if (seen.has(val)) return "[Circular]";
       seen.add(val);
       if (currentDepth >= maxDepth) return "[Object]";
@@ -233,21 +282,36 @@ class MyColorino {
     };
     return JSON.stringify(sanitize(value, 0), null, 2);
   }
+  _normalizeString(value) {
+    if (value instanceof String) return value.valueOf();
+    return value;
+  }
   _processArgs(args) {
     const processedArgs = [];
     let previousWasObject = false;
-    for (const arg of args) {
-      const isFormattableObject = arg !== null && typeof arg === "object" && typeof arg !== "string" && !(arg instanceof Error);
-      const isError = arg instanceof Error;
-      if (isFormattableObject) {
-        processedArgs.push(`
+    for (const rawArg of args) {
+      const arg = this._normalizeString(rawArg);
+      if (TypeValidator.isBrowserColorizedArg(arg)) {
+        processedArgs.push(arg);
+        previousWasObject = false;
+        continue;
+      }
+      if (TypeValidator.isFormattableObject(arg)) {
+        if (this.isBrowser) {
+          processedArgs.push({
+            [ColorinoBrowserObject]: true,
+            value: arg
+          });
+        } else {
+          processedArgs.push(`
 ${this._formatValue(arg)}`);
+        }
         previousWasObject = true;
-      } else if (isError) {
+      } else if (TypeValidator.isError(arg)) {
         processedArgs.push("\n", this._cleanErrorStack(arg));
         previousWasObject = true;
       } else {
-        if (typeof arg === "string" && previousWasObject) {
+        if (TypeValidator.isString(arg) && previousWasObject) {
           processedArgs.push(`
 ${arg}`);
         } else {
@@ -259,48 +323,78 @@ ${arg}`);
     return processedArgs;
   }
   _applyBrowserColors(consoleMethod, args) {
-    const hex = this._palette[consoleMethod];
-    if (typeof args[0] === "string") {
-      return [`%c${args[0]}`, `color:${hex}`, ...args.slice(1)];
+    const formatParts = [];
+    const cssArgs = [];
+    const otherArgs = [];
+    const paletteHex = this._palette[consoleMethod];
+    for (const rawArg of args) {
+      const arg = this._normalizeString(rawArg);
+      if (TypeValidator.isBrowserColorizedArg(arg)) {
+        formatParts.push(`%c${arg.text}`);
+        cssArgs.push(`color:${arg.hex}`);
+        continue;
+      }
+      if (TypeValidator.isBrowserObjectArg(arg)) {
+        formatParts.push("%o");
+        otherArgs.push(arg.value);
+        continue;
+      }
+      if (TypeValidator.isString(arg)) {
+        formatParts.push(`%c${arg}`);
+        cssArgs.push(`color:${paletteHex}`);
+        continue;
+      }
+      formatParts.push("%o");
+      otherArgs.push(arg);
     }
-    return args;
+    if (formatParts.length === 0) {
+      return args;
+    }
+    return [formatParts.join(""), ...cssArgs, ...otherArgs];
   }
-  _applyNodeColors(consoleMethod, args) {
-    const hex = this._palette[consoleMethod];
-    let ansiCode;
+  _toAnsiPrefix(hex) {
+    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
+      return "";
+    }
     switch (this._colorLevel) {
       case ColorLevel.TRUECOLOR: {
         const [r, g, b] = colorConverter.hex.toRgb(hex);
-        ansiCode = `\x1B[38;2;${r};${g};${b}m`;
-        break;
+        return `\x1B[38;2;${r};${g};${b}m`;
       }
       case ColorLevel.ANSI256: {
         const code = colorConverter.hex.toAnsi256(hex);
-        ansiCode = `\x1B[38;5;${code}m`;
-        break;
+        return `\x1B[38;5;${code}m`;
       }
       case ColorLevel.ANSI:
       default: {
         const code = colorConverter.hex.toAnsi16(hex);
-        ansiCode = `\x1B[${code}m`;
-        break;
+        return `\x1B[${code}m`;
       }
     }
+  }
+  _applyNodeColors(consoleMethod, args) {
     const coloredArgs = [...args];
     const firstStringIndex = coloredArgs.findIndex(
       (arg) => typeof arg === "string"
     );
-    if (firstStringIndex !== -1) {
-      coloredArgs[firstStringIndex] = `${ansiCode}${coloredArgs[firstStringIndex]}\x1B[0m`;
+    if (firstStringIndex === -1) {
+      return coloredArgs;
+    }
+    const first = coloredArgs[firstStringIndex];
+    if (this._isAnsiColoredString(first)) {
+      return coloredArgs;
+    }
+    const hex = this._palette[consoleMethod];
+    const ansiPrefix = this._toAnsiPrefix(hex);
+    if (!ansiPrefix) {
+      return coloredArgs;
     }
+    coloredArgs[firstStringIndex] = `${ansiPrefix}${String(first)}\x1B[0m`;
     return coloredArgs;
   }
   _output(consoleMethod, args) {
-    if (consoleMethod === "trace") {
-      this._printCleanTrace(args);
-    } else {
-      console[consoleMethod](...args);
-    }
+    if (consoleMethod === "trace") this._printCleanTrace(args);
+    else console[consoleMethod](...args);
   }
   _out(level, args) {
     const consoleMethod = isConsoleMethod(level) ? level : "log";
@@ -822,11 +916,11 @@ class Err {
 }
 Result.fromThrowable;
 
-class ColorinoError extends Error {
+class InputValidationError extends Error {
   constructor(message) {
     super(message);
-    this.name = "ColorinoError";
-    Object.setPrototypeOf(this, ColorinoError.prototype);
+    this.name = "InputValidationError";
+    Object.setPrototypeOf(this, InputValidationError.prototype);
   }
 }
 
@@ -835,7 +929,7 @@ class InputValidator {
     const trimmedHex = hex.trim();
     const isHexValid = /^#[0-9A-F]{6}$/i.test(trimmedHex);
     if (!isHexValid) {
-      return err(new ColorinoError(`Invalid hex color: '${hex}'`));
+      return err(new InputValidationError(`Invalid hex color: '${hex}'`));
     }
     return ok(true);
   }

package/dist/shared/{colorino.DWWtObdr.d.ts → colorino.FdIbpxRG.d.cts}

@@ -16,6 +16,7 @@ interface Colorino {
     error(...args: unknown[]): void;
     debug(...args: unknown[]): void;
     trace(...args: unknown[]): void;
+    colorize(text: string, hex: string): void;
 }
 
 declare const themePalettes: Record<ThemeName, Palette>;

package/dist/shared/{colorino.DWWtObdr.d.cts → colorino.FdIbpxRG.d.mts}

@@ -16,6 +16,7 @@ interface Colorino {
     error(...args: unknown[]): void;
     debug(...args: unknown[]): void;
     trace(...args: unknown[]): void;
+    colorize(text: string, hex: string): void;
 }
 
 declare const themePalettes: Record<ThemeName, Palette>;

package/dist/shared/{colorino.DWWtObdr.d.mts → colorino.FdIbpxRG.d.ts}

@@ -16,6 +16,7 @@ interface Colorino {
     error(...args: unknown[]): void;
     debug(...args: unknown[]): void;
     trace(...args: unknown[]): void;
+    colorize(text: string, hex: string): void;
 }
 
 declare const themePalettes: Record<ThemeName, Palette>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "colorino",
-  "version": "0.12.7",
+  "version": "0.13.0",
   "description": "A super simple colorized logger that gets the most out of your terminal",
   "type": "module",
   "license": "MIT",