tinky 1.4.4 → 1.6.0

package/lib/core/cell-log-update-run.js

@@ -0,0 +1,518 @@
+import ansiEscapes from "../utils/ansi-escapes.js";
+import * as cliCursor from "../utils/cli-cursor.js";
+const cursorToColumn = (x) => ansiEscapes.cursorTo(x);
+const cursorForward = (count) => ansiEscapes.cursorForward(count);
+/**
+ * Compares two cells at an absolute row/column, including style and width.
+ */
+const cellsEqualAt = (prevBuffer, nextBuffer, row, x) => {
+    const idx = row * nextBuffer.width + x;
+    return (prevBuffer.styleIds[idx] === nextBuffer.styleIds[idx] &&
+        prevBuffer.widths[idx] === nextBuffer.widths[idx] &&
+        prevBuffer.chars[idx] === nextBuffer.chars[idx]);
+};
+/**
+ * Rewinds to the first cell of a glyph when `x` lands in a continuation cell.
+ */
+const findGlyphStart = (buffer, row, x) => {
+    if (x <= 0) {
+        return 0;
+    }
+    const rowOffset = row * buffer.width;
+    let currentX = x;
+    while (currentX > 0 && buffer.widths[rowOffset + currentX] === 0) {
+        currentX--;
+    }
+    return currentX;
+};
+/**
+ * Extends an end position so we never split a wide character.
+ */
+const alignEndToGlyphBoundary = (buffer, row, end) => {
+    const width = buffer.width;
+    let safeEnd = Math.max(0, Math.min(width, end));
+    if (safeEnd <= 0 || safeEnd >= width) {
+        return safeEnd <= 0 ? 0 : width;
+    }
+    const rowOffset = row * width;
+    let x = safeEnd - 1;
+    while (x > 0 && buffer.widths[rowOffset + x] === 0) {
+        x--;
+    }
+    const cellWidth = buffer.widths[rowOffset + x] || 1;
+    const glyphEnd = x + cellWidth;
+    if (glyphEnd > safeEnd) {
+        safeEnd = Math.min(width, glyphEnd);
+    }
+    return safeEnd;
+};
+/**
+ * Finds changed cell runs for one row and normalizes them to glyph boundaries.
+ */
+const computeSegments = (prevBuffer, nextBuffer, row, scanEnd) => {
+    const width = nextBuffer.width;
+    const end = Math.max(0, Math.min(width, scanEnd));
+    const segments = [];
+    let inSegment = false;
+    let segmentStart = 0;
+    for (let x = 0; x < end; x++) {
+        const isDiff = !cellsEqualAt(prevBuffer, nextBuffer, row, x);
+        if (isDiff && !inSegment) {
+            inSegment = true;
+            segmentStart = x;
+        }
+        else if (!isDiff && inSegment) {
+            segments.push({ start: segmentStart, end: x });
+            inSegment = false;
+        }
+    }
+    if (inSegment) {
+        segments.push({ start: segmentStart, end });
+    }
+    for (const segment of segments) {
+        segment.start = findGlyphStart(nextBuffer, row, segment.start);
+        segment.end = alignEndToGlyphBoundary(nextBuffer, row, segment.end);
+    }
+    segments.sort((a, b) => a.start - b.start);
+    const merged = [];
+    for (const segment of segments) {
+        if (merged.length === 0) {
+            merged.push({ ...segment });
+            continue;
+        }
+        const last = merged.at(-1);
+        if (!last) {
+            continue;
+        }
+        if (segment.start <= last.end) {
+            last.end = Math.max(last.end, segment.end);
+        }
+        else {
+            merged.push({ ...segment });
+        }
+    }
+    return merged;
+};
+/**
+ * Merges nearby segments using a fixed gap threshold.
+ */
+const mergeByGapThreshold = (segments, mergeThreshold) => {
+    if (segments.length <= 1) {
+        return segments;
+    }
+    const merged = [];
+    for (const segment of segments) {
+        if (merged.length === 0) {
+            merged.push({ ...segment });
+            continue;
+        }
+        const last = merged.at(-1);
+        if (!last) {
+            continue;
+        }
+        const gap = segment.start - last.end;
+        if (gap <= mergeThreshold) {
+            last.end = Math.max(last.end, segment.end);
+        }
+        else {
+            merged.push({ ...segment });
+        }
+    }
+    return merged;
+};
+const asciiByteLength = (value) => value.length;
+const utf8ByteLength = (value) => {
+    let bytes = 0;
+    for (const char of value) {
+        const codePoint = char.codePointAt(0) ?? 0;
+        if (codePoint <= 0x7f) {
+            bytes += 1;
+        }
+        else if (codePoint <= 0x7ff) {
+            bytes += 2;
+        }
+        else if (codePoint <= 0xffff) {
+            bytes += 3;
+        }
+        else {
+            bytes += 4;
+        }
+    }
+    return bytes;
+};
+const digits10 = (input) => {
+    let value = input;
+    let digits = 1;
+    while (value >= 10) {
+        value = Math.floor(value / 10);
+        digits++;
+    }
+    return digits;
+};
+const bytesCursorForward = (delta) => {
+    if (delta <= 0) {
+        return 0;
+    }
+    return 3 + digits10(delta);
+};
+const bytesCursorToColumn = (column0) => {
+    const column = Math.max(0, column0) + 1;
+    return 3 + digits10(column);
+};
+/**
+ * Chooses between relative forward movement and absolute column movement based
+ * on encoded byte cost.
+ */
+const chooseHorizontalMove = (fromX, toX) => {
+    if (toX <= fromX) {
+        return { bytes: bytesCursorToColumn(toX), method: "abs" };
+    }
+    const delta = toX - fromX;
+    const forwardBytes = bytesCursorForward(delta);
+    const absoluteBytes = bytesCursorToColumn(toX);
+    if (forwardBytes <= absoluteBytes) {
+        return { bytes: forwardBytes, method: "forward" };
+    }
+    return { bytes: absoluteBytes, method: "abs" };
+};
+const getStyleLens = (buffer, styleLenCache, styleId) => {
+    const cached = styleLenCache.get(styleId);
+    if (cached) {
+        return cached;
+    }
+    const styles = buffer.styleRegistry.getStyles(styleId);
+    let open = 0;
+    let close = 0;
+    for (const style of styles) {
+        open += asciiByteLength(style.code);
+        close += asciiByteLength(style.endCode);
+    }
+    const lens = { open, close };
+    styleLenCache.set(styleId, lens);
+    return lens;
+};
+const transitionBytes = (buffer, styleLenCache, fromId, toId) => {
+    if (fromId === toId) {
+        return 0;
+    }
+    const from = getStyleLens(buffer, styleLenCache, fromId);
+    const to = getStyleLens(buffer, styleLenCache, toId);
+    return from.close + to.open;
+};
+const closeBytes = (buffer, styleLenCache, activeStyleId) => {
+    if (activeStyleId === 0) {
+        return 0;
+    }
+    return getStyleLens(buffer, styleLenCache, activeStyleId).close;
+};
+/**
+ * Estimates bytes written for a styled range and returns resulting cursor/style.
+ */
+const measureStyledRange = (buffer, styleLenCache, row, start, end, activeStyleId, cursorX) => {
+    const width = buffer.width;
+    const safeStart = Math.max(0, Math.min(width, start));
+    const safeEnd = Math.max(0, Math.min(width, end));
+    if (safeEnd <= safeStart) {
+        return { bytes: 0, activeStyleId, cursorX };
+    }
+    let bytes = 0;
+    const rowOffset = row * width;
+    let x = safeStart;
+    while (x < safeEnd) {
+        const index = rowOffset + x;
+        const cellWidth = buffer.widths[index];
+        if (cellWidth === 0) {
+            x++;
+            continue;
+        }
+        const styleId = buffer.styleIds[index] ?? 0;
+        if (styleId !== activeStyleId) {
+            bytes += transitionBytes(buffer, styleLenCache, activeStyleId, styleId);
+            activeStyleId = styleId;
+        }
+        const char = buffer.chars[index] ?? " ";
+        bytes += utf8ByteLength(char);
+        const advance = cellWidth || 1;
+        cursorX += advance;
+        x += advance;
+    }
+    return { bytes, activeStyleId, cursorX };
+};
+/**
+ * Builds row operations and compares patch cost versus full-row redraw cost.
+ */
+const planRowOpsWithCostModel = (nextBuffer, styleLenCache, row, segments, nextEnd, tailClear, overwriteGapPenaltyBytes) => {
+    const width = nextBuffer.width;
+    const ops = [];
+    let patchBytes = 0;
+    let cursorX = 0;
+    let activeStyleId = 0;
+    for (const segment of segments) {
+        let segStart = segment.start;
+        const segEnd = Math.min(width, segment.end);
+        if (segStart < cursorX) {
+            segStart = cursorX;
+        }
+        if (segStart >= segEnd) {
+            continue;
+        }
+        if (segStart > cursorX) {
+            const move = chooseHorizontalMove(cursorX, segStart);
+            const split = measureStyledRange(nextBuffer, styleLenCache, row, segStart, segEnd, activeStyleId, segStart);
+            const splitCost = move.bytes + split.bytes;
+            const gap = measureStyledRange(nextBuffer, styleLenCache, row, cursorX, segStart, activeStyleId, cursorX);
+            const mergedSegment = measureStyledRange(nextBuffer, styleLenCache, row, segStart, segEnd, gap.activeStyleId, segStart);
+            const mergeCost = gap.bytes + mergedSegment.bytes + overwriteGapPenaltyBytes;
+            if (mergeCost <= splitCost) {
+                ops.push({ kind: "write", start: cursorX, end: segStart });
+                patchBytes += gap.bytes;
+                cursorX = gap.cursorX;
+                activeStyleId = gap.activeStyleId;
+                ops.push({ kind: "write", start: segStart, end: segEnd });
+                patchBytes += mergedSegment.bytes;
+                cursorX = mergedSegment.cursorX;
+                activeStyleId = mergedSegment.activeStyleId;
+            }
+            else {
+                ops.push({ kind: "move", toX: segStart, method: move.method });
+                patchBytes += move.bytes;
+                cursorX = segStart;
+                ops.push({ kind: "write", start: segStart, end: segEnd });
+                patchBytes += split.bytes;
+                cursorX = split.cursorX;
+                activeStyleId = split.activeStyleId;
+            }
+        }
+        else {
+            const fullSegment = measureStyledRange(nextBuffer, styleLenCache, row, segStart, segEnd, activeStyleId, cursorX);
+            ops.push({ kind: "write", start: segStart, end: segEnd });
+            patchBytes += fullSegment.bytes;
+            cursorX = fullSegment.cursorX;
+            activeStyleId = fullSegment.activeStyleId;
+        }
+    }
+    patchBytes += closeBytes(nextBuffer, styleLenCache, activeStyleId);
+    activeStyleId = 0;
+    if (tailClear) {
+        if (cursorX !== nextEnd) {
+            patchBytes += chooseHorizontalMove(cursorX, nextEnd).bytes;
+            cursorX = nextEnd;
+        }
+        patchBytes += asciiByteLength(ansiEscapes.eraseEndLine);
+    }
+    patchBytes += asciiByteLength(ansiEscapes.cursorNextLine);
+    let fullBytes = 0;
+    const fullRange = measureStyledRange(nextBuffer, styleLenCache, row, 0, nextEnd, 0, 0);
+    fullBytes += fullRange.bytes;
+    fullBytes += closeBytes(nextBuffer, styleLenCache, fullRange.activeStyleId);
+    if (tailClear) {
+        fullBytes += asciiByteLength(ansiEscapes.eraseEndLine);
+    }
+    fullBytes += asciiByteLength(ansiEscapes.cursorNextLine);
+    if (patchBytes >= fullBytes) {
+        return { useFullRow: true, ops: [] };
+    }
+    return { useFullRow: false, ops };
+};
+/**
+ * Creates a run-diff renderer bound to one output stream.
+ */
+const create = (stream, options = {}) => {
+    const incremental = options.incremental ?? true;
+    const showCursor = options.showCursor ?? false;
+    const mergeStrategy = options.mergeStrategy ?? "cost";
+    const mergeThreshold = Math.max(0, options.mergeThreshold ?? 2);
+    const maxSegmentsBeforeFullRow = Math.max(1, options.maxSegmentsBeforeFullRow ?? 12);
+    const overwriteGapPenaltyBytes = Math.max(0, options.overwriteGapPenaltyBytes ?? 0);
+    const styleLenCache = new Map();
+    let previousHeight = 0;
+    let hasHiddenCursor = false;
+    const previousFrameLineCount = () => previousHeight > 0 ? previousHeight + 1 : 0;
+    const render = ((prevBuffer, nextBuffer, renderOptions = {}) => {
+        const forceFull = renderOptions.forceFull ?? false;
+        if (!showCursor && !hasHiddenCursor) {
+            cliCursor.hide(stream);
+            hasHiddenCursor = true;
+        }
+        const nextHeight = nextBuffer.height;
+        const dimsChanged = previousHeight === 0 ||
+            prevBuffer.width !== nextBuffer.width ||
+            prevBuffer.height !== nextBuffer.height;
+        // Full redraw path: used on first frame, dimension changes, or forced mode.
+        if (forceFull || !incremental || dimsChanged) {
+            const output = nextBuffer.toString();
+            stream.write(ansiEscapes.eraseLines(previousFrameLineCount()) + output + "\n");
+            previousHeight = nextHeight;
+            return;
+        }
+        const prevCount = previousHeight + 1;
+        const nextCount = nextHeight + 1;
+        const visibleCount = nextHeight;
+        const chunks = [];
+        if (nextCount < prevCount) {
+            chunks.push(ansiEscapes.eraseLines(prevCount - nextCount + 1));
+            chunks.push(ansiEscapes.cursorUp(visibleCount));
+        }
+        else {
+            chunks.push(ansiEscapes.cursorUp(prevCount - 1));
+        }
+        const width = nextBuffer.width;
+        // Incremental path: process one row at a time and emit minimal writes.
+        for (let row = 0; row < visibleCount; row++) {
+            if (prevBuffer.isRowEqual(nextBuffer, row)) {
+                chunks.push(ansiEscapes.cursorNextLine);
+                continue;
+            }
+            chunks.push(cursorToColumn(0));
+            const nextEnd = nextBuffer.getRowRightEdge(row);
+            const prevEnd = prevBuffer.getRowRightEdge(row);
+            const tailClear = prevEnd > nextEnd;
+            const scanEnd = tailClear ? nextEnd : Math.max(nextEnd, prevEnd);
+            if (scanEnd === 0 && tailClear) {
+                chunks.push(ansiEscapes.eraseEndLine);
+                chunks.push(ansiEscapes.cursorNextLine);
+                continue;
+            }
+            let segments = computeSegments(prevBuffer, nextBuffer, row, scanEnd);
+            if (mergeStrategy === "threshold") {
+                segments = mergeByGapThreshold(segments, mergeThreshold);
+            }
+            if (segments.length > maxSegmentsBeforeFullRow) {
+                const full = nextBuffer.appendStyledRange(row, 0, nextEnd, chunks, 0, 0);
+                let activeStyleId = full.activeStyleId;
+                activeStyleId = nextBuffer.appendCloseActiveStyle(chunks, activeStyleId);
+                if (tailClear) {
+                    chunks.push(ansiEscapes.eraseEndLine);
+                }
+                chunks.push(ansiEscapes.cursorNextLine);
+                continue;
+            }
+            if (segments.length === 0) {
+                if (tailClear) {
+                    chunks.push(ansiEscapes.eraseEndLine);
+                }
+                chunks.push(ansiEscapes.cursorNextLine);
+                continue;
+            }
+            let cursorX = 0;
+            let activeStyleId = 0;
+            if (mergeStrategy === "cost") {
+                const plan = planRowOpsWithCostModel(nextBuffer, styleLenCache, row, segments, nextEnd, tailClear, overwriteGapPenaltyBytes);
+                if (plan.useFullRow) {
+                    const full = nextBuffer.appendStyledRange(row, 0, nextEnd, chunks, activeStyleId, cursorX);
+                    cursorX = full.cursorX;
+                    activeStyleId = full.activeStyleId;
+                    activeStyleId = nextBuffer.appendCloseActiveStyle(chunks, activeStyleId);
+                    if (tailClear) {
+                        chunks.push(ansiEscapes.eraseEndLine);
+                    }
+                    chunks.push(ansiEscapes.cursorNextLine);
+                    continue;
+                }
+                for (const op of plan.ops) {
+                    if (op.kind === "move") {
+                        const toX = Math.max(0, Math.min(width, op.toX));
+                        const delta = toX - cursorX;
+                        if (delta === 0) {
+                            continue;
+                        }
+                        if (delta > 0) {
+                            if (op.method === "abs") {
+                                chunks.push(cursorToColumn(toX));
+                            }
+                            else {
+                                chunks.push(cursorForward(delta));
+                            }
+                            cursorX = toX;
+                        }
+                        else {
+                            chunks.push(cursorToColumn(toX));
+                            cursorX = toX;
+                        }
+                        continue;
+                    }
+                    let start = op.start;
+                    const end = op.end;
+                    if (start < cursorX) {
+                        start = cursorX;
+                    }
+                    if (start >= end) {
+                        continue;
+                    }
+                    if (start !== cursorX) {
+                        const move = chooseHorizontalMove(cursorX, start);
+                        if (move.method === "abs") {
+                            chunks.push(cursorToColumn(start));
+                        }
+                        else {
+                            chunks.push(cursorForward(start - cursorX));
+                        }
+                        cursorX = start;
+                    }
+                    const result = nextBuffer.appendStyledRange(row, start, end, chunks, activeStyleId, cursorX);
+                    cursorX = result.cursorX;
+                    activeStyleId = result.activeStyleId;
+                }
+            }
+            else {
+                for (const segment of segments) {
+                    let segStart = segment.start;
+                    const segEnd = Math.min(width, segment.end);
+                    if (segStart < cursorX) {
+                        segStart = cursorX;
+                    }
+                    if (segStart >= segEnd) {
+                        continue;
+                    }
+                    const delta = segStart - cursorX;
+                    if (delta > 0) {
+                        chunks.push(cursorForward(delta));
+                        cursorX = segStart;
+                    }
+                    else if (delta < 0) {
+                        chunks.push(cursorToColumn(segStart));
+                        cursorX = segStart;
+                    }
+                    const result = nextBuffer.appendStyledRange(row, segStart, segEnd, chunks, activeStyleId, cursorX);
+                    cursorX = result.cursorX;
+                    activeStyleId = result.activeStyleId;
+                }
+            }
+            activeStyleId = nextBuffer.appendCloseActiveStyle(chunks, activeStyleId);
+            if (tailClear) {
+                if (cursorX !== nextEnd) {
+                    const move = chooseHorizontalMove(cursorX, nextEnd);
+                    if (move.method === "abs") {
+                        chunks.push(cursorToColumn(nextEnd));
+                    }
+                    else {
+                        chunks.push(cursorForward(Math.max(0, nextEnd - cursorX)));
+                    }
+                }
+                chunks.push(ansiEscapes.eraseEndLine);
+            }
+            chunks.push(ansiEscapes.cursorNextLine);
+        }
+        stream.write(chunks.join(""));
+        previousHeight = nextHeight;
+    });
+    render.clear = () => {
+        stream.write(ansiEscapes.eraseLines(previousFrameLineCount()));
+        previousHeight = 0;
+    };
+    render.reset = () => {
+        previousHeight = 0;
+    };
+    render.sync = (buffer) => {
+        previousHeight = buffer.height;
+    };
+    render.done = () => {
+        previousHeight = 0;
+        if (!showCursor && hasHiddenCursor) {
+            cliCursor.show(stream);
+            hasHiddenCursor = false;
+        }
+    };
+    return render;
+};
+export const cellLogUpdateRun = { create };

