console-toolkit 1.2.15 → 1.3.0

package/src/plot/bitmap.js

@@ -2,16 +2,7 @@ import Box from '../box.js';
 import {addAlias} from '../meta.js';
 import {fullBlock} from '../symbols.js';
 
-/** A bitmap image using a compact bit-packed representation.
- * Supports setting/getting individual bits and converting to a Box for console display.
- */
 export class Bitmap {
-  /** Creates a new Bitmap.
-   * @param {number} width - The width in pixels.
-   * @param {number} height - The height in pixels.
-   * @param {number} [blockWidth=5] - The width of each internal block (blockWidth * blockHeight <= 32).
-   * @param {number} [blockHeight=5] - The height of each internal block.
-   */
   constructor(width, height, blockWidth = 5, blockHeight = 5) {
     // parameters check
     width = Math.round(width);
@@ -58,11 +49,6 @@ export class Bitmap {
     return 1 << (shiftX + this.blockWidth * shiftY);
   }
 
-  /** Gets the value of a bit at the given position.
-   * @param {number} x - The x coordinate.
-   * @param {number} y - The y coordinate.
-   * @returns {number} Non-zero if the bit is set, 0 otherwise.
-   */
   getBit(x, y) {
     if (x < 0 || x >= this.width || y < 0 || y >= this.height) return 0;
     const index = this.getWordIndex(x, y),
@@ -70,12 +56,6 @@ export class Bitmap {
     return this.bitmap[index] & mask;
   }
 
-  /** Sets or clears a bit at the given position.
-   * @param {number} x - The x coordinate.
-   * @param {number} y - The y coordinate.
-   * @param {number} [value=1] - Positive to set, 0 to clear, negative to toggle.
-   * @returns {this}
-   */
   setBit(x, y, value = 1) {
     if (x < 0 || x >= this.width || y < 0 || y >= this.height) return this;
     const index = this.getWordIndex(x, y),
@@ -85,10 +65,6 @@ export class Bitmap {
     return this;
   }
 
-  /** Clears the entire bitmap.
-   * @param {boolean} [value=false] - If true, sets all bits; if false, clears all bits.
-   * @returns {this}
-   */
   clear(value) {
     this.bitmap.fill(value ? ~0 : 0);
     return this;
@@ -105,27 +81,23 @@ export class Bitmap {
   //   return result;
   // }
 
-  /** Converts the bitmap to a Box for console display.
-   * @param {string} [one=fullBlock] - Character for set bits.
-   * @param {string} [zero=' '] - Character for unset bits.
-   * @returns {import('../box.js').Box} A Box representation of the bitmap.
-   */
   toBox(one = fullBlock, zero = ' ') {
-    const result = [];
+    const result = [],
+      chars = new Array(this.width);
     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 = '';
+        let pos = 0;
         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;
+            chars[pos++] = word & mask ? one : zero;
           }
         }
-        result.push(row);
+        result.push(chars.join(''));
       }
     }
     return new Box(result, true);

package/src/plot/draw-line.js

@@ -1,14 +1,6 @@
 // Drawing lines using Bresenham's line algorithm
 // The canonic version from https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm
 
-/** Draws a line on a Bitmap using Bresenham's line algorithm.
- * @param {import('./bitmap.js').Bitmap} bmp - The bitmap to draw on.
- * @param {number} x0 - Start x coordinate.
- * @param {number} y0 - Start y coordinate.
- * @param {number} x1 - End x coordinate.
- * @param {number} y1 - End y coordinate.
- * @param {number} [value=1] - Bit value: positive to set, 0 to clear, negative to toggle.
- */
 export const drawLine = (bmp, x0, y0, x1, y1, value = 1) => {
   const dx = Math.abs(x1 - x0),
     sx = x0 < x1 ? 1 : -1,

package/src/plot/draw-rect.js

@@ -1,15 +1,16 @@
-/** Draws a filled rectangle on a Bitmap by efficiently manipulating the underlying bit array.
- * @param {import('./bitmap.js').Bitmap} bmp - The bitmap to draw on.
- * @param {number} x0 - First corner x coordinate.
- * @param {number} y0 - First corner y coordinate.
- * @param {number} x1 - Opposite corner x coordinate.
- * @param {number} y1 - Opposite corner y coordinate.
- * @param {number} [value=1] - Bit value: positive to set, 0 to clear, negative to toggle.
- */
 export const drawRect = (bmp, x0, y0, x1, y1, value = 1) => {
   if (x1 < x0) [x0, x1] = [x1, x0];
   if (y1 < y0) [y0, y1] = [y1, y0];
 
+  // hoist op-mode once: + = set (OR), - = toggle (XOR), 0 = clear (AND~)
+  const apply =
+    value > 0
+      ? (current, mask) => current | mask
+      : value < 0
+        ? (current, mask) => current ^ mask
+        : (current, mask) => current & ~mask;
+  const applyFull = value > 0 ? () => ~0 : value < 0 ? current => ~current : () => 0;
+
   let indexL = bmp.getWordIndex(x0, y0),
     indexR = bmp.getWordIndex(x1, y0);
 
@@ -30,12 +31,7 @@ export const drawRect = (bmp, x0, y0, x1, y1, value = 1) => {
       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;
+      bmp.bitmap[indexL] = apply(bmp.bitmap[indexL], fullMask);
       return;
     }
 
@@ -56,25 +52,9 @@ export const drawRect = (bmp, x0, y0, x1, y1, value = 1) => {
     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;
+    bmp.bitmap[indexL] = apply(bmp.bitmap[indexL], fullMaskL);
+    for (let index = indexL + 1; index < indexR; ++index) bmp.bitmap[index] = apply(bmp.bitmap[index], fullMaskM);
+    bmp.bitmap[indexR] = apply(bmp.bitmap[indexR], fullMaskR);
     return;
   }
 
@@ -90,12 +70,7 @@ export const drawRect = (bmp, x0, y0, x1, y1, value = 1) => {
       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;
+      bmp.bitmap[indexL] = apply(bmp.bitmap[indexL], fullMask);
       indexL += bmp.lineSize;
     }
     if (fullLines) {
@@ -104,23 +79,13 @@ export const drawRect = (bmp, x0, y0, x1, y1, value = 1) => {
       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;
+        bmp.bitmap[indexL] = apply(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;
+      bmp.bitmap[indexL] = apply(bmp.bitmap[indexL], fullMask);
     }
     return;
   }
@@ -140,25 +105,9 @@ export const drawRect = (bmp, x0, y0, x1, y1, value = 1) => {
     }
     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;
+    bmp.bitmap[indexL] = apply(bmp.bitmap[indexL], fullMaskL);
+    for (let index = indexL + 1; index < indexR; ++index) bmp.bitmap[index] = apply(bmp.bitmap[index], fullMaskM);
+    bmp.bitmap[indexR] = apply(bmp.bitmap[indexR], fullMaskR);
     indexL += bmp.lineSize;
     indexR += bmp.lineSize;
   }
@@ -173,20 +122,9 @@ export const drawRect = (bmp, x0, y0, x1, y1, value = 1) => {
     }
     // 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;
+      bmp.bitmap[indexL] = apply(bmp.bitmap[indexL], fullMaskL);
+      for (let index = indexL + 1; index < indexR; ++index) bmp.bitmap[index] = applyFull(bmp.bitmap[index]);
+      bmp.bitmap[indexR] = apply(bmp.bitmap[indexR], fullMaskR);
     }
   }
 
@@ -199,25 +137,9 @@ export const drawRect = (bmp, x0, y0, x1, y1, value = 1) => {
       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;
+    bmp.bitmap[indexL] = apply(bmp.bitmap[indexL], fullMaskL);
+    for (let index = indexL + 1; index < indexR; ++index) bmp.bitmap[index] = apply(bmp.bitmap[index], fullMaskM);
+    bmp.bitmap[indexR] = apply(bmp.bitmap[indexR], fullMaskR);
   }
 };
 

package/src/plot/index.js

@@ -5,39 +5,17 @@ import toQuads from './to-quads.js';
 
 // patch Bitmap
 
-/** Draws a line on this bitmap.
- * @param {number} x0 - Start X.
- * @param {number} y0 - Start Y.
- * @param {number} x1 - End X.
- * @param {number} y1 - End Y.
- * @param {number} [value=1] - Bit value.
- * @returns {this}
- */
 Bitmap.prototype.line = function (...args) {
   drawLine(this, ...args);
   return this;
 };
-/** Draws a filled rectangle on this bitmap.
- * @param {number} x0 - First corner x coordinate.
- * @param {number} y0 - First corner y coordinate.
- * @param {number} x1 - Opposite corner x coordinate.
- * @param {number} y1 - Opposite corner y coordinate.
- * @param {number} [value=1] - Bit value.
- * @returns {this}
- */
 Bitmap.prototype.rect = function (...args) {
   drawRect(this, ...args);
   return this;
 };
-/** Converts this bitmap to a Box using quadrant characters.
- * @returns {import('../box.js').default}
- */
 Bitmap.prototype.toQuads = function () {
   return toQuads(this);
 };
-/** Converts this bitmap to a string array via `toBox()`.
- * @returns {string[]}
- */
 Bitmap.prototype.toStrings = function () {
   return this.toBox().toStrings();
 };

package/src/plot/to-quads.js

@@ -1,11 +1,6 @@
 import Box from '../box.js';
 import {quadrants} from '../symbols.js';
 
-/** Converts a Bitmap to a Box using Unicode quadrant characters (2x2 pixels per character).
- * Provides higher resolution representation than `toBox()`.
- * @param {import('./bitmap.js').Bitmap} bmp - The bitmap to convert.
- * @returns {import('../box.js').Box} A Box with quadrant characters.
- */
 export const toQuads = bmp => {
   const result = [],
     rowSize = Math.floor((bmp.width + 1) / 2),
@@ -23,7 +18,9 @@ export const toQuads = bmp => {
         }
       }
       if ((kBase + i) & 1) {
-        result.push(accumulator.map(i => quadrants[i]).join(''));
+        let row = '';
+        for (const k of accumulator) row += quadrants[k];
+        result.push(row);
         if (kBase + i + 1 < bmp.height) accumulator.fill(0);
       }
     }

package/src/spinner/spin.js

@@ -1,10 +1,6 @@
 import {SpinnerBase} from './spinner.js';
 
-/** Internal composite spinner that handles multiple spinner parts and functions via tagged template literals. */
 class Spinner extends SpinnerBase {
-  /** @param {TemplateStringsArray} strings - Template literal strings.
-   * @param {any[]} args - Interpolated values.
-   */
   constructor(strings, args) {
     super(false);
     this.strings = strings;
@@ -12,9 +8,28 @@ class Spinner extends SpinnerBase {
     this.indices = new WeakMap();
   }
 
-  /** Returns the current composite frame string.
-   * @returns {string}
-   */
+  tick() {
+    for (const arg of this.args) {
+      if (arg instanceof SpinnerBase) {
+        arg.active = this.active;
+        arg.paused = this.paused;
+        arg.finished = this.finished;
+        arg.tick();
+        continue;
+      }
+      if (Array.isArray(arg)) {
+        if (!this.indices.has(arg)) {
+          this.indices.set(arg, 0);
+          continue;
+        }
+        if (!this.finished && !this.paused && this.active) {
+          this.indices.set(arg, (this.indices.get(arg) + 1) % arg.length);
+        }
+      }
+    }
+    return this;
+  }
+
   getFrame() {
     let result = '';
     for (let i = 0; i < this.args.length; ++i) {
@@ -28,18 +43,12 @@ class Spinner extends SpinnerBase {
       }
 
       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]);
+        result += String(arg[this.indices.get(arg) ?? 0]);
         continue;
       }
 
@@ -51,12 +60,6 @@ class Spinner extends SpinnerBase {
   }
 }
 
-/** Tagged template literal function that creates a composite spinner.
- * Arguments can be string arrays (cycled through), functions `(state) => string`, or SpinnerBase instances.
- * @param {TemplateStringsArray} strings - Template literal strings.
- * @param {...(string[]|Function|import('./spinner.js').SpinnerBase|*)} args - Interpolated values.
- * @returns {import('./spinner.js').SpinnerBase} A composite spinner.
- */
 const spin = (strings, ...args) => new Spinner(strings, args);
 
 export default spin;

package/src/spinner/spinner.d.ts

@@ -31,10 +31,19 @@ export class SpinnerBase {
    * @returns The next frame index.
    */
   nextFrameIndex(length: number): number;
-  /** Returns the current frame string.
+  /** Advances internal state by one step (state-aware: only advances when active+!paused or in finished/notStarted modes).
+   * Pure mutation — call `getFrame()` after to read the new frame.
+   * @returns This instance.
+   */
+  tick(): this;
+  /** Returns the frame string at the current index. Read-only — does not mutate.
    * @returns The frame string.
    */
   getFrame(): string;
+  /** Convenience: calls `tick()` then `getFrame()`. Equivalent to the pre-1.3 `getFrame()` advance-and-return.
+   * @returns The frame string at the new index.
+   */
+  nextFrame(): string;
 }
 
 /** Definition of spinner frame sets. */
@@ -60,7 +69,12 @@ export class Spinner extends SpinnerBase {
    */
   constructor(spinnerDefinition?: SpinnerDefinition, isStarted?: boolean);
 
-  /** Returns the current frame string based on state.
+  /** Advances frame index for the active state-array (frames / notStarted / finished).
+   * No-op in `paused` state. Read-only-call `getFrame()` after.
+   * @returns This instance.
+   */
+  tick(): this;
+  /** Returns the frame string at the current index for the active state-array. Read-only.
    * @returns The frame string.
    */
   getFrame(): string;

package/src/spinner/spinner.js

@@ -1,10 +1,6 @@
 import {checkMarkHeavy} from '../symbols.js';
 
-/** Base class for spinners. Manages spinner state (active, paused, finished) and frame index. */
 export class SpinnerBase {
-  /**
-   * @param {boolean} [isStarted=false] - Whether the spinner starts in the active state.
-   */
   constructor(isStarted) {
     this.active = isStarted;
     this.paused = false;
@@ -12,31 +8,24 @@ export class SpinnerBase {
     this.frameIndex = 0;
   }
 
-  /** Whether the spinner has been started (active or finished). */
   get isStarted() {
     return this.active || this.finished;
   }
 
-  /** Whether the spinner is currently active. */
   get isActive() {
     return this.active;
   }
 
-  /** Whether the spinner has finished. */
   get isFinished() {
     return this.finished;
   }
 
-  /** The current state: `''`, `'active'`, `'paused'`, or `'finished'`. */
   get state() {
     if (this.finished) return 'finished';
     if (this.active) return this.paused ? 'paused' : 'active';
     return '';
   }
 
-  /** Sets the spinner state.
-   * @param {''|'active'|'paused'|'finished'} value
-   */
   set state(value) {
     this.finished = this.active = this.paused = false;
     switch (value) {
@@ -52,51 +41,50 @@ export class SpinnerBase {
     }
   }
 
-  /** Resets the spinner to its initial (not started) state. */
   reset() {
     this.active = this.paused = this.finished = false;
   }
 
-  /** Advances and returns the next frame index.
-   * @param {number} length - The total number of frames.
-   * @returns {number} The new frame index.
-   */
   nextFrameIndex(length) {
     return (this.frameIndex = (this.frameIndex + 1) % length);
   }
 
-  /** Returns the current frame string. Override in subclasses.
-   * @returns {string}
-   */
+  tick() {
+    return this;
+  }
+
   getFrame() {
     return 'X';
   }
+
+  nextFrame() {
+    this.tick();
+    return this.getFrame();
+  }
 }
 
 const defaultSpinnerDefinition = {notStarted: [' '], finished: [checkMarkHeavy], frames: [...'⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏']};
 
-/** A spinner with configurable frame sets for active, not-started, and finished states. */
 export class Spinner extends SpinnerBase {
-  /**
-   * @param {object} [spinnerDefinition] - Spinner definition with `frames`, `notStarted`, and `finished` arrays.
-   * @param {string[]} [spinnerDefinition.frames] - Animation frames for the active state.
-   * @param {string[]} [spinnerDefinition.notStarted] - Frames shown before the spinner starts.
-   * @param {string[]} [spinnerDefinition.finished] - Frames shown after the spinner finishes.
-   * @param {boolean} [isStarted=false] - Whether the spinner starts active.
-   */
   constructor(spinnerDefinition, isStarted) {
     super(isStarted);
     this.spinner = {...defaultSpinnerDefinition, ...spinnerDefinition};
   }
 
-  /** Returns the current frame based on the spinner's state.
-   * @returns {string}
-   */
+  tick() {
+    if (this.finished) {
+      this.nextFrameIndex(this.spinner.finished.length);
+    } else if (!this.active) {
+      this.nextFrameIndex(this.spinner.notStarted.length);
+    } else if (!this.paused) {
+      this.nextFrameIndex(this.spinner.frames.length);
+    }
+    return this;
+  }
+
   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];
+    const arr = this.finished ? this.spinner.finished : !this.active ? this.spinner.notStarted : this.spinner.frames;
+    return arr[this.frameIndex % arr.length];
   }
 }
 

package/src/spinner/spinners.js

@@ -2,41 +2,26 @@
 // Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
 // See `cli-spinners` for more great options.
 
-/** Braille dots spinner. */
 export const dots = {frames: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']};
-/** Sand/hourglass spinner. */
 export const sand = {frames: [...'⠁⠂⠄⡀⡈⡐⡠⣀⣁⣂⣄⣌⣔⣤⣥⣦⣮⣶⣷⣿⡿⠿⢟⠟⡛⠛⠫⢋⠋⠍⡉⠉⠑⠡⢁']};
-/** Line spinner (|/-\). */
 export const line = {frames: ['-', '\\', '|', '/']};
-/** Pipe spinner. */
 export const pipe = {frames: ['┤', '┘', '┴', '└', '├', '┌', '┬', '┐']};
-/** Vertical growing bar spinner. */
 export const growVertical = {frames: ['▁', '▃', '▄', '▅', '▆', '▇', '▆', '▅', '▄', '▃']};
-/** Horizontal growing bar spinner. */
 export const growHorizontal = {frames: ['▏', '▎', '▍', '▌', '▋', '▊', '▉', '▊', '▋', '▌', '▍', '▎']};
-/** Random noise spinner. */
 export const noise = {frames: ['▓', '▒', '░']};
-/** Bouncing spinner. */
 export const bounce = {frames: ['⠁', '⠂', '⠄', '⠂']};
-/** Arc spinner. */
 export const arc = {frames: ['◜', '◠', '◝', '◞', '◡', '◟']};
-/** Square quarters spinner. */
 export const squareQuarters = {frames: ['◰', '◳', '◲', '◱']};
-/** Circle quarters spinner. */
 export const circleQuarters = {frames: ['◴', '◷', '◶', '◵']};
-/** Circle halves spinner. */
 export const circleHalves = {frames: ['◐', '◓', '◑', '◒']};
-/** Arrows spinner. */
 export const arrows = {frames: ['←', '↖', '↑', '↗', '→', '↘', '↓', '↙']};
 
-/** Clock spinner. */
 export const clock = {
   frames: ['🕛 ', '🕐 ', '🕑 ', '🕒 ', '🕓 ', '🕔 ', '🕕 ', '🕖 ', '🕗 ', '🕘 ', '🕙 ', '🕚 '],
   notStarted: [' '],
   finished: ['✔ ']
 };
 
-/** Bouncing bar spinner. */
 export const bouncingBar = {
   frames: [
     '[    ]',
@@ -60,7 +45,6 @@ export const bouncingBar = {
   finished: ['[####]']
 };
 
-/** Bouncing ball spinner. */
 export const bouncingBall = {
   frames: [
     '( ●    )',

package/src/strings/clip.js

@@ -1,16 +1,6 @@
 import parse, {matchCsiNoGroups} from './parse.js';
 import {split} from './split.js';
 
-/** Clips a string to a specified display width, correctly handling ANSI escape codes and multi-width characters.
- * @param {string} s - The string to clip.
- * @param {number} width - The maximum display width.
- * @param {object} [options] - Options.
- * @param {boolean} [options.includeLastCommand=false] - If true, include the last (invisible) ANSI command in the clipped result.
- * @param {RegExp} [options.matcher=matchCsiNoGroups] - The regular expression used to match escape sequences.
- * @param {boolean} [options.ignoreControlSymbols] - If true, control symbols are ignored during width calculation.
- * @param {boolean} [options.ambiguousAsWide] - If true, ambiguous East Asian characters are treated as double-wide.
- * @returns {string} The clipped string.
- */
 export const clip = (s, width, options = {}) => {
   const {includeLastCommand = false, matcher = matchCsiNoGroups} = options;
 

package/src/strings/parse.js

@@ -1,13 +1,6 @@
-/** RegExp that matches CSI sequences with no capture groups. */
 export const matchCsiNoGroups = /\x1B\[[\x30-\x3F]*[\x20-\x2F]*[\x40-\x7E]/g;
-/** RegExp that matches CSI sequences excluding SGR commands, with no capture groups. */
 export const matchCsiNoSgrNoGroups = /\x1B\[[\x30-\x3F]*[\x20-\x2F]*[\x40-\x6C\x6E-\x7E]/g;
 
-/** Parses a string yielding segments of text and matched ANSI escape sequences.
- * @param {string} s - The string to parse.
- * @param {RegExp} [matcher=matchCsiNoGroups] - The regular expression used to match escape sequences.
- * @yields {{start: number, string: string, match: RegExpMatchArray | null}} Parsed segments.
- */
 export function* parse(s, matcher = matchCsiNoGroups) {
   s = String(s);
   let start = 0;