@travetto/terminal 3.4.0 → 4.0.0-rc.0

package/src/writer.ts

@@ -1,28 +1,50 @@
-import { ANSICodes } from './codes';
-import { TermCoord, TermState } from './types';
-
-const boundIndex = (v: number, size: number): number => {
-  if (v < 0) {
-    v = size + v;
-  }
-  return Math.max(Math.min(v, size - 1), 0);
+import tty from 'node:tty';
+
+type State = { output: tty.WriteStream, height: number, width: number };
+type TermCoord = { x: number, y: number };
+
+const ESC = '\x1b[';
+const clamp = (v: number, size: number): number => Math.max(Math.min(v + (v < 0 ? size : 0), size - 1), 0);
+const delta = (v: number | undefined, pos: string, neg: string): string =>
+  !v ? '' : `${ESC}${Math.abs(v)}${v < 0 ? neg : pos}`;
+
+const Codes = {
+  SHOW_CURSOR: `${ESC}?25h`,
+  HIDE_CURSOR: `${ESC}?25l`,
+  SCROLL_RANGE_CLEAR: `${ESC}r`,
+  POSITION_RESTORE: `${ESC}u`,
+  POSITION_SAVE: `${ESC}s`,
+  SOFT_RESET_CODES: `${ESC}!p`,
+  ERASE_LINE_RIGHT: `${ESC}0K`,
+  ERASE_LINE_LEFT: `${ESC}1K`,
+  ERASE_LINE_ALL: `${ESC}2K`,
+
+  DEBUG: (text: string): string => text.replaceAll(ESC, '<ESC>').replaceAll('\n', '<NL>'),
+  CURSOR_MOVE: (x?: number, y?: number): string => `${delta(x, 'C', 'D')}${delta(y, 'B', 'A')}`,
+  POSITION_SET: (x: number, y: number | undefined, maxX: number, maxY: number): string => y !== undefined ?
+    `${ESC}${clamp(y, maxY) + 1};${clamp(x, maxX) + 1}H` : `${ESC}${clamp(x, maxX) + 1}G`,
+  SCROLL_RANGE_SET: (start: number, end: number, max: number): string =>
+    `${ESC}${clamp(start, max) + 1};${clamp(end, max) + 1}r`
 };
 
 /**
  * Buffered/batched writer.  Meant to be similar to readline.Readline, but with more general writing support and extensibility
  */
 export class TerminalWriter {
+  #buffer: (string | number)[] = [];
+  #restoreOnCommit = false;
+  #term: State;
 
-  static for(term: TermState): TerminalWriter {
-    return new TerminalWriter(term);
+  constructor(state: State) {
+    this.#term = state;
   }
 
-  #queue: (string | number)[] = [];
-  #term: TermState;
-  #restoreOnCommit = false;
-
-  constructor(term: TermState) {
-    this.#term = term;
+  /** Pad to width of terminal */
+  padToWidth(text: string, offset = 0, ellipsis = '...'): string {
+    if (text.length > (this.#term.width - offset)) {
+      return `${text.substring(0, this.#term.width - (offset + ellipsis.length))}${ellipsis}`;
+    }
+    return text.padEnd(this.#term.width - offset, ' ');
   }
 
   /** Restore on commit */
@@ -32,62 +54,51 @@ export class TerminalWriter {
   }
 
   commit(restorePosition: boolean = this.#restoreOnCommit): Promise<void> {
-    const q = this.#queue.filter(x => x !== undefined);
-    this.#queue = [];
+    const q = this.#buffer.filter(x => x !== undefined);
+    this.#buffer = [];
     if (q.length && restorePosition) {
-      q.unshift(ANSICodes.POSITION_SAVE());
-      q.push(ANSICodes.POSITION_RESTORE());
+      q.unshift(Codes.POSITION_SAVE);
+      q.push(Codes.POSITION_RESTORE);
+    }
+    if (q.length && !this.#term.output.write(q.join(''))) {
+      return new Promise<void>(r => this.#term.output.once('drain', r));
+    } else {
+      return Promise.resolve();
     }
-    return q.length ? new Promise(r => this.#term.output.write(q.join(''), () => r())) : Promise.resolve();
   }
 
   write(...text: (string | number)[]): this {
-    this.#queue.push(...text);
+    this.#buffer.push(...text);
     return this;
   }
 
   /** Stores current cursor position, if called multiple times before restore, last one ones */
   storePosition(): this {
-    return this.write(ANSICodes.POSITION_SAVE());
+    return this.write(Codes.POSITION_SAVE);
   }
 
   /** Restores cursor position, will not behave correctly if nested  */
   restorePosition(): this {
-    return this.write(ANSICodes.POSITION_RESTORE());
-  }
-
-  /** Rewrite a single line in the stream  */
-  rewriteLine(text: string): this {
-    return this.setPosition({ x: 0 }).write(text);
+    return this.write(Codes.POSITION_RESTORE);
   }
 
   /** Clear line, -1 (left), 0 (both), 1 (right), from current cursor */
   clearLine(dir: -1 | 0 | 1 = 0): this {
-    return this.write(ANSICodes.ERASE_LINE(dir === 0 ? 2 : (dir === 1 ? 0 : 1)));
+    switch (dir) {
+      case 0: return this.write(Codes.ERASE_LINE_ALL);
+      case 1: return this.write(Codes.ERASE_LINE_RIGHT);
+      case -1: return this.write(Codes.ERASE_LINE_LEFT);
+    }
   }
 
   /** Set position */
   setPosition({ x = 0, y }: Partial<TermCoord>): this {
-    if (y !== undefined) {
-      y = boundIndex(y, this.#term.output.rows);
-    }
-    x = boundIndex(x, this.#term.output.columns);
-    if (y !== undefined) {
-      return this.write(ANSICodes.POSITION_SET(y + 1, x + 1));
-    } else {
-      return this.write(ANSICodes.COLUMN_SET(x + 1));
-    }
+    return this.write(Codes.POSITION_SET(x, y, this.#term.width, this.#term.height));
   }
 
   /** Relative movement */
   changePosition({ x, y }: Partial<TermCoord>): this {
-    if (x) {
-      this.write(ANSICodes.CURSOR_DX(x));
-    }
-    if (y) {
-      this.write(ANSICodes.CURSOR_DY(y));
-    }
-    return this;
+    return this.write(Codes.CURSOR_MOVE(x, y));
   }
 
   /** Write single line */
@@ -101,7 +112,7 @@ export class TerminalWriter {
     let text = lines.join('\n');
     if (text.length > 0) {
       if (clear) {
-        text = text.replaceAll('\n', `${ANSICodes.ERASE_LINE(0)}\n`);
+        text = text.replaceAll('\n', `${Codes.ERASE_LINE_RIGHT}\n`);
       }
       text = `${text}\n`;
     }
@@ -110,43 +121,26 @@ export class TerminalWriter {
 
   /** Show cursor */
   showCursor(): this {
-    return this.write(ANSICodes.SHOW_CURSOR());
+    return this.write(Codes.SHOW_CURSOR);
   }
 
   /** Hide cursor */
   hideCursor(): this {
-    return this.write(ANSICodes.HIDE_CURSOR());
+    return this.write(Codes.HIDE_CURSOR);
   }
 
   /** Set scrolling range */
-  scrollRange({ start, end }: { start?: number, end?: number }): this {
-    start = boundIndex(start ?? 0, this.#term.output.rows);
-    end = boundIndex(end ?? -1, this.#term.output.rows);
-    return this.write(ANSICodes.SCROLL_RANGE_SET(start + 1, end + 1));
+  scrollRange({ start = 0, end = -1 }: { start?: number, end?: number }): this {
+    return this.write(Codes.SCROLL_RANGE_SET(start, end, this.#term.height));
   }
 
   /** Clear scrolling range */
   scrollRangeClear(): this {
-    return this.write(ANSICodes.SCROLL_RANGE_CLEAR());
-  }
-
-  /** Scrolling window y <=0 - up,  else down */
-  scrollY(y: number): this {
-    return this.write(ANSICodes.SCROLL_WINDOW(y));
+    return this.write(Codes.SCROLL_RANGE_CLEAR);
   }
 
   /** Reset */
-  reset(): this {
-    return this.write(this.resetCommands());
-  }
-
-  /** Reset Commands */
-  resetCommands(): string {
-    return [
-      ANSICodes.POSITION_SAVE(),
-      ANSICodes.SHOW_CURSOR(),
-      ANSICodes.SCROLL_RANGE_CLEAR(),
-      ANSICodes.POSITION_RESTORE()
-    ].join('');
+  softReset(): this {
+    return this.write(Codes.SOFT_RESET_CODES);
   }
 }

package/src/codes.ts

@@ -1,41 +0,0 @@
-const ESC = '\x1b[';
-const OSC = '\x1b]';
-const ST = '\x1b\\';
-
-// eslint-disable-next-line no-control-regex
-export const ANSI_CODE_REGEX = /(\x1b|\x1B)[\[\]][?]?[0-9;]+[A-Za-z]/g;
-
-export const OSC_QUERY_FIELDS = {
-  backgroundColor: 11,
-  foregroundColor: 10
-};
-
-export type OSCQueryField = keyof (typeof OSC_QUERY_FIELDS);
-
-export const DEVICE_STATUS_FIELDS = {
-  cursorPosition: 6,
-};
-
-export type DeviceStatusField = keyof (typeof DEVICE_STATUS_FIELDS);
-
-export const ANSICodes = {
-  DEBUG: (text: string): string => text.replaceAll(ESC, '<ESC>').replaceAll(OSC, '<OSC>').replaceAll('\n', '<NL>').replaceAll(ST, '<ST>'),
-  CURSOR_DY: (row: number): string => `${ESC}${Math.abs(row)}${row < 0 ? 'A' : 'B'}`,
-  CURSOR_DX: (col: number): string => `${ESC}${Math.abs(col)}${col < 0 ? 'D' : 'C'}`,
-  COLUMN_SET: (col: number): string => `${ESC}${col}G`,
-  POSITION_SET: (row: number, col: number): string => `${ESC}${row};${col}H`,
-  ERASE_SCREEN: (dir: 0 | 1 | 2 | 3 = 0): string => `${ESC}${dir}J`,
-  ERASE_LINE: (dir: 0 | 1 | 2 = 0): string => `${ESC}${dir}K`,
-  STYLE: (codes: (string | number)[]): string => `${ESC}${codes.join(';')}m`,
-  SHOW_CURSOR: (): string => `${ESC}?25h`,
-  HIDE_CURSOR: (): string => `${ESC}?25l`,
-  SCROLL_RANGE_SET: (start: number, end: number): string => `${ESC}${start};${end}r`,
-  SCROLL_RANGE_CLEAR: (): string => `${ESC}r`,
-  SCROLL_WINDOW: (rows: number): string => `${ESC}${Math.abs(rows)}${rows < 0 ? 'S' : 'T'}`,
-  POSITION_RESTORE: (): string => `${ESC}u`,
-  POSITION_SAVE: (): string => `${ESC}s`,
-  DEVICE_STATUS_REPORT: (code: DeviceStatusField): string => `${ESC}${DEVICE_STATUS_FIELDS[code]}n`,
-  OSC_QUERY: (code: OSCQueryField): string => `${OSC}${OSC_QUERY_FIELDS[code]};?${ST}`,
-};
-
-export const stripAnsiCodes = (text: string): string => text.replace(ANSI_CODE_REGEX, '');

package/src/color-define.ts

@@ -1,195 +0,0 @@
-import { NAMED_COLORS } from './named-colors';
-import { RGB, TermColorScheme } from './types';
-
-type I = number;
-type HSL = [h: I, s: I, l: I];
-export type DefinedColor = { rgb: RGB, hsl: HSL, idx16: I, idx16bg: I, idx256: I, scheme: TermColorScheme };
-export type RGBInput = I | keyof (typeof NAMED_COLORS) | `#${string}`;
-
-const _rgb = (r: I, g: I = r, b: I = g): RGB => [r, g, b];
-
-const STD_PRE = ['std', 'bright'] as const;
-const STD_COLORS = ['Black', 'Red', 'Green', 'Yellow', 'Blue', 'Magenta', 'Cyan', 'White'] as const;
-
-// eslint-disable-next-line no-bitwise
-const toRgbArray = (val: number): RGB => [(val >> 16) & 255, (val >> 8) & 255, val & 255];
-
-const ANSI256_TO_16_IDX = [30, 31, 32, 33, 34, 35, 36, 37, 90, 91, 92, 93, 94, 95, 96, 97];
-const ANSI16_TO_BG = new Map(ANSI256_TO_16_IDX.map(x => [x, x + 10]));
-
-// Inspired/sourced from: https://github.com/mina86/ansi_colours/blob/master/src/ansi256.rs
-const ANSI256_GRAY_MAPPING = [
-  [16, 5],
-  [232, 9], [233, 10], [234, 10], [235, 10], [236, 10], [237, 10], [238, 10], [239, 10], [240, 8],
-  [59, 5],
-  [241, 7], [242, 10], [243, 9], [244, 9],
-  [102, 5],
-  [245, 6], [246, 10], [247, 10], [248, 9],
-  [145, 5],
-  [249, 6], [250, 10], [251, 10], [252, 9],
-  [188, 5],
-  [253, 6], [254, 10], [255, 14],
-  [231, 9]
-].flatMap(([v, r]) => new Array<number>(v).fill(r));
-
-const STEPS_256 = [0, 95, 135, 175, 215, 255];
-
-const ANSI256_TO_RGB: RGB[] = [
-  ...STD_PRE.flatMap(p => STD_COLORS.map(c => NAMED_COLORS[`${p}${c}`]).map(toRgbArray)),
-  ...STEPS_256.flatMap(r => STEPS_256.flatMap(g => STEPS_256.map(b => _rgb(r, g, b)))),
-  ...new Array(24).fill(0).map((_, i) => _rgb(i * 10 + 8)) // Grays
-];
-
-// Pulled from: https://github.com/mina86/ansi_colours/blob/master/src/ansi256.rs
-const RED_256_LEVELS = [38, 115, 155, 196, 235];
-const GREEN_256_LEVELS = [38, 115, 155, 196, 235];
-const BLUE_256_LEVELS = [35, 115, 155, 195, 235];
-
-export class ColorDefineUtil {
-  static CACHE = new Map<number | string, DefinedColor>();
-
-  static #snapToLevel(levels: number[], val: number): number {
-    for (let i = 0; i < levels.length; i += 1) {
-      if (val < levels[i]) { return i; }
-    }
-    return levels.length;
-  }
-
-  // Returns luminance of given sRGB color.
-  // Pulled from: https://github.com/mina86/ansi_colours/blob/master/src/ansi256.rs
-  // eslint-disable-next-line no-bitwise
-  static #luminance = ([r, g, b]: RGB): number => (((3567664 * r + 11998547 * g + 1211005 * b) + (1 << 23)) >> 24) & 255;
-
-  // Pulled from: https://github.com/mina86/ansi_colours/blob/master/src/ansi256.rs
-  static #distance = ([xr, xg, xb]: RGB, [yr, yg, yb]: RGB, sr = xr + yr): number =>
-    (1024 + sr) * ((xr - yr) ** 2) + 2048 * ((xg - yg) ** 2) + (1534 - sr) * ((xb - yb) ** 2);
-
-  static #snapToAnsi256Bands([r, g, b]: RGB): [idx: number, snapped: RGB] {
-    const ri = this.#snapToLevel(RED_256_LEVELS, r);
-    const gi = this.#snapToLevel(GREEN_256_LEVELS, g);
-    const bi = this.#snapToLevel(BLUE_256_LEVELS, b);
-    return [(ri * 36 + 16 + gi * 6 + bi), [STEPS_256[ri], STEPS_256[gi], STEPS_256[bi]]];
-  }
-
-  /**
-   * Converts [R,G,B] to an ANSI 256 index
-   */
-  // Inspired/sourced from: https://github.com/mina86/ansi_colours/blob/master/src/ansi256.rs
-  static ansi256FromRgb(rgb: RGB): number {
-    const grayIdx = ANSI256_GRAY_MAPPING[this.#luminance(rgb)];
-    const grayDist = this.#distance(rgb, ANSI256_TO_RGB[grayIdx]);
-    const [snappedIdx, snapped] = this.#snapToAnsi256Bands(rgb);
-    return this.#distance(rgb, snapped) < grayDist ? snappedIdx : grayIdx;
-  }
-
-  /**
-   * Converts [R,G,B] to an ANSI 16 index
-   */
-  static ansi16FromRgb(rgb: RGB): number {
-    let min = Number.MAX_SAFE_INTEGER;
-    let minIdx = -1;
-    for (let i = 0; i < 16; i += 1) {
-      const dist = this.#distance(rgb, ANSI256_TO_RGB[i]);
-      if (dist < min) {
-        min = dist;
-        minIdx = i;
-      }
-    }
-    return ANSI256_TO_16_IDX[minIdx];
-  }
-
-  /**
-   * ANSI 256 into RGB
-   */
-  static rgbFromAnsi256(val: number): RGB {
-    return ANSI256_TO_RGB[val];
-  }
-
-  /**
-   * Converts [R,G,B] to [H,S,L]
-   */
-  static hsl([r, g, b]: RGB): HSL {
-    const [rf, gf, bf] = [r / 255, g / 255, b / 255];
-    const max = Math.max(rf, gf, bf), min = Math.min(rf, gf, bf);
-    let h = 0;
-    let s = 0;
-    const l = (max + min) / 2;
-
-    if (max === min) {
-      h = s = 0; // achromatic
-    } else {
-      const d = max - min;
-      s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-      switch (max) {
-        case rf: h = (gf - bf) / d + (gf < bf ? 6 : 0); break;
-        case gf: h = (bf - rf) / d + 2; break;
-        case bf: h = (rf - gf) / d + 4; break;
-      }
-      h /= 6;
-    }
-    return [h, s, l];
-  }
-
-
-  /**
-   * Converts input value into [R,G,B] output
-   */
-  static toRgb(val: RGBInput): RGB {
-    if (typeof val === 'string') {
-      if (val.startsWith('#')) {
-        const res = val.match(/^#(?<rh>[a-f0-9]{2})(?<gh>[a-f0-9]{2})(?<bh>[a-f0-9]{2})$/i);
-        if (res) {
-          const { rh, gh, bh } = res.groups!;
-          return [parseInt(rh, 16), parseInt(gh, 16), parseInt(bh, 16)];
-        }
-      } else if (val in NAMED_COLORS) {
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        return this.toRgb(NAMED_COLORS[val as keyof typeof NAMED_COLORS]);
-      }
-      throw new Error(`Unknown color format: ${val}`);
-    } else if (typeof val === 'number') {
-      return toRgbArray(val);
-    } else {
-      return val;
-    }
-  }
-
-  /**
-   * Determine if a color is light or dark
-   */
-  static getScheme(color: RGB): TermColorScheme {
-    const [r, g, b] = color;
-    return (r + g + b) / 3 < 128 ? 'dark' : 'light';
-  }
-
-  /**
-   * Define a color and all its parts
-   */
-  static defineColor(val: RGBInput): DefinedColor {
-    if (!this.CACHE.has(val)) {
-      const rgb = this.toRgb(val);
-      const idx16 = this.ansi16FromRgb(rgb);
-      const idx256 = this.ansi256FromRgb(rgb);
-      const hsl = this.hsl(rgb);
-      const idx16bg = ANSI16_TO_BG.get(idx16)!;
-      const scheme = this.getScheme(rgb);
-      this.CACHE.set(val, { rgb, idx16, idx16bg, idx256, hsl, scheme });
-    }
-    return this.CACHE.get(val)!;
-  }
-
-  /**
-   * Build ANSI compatible color codes by level
-   */
-  static getColorCodes(inp: RGBInput, bg: boolean): [number[], number[]][] {
-    const spec = this.defineColor(inp);
-    const { idx16, idx16bg, idx256, rgb } = spec;
-    const [open, close] = bg ? [48, 49] : [38, 39];
-    return [
-      [[], []],
-      [[bg ? idx16bg : idx16], [close]],
-      [[open, 5, idx256], [close]],
-      [[open, 2, ...rgb], [close]]
-    ];
-  }
-}

package/src/color-output.ts

@@ -1,128 +0,0 @@
-import tty from 'tty';
-
-import { ColorDefineUtil, RGBInput } from './color-define';
-import { ANSICodes } from './codes';
-import { TermColorScheme, TermColorLevel, TermState, RGB } from './types';
-
-export type TermStyle =
-  { text?: RGBInput, background?: RGBInput, italic?: boolean, underline?: boolean, inverse?: boolean, blink?: boolean };
-
-export type TermStyleInput = TermStyle | RGBInput;
-export type Prim = string | number | boolean | Date | RegExp;
-export type TermColorPaletteInput = Record<string, TermStyleInput | [dark: TermStyleInput, light: TermStyleInput]>;
-export type TermColorFn = (text: Prim) => string;
-export type TermColorPalette<T> = Record<keyof T, TermColorFn>;
-
-const COLOR_LEVEL_MAP = { 1: 0, 4: 1, 8: 2, 24: 3 } as const;
-type ColorBits = keyof (typeof COLOR_LEVEL_MAP);
-
-/**
- * Utils for colorizing output
- */
-export class ColorOutputUtil {
-
-  /**
-   * Detect color level from tty information
-   */
-  static async readTermColorLevel(stream: tty.WriteStream): Promise<TermColorLevel> {
-    const force = process.env.FORCE_COLOR;
-    const disable = process.env.NO_COLOR ?? process.env.NODE_DISABLE_COLORS;
-    if (force !== undefined) {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      return Math.max(Math.min(/^\d+$/.test(force) ? parseInt(force, 10) : 1, 3), 0) as TermColorLevel;
-    } else if (disable !== undefined && /^(1|true|yes|on)/i.test(disable)) {
-      return 0;
-    }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return stream.isTTY ? COLOR_LEVEL_MAP[stream.getColorDepth() as ColorBits] : 0;
-  }
-
-  /**
-   * Read foreground/background color if env var is set
-   */
-  static async readBackgroundScheme(
-    stream: tty.WriteStream,
-    query: () => Promise<RGB | undefined> | RGB | undefined,
-    env: string | undefined = process.env.COLORFGBG
-  ): Promise<TermColorScheme | undefined> {
-    let color = stream.isTTY ? await query() : undefined;
-    if (!color && env) {
-      const [, bg] = env.split(';');
-      color = ColorDefineUtil.rgbFromAnsi256(+bg);
-    }
-    if (color) {
-      const hex = `#${color.map(x => x.toString(16).padStart(2, '0')).join('')}` as const;
-      return ColorDefineUtil.defineColor(hex).scheme;
-    }
-  }
-
-  /**
-   * Get styled levels, 0-3
-   */
-  static getStyledLevels(inp: TermStyle | RGBInput): [string, string][] {
-    const cfg = (typeof inp !== 'object') ? { text: inp } : inp;
-    const levelPairs: [string, string][] = [['', '']];
-    const text = cfg.text ? ColorDefineUtil.getColorCodes(cfg.text, false) : undefined;
-    const bg = cfg.background ? ColorDefineUtil.getColorCodes(cfg.background, true) : undefined;
-
-    for (const level of [1, 2, 3]) {
-      const prefix: number[] = [];
-      const suffix: number[] = [];
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-      for (const key of Object.keys(cfg) as (keyof typeof cfg)[]) {
-        if (!cfg[key]) {
-          continue;
-        }
-        switch (key) {
-          case 'inverse': prefix.push(7); suffix.push(27); break;
-          case 'underline': prefix.push(4); suffix.push(24); break;
-          case 'italic': prefix.push(3); suffix.push(23); break;
-          case 'blink': prefix.push(5); suffix.push(25); break;
-          case 'text': prefix.push(...text![level][0]); suffix.push(...text![level][1]); break;
-          case 'background': prefix.push(...bg![level][0]); suffix.push(...bg![level][1]); break;
-        }
-      }
-      levelPairs[level] = [
-        ANSICodes.STYLE(prefix),
-        ANSICodes.STYLE(suffix.reverse())
-      ];
-    }
-    return levelPairs;
-  }
-
-  /**
-   * Make a simple primitive colorer
-   */
-  static colorer(term: TermState, style: TermStyleInput | [dark: TermStyleInput, light: TermStyleInput]): TermColorFn {
-    const schemes = {
-      light: this.getStyledLevels(Array.isArray(style) ? style[1] ?? style[0] : style),
-      dark: this.getStyledLevels(Array.isArray(style) ? style[0] : style),
-    };
-    return (v: Prim): string => {
-      const [prefix, suffix] = schemes[term.backgroundScheme][term.colorLevel];
-      return (v === undefined || v === null) ? '' : `${prefix}${v}${suffix}`;
-    };
-  }
-
-  /**
-   * Creates a color palette based on input styles
-   */
-  static palette<P extends TermColorPaletteInput>(term: TermState, input: P): TermColorPalette<P> {
-    // Common color support
-    const out: Partial<TermColorPalette<P>> = {};
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    for (const [k, col] of Object.entries(input) as [keyof P, TermStyleInput][]) {
-      out[k] = this.colorer(term, col);
-    }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return out as TermColorPalette<P>;
-  }
-
-  /**
-   * Convenience method to creates a color template function based on input styles
-   */
-  static templateFunction<P extends TermColorPaletteInput>(term: TermState, input: P): (key: keyof P, val: Prim) => string {
-    const pal = this.palette(term, input);
-    return (key: keyof P, val: Prim) => pal[key](val);
-  }
-}

package/src/iterable.ts

@@ -1,100 +0,0 @@
-import timers from 'timers/promises';
-import { DelayedConfig, Indexed } from './types';
-
-export type StoppableIterable<T> = { stream: AsyncIterable<T>, stop: () => void };
-
-export type MapFn<T, U> = (val: T, i: number) => U | Promise<U>;
-
-const isIdx = (x: unknown): x is Indexed => (x !== undefined && x !== null) && typeof x === 'object' && 'idx' in x;
-
-export class IterableUtil {
-
-  static DELAY = ({ initialDelay = 0, cycleDelay = 0 }: DelayedConfig = {}) =>
-    <T>(x: T, i: number): Promise<T> => timers.setTimeout(i === 0 ? initialDelay : cycleDelay).then(() => x);
-
-  static ORDERED = <T extends Indexed>(): (val: T) => boolean => {
-    let last = -1;
-    return (v: T): boolean => (last = Math.max(v.idx, last)) === v.idx;
-  };
-
-  static map<T, U, V, W>(source: AsyncIterable<T>, fn1: MapFn<T, U>, fn2: MapFn<U, V>, fn3: MapFn<V, W>): AsyncIterable<W>;
-  static map<T, U, V>(source: AsyncIterable<T>, fn1: MapFn<T, U>, fn2: MapFn<U, V>): AsyncIterable<V>;
-  static map<T, U>(source: AsyncIterable<T>, fn: MapFn<T, U>): AsyncIterable<U>;
-  static async * map<T>(source: AsyncIterable<T>, ...fns: MapFn<unknown, unknown>[]): AsyncIterable<unknown> {
-    let idx = -1;
-    for await (const el of source) {
-      if (el !== undefined) {
-        idx += 1;
-        let m = el;
-        for (const fn of fns) {
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-          m = (await fn(m, idx)) as typeof m;
-        }
-        yield m;
-      }
-    }
-  }
-
-  static async * filter<T>(source: AsyncIterable<T>, pred: (val: T, i: number) => boolean | Promise<boolean>): AsyncIterable<T> {
-    let idx = -1;
-    for await (const el of source) {
-      if (await pred(el, idx += 1)) {
-        yield el;
-      }
-    }
-  }
-
-  static cycle<T>(items: T[]): StoppableIterable<T> {
-    let done = false;
-    async function* buildStream(): AsyncIterable<T> {
-      let i = -1;
-      while (!done) {
-        yield items[(i += 1) % items.length];
-      }
-    }
-    return { stream: buildStream(), stop: (): void => { done = true; } };
-  }
-
-  static async drain<T>(source: AsyncIterable<T>): Promise<T[]> {
-    const items: T[] = [];
-    for await (const ev of source) {
-      items[isIdx(ev) ? ev.idx : items.length] = ev;
-    }
-    return items;
-  }
-
-  static simpleQueue(): {
-    close: () => Promise<void>;
-    add: <T>(item: () => Promise<T>) => Promise<T>;
-    running: Promise<void>;
-  } {
-    let done = false;
-    let fire: () => void;
-    let next = new Promise<void>(r => fire = r);
-
-    const queue: Function[] = [];
-    async function run(): Promise<void> {
-      while (!done) {
-        if (!queue.length) {
-          await next;
-          next = new Promise(r => fire = r);
-        }
-        await queue.shift()?.();
-      }
-    }
-    const running = run();
-    return {
-      running,
-      close: (): Promise<void> => {
-        done = true;
-        fire();
-        return running;
-      },
-      add: <T>(fn: () => Promise<T>): Promise<T> => {
-        const prom = new Promise<T>(r => queue.push(() => fn().then(r)));
-        fire();
-        return prom;
-      }
-    };
-  }
-}