@textui/core 0.1.0

package/dist/jsx/jsx-runtime.js

@@ -0,0 +1,16 @@
+import { componentNameOf, Fragment } from './factory.js';
+export { Fragment };
+function build(type, props, key) {
+    const node = typeof type === 'string'
+        ? { component: type, ...props }
+        : { component: componentNameOf(type), ...props, $meta: { fn: type } };
+    if (key !== undefined)
+        node.key = key;
+    return node;
+}
+export function jsx(type, props, key) {
+    return build(type, props, key);
+}
+export function jsxs(type, props, key) {
+    return build(type, props, key);
+}

package/dist/render/buffer.d.ts

@@ -0,0 +1,77 @@
+import type { Rect } from '../types/geometry.js';
+import type { Cell, CellBuffer } from '../types/cells.js';
+import { type PackedColor } from './color.js';
+/** One cell as it is stored: colours packed, nothing allocated to read it. */
+export interface PackedCell {
+    char: string;
+    fg: PackedColor;
+    bg: PackedColor;
+    attrs: number;
+    link: string | undefined;
+}
+/** Internal cell flags, kept out of the public attrs bitfield. */
+export declare const FLAG_CONTINUATION = 1;
+/**
+ * The frame.
+ *
+ * Cells live in parallel arrays rather than objects because the diff walks
+ * every cell of every frame, and one allocation per cell per frame is the
+ * difference between a smooth redraw and a visibly stuttering one.
+ */
+export declare class Buffer implements CellBuffer {
+    width: number;
+    height: number;
+    chars: string[];
+    fg: Int32Array;
+    bg: Int32Array;
+    attrs: Uint16Array;
+    flags: Uint8Array;
+    links: (string | undefined)[];
+    private prevChars;
+    private prevFg;
+    private prevBg;
+    private prevAttrs;
+    private prevLinks;
+    private committed;
+    constructor(width: number, height: number);
+    /** Cell-object access, for the `CellBuffer` contract and the test harness. */
+    get(x: number, y: number): Cell | undefined;
+    /**
+     * The same cell, as the numbers it is actually stored as.
+     *
+     * `get` is the friendly shape: it unpacks both colours into `Color` values,
+     * which is right for a test or a caller reasoning about colour and wrong for
+     * a loop over a region - packing them straight back is an allocation and a
+     * round trip per cell. This is what the renderer's inner loops use.
+     */
+    packedAt(x: number, y: number): PackedCell | undefined;
+    set(x: number, y: number, cell: Cell): void;
+    index(x: number, y: number): number;
+    inBounds(x: number, y: number): boolean;
+    /**
+     * Write one grapheme. A double-width grapheme claims the next cell as a
+     * continuation, and writing over either half clears the other - otherwise a
+     * half-overwritten wide character shifts every cell after it on that row.
+     */
+    put(x: number, y: number, char: string, fg?: PackedColor, bg?: PackedColor, attrs?: number, link?: string): void;
+    /**
+     * Blank a region, or the whole buffer.
+     *
+     * By span rather than by cell. Clearing everything happens once a frame, and
+     * a cell-at-a-time loop over twelve thousand of them - each with two bounds
+     * checks and an index multiply - was costing more than painting the content
+     * that replaced it. `fill` is one call into the engine per array, and the
+     * four that matter are typed.
+     */
+    clear(rect?: Rect, bg?: PackedColor): void;
+    private fillSpan;
+    resize(width: number, height: number): void;
+    cellChanged(i: number): boolean;
+    dirtyRows(): number[];
+    commit(): void;
+    /** Force the next diff to repaint everything. After a resize or a redraw. */
+    invalidate(): void;
+    toText(rect?: Rect): string;
+}
+export declare function createBuffer(width: number, height: number): Buffer;
+//# sourceMappingURL=buffer.d.ts.map

