Merge branch 'master' of https://github.com/chalk/chalk

.flowconfig

@@ -3,3 +3,4 @@
 
 [options]
 suppress_comment= \\(.\\|\n\\)*\\$ExpectError
+include_warnings=true

.travis.yml

@@ -1,5 +1,6 @@
 language: node_js
 node_js:
+  - '10'
   - '8'
   - '6'
 after_success:

index.d.ts

@@ -0,0 +1,276 @@
+export const enum Level {
+	/**
+	 * All colors disabled.
+	 */
+	None = 0,
+
+	/**
+	 * Basic 16 colors support.
+	 */
+	Basic = 1,
+
+	/**
+	 * ANSI 256 colors support.
+	 */
+	Ansi256 = 2,
+
+	/**
+	 * Truecolor 16 million colors support.
+	 */
+	TrueColor = 3
+}
+
+export interface Options {
+	/**
+	 * Enable or disable Chalk.
+	 *
+	 * @default true
+	 */
+	enabled?: boolean;
+
+	/**
+	 * Specify the color support for Chalk.
+	 * By default, color support is automatically detected based on the environment.
+	 */
+	level?: Level;
+}
+
+export interface Constructor {
+	/**
+	 * Return a new Chalk instance.
+	 */
+	new (options?: Options): Chalk;
+}
+
+/**
+ * Detect whether the terminal supports color.
+ */
+export interface ColorSupport {
+	/**
+	 * The color level used by Chalk.
+	 */
+	level: Level;
+
+	/**
+	 * Return whether Chalk supports basic 16 colors.
+	 */
+	hasBasic: boolean;
+
+	/**
+	 * Return whether Chalk supports ANSI 256 colors.
+	 */
+	has256: boolean;
+
+	/**
+	 * Return whether Chalk supports Truecolor 16 million colors.
+	 */
+	has16m: boolean;
+}
+
+export interface Chalk {
+	(...text: unknown[]): string;
+
+	(text: TemplateStringsArray, ...placeholders: unknown[]): string;
+
+	/**
+	 * Return a new Chalk instance.
+	 */
+	constructor: Constructor;
+
+	/**
+	 * Enable or disable Chalk.
+	 *
+	 * @default true
+	 */
+	enabled: boolean;
+
+	/**
+	 * The color support for Chalk.
+	 * By default, color support is automatically detected based on the environment.
+	 */
+	level: Level;
+
+	/**
+	 * Use HEX value to set text color.
+	 *
+	 * @param color - Hexadecimal value representing the desired color.
+	 *
+	 * @example
+	 *
+	 * import chalk from 'chalk';
+	 *
+	 * chalk.hex('#DEADED');
+	 */
+	hex(color: string): this;
+
+	/**
+	 * Use keyword color value to set text color.
+	 *
+	 * @param color - Keyword value representing the desired color.
+	 *
+	 * @example
+	 *
+	 * import chalk from 'chalk';
+	 *
+	 * chalk.keyword('orange');
+	 */
+	keyword(color: string): this;
+
+	/**
+	 * Use RGB values to set text color.
+	 */
+	rgb(red: number, green: number, blue: number): this;
+
+	/**
+	 * Use HSL values to set text color.
+	 */
+	hsl(hue: number, saturation: number, lightness: number): this;
+
+	/**
+	 * Use HSV values to set text color.
+	 */
+	hsv(hue: number, saturation: number, value: number): this;
+
+	/**
+	 * Use HWB values to set text color.
+	 */
+	hwb(hue: number, whiteness: number, blackness: number): this;
+
+	/**
+	 * Use HEX value to set background color.
+	 *
+	 * @param color - Hexadecimal value representing the desired color.
+	 *
+	 * @example
+	 *
+	 * import chalk from 'chalk';
+	 *
+	 * chalk.bgHex('#DEADED');
+	 */
+	bgHex(color: string): this;
+
+	/**
+	 * Use keyword color value to set background color.
+	 *
+	 * @param color - Keyword value representing the desired color.
+	 *
+	 * @example
+	 *
+	 * import chalk from 'chalk';
+	 *
+	 * chalk.bgKeyword('orange');
+	 */
+	bgKeyword(color: string): this;
+
+	/**
+	 * Use RGB values to set background color.
+	 */
+	bgRgb(red: number, green: number, blue: number): this;
+
+	/**
+	 * Use HSL values to set background color.
+	 */
+	bgHsl(hue: number, saturation: number, lightness: number): this;
+
+	/**
+	 * Use HSV values to set background color.
+	 */
+	bgHsv(hue: number, saturation: number, value: number): this;
+
+	/**
+	 * Use HWB values to set background color.
+	 */
+	bgHwb(hue: number, whiteness: number, blackness: number): this;
+
+	/**
+	 * Modifier: Resets the current color chain.
+	 */
+	readonly reset: this;
+
+	/**
+	 * Modifier: Make text bold.
+	 */
+	readonly bold: this;
+
+	/**
+	 * Modifier: Emitting only a small amount of light.
+	 */
+	readonly dim: this;
+
+	/**
+	 * Modifier: Make text italic. (Not widely supported)
+	 */
+	readonly italic: this;
+
+	/**
+	 * Modifier: Make text underline. (Not widely supported)
+	 */
+	readonly underline: this;
+
+	/**
+	 * Modifier: Inverse background and foreground colors.
+	 */
+	readonly inverse: this;
+
+	/**
+	 * Modifier: Prints the text, but makes it invisible.
+	 */
+	readonly hidden: this;
+
+	/**
+	 * Modifier: Puts a horizontal line through the center of the text. (Not widely supported)
+	 */
+	readonly strikethrough: this;
+
+	/**
+	 * Modifier: Prints the text only when Chalk is enabled.
+	 * Can be useful for things that are purely cosmetic.
+	 */
+	readonly visible: this;
+
+	readonly black: this;
+	readonly red: this;
+	readonly green: this;
+	readonly yellow: this;
+	readonly blue: this;
+	readonly magenta: this;
+	readonly cyan: this;
+	readonly white: this;
+	readonly gray: this;
+	readonly grey: this;
+	readonly blackBright: this;
+	readonly redBright: this;
+	readonly greenBright: this;
+	readonly yellowBright: this;
+	readonly blueBright: this;
+	readonly magentaBright: this;
+	readonly cyanBright: this;
+	readonly whiteBright: this;
+
+	readonly bgBlack: this;
+	readonly bgRed: this;
+	readonly bgGreen: this;
+	readonly bgYellow: this;
+	readonly bgBlue: this;
+	readonly bgMagenta: this;
+	readonly bgCyan: this;
+	readonly bgWhite: this;
+	readonly bgBlackBright: this;
+	readonly bgRedBright: this;
+	readonly bgGreenBright: this;
+	readonly bgYellowBright: this;
+	readonly bgBlueBright: this;
+	readonly bgMagentaBright: this;
+	readonly bgCyanBright: this;
+	readonly bgWhiteBright: this;
+}
+
+/**
+ * Main Chalk object that allows to chain styles together.
+ * Call the last one as a method with a string argument.
+ * Order doesn't matter, and later styles take precedent in case of a conflict.
+ * This simply means that `chalk.red.yellow.green` is equivalent to `chalk.green`.
+ */
+declare const chalk: Chalk & { supportsColor: ColorSupport };
+
+export default chalk;