package/lib/core/cell-output.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Output implementation that writes directly into CellBuffer.
+ */
+import { type CellBuffer } from "./cell-buffer.js";
+import { type Clip, type OutputLike, type OutputWriteOptions } from "./output.js";
+export declare class CellOutput implements OutputLike {
+    private readonly clips;
+    readonly buffer: CellBuffer;
+    constructor(buffer: CellBuffer);
+    clip(clip: Clip): void;
+    unclip(): void;
+    write(x: number, y: number, text: string, options: OutputWriteOptions): void;
+}

package/lib/core/cell-output.js

@@ -0,0 +1,107 @@
+/**
+ * Output implementation that writes directly into CellBuffer.
+ */
+import sliceAnsi from "slice-ansi";
+import stringWidth from "string-width";
+import widestLine from "widest-line";
+import { styledCharsFromTokens, tokenize } from "@alcalzone/ansi-tokenize";
+export class CellOutput {
+    clips = [];
+    buffer;
+    constructor(buffer) {
+        this.buffer = buffer;
+    }
+    clip(clip) {
+        this.clips.push(clip);
+    }
+    unclip() {
+        this.clips.pop();
+    }
+    write(x, y, text, options) {
+        const { transformers } = options;
+        if (!text) {
+            return;
+        }
+        let writeX = x;
+        let writeY = y;
+        let lines = text.split("\n");
+        // Match Output.get() semantics: transformed lines may intentionally keep
+        // trailing spaces (for alignment or visual effects), so mark them.
+        const preserveLineTrailingSpaces = transformers.length > 0;
+        const clip = this.clips.at(-1);
+        if (clip) {
+            const clipHorizontally = typeof clip.x1 === "number" && typeof clip.x2 === "number";
+            const clipVertically = typeof clip.y1 === "number" && typeof clip.y2 === "number";
+            const clipX1 = clip.x1 ?? 0;
+            const clipX2 = clip.x2 ?? 0;
+            const clipY1 = clip.y1 ?? 0;
+            const clipY2 = clip.y2 ?? 0;
+            if (clipHorizontally) {
+                const width = widestLine(text);
+                if (writeX + width < clipX1 || writeX > clipX2) {
+                    return;
+                }
+            }
+            if (clipVertically) {
+                const height = lines.length;
+                if (writeY + height < clipY1 || writeY > clipY2) {
+                    return;
+                }
+            }
+            if (clipHorizontally) {
+                lines = lines.map((line) => {
+                    const from = writeX < clipX1 ? clipX1 - writeX : 0;
+                    const width = stringWidth(line);
+                    const to = writeX + width > clipX2 ? clipX2 - writeX : width;
+                    return sliceAnsi(line, from, to);
+                });
+                if (writeX < clipX1) {
+                    writeX = clipX1;
+                }
+            }
+            if (clipVertically) {
+                const from = writeY < clipY1 ? clipY1 - writeY : 0;
+                const height = lines.length;
+                const to = writeY + height > clipY2 ? clipY2 - writeY : height;
+                lines = lines.slice(from, to);
+                if (writeY < clipY1) {
+                    writeY = clipY1;
+                }
+            }
+        }
+        let offsetY = 0;
+        for (const [lineIndex, line] of lines.entries()) {
+            const row = writeY + offsetY;
+            if (row < 0) {
+                offsetY++;
+                continue;
+            }
+            if (row >= this.buffer.height) {
+                break;
+            }
+            let transformedLine = line;
+            for (const transformer of transformers) {
+                transformedLine = transformer(transformedLine, lineIndex);
+            }
+            const styledChars = styledCharsFromTokens(tokenize(transformedLine));
+            let offsetX = writeX;
+            for (const char of styledChars) {
+                const charWidth = Math.max(1, stringWidth(char.value));
+                if (offsetX < 0) {
+                    offsetX += charWidth;
+                    continue;
+                }
+                if (offsetX >= this.buffer.width) {
+                    break;
+                }
+                if (offsetX + charWidth > this.buffer.width) {
+                    break;
+                }
+                const styleId = this.buffer.styleRegistry.getId(char.styles);
+                this.buffer.setCell(offsetX, row, char.value, charWidth, styleId, preserveLineTrailingSpaces);
+                offsetX += charWidth;
+            }
+            offsetY++;
+        }
+    }
+}

package/lib/core/cell-renderer.d.ts

@@ -0,0 +1,25 @@
+import { type DOMElement } from "./dom.js";
+import { type CellBuffer } from "./cell-buffer.js";
+interface CellRendererResult {
+    /** Interactive frame rendered into `buffer`. */
+    buffer: CellBuffer;
+    /** Height (rows) of the interactive frame. */
+    outputHeight: number;
+    /** Newly appended `<Static>` output, with trailing newline when present. */
+    staticOutput: string;
+    /** Screen-reader text when screen-reader mode is enabled. */
+    screenReaderOutput?: string;
+}
+/**
+ * Renderer that writes interactive output into a CellBuffer.
+ *
+ * Static output is still rendered as string output because it is emitted once
+ * and not updated incrementally.
+ *
+ * @param node - Root DOM node to render.
+ * @param buffer - Reusable destination buffer for the interactive frame.
+ * @param isScreenReaderEnabled - Enables screen-reader rendering path.
+ * @returns The rendered interactive frame and any static output emitted this pass.
+ */
+export declare const cellRenderer: (node: DOMElement, buffer: CellBuffer, isScreenReaderEnabled: boolean) => CellRendererResult;
+export {};