blecsd 0.3.0 → 0.6.0

package/dist/textWrap-Ct2J8gO6.d.ts

@@ -0,0 +1,761 @@
+import { o as BorderCharset } from './border-Br-Jc027.js';
+
+/**
+ * Box rendering utilities for drawing borders and boxes.
+ * @module utils/box
+ */
+
+/**
+ * Box drawing characters as strings (for convenience).
+ */
+interface BoxChars {
+    readonly topLeft: string;
+    readonly topRight: string;
+    readonly bottomLeft: string;
+    readonly bottomRight: string;
+    readonly horizontal: string;
+    readonly vertical: string;
+}
+/**
+ * Converts a BorderCharset (code points) to BoxChars (strings).
+ *
+ * @param charset - Border character set with code points
+ * @returns Box characters as strings
+ *
+ * @example
+ * ```typescript
+ * import { BORDER_ROUNDED, charsetToBoxChars } from 'blecsd';
+ *
+ * const chars = charsetToBoxChars(BORDER_ROUNDED);
+ * console.log(chars.topLeft); // "╭"
+ * ```
+ */
+declare function charsetToBoxChars(charset: BorderCharset): BoxChars;
+/**
+ * Preset box styles as string characters.
+ */
+declare const BOX_SINGLE: BoxChars;
+declare const BOX_DOUBLE: BoxChars;
+declare const BOX_ROUNDED: BoxChars;
+declare const BOX_BOLD: BoxChars;
+/**
+ * ASCII box characters (works in all terminals).
+ */
+declare const BOX_ASCII: BoxChars;
+/**
+ * Dashed box characters.
+ */
+declare const BOX_DASHED: BoxChars;
+/**
+ * Interface for a renderable cell buffer.
+ * Any object implementing this interface can be used with renderBox.
+ */
+interface CellBuffer {
+    /** Width of the buffer in cells */
+    readonly width: number;
+    /** Height of the buffer in cells */
+    readonly height: number;
+    /**
+     * Set a cell's character and colors.
+     * @param x - Column (0-indexed)
+     * @param y - Row (0-indexed)
+     * @param char - Character to display
+     * @param fg - Foreground color (optional)
+     * @param bg - Background color (optional)
+     */
+    setCell(x: number, y: number, char: string, fg?: number, bg?: number): void;
+}
+/**
+ * Simple in-memory cell buffer for testing and rendering.
+ */
+interface Cell {
+    char: string;
+    fg: number;
+    bg: number;
+}
+/**
+ * Creates a simple cell buffer.
+ *
+ * @param width - Buffer width in cells
+ * @param height - Buffer height in cells
+ * @param defaultFg - Default foreground color (default: 0xffffffff white)
+ * @param defaultBg - Default background color (default: 0x00000000 transparent)
+ * @returns A CellBuffer instance
+ *
+ * @example
+ * ```typescript
+ * import { createCellBuffer, renderBox, BOX_SINGLE } from 'blecsd';
+ *
+ * const buffer = createCellBuffer(80, 24);
+ * renderBox(buffer, 5, 2, 20, 10, BOX_SINGLE);
+ * ```
+ */
+declare function createCellBuffer(width: number, height: number, defaultFg?: number, defaultBg?: number): CellBuffer & {
+    cells: Cell[][];
+};
+/**
+ * Options for rendering a box.
+ */
+interface RenderBoxOptions {
+    /** Foreground color for the border (optional) */
+    fg?: number;
+    /** Background color for the border (optional) */
+    bg?: number;
+    /** Fill the interior with background color (default: false) */
+    fill?: boolean;
+    /** Fill character for interior (default: ' ') */
+    fillChar?: string;
+}
+/**
+ * Renders a box to a cell buffer.
+ *
+ * Draws border characters around the specified rectangle.
+ * Minimum size is 1x1 (just corners).
+ *
+ * @param buffer - The cell buffer to render to
+ * @param x - Left column (0-indexed)
+ * @param y - Top row (0-indexed)
+ * @param width - Box width (including borders)
+ * @param height - Box height (including borders)
+ * @param chars - Box characters to use
+ * @param options - Rendering options
+ *
+ * @example
+ * ```typescript
+ * import { createCellBuffer, renderBox, BOX_ROUNDED } from 'blecsd';
+ *
+ * const buffer = createCellBuffer(80, 24);
+ *
+ * // Draw a simple box
+ * renderBox(buffer, 5, 2, 20, 10, BOX_ROUNDED);
+ *
+ * // Draw with colors
+ * renderBox(buffer, 30, 2, 20, 10, BOX_DOUBLE, {
+ *   fg: 0x00ff00ff, // Green
+ *   fill: true
+ * });
+ * ```
+ */
+declare function renderBox(buffer: CellBuffer, x: number, y: number, width: number, height: number, chars: BoxChars, options?: RenderBoxOptions): void;
+/**
+ * Renders a horizontal line to a cell buffer.
+ *
+ * @param buffer - The cell buffer to render to
+ * @param x - Starting column (0-indexed)
+ * @param y - Row (0-indexed)
+ * @param length - Line length
+ * @param char - Character to use (default: horizontal box char)
+ * @param fg - Foreground color (optional)
+ * @param bg - Background color (optional)
+ *
+ * @example
+ * ```typescript
+ * import { createCellBuffer, renderHLine, BOX_SINGLE } from 'blecsd';
+ *
+ * const buffer = createCellBuffer(80, 24);
+ * renderHLine(buffer, 5, 10, 20, BOX_SINGLE.horizontal);
+ * ```
+ */
+declare function renderHLine(buffer: CellBuffer, x: number, y: number, length: number, char?: string, fg?: number, bg?: number): void;
+/**
+ * Renders a vertical line to a cell buffer.
+ *
+ * @param buffer - The cell buffer to render to
+ * @param x - Column (0-indexed)
+ * @param y - Starting row (0-indexed)
+ * @param length - Line length
+ * @param char - Character to use (default: vertical box char)
+ * @param fg - Foreground color (optional)
+ * @param bg - Background color (optional)
+ *
+ * @example
+ * ```typescript
+ * import { createCellBuffer, renderVLine, BOX_SINGLE } from 'blecsd';
+ *
+ * const buffer = createCellBuffer(80, 24);
+ * renderVLine(buffer, 10, 5, 10, BOX_SINGLE.vertical);
+ * ```
+ */
+declare function renderVLine(buffer: CellBuffer, x: number, y: number, length: number, char?: string, fg?: number, bg?: number): void;
+/**
+ * Fills a rectangular region with a character.
+ *
+ * @param buffer - The cell buffer to render to
+ * @param x - Left column (0-indexed)
+ * @param y - Top row (0-indexed)
+ * @param width - Region width
+ * @param height - Region height
+ * @param char - Fill character (default: ' ')
+ * @param fg - Foreground color (optional)
+ * @param bg - Background color (optional)
+ *
+ * @example
+ * ```typescript
+ * import { createCellBuffer, fillRect } from 'blecsd';
+ *
+ * const buffer = createCellBuffer(80, 24);
+ * boxFillRect(buffer, 5, 2, 20, 10, ' ', 0xffffffff, 0x0000aaff);
+ * ```
+ */
+declare function boxFillRect(buffer: CellBuffer, x: number, y: number, width: number, height: number, char?: string, fg?: number, bg?: number): void;
+/**
+ * Renders text to a cell buffer.
+ *
+ * @param buffer - The cell buffer to render to
+ * @param x - Starting column (0-indexed)
+ * @param y - Row (0-indexed)
+ * @param text - Text to render
+ * @param fg - Foreground color (optional)
+ * @param bg - Background color (optional)
+ *
+ * @example
+ * ```typescript
+ * import { createCellBuffer, renderText } from 'blecsd';
+ *
+ * const buffer = createCellBuffer(80, 24);
+ * renderText(buffer, 10, 5, 'Hello, World!');
+ * ```
+ */
+declare function renderText(buffer: CellBuffer, x: number, y: number, text: string, fg?: number, bg?: number): void;
+/**
+ * Converts a cell buffer to a string representation.
+ * Useful for testing and debugging.
+ *
+ * @param buffer - The cell buffer with cells property
+ * @returns String representation of the buffer
+ *
+ * @example
+ * ```typescript
+ * import { createCellBuffer, renderBox, BOX_SINGLE, bufferToString } from 'blecsd';
+ *
+ * const buffer = createCellBuffer(10, 5);
+ * renderBox(buffer, 0, 0, 10, 5, BOX_SINGLE);
+ * console.log(bufferToString(buffer));
+ * // Output:
+ * // ┌────────┐
+ * // │        │
+ * // │        │
+ * // │        │
+ * // └────────┘
+ * ```
+ */
+declare function bufferToString(buffer: CellBuffer & {
+    cells: Cell[][];
+}): string;
+
+/**
+ * Rope Data Structure for Large Text Buffers
+ *
+ * A rope is a binary tree where leaf nodes contain text strings and internal
+ * nodes contain the total length of text in their left subtree. This allows
+ * for O(log n) insert, delete, and index operations.
+ *
+ * @module utils/rope
+ *
+ * @example
+ * ```typescript
+ * import { createRope, insert, deleteRange, getLine, getText } from 'blecsd';
+ *
+ * // Create a rope from text
+ * let rope = createRope('Hello, World!');
+ *
+ * // Insert at position
+ * rope = insert(rope, 7, 'Beautiful ');
+ * // Result: "Hello, Beautiful World!"
+ *
+ * // Delete a range
+ * rope = deleteRange(rope, 0, 7);
+ * // Result: "Beautiful World!"
+ *
+ * // Get specific line
+ * const line = getLine(rope, 0);
+ * ```
+ */
+/**
+ * Maximum characters in a leaf node.
+ * Smaller values give better balance but more nodes.
+ * Larger values reduce overhead but slower operations.
+ */
+declare const LEAF_MAX_SIZE = 512;
+/**
+ * Minimum characters in a leaf node before merging.
+ */
+declare const LEAF_MIN_SIZE = 256;
+/**
+ * Maximum depth before forcing rebalance.
+ */
+declare const MAX_DEPTH = 48;
+/**
+ * A leaf node containing actual text content.
+ */
+interface RopeLeaf {
+    readonly type: 'leaf';
+    /** The text content of this leaf */
+    readonly text: string;
+    /** Total number of characters */
+    readonly length: number;
+    /** Number of newlines in this leaf */
+    readonly newlines: number;
+    /** Line break positions within this leaf (relative to start) */
+    readonly lineBreaks: readonly number[];
+}
+/**
+ * An internal node containing two subtrees.
+ */
+interface RopeNode {
+    readonly type: 'node';
+    /** Left subtree */
+    readonly left: Rope;
+    /** Right subtree */
+    readonly right: Rope;
+    /** Total length of left subtree (weight) */
+    readonly leftLength: number;
+    /** Total length of entire subtree */
+    readonly length: number;
+    /** Total newlines in entire subtree */
+    readonly newlines: number;
+    /** Depth of tree from this node */
+    readonly depth: number;
+}
+/**
+ * A rope is either a leaf or an internal node.
+ */
+type Rope = RopeLeaf | RopeNode;
+/**
+ * Line information returned by getLine.
+ */
+interface LineInfo {
+    /** Line content (without newline) */
+    readonly text: string;
+    /** Start index in rope */
+    readonly start: number;
+    /** End index in rope (exclusive) */
+    readonly end: number;
+    /** Line number (0-based) */
+    readonly lineNumber: number;
+}
+/**
+ * Statistics about a rope.
+ */
+interface RopeStats {
+    /** Total characters */
+    readonly length: number;
+    /** Total newlines */
+    readonly newlines: number;
+    /** Number of leaf nodes */
+    readonly leafCount: number;
+    /** Maximum depth */
+    readonly depth: number;
+    /** Average leaf size */
+    readonly avgLeafSize: number;
+}
+/**
+ * Creates a rope from a string.
+ *
+ * @param text - Initial text content
+ * @returns A new Rope
+ *
+ * @example
+ * ```typescript
+ * import { createRope } from 'blecsd';
+ *
+ * const rope = createRope('Hello, World!');
+ * ```
+ */
+declare function createRope(text?: string): Rope;
+/**
+ * Creates an empty rope.
+ *
+ * @returns An empty Rope
+ */
+declare function createEmptyRope(): Rope;
+/**
+ * Gets the total length of the rope.
+ *
+ * @param rope - The rope to measure
+ * @returns Total character count
+ *
+ * @example
+ * ```typescript
+ * import { createRope, getLength } from 'blecsd';
+ *
+ * const rope = createRope('Hello');
+ * console.log(getLength(rope)); // 5
+ * ```
+ */
+declare function getLength(rope: Rope): number;
+/**
+ * Gets the total number of newlines in the rope.
+ *
+ * @param rope - The rope to measure
+ * @returns Total newline count
+ */
+declare function getNewlineCount(rope: Rope): number;
+/**
+ * Gets the total number of lines (newlines + 1).
+ *
+ * @param rope - The rope to measure
+ * @returns Line count
+ */
+declare function getLineCount(rope: Rope): number;
+/**
+ * Checks if the rope is empty.
+ *
+ * @param rope - The rope to check
+ * @returns true if empty
+ */
+declare function isEmpty(rope: Rope): boolean;
+/**
+ * Gets the character at a specific index.
+ *
+ * @param rope - The rope to query
+ * @param index - Character index (0-based)
+ * @returns Character at index, or undefined if out of bounds
+ *
+ * @example
+ * ```typescript
+ * import { createRope, charAt } from 'blecsd';
+ *
+ * const rope = createRope('Hello');
+ * console.log(charAt(rope, 0)); // 'H'
+ * ```
+ */
+declare function charAt(rope: Rope, index: number): string | undefined;
+/**
+ * Gets a substring from the rope.
+ *
+ * @param rope - The rope to query
+ * @param start - Start index (inclusive)
+ * @param end - End index (exclusive), defaults to end of rope
+ * @returns Substring
+ *
+ * @example
+ * ```typescript
+ * import { createRope, substring } from 'blecsd';
+ *
+ * const rope = createRope('Hello, World!');
+ * console.log(substring(rope, 0, 5)); // 'Hello'
+ * ```
+ */
+declare function substring(rope: Rope, start: number, end?: number): string;
+/**
+ * Converts entire rope to string.
+ *
+ * @param rope - The rope to convert
+ * @returns Full text content
+ *
+ * @example
+ * ```typescript
+ * import { createRope, getText } from 'blecsd';
+ *
+ * const rope = createRope('Hello');
+ * console.log(getText(rope)); // 'Hello'
+ * ```
+ */
+declare function getText(rope: Rope): string;
+/**
+ * Gets the line index for a character position.
+ *
+ * @param rope - The rope to query
+ * @param index - Character index
+ * @returns Line number (0-based)
+ *
+ * @example
+ * ```typescript
+ * import { createRope, getLineForIndex } from 'blecsd';
+ *
+ * const rope = createRope('Line 1\nLine 2\nLine 3');
+ * console.log(getLineForIndex(rope, 7)); // 1 (start of 'Line 2')
+ * ```
+ */
+declare function getLineForIndex(rope: Rope, index: number): number;
+/**
+ * Gets the start index of a line.
+ *
+ * @param rope - The rope to query
+ * @param lineNumber - Line number (0-based)
+ * @returns Start index of line, or -1 if out of bounds
+ */
+declare function getLineStart(rope: Rope, lineNumber: number): number;
+/**
+ * Gets the end index of a line (position of newline or end of rope).
+ *
+ * @param rope - The rope to query
+ * @param lineNumber - Line number (0-based)
+ * @returns End index of line, or -1 if out of bounds
+ */
+declare function getLineEnd(rope: Rope, lineNumber: number): number;
+/**
+ * Gets a specific line's content.
+ *
+ * @param rope - The rope to query
+ * @param lineNumber - Line number (0-based)
+ * @returns Line info or undefined if out of bounds
+ *
+ * @example
+ * ```typescript
+ * import { createRope, getLine } from 'blecsd';
+ *
+ * const rope = createRope('Line 1\nLine 2\nLine 3');
+ * const line = getLine(rope, 1);
+ * console.log(line?.text); // 'Line 2'
+ * ```
+ */
+declare function getLine(rope: Rope, lineNumber: number): LineInfo | undefined;
+/**
+ * Gets a range of lines.
+ *
+ * @param rope - The rope to query
+ * @param startLine - Start line (inclusive)
+ * @param endLine - End line (exclusive)
+ * @returns Array of line info
+ *
+ * @example
+ * ```typescript
+ * import { createRope, getLines } from 'blecsd';
+ *
+ * const rope = createRope('Line 1\nLine 2\nLine 3');
+ * const lines = getLines(rope, 0, 2);
+ * // lines = [{ text: 'Line 1', ... }, { text: 'Line 2', ... }]
+ * ```
+ */
+declare function getLines(rope: Rope, startLine: number, endLine: number): LineInfo[];
+/**
+ * Inserts text at a position.
+ *
+ * @param rope - The rope to modify
+ * @param index - Position to insert at
+ * @param text - Text to insert
+ * @returns New rope with text inserted
+ *
+ * @example
+ * ```typescript
+ * import { createRope, insert } from 'blecsd';
+ *
+ * let rope = createRope('Hello World');
+ * rope = insert(rope, 6, 'Beautiful ');
+ * // Result: 'Hello Beautiful World'
+ * ```
+ */
+declare function insert(rope: Rope, index: number, text: string): Rope;
+/**
+ * Appends text to the end.
+ *
+ * @param rope - The rope to modify
+ * @param text - Text to append
+ * @returns New rope with text appended
+ *
+ * @example
+ * ```typescript
+ * import { createRope, append } from 'blecsd';
+ *
+ * let rope = createRope('Hello');
+ * rope = append(rope, ' World');
+ * // Result: 'Hello World'
+ * ```
+ */
+declare function append(rope: Rope, text: string): Rope;
+/**
+ * Prepends text to the start.
+ *
+ * @param rope - The rope to modify
+ * @param text - Text to prepend
+ * @returns New rope with text prepended
+ */
+declare function prepend(rope: Rope, text: string): Rope;
+/**
+ * Deletes a range of text.
+ *
+ * @param rope - The rope to modify
+ * @param start - Start index (inclusive)
+ * @param end - End index (exclusive)
+ * @returns New rope with range deleted
+ *
+ * @example
+ * ```typescript
+ * import { createRope, deleteRange } from 'blecsd';
+ *
+ * let rope = createRope('Hello Beautiful World');
+ * rope = deleteRange(rope, 6, 16);
+ * // Result: 'Hello World'
+ * ```
+ */
+declare function deleteRange(rope: Rope, start: number, end: number): Rope;
+/**
+ * Replaces a range of text.
+ *
+ * @param rope - The rope to modify
+ * @param start - Start index (inclusive)
+ * @param end - End index (exclusive)
+ * @param text - Replacement text
+ * @returns New rope with range replaced
+ *
+ * @example
+ * ```typescript
+ * import { createRope, replaceRange } from 'blecsd';
+ *
+ * let rope = createRope('Hello World');
+ * rope = replaceRange(rope, 6, 11, 'Universe');
+ * // Result: 'Hello Universe'
+ * ```
+ */
+declare function replaceRange(rope: Rope, start: number, end: number, text: string): Rope;
+/**
+ * Gets statistics about the rope structure.
+ *
+ * @param rope - The rope to analyze
+ * @returns Rope statistics
+ */
+declare function getStats(rope: Rope): RopeStats;
+/**
+ * Verifies rope integrity (for testing/debugging).
+ *
+ * @param rope - The rope to verify
+ * @returns true if valid
+ */
+declare function verify(rope: Rope): boolean;
+
+/**
+ * Text wrapping utilities with Unicode and ANSI support.
+ * @module utils/textWrap
+ */
+
+/**
+ * Text alignment options.
+ */
+type TextAlign = 'left' | 'center' | 'right';
+/**
+ * Options for text wrapping.
+ */
+interface WrapOptions {
+    /** Maximum width in characters */
+    width: number;
+    /** Whether to wrap text (default: true) */
+    wrap?: boolean;
+    /** Text alignment (default: 'left') */
+    align?: TextAlign;
+    /** Break mid-word if word exceeds width (default: false) */
+    breakWord?: boolean;
+}
+/**
+ * Removes ANSI escape sequences from a string.
+ *
+ * @param text - Text with possible ANSI codes
+ * @returns Text without ANSI codes
+ *
+ * @example
+ * ```typescript
+ * import { stripAnsi } from 'blecsd';
+ *
+ * const plain = stripAnsi('\x1b[31mRed\x1b[0m');
+ * console.log(plain); // "Red"
+ * ```
+ */
+declare function stripAnsi(text: string): string;
+/**
+ * Gets the visible width of a string (excluding ANSI codes).
+ * Currently handles ASCII only. East Asian width support to be added.
+ *
+ * @param text - Text to measure
+ * @returns Visible character width
+ *
+ * @example
+ * ```typescript
+ * import { getVisibleWidth } from 'blecsd';
+ *
+ * console.log(getVisibleWidth('Hello')); // 5
+ * console.log(getVisibleWidth('\x1b[31mHello\x1b[0m')); // 5 (ANSI codes not counted)
+ * ```
+ */
+declare function getVisibleWidth(text: string): number;
+/**
+ * Truncates a string to fit within a specified width,
+ * preserving ANSI codes and adding ellipsis if truncated.
+ *
+ * @param text - Text to truncate
+ * @param width - Maximum width
+ * @param ellipsis - Ellipsis string (default: '…')
+ * @returns Truncated text
+ *
+ * @example
+ * ```typescript
+ * import { truncate } from 'blecsd';
+ *
+ * console.log(truncate('Hello World', 8)); // "Hello W…"
+ * ```
+ */
+declare function truncate(text: string, width: number, ellipsis?: string): string;
+/**
+ * Aligns a line of text within a specified width.
+ *
+ * @param line - Line to align
+ * @param width - Target width
+ * @param align - Alignment type
+ * @returns Aligned line (padded with spaces)
+ *
+ * @example
+ * ```typescript
+ * import { alignLine } from 'blecsd';
+ *
+ * console.log(alignLine('Hello', 10, 'left'));   // "Hello     "
+ * console.log(alignLine('Hello', 10, 'center')); // "  Hello   "
+ * console.log(alignLine('Hello', 10, 'right'));  // "     Hello"
+ * ```
+ */
+declare function alignLine(line: string, width: number, align: TextAlign): string;
+/**
+ * Wraps text to fit within a specified width, breaking at word boundaries.
+ *
+ * @param text - Text to wrap
+ * @param width - Maximum width per line
+ * @returns Array of wrapped lines
+ *
+ * @example
+ * ```typescript
+ * import { wordWrap } from 'blecsd';
+ *
+ * const lines = wordWrap('The quick brown fox jumps over the lazy dog', 20);
+ * // ["The quick brown fox", "jumps over the lazy", "dog"]
+ * ```
+ */
+declare function wordWrap(text: string, width: number): string[];
+/**
+ * Wraps and aligns text with full options.
+ *
+ * @param text - Text to wrap
+ * @param options - Wrapping options
+ * @returns Array of wrapped and aligned lines
+ *
+ * @example
+ * ```typescript
+ * import { wrapText } from 'blecsd';
+ *
+ * const lines = wrapText('Hello world, this is a test', {
+ *   width: 15,
+ *   wrap: true,
+ *   align: 'center'
+ * });
+ * // ["  Hello world  ", " this is a test"]
+ * ```
+ */
+declare function wrapText(text: string, options: WrapOptions): string[];
+/**
+ * Pads text to a specific height by adding empty lines.
+ *
+ * @param lines - Array of lines
+ * @param height - Target height
+ * @param width - Line width for padding
+ * @param valign - Vertical alignment ('top' | 'middle' | 'bottom')
+ * @returns Array of lines padded to height
+ *
+ * @example
+ * ```typescript
+ * import { padHeight } from 'blecsd';
+ *
+ * const lines = padHeight(['Hello'], 3, 10, 'middle');
+ * // ["          ", "Hello     ", "          "]
+ * ```
+ */
+declare function padHeight(lines: string[], height: number, width: number, valign?: 'top' | 'middle' | 'bottom'): string[];
+
+export { type RopeStats as $, getLineForIndex as A, type BoxChars as B, getNewlineCount as C, isEmpty as D, verify as E, wordWrap as F, truncate as G, alignLine as H, getVisibleWidth as I, stripAnsi as J, padHeight as K, BOX_ASCII as L, BOX_BOLD as M, BOX_DASHED as N, BOX_DOUBLE as O, BOX_ROUNDED as P, BOX_SINGLE as Q, type Cell as R, type CellBuffer as S, LEAF_MAX_SIZE as T, LEAF_MIN_SIZE as U, type LineInfo as V, MAX_DEPTH as W, type RenderBoxOptions as X, type Rope as Y, type RopeLeaf as Z, type RopeNode as _, getLines as a, type TextAlign as a0, type WrapOptions as a1, getStats as b, renderBox as c, renderHLine as d, renderVLine as e, createCellBuffer as f, getLine as g, bufferToString as h, boxFillRect as i, charsetToBoxChars as j, createRope as k, createEmptyRope as l, insert as m, deleteRange as n, replaceRange as o, getText as p, getLineCount as q, renderText as r, append as s, prepend as t, charAt as u, substring as v, wrapText as w, getLength as x, getLineStart as y, getLineEnd as z };