index.js

@@ -1,8 +1,7 @@
 'use strict';
 const escapeStringRegexp = require('escape-string-regexp');
 const ansiStyles = require('ansi-styles');
-const stdoutColor = require('supports-color').stdout;
+const {stdout: stdoutColor} = require('supports-color');
-
 const template = require('./templates.js');
 
 const isSimpleWindowsTerm = process.platform === 'win32' && !(process.env.TERM || '').toLowerCase().startsWith('xterm');
@@ -15,15 +14,15 @@ const skipModels = new Set(['gray']);
 
 const styles = Object.create(null);
 
-function applyOptions(obj, options = {}) {
+function applyOptions(object, options = {}) {
 	if (options.level > 3 || options.level < 0) {
 		throw new Error('The `level` option should be an integer from 0 to 3');
 	}
 
 	// Detect level if not set manually
-	const scLevel = stdoutColor ? stdoutColor.level : 0;
+	const colorLevel = stdoutColor ? stdoutColor.level : 0;
-	obj.level = options.level === undefined ? scLevel : options.level;
+	object.level = options.level === undefined ? colorLevel : options.level;
-	obj.enabled = 'enabled' in options ? options.enabled : obj.level > 0;
+	object.enabled = 'enabled' in options ? options.enabled : object.level > 0;
 }
 
 function Chalk(options) {
@@ -33,7 +32,7 @@ function Chalk(options) {
 		const chalk = {};
 		applyOptions(chalk, options);
 
-		chalk.template = (...args) => chalkTag(...[chalk.template].concat(args));
+		chalk.template = (...args) => chalkTag(chalk.template, ...args);
 
 		Object.setPrototypeOf(chalk, Chalk.prototype);
 		Object.setPrototypeOf(chalk.template, chalk);
@@ -57,7 +56,7 @@ for (const key of Object.keys(ansiStyles)) {
 	styles[key] = {
 		get() {
 			const codes = ansiStyles[key];
-			return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, key);
+			return build.call(this, [...(this._styles || []), codes], this._empty, key);
 		}
 	};
 }
@@ -84,7 +83,7 @@ for (const model of Object.keys(ansiStyles.color.ansi)) {
 					close: ansiStyles.color.close,
 					closeRe: ansiStyles.color.closeRe
 				};
-				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+				return build.call(this, [...(this._styles || []), codes], this._empty, model);
 			};
 		}
 	};
@@ -107,7 +106,7 @@ for (const model of Object.keys(ansiStyles.bgColor.ansi)) {
 					close: ansiStyles.bgColor.close,
 					closeRe: ansiStyles.bgColor.closeRe
 				};
-				return build.call(this, this._styles ? this._styles.concat(codes) : [codes], this._empty, model);
+				return build.call(this, [...(this._styles || []), codes], this._empty, model);
 			};
 		}
 	};
@@ -153,23 +152,10 @@ function build(_styles, _empty, key) {
 }
 
 function applyStyle(...args) {
-	// Support varags, but simply cast to string in case there's only one arg
+	let string = args.join(' ');
-	const argsLen = args.length;
-	let str = String(args[0]);
 
-	if (argsLen === 0) {
+	if (!this.enabled || this.level <= 0 || !string) {
-		return '';
+		return this._empty ? '' : string;
-	}
-
-	if (argsLen > 1) {
-		// Don't slice `arguments`, it prevents V8 optimizations
-		for (let a = 1; a < argsLen; a++) {
-			str += ' ' + args[a];
-		}
-	}
-
-	if (!this.enabled || this.level <= 0 || !str) {
-		return this._empty ? '' : str;
 	}
 
 	// Turns out that on Windows dimmed gray text becomes invisible in cmd.exe,
@@ -184,22 +170,22 @@ function applyStyle(...args) {
 		// Replace any instances already present with a re-opening code
 		// otherwise only the part of the string until said closing code
 		// will be colored, and the rest will simply be 'plain'.
-		str = code.open + str.replace(code.closeRe, code.open) + code.close;
+		string = code.open + string.replace(code.closeRe, code.open) + code.close;
 
 		// Close the styling before a linebreak and reopen
 		// after next line to fix a bleed issue on macOS
 		// https://github.com/chalk/chalk/pull/92
-		str = str.replace(/\r?\n/g, `${code.close}$&${code.open}`);
+		string = string.replace(/\r?\n/g, `${code.close}$&${code.open}`);
 	}
 
 	// Reset the original `dim` if we changed it to work around the Windows dimmed gray issue
 	ansiStyles.dim.open = originalDim;
 
-	return str;
+	return string;
 }
 
 function chalkTag(chalk, ...strings) {
-	const firstString = strings[0];
+	const [firstString] = strings;
 
 	if (!Array.isArray(firstString)) {
 		// If chalk() was called by itself or with a string,
@@ -211,8 +197,10 @@ function chalkTag(chalk, ...strings) {
 	const parts = [firstString.raw[0]];
 
 	for (let i = 1; i < firstString.length; i++) {
-		parts.push(String(args[i - 1]).replace(/[{}\\]/g, '\\$&'));
+		parts.push(
-		parts.push(String(firstString.raw[i]));
+			String(args[i - 1]).replace(/[{}\\]/g, '\\$&'),
+			String(firstString.raw[i])
+		);
 	}
 
 	return template(chalk, parts.join(''));

index.js.flow

@@ -9,7 +9,7 @@ export type Level = $Values<{
 	TrueColor: 3
 }>;
 
-export type ChalkOptions = {|
+export type Options = {|
 	enabled?: boolean,
 	level?: Level
 |};
@@ -22,21 +22,21 @@ export type ColorSupport = {|
 |};
 
 export interface Chalk {
-	(...text: mixed[]): string,
+	(...text: string[]): string,
 	(text: TemplateStringsArray, ...placeholders: mixed[]): string,
-	constructor(options?: ChalkOptions): Chalk,
+	constructor(options?: Options): Chalk,
 	enabled: boolean,
 	level: Level,
-	rgb(r: number, g: number, b: number): Chalk,
+	rgb(red: number, green: number, blue: number): Chalk,
-	hsl(h: number, s: number, l: number): Chalk,
+	hsl(hue: number, saturation: number, lightness: number): Chalk,
-	hsv(h: number, s: number, v: number): Chalk,
+	hsv(hue: number, saturation: number, value: number): Chalk,
-	hwb(h: number, w: number, b: number): Chalk,
+	hwb(hue: number, whiteness: number, blackness: number): Chalk,
 	bgHex(color: string): Chalk,
 	bgKeyword(color: string): Chalk,
-	bgRgb(r: number, g: number, b: number): Chalk,
+	bgRgb(red: number, green: number, blue: number): Chalk,
-	bgHsl(h: number, s: number, l: number): Chalk,
+	bgHsl(hue: number, saturation: number, lightness: number): Chalk,
-	bgHsv(h: number, s: number, v: number): Chalk,
+	bgHsv(hue: number, saturation: number, value: number): Chalk,
-	bgHwb(h: number, w: number, b: number): Chalk,
+	bgHwb(hue: number, whiteness: number, blackness: number): Chalk,
 	hex(color: string): Chalk,
 	keyword(color: string): Chalk,
 
@@ -85,7 +85,7 @@ export interface Chalk {
 	+bgBlueBright: Chalk,
 	+bgMagentaBright: Chalk,
 	+bgCyanBright: Chalk,
-	+bgWhiteBrigh: Chalk,
+	+bgWhiteBright: Chalk,
 
 	supportsColor: ColorSupport
 };

index.test-d.ts

@@ -0,0 +1,138 @@
+import {expectType} from 'tsd-check';
+import chalk, {Level, Chalk, ColorSupport} from '.';
+
+// - Helpers -
+type colorReturn = Chalk & {supportsColor: ColorSupport};
+
+// - Level -
+expectType<number>(Level.None);
+expectType<number>(Level.Basic);
+expectType<number>(Level.Ansi256);
+expectType<number>(Level.TrueColor);
+
+// - supportsColor -
+expectType<boolean>(chalk.supportsColor.hasBasic);
+expectType<boolean>(chalk.supportsColor.has256);
+expectType<boolean>(chalk.supportsColor.has16m);
+
+// - Chalk -
+// -- Constructor --
+expectType<Chalk>(new chalk.constructor({level: 1}));
+
+// -- Properties --
+expectType<boolean>(chalk.enabled);
+expectType<Level>(chalk.level);
+
+// -- Template literal --
+expectType<string>(chalk``);
+const name = 'John';
+expectType<string>(chalk`Hello {bold.red ${name}}`);
+expectType<string>(chalk`Works with numbers {bold.red ${1}}`);
+
+// -- Color methods --
+expectType<colorReturn>(chalk.hex('#DEADED'));
+expectType<colorReturn>(chalk.keyword('orange'));
+expectType<colorReturn>(chalk.rgb(0, 0, 0));
+expectType<colorReturn>(chalk.hsl(0, 0, 0));
+expectType<colorReturn>(chalk.hsv(0, 0, 0));
+expectType<colorReturn>(chalk.hwb(0, 0, 0));
+expectType<colorReturn>(chalk.bgHex('#DEADED'));
+expectType<colorReturn>(chalk.bgKeyword('orange'));
+expectType<colorReturn>(chalk.bgRgb(0, 0, 0));
+expectType<colorReturn>(chalk.bgHsl(0, 0, 0));
+expectType<colorReturn>(chalk.bgHsv(0, 0, 0));
+expectType<colorReturn>(chalk.bgHwb(0, 0, 0));
+
+// -- Modifiers --
+expectType<string>(chalk.reset('foo'));
+expectType<string>(chalk.bold('foo'));
+expectType<string>(chalk.dim('foo'));
+expectType<string>(chalk.italic('foo'));
+expectType<string>(chalk.underline('foo'));
+expectType<string>(chalk.inverse('foo'));
+expectType<string>(chalk.hidden('foo'));
+expectType<string>(chalk.strikethrough('foo'));
+expectType<string>(chalk.visible('foo'));
+expectType<string>(chalk.reset`foo`);
+expectType<string>(chalk.bold`foo`);
+expectType<string>(chalk.dim`foo`);
+expectType<string>(chalk.italic`foo`);
+expectType<string>(chalk.underline`foo`);
+expectType<string>(chalk.inverse`foo`);
+expectType<string>(chalk.hidden`foo`);
+expectType<string>(chalk.strikethrough`foo`);
+expectType<string>(chalk.visible`foo`);
+
+// -- Colors --
+expectType<string>(chalk.black('foo'));
+expectType<string>(chalk.red('foo'));
+expectType<string>(chalk.green('foo'));
+expectType<string>(chalk.yellow('foo'));
+expectType<string>(chalk.blue('foo'));
+expectType<string>(chalk.magenta('foo'));
+expectType<string>(chalk.cyan('foo'));
+expectType<string>(chalk.white('foo'));
+expectType<string>(chalk.gray('foo'));
+expectType<string>(chalk.grey('foo'));
+expectType<string>(chalk.blackBright('foo'));
+expectType<string>(chalk.redBright('foo'));
+expectType<string>(chalk.greenBright('foo'));
+expectType<string>(chalk.yellowBright('foo'));
+expectType<string>(chalk.blueBright('foo'));
+expectType<string>(chalk.magentaBright('foo'));
+expectType<string>(chalk.cyanBright('foo'));
+expectType<string>(chalk.whiteBright('foo'));
+expectType<string>(chalk.bgBlack('foo'));
+expectType<string>(chalk.bgRed('foo'));
+expectType<string>(chalk.bgGreen('foo'));
+expectType<string>(chalk.bgYellow('foo'));
+expectType<string>(chalk.bgBlue('foo'));
+expectType<string>(chalk.bgMagenta('foo'));
+expectType<string>(chalk.bgCyan('foo'));
+expectType<string>(chalk.bgWhite('foo'));
+expectType<string>(chalk.bgBlackBright('foo'));
+expectType<string>(chalk.bgRedBright('foo'));
+expectType<string>(chalk.bgGreenBright('foo'));
+expectType<string>(chalk.bgYellowBright('foo'));
+expectType<string>(chalk.bgBlueBright('foo'));
+expectType<string>(chalk.bgMagentaBright('foo'));
+expectType<string>(chalk.bgCyanBright('foo'));
+expectType<string>(chalk.bgWhiteBright('foo'));
+expectType<string>(chalk.black`foo`);
+expectType<string>(chalk.red`foo`);
+expectType<string>(chalk.green`foo`);
+expectType<string>(chalk.yellow`foo`);
+expectType<string>(chalk.blue`foo`);
+expectType<string>(chalk.magenta`foo`);
+expectType<string>(chalk.cyan`foo`);
+expectType<string>(chalk.white`foo`);
+expectType<string>(chalk.gray`foo`);
+expectType<string>(chalk.grey`foo`);
+expectType<string>(chalk.blackBright`foo`);
+expectType<string>(chalk.redBright`foo`);
+expectType<string>(chalk.greenBright`foo`);
+expectType<string>(chalk.yellowBright`foo`);
+expectType<string>(chalk.blueBright`foo`);
+expectType<string>(chalk.magentaBright`foo`);
+expectType<string>(chalk.cyanBright`foo`);
+expectType<string>(chalk.whiteBright`foo`);
+expectType<string>(chalk.bgBlack`foo`);
+expectType<string>(chalk.bgRed`foo`);
+expectType<string>(chalk.bgGreen`foo`);
+expectType<string>(chalk.bgYellow`foo`);
+expectType<string>(chalk.bgBlue`foo`);
+expectType<string>(chalk.bgMagenta`foo`);
+expectType<string>(chalk.bgCyan`foo`);
+expectType<string>(chalk.bgWhite`foo`);
+expectType<string>(chalk.bgBlackBright`foo`);
+expectType<string>(chalk.bgRedBright`foo`);
+expectType<string>(chalk.bgGreenBright`foo`);
+expectType<string>(chalk.bgYellowBright`foo`);
+expectType<string>(chalk.bgBlueBright`foo`);
+expectType<string>(chalk.bgMagentaBright`foo`);
+expectType<string>(chalk.bgCyanBright`foo`);
+expectType<string>(chalk.bgWhiteBright`foo`);
+
+// -- Complex --
+expectType<string>(chalk.red.bgGreen.underline('foo'));
+expectType<string>(chalk.underline.red.bgGreen('foo'));

package.json

@@ -8,13 +8,13 @@
 		"node": ">=6"
 	},
 	"scripts": {
-		"test": "xo && nyc ava && tsc --project types && flow --max-warnings=0",
+		"test": "xo && nyc ava && tsd-check && flow",
 		"bench": "matcha benchmark.js"
 	},
 	"files": [
 		"index.js",
 		"templates.js",
-		"types/index.d.ts",
+		"index.d.ts",
 		"index.js.flow"
 	],
 	"keywords": [
@@ -43,21 +43,22 @@
 	"dependencies": {
 		"ansi-styles": "^3.2.1",
 		"escape-string-regexp": "^1.0.5",
-		"supports-color": "^5.5.0"
+		"supports-color": "^6.0.0"
 	},
 	"devDependencies": {
-		"ava": "^0.25.0",
+		"@sindresorhus/tsconfig": "^0.1.1",
+		"ava": "^1.0.1",
 		"coveralls": "^3.0.2",
 		"execa": "^1.0.0",
-		"flow-bin": "^0.81.0",
+		"flow-bin": "^0.89.0",
-		"import-fresh": "^2.0.0",
+		"import-fresh": "^3.0.0",
 		"matcha": "^0.7.0",
-		"nyc": "^13.0.1",
+		"nyc": "^13.1.0",
 		"resolve-from": "^4.0.0",
-		"typescript": "^3.0.3",
+		"tsd-check": "^0.3.0",
 		"xo": "^0.23.0"
 	},
-	"types": "types/index.d.ts",
+	"types": "index.d.ts",
 	"xo": {
 		"ignores": [
 			"test/_flow.js"

readme.md

@@ -138,7 +138,7 @@ Multiple arguments will be separated by space.
 
 ### chalk.enabled
 
-Color support is automatically detected, as is the level (see `chalk.level`). However, if you'd like to simply enable/disable Chalk, you can do so via the `.enabled` property.
+Color support is automatically detected, as is the level (see `chalk.level`). However, if you'd like to simply enable/disable Chalk, you can do so via the `.enabled` property. When `chalk.enabled` is `true`, `chalk.level` must *also* be greater than `0` for colored output to be produced.
 
 Chalk is enabled by default unless explicitly disabled via the constructor or `chalk.level` is `0`.
 
@@ -150,7 +150,7 @@ const ctx = new chalk.constructor({enabled: false});
 
 ### chalk.level
 
-Color support is automatically detected, but you can override it by setting the `level` property. You should however only do this in your own code as it applies globally to all Chalk consumers.
+Color support is automatically detected, but you can override it by setting the `level` property. You should however only do this in your own code as it applies globally to all Chalk consumers. When `chalk.level` is greater than `0`, `chalk.enabled` must *also* be `true` for colored output to be produced.
 
 If you need to change this in a reusable module, create a new instance:
 
@@ -178,15 +178,15 @@ Explicit 256/Truecolor mode can be enabled using the `--color=256` and `--color=
 
 ### Modifiers
 
-- `reset`
+- `reset` - Resets the current color chain.
-- `bold`
+- `bold` - Make text bold.
-- `dim`
+- `dim` - Emitting only a small amount of light.
-- `italic` *(Not widely supported)*
+- `italic` - Make text italic. *(Not widely supported)*
-- `underline`
+- `underline` - Make text underline. *(Not widely supported)*
-- `inverse`
+- `inverse`- Inverse background and foreground colors.
-- `hidden`
+- `hidden` - Prints the text, but makes it invisible.
-- `strikethrough` *(Not widely supported)*
+- `strikethrough` - Puts a horizontal line through the center of the text. *(Not widely supported)*
-- `visible` (Text is emitted only if enabled)
+- `visible`- Prints the text only when Chalk is enabled. Can be useful for things that are purely cosmetic.
 
 ### Colors
 
@@ -297,6 +297,11 @@ If you're on Windows, do yourself a favor and use [`cmder`](http://cmder.net/) i
 [colors.js](https://github.com/Marak/colors.js) used to be the most popular string styling module, but it has serious deficiencies like extending `String.prototype` which causes all kinds of [problems](https://github.com/yeoman/yo/issues/68) and the package is unmaintained. Although there are other packages, they either do too much or not enough. Chalk is a clean and focused alternative.
 
 
+## Security
+
+To report a security vulnerability, please use the [Tidelift security contact](https://tidelift.com/security). Tidelift will coordinate the fix and disclosure.
+
+
 ## Related
 
 - [chalk-cli](https://github.com/chalk/chalk-cli) - CLI for this module

templates.js

@@ -31,10 +31,11 @@ function parseArguments(name, args) {
 	let matches;
 
 	for (const chunk of chunks) {
-		if (!isNaN(chunk)) {
+		const number = Number(chunk);
-			results.push(Number(chunk));
+		if (!Number.isNaN(number)) {
+			results.push(number);
 		} else if ((matches = chunk.match(STRING_REGEX))) {
-			results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, chr) => escape ? unescape(escape) : chr));
+			results.push(matches[2].replace(ESCAPE_REGEX, (m, escape, character) => escape ? unescape(escape) : character));
 		} else {
 			throw new Error(`Invalid Chalk template style argument: ${chunk} (in style '${name}')`);
 		}
@@ -50,7 +51,7 @@ function parseStyle(style) {
 	let matches;
 
 	while ((matches = STYLE_REGEX.exec(style)) !== null) {
-		const name = matches[1];
+		const name = matches[1]; // eslint-disable-line prefer-destructuring
 
 		if (matches[2]) {
 			const args = parseArguments(name, matches[2]);
@@ -73,17 +74,20 @@ function buildStyle(chalk, styles) {
 	}
 
 	let current = chalk;
+	// TODO: Use `Object.entries` when targeting Node.js 8
 	for (const styleName of Object.keys(enabled)) {
-		if (Array.isArray(enabled[styleName])) {
+		if (!Array.isArray(enabled[styleName])) {
-			if (!(styleName in current)) {
+			continue;
-				throw new Error(`Unknown Chalk style: ${styleName}`);
+		}
-			}
 
-			if (enabled[styleName].length > 0) {
+		if (!(styleName in current)) {
-				current = current[styleName](...enabled[styleName]);
+			throw new Error(`Unknown Chalk style: ${styleName}`);
-			} else {
+		}
-				current = current[styleName];
+
-			}
+		if (enabled[styleName].length > 0) {
+			current = current[styleName](...enabled[styleName]);
+		} else {
+			current = current[styleName];
 		}
 	}
 
@@ -96,13 +100,13 @@ module.exports = (chalk, tmp) => {
 	let chunk = [];
 
 	// eslint-disable-next-line max-params
-	tmp.replace(TEMPLATE_REGEX, (m, escapeChar, inverse, style, close, chr) => {
+	tmp.replace(TEMPLATE_REGEX, (m, escapeCharacter, inverse, style, close, character) => {
-		if (escapeChar) {
+		if (escapeCharacter) {
-			chunk.push(unescape(escapeChar));
+			chunk.push(unescape(escapeCharacter));
 		} else if (style) {
-			const str = chunk.join('');
+			const string = chunk.join('');
 			chunk = [];
-			chunks.push(styles.length === 0 ? str : buildStyle(chalk, styles)(str));
+			chunks.push(styles.length === 0 ? string : buildStyle(chalk, styles)(string));
 			styles.push({inverse, styles: parseStyle(style)});
 		} else if (close) {
 			if (styles.length === 0) {
@@ -113,7 +117,7 @@ module.exports = (chalk, tmp) => {
 			chunk = [];
 			styles.pop();
 		} else {
-			chunk.push(chr);
+			chunk.push(character);
 		}
 	});
 

tsconfig.json

@@ -0,0 +1,7 @@
+{
+	"extends": "@sindresorhus/tsconfig",
+	"compilerOptions": {
+		"noEmit": true,
+		"allowJs": true
+	}
+}

types/index.d.ts

@@ -1,97 +0,0 @@
-// Type definitions for Chalk
-// Definitions by: Thomas Sauer <https://github.com/t-sauer>
-
-export const enum Level {
-	None = 0,
-	Basic = 1,
-	Ansi256 = 2,
-	TrueColor = 3
-}
-
-export interface ChalkOptions {
-	enabled?: boolean;
-	level?: Level;
-}
-
-export interface ChalkConstructor {
-	new (options?: ChalkOptions): Chalk;
-	(options?: ChalkOptions): Chalk;
-}
-
-export interface ColorSupport {
-	level: Level;
-	hasBasic: boolean;
-	has256: boolean;
-	has16m: boolean;
-}
-
-export interface Chalk {
-	(...text: unknown[]): string;
-	(text: TemplateStringsArray, ...placeholders: unknown[]): string;
-	constructor: ChalkConstructor;
-	enabled: boolean;
-	level: Level;
-	rgb(r: number, g: number, b: number): this;
-	hsl(h: number, s: number, l: number): this;
-	hsv(h: number, s: number, v: number): this;
-	hwb(h: number, w: number, b: number): this;
-	bgHex(color: string): this;
-	bgKeyword(color: string): this;
-	bgRgb(r: number, g: number, b: number): this;
-	bgHsl(h: number, s: number, l: number): this;
-	bgHsv(h: number, s: number, v: number): this;
-	bgHwb(h: number, w: number, b: number): this;
-	hex(color: string): this;
-	keyword(color: string): this;
-
-	readonly reset: this;
-	readonly bold: this;
-	readonly dim: this;
-	readonly italic: this;
-	readonly underline: this;
-	readonly inverse: this;
-	readonly hidden: this;
-	readonly strikethrough: this;
-
-	readonly visible: this;
-
-	readonly black: this;
-	readonly red: this;
-	readonly green: this;
-	readonly yellow: this;
-	readonly blue: this;
-	readonly magenta: this;
-	readonly cyan: this;
-	readonly white: this;
-	readonly gray: this;
-	readonly grey: this;
-	readonly blackBright: this;
-	readonly redBright: this;
-	readonly greenBright: this;
-	readonly yellowBright: this;
-	readonly blueBright: this;
-	readonly magentaBright: this;
-	readonly cyanBright: this;
-	readonly whiteBright: this;
-
-	readonly bgBlack: this;
-	readonly bgRed: this;
-	readonly bgGreen: this;
-	readonly bgYellow: this;
-	readonly bgBlue: this;
-	readonly bgMagenta: this;
-	readonly bgCyan: this;
-	readonly bgWhite: this;
-	readonly bgBlackBright: this;
-	readonly bgRedBright: this;
-	readonly bgGreenBright: this;
-	readonly bgYellowBright: this;
-	readonly bgBlueBright: this;
-	readonly bgMagentaBright: this;
-	readonly bgCyanBright: this;
-	readonly bgWhiteBright: this;
-}
-
-declare const chalk: Chalk & { supportsColor: ColorSupport };
-
-export default chalk

types/test.ts

@@ -1,57 +0,0 @@
-import chalk, {Level} from '..';
-
-chalk.underline('foo');
-chalk.red('foo');
-chalk.bgRed('foo');
-
-const name = 'Josh';
-chalk`Hello {bold.red ${name}}`;
-
-chalk.red`foo`;
-chalk.underline`foo`;
-chalk`foo`;
-
-chalk.red.bgGreen.underline('foo');
-chalk.underline.red.bgGreen('foo');
-
-chalk.grey('foo');
-
-chalk.constructor({level: 1});
-const ctx = chalk.constructor({level: Level.TrueColor });
-ctx('foo');
-ctx.red('foo');
-ctx`foo`;
-ctx`works with numbers ${1}`;
-
-chalk.enabled = true;
-chalk.level = 1;
-chalk.level = Level.Ansi256;
-
-chalk.level === Level.Ansi256;
-
-let chalkInstance = new chalk.constructor();
-chalkInstance = chalk.constructor();
-
-chalkInstance.blue('foo');
-chalkInstance`foo`;
-
-let x = 'imastring';
-x = chalk();
-
-chalk.enabled;
-chalk.level;
-chalk.supportsColor.level;
-chalk.supportsColor.has16m;
-chalk.supportsColor.has256;
-chalk.supportsColor.hasBasic;
-
-chalk.keyword('orange').bgBlue('foo');
-chalk.hex('#123456').bgBlue('foo');
-chalk.rgb(1, 14, 9).bgBlue('foo');
-chalk.hsl(1, 14, 9).bgBlue('foo');
-chalk.hsv(1, 14, 9).bgBlue('foo');
-chalk.hwb(1, 14, 9).bgBlue('foo');
-
-chalk.visible('foo');
-chalk.red.visible('foo');
-chalk.visible.red('foo');

types/tsconfig.json

@@ -1,9 +0,0 @@
-{
-	"compilerOptions": {
-		"module": "commonjs",
-		"target": "es6",
-		"noImplicitAny": true,
-		"noEmit": true,
-		"allowJs": true
-	}
-}