console-toolkit 1.0.0

package/src/plot/bitmap.js

@@ -0,0 +1,108 @@
+import Box from '../box.js';
+import {addAlias} from '../meta.js';
+import {fullBlock} from '../symbols.js';
+
+export class Bitmap {
+  constructor(width, height, blockWidth = 5, blockHeight = 5) {
+    // parameters check
+    width = Math.round(width);
+    if (isNaN(width) || width <= 0) throw new Error(`Width should be a positive integer instead of "${width}"`);
+    height = Math.round(height);
+    if (isNaN(width) || height <= 0) throw new Error(`Height should be a positive integer instead of "${height}"`);
+    blockWidth = Math.round(blockWidth);
+    if (isNaN(width) || blockWidth <= 0)
+      throw new Error(`Block width should be a positive integer instead of "${blockWidth}"`);
+    blockHeight = Math.round(blockHeight);
+    if (isNaN(width) || blockHeight <= 0)
+      throw new Error(`Block height should be a positive integer instead of "${blockHeight}"`);
+    if (isNaN(width) || blockWidth * blockHeight > 32)
+      throw new Error("Multiplication of 'blockWidth' and 'blockHeight' should be equal or less than 32");
+
+    this.width = width;
+    this.height = height;
+    this.blockWidth = blockWidth;
+    this.blockHeight = blockHeight;
+
+    // create a bitmap
+    this.lineSize = Math.floor(this.width / this.blockWidth);
+    if (this.width % this.blockWidth) ++this.lineSize;
+    this.lineCount = Math.floor(this.height / this.blockHeight);
+    if (this.height % this.blockHeight) ++this.lineCount;
+    this.bitmap = new Array(this.lineCount * this.lineSize).fill(0);
+  }
+
+  verifyPos(x, y) {
+    if (x < 0 || x >= this.width) throw new Error(`X is out of bounds: "${x}`);
+    if (y < 0 || y >= this.height) throw new Error(`Y is out of bounds: "${y}`);
+    return this;
+  }
+
+  getWordIndex(x, y) {
+    const line = Math.floor(y / this.blockHeight),
+      linePos = Math.floor(x / this.blockWidth);
+    return line * this.lineSize + linePos;
+  }
+
+  getWordMask(x, y) {
+    const shiftX = x % this.blockWidth,
+      shiftY = y % this.blockHeight;
+    return 1 << (shiftX + this.blockWidth * shiftY);
+  }
+
+  getBit(x, y) {
+    if (x < 0 || x >= this.width || y < 0 || y >= this.height) return 0;
+    const index = this.getWordIndex(x, y),
+      mask = this.getWordMask(x, y);
+    return this.bitmap[index] & mask;
+  }
+
+  setBit(x, y, value = 1) {
+    if (x < 0 || x >= this.width || y < 0 || y >= this.height) return this;
+    const index = this.getWordIndex(x, y),
+      mask = this.getWordMask(x, y);
+    this.bitmap[index] =
+      value > 0 ? this.bitmap[index] | mask : value < 0 ? this.bitmap[index] ^ mask : this.bitmap[index] & ~mask;
+    return this;
+  }
+
+  clear(value) {
+    this.bitmap.fill(value ? ~0 : 0);
+    return this;
+  }
+
+  // toBox(one = fullBlock, zero = ' ') {
+  //   // this algorithm is trivial, and not very efficient
+  //   const result = [];
+  //   for (let i = 0; i < this.height; ++i) {
+  //     let row = '';
+  //     for (let j = 0; j < this.width; ++j) row += this.getBit(j, i) ? one : zero;
+  //     result.push(row);
+  //   }
+  //   return result;
+  // }
+
+  toBox(one = fullBlock, zero = ' ') {
+    const result = [];
+    for (let k = 0, kBase = 0; k < this.lineCount; ++k, kBase += this.blockHeight) {
+      const iLimit = Math.min(this.blockHeight, this.height - kBase);
+      for (let i = 0; i < iLimit; ++i) {
+        let row = '';
+        for (let j = 0, jBase = 0; j < this.lineSize; ++j, jBase += this.blockWidth) {
+          const index = k * this.lineSize + j,
+            word = this.bitmap[index],
+            mLimit = Math.min(this.blockWidth, this.width - jBase);
+          let mask = 1 << (this.blockWidth * i);
+          for (let m = 0; m < mLimit; ++m, mask <<= 1) {
+            row += word & mask ? one : zero;
+          }
+        }
+        result.push(row);
+      }
+    }
+    return new Box(result, true);
+  }
+}
+
+addAlias(Bitmap, 'set', 'setBit');
+
+export default Bitmap;

