Package detail

Why Colorize?

• Supports both ESM and CommonJS
• TypeScript support out of the box
• Supports Deno, Next.JS runtimes and Browser (not only chrome) (currently multi nesting is not supported)
• Standard API compatible with Chalk, switch from Chalk to Colorize without changing your code

- import chalk from 'chalk';
+ import chalk, { red } from '@visulima/colorize';

chalk.red.bold('Error!'); // <- Chalk like syntax works fine with Colorize
red.bold('Error!');       // <- the same result with Colorize
red.bold`Error!`;         // <- the same result with Colorize

• Default import
  • import colorize from '@visulima/colorize' or const colorize = require('@visulima/colorize')
• Named import
  • import { red } from '@visulima/colorize' or const { red } = require('@visulima/colorize')
• Chained syntax red.bold.underline('text')
• Template literals red`text`
• String styling with tagged template literals, see template-literals
• Nested template strings red`R ${green`G`} R`
• Base ANSI styles dim bold italic underline strikethrough
• Base ANSI 16 colors red`Error!` redBright`Error!` bgRed`Error!` bgRedBright`Error!`
• ANSI 256 colors and TrueColor (RGB, HEX) rgb(224, 17, 95)`Ruby`, hex('#96C')`Amethyst`
• TrueColor (RGB, HEX) rgb(224, 17, 95)`Ruby`, hex('#96C')`Amethyst`
• Fallback to supported color space: TrueColor → 256 colors → 16 colors → no colors
• ANSI codes as open and close property for each style `Hello ${red.open}World${red.close}!`
• Strip ANSI codes method colorize.strip()
• Correct style break at the end of line when used \n in string
• Supports the environment variables NO_COLOR FORCE_COLOR and flags --no-color --color
• Expressive API
• Doesn't extend String.prototype
• Up to x3 faster than chalk, see benchmarks
• Auto detects color support
• Clean and focused
• String Gradient´s

Install

npm install @visulima/colorize

yarn add @visulima/colorize

pnpm add @visulima/colorize

Demo

Usage

// ESM default import
import colorize from "@visulima/colorize";
// ESM named import
import { red, green, blue } from "@visulima/colorize";

or

// CommonJS default import
const colorize = require("@visulima/colorize");
// CommonJS named import
const { red, green, blue } = require("@visulima/colorize");

Some examples:

console.log(colorize.green("Success!"));
console.log(green("Success!"));

// template string
console.log(blue`Info!`);

// chained syntax
console.log(green.bold`Success!`);

// nested syntax
console.log(red`The ${blue.underline`file.js`} not found!`);

Browser

Note: It has the same API as in Node.js.

The return value of the browser version is an array of strings, not a string, because the browser console use the %c syntax for styling. This is why you need the spread operator ... to log the colorized string.

// ESM default import
import colorize from "@visulima/colorize/browser";
// ESM named import
import { red, green, blue } from "@visulima/colorize/browser";

Some examples:

console.log(...colorize.green("Success!"));
console.log(...green("Success!"));

// template string
console.log(...blue`Info!`);

// chained syntax
console.log(...green.bold`Success!`);

// nested syntax
console.log(...red`The ${blue.underline`file.js`} not found!`);

Workaround/Hack to not use the spread operator ....

Warning: But you will lose the correct file path and line number in the console.

let consoleOverwritten = false;

// Heck the window.console object to add colorized logging
if (typeof navigator !== "undefined" && typeof window !== "undefined" && !consoleOverwritten) {
    ["error", "group", "groupCollapsed", "info", "log", "trace", "warn"].forEach((o) => {
        const originalMethod = (window.console as any)[o as keyof Console];

        (window.console as any)[o as keyof Console] = (...args: any[]) => {
            if (Array.isArray(args[0]) && args[0].length >= 2 && args[0][0].includes("%c")) {
                originalMethod(...args[0]);
            } else {
                originalMethod(...args);
            }
        };
    });

    consoleOverwritten = true;
}

Named import

The @visulima/colorize supports both the default import and named import.

// default import
import colorize from "@visulima/colorize";

colorize.red.bold("text");

You can import named colors, styles and functions. All imported colors and styles are chainable.

// named import
import { red, hex, italic } from "@visulima/colorize";

red.bold("text");

Default import and named import can be combined.

// default and named import
import colorize, { red } from "@visulima/colorize";

const redText = red("text"); // colorized ANSI string
const text = colorize.strip(redText); // pure string without ANSI codes

