console-toolkit 1.2.8 → 1.2.10

package/src/panel.js

@@ -15,7 +15,15 @@ import split, {size} from './strings/split.js';
 import Box from './box.js';
 import {addAliases} from './meta.js';
 
+/** A 2D array of cells, where each cell has a character symbol and an SGR state.
+ * Provides methods for manipulation, styling, geometric transforms, and conversion to Box/strings.
+ * @see {@link https://github.com/uhop/console-toolkit/wiki/Module:-panel}
+ */
 export class Panel {
+  /** Creates an empty Panel of the given dimensions.
+   * @param {number} width - Width in columns.
+   * @param {number} height - Height in rows.
+   */
   constructor(width, height) {
     this.box = new Array(height);
     for (let i = 0; i < height; ++i) {
@@ -23,14 +31,21 @@ export class Panel {
     }
   }
 
+  /** The width of the panel in columns. */
   get width() {
     return this.box.length && this.box[0].length;
   }
 
+  /** The height of the panel in rows. */
   get height() {
     return this.box.length;
   }
 
+  /** Creates a Panel from various input types (Panel, Box, string, string[], function).
+   * @param {import('./strings.js').StringsInput} s - Input data.
+   * @param {object} [options] - Options passed to Box.make() or put().
+   * @returns {Panel}
+   */
   static make(s, options) {
     main: for (;;) {
       switch (typeof s) {
@@ -52,6 +67,12 @@ export class Panel {
     return panel;
   }
 
+  /** Converts the panel to an array of strings with embedded ANSI escape sequences.
+   * @param {object} [options] - Options.
+   * @param {string} [options.emptySymbol=' '] - Character for empty cells.
+   * @param {object} [options.emptyState] - SGR state for empty cells.
+   * @returns {string[]}
+   */
   toStrings(options = {}) {
     if (!this.height || !this.width) return Box.makeBlank(this.width, this.height);
 
@@ -81,10 +102,21 @@ export class Panel {
     return s;
   }
 
+  /** Converts the panel to a Box.
+   * @param {object} [options] - Options passed to toStrings().
+   * @returns {import('./box.js').Box}
+   */
   toBox(options) {
     return new Box(this.toStrings(options), true);
   }
 
+  /** Extracts a rectangular region as a new Panel.
+   * @param {number} [x=0] - Left column.
+   * @param {number} [y=0] - Top row.
+   * @param {number} [width] - Width (defaults to panel width).
+   * @param {number} [height] - Height (defaults to panel height).
+   * @returns {Panel}
+   */
   extract(x, y, width, height) {
     // normalize arguments
 
@@ -131,10 +163,23 @@ export class Panel {
     return panel;
   }
 
+  /** Creates a deep copy of this panel.
+   * @returns {Panel}
+   */
   clone() {
     return this.extract();
   }
 
+  /** Copies cells from another panel into this panel.
+   * @param {number} x - Destination x.
+   * @param {number} y - Destination y.
+   * @param {number} width - Width to copy.
+   * @param {number} height - Height to copy.
+   * @param {Panel} panel - Source panel.
+   * @param {number} [x1=0] - Source x.
+   * @param {number} [y1=0] - Source y.
+   * @returns {this}
+   */
   copyFrom(x, y, width, height, panel, x1 = 0, y1 = 0) {
     // normalize arguments
 
@@ -169,6 +214,14 @@ export class Panel {
     return this;
   }
 
+  /** Places text onto this panel at the given position. Characters matching `emptySymbol` (default: '\x07' BELL) are treated as empty cells.
+   * @param {number} x - Left column.
+   * @param {number} y - Top row.
+   * @param {import('./strings.js').StringsInput} text - Content to place.
+   * @param {object} [options] - Put options.
+   * @param {string} [options.emptySymbol='\x07'] - Character treated as an empty cell.
+   * @returns {this}
+   */
   put(x, y, text, options = {}) {
     if (text instanceof Panel) return this.copyFrom(x, y, text.width, text.height, text);
 
@@ -228,6 +281,15 @@ export class Panel {
     return this;
   }
 
+  /** Applies a function to each cell in a rectangular region.
+   * @param {number|Function} x - Left column, or the function if called with a single argument.
+   * @param {number} [y] - Top row.
+   * @param {number} [width] - Width.
+   * @param {number} [height] - Height.
+   * @param {Function} [fn] - Function `(x, y, cell) => newCell`.
+   * @param {object} [options] - Options.
+   * @returns {this}
+   */
   applyFn(x, y, width, height, fn, options) {
     // normalize arguments
 
@@ -274,6 +336,16 @@ export class Panel {
     return this;
   }
 
+  /** Fills a rectangular region with a symbol and state.
+   * @param {number|string} x - Left column, or symbol if filling the entire panel.
+   * @param {number} [y] - Top row.
+   * @param {number} [width] - Width.
+   * @param {number} [height] - Height.
+   * @param {string} [symbol] - Fill character.
+   * @param {object|string|string[]} [state={}] - SGR state.
+   * @param {object} [options] - Options.
+   * @returns {this}
+   */
   fill(x, y, width, height, symbol, state = {}, options) {
     if (typeof x === 'string') {
       symbol = x;
@@ -293,6 +365,14 @@ export class Panel {
     return this.applyFn(x, y, width, height, () => ({symbol, state}), options);
   }
 
+  /** Fills all cells with the given state, using `emptySymbol` for empty cells' symbol.
+   * @param {number|object} x - Left column, or options if filling the entire panel.
+   * @param {number} [y] - Top row.
+   * @param {number} [width] - Width.
+   * @param {number} [height] - Height.
+   * @param {object} [options] - Options with `state` and `emptySymbol`.
+   * @returns {this}
+   */
   fillState(x, y, width, height, options) {
     if (typeof x === 'object') {
       options = x;
@@ -319,6 +399,14 @@ export class Panel {
     );
   }
 
+  /** Fills state only for non-empty cells in a region.
+   * @param {number|object} x - Left column, or options if filling the entire panel.
+   * @param {number} [y] - Top row.
+   * @param {number} [width] - Width.
+   * @param {number} [height] - Height.
+   * @param {object} [options] - Options with `state`.
+   * @returns {this}
+   */
   fillNonEmptyState(x, y, width, height, options) {
     if (typeof x === 'object') {
       options = x;
@@ -338,6 +426,14 @@ export class Panel {
     return this.applyFn(x, y, width, height, (x, y, cell) => cell && {symbol: cell.symbol, state}, options);
   }
 
+  /** Combines a state before existing cell states (applied state acts as a base that cells override).
+   * @param {number|object} x - Left column, or options if filling the entire panel.
+   * @param {number} [y] - Top row.
+   * @param {number} [width] - Width.
+   * @param {number} [height] - Height.
+   * @param {object} [options] - Options with `state`, `emptySymbol`, `emptyState`.
+   * @returns {this}
+   */
   combineStateBefore(x, y, width, height, options) {
     if (typeof x === 'object') {
       options = x;
@@ -367,6 +463,14 @@ export class Panel {
     );
   }
 
+  /** Combines a state after existing cell states (applied state overrides cell properties).
+   * @param {number|object} x - Left column, or options if filling the entire panel.
+   * @param {number} [y] - Top row.
+   * @param {number} [width] - Width.
+   * @param {number} [height] - Height.
+   * @param {object} [options] - Options with `state`, `emptySymbol`, `emptyState`.
+   * @returns {this}
+   */
   combineStateAfter(x, y, width, height, options) {
     if (typeof x === 'object') {
       options = x;
@@ -396,6 +500,14 @@ export class Panel {
     );
   }
 
+  /** Clears (nullifies) cells in a rectangular region.
+   * @param {number} [x=0] - Left column.
+   * @param {number} [y=0] - Top row.
+   * @param {number} [width] - Width.
+   * @param {number} [height] - Height.
+   * @param {object} [options] - Options.
+   * @returns {this}
+   */
   clear(x, y, width, height, options) {
     // normalize arguments
     if (typeof x != 'number') {
@@ -416,6 +528,10 @@ export class Panel {
     return this.applyFn(x, y, width, height, () => null, options);
   }
 
+  /** Pads the left side with `n` empty columns.
+   * @param {number} n
+   * @returns {this}
+   */
   padLeft(n) {
     if (n <= 0) return this;
 
@@ -427,6 +543,10 @@ export class Panel {
     return this;
   }
 
+  /** Pads the right side with `n` empty columns.
+   * @param {number} n
+   * @returns {this}
+   */
   padRight(n) {
     if (n <= 0) return this;
 
@@ -438,6 +558,11 @@ export class Panel {
     return this;
   }
 
+  /** Pads left and right sides with empty cells.
+   * @param {number} n - Left columns.
+   * @param {number} m - Right columns.
+   * @returns {this}
+   */
   padLeftRight(n, m) {
     if (n <= 0) return this.padRight(m);
     if (m <= 0) return this.padLeft(n);
@@ -449,6 +574,10 @@ export class Panel {
     return this;
   }
 
+  /** Pads the top with `n` empty rows.
+   * @param {number} n
+   * @returns {this}
+   */
   padTop(n) {
     if (n <= 0) return this;
 
@@ -459,6 +588,10 @@ export class Panel {
     return this;
   }
 
+  /** Pads the bottom with `n` empty rows.
+   * @param {number} n
+   * @returns {this}
+   */
   padBottom(n) {
     if (n <= 0) return this;
 
@@ -469,6 +602,11 @@ export class Panel {
     return this;
   }
 
+  /** Pads top and bottom with empty rows.
+   * @param {number} n - Top rows.
+   * @param {number} m - Bottom rows.
+   * @returns {this}
+   */
   padTopBottom(n, m) {
     if (n <= 0) return this.padBottom(m);
     if (m <= 0) return this.padTop(n);
@@ -484,6 +622,13 @@ export class Panel {
     return this;
   }
 
+  /** Pads the panel using CSS-style shorthand (top, right, bottom, left).
+   * @param {number} t - Top (or all sides if only argument).
+   * @param {number} [r] - Right.
+   * @param {number} [b] - Bottom.
+   * @param {number} [l] - Left.
+   * @returns {this}
+   */
   pad(t, r, b, l) {
     // use values according to CSS rules
     if (typeof r != 'number') {
@@ -498,6 +643,11 @@ export class Panel {
     return this.padLeftRight(l, r).padTopBottom(t, b);
   }
 
+  /** Removes `n` columns starting at column `x`.
+   * @param {number} x - Start column.
+   * @param {number} n - Number of columns to remove.
+   * @returns {this}
+   */
   removeColumns(x, n) {
     // normalize arguments
     if (x < 0) {
@@ -511,6 +661,11 @@ export class Panel {
     return this;
   }
 
+  /** Removes `n` rows starting at row `y`.
+   * @param {number} y - Start row.
+   * @param {number} n - Number of rows to remove.
+   * @returns {this}
+   */
   removeRows(y, n) {
     // normalize arguments
     if (y < 0) {
@@ -524,6 +679,11 @@ export class Panel {
     return this;
   }
 
+  /** Resizes the panel horizontally.
+   * @param {number} newWidth - New width.
+   * @param {'left'|'center'|'right'} [align='right'] - Alignment when adding/removing columns.
+   * @returns {this}
+   */
   resizeH(newWidth, align = 'right') {
     if (!this.width) return this.padRight(newWidth);
 
@@ -536,7 +696,7 @@ export class Panel {
       case 'c': {
         const half = Math.abs(diff) >> 1;
         return diff < 0
-          ? this.removeColumns(0, half).removeColumns(newWidth, half + 1)
+          ? this.removeColumns(0, half).removeColumns(newWidth, -diff - half)
           : this.padLeft(half).padRight(diff - half);
       }
     }
@@ -544,6 +704,11 @@ export class Panel {
     return diff < 0 ? this.removeColumns(newWidth, -diff) : this.padRight(diff);
   }
 
+  /** Resizes the panel vertically.
+   * @param {number} newHeight - New height.
+   * @param {'top'|'center'|'bottom'} [align='bottom'] - Alignment when adding/removing rows.
+   * @returns {this}
+   */
   resizeV(newHeight, align = 'bottom') {
     if (!this.height) return this.padBottom(newHeight);
 
@@ -556,7 +721,7 @@ export class Panel {
       case 'c': {
         const half = Math.abs(diff) >> 1;
         return diff < 0
-          ? this.removeRows(0, half).removeRows(newHeight, half + 1)
+          ? this.removeRows(0, half).removeRows(newHeight, -diff - half)
           : this.padTop(half).padBottom(diff - half);
       }
     }
@@ -564,6 +729,13 @@ export class Panel {
     return diff < 0 ? this.removeRows(newHeight, -diff) : this.padBottom(diff);
   }
 
+  /** Resizes the panel in both dimensions.
+   * @param {number} newWidth - New width.
+   * @param {number} newHeight - New height.
+   * @param {'left'|'center'|'right'} [horizontal='right'] - Horizontal alignment.
+   * @param {'top'|'center'|'bottom'} [vertical='bottom'] - Vertical alignment.
+   * @returns {this}
+   */
   resize(newWidth, newHeight, horizontal = 'right', vertical = 'bottom') {
     if (!this.height) return this.padBottom(newHeight).padRight(newWidth);
 
@@ -572,27 +744,45 @@ export class Panel {
       : this.resizeH(newWidth, horizontal).resizeV(newHeight, vertical);
   }
 
+  /** Inserts `n` empty columns at position `x`.
+   * @param {number} x - Insert position.
+   * @param {number} n - Number of columns.
+   * @returns {this}
+   */
   insertColumns(x, n) {
     // normalize arguments
     if (n <= 0) return this;
     if (x > this.width) x = this.width;
     else if (x < 0) x = 0;
 
-    for (const row of this.box) row.splice(x, 0, ...new Array(n).fill(null));
+    const padding = new Array(n).fill(null);
+    for (const row of this.box) row.splice(x, 0, ...padding);
     return this;
   }
 
+  /** Inserts `n` empty rows at position `y`.
+   * @param {number} y - Insert position.
+   * @param {number} n - Number of rows.
+   * @returns {this}
+   */
   insertRows(y, n) {
     // normalize arguments
     if (n <= 0) return this;
     if (y > this.height) y = this.height;
     else if (y < 0) y = 0;
 
-    this.box.splice(y, 0, ...new Array(n).fill(null));
-    for (let i = 0; i < n; ++i) this.box[y + i] = new Array(this.width).fill(null);
+    const rows = new Array(n);
+    for (let i = 0; i < n; ++i) rows[i] = new Array(this.width).fill(null);
+    this.box.splice(y, 0, ...rows);
     return this;
   }
 
+  /** Appends another panel below this one.
+   * @param {Panel} panel - Panel to append.
+   * @param {object} [options] - Options.
+   * @param {'left'|'center'|'right'} [options.align='left'] - Horizontal alignment.
+   * @returns {this}
+   */
   addBottom(panel, {align = 'left'} = {}) {
     panel = panel.clone();
 
@@ -635,6 +825,12 @@ export class Panel {
     return this;
   }
 
+  /** Appends another panel to the right of this one.
+   * @param {Panel} panel - Panel to append.
+   * @param {object} [options] - Options.
+   * @param {'top'|'center'|'bottom'} [options.align='top'] - Vertical alignment.
+   * @returns {this}
+   */
   addRight(panel, {align = 'top'} = {}) {
     panel = panel.clone();
 
@@ -713,6 +909,9 @@ export class Panel {
     return this;
   }
 
+  /** Returns a new Panel that is the transpose of this one (rows become columns).
+   * @returns {Panel}
+   */
   transpose() {
     const panel = new Panel(this.height, this.width);
     for (let i = 0; i < this.height; ++i) {
@@ -725,6 +924,9 @@ export class Panel {
     return panel;
   }
 
+  /** Returns a new Panel rotated 90° clockwise.
+   * @returns {Panel}
+   */
   rotateRight() {
     const panel = new Panel(this.height, this.width);
     for (let i = 0; i < this.height; ++i) {
@@ -737,6 +939,9 @@ export class Panel {
     return panel;
   }
 
+  /** Returns a new Panel rotated 90° counter-clockwise.
+   * @returns {Panel}
+   */
   rotateLeft() {
     const panel = new Panel(this.height, this.width);
     for (let i = 0; i < this.height; ++i) {
@@ -749,11 +954,17 @@ export class Panel {
     return panel;
   }
 
+  /** Flips the panel horizontally (mirrors left-right) in place.
+   * @returns {this}
+   */
   flipH() {
     for (const row of this.box) row.reverse();
     return this;
   }
 
+  /** Flips the panel vertically (mirrors top-bottom) in place.
+   * @returns {this}
+   */
   flipV() {
     this.box.reverse();
     return this;
@@ -762,6 +973,9 @@ export class Panel {
 
 addAliases(Panel, {combineState: 'combineStateAfter', toPanel: 'clone'});
 
+/** Alias for `Panel.make()`. Creates a Panel from various input types.
+ * @type {typeof Panel.make}
+ */
 export const toPanel = Panel.make;
 
 export default Panel;

package/src/plot/bitmap.d.ts

@@ -0,0 +1,80 @@
+import Box from '../box.js';
+
+/** A bitmap for drawing pixels, stored as a compact bit-packed array.
+ * @see {@link https://github.com/uhop/console-toolkit/wiki/Module:-plot}
+ */
+export class Bitmap {
+  /** Width in pixels. */
+  width: number;
+  /** Height in pixels. */
+  height: number;
+  /** Width of each internal block (default: 5). */
+  blockWidth: number;
+  /** Height of each internal block (default: 5). */
+  blockHeight: number;
+  /** Number of words per line. */
+  lineSize: number;
+  /** Number of lines. */
+  lineCount: number;
+  /** The underlying bit-packed array. */
+  bitmap: number[];
+
+  /**
+   * @param width - Width in pixels.
+   * @param height - Height in pixels.
+   * @param blockWidth - Width of each internal block (default: 5).
+   * @param blockHeight - Height of each internal block (default: 5).
+   */
+  constructor(width: number, height: number, blockWidth?: number, blockHeight?: number);
+
+  /** Verifies that (x, y) is within bounds.
+   * @param x - X coordinate.
+   * @param y - Y coordinate.
+   * @returns This Bitmap.
+   * @throws If out of bounds.
+   */
+  verifyPos(x: number, y: number): this;
+  /** Returns the word index for the given position.
+   * @param x - X coordinate.
+   * @param y - Y coordinate.
+   * @returns The word index.
+   */
+  getWordIndex(x: number, y: number): number;
+  /** Returns the bit mask for the given position.
+   * @param x - X coordinate.
+   * @param y - Y coordinate.
+   * @returns The bit mask.
+   */
+  getWordMask(x: number, y: number): number;
+
+  /** Gets the bit value at (x, y).
+   * @param x - X coordinate.
+   * @param y - Y coordinate.
+   * @returns Non-zero if the bit is set, 0 otherwise.
+   */
+  getBit(x: number, y: number): number;
+  /** Sets the bit value at (x, y).
+   * @param x - X coordinate.
+   * @param y - Y coordinate.
+   * @param value - Bit value (default: 1).
+   * @returns This Bitmap.
+   */
+  setBit(x: number, y: number, value?: number): this;
+  /** Alias for `setBit`. */
+  set: Bitmap['setBit'];
+
+  /** Clears the bitmap.
+   * @param value - If true, set all bits; if false, clear all (default: false).
+   * @returns This Bitmap.
+   */
+  clear(value?: boolean): this;
+
+  /** Converts the bitmap to a Box using the given characters.
+   * @param one - Character for set bits (default: full block).
+   * @param zero - Character for clear bits (default: space).
+   * @returns A Box representation.
+   */
+  toBox(one?: string, zero?: string): Box;
+}
+
+export default Bitmap;

package/src/plot/bitmap.js

@@ -2,20 +2,29 @@ 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);
     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}"`);
+    if (isNaN(height) || height <= 0) throw new Error(`Height should be a positive integer instead of "${height}"`);
     blockWidth = Math.round(blockWidth);
-    if (isNaN(width) || blockWidth <= 0)
+    if (isNaN(blockWidth) || blockWidth <= 0)
       throw new Error(`Block width should be a positive integer instead of "${blockWidth}"`);
     blockHeight = Math.round(blockHeight);
-    if (isNaN(width) || blockHeight <= 0)
+    if (isNaN(blockHeight) || blockHeight <= 0)
       throw new Error(`Block height should be a positive integer instead of "${blockHeight}"`);
-    if (isNaN(width) || blockWidth * blockHeight > 32)
+    if (blockWidth * blockHeight > 32)
       throw new Error("Multiplication of 'blockWidth' and 'blockHeight' should be equal or less than 32");
 
     this.width = width;
@@ -49,6 +58,11 @@ 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),
@@ -56,6 +70,12 @@ 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),
@@ -65,6 +85,10 @@ 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;
@@ -81,6 +105,11 @@ 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 = [];
     for (let k = 0, kBase = 0; k < this.lineCount; ++k, kBase += this.blockHeight) {

package/src/plot/draw-line.d.ts

@@ -0,0 +1,13 @@
+import {Bitmap} from './bitmap.js';
+
+/** Draws a line on a Bitmap using Bresenham's algorithm.
+ * @param bmp - The target bitmap.
+ * @param x0 - Start X.
+ * @param y0 - Start Y.
+ * @param x1 - End X.
+ * @param y1 - End Y.
+ * @param value - Bit value to set (default: 1).
+ */
+export function drawLine(bmp: Bitmap, x0: number, y0: number, x1: number, y1: number, value?: number): void;
+
+export default drawLine;

package/src/plot/draw-line.js

@@ -1,6 +1,14 @@
 // 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.d.ts

@@ -0,0 +1,13 @@
+import {Bitmap} from './bitmap.js';
+
+/** Draws a filled rectangle on a Bitmap.
+ * @param bmp - The target bitmap.
+ * @param x0 - First corner x coordinate.
+ * @param y0 - First corner y coordinate.
+ * @param x1 - Opposite corner x coordinate.
+ * @param y1 - Opposite corner y coordinate.
+ * @param value - Bit value to set (default: 1).
+ */
+export function drawRect(bmp: Bitmap, x0: number, y0: number, x1: number, y1: number, value?: number): void;
+
+export default drawRect;