package/src/plot/draw-line.js

@@ -0,0 +1,26 @@
+// Drawing lines using Bresenham's line algorithm
+// The canonic version from https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm
+
+export const drawLine = (bmp, x0, y0, x1, y1, value = 1) => {
+  const dx = Math.abs(x1 - x0),
+    sx = x0 < x1 ? 1 : -1,
+    dy = -Math.abs(y1 - y0),
+    sy = y0 < y1 ? 1 : -1;
+  for (let error = dx + dy; ; ) {
+    bmp.setBit(x0, y0, value);
+    if (x0 == x1 && y0 == y1) break;
+    const e2 = 2 * error;
+    if (e2 >= dy) {
+      if (x0 == x1) break;
+      error += dy;
+      x0 += sx;
+    }
+    if (e2 <= dx) {
+      if (y0 == y1) break;
+      error += dx;
+      y0 += sy;
+    }
+  }
+};
+
+export default drawLine;

package/src/plot/draw-rect.js

@@ -0,0 +1,216 @@
+export const drawRect = (bmp, x0, y0, x1, y1, value = 1) => {
+  if (x1 < x0) [x0, x1] = [x1, x0];
+  if (y1 < y0) [y0, y1] = [y1, y0];
+
+  let indexL = bmp.getWordIndex(x0, y0),
+    indexR = bmp.getWordIndex(x1, y0);
+
+  const mask0 = bmp.getWordMask(x0, 0),
+    mask1 = bmp.getWordMask(x1, 0),
+    rowMask = (1 << bmp.blockWidth) - 1,
+    firstRows = y0 % bmp.blockHeight,
+    firstRowShift = bmp.blockWidth * firstRows,
+    height = y1 - y0 + 1;
+
+  if (firstRows + (y1 - y0) < bmp.blockHeight) {
+    if (indexL === indexR) {
+      // our rows are in a word: calculate a block mask
+      const mask = ~(mask0 - 1) & (mask1 | (mask1 - 1));
+
+      // apply the mask to the last incomplete block
+      let fullMask = mask;
+      for (let i = 1; i < height; ++i) fullMask = (fullMask << bmp.blockWidth) | mask;
+      fullMask <<= firstRowShift;
+
+      bmp.bitmap[indexL] =
+        value > 0
+          ? bmp.bitmap[indexL] | fullMask
+          : value < 0
+          ? bmp.bitmap[indexL] ^ fullMask
+          : bmp.bitmap[indexL] & ~fullMask;
+      return;
+    }
+
+    // our rows are all in one block vertically but over several words
+    // calculate a left mask and a right masks
+    const maskL = ~(mask0 - 1) & rowMask,
+      maskR = mask1 | (mask1 - 1);
+
+    // calculate masks
+    let fullMaskL = maskL,
+      fullMaskR = maskR,
+      fullMaskM = ((1 << (bmp.blockWidth * height)) - 1) << firstRowShift;
+    for (let i = 1; i < height; ++i) {
+      fullMaskL = (fullMaskL << bmp.blockWidth) | maskL;
+      fullMaskR = (fullMaskR << bmp.blockWidth) | maskR;
+    }
+    fullMaskL <<= firstRowShift;
+    fullMaskR <<= firstRowShift;
+
+    // apply masks
+    bmp.bitmap[indexL] =
+      value > 0
+        ? bmp.bitmap[indexL] | fullMaskL
+        : value < 0
+        ? bmp.bitmap[indexL] ^ fullMaskL
+        : bmp.bitmap[indexL] & ~fullMaskL;
+    for (let index = indexL + 1; index < indexR; ++index)
+      bmp.bitmap[index] =
+        value > 0
+          ? bmp.bitmap[index] | fullMaskM
+          : value < 0
+          ? bmp.bitmap[index] ^ fullMaskM
+          : bmp.bitmap[index] & ~fullMaskM;
+    bmp.bitmap[indexR] =
+      value > 0
+        ? bmp.bitmap[indexR] | fullMaskR
+        : value < 0
+        ? bmp.bitmap[indexR] ^ fullMaskR
+        : bmp.bitmap[indexR] & ~fullMaskR;
+    return;
+  }
+
+  const rowsOverFullBlock = height - (firstRows ? bmp.blockHeight - firstRows : 0),
+    fullLines = Math.floor(rowsOverFullBlock / bmp.blockHeight),
+    lastRows = rowsOverFullBlock % bmp.blockHeight;
+
+  if (indexL === indexR) {
+    // our row is confined in a word: calculate a row mask
+    const mask = ~(mask0 - 1) & (mask1 | (mask1 - 1));
+    if (firstRows) {
+      // apply the mask to the first incomplete block
+      let fullMask = mask;
+      for (let i = 1, n = bmp.blockHeight - firstRows; i < n; ++i) fullMask = (fullMask << bmp.blockWidth) | mask;
+      fullMask <<= firstRowShift;
+      bmp.bitmap[indexL] =
+        value > 0
+          ? bmp.bitmap[indexL] | fullMask
+          : value < 0
+          ? bmp.bitmap[indexL] ^ fullMask
+          : bmp.bitmap[indexL] & ~fullMask;
+      indexL += bmp.lineSize;
+    }
+    if (fullLines) {
+      // calculate a mask for full blocks
+      let fullMask = mask;
+      for (let i = 1; i < bmp.blockHeight; ++i) fullMask = (fullMask << bmp.blockWidth) | mask;
+      // apply the mask to full blocks
+      for (let i = 0; i < fullLines; ++i, indexL += bmp.lineSize)
+        bmp.bitmap[indexL] =
+          value > 0
+            ? bmp.bitmap[indexL] | fullMask
+            : value < 0
+            ? bmp.bitmap[indexL] ^ fullMask
+            : bmp.bitmap[indexL] & ~fullMask;
+    }
+    if (lastRows) {
+      // apply the mask to the last incomplete block
+      let fullMask = mask;
+      for (let i = 1; i < lastRows; ++i) fullMask = (fullMask << bmp.blockWidth) | mask;
+      bmp.bitmap[indexL] =
+        value > 0
+          ? bmp.bitmap[indexL] | fullMask
+          : value < 0
+          ? bmp.bitmap[indexL] ^ fullMask
+          : bmp.bitmap[indexL] & ~fullMask;
+    }
+    return;
+  }
+
+  // calculate a left mask and a right masks
+  const maskL = ~(mask0 - 1) & rowMask,
+    maskR = mask1 | (mask1 - 1);
+
+  if (firstRows) {
+    // apply the mask to the first incomplete block
+    let fullMaskL = maskL,
+      fullMaskR = maskR,
+      fullMaskM = ((1 << (bmp.blockWidth * (bmp.blockHeight - firstRows))) - 1) << firstRowShift;
+    for (let i = 1, n = bmp.blockHeight - firstRows; i < n; ++i) {
+      fullMaskL = (fullMaskL << bmp.blockWidth) | maskL;
+      fullMaskR = (fullMaskR << bmp.blockWidth) | maskR;
+    }
+    fullMaskL <<= firstRowShift;
+    fullMaskR <<= firstRowShift;
+    bmp.bitmap[indexL] =
+      value > 0
+        ? bmp.bitmap[indexL] | fullMaskL
+        : value < 0
+        ? bmp.bitmap[indexL] ^ fullMaskL
+        : bmp.bitmap[indexL] & ~fullMaskL;
+    for (let index = indexL + 1; index < indexR; ++index)
+      bmp.bitmap[index] =
+        value > 0
+          ? bmp.bitmap[index] | fullMaskM
+          : value < 0
+          ? bmp.bitmap[index] ^ fullMaskM
+          : bmp.bitmap[index] & ~fullMaskM;
+    bmp.bitmap[indexR] =
+      value > 0
+        ? bmp.bitmap[indexR] | fullMaskR
+        : value < 0
+        ? bmp.bitmap[indexR] ^ fullMaskR
+        : bmp.bitmap[indexR] & ~fullMaskR;
+    indexL += bmp.lineSize;
+    indexR += bmp.lineSize;
+  }
+
+  if (fullLines) {
+    // calculate masks
+    let fullMaskL = maskL,
+      fullMaskR = maskR;
+    for (let i = 1; i < bmp.blockHeight; ++i) {
+      fullMaskL = (fullMaskL << bmp.blockWidth) | maskL;
+      fullMaskR = (fullMaskR << bmp.blockWidth) | maskR;
+    }
+    // apply masks
+    for (let i = 0; i < fullLines; ++i, indexL += bmp.lineSize, indexR += bmp.lineSize) {
+      bmp.bitmap[indexL] =
+        value > 0
+          ? bmp.bitmap[indexL] | fullMaskL
+          : value < 0
+          ? bmp.bitmap[indexL] ^ fullMaskL
+          : bmp.bitmap[indexL] & ~fullMaskL;
+      for (let index = indexL + 1; index < indexR; ++index)
+        bmp.bitmap[index] = value > 0 ? ~0 : value < 0 ? ~bmp.bitmap[index] : 0;
+      bmp.bitmap[indexR] =
+        value > 0
+          ? bmp.bitmap[indexR] | fullMaskR
+          : value < 0
+          ? bmp.bitmap[indexR] ^ fullMaskR
+          : bmp.bitmap[indexR] & ~fullMaskR;
+    }
+  }
+
+  if (lastRows) {
+    // apply the mask to an incomplete block
+    let fullMaskL = maskL,
+      fullMaskR = maskR,
+      fullMaskM = (1 << (bmp.blockWidth * lastRows)) - 1;
+    for (let i = 1; i < lastRows; ++i) {
+      fullMaskL = (fullMaskL << bmp.blockWidth) | maskL;
+      fullMaskR = (fullMaskR << bmp.blockWidth) | maskR;
+    }
+    bmp.bitmap[indexL] =
+      value > 0
+        ? bmp.bitmap[indexL] | fullMaskL
+        : value < 0
+        ? bmp.bitmap[indexL] ^ fullMaskL
+        : bmp.bitmap[indexL] & ~fullMaskL;
+    for (let index = indexL + 1; index < indexR; ++index)
+      bmp.bitmap[index] =
+        value > 0
+          ? bmp.bitmap[index] | fullMaskM
+          : value < 0
+          ? bmp.bitmap[index] ^ fullMaskM
+          : bmp.bitmap[index] & ~fullMaskM;
+    bmp.bitmap[indexR] =
+      value > 0
+        ? bmp.bitmap[indexR] | fullMaskR
+        : value < 0
+        ? bmp.bitmap[indexR] ^ fullMaskR
+        : bmp.bitmap[indexR] & ~fullMaskR;
+  }
+};
+
+export default drawRect;