Template literals

The @visulima/colorize supports both the function syntax red('error') and template literals red`error`.

The template literals allow you to make a complex template more readable and shorter.\ The function syntax can be used to colorize a variable.

import { red, blue } from "@visulima/colorize";

let message = "error";

red(message);
blue`text`;
blue`text ${message} text`;

Tagged Template Literals

The @visulima/colorize supports the tagged template literals.

import template from "@visulima/colorize/template";

console.log(template`
CPU: {red ${cpu.totalPercent}%}
RAM: {green ${(ram.used / ram.total) * 100}%}
DISK: {rgb(255,131,0) ${(disk.used / disk.total) * 100}%}
`);

const miles = 18;
const calculateFeet = (miles) => miles * 5280;

console.log(template`
    There are {bold 5280 feet} in a mile.
    In {bold ${miles} miles}, there are {green.bold ${calculateFeet(miles)} feet}.
`);

console.log(template`
    There are also {#FF0000 shorthand hex styles} for
    both the {#ABCDEF foreground}, {#:123456 background},
    or {#ABCDEF:123456 both}.
`);

API

Blocks are delimited by an opening curly brace ({), a style, some content, and a closing curly brace (}).

Template styles are chained exactly like normal Colorize styles. The following two statements are equivalent:

import colorize from "@visulima/colorize";
import template from "@visulima/colorize/template";

console.log(colorize.bold.rgb(10, 100, 200)("Hello!"));
console.log(template`{bold.rgb(10,100,200) Hello!}`);

Chained syntax

All colors, styles and functions are chainable. Each color or style can be combined in any order.

import { blue, bold, italic, hex } from "@visulima/colorize";

blue.bold`text`;

hex("#FF75D1").bgCyan.bold`text`;

bold.bgHex("#FF75D1").cyan`text`;

italic.yellow.bgMagentaBright`text`;

Nested syntax

You can nest functions and template strings within each other. None of the other libraries (chalk, kleur, colorette, colors.js etc.) support nested template strings.

Nested template strings:

import { red, green } from "@visulima/colorize";

red`red ${green`green`} red`;

Deep nested chained styles:

import { red, green, cyan, magenta, yellow, italic, underline } from "@visulima/colorize";

console.log(red(`red ${italic(`red italic ${underline(`red italic underline`)}`)} red`));

// deep nested chained styles
console.log(green(`green ${yellow(`yellow ${magenta(`magenta ${cyan(`cyan ${red.italic.underline`red italic underline`} cyan`)} magenta`)} yellow`)} green`));

Output:\

Multiline nested template strings:

import { red, green, hex, visible, inverse } from "@visulima/colorize";

// defined a TrueColor as the constant
const orange = hex("#FFAB40");

// normal colors
console.log(visible`
CPU: ${red`${cpu.totalPercent}%`}
RAM: ${green`${(ram.used / ram.total) * 100}%`}
DISK: ${orange`${(disk.used / disk.total) * 100}%`}
`);

// inversed colors
console.log(inverse`
CPU: ${red`${cpu.totalPercent}%`}
RAM: ${green`${(ram.used / ram.total) * 100}%`}
DISK: ${orange`${(disk.used / disk.total) * 100}%`}
`);

Output:\

Base ANSI 16 colors and styles

Colors and styles have standard names used by many popular libraries, such as [chalk][chalk], [colorette][colorette], [kleur][kleur].

ANSI 256 colors

The pre-defined set of 256 colors.

Foreground function: ansi256(code) has short alias fg(code)\ Background function: bgAnsi256(code) has short alias bg(code)

The ansi256() and bgAnsi256() methods are implemented for compatibility with the chalk API.

See ANSI color codes.

Fallback

If a terminal supports only 16 colors then ANSI 256 colors will be interpolated into base 16 colors.

Usage Example

import { bold, ansi256, fg, bgAnsi256, bg } from "@visulima/colorize";

// foreground color
ansi256(96)`Bright Cyan`;
fg(96)`Bright Cyan`; // alias for ansi256

// background color
bgAnsi256(105)`Bright Magenta`;
bg(105)`Bright Magenta`; // alias for bgAnsi256

// function is chainable
ansi256(96).bold`bold Bright Cyan`;

// function is avaliable in each style
bold.ansi256(96).underline`bold underline Bright Cyan`;

// you can combine the functions and styles in any order
bgAnsi256(105).ansi256(96)`cyan text on magenta background`;
bg(105).fg(96)`cyan text on magenta background`;

