GitHub - webdiscus/ansis: Small and fast Node.js lib to colorize terminal output. Lightweight alternative to Chalk with more features. Supports Bun, Deno, Next.JS.

ANSI Styling

Colorize terminal with ANSI colors & styles, smaller and faster alternative to Chalk with additional useful features.

Usage example

import ansis, { red, green, black, ansi256, hex } from 'ansis';

ansis.cyan('path/to/file')
green('Succeful!')
red`Error!`
black.bgYellow`Warning!`
ansi256(214)`Orange`
hex('#E0115F').bold.underline('Hello TrueColor!')

🚀 Install and Quick Start

👀 Why yet one lib?

Quality is first, test coverage 100%.
Ansis has a lot of useful features, compare with other libraries.
Ansis is one of the smallest, 3.5 KB only.
Ansis is one of the fastest.
Ansis is stable, continuously developing and improving.
Ansis is open for your feature requests.

🏆 Compare & Benchmark

See the features comparison and benchmarks of most popular terminal colors libraries:
ansis, chalk, kleur, kolorist, colors.js, colorette, picocolors, ansi-colors, cli-color, colors-cli.

💡 Highlights

Supports both ESM and CommonJS
Supports TypeScript
Supports Bun, Deno, Next.JS runtimes

Standard API compatible with Chalk, switch from Chalk to Ansis without changing your code

- import chalk from 'chalk';
+ import chalk, { red } from 'ansis';

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

Default and named import import ansis, { red, green, bold, underline } from 'ansis'
Chained syntax red.bold.underline('text')
Nested template strings red`RED text ${green`GREEN text`} RED text`
Base ANSI styles dim bold italic underline ~~strikethrough~~
Base ANSI 16 colors red`Error!` redBright`Error!` bgRed`Error!` bgRedBright`Error!`
ANSI 256 colors fg(56)`violet` bg(208)`orange`
TrueColor (RGB, HEX) rgb(224, 17, 95)`Ruby`, hex('#96C')`Amethyst`
Fallback to supported color space: TrueColor → 256 colors → 16 colors → no colors
Extending of base colors with named True Colors
ANSI codes as open and close properties `Hello ${red.open}World${red.close}!`
Strip ANSI codes method ansis.strip()
Correct style break at the end of line when used \n in string
Supports environment variables NO_COLOR FORCE_COLOR and flags --no-color --color
Detect color support using ansis.isSupported() method
Up to x3 faster than Chalk, see benchmarks
Code bundle is only 3.5 KB
Doesn't extend String.prototype
Zero dependencies

🔆 What's New in v3

NEW added detection of supported color space: TrueColor, 256 colors, 16 colors, no colors (black & white)
NEW added fallback to supported color space: TrueColor —> 256 colors —> 16 colors —> no colors

⚠️ Warning

The v3 has the BREAKING CHANGES (removed not widely supported styles and deprecated methods).
For details see the changelog.

❓Question / Feature Request / Bug

If you have discovered a bug or have a feature suggestion, feel free to create an issue on GitHub.

Install and Quick Start

npm install ansis

You can import default module or named colors with ESM or CommonJS syntax.

// ESM default import
import ansis from 'ansis';
// ESM named import
import { red, green, blue } from 'ansis';

or

// CommonJS default import
const ansis = require('ansis');
// CommonJS named import
const { red, green, blue } = require('ansis');

See the list of the ANSI colors and styles.

console.log(ansis.green('Success!'));
console.log(green('Success!'));

// template string
console.log(green`Success!`);

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

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

Basic example Hello World!:

import { red, black, inverse, reset } from 'ansis';

console.log(green`Hello ${inverse`ANSI`} World!
${black.bgYellow`Warning:`} ${cyan`/path/to/file.js`} ${red`not found!`}`);

Output:

↑ top

Named import

The ansis supports both the default import and named import.

// default import
import ansis from 'ansis';

ansis.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 'ansis';

red.bold('text');

Default import and named import can be combined.

// default and named import
import ansis, { red } from 'ansis';

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

Template literals

The ansis 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 } from 'ansis';

let message = 'error';

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

Chained syntax

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

import { red, bold, italic, hex } from 'ansis';

red.bold`text`;
hex('#FF75D1').bgCyan.bold`text`;
bold.bgHex('#FF75D1').cyan`text`;
italic.bold.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 'ansis';

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

Deep nested chained styles:

import { red, green, cyan, magenta, yellow, italic, underline } from 'ansis';

red(`red ${italic(`red italic ${underline(`red italic underline`)}`)} red`);

// deep nested chained styles
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 'ansis';

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

let cpu = 33;
let ram = 44;
let disk = 55;

// normal colors
visible`
CPU:  ${red`${cpu}%`}
RAM:  ${green`${ram}%`}
DISK: ${orange`${disk}%`}
`;

// inversed colors
inverse`
CPU:  ${red`${cpu}%`}
RAM:  ${green`${ram}%`}
DISK: ${orange`${disk}%`}
`;

Output:

↑ top

Base ANSI 16 colors and styles

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

Foreground colors	Background colors	Styles
`black`	`bgBlack`	`dim`
`red`	`bgRed`	`bold`
`green`	`bgGreen`	`italic`
`yellow`	`bgYellow`	`underline`
`blue`	`bgBlue`	~~`strikethrough`~~ (alias `strike`)
`magenta`	`bgMagenta`	`inverse`
`cyan`	`bgCyan`	`visible`
`white`	`bgWhite`	`hidden`
`blackBright` aliases: `grey` `gray` US spelling	`bgBlackBright` aliases: `bgGrey` `bgGray` US spelling	`reset`
`redBright`	`bgRedBright`
`greenBright`	`bgGreenBright`
`yellowBright`	`bgYellowBright`
`blueBright`	`bgBlueBright`
`magentaBright`	`bgMagentaBright`
`cyanBright`	`bgCyanBright`
`whiteBright`	`bgWhiteBright`

Extend base colors

Defaults, the imported ansis instance contains base styles and colors. To extend base colors with custom color names for TrueColor use the ansis.extend() method.

import ansis from 'ansis';

// extend base colors
ansis.extend({
  pink: '#FF75D1',
  orange: '#FFAB40',
});

// the custom colors are available under namespace `ansis`
ansis.pink('text');
ansis.orange('text');

Usage example with TypeScript:

import ansis, { AnsiColorsExtend } from 'ansis';

// extend base colors
ansis.extend({
  pink: '#FF75D1',
  orange: '#FFAB40',
});

const write = (style: AnsiColorsExtend<'pink' | 'orange'>, message: string) => {
  console.log(ansis[style](message));
}

write('red', 'message'); // base color OK
write('pink', 'message'); // extended color OK
write('orange', 'message'); // extended color OK
write('unknown', 'message'); // TypeScript Error

↑ top

ANSI 256 colors

The pre-defined set of 256 colors.

Code range	Description
0 - 7	standard colors
8 - 15	bright colors
16 - 231	6 × 6 × 6 cube (216 colors)
232 - 255	grayscale from black to white in 24 steps

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 'ansis';

// 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`

TrueColor

You can use the hex or rgb format.

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

import { bold, hex, rgb, bgHex, bgRgb } from 'ansis';

// 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`

↑ top

Fallback

The ansis supports fallback to 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.

↑ top

Use ANSI codes

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

import { red, bold } from 'ansis';

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

// you can defiene 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 Ansis class contains the method strip() to remove all ANSI codes from string.

import ansis from 'ansis';

const ansiString = ansis.green`Hello World!`;
const string = ansis.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 'ansis';

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

Shortcuts / Themes

Define your own themes:

import ansis from 'ansis';

const theme = {
  error: ansis.red.bold,
  info: ansis.cyan.italic,
  warning: ansis.black.bgYellowBright,
  ruby: ansis.hex('#E0115F'),
};

theme.error('error');
theme.info('info');
theme.warning('warning');
theme.ruby('Ruby color');

↑ top

CLI

Defaults, the output in terminal console is colored and output in a file is uncolored.

Environment variables

To force disable or enable colored output use environment variables NO_COLOR and FORCE_COLOR.

The NO_COLOR variable should be presents with any not empty value. The value is not important, e.g., NO_COLOR=1 NO_COLOR=true disable colors.
See standard description by NO_COLOR.

The FORCE_COLOR variable should be presents with one of values:
FORCE_COLOR=0 force disable colors
FORCE_COLOR=1 force enable colors
See standard description by FORCE_COLOR.

For example, app.js:

import { red } from 'ansis';

console.log(red`red color`);

Execute the script in a terminal:

$ node app.js           # colored output in terminal
$ node app.js > log.txt # output in file without ANSI codes

$ NO_COLOR=1 node app.js              # force disable colors, non colored output in terminal
$ FORCE_COLOR=0 node app.js           # force disable colors, non colored output in terminal
$ FORCE_COLOR=1 node app.js > log.txt # force enable colors, output in file with ANSI codes

CLI arguments

Use arguments --no-color or --color=false to disable colors and --color to enable ones.

For example, an executable script app.js:

#!/usr/bin/env node
import { red } from 'ansis';

console.log(red`red color`);

Execute the script in a terminal:

$ ./app.js                        # colored output in terminal
$ ./app.js --no-color             # non colored output in terminal
$ ./app.js --color=false          # non colored output in terminal

$ ./app.js > log.txt              # output in file without ANSI codes
$ ./app.js --color > log.txt      # output in file with ANSI codes
$ ./app.js --color=true > log.txt # output in file with ANSI codes

Warning

The command line arguments have a higher priority than environment variable.

↑ top

Color support

Ansis automatically detects the supported color space:

TrueColor
ANSI 256 colors
ANSI 16 colors
black & white (no colors)

Ansis has the method isSupported() that returns a boolean value whether the output supports ANSI color and styles.

import ansis from 'ansis';

console.log('Color output: ', ansis.isSupported());

There is no standard way to detect which color space is supported. The most common way to detect color support is to check the TERM and COLORTERM environment variables. CI systems can be detected by checking for the existence of the CI and other specifically environment variables. Combine that with the knowledge about which operating system the program is running on, and we have a decent enough way to detect colors.

Terminal	ANSI 16 colors	ANSI 256 colors	True Color	env. TERM	env. COLORTERM	Specifically ENV variables
Azure CI	✅	❌	❌	dumb		TF_BUILD AGENT_NAME
GitHub CI	✅	✅	✅	dumb		CI GITHUB_ACTIONS
GitTea CI	✅	✅	✅	dumb		CI GITEA_ACTIONS
GitLab CI	✅	❌	❌	dumb		CI GITLAB_CI
Travis CI	✅	❌	❌	dumb		TRAVIS
PM2 not isTTY	✅¹	✅¹	✅¹	dumb		PM2_HOME pm_id
JetBrains TeamCity >=2020.1.1	✅	✅	❌			TEAMCITY_VERSION
JetBrains IDEA	✅	✅	✅	xterm-256color		TERMINAL_EMULATOR='JetBrains-JediTerm'
VS Code	✅	✅	✅	xterm-256color	truecolor
Windows Terminal	✅	✅	✅²
Windows PowerShell	✅	✅	✅²
macOS Terminal	✅	✅	❌	xterm-256color
iTerm	✅	✅	✅	xterm-256color	truecolor
Terminal emulator Kitty	✅	✅	✅	xterm-kitty

↑ top

Comparison of most popular libraries

Run the command to see the support of some features by various libraries:

npm run compare

Library ________________ - name - bundle size - named import - naming colors	ANSI base colors	ANSI 256 colors	True Color	Chained syntax	Nested template strings	New Line	Fallbacks	Supports ENV vars CLI flags
`colors.js` 18.1KB `❌ named import` `❌ standard`	`16` colors	❌	❌	✅	❌	✅	no colors	`FORCE_COLOR` `--no-color` `--color`
`colors-cli` 8.6KB `❌ named import` `❌ standard`	`16` colors	✅	❌	✅	❌	✅	no colors	`--no-color` `--color`
`cli-color` `❌ named import` `✅ standard`	`16` colors	✅	❌	✅	❌	❌	16 colors no colors	`NO_COLOR`
`ansi-colors` 5.8KB `❌ named import` `✅ standard`	`16` colors	❌	❌	✅	❌	✅	❌	`FORCE_COLOR`
`colorette` 3.3KB `✅ named import` `✅ standard`	`16` colors	❌	❌	❌	❌	❌	no colors	`NO_COLOR` `FORCE_COLOR` `--no-color` `--color`
`picocolors` 2.6KB `❌ named import` `✅ standard`	`8` colors	❌	❌	❌	❌	❌	no colors	`NO_COLOR` `FORCE_COLOR` `--no-color` `--color`
`kleur` 2.7KB `✅ named import` `✅ standard`	`8` colors	❌	❌	✅	❌	❌	no colors	`NO_COLOR` `FORCE_COLOR`
`kolorist` 6.8KB `✅ named import` `❌ standard`	`16` colors	✅	✅	❌	❌	❌	256 color ❌ no colors	`NO_COLOR` `FORCE_COLOR`
`chalk` 15KB `❌ named import` `✅ standard`	`16` colors	✅	✅	✅	❌	✅	256 color 16 colors no colors	`NO_COLOR` `FORCE_COLOR` `--no-color` `--color`
`ansis` 3.5KB `✅ named import` `✅ standard`	`16` colors	✅	✅	✅	✅	✅	256 color 16 colors no colors	`NO_COLOR` `FORCE_COLOR` `--no-color` `--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:

colors-cli: x<n>

cli-color: xterm(n)

chalk: ansi256(n) bgAnsi256(n)

ansis: ansi256(n) bgAnsi256(n) fg(n) bg(n)

TrueColor

The method names:

chalk: hex() rgb()

ansis: hex() rgb()

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`);

↑ top

Show ANSI demo

git clone https://github.com/webdiscus/ansis.git
cd ./ansis
npm i
npm run demo

Benchmark

To measure performance is used benchmark.js.

‼️ Warning

Don't trust other test results using vitest benchmark.

The vitest benchmark generate FALSE/unreal results.
For example, the results of the simple bench:
chalk.red('foo') -  7.000.000 ops/sec
ansis.red('foo') - 23.000.000 ops/sec (x3 faster is WRONG result)
The real performance results of chalk and ansis in this test are very close.

Run benchmark

git clone https://github.com/webdiscus/ansis.git
cd ./ansis
npm i
npm run bench

Tested on

MacBook Pro 16" M1 Max 64GB
macOS Monterey 12.1
Node.js v16.13.1
Terminal iTerm2

Colorette bench

The benchmark used in colorette.

c.red(`${c.bold(`${c.cyan(`${c.yellow('yellow')}cyan`)}`)}red`);

+  colorette           4,572,582 ops/sec   very fast
   picocolors          3,841,124 ops/sec   very fast
-> ansis               2,725,758 ops/sec   fast
   chalk               2,287,146 ops/sec   fast
   kleur/colors        2,281,415 ops/sec   fast
   kleur               2,228,639 ops/sec   fast
   ansi-colors         1,265,615 ops/sec   slow
   colors.js           1,158,572 ops/sec   slow
   cli-color             470,320 ops/sec   too slow
   colors-cli            109,811 ops/sec   too slow

Base colors

const colors = ['black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'];
colors.forEach((color) => c[color]('foo'));

+  picocolors          8,265,628 ops/sec  very fast
-> ansis               6,197,754 ops/sec  fast
   kleur               5,455,121 ops/sec  fast
   chalk               4,428,884 ops/sec  fast
   kleur/colors        2,074,111 ops/sec  slow
   colorette           1,874,506 ops/sec  slow
   ansi-colors         1,010,628 ops/sec  slow
   colors.js             640,101 ops/sec  too slow
   cli-color             305,690 ops/sec  too slow
   colors-cli            104,962 ops/sec  too slow

Chained styles

const colors = ['black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'];
colors.forEach((color) => c[color].bold.underline.italic('foo'));

+  ansis               5,515,868 ops/sec  very fast
   chalk               1,234,573 ops/sec  fast
   kleur                 514,035 ops/sec  slow
   ansi-colors           158,921 ops/sec  too slow
   cli-color             144,837 ops/sec  too slow
   colors.js             138,219 ops/sec  too slow
   colors-cli             52,732 ops/sec  too slow
   kleur/colors        (not supported)
   colorette           (not supported)
   picocolors          (not supported)

Nested calls

const colors = ['black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white'];
colors.forEach((color) => c[color](c.bold(c.underline(c.italic('foo')))));

+  picocolors            942,592 ops/sec  very fast
   colorette             695,350 ops/sec  fast
   kleur                 648,195 ops/sec  fast
   kleur/colors          561,111 ops/sec  fast
-> ansis                 558,575 ops/sec  fast
   chalk                 497,292 ops/sec  fast
   ansi-colors           260,316 ops/sec  slow
   colors.js             166,425 ops/sec  slow
   cli-color              65,561 ops/sec  too slow
   colors-cli             13,800 ops/sec  too slow

Nested styles

c.red(
  `a red ${c.white('white')} red ${c.red('red')} red ${c.cyan('cyan')} red ${c.black('black')} red ${c.red('red')} red
  ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red
  ${c.green('green')} red ${c.red('red')} red ${c.yellow('yellow')} red ${c.blue('blue')} red ${c.red('red')} red
  ${c.magenta('magenta')} red ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red
  ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red
  ${c.black('black')} red ${c.yellow('yellow')} red ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red
  ${c.yellow('yellow')} red ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red
  ${c.green('green')} red ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red
  ${c.magenta('magenta')} red ${c.red('red')} red ${c.red('red')} red ${c.cyan('cyan')} red ${c.red('red')} red
  ${c.cyan('cyan')} red ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red ${c.red('red')} red message`
);

+  picocolors            243,975 ops/sec  very fast
   colorette             243,139 ops/sec  very fast
   kleur/colors          234,132 ops/sec  very fast
   kleur                 221,446 ops/sec  very fast
-> ansis                 211,868 ops/sec  very fast
   chalk                 189,960 ops/sec  fast
   ansi-colors           121,451 ops/sec  slow
   colors.js              89,633 ops/sec  too slow
   cli-color              41,657 ops/sec  too slow
   colors-cli             14,264 ops/sec  too slow

Deep nested styles

c.green(
  `green ${c.cyan(
    `cyan ${c.red(
      `red ${c.yellow(
        `yellow ${c.blue(
          `blue ${c.magenta(`magenta ${c.underline(`underline ${c.italic(`italic`)} underline`)} magenta`)} blue`
        )} yellow`
      )} red`
    )} cyan`
  )} green`
);

+  colorette           1,131,757 ops/sec  very fast
   picocolors          1,002,649 ops/sec  very fast
-> ansis                 882,220 ops/sec  very fast
   chalk                 565,965 ops/sec  fast
   kleur/colors          478,547 ops/sec  fast
   kleur                 464,004 ops/sec  fast
   colors.js             451,592 ops/sec  fast
   ansi-colors           362,733 ops/sec  slow
   cli-color             213,441 ops/sec  slow
   colors-cli             40,340 ops/sec  too slow

HEX colors

Only two libraries support TrueColor: ansis and chalk

c.hex('#FBA')('foo');

+  ansis               4,944,572 ops/sec  very fast
   chalk               2,891,684 ops/sec  fast
   colors.js           (not supported)
   colorette           (not supported)
   picocolors          (not supported)
   cli-color           (not supported)
   colors-cli          (not supported)
   ansi-colors         (not supported)
   kleur/colors        (not supported)
   kleur               (not supported)

↑ top

Testing

npm run test will run the unit and integration tests.
npm run test:coverage will run the tests with coverage.

Also See

Most popular ANSI libraries for Node.js:

License

ISC

Colors supported depends on actual terminal. ↩ ↩² ↩³
The Windows terminal supports true color since Windows 10 revision 14931 (2016-09-21). ↩ ↩²

Name		Name	Last commit message	Last commit date
Latest commit History 53 Commits
.github		.github
bench		bench
compare		compare
docs		docs
examples		examples
src		src
test		test
.codecov.yml		.codecov.yml
.editorconfig		.editorconfig
.gitignore		.gitignore
.npmignore		.npmignore
.prettierrc		.prettierrc
CHANGELOG.md		CHANGELOG.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
README.npm.md		README.npm.md
SECURITY.md		SECURITY.md
package.json		package.json
package.npm.json		package.npm.json
rollup.config.js		rollup.config.js
vitest.config.js		vitest.config.js

License

webdiscus/ansis

Folders and files

Latest commit

History

Repository files navigation

Usage example

👀 Why yet one lib?

🏆 Compare & Benchmark

💡 Highlights

🔆 What's New in v3

⚠️ Warning

❓Question / Feature Request / Bug

Install and Quick Start

Named import

Template literals

Chained syntax

Nested syntax

Base ANSI 16 colors and styles

Extend base colors

ANSI 256 colors

Fallback

Usage example

TrueColor

Fallback

Use ANSI codes

Strip ANSI codes

New lines

Shortcuts / Themes

CLI

Environment variables

CLI arguments

Color support

Comparison of most popular libraries

Show ANSI demo

Benchmark

Run benchmark

Tested on

Colorette bench

Base colors

Chained styles

Nested calls

Nested styles

Deep nested styles

HEX colors

Testing

Also See

License

Footnotes

About

Topics

Resources

License

Code of conduct

Security policy

Stars

Watchers

Forks

Sponsor this project

Languages