package/src/plot/index.js

@@ -0,0 +1,24 @@
+import Bitmap from './bitmap.js';
+import drawLine from './draw-line.js';
+import drawRect from './draw-rect.js';
+import toQuads from './to-quads.js';
+
+// patch Bitmap
+
+Bitmap.prototype.line = function (...args) {
+  drawLine(this, ...args);
+  return this;
+};
+Bitmap.prototype.rect = function (...args) {
+  drawRect(this, ...args);
+  return this;
+};
+Bitmap.prototype.toQuads = function () {
+  return toQuads(this);
+};
+Bitmap.prototype.toStrings = function () {
+  return this.toBox().toStrings();
+};
+
+export {Bitmap, drawLine, drawRect, toQuads};
+export default Bitmap;

package/src/plot/to-quads.js

@@ -0,0 +1,32 @@
+import Box from '../box.js';
+import {quadrants} from '../symbols.js';
+
+export const toQuads = bmp => {
+  const result = [],
+    rowSize = Math.floor((bmp.width + 1) / 2),
+    accumulator = new Array(rowSize).fill(0);
+  for (let k = 0, kBase = 0; k < bmp.lineCount; ++k, kBase += bmp.blockHeight) {
+    const iLimit = Math.min(bmp.blockHeight, bmp.height - kBase);
+    for (let i = 0; i < iLimit; ++i) {
+      for (let j = 0, jBase = 0; j < bmp.lineSize; ++j, jBase += bmp.blockWidth) {
+        const index = k * bmp.lineSize + j,
+          word = bmp.bitmap[index],
+          mLimit = Math.min(bmp.blockWidth, bmp.width - jBase);
+        let mask = 1 << (bmp.blockWidth * i);
+        for (let m = 0; m < mLimit; ++m, mask <<= 1) {
+          accumulator[(jBase + m) >> 1] += word & mask ? ((kBase + i) & 1 ? 4 : 1) << ((jBase + m) & 1) : 0;
+        }
+      }
+      if ((kBase + i) & 1) {
+        result.push(accumulator.map(i => quadrants[i]).join(''));
+        if (kBase + i + 1 < bmp.height) accumulator.fill(0);
+      }
+    }
+  }
+  if (bmp.height & 1) {
+    result.push(accumulator.map(i => quadrants[i]).join(''));
+  }
+  return new Box(result, true);
+};
+
+export default toQuads;