import { bold, ansi256, fg, bgAnsi256, bg } from "@visulima/colorize";

// foreground color
ansi256(96)`Bright Cyan`;
fg(96)`Bright Cyan`;

// background color
bgAnsi256(105)`Bright Magenta`;
bg(105)`Bright Magenta`;

// function is chainable
ansi256(96).bold`bold Bright Cyan`;

// function is available in each style
bold.ansi256(96).underline`bold underline Bright Cyan`;

// you can combine the functions and styles in any order
bgAnsi256(105).ansi256(96)`cyan text on magenta background`;
bg(105).fg(96)`cyan text on magenta background`;

Truecolor (16 million colors)

You can use the hex or rgb format.

Foreground function: hex() rgb()\ Background function: bgHex() bgRgb()

import { bold, hex, rgb, bgHex, bgRgb } from "@visulima/colorize";

// foreground color
hex("#E0115F").bold`bold Ruby`;
hex("#96C")`Amethyst`;
rgb(224, 17, 95).italic`italic Ruby`;

// background color
bgHex("#E0115F")`Ruby`;
bgHex("#96C")`Amethyst`;
bgRgb(224, 17, 95)`Ruby`;

// you can combine the functions and styles in any order
bold.hex("#E0115F").bgHex("#96C")`ruby bold text on amethyst background`;

Fallback

If a terminal does not support ANSI colors, the library will automatically fall back to the next supported color space.

TrueColor —> 256 colors —> 16 colors —> no colors (black & white)

If you use the hex(), rgb() or ansis256() functions in a terminal not supported TrueColor or 256 colors, then colors will be interpolated.

Use ANSI codes

You can use the ANSI escape codes with open and close properties for each style.

import { green, bold } from "@visulima/colorize";

// each style has `open` and `close` properties
console.log(`Hello ${green.open}ANSI${green.close} World!`);

// you can define own style which will have the `open` and `close` properties
const myStyle = bold.italic.black.bgHex("#E0115F");

console.log(`Hello ${myStyle.open}ANSI${myStyle.close} World!`);

Strip ANSI codes

The Colorize class contains the method strip() to remove all ANSI codes from string.

import colorize from "@visulima/colorize";
// or named import
import { strip } from "@visulima/colorize";

const ansiString = colorize.blue`Hello World!`;
const string = colorize.strip(ansiString);

The variable string will contain the pure string without ANSI codes.

New lines

Supports correct style break at the end of line.

import { bgGreen } from "@visulima/colorize";

console.log(bgGreen`\nColorize\nNew Line\nNext New Line\n`);

Environment variables and CLI arguments

Please check @visulima/is-ansi-color-supported for more information.

Browser support

Since Chrome 69 (every chrome based browser), ANSI escape codes are natively supported in the developer console.

For other browsers (like firefox) we use the console style syntax command %c.

Browser Compatibility for ANSI Codes

[!WARNING] Firefox doesn't natively support ANSI codes in the developer console. Colorize automatically falls back to %c syntax for Firefox.

Windows

If you're on Windows, do yourself a favor and use Windows Terminal instead of cmd.exe.

Edge Cases: Handling Input Arguments

Colorize ensures consistent and predictable behavior for edge-case inputs, making it reliable for production use.

Handling falsy arguments

import colorize, { red } from "@visulima/colorize";

colorize.red(); // ✅ Returns empty string ''
colorize.red(undefined); // ✅ Returns empty string ''
colorize.red(null); // ✅ Returns empty string ''
colorize.red(""); // ✅ Returns empty string ''
colorize.reset(); // ✅ Returns reset ANSI code '\x1b[0m'

This reliable handling prevents unexpected output when working with variables that might be undefined, null, or empty strings.

Which One Should You Use?

Quick Decision Guide

• Need basic 16 colors only? Both Colorize and styleText() work, but Colorize is ~100x faster and supports more environments.
• Need truecolor (hex/rgb), 256 colors, or browser support? Use Colorize - styleText() doesn't support these.
• Need nested template strings or chained syntax? Use Colorize - styleText() requires verbose nested calls.
• Only targeting Node.js 22+ and want zero dependencies? styleText() works, but consider the performance and feature trade-offs.

Checklist

• Does support for ESM or CJS matter?

  • ✅ Colorize: ESM and CJS
  • ❌ styleText: Node.js only

• Does browser compatibility matter?

  • ✅ Colorize: Works in Chromium-based browsers and Safari
  • ❌ styleText: Node.js only