package/dist/render/buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.d.ts","sourceRoot":"","sources":["../../src/render/buffer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAC;AACjD,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAA4B,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAExE,8EAA8E;AAC9E,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,WAAW,CAAC;IAChB,EAAE,EAAE,WAAW,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B;AAGD,kEAAkE;AAClE,eAAO,MAAM,iBAAiB,IAAI,CAAC;AAEnC;;;;;;GAMG;AACH,qBAAa,MAAO,YAAW,UAAU;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IAEf,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,EAAE,EAAE,UAAU,CAAC;IACf,EAAE,EAAE,UAAU,CAAC;IACf,KAAK,EAAE,WAAW,CAAC;IACnB,KAAK,EAAE,UAAU,CAAC;IAClB,KAAK,EAAE,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAAC;IAE9B,OAAO,CAAC,SAAS,CAAW;IAC5B,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,SAAS,CAAc;IAC/B,OAAO,CAAC,SAAS,CAAyB;IAC1C,OAAO,CAAC,SAAS,CAAS;gBAEd,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAkBzC,8EAA8E;IAC9E,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS;IAa3C;;;;;;;OAOG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAYtD,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI;IAO3C,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM;IAInC,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO;IAIvC;;;;OAIG;IACH,GAAG,CACD,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,MAAM,EACZ,EAAE,GAAE,WAA2B,EAC/B,EAAE,GAAE,WAA2B,EAC/B,KAAK,SAAI,EACT,IAAI,CAAC,EAAE,MAAM,GACZ,IAAI;IAqDP;;;;;;;;OAQG;IACH,KAAK,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE,GAAE,WAA2B,GAAG,IAAI;IAmBzD,OAAO,CAAC,QAAQ;IAShB,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAoC3C,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAU/B,SAAS,IAAI,MAAM,EAAE;IAiBrB,MAAM,IAAI,IAAI;IASd,6EAA6E;IAC7E,UAAU,IAAI,IAAI;IAIlB,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,GAAG,MAAM;CAgB5B;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAElE"}

package/dist/render/buffer.js

@@ -0,0 +1,275 @@
+import { COLOR_DEFAULT, packColor } from './color.js';
+import { graphemeWidth } from '../util/text.js';
+/** Internal cell flags, kept out of the public attrs bitfield. */
+export const FLAG_CONTINUATION = 1;
+/**
+ * The frame.
+ *
+ * Cells live in parallel arrays rather than objects because the diff walks
+ * every cell of every frame, and one allocation per cell per frame is the
+ * difference between a smooth redraw and a visibly stuttering one.
+ */
+export class Buffer {
+    width;
+    height;
+    chars;
+    fg;
+    bg;
+    attrs;
+    flags;
+    links;
+    prevChars;
+    prevFg;
+    prevBg;
+    prevAttrs;
+    prevLinks;
+    committed = false;
+    constructor(width, height) {
+        this.width = Math.max(0, width);
+        this.height = Math.max(0, height);
+        const n = this.width * this.height;
+        this.chars = new Array(n).fill(' ');
+        this.fg = new Int32Array(n).fill(COLOR_DEFAULT);
+        this.bg = new Int32Array(n).fill(COLOR_DEFAULT);
+        this.attrs = new Uint16Array(n);
+        this.flags = new Uint8Array(n);
+        this.links = new Array(n).fill(undefined);
+        this.prevChars = new Array(n).fill(' ');
+        this.prevFg = new Int32Array(n).fill(COLOR_DEFAULT);
+        this.prevBg = new Int32Array(n).fill(COLOR_DEFAULT);
+        this.prevAttrs = new Uint16Array(n);
+        this.prevLinks = new Array(n).fill(undefined);
+    }
+    /** Cell-object access, for the `CellBuffer` contract and the test harness. */
+    get(x, y) {
+        if (!this.inBounds(x, y))
+            return undefined;
+        const i = this.index(x, y);
+        return {
+            char: this.chars[i],
+            fg: packedToColor(this.fg[i]),
+            bg: packedToColor(this.bg[i]),
+            attrs: this.attrs[i],
+            link: this.links[i],
+            continuation: (this.flags[i] & FLAG_CONTINUATION) !== 0,
+        };
+    }
+    /**
+     * The same cell, as the numbers it is actually stored as.
+     *
+     * `get` is the friendly shape: it unpacks both colours into `Color` values,
+     * which is right for a test or a caller reasoning about colour and wrong for
+     * a loop over a region - packing them straight back is an allocation and a
+     * round trip per cell. This is what the renderer's inner loops use.
+     */
+    packedAt(x, y) {
+        if (!this.inBounds(x, y))
+            return undefined;
+        const i = this.index(x, y);
+        return {
+            char: this.chars[i],
+            fg: this.fg[i],
+            bg: this.bg[i],
+            attrs: this.attrs[i],
+            link: this.links[i],
+        };
+    }
+    set(x, y, cell) {
+        this.put(x, y, cell.char, packColor(cell.fg), packColor(cell.bg), cell.attrs, cell.link);
+    }
+    index(x, y) {
+        return y * this.width + x;
+    }
+    inBounds(x, y) {
+        return x >= 0 && x < this.width && y >= 0 && y < this.height;
+    }
+    /**
+     * Write one grapheme. A double-width grapheme claims the next cell as a
+     * continuation, and writing over either half clears the other - otherwise a
+     * half-overwritten wide character shifts every cell after it on that row.
+     */
+    put(x, y, char, fg = COLOR_DEFAULT, bg = COLOR_DEFAULT, attrs = 0, link) {
+        if (!this.inBounds(x, y))
+            return;
+        const i = this.index(x, y);
+        // Overwriting the right half of a wide pair: blank the left half.
+        if ((this.flags[i] & FLAG_CONTINUATION) !== 0 && x > 0) {
+            this.chars[i - 1] = ' ';
+            this.flags[i - 1] = 0;
+        }
+        // Overwriting a wide left half: blank its continuation.
+        if (x + 1 < this.width && (this.flags[i + 1] & FLAG_CONTINUATION) !== 0) {
+            this.chars[i + 1] = ' ';
+            this.flags[i + 1] = 0;
+        }
+        /*
+         * The width of one printable ASCII character, without asking.
+         *
+         * `graphemeWidth` is a function call per cell painted - twelve thousand of
+         * them a frame on a full screen - to answer "is `a` one cell wide". It is,
+         * and the character code says so.
+         */
+        const only = char.length === 1 ? char.charCodeAt(0) : -1;
+        const w = only >= 0x20 && only <= 0x7e ? 1 : graphemeWidth(char);
+        if (w === 0)
+            return;
+        this.chars[i] = char;
+        this.fg[i] = fg;
+        this.bg[i] = bg;
+        this.attrs[i] = attrs;
+        this.flags[i] = 0;
+        this.links[i] = link;
+        if (w === 2) {
+            if (x + 1 >= this.width) {
+                // A wide grapheme in the last column cannot render; blank it.
+                this.chars[i] = ' ';
+                return;
+            }
+            const j = i + 1;
+            if (x + 2 < this.width && (this.flags[j + 1] & FLAG_CONTINUATION) !== 0) {
+                this.chars[j + 1] = ' ';
+                this.flags[j + 1] = 0;
+            }
+            this.chars[j] = '';
+            this.fg[j] = fg;
+            this.bg[j] = bg;
+            this.attrs[j] = attrs;
+            this.flags[j] = FLAG_CONTINUATION;
+            this.links[j] = link;
+        }
+    }
+    /**
+     * Blank a region, or the whole buffer.
+     *
+     * By span rather than by cell. Clearing everything happens once a frame, and
+     * a cell-at-a-time loop over twelve thousand of them - each with two bounds
+     * checks and an index multiply - was costing more than painting the content
+     * that replaced it. `fill` is one call into the engine per array, and the
+     * four that matter are typed.
+     */
+    clear(rect, bg = COLOR_DEFAULT) {
+        if (rect === undefined) {
+            this.fillSpan(0, this.width * this.height, bg);
+            return;
+        }
+        const x0 = Math.max(0, rect.x);
+        const x1 = Math.min(this.width, rect.x + rect.width);
+        const y0 = Math.max(0, rect.y);
+        const y1 = Math.min(this.height, rect.y + rect.height);
+        if (x1 <= x0 || y1 <= y0)
+            return;
+        // A row at a time: rows are contiguous, columns are not.
+        for (let y = y0; y < y1; y++) {
+            const start = y * this.width;
+            this.fillSpan(start + x0, start + x1, bg);
+        }
+    }
+    fillSpan(from, to, bg) {
+        this.chars.fill(' ', from, to);
+        this.fg.fill(COLOR_DEFAULT, from, to);
+        this.bg.fill(bg, from, to);
+        this.attrs.fill(0, from, to);
+        this.flags.fill(0, from, to);
+        this.links.fill(undefined, from, to);
+    }
+    resize(width, height) {
+        if (width === this.width && height === this.height)
+            return;
+        const next = new Buffer(width, height);
+        const w = Math.min(width, this.width);
+        const h = Math.min(height, this.height);
+        for (let y = 0; y < h; y++) {
+            for (let x = 0; x < w; x++) {
+                const from = this.index(x, y);
+                const to = next.index(x, y);
+                next.chars[to] = this.chars[from];
+                next.fg[to] = this.fg[from];
+                next.bg[to] = this.bg[from];
+                next.attrs[to] = this.attrs[from];
+                next.flags[to] = this.flags[from];
+                next.links[to] = this.links[from];
+            }
+        }
+        this.width = next.width;
+        this.height = next.height;
+        this.chars = next.chars;
+        this.fg = next.fg;
+        this.bg = next.bg;
+        this.attrs = next.attrs;
+        this.flags = next.flags;
+        this.links = next.links;
+        // A resize invalidates the previous frame entirely.
+        const n = width * height;
+        this.prevChars = new Array(n).fill(' ');
+        this.prevFg = new Int32Array(n).fill(COLOR_DEFAULT);
+        this.prevBg = new Int32Array(n).fill(COLOR_DEFAULT);
+        this.prevAttrs = new Uint16Array(n);
+        this.prevLinks = new Array(n).fill(undefined);
+        this.committed = false;
+    }
+    cellChanged(i) {
+        return (this.chars[i] !== this.prevChars[i] ||
+            this.fg[i] !== this.prevFg[i] ||
+            this.bg[i] !== this.prevBg[i] ||
+            this.attrs[i] !== this.prevAttrs[i] ||
+            this.links[i] !== this.prevLinks[i]);
+    }
+    dirtyRows() {
+        if (!this.committed) {
+            return Array.from({ length: this.height }, (_, y) => y);
+        }
+        const rows = [];
+        for (let y = 0; y < this.height; y++) {
+            const start = y * this.width;
+            for (let x = 0; x < this.width; x++) {
+                if (this.cellChanged(start + x)) {
+                    rows.push(y);
+                    break;
+                }
+            }
+        }
+        return rows;
+    }
+    commit() {
+        this.prevChars = this.chars.slice();
+        this.prevFg = this.fg.slice();
+        this.prevBg = this.bg.slice();
+        this.prevAttrs = this.attrs.slice();
+        this.prevLinks = this.links.slice();
+        this.committed = true;
+    }
+    /** Force the next diff to repaint everything. After a resize or a redraw. */
+    invalidate() {
+        this.committed = false;
+    }
+    toText(rect) {
+        const r = rect ?? { x: 0, y: 0, width: this.width, height: this.height };
+        const lines = [];
+        for (let y = r.y; y < r.y + r.height; y++) {
+            if (y < 0 || y >= this.height)
+                continue;
+            let line = '';
+            for (let x = r.x; x < r.x + r.width; x++) {
+                if (x < 0 || x >= this.width)
+                    continue;
+                const i = this.index(x, y);
+                if ((this.flags[i] & FLAG_CONTINUATION) !== 0)
+                    continue;
+                line += this.chars[i];
+            }
+            lines.push(line.replace(/[ ]+$/, ''));
+        }
+        return lines.join('\n');
+    }
+}
+export function createBuffer(width, height) {
+    return new Buffer(width, height);
+}
+function packedToColor(packed) {
+    if (packed === COLOR_DEFAULT)
+        return 'default';
+    if (packed >= 0x1000000) {
+        return { rgb: [(packed >> 16) & 0xff, (packed >> 8) & 0xff, packed & 0xff] };
+    }
+    return { palette: packed };
+}

package/dist/render/color.d.ts

@@ -0,0 +1,35 @@
+import type { AnsiColorName, Color, ColorDepth } from '../types/index.js';
+/**
+ * Colours are packed into one integer so a cell is cheap to store and cheap to
+ * compare - the frame diff runs over every cell, every frame.
+ *
+ *   -1              terminal default
+ *   0..255          palette index (0..15 are the ANSI names)
+ *   >= 0x1000000    24-bit rgb, as 0x1000000 | rrggbb
+ */
+export type PackedColor = number;
+export declare const COLOR_DEFAULT: PackedColor;
+export declare const ANSI_NAMES: Record<AnsiColorName, number>;
+export declare function packRgb(r: number, g: number, b: number): PackedColor;
+export declare function isRgb(c: PackedColor): boolean;
+export declare function unpackRgb(c: PackedColor): [number, number, number];
+export declare function packColor(color: Color | undefined): PackedColor;
+/**
+ * Reduce a colour to what the terminal can show. A component never picks a
+ * fallback itself - it names a token, and this decides what that survives as.
+ */
+export declare function downsample(c: PackedColor, depth: ColorDepth): PackedColor;
+/** Relative luminance, for picking readable foreground over a background. */
+export declare function luminance(c: PackedColor): number;
+/** Mix two packed colours. `t` of 0 is `a`, 1 is `b`. */
+export declare function mix(a: PackedColor, b: PackedColor, t: number): PackedColor;
+/**
+ * A packed colour back as a `Color`, which is the shape a style takes.
+ *
+ * The inverse of `packColor`, for the places that compute a colour and then
+ * have to hand it to a component - blending a tint out of two theme colours,
+ * say. Painting goes the other way and should stay packed.
+ */
+export declare function unpackColor(packed: PackedColor): Color;
+export declare function toHex(c: PackedColor): string;
+//# sourceMappingURL=color.d.ts.map

package/dist/render/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../src/render/color.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE1E;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC;AAEjC,eAAO,MAAM,aAAa,EAAE,WAAgB,CAAC;AAG7C,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,aAAa,EAAE,MAAM,CAKpD,CAAC;AAEF,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW,CAEpE;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO,CAE7C;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAElE;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,GAAG,WAAW,CA6B/D;AAyDD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,EAAE,UAAU,GAAG,WAAW,CAazE;AAED,6EAA6E;AAC7E,wBAAgB,SAAS,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAOhD;AAED,yDAAyD;AACzD,wBAAgB,GAAG,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW,CAQ1E;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,WAAW,GAAG,KAAK,CAOtD;AAED,wBAAgB,KAAK,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAG5C"}

package/dist/render/color.js

@@ -0,0 +1,160 @@
+export const COLOR_DEFAULT = -1;
+const RGB_FLAG = 0x1000000;
+export const ANSI_NAMES = {
+    black: 0, red: 1, green: 2, yellow: 3,
+    blue: 4, magenta: 5, cyan: 6, white: 7,
+    brightBlack: 8, brightRed: 9, brightGreen: 10, brightYellow: 11,
+    brightBlue: 12, brightMagenta: 13, brightCyan: 14, brightWhite: 15,
+};
+export function packRgb(r, g, b) {
+    return RGB_FLAG | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff);
+}
+export function isRgb(c) {
+    return c >= RGB_FLAG;
+}
+export function unpackRgb(c) {
+    return [(c >> 16) & 0xff, (c >> 8) & 0xff, c & 0xff];
+}
+export function packColor(color) {
+    if (color === undefined || color === 'default')
+        return COLOR_DEFAULT;
+    if (typeof color === 'string') {
+        if (color.startsWith('#')) {
+            const hex = color.slice(1);
+            if (hex.length === 3) {
+                const r = parseInt(hex[0], 16);
+                const g = parseInt(hex[1], 16);
+                const b = parseInt(hex[2], 16);
+                return packRgb(r * 17, g * 17, b * 17);
+            }
+            if (hex.length === 6) {
+                return packRgb(parseInt(hex.slice(0, 2), 16), parseInt(hex.slice(2, 4), 16), parseInt(hex.slice(4, 6), 16));
+            }
+            return COLOR_DEFAULT;
+        }
+        const idx = ANSI_NAMES[color];
+        return idx === undefined ? COLOR_DEFAULT : idx;
+    }
+    if ('rgb' in color) {
+        const [r, g, b] = color.rgb;
+        return packRgb(r, g, b);
+    }
+    if ('palette' in color)
+        return color.palette & 0xff;
+    return COLOR_DEFAULT;
+}
+/** The xterm 256 palette, so 24-bit can be reduced without a lookup table. */
+const CUBE_STEPS = [0, 95, 135, 175, 215, 255];
+function nearestCube(v) {
+    let best = 0;
+    let bestDist = Infinity;
+    for (let i = 0; i < CUBE_STEPS.length; i++) {
+        const d = Math.abs(CUBE_STEPS[i] - v);
+        if (d < bestDist) {
+            bestDist = d;
+            best = i;
+        }
+    }
+    return best;
+}
+function rgbTo256(r, g, b) {
+    // Greyscale ramp is a better fit when the channels are close.
+    if (Math.abs(r - g) < 8 && Math.abs(g - b) < 8) {
+        if (r < 8)
+            return 16;
+        if (r > 248)
+            return 231;
+        return 232 + Math.round(((r - 8) / 247) * 23);
+    }
+    return 16 + 36 * nearestCube(r) + 6 * nearestCube(g) + nearestCube(b);
+}
+const ANSI16_RGB = [
+    [0, 0, 0], [205, 49, 49], [13, 188, 121], [229, 229, 16],
+    [36, 114, 200], [188, 63, 188], [17, 168, 205], [229, 229, 229],
+    [102, 102, 102], [241, 76, 76], [35, 209, 139], [245, 245, 67],
+    [59, 142, 234], [214, 112, 214], [41, 184, 219], [255, 255, 255],
+];
+function rgbTo16(r, g, b) {
+    let best = 0;
+    let bestDist = Infinity;
+    for (let i = 0; i < 16; i++) {
+        const [cr, cg, cb] = ANSI16_RGB[i];
+        const d = (r - cr) ** 2 + (g - cg) ** 2 + (b - cb) ** 2;
+        if (d < bestDist) {
+            bestDist = d;
+            best = i;
+        }
+    }
+    return best;
+}
+function palette256ToRgb(idx) {
+    if (idx < 16)
+        return ANSI16_RGB[idx];
+    if (idx >= 232) {
+        const v = 8 + (idx - 232) * 10;
+        return [v, v, v];
+    }
+    const n = idx - 16;
+    return [
+        CUBE_STEPS[Math.floor(n / 36) % 6],
+        CUBE_STEPS[Math.floor(n / 6) % 6],
+        CUBE_STEPS[n % 6],
+    ];
+}
+/**
+ * Reduce a colour to what the terminal can show. A component never picks a
+ * fallback itself - it names a token, and this decides what that survives as.
+ */
+export function downsample(c, depth) {
+    if (c === COLOR_DEFAULT)
+        return c;
+    if (depth === 0)
+        return COLOR_DEFAULT;
+    if (depth === 24)
+        return c;
+    if (isRgb(c)) {
+        const [r, g, b] = unpackRgb(c);
+        return depth === 8 ? rgbTo256(r, g, b) : rgbTo16(r, g, b);
+    }
+    if (depth === 8)
+        return c;
+    if (c < 16)
+        return c;
+    const [r, g, b] = palette256ToRgb(c);
+    return rgbTo16(r, g, b);
+}
+/** Relative luminance, for picking readable foreground over a background. */
+export function luminance(c) {
+    const [r, g, b] = isRgb(c) ? unpackRgb(c) : palette256ToRgb(c < 0 ? 0 : c);
+    const f = (v) => {
+        const s = v / 255;
+        return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4;
+    };
+    return 0.2126 * f(r) + 0.7152 * f(g) + 0.0722 * f(b);
+}
+/** Mix two packed colours. `t` of 0 is `a`, 1 is `b`. */
+export function mix(a, b, t) {
+    const [ar, ag, ab] = isRgb(a) ? unpackRgb(a) : palette256ToRgb(Math.max(0, a));
+    const [br, bg, bb] = isRgb(b) ? unpackRgb(b) : palette256ToRgb(Math.max(0, b));
+    return packRgb(Math.round(ar + (br - ar) * t), Math.round(ag + (bg - ag) * t), Math.round(ab + (bb - ab) * t));
+}
+/**
+ * A packed colour back as a `Color`, which is the shape a style takes.
+ *
+ * The inverse of `packColor`, for the places that compute a colour and then
+ * have to hand it to a component - blending a tint out of two theme colours,
+ * say. Painting goes the other way and should stay packed.
+ */
+export function unpackColor(packed) {
+    if (packed === COLOR_DEFAULT)
+        return 'default';
+    if (isRgb(packed)) {
+        const [r, g, b] = unpackRgb(packed);
+        return { rgb: [r, g, b] };
+    }
+    return { palette: packed };
+}
+export function toHex(c) {
+    const [r, g, b] = isRgb(c) ? unpackRgb(c) : palette256ToRgb(Math.max(0, c));
+    return `#${[r, g, b].map((v) => v.toString(16).padStart(2, '0')).join('')}`;
+}

package/dist/render/diff.d.ts

@@ -0,0 +1,37 @@
+import type { Buffer } from './buffer.js';
+import type { PackedColor } from './color.js';
+/** One contiguous run of identical-style cells - what the writer emits. */
+export interface Run {
+    x: number;
+    y: number;
+    text: string;
+    fg: PackedColor;
+    bg: PackedColor;
+    attrs: number;
+    link: string | undefined;
+}
+export interface Frame {
+    runs: Run[];
+    cursor: {
+        x: number;
+        y: number;
+        visible: boolean;
+    } | null;
+    /** True when every row was emitted - first frame, or after invalidate. */
+    full: boolean;
+}
+/**
+ * Turn changed cells into runs.
+ *
+ * Two economies matter here and nowhere else: only touched rows are walked,
+ * and within a row, adjacent changed cells sharing a style become one run, so
+ * a redraw costs one cursor move and one SGR change per run rather than per
+ * cell. A run continues through a short stretch of unchanged cells when
+ * repainting them is cheaper than moving the cursor around them.
+ */
+export declare function diffFrame(buffer: Buffer, cursor?: {
+    x: number;
+    y: number;
+    visible: boolean;
+} | null, gapTolerance?: number): Frame;
+//# sourceMappingURL=diff.d.ts.map

package/dist/render/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/render/diff.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,2EAA2E;AAC3E,MAAM,WAAW,GAAG;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,WAAW,CAAC;IAChB,EAAE,EAAE,WAAW,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B;AAED,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,MAAM,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI,CAAC;IAC1D,0EAA0E;IAC1E,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,GAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,GAAG,IAAW,EAChE,YAAY,SAAI,GACf,KAAK,CA+DP"}

package/dist/render/diff.js

@@ -0,0 +1,66 @@
+import { FLAG_CONTINUATION } from './buffer.js';
+/**
+ * Turn changed cells into runs.
+ *
+ * Two economies matter here and nowhere else: only touched rows are walked,
+ * and within a row, adjacent changed cells sharing a style become one run, so
+ * a redraw costs one cursor move and one SGR change per run rather than per
+ * cell. A run continues through a short stretch of unchanged cells when
+ * repainting them is cheaper than moving the cursor around them.
+ */
+export function diffFrame(buffer, cursor = null, gapTolerance = 4) {
+    const runs = [];
+    const rows = buffer.dirtyRows();
+    const full = rows.length === buffer.height && buffer.height > 0;
+    for (const y of rows) {
+        const base = y * buffer.width;
+        let x = 0;
+        while (x < buffer.width) {
+            const i = base + x;
+            if ((buffer.flags[i] & FLAG_CONTINUATION) !== 0 || !buffer.cellChanged(i)) {
+                x++;
+                continue;
+            }
+            const fg = buffer.fg[i];
+            const bg = buffer.bg[i];
+            const attrs = buffer.attrs[i];
+            const link = buffer.links[i];
+            let text = '';
+            let cx = x;
+            let gap = 0;
+            let pendingGap = '';
+            while (cx < buffer.width) {
+                const j = base + cx;
+                if ((buffer.flags[j] & FLAG_CONTINUATION) !== 0) {
+                    cx++;
+                    continue;
+                }
+                const sameStyle = buffer.fg[j] === fg &&
+                    buffer.bg[j] === bg &&
+                    buffer.attrs[j] === attrs &&
+                    buffer.links[j] === link;
+                if (!sameStyle)
+                    break;
+                if (buffer.cellChanged(j)) {
+                    if (pendingGap !== '') {
+                        text += pendingGap;
+                        pendingGap = '';
+                        gap = 0;
+                    }
+                    text += buffer.chars[j];
+                    cx++;
+                    continue;
+                }
+                gap++;
+                if (gap > gapTolerance)
+                    break;
+                pendingGap += buffer.chars[j];
+                cx++;
+            }
+            if (text !== '')
+                runs.push({ x, y, text, fg, bg, attrs, link });
+            x = cx > x ? cx : x + 1;
+        }
+    }
+    return { runs, cursor, full };
+}