package/src/spinner/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+export {Spinner} from './spinner.js';
+import spin from './spin.js';
+
+export {spin};
+
+export default spin;

package/src/spinner/spin.js

@@ -0,0 +1,51 @@
+'use strict';
+
+import {SpinnerBase} from './spinner.js';
+
+class Spinner extends SpinnerBase {
+  constructor(strings, args) {
+    super(false);
+    this.strings = strings;
+    this.args = args;
+    this.indices = new WeakMap();
+  }
+
+  getFrame() {
+    let result = '';
+    for (let i = 0; i < this.args.length; ++i) {
+      const arg = this.args[i];
+
+      result += this.strings[i];
+
+      if (typeof arg == 'function') {
+        result += String(arg(this.state));
+        continue;
+      }
+
+      if (arg instanceof SpinnerBase) {
+        arg.active = this.active;
+        arg.paused = this.paused;
+        arg.finished = this.finished;
+        result += arg.getFrame();
+        continue;
+      }
+
+      if (Array.isArray(arg)) {
+        if (!this.indices.has(arg)) this.indices.set(arg, 0);
+        const index = this.indices.get(arg);
+        if (!this.finished && !this.paused && this.active) this.indices.set(arg, (index + 1) % arg.length);
+        result += String(arg[index]);
+        continue;
+      }
+
+      result += String(arg);
+    }
+
+    result += this.strings[this.args.length];
+    return result;
+  }
+}
+
+const spin = (strings, ...args) => new Spinner(strings, args);
+
+export default spin;

package/src/spinner/spinner.js

@@ -0,0 +1,75 @@
+'use strict';
+
+import {checkMarkHeavy} from '../symbols.js';
+
+export class SpinnerBase {
+  constructor(isStarted) {
+    this.active = isStarted;
+    this.paused = false;
+    this.finished = false;
+    this.frameIndex = 0;
+  }
+
+  get isStarted() {
+    return this.active || this.finished;
+  }
+
+  get isActive() {
+    return this.active;
+  }
+
+  get isFinished() {
+    return this.finished;
+  }
+
+  get state() {
+    if (this.finished) return 'finished';
+    if (this.active) return this.paused ? 'paused' : 'active';
+    return '';
+  }
+
+  set state(value) {
+    this.finished = this.active = this.paused = false;
+    switch (value) {
+      case 'finished':
+        this.finished = true;
+        break;
+      case 'paused':
+        this.active = this.paused = true;
+        break;
+      case 'active':
+        this.active = true;
+        break;
+    }
+  }
+
+  reset() {
+    this.active = this.paused = this.finished = false;
+  }
+
+  nextFrameIndex(length) {
+    return (this.frameIndex = (this.frameIndex + 1) % length);
+  }
+
+  getFrame() {
+    return 'X';
+  }
+}
+
+const defaultSpinnerDefinition = {notStarted: [' '], finished: [checkMarkHeavy], frames: [...'⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏']};
+
+export class Spinner extends SpinnerBase {
+  constructor(spinnerDefinition, isStarted) {
+    super(isStarted);
+    this.spinner = {...defaultSpinnerDefinition, ...spinnerDefinition};
+  }
+
+  getFrame() {
+    if (this.finished) return this.spinner.finished[this.nextFrameIndex(this.spinner.finished.length)];
+    if (!this.active) return this.spinner.notStarted[this.nextFrameIndex(this.spinner.notStarted.length)];
+    if (!this.paused) this.nextFrameIndex(this.spinner.frames.length);
+    return this.spinner.frames[this.frameIndex];
+  }
+}
+
+export default Spinner;

package/src/spinner/spinners.js

@@ -0,0 +1,65 @@
+'use strict';
+
+// Spinners are from https://github.com/sindresorhus/cli-spinners under the MIT license.
+// Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+// See `cli-spinners` for more great options.
+
+export const dots = {frames: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']};
+export const sand = {frames: [...'⠁⠂⠄⡀⡈⡐⡠⣀⣁⣂⣄⣌⣔⣤⣥⣦⣮⣶⣷⣿⡿⠿⢟⠟⡛⠛⠫⢋⠋⠍⡉⠉⠑⠡⢁']};
+export const line = {frames: ['-', '\\', '|', '/']};
+export const pipe = {frame: ['┤', '┘', '┴', '└', '├', '┌', '┬', '┐']};
+export const growVertical = {frame: ['▁', '▃', '▄', '▅', '▆', '▇', '▆', '▅', '▄', '▃']};
+export const growHorizontal = {frame: ['▏', '▎', '▍', '▌', '▋', '▊', '▉', '▊', '▋', '▌', '▍', '▎']};
+export const noise = {frame: ['▓', '▒', '░']};
+export const bounce = {frame: ['⠁', '⠂', '⠄', '⠂']};
+export const arc = {frame: ['◜', '◠', '◝', '◞', '◡', '◟']};
+export const squareQuarters = {frames: ['◰', '◳', '◲', '◱']};
+export const circleQuarters = {frames: ['◴', '◷', '◶', '◵']};
+export const circleHalves = {frames: ['◐', '◓', '◑', '◒']};
+export const arrows = {frame: ['←', '↖', '↑', '↗', '→', '↘', '↓', '↙']};
+
+export const clock = {
+  frames: ['🕛 ', '🕐 ', '🕑 ', '🕒 ', '🕓 ', '🕔 ', '🕕 ', '🕖 ', '🕗 ', '🕘 ', '🕙 ', '🕚 '],
+  notStarted: [' '],
+  finished: ['✔ ']
+};
+
+export const bouncingBar = {
+  frames: [
+    '[    ]',
+    '[=   ]',
+    '[==  ]',
+    '[=== ]',
+    '[====]',
+    '[ ===]',
+    '[  ==]',
+    '[   =]',
+    '[    ]',
+    '[   =]',
+    '[  ==]',
+    '[ ===]',
+    '[====]',
+    '[=== ]',
+    '[==  ]',
+    '[=   ]'
+  ],
+  notStarted: ['[    ]'],
+  finished: ['[####]']
+};
+
+export const bouncingBall = {
+  frames: [
+    '( ●    )',
+    '(  ●   )',
+    '(   ●  )',
+    '(    ● )',
+    '(     ●)',
+    '(    ● )',
+    '(   ●  )',
+    '(  ●   )',
+    '( ●    )',
+    '(●     )'
+  ],
+  notStarted: ['(      )'],
+  finished: ['(●●●●●●)']
+};

package/src/strings.js

@@ -0,0 +1,72 @@
+export const matchCsiNoGroups = /\x1B\[[\x30-\x3F]*[\x20-\x2F]*[\x40-\x7E]/g;
+export const matchCsiNoSgrNoGroups = /\x1B\[[\x30-\x3F]*[\x20-\x2F]*[\x40-\x6C\x6E-\x7E]/g;
+
+export const getLength = (s, matcher = matchCsiNoGroups) => {
+  s = String(s);
+  let counter = 0,
+    start = 0;
+  matcher.lastIndex = 0;
+  for (const match of s.matchAll(matcher)) {
+    counter += [...s.substring(start, match.index)].length;
+    start = match.index + match[0].length;
+  }
+  counter += [...s.substring(start)].length;
+  return counter;
+};
+
+export const getMaxLength = (strings, matcher = matchCsiNoGroups) =>
+  Math.max(0, ...strings.map(s => getLength(s, matcher)));
+
+export const clip = (s, width, includeLastCommand, matcher = matchCsiNoGroups) => {
+  s = String(s);
+  let counter = 0,
+    start = 0;
+  matcher.lastIndex = 0;
+  for (const match of s.matchAll(matcher)) {
+    if (counter >= width) return s.substring(0, match.index + (includeLastCommand ? match[0].length : 0));
+    const prev = [...s.substring(start, match.index)];
+    counter += prev.length;
+    if (includeLastCommand ? counter > width : counter >= width) {
+      const diff = width - counter,
+        end = start + (diff ? prev.slice(0, prev.length + diff).join('').length : prev.length);
+      return s.substring(0, end);
+    }
+    start = match.index + match[0].length;
+  }
+  if (counter >= width) return s.substring(0, start);
+  const prev = [...s.substring(start)];
+  if (counter + prev.length > width) {
+    const end = start + prev.slice(0, width - counter).join('').length;
+    return s.substring(0, end);
+  }
+  return s; // unchanged
+};
+
+export const clipStrings = (strings, width, includeLastCommand, matcher = matchCsiNoGroups) =>
+  strings.map(s => clip(s, width, includeLastCommand, matcher));
+
+export const toStrings = s => {
+  main: for (;;) {
+    switch (typeof s) {
+      case 'function':
+        for (let i = 0; i < 10 && typeof s == 'function'; ++i) s = s();
+        if (typeof s == 'function') s = String(s);
+        continue main;
+      case 'number':
+      case 'boolean':
+        return [String(s)];
+      case 'string':
+        return String(s).split(/\r?\n/g);
+      case 'object':
+        if (Array.isArray(s)) return [...s];
+        if (!s) break main;
+        if (typeof s.toStrings == 'function') return s.toStrings();
+        if (typeof s.toBox == 'function') return s.toBox().box;
+        if (typeof s.toPanel == 'function') return s.toPanel().toStrings();
+        s = String(s);
+        continue main;
+    }
+    break main;
+  }
+  return [];
+};