• Does performance matter? (e.g., high-frequency logging)

  • ✅ Colorize: ~100x faster than styleText
  • ❌ styleText: Significantly slower

• Does support for ANSI 256 colors or Truecolor with fallback matter?

  • ✅ Colorize: Full support with automatic fallback
  • ❌ styleText: Limited to 16 colors only

• Does handling edge cases (undefined, null, empty strings) matter?

  • ✅ Colorize: Reliable handling of all edge cases
  • ⚠️ styleText: Behavior varies by Node.js version

• Does keeping your code clean and readable matter?

  • ✅ Colorize: Default and named import, chained syntax, nested template strings
  • ❌ styleText: Verbose nested calls, no chaining

• Does TypeScript support and IDE autocomplete matter?

  • ✅ Colorize: Full TypeScript support with autocomplete
  • ⚠️ styleText: Basic TypeScript support

Library Maintenance Status

As of 2025, here's the maintenance status of popular ANSI color libraries:

• ✅ @visulima/colorize: Actively maintained
• ✅ ansis: Actively maintained
• ✅ chalk: Actively maintained
• ✅ picocolors: Actively maintained
• ⚠️ colorette: Last updated 2+ years ago
• ⚠️ ansi-colors: Last updated 3+ years ago
• ⚠️ kleur: Last updated 3+ years ago
• ⚠️ colors.js: Last updated 2+ years ago
• ⚠️ cli-color: Last updated 1+ year ago
• ⚠️ colors-cli: Last updated 1+ year ago

Colorize is actively maintained and regularly updated with new features, bug fixes, and performance improvements.

Colorize vs util.styleText()

Since Node.js v22, the built-in util.styleText() function has been officially introduced, supporting standard modifiers - the basic 16 colors and styles.

Where it works

Colorize

✅ Works on Node.js v20.19+\ ✅ Works in Chromium-based browsers and Safari (useful for shared utils)\ ✅ Works in Deno and Next.JS runtimes\ ⚠️ Firefox DevTools don't render ANSI escape sequences.

styleText

✅ Native since Node.js v22+\ ❌ Node only - it doesn't work in browsers or other runtimes

Performance

In practical benchmarks, styleText() is dramatically slower, ~100x slower than Colorize:

styleText("red", "text"); //    579.832 ops/sec
colorize.red("text"); // 59.646.465 ops/sec

See the benchmark for detailed performance comparisons.

Color support detection

Colorize

• Detects terminal, TTY, CI, or browser color capability and automatically falls back to the supported level (truecolor → 256 → 16 → no color).
• Supports common flags and environment variables:\ NO_COLOR, FORCE_COLOR, COLORTERM, --no-color, --color.

styleText

• Detects terminal color support automatically.
• Supports only environment variables:\ NO_COLOR, FORCE_COLOR, NODE_DISABLE_COLORS.

Simple styling

Colorize has a compact and elegant syntax:

import colorize, { green } from "@visulima/colorize";

console.log(colorize.green("Success!"));
// or even shorter using named import
console.log(green`Success!`);
console.log(green.bold`Success!`);

The same example with styleText is more verbose:

const { styleText } = require("node:util");

console.log(styleText("green", "Success!"));
console.log(styleText(["green", "bold"], "Success!"));

Nested styling

Colorize keeps your code short and readable:

import { red, cyan } from "@visulima/colorize";

console.log(red`Error: ${cyan.bold`file.js`} not found!`);

Using styleText becomes awkward and verbose for nested or combined styles:

const { styleText } = require("node:util");

console.log(styleText("red", `Error: ${styleText(["cyan", "bold"], "file.js")} not found!`));

Truecolor

Colorize

• Supports 16-color, 256-color, and truecolor output.

• Truecolor methods hex() and rgb():

    console.log(colorize.hex("#ffa500")("orange text"));
    console.log(colorize.rgb(255, 165, 0)("orange text"));

styleText

• Limited to the 16 ANSI colors and standard styles.
• No support for hex, rgb, or truecolor.

TypeScript & IDE support

Colorize includes d.ts type definitions for seamless TypeScript integration.\ Color names, methods, and style chains are fully typed, enabling autocomplete and type checking in IDEs like VS Code.

Comparison of most popular libraries

Library **__** - name - named import	Code size	Naming colors	ANSI 256 colors	True- color	Chained syntax	Nested template strings	New Line	Supports CLI params ENV vars	Fallbacks
[@visulima/colorize][npm-url] <nobr>✅ named import</nobr>		standard 16 colors	✅	✅	✅	✅	✅	NO_COLOR FORCE_COLOR --no-color --color	256 color 16 colors no color
[ansi-colors][ansi-colors] <nobr>❌ named import</nobr>		standard 16 colors	❌	❌	✅	❌	✅	only FORCE_COLOR	❌
[ansis][ansis] <nobr>✅ named import</nobr>		standard 16 colors	✅	✅	✅	✅	✅	NO_COLOR FORCE_COLOR --no-color --color	256 color 16 colors no color
[chalk][chalk] <nobr>❌ named import</nobr>		standard 16 colors	✅	✅	✅	❌	✅	NO_COLOR FORCE_COLOR --no-color --color	256 color 16 colors no color
[cli-color][cli-color] <nobr>❌ named import</nobr>		standard 16 colors	✅	❌	✅	❌	❌	only NO_COLOR	16 colors no color
[colorette][colorette] <nobr>✅ named import</nobr>		standard 16 colors	❌	❌	❌	❌	❌	NO_COLOR FORCE_COLOR --no-color --color	no color
[colors-cli][colors-cli] <nobr>❌ named import</nobr>		<nobr>non-standard</nobr> 16 colors	✅	❌	✅	❌	✅	only --no-color --color	no color
[colors.js][colors.js] <nobr>❌ named import</nobr>		<nobr>non-standard</nobr> 16 colors	❌	❌	✅	❌	✅	only FORCE_COLOR --no-color --color	no color
[kleur][kleur] <nobr>✅ named import</nobr>		standard 8 colors	❌	❌	✅	❌	❌	only NO_COLOR FORCE_COLOR	no color
[picocolors][picocolors] <nobr>❌ named import</nobr>		standard 8 colors	❌	❌	❌	❌	❌	NO_COLOR FORCE_COLOR --no-color --color	no color
[util.styleText()][styleText] <nobr>❌ named import</nobr> <nobr>Node ≥ 22</nobr>	Built-in	standard 16 colors	❌	❌	❌	❌	❓	NO_COLOR FORCE_COLOR NODE_DISABLE_COLORS	no color

Note

Code size\ The size of distributed code that will be loaded via require or import into your app. It's not a package size.

Named import\ import { red, green, blue } from 'lib';\ or\ const { red, green, blue } = require('lib');

Naming colors

• standard: colors have standard names, e.g.: red, redBright, bgRed, bgRedBright
• non-standard: colors have lib-specific names, e.g.: brightRed, bgBrightRed, red_b, red_btt

ANSI 256 colors

The method names:

• [@visulima/colorize][npm-url]: ansi256(n) bgAnsi256(n) fg(n) bg(n)
• [ansis][ansis]: ansi256(n) bgAnsi256(n) fg(n) bg(n)
• [chalk][chalk]: ansi256(n) bgAnsi256(n)
• [cli-color][cli-color]: xterm(n)
• [colors-cli][colors-cli]: x<n>

Truecolor

The method names:

• [@visulima/colorize][npm-url]: hex() rgb()
• [ansis][ansis]: hex() rgb()
• [chalk][chalk]: hex() rgb()
• [util.styleText()][styleText]: Not supported (limited to 16 colors)

Chained syntax\ lib.red.bold('text')

Nested template strings\ lib.red`text ${lib.cyan`nested`} text`

New line\ Correct break styles at end-of-line.

lib.bgGreen(`First Line
Next Line`);

Gradient

The @visulima/colorize/gradient supports the string gradient´s, single and multi line.

import { gradient } from "@visulima/colorize/gradient";

console.log(gradient("red", "green", "blue")("Hello World!"));

Multi line gradient

In some cases, you may want to apply the same horizontal gradient on each line of a long text (or a piece of ASCII art).

You can use the multilineGradient method of a gradient to ensure that the colors are vertically aligned.

import { multilineGradient, gradient } from "@visulima/colorize/gradient";

console.log(multilineGradient(["orange", "yellow"])(["     __", "   <(o )___", "    ( ._> /", "     `---'"].join("\n")));
console.log(gradient(["blue", "cyan", "blue"])("----------------"));

Benchmark

See benchmark

Reference

• The opaque named colors
• ANSI escape code

The ANSI Escape sequences control code screen.

echo -e "\033[31;41;4m something here 33[0m"

\033 As the escape character, inform the terminal to switch to the escape mode. [ The beginning of the CSI. m Make the action to be performed. ; ASCII code separator.

Supported Node.js Versions

Libraries in this ecosystem make the best effort to track Node.js’ release schedule. Here’s a post on why we think this is important.

Contributing

If you would like to help take a look at the list of issues and check our Contributing guild.

Note: please note that this project is released with a Contributor Code of Conduct. By participating in this project you agree to abide by its terms.

Credits

• WebDiscus
• Daniel Bannert
• All Contributors

About

Related Projects

• [ansis][ansis] - The Node.js library for formatting text in terminal with ANSI colors & styles
• [ansi-colors][ansi-colors] - Easily add ANSI colors to your text and symbols in the terminal.
• [chalk][chalk] - Terminal string styling done right
• [cli-color][cli-color] - Colors and formatting for the console
• [colorette][colorette] - Easily set your terminal text color & styles
• [colors-cli][colors-cli] - Terminal string styling done right.
• [colors.js][colors.js] - get colors in your node.js console
• [kleur][kleur] - The fastest Node.js library for formatting terminal text with ANSI colors~!
• [picocolors][picocolors] - Tiny yet powerful colors for terminal

Template:

• [chalk-template][chalk-template] - Terminal string styling with tagged template literals

Gradient:

• tinygradient - Easily generate color gradients with an unlimited number of color stops and steps.
• gradient-string - Beautiful color gradients in terminal output

License

The visulima colorize is open-sourced software licensed under the [MIT][license-url]

[typescript-url]: https://www.typescriptlang.org/ "TypeScript" "typescript" [license-image]: https://img.shields.io/npm/l/@visulima/colorize?color=blueviolet&style=for-the-badge [license-url]: LICENSE.md "license" [npm-image]: https://img.shields.io/npm/v/@visulima/colorize/latest.svg?style=for-the-badge&logo=npm [npm-url]: https://www.npmjs.com/package/@visulima/colorize/v/latest "npm" [colors.js]: https://github.com/Marak/colors.js [colorette]: https://github.com/jorgebucaran/colorette [picocolors]: https://github.com/alexeyraspopov/picocolors [cli-color]: https://github.com/medikoo/cli-color [colors-cli]: https://github.com/jaywcjlove/colors-cli [ansi-colors]: https://github.com/doowb/ansi-colors [kleur]: https://github.com/lukeed/kleur [chalk]: https://github.com/chalk/chalk [chalk-template]: https://github.com/chalk/chalk-template [ansis]: https://github.com/webdiscus/ansis [styleText]: https://nodejs.org/api/util.html#utilstyletextformat-text-options

@visulima/colorize 1.4.29 (2025-11-13)

Bug Fixes

• bump packem, to fix minified version of the code (2a36ceb)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.3.5

@visulima/colorize 1.4.28 (2025-11-12)

Bug Fixes

• update package configurations and TypeScript definitions (b59aa59)

Miscellaneous Chores

• Add jsr file to all packages for release (#565) (ec91652)
• update license files and clean up TypeScript definitions (fe668cc)

Code Refactoring

• colorize: simplify TypeScript definitions and remove unused plugin configuration (fcc0649)

Tests

• colorize: correct Colorize function name in test output (ffee5b4)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.3.4

@visulima/colorize 1.4.27 (2025-11-07)

Bug Fixes

• update TypeScript configurations and improve linting across multiple packages (6f25ec7)

Documentation

• enhance README with browser compatibility, edge case handling, and performance comparisons for Colorize (432193f)

Miscellaneous Chores

• update npm and pnpm configurations for monorepo optimization (#564) (5512b42)
• update package.json files and pnpm-lock.yaml (95d9f5b)

Tests

• update expected output for Colorize function in integration test (1e316e9)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.3.3

@visulima/colorize 1.4.26 (2025-11-05)

Bug Fixes

• update dependencies across multiple packages (36a47f2)

Miscellaneous Chores

• update dependencies across multiple packages (c526462)
• update package dependencies and configurations (7bfe7e7)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.3.2

@visulima/colorize 1.4.25 (2025-10-21)

Bug Fixes

• allow node v25 and updated dev deps (8158cc5)

Miscellaneous Chores

• deps: update package versions and dependencies (88d8d32)
• update license years and add validation rules (b97811e)
• update package dependencies across multiple packages (17e3f23)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.3.1

@visulima/colorize 1.4.24 (2025-10-15)

Bug Fixes

• enhance ESLint configuration and improve code readability (adc640b)
• update @visulima/packem to 2.0.0-alpha.32 across multiple packages for improved compatibility (27b346e)
• upgrade @visulima/packem to 2.0.0-alpha.29 and refine packem.config.ts settings (bef233d)

Miscellaneous Chores

• correct formatting in packem.config.ts for requireCJS settings (6413894)
• deps: update build scripts and remove cross-env dependency (7510e82)
• refactor ESLint configuration and update dependencies in colorize package (3e5a30c)
• update dependencies and fix linting issues (0e802fe)
• update dependencies and improve linting commands (478843d)
• update package dependencies across multiple packages for improved compatibility and performance (9567591)
• update package.json and pnpm-lock.yaml to include publint@0.3.12 and adjust build/test commands to exclude shared-utils (1f7b3c0)

Tests

• enhance color output in integration tests for colorize package (e7975f8)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.3.0

@visulima/colorize 1.4.23 (2025-06-04)

Dependencies

• @visulima/path: upgraded to 1.4.0

@visulima/colorize 1.4.22 (2025-05-30)

Bug Fixes

• colorize: update dependencies (3b5af21)

Miscellaneous Chores

• colorize-bench: update devDependencies (f52523a)
• updated dev dependencies (2433ed5)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.2.14
• @visulima/path: upgraded to 1.3.6

@visulima/colorize 1.4.21 (2025-03-07)

Bug Fixes

• updated @visulima/packem and other dev deps, for better bundling size (e940581)

Miscellaneous Chores

• colorize: add type assertions for better type safety (2ad0425)
• fixed issue with pnpm audit, changed browser path (67337cb)
• updated dev dependencies (487a976)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.2.13
• @visulima/path: upgraded to 1.3.5

@visulima/colorize 1.4.20 (2025-01-25)

Bug Fixes

• fixed wrong node version range in package.json (4ae2929)

Miscellaneous Chores

• fixed typescript url (fe65a8c)
• updated all dev dependencies (37fb298)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.2.12
• @visulima/path: upgraded to 1.3.4

@visulima/colorize 1.4.19 (2025-01-22)

Bug Fixes

• colorize: fixed the typesVersions exports (47d60fe)
• fixed support for edge-light runtime (40e9ea3)

Miscellaneous Chores

• updated all dev dependencies and all dependencies in the app folder (87f4ccb)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.2.11

@visulima/colorize 1.4.18 (2025-01-13)

Dependencies

• @visulima/path: upgraded to 1.3.3

@visulima/colorize 1.4.17 (2025-01-12)

Bug Fixes

• updated @visulima/packem, and all other dev dependencies (7797a1c)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.2.10
• @visulima/path: upgraded to 1.3.2

@visulima/colorize 1.4.16 (2025-01-08)

Dependencies

• @visulima/path: upgraded to 1.3.1

@visulima/colorize 1.4.15 (2025-01-08)

Dependencies

• @visulima/path: upgraded to 1.3.0

@visulima/colorize 1.4.14 (2024-12-31)

Styles

• cs fixes (12d0b20)

Miscellaneous Chores

• updated dev dependencies (9de2eab)

Dependencies

• @visulima/path: upgraded to 1.2.0

@visulima/colorize 1.4.13 (2024-12-12)

Bug Fixes

• allow node v23 (8ca929a)
• allowed node 23, updated dev dependencies (f99d34e)
• colorize: migrated from tsup to packem (d9356e5)
• updated packem to v1.9.2 (47bdc2d)

Styles

• cs fixes (46d31e0)

Miscellaneous Chores

• colorize: fixed test on prod build (be87894)
• updated dev dependencies (a916944)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.2.9
• @visulima/path: upgraded to 1.1.2

@visulima/colorize 1.4.12 (2024-10-05)

Dependencies

• @visulima/path: upgraded to 1.1.1

@visulima/colorize 1.4.11 (2024-10-05)

Bug Fixes

• updated dev dependencies, updated packem to v1.0.7, fixed naming of some lint config files (c071a9c)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.2.8
• @visulima/path: upgraded to 1.1.0

@visulima/colorize 1.4.10 (2024-09-24)

Miscellaneous Chores

• updated dev dependencies (05edb67)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.2.7
• @visulima/path: upgraded to 1.0.9

@visulima/colorize 1.4.9 (2024-09-11)

Miscellaneous Chores

• updated dev dependencies (28b5ee5)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.2.6
• @visulima/path: upgraded to 1.0.8

@visulima/colorize 1.4.8 (2024-09-07)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.2.5
• @visulima/path: upgraded to 1.0.7

@visulima/colorize 1.4.7 (2024-09-07)

Miscellaneous Chores

• update dev dependencies (0738f98)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.2.4
• @visulima/path: upgraded to 1.0.6

@visulima/colorize 1.4.6 (2024-08-30)

Miscellaneous Chores

• updated dev dependencies (45c2a76)
• updated dev dependencies (da46d8e)

Dependencies

• @visulima/path: upgraded to 1.0.5

@visulima/colorize 1.4.5 (2024-08-04)

Dependencies

• @visulima/path: upgraded to 1.0.4

@visulima/colorize 1.4.4 (2024-08-01)

Styles

• cs fixes (6f727ec)

Miscellaneous Chores

• added private true into fixture package.json files (4a9494c)
• changed typescript version back to 5.4.5 (55d28bb)
• colorize: fixed test for ci cjs output test (b0b30a8)
• colorize: updated benchmark and deps for benchmark (95448ce)
• updated dev dependencies (ac67ec1)
• updated dev dependencies (34df456)
• updated dev dependencies and sorted the package.json (9571572)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.2.3
• @visulima/path: upgraded to 1.0.3

@visulima/colorize 1.4.3 (2024-06-13)

Miscellaneous Chores

• updated all dev deps (ef143ce)

Build System

• fixed found audit error, updated all dev package deps, updated deps in apps and examples (4c51950)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.2.2

@visulima/colorize 1.4.2 (2024-06-06)

Bug Fixes

• allow node v22 (890d457)

Miscellaneous Chores

• updated dev dependencies (a2e0504)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.2.1
• @visulima/path: upgraded to 1.0.2

@visulima/colorize 1.4.1 (2024-05-24)

Bug Fixes

• changed pathe to @visulima/path (#410) (bfe1287)

Styles

• cs fixes (7bf5b91)

Miscellaneous Chores

• changed semantic-release-npm to pnpm (b6d100a)
• deps: updated dev deps (d91ac38)
• fixed wrong named folders to integration, added TEST_PROD_BUILD (1b826f5)
• update bench dependencies (d03bf14)
• update dev dependencies (068bdbf)
• update dev dependencies (09c4854)
• updated dev dependencies (2e08f23)
• updated dev dependencies (abd319c)
• updated dev dependencies (0767afe)
• updated dev dependencies (d7791e3)
• updated dev dependencies (6005345)
• updated devDependencies (e5f936c)

Dependencies

• @visulima/path: upgraded to 1.0.1

@visulima/colorize 1.4.0 (2024-04-10)

Features

• add detection of color spaces support: TrueColor, 256 colors, 16 colors, no color (#391) (f35525c)

@visulima/colorize 1.3.3 (2024-04-09)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.2.0

@visulima/colorize 1.3.2 (2024-04-09)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.1.0

@visulima/colorize 1.3.1 (2024-03-27)

Bug Fixes

• added missing os key to package.json (4ad1268)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.0.2

@visulima/colorize 1.3.0 (2024-03-04)

Features

• adding new gradient helper (#324) (49b1ab0)
• adding tagged template literals support (#323) (492e66b)

Bug Fixes

• fixed all found type issues (eaa40d1)
• minifyWhitespace on prod build, removed @tsconfig/* configs (410cb73)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.0.1

@visulima/colorize 1.2.2 (2024-02-28)

Bug Fixes

• migrated to @visulima/is-ansi-color-supported v2 (66b5877)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 2.0.0

@visulima/colorize 1.2.1 (2024-02-20)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 1.2.0

@visulima/colorize 1.2.0 (2024-02-18)

Features

• added css support for the browser (00bed6a)
• added full support for no ansi supported browser (2c08071)
• added full support for no ansi supported browser (e53065f)

Bug Fixes

• added 99% of the feature (d9ebe51)

@visulima/colorize 1.1.0 (2024-02-13)

Features

• add supports the argument as number and tests for it (47cff3e)

@visulima/colorize 1.0.1 (2024-01-31)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 1.1.0

@visulima/colorize 1.0.0 (2024-01-28)

Features

• added colorize and is-ansi-color-supported (e2d9945)

Bug Fixes

• added cross-env to test (a7efeec)
• fixed wrong package.json (43dd507)

Dependencies

• @visulima/is-ansi-color-supported: upgraded to 1.0.0