push

lib/util/chalk/ansi-styles/index.d.ts

@@ -0,0 +1,194 @@
+export interface CSPair {
+  // eslint-disable-line @typescript-eslint/naming-convention
+  /**
+	The ANSI terminal control sequence for starting this style.
+	*/
+  readonly open: string;
+
+  /**
+	The ANSI terminal control sequence for ending this style.
+	*/
+  readonly close: string;
+}
+
+export interface ColorBase {
+  /**
+	The ANSI terminal control sequence for ending this color.
+	*/
+  readonly close: string;
+
+  ansi(code: number): string;
+
+  ansi256(code: number): string;
+
+  ansi16m(red: number, green: number, blue: number): string;
+}
+
+export interface Modifier {
+  /**
+	Resets the current color chain.
+	*/
+  readonly reset: CSPair;
+
+  /**
+	Make text bold.
+	*/
+  readonly bold: CSPair;
+
+  /**
+	Emitting only a small amount of light.
+	*/
+  readonly dim: CSPair;
+
+  /**
+	Make text italic. (Not widely supported)
+	*/
+  readonly italic: CSPair;
+
+  /**
+	Make text underline. (Not widely supported)
+	*/
+  readonly underline: CSPair;
+
+  /**
+	Make text overline.
+
+	Supported on VTE-based terminals, the GNOME terminal, mintty, and Git Bash.
+	*/
+  readonly overline: CSPair;
+
+  /**
+	Inverse background and foreground colors.
+	*/
+  readonly inverse: CSPair;
+
+  /**
+	Prints the text, but makes it invisible.
+	*/
+  readonly hidden: CSPair;
+
+  /**
+	Puts a horizontal line through the center of the text. (Not widely supported)
+	*/
+  readonly strikethrough: CSPair;
+}
+
+export interface ForegroundColor {
+  readonly black: CSPair;
+  readonly red: CSPair;
+  readonly green: CSPair;
+  readonly yellow: CSPair;
+  readonly blue: CSPair;
+  readonly cyan: CSPair;
+  readonly magenta: CSPair;
+  readonly white: CSPair;
+
+  /**
+	Alias for `blackBright`.
+	*/
+  readonly gray: CSPair;
+
+  /**
+	Alias for `blackBright`.
+	*/
+  readonly grey: CSPair;
+
+  readonly blackBright: CSPair;
+  readonly redBright: CSPair;
+  readonly greenBright: CSPair;
+  readonly yellowBright: CSPair;
+  readonly blueBright: CSPair;
+  readonly cyanBright: CSPair;
+  readonly magentaBright: CSPair;
+  readonly whiteBright: CSPair;
+}
+
+export interface BackgroundColor {
+  readonly bgBlack: CSPair;
+  readonly bgRed: CSPair;
+  readonly bgGreen: CSPair;
+  readonly bgYellow: CSPair;
+  readonly bgBlue: CSPair;
+  readonly bgCyan: CSPair;
+  readonly bgMagenta: CSPair;
+  readonly bgWhite: CSPair;
+
+  /**
+	Alias for `bgBlackBright`.
+	*/
+  readonly bgGray: CSPair;
+
+  /**
+	Alias for `bgBlackBright`.
+	*/
+  readonly bgGrey: CSPair;
+
+  readonly bgBlackBright: CSPair;
+  readonly bgRedBright: CSPair;
+  readonly bgGreenBright: CSPair;
+  readonly bgYellowBright: CSPair;
+  readonly bgBlueBright: CSPair;
+  readonly bgCyanBright: CSPair;
+  readonly bgMagentaBright: CSPair;
+  readonly bgWhiteBright: CSPair;
+}
+
+export interface ConvertColor {
+  /**
+	Convert from the RGB color space to the ANSI 256 color space.
+
+	@param red - (`0...255`)
+	@param green - (`0...255`)
+	@param blue - (`0...255`)
+	*/
+  rgbToAnsi256(red: number, green: number, blue: number): number;
+
+  /**
+	Convert from the RGB HEX color space to the RGB color space.
+
+	@param hex - A hexadecimal string containing RGB data.
+	*/
+  hexToRgb(hex: string): [red: number, green: number, blue: number];
+
+  /**
+	Convert from the RGB HEX color space to the ANSI 256 color space.
+
+	@param hex - A hexadecimal string containing RGB data.
+	*/
+  hexToAnsi256(hex: string): number;
+
+  /**
+	Convert from the ANSI 256 color space to the ANSI 16 color space.
+
+	@param code - A number representing the ANSI 256 color.
+	*/
+  ansi256ToAnsi(code: number): number;
+
+  /**
+	Convert from the RGB color space to the ANSI 16 color space.
+
+	@param red - (`0...255`)
+	@param green - (`0...255`)
+	@param blue - (`0...255`)
+	*/
+  rgbToAnsi(red: number, green: number, blue: number): number;
+
+  /**
+	Convert from the RGB HEX color space to the ANSI 16 color space.
+
+	@param hex - A hexadecimal string containing RGB data.
+	*/
+  hexToAnsi(hex: string): number;
+}
+
+declare const ansiStyles: {
+  readonly modifier: Modifier;
+  readonly color: ColorBase & ForegroundColor;
+  readonly bgColor: ColorBase & BackgroundColor;
+  readonly codes: ReadonlyMap<number, number>;
+} & ForegroundColor &
+  BackgroundColor &
+  Modifier &
+  ConvertColor;
+
+export default ansiStyles;

lib/util/chalk/ansi-styles/index.ts

@@ -0,0 +1,230 @@
+const ANSI_BACKGROUND_OFFSET = 10;
+
+const wrapAnsi16 =
+  (offset = 0) =>
+  (code) =>
+    `\u001B[${code + offset}m`;
+
+const wrapAnsi256 =
+  (offset = 0) =>
+  (code) =>
+    `\u001B[${38 + offset};5;${code}m`;
+
+const wrapAnsi16m =
+  (offset = 0) =>
+  (red, green, blue) =>
+    `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+
+function assembleStyles() {
+  const codes = new Map();
+  const styles = {
+    modifier: {
+      reset: [0, 0],
+      // 21 isn't widely supported and 22 does the same thing
+      bold: [1, 22],
+      dim: [2, 22],
+      italic: [3, 23],
+      underline: [4, 24],
+      overline: [53, 55],
+      inverse: [7, 27],
+      hidden: [8, 28],
+      strikethrough: [9, 29],
+    },
+    color: {
+      black: [30, 39],
+      red: [31, 39],
+      green: [32, 39],
+      yellow: [33, 39],
+      blue: [34, 39],
+      magenta: [35, 39],
+      cyan: [36, 39],
+      white: [37, 39],
+
+      // Bright color
+      blackBright: [90, 39],
+      redBright: [91, 39],
+      greenBright: [92, 39],
+      yellowBright: [93, 39],
+      blueBright: [94, 39],
+      magentaBright: [95, 39],
+      cyanBright: [96, 39],
+      whiteBright: [97, 39],
+    },
+    bgColor: {
+      bgBlack: [40, 49],
+      bgRed: [41, 49],
+      bgGreen: [42, 49],
+      bgYellow: [43, 49],
+      bgBlue: [44, 49],
+      bgMagenta: [45, 49],
+      bgCyan: [46, 49],
+      bgWhite: [47, 49],
+
+      // Bright color
+      bgBlackBright: [100, 49],
+      bgRedBright: [101, 49],
+      bgGreenBright: [102, 49],
+      bgYellowBright: [103, 49],
+      bgBlueBright: [104, 49],
+      bgMagentaBright: [105, 49],
+      bgCyanBright: [106, 49],
+      bgWhiteBright: [107, 49],
+    },
+  };
+
+  // Alias bright black as gray (and grey)
+  styles.color.gray = styles.color.blackBright;
+  styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+  styles.color.grey = styles.color.blackBright;
+  styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\u001B[${style[0]}m`,
+        close: `\u001B[${style[1]}m`,
+      };
+
+      group[styleName] = styles[styleName];
+
+      codes.set(style[0], style[1]);
+    }
+
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false,
+    });
+  }
+
+  Object.defineProperty(styles, 'codes', {
+    value: codes,
+    enumerable: false,
+  });
+
+  styles.color.close = '\u001B[39m';
+  styles.bgColor.close = '\u001B[49m';
+
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+
+  // From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value: (red, green, blue) => {
+        // We use the extended greyscale palette here, with the exception of
+        // black and white. normal palette only has 4 greyscale shades.
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+
+          if (red > 248) {
+            return 231;
+          }
+
+          return Math.round(((red - 8) / 247) * 24) + 232;
+        }
+
+        return (
+          16 +
+          36 * Math.round((red / 255) * 5) +
+          6 * Math.round((green / 255) * 5) +
+          Math.round((blue / 255) * 5)
+        );
+      },
+      enumerable: false,
+    },
+    hexToRgb: {
+      value: (hex) => {
+        const matches = /(?<colorString>[a-f\d]{6}|[a-f\d]{3})/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+
+        let { colorString } = matches.groups;
+
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join('');
+        }
+
+        const integer = Number.parseInt(colorString, 16);
+
+        return [
+          /* eslint-disable no-bitwise */
+          (integer >> 16) & 0xff,
+          (integer >> 8) & 0xff,
+          integer & 0xff,
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false,
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false,
+    },
+    ansi256ToAnsi: {
+      value: (code) => {
+        if (code < 8) {
+          return 30 + code;
+        }
+
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+
+        let red;
+        let green;
+        let blue;
+
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+
+          const remainder = code % 36;
+
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = (remainder % 6) / 5;
+        }
+
+        const value = Math.max(red, green, blue) * 2;
+
+        if (value === 0) {
+          return 30;
+        }
+
+        // eslint-disable-next-line no-bitwise
+        let result = 30 + ((Math.round(blue) << 2) | (Math.round(green) << 1) | Math.round(red));
+
+        if (value === 2) {
+          result += 60;
+        }
+
+        return result;
+      },
+      enumerable: false,
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false,
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false,
+    },
+  });
+
+  return styles;
+}
+
+const ansiStyles = assembleStyles();
+
+export default ansiStyles;

lib/util/chalk/index.d.ts

@@ -0,0 +1,317 @@
+// TODO: Make it this when TS suports that.
+// import {ColorInfo, ColorSupportLevel} from '#supports-color';
+import { ColorInfo, ColorSupportLevel } from './vendor/supports-color/index.js';
+
+/**
+Basic foreground colors.
+
+[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support)
+*/
+export type ForegroundColor =
+  | 'black'
+  | 'red'
+  | 'green'
+  | 'yellow'
+  | 'blue'
+  | 'magenta'
+  | 'cyan'
+  | 'white'
+  | 'gray'
+  | 'grey'
+  | 'blackBright'
+  | 'redBright'
+  | 'greenBright'
+  | 'yellowBright'
+  | 'blueBright'
+  | 'magentaBright'
+  | 'cyanBright'
+  | 'whiteBright';
+
+/**
+Basic background colors.
+
+[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support)
+*/
+export type BackgroundColor =
+  | 'bgBlack'
+  | 'bgRed'
+  | 'bgGreen'
+  | 'bgYellow'
+  | 'bgBlue'
+  | 'bgMagenta'
+  | 'bgCyan'
+  | 'bgWhite'
+  | 'bgGray'
+  | 'bgGrey'
+  | 'bgBlackBright'
+  | 'bgRedBright'
+  | 'bgGreenBright'
+  | 'bgYellowBright'
+  | 'bgBlueBright'
+  | 'bgMagentaBright'
+  | 'bgCyanBright'
+  | 'bgWhiteBright';
+
+/**
+Basic colors.
+
+[More colors here.](https://github.com/chalk/chalk/blob/main/readme.md#256-and-truecolor-color-support)
+*/
+export type Color = ForegroundColor | BackgroundColor;
+
+export type Modifiers =
+  | 'reset'
+  | 'bold'
+  | 'dim'
+  | 'italic'
+  | 'underline'
+  | 'overline'
+  | 'inverse'
+  | 'hidden'
+  | 'strikethrough'
+  | 'visible';
+
+export interface Options {
+  /**
+	Specify the color support for Chalk.
+
+	By default, color support is automatically detected based on the environment.
+
+	Levels:
+	- `0` - All colors disabled.
+	- `1` - Basic 16 colors support.
+	- `2` - ANSI 256 colors support.
+	- `3` - Truecolor 16 million colors support.
+	*/
+  readonly level?: ColorSupportLevel;
+}
+
+/**
+Return a new Chalk instance.
+*/
+export const Chalk: new (options?: Options) => ChalkInstance; // eslint-disable-line @typescript-eslint/naming-convention
+
+export interface ChalkInstance {
+  (...text: unknown[]): string;
+
+  /**
+	The color support for Chalk.
+
+	By default, color support is automatically detected based on the environment.
+
+	Levels:
+	- `0` - All colors disabled.
+	- `1` - Basic 16 colors support.
+	- `2` - ANSI 256 colors support.
+	- `3` - Truecolor 16 million colors support.
+	*/
+  level: ColorSupportLevel;
+
+  /**
+	Use RGB values to set text color.
+
+	@example
+	```
+	import chalk from 'chalk';
+
+	chalk.rgb(222, 173, 237);
+	```
+	*/
+  rgb: (red: number, green: number, blue: number) => this;
+
+  /**
+	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 an [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set text color.
+
+	@example
+	```
+	import chalk from 'chalk';
+
+	chalk.ansi256(201);
+	```
+	*/
+  ansi256: (index: number) => this;
+
+  /**
+	Use RGB values to set background color.
+
+	@example
+	```
+	import chalk from 'chalk';
+
+	chalk.bgRgb(222, 173, 237);
+	```
+	*/
+  bgRgb: (red: number, green: number, blue: 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 a [8-bit unsigned number](https://en.wikipedia.org/wiki/ANSI_escape_code#8-bit) to set background color.
+
+	@example
+	```
+	import chalk from 'chalk';
+
+	chalk.bgAnsi256(201);
+	```
+	*/
+  bgAnsi256: (index: number) => this;
+
+  /**
+	Modifier: Reset the current style.
+	*/
+  readonly reset: this;
+
+  /**
+	Modifier: Make the text bold.
+	*/
+  readonly bold: this;
+
+  /**
+	Modifier: Make the text have lower opacity.
+	*/
+  readonly dim: this;
+
+  /**
+	Modifier: Make the text italic. *(Not widely supported)*
+	*/
+  readonly italic: this;
+
+  /**
+	Modifier: Put a horizontal line below the text. *(Not widely supported)*
+	*/
+  readonly underline: this;
+
+  /**
+	Modifier: Put a horizontal line above the text. *(Not widely supported)*
+	*/
+  readonly overline: this;
+
+  /**
+	Modifier: Invert background and foreground colors.
+	*/
+  readonly inverse: this;
+
+  /**
+	Modifier: Print the text but make it invisible.
+	*/
+  readonly hidden: this;
+
+  /**
+	Modifier: Puts a horizontal line through the center of the text. *(Not widely supported)*
+	*/
+  readonly strikethrough: this;
+
+  /**
+	Modifier: Print the text only when Chalk has a color level above zero.
+
+	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;
+
+  /*
+	Alias for `blackBright`.
+	*/
+  readonly gray: this;
+
+  /*
+	Alias for `blackBright`.
+	*/
+  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;
+
+  /*
+	Alias for `bgBlackBright`.
+	*/
+  readonly bgGray: this;
+
+  /*
+	Alias for `bgBlackBright`.
+	*/
+  readonly bgGrey: 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: ChalkInstance;
+
+export const supportsColor: ColorInfo;
+
+export const chalkStderr: typeof chalk;
+export const supportsColorStderr: typeof supportsColor;
+
+export {
+  ColorInfo,
+  ColorSupport,
+  ColorSupportLevel, // } from '#supports-color';
+} from './vendor/supports-color/index.js';
+
+export default chalk;

lib/util/chalk/index.ts

@@ -0,0 +1,218 @@
+import ansiStyles from './ansi-styles';
+import supportsColor from './supports-color';
+import { stringReplaceAll, stringEncaseCRLFWithFirstIndex } from './utilities';
+import { ChalkInstance } from './index.d';
+
+const { stdout: stdoutColor, stderr: stderrColor } = supportsColor;
+
+const GENERATOR = Symbol('GENERATOR');
+const STYLER = Symbol('STYLER');
+const IS_EMPTY = Symbol('IS_EMPTY');
+
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
+
+const styles = Object.create(null);
+
+const applyOptions = (object, options = {}) => {
+  if (
+    options.level &&
+    !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)
+  ) {
+    throw new Error('The `level` option should be an integer from 0 to 3');
+  }
+
+  // Detect level if not set manually
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === undefined ? colorLevel : options.level;
+};
+
+export class Chalk {
+  constructor(options) {
+    // eslint-disable-next-line no-constructor-return
+    return chalkFactory(options);
+  }
+}
+
+const chalkFactory = (options) => {
+  const chalk = (...strings) => strings.join(' ');
+  applyOptions(chalk, options);
+
+  Object.setPrototypeOf(chalk, createChalk.prototype);
+
+  return chalk;
+};
+
+function createChalk(options) {
+  return chalkFactory(options);
+}
+
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+
+for (const [styleName, style] of Object.entries(ansiStyles)) {
+  styles[styleName] = {
+    get() {
+      const builder = createBuilder(
+        this,
+        createStyler(style.open, style.close, this[STYLER]),
+        this[IS_EMPTY]
+      );
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
+    },
+  };
+}
+
+styles.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, 'visible', { value: builder });
+    return builder;
+  },
+};
+
+const getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === 'rgb') {
+    if (level === 'ansi16m') {
+      return ansiStyles[type].ansi16m(...arguments_);
+    }
+
+    if (level === 'ansi256') {
+      return ansiStyles[type].ansi256(ansiStyles.rgbToAnsi256(...arguments_));
+    }
+
+    return ansiStyles[type].ansi(ansiStyles.rgbToAnsi(...arguments_));
+  }
+
+  if (model === 'hex') {
+    return getModelAnsi('rgb', level, type, ...ansiStyles.hexToRgb(...arguments_));
+  }
+
+  return ansiStyles[type][model](...arguments_);
+};
+
+const usedModels = ['rgb', 'hex', 'ansi256'];
+
+for (const model of usedModels) {
+  styles[model] = {
+    get() {
+      const { level } = this;
+      return function (...arguments_) {
+        const styler = createStyler(
+          getModelAnsi(model, levelMapping[level], 'color', ...arguments_),
+          ansiStyles.color.close,
+          this[STYLER]
+        );
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    },
+  };
+
+  const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+  styles[bgModel] = {
+    get() {
+      const { level } = this;
+      return function (...arguments_) {
+        const styler = createStyler(
+          getModelAnsi(model, levelMapping[level], 'bgColor', ...arguments_),
+          ansiStyles.bgColor.close,
+          this[STYLER]
+        );
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    },
+  };
+}
+
+const proto = Object.defineProperties(() => {}, {
+  ...styles,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    },
+  },
+});
+
+const createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === undefined) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent,
+  };
+};
+
+const createBuilder = (self, _styler, _isEmpty) => {
+  // Single argument is hot path, implicit coercion is faster than anything
+  // eslint-disable-next-line no-implicit-coercion
+  const builder = (...arguments_) =>
+    applyStyle(builder, arguments_.length === 1 ? '' + arguments_[0] : arguments_.join(' '));
+
+  // We alter the prototype because we must return a function, but there is
+  // no way to create a function with a different prototype
+  Object.setPrototypeOf(builder, proto);
+
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+
+  return builder;
+};
+
+const applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? '' : string;
+  }
+
+  let styler = self[STYLER];
+
+  if (styler === undefined) {
+    return string;
+  }
+
+  const { openAll, closeAll } = styler;
+  if (string.includes('\u001B')) {
+    while (styler !== undefined) {
+      // 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'.
+      string = stringReplaceAll(string, styler.close, styler.open);
+
+      styler = styler.parent;
+    }
+  }
+
+  // We can move both next actions out of loop, because remaining actions in loop won't have
+  // any/visible effect on parts we add here. 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
+  const lfIndex = string.indexOf('\n');
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+
+  return openAll + string + closeAll;
+};
+
+Object.defineProperties(createChalk.prototype, styles);
+
+const chalk: ChalkInstance = createChalk();
+export const chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+
+export { stdoutColor as supportsColor, stderrColor as supportsColorStderr };
+
+export default chalk;

lib/util/chalk/supports-color/index.d.ts

@@ -0,0 +1 @@
+export { default } from './index.js';

lib/util/chalk/supports-color/index.ts

@@ -0,0 +1,19 @@
+/* eslint-env browser */
+
+const isBlinkBasedBrowser = /\b(Chrome|Chromium)\//.test(navigator.userAgent);
+
+const colorSupport = isBlinkBasedBrowser
+  ? {
+      level: 1,
+      hasBasic: true,
+      has256: false,
+      has16m: false,
+    }
+  : false;
+
+const supportsColor = {
+  stdout: colorSupport,
+  stderr: colorSupport,
+};
+
+export default supportsColor;

lib/util/chalk/utilities.ts

@@ -0,0 +1,37 @@
+// TODO: When targeting Node.js 16, use `String.prototype.replaceAll`.
+export function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = '';
+  do {
+    returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+
+export function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = '';
+  do {
+    const gotCR = string[index - 1] === '\r';
+    returnValue +=
+      string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) +
+      prefix +
+      (gotCR ? '\r\n' : '\n') +
+      postfix;
+    endIndex = index + 1;
+    index = string.indexOf('\n', endIndex);
+  } while (index !== -1);
+
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}