@promptctl/rich-js 0.16.0 → 0.18.0

package/dist/core/wrap.d.ts

@@ -1,41 +0,0 @@
-/**
- * Word wrapping: the offsets one logical line is cut at so its pieces fit a
- * cell budget.
- *
- * This is deliberately not in `cells.ts` next door. That module answers
- * geometry — how wide is this, where does cell column N fall — and knows
- * nothing about language. This one answers where a line may *break*, which is
- * a fact about words, and the only thing it borrows from geometry is how to
- * measure one.
- *
- * It returns offsets rather than pieces because the caller holds styled
- * `Segment[]`, not a string: cutting the text here would drop every span
- * attached to it. Offsets are the one representation both sides can act on —
- * `Segment.divide` cuts the styled line at exactly the places this function
- * found in the plain one.
- *
- * Wrapping is the *first* step, and overflow is the last resort applied to a
- * line still too wide once wrapping is done. That order is the whole reason a
- * long sentence in a table cell grows the row while an unbreakable word in the
- * same cell still ellipsizes.
- */
-import { type CellCol } from "./cells.js";
-/**
- * The cell offsets `text` should be cut at to wrap it into lines of at most
- * `width` cells, for `Segment.divide` to apply to the styled line.
- *
- * `fold` decides what happens to a word that fits on no line at all: folded,
- * it is chopped across as many lines as it needs; unfolded, it is left whole
- * on its own line for the caller's overflow method to cut. Only the `fold`
- * overflow method folds — `crop` and `ellipsis` want the word intact so they
- * can truncate it, which is what makes an unbreakable word ellipsize while the
- * sentence around it merely wraps.
- *
- * Requires `width >= 1`. A zero-cell canvas gets no cuts, because "no cut
- * fits" and "no cell fits" are different facts and only one of them is a list
- * of offsets — the caller answers the second one by cropping the single
- * uncut piece to nothing, which is what every overflow method does there.
- */
-export declare function divideLine(text: string, width: CellCol, options: {
-    fold: boolean;
-}): CellCol[];

package/dist/core/wrap.js

@@ -1,127 +0,0 @@
-/**
- * Word wrapping: the offsets one logical line is cut at so its pieces fit a
- * cell budget.
- *
- * This is deliberately not in `cells.ts` next door. That module answers
- * geometry — how wide is this, where does cell column N fall — and knows
- * nothing about language. This one answers where a line may *break*, which is
- * a fact about words, and the only thing it borrows from geometry is how to
- * measure one.
- *
- * It returns offsets rather than pieces because the caller holds styled
- * `Segment[]`, not a string: cutting the text here would drop every span
- * attached to it. Offsets are the one representation both sides can act on —
- * `Segment.divide` cuts the styled line at exactly the places this function
- * found in the plain one.
- *
- * Wrapping is the *first* step, and overflow is the last resort applied to a
- * line still too wide once wrapping is done. That order is the whole reason a
- * long sentence in a table cell grows the row while an unbreakable word in the
- * same cell still ellipsizes.
- */
-import { cellLen, chopCells, asCellCol } from "./cells.js";
-/**
- * Each word of `text` in order, where a "word" carries its own trailing
- * whitespace — the run of spaces that follows it belongs to it, because that
- * is the whitespace a break at the *next* word leaves hanging past the edge.
- *
- * The matches tile the text: each begins exactly where the last ended, so a
- * caller can track absolute offsets by accumulating widths alone. Text with no
- * non-whitespace character yields nothing, which is the honest answer — there
- * is nowhere to break.
- */
-function* words(text) {
-    // Constructed per call rather than hoisted: a sticky regex carries its
-    // `lastIndex` as mutable state, and a shared one would corrupt any two
-    // interleaved walks. [LAW:no-shared-mutable-globals]
-    const re = /\s*\S+\s*/y;
-    for (let match = re.exec(text); match !== null; match = re.exec(text)) {
-        yield match[0];
-    }
-}
-/**
- * A word chopped into pieces of at most `width` cells, as the reference chops
- * it.
- *
- * `chopCells` next door and Rich's `chop_cells` disagree in exactly one place.
- * Rich opens a new line for any glyph that does not fit and emits whatever line
- * it was already on, so a word beginning with a glyph wider than the entire
- * canvas folds with an empty piece in front of it — and that piece reaches the
- * output as a blank line. `chopCells` force-takes the glyph instead and never
- * returns an empty piece.
- *
- * Restoring the blank is what keeps `test/core/text-wrap.golden.txt`
- * regenerable from the reference. A fixture is only an oracle while the command
- * in its header reproduces it byte for byte; smoothing away one byte the
- * reference emits costs that, everywhere, to tidy a blank line reachable only
- * by folding a two-cell glyph onto a one-cell canvas.
- */
-function foldWord(word, width) {
-    const pieces = chopCells(word, width);
-    // `chopCells` overshoots the budget only when it force-takes one glyph, so an
-    // over-wide first piece is exactly the case Rich opens a blank line for.
-    return cellLen(pieces[0]) > width ? ["", ...pieces] : pieces;
-}
-/**
- * The cell offsets `text` should be cut at to wrap it into lines of at most
- * `width` cells, for `Segment.divide` to apply to the styled line.
- *
- * `fold` decides what happens to a word that fits on no line at all: folded,
- * it is chopped across as many lines as it needs; unfolded, it is left whole
- * on its own line for the caller's overflow method to cut. Only the `fold`
- * overflow method folds — `crop` and `ellipsis` want the word intact so they
- * can truncate it, which is what makes an unbreakable word ellipsize while the
- * sentence around it merely wraps.
- *
- * Requires `width >= 1`. A zero-cell canvas gets no cuts, because "no cut
- * fits" and "no cell fits" are different facts and only one of them is a list
- * of offsets — the caller answers the second one by cropping the single
- * uncut piece to nothing, which is what every overflow method does there.
- */
-export function divideLine(text, width, options) {
-    if (width <= 0)
-        return [];
-    const cuts = [];
-    // A cut at the start of the text is not a cut: it would open the line with
-    // an empty piece. [LAW:single-enforcer] for that rule, so neither arm below
-    // has to restate it.
-    const cutAt = (cell) => {
-        if (cell > 0)
-            cuts.push(asCellCol(cell));
-    };
-    let used = 0; // cells already committed to the line being filled
-    let wordStart = 0; // absolute cell offset where the current word begins
-    for (const word of words(text)) {
-        // Measured without its trailing whitespace: a word is allowed to end the
-        // line with its spaces hanging past the edge, and the caller crops them.
-        const wordWidth = cellLen(word.trimEnd());
-        if (width - used >= wordWidth) {
-            used += cellLen(word);
-        }
-        else if (options.fold && wordWidth > width) {
-            // No line, however empty, can hold this word whole, and folding is
-            // allowed — so it is chopped across as many lines as it needs. Unfolded,
-            // it takes the arm below and is left whole for the overflow method.
-            const pieces = foldWord(word, width);
-            let pieceStart = wordStart;
-            for (let index = 0; index < pieces.length; index += 1) {
-                cutAt(pieceStart);
-                const piece = pieces[index];
-                // The last piece is what the *next* word finds already on the line;
-                // the rest are whole lines of their own.
-                if (index === pieces.length - 1)
-                    used = cellLen(piece);
-                else
-                    pieceStart += cellLen(piece);
-            }
-        }
-        else {
-            // It does not fit here. Either it fits on a line of its own, or nothing
-            // can hold it and the caller's overflow method will cut it there.
-            cutAt(wordStart);
-            used = cellLen(word);
-        }
-        wordStart += cellLen(word);
-    }
-    return cuts;
-}

package/dist/host/host-stream.d.ts

@@ -1,30 +0,0 @@
-/**
- * hostStream — adapt a `TerminalHost` into the narrow Writable surface that
- * Console (and Live) actually exercise.
- *
- * [LAW:types-are-the-program] The return type matches Console's `ConsoleSink`
- * exactly: a single `.write(chunk)` method whose return value Console never
- * inspects (so the type leaves it as `unknown`; this implementation happens
- * to return `true` to mirror Node's stream contract, but callers may not
- * rely on that). Anything wider would lie about what this adapter
- * implements; anything narrower would force a cast at the call site.
- * Calling `.pipe()`, `.cork()`, `.on('error')`, etc. is a programming error
- * that TypeScript will reject at compile time.
- *
- * [LAW:locality-or-seam] Console + Live access their sink only via `.write()`
- * — verified in src/core/console.ts (one `_file.write` call) and
- * src/renderables/live.ts (every `this._console.file.write(...)` site). So
- * this narrow surface is the entire contract they need.
- */
-import type { ConsoleSink } from "../core/console.js";
-import type { TerminalHost } from "./terminal-host.js";
-/**
- * Wrap a `TerminalHost` so its output can be threaded into `Console` via the
- * existing `file:` option. The returned object implements `.write()` only —
- * exactly the surface Console + Live touch.
- *
- * Pair with `forceTerminal: true` on the Console — without it, Console treats
- * any non-undefined `file` option as non-TTY and disables color, which
- * defeats the point.
- */
-export declare function hostStream(host: TerminalHost): ConsoleSink;

package/dist/host/host-stream.js

@@ -1,35 +0,0 @@
-/**
- * hostStream — adapt a `TerminalHost` into the narrow Writable surface that
- * Console (and Live) actually exercise.
- *
- * [LAW:types-are-the-program] The return type matches Console's `ConsoleSink`
- * exactly: a single `.write(chunk)` method whose return value Console never
- * inspects (so the type leaves it as `unknown`; this implementation happens
- * to return `true` to mirror Node's stream contract, but callers may not
- * rely on that). Anything wider would lie about what this adapter
- * implements; anything narrower would force a cast at the call site.
- * Calling `.pipe()`, `.cork()`, `.on('error')`, etc. is a programming error
- * that TypeScript will reject at compile time.
- *
- * [LAW:locality-or-seam] Console + Live access their sink only via `.write()`
- * — verified in src/core/console.ts (one `_file.write` call) and
- * src/renderables/live.ts (every `this._console.file.write(...)` site). So
- * this narrow surface is the entire contract they need.
- */
-/**
- * Wrap a `TerminalHost` so its output can be threaded into `Console` via the
- * existing `file:` option. The returned object implements `.write()` only —
- * exactly the surface Console + Live touch.
- *
- * Pair with `forceTerminal: true` on the Console — without it, Console treats
- * any non-undefined `file` option as non-TTY and disables color, which
- * defeats the point.
- */
-export function hostStream(host) {
-    return {
-        write(chunk) {
-            host.write(chunk);
-            return true;
-        },
-    };
-}

package/dist/host/index.d.ts

@@ -1,3 +0,0 @@
-export { BrowserTerminalHost } from "./terminal-host.js";
-export type { TerminalHost, TerminalSize, DataHandler, ResizeHandler, BrowserTerminalHostOptions, XtermTerminal, XtermDisposable, XtermResizeEvent, } from "./terminal-host.js";
-export { hostStream } from "./host-stream.js";

package/dist/host/index.js

@@ -1,2 +0,0 @@
-export { BrowserTerminalHost } from "./terminal-host.js";
-export { hostStream } from "./host-stream.js";

package/dist/host/terminal-host.d.ts

@@ -1,143 +0,0 @@
-/**
- * TerminalHost — the capability seam between the interactive runtime and its
- * I/O environment.
- *
- * [LAW:locality-or-seam] The missing seam *was* the missing type. Before this
- * type existed, Screen and EventRouter reached for ambient `process.stdin`/
- * `process.stdout`, which crystallised them to node. With a `TerminalHost`
- * value flowing across one boundary, the same runtime code runs against any
- * implementation — node's TTY (`NodeTerminalHost`, on the `node/terminal-host`
- * subpath) or a browser xterm.js terminal (`BrowserTerminalHost`, below).
- *
- * [LAW:dataflow-not-control-flow] The runtime never branches on "am I in
- * node or browser." The host is the value that differs; the code path is
- * the same. Variability lives in which host is constructed at the program
- * entry, not in any `if` inside the runtime.
- *
- * [LAW:one-way-deps] The interface and the browser host live here, on the
- * `host` subpath; the node host lives in `src/node/terminal-host.ts`, behind
- * its own subpath, because it reads `process.stdin` / `process.stdout`. The
- * dependency runs one way — the node adapter imports this seam; nothing here
- * imports the adapter — so importing a browser-facing entry point cannot
- * reach the ambient `process` global by any path, rather than merely not
- * reaching it in practice. `test/seam/browser-safe.test.ts` is what holds
- * that direction; who reads the host at all is `HOST_ACCESS` in
- * `test/seam/ambient-process.ts`, and neither list is repeated here.
- *
- * [LAW:decomposition] This seam is not part of the interactive layer, which is
- * why it is not in it. It sits below `src/widgets/` and imports nothing from
- * it, so a program that wants to write bytes through a host — every non-
- * interactive consumer — reaches one without loading the widget set or its
- * `mobx` dependency.
- *
- * [boundaries: capabilities over context] A `TerminalHost` grants exactly
- * the I/O capabilities the runtime needs: write bytes, read input, query
- * size, observe resize, switch raw mode, lifecycle. It is not an
- * omniscient handle to "the process."
- */
-import type { Unsubscribe } from "../core/subscription.js";
-export interface TerminalSize {
-    readonly cols: number;
-    readonly rows: number;
-}
-export type DataHandler = (chunk: Uint8Array | string) => void;
-export type ResizeHandler = (size: TerminalSize) => void;
-export interface TerminalHost {
-    /**
-     * Write raw bytes (or UTF-8 text) to the terminal. The byte sequence is
-     * written verbatim; no escape interpretation, no framing.
-     */
-    write(data: Uint8Array | string): void;
-    /**
-     * Subscribe to input data. The host emits whatever its underlying
-     * transport produces (Buffer on node, string on browser xterm.js); the
-     * runtime's parser accepts either.
-     */
-    onData(handler: DataHandler): Unsubscribe;
-    /**
-     * Subscribe to terminal resize events. The handler fires with the new
-     * size after a resize is observed.
-     */
-    onResize(handler: ResizeHandler): Unsubscribe;
-    /** Current terminal size in cells. Always returns a valid size. */
-    size(): TerminalSize;
-    /**
-     * Enable or disable raw mode on the input side. Implementations whose
-     * transport has no "cooked" mode (xterm.js, non-TTY pipes) silently
-     * no-op so callers don't need to branch on capability.
-     */
-    setRawMode(raw: boolean): void;
-    /**
-     * Whether the host is connected to a real interactive terminal. Drives
-     * default option values (e.g. `manageCursor`, `manageRawMode`) in the
-     * runtime; non-TTY hosts default those features off.
-     */
-    readonly isTTY: boolean;
-    /**
-     * Begin the host's lifecycle. Implementations attach whatever resources
-     * they own — or no-op when there is nothing to attach. Idempotent. See
-     * the concrete host's own JSDoc for what its `start()` actually does:
-     * `NodeTerminalHost` and `BrowserTerminalHost` both no-op because their
-     * underlying transports (process streams; a caller-managed xterm.js
-     * Terminal) are already live by the time the host is constructed.
-     */
-    start(): void;
-    /**
-     * Stop the host's lifecycle. Pairs with `start`. Idempotent. After
-     * `stop()`, the host releases its own subscriptions to the underlying
-     * transport and clears its handler sets; the transport itself is not
-     * torn down (that is the caller's concern — process streams persist;
-     * an xterm.js Terminal is disposed by the caller). Re-subscribing via
-     * `onData` / `onResize` after `stop()` re-engages the host.
-     */
-    stop(): void;
-}
-/**
- * Subset of xterm.js's `Terminal` surface the browser host depends on.
- *
- * [LAW:locality-or-seam] Declaring the dependency by *shape* — rather than
- * importing xterm.js's types — keeps this package free of an xterm.js
- * dev-dep at the type level, lets the browser-bundle pipeline (downstream
- * ticket) pin whichever xterm.js version it wants, and lets unit tests
- * pass a hand-built fake: ask for exactly the capabilities the host uses,
- * no more.
- */
-export interface XtermDisposable {
-    dispose(): void;
-}
-export interface XtermResizeEvent {
-    cols: number;
-    rows: number;
-}
-export interface XtermTerminal {
-    readonly cols: number;
-    readonly rows: number;
-    write(data: Uint8Array | string): void;
-    onData(handler: (data: string) => void): XtermDisposable;
-    onResize(handler: (size: XtermResizeEvent) => void): XtermDisposable;
-}
-export interface BrowserTerminalHostOptions {
-    /**
-     * The xterm.js `Terminal` instance to wrap. The caller is responsible
-     * for its DOM lifecycle (`terminal.open(element)`, `terminal.dispose()`)
-     * — the host only owns its own subscriber lifecycle, exactly mirroring
-     * `NodeTerminalHost`'s relationship to `process.stdin`/`process.stdout`.
-     */
-    terminal: XtermTerminal;
-}
-export declare class BrowserTerminalHost implements TerminalHost {
-    private readonly terminal;
-    private readonly dataHandlers;
-    private readonly resizeHandlers;
-    private dataSubscription;
-    private resizeSubscription;
-    constructor(options: BrowserTerminalHostOptions);
-    get isTTY(): boolean;
-    write(data: Uint8Array | string): void;
-    size(): TerminalSize;
-    setRawMode(_raw: boolean): void;
-    onData(handler: DataHandler): Unsubscribe;
-    onResize(handler: ResizeHandler): Unsubscribe;
-    start(): void;
-    stop(): void;
-}

package/dist/host/terminal-host.js

@@ -1,132 +0,0 @@
-/**
- * TerminalHost — the capability seam between the interactive runtime and its
- * I/O environment.
- *
- * [LAW:locality-or-seam] The missing seam *was* the missing type. Before this
- * type existed, Screen and EventRouter reached for ambient `process.stdin`/
- * `process.stdout`, which crystallised them to node. With a `TerminalHost`
- * value flowing across one boundary, the same runtime code runs against any
- * implementation — node's TTY (`NodeTerminalHost`, on the `node/terminal-host`
- * subpath) or a browser xterm.js terminal (`BrowserTerminalHost`, below).
- *
- * [LAW:dataflow-not-control-flow] The runtime never branches on "am I in
- * node or browser." The host is the value that differs; the code path is
- * the same. Variability lives in which host is constructed at the program
- * entry, not in any `if` inside the runtime.
- *
- * [LAW:one-way-deps] The interface and the browser host live here, on the
- * `host` subpath; the node host lives in `src/node/terminal-host.ts`, behind
- * its own subpath, because it reads `process.stdin` / `process.stdout`. The
- * dependency runs one way — the node adapter imports this seam; nothing here
- * imports the adapter — so importing a browser-facing entry point cannot
- * reach the ambient `process` global by any path, rather than merely not
- * reaching it in practice. `test/seam/browser-safe.test.ts` is what holds
- * that direction; who reads the host at all is `HOST_ACCESS` in
- * `test/seam/ambient-process.ts`, and neither list is repeated here.
- *
- * [LAW:decomposition] This seam is not part of the interactive layer, which is
- * why it is not in it. It sits below `src/widgets/` and imports nothing from
- * it, so a program that wants to write bytes through a host — every non-
- * interactive consumer — reaches one without loading the widget set or its
- * `mobx` dependency.
- *
- * [boundaries: capabilities over context] A `TerminalHost` grants exactly
- * the I/O capabilities the runtime needs: write bytes, read input, query
- * size, observe resize, switch raw mode, lifecycle. It is not an
- * omniscient handle to "the process."
- */
-export class BrowserTerminalHost {
-    terminal;
-    dataHandlers = new Set();
-    resizeHandlers = new Set();
-    dataSubscription;
-    resizeSubscription;
-    constructor(options) {
-        this.terminal = options.terminal;
-    }
-    // [LAW:dataflow-not-control-flow] xterm.js is always an interactive
-    // terminal — there is no "non-TTY" code path in the browser. The
-    // runtime never branches on the value; this is the only sensible
-    // constant for this host.
-    get isTTY() {
-        return true;
-    }
-    write(data) {
-        this.terminal.write(data);
-    }
-    size() {
-        return { cols: this.terminal.cols, rows: this.terminal.rows };
-    }
-    // [LAW:dataflow-not-control-flow] xterm.js delivers keystrokes raw
-    // unconditionally — there is no cooked mode to toggle. The no-op
-    // matches the TerminalHost contract's documented "silently no-op when
-    // the transport has no cooked mode," so callers stay uniform across
-    // hosts. (Mirror: NodeTerminalHost on a non-TTY stream takes the same
-    // no-op path via the optional-chain in `applyRawMode`.)
-    setRawMode(_raw) { }
-    // [LAW:single-enforcer] One underlying `terminal.onData` subscription
-    // fans out to every host-level handler — the same lazy-attach,
-    // last-unsubscribe-detaches shape as NodeTerminalHost.onData. The
-    // runtime never sees the underlying subscription; it sees a single
-    // uniform `(handler) => Unsubscribe` API across hosts.
-    onData(handler) {
-        this.dataHandlers.add(handler);
-        if (!this.dataSubscription) {
-            this.dataSubscription = this.terminal.onData((chunk) => {
-                for (const h of this.dataHandlers)
-                    h(chunk);
-            });
-        }
-        return () => {
-            this.dataHandlers.delete(handler);
-            if (this.dataHandlers.size === 0 && this.dataSubscription) {
-                this.dataSubscription.dispose();
-                this.dataSubscription = undefined;
-            }
-        };
-    }
-    onResize(handler) {
-        this.resizeHandlers.add(handler);
-        if (!this.resizeSubscription) {
-            this.resizeSubscription = this.terminal.onResize((size) => {
-                const snapshot = { cols: size.cols, rows: size.rows };
-                for (const h of this.resizeHandlers)
-                    h(snapshot);
-            });
-        }
-        return () => {
-            this.resizeHandlers.delete(handler);
-            if (this.resizeHandlers.size === 0 && this.resizeSubscription) {
-                this.resizeSubscription.dispose();
-                this.resizeSubscription = undefined;
-            }
-        };
-    }
-    start() {
-        // [LAW:one-source-of-truth] The host does NOT own the terminal's DOM
-        // lifecycle (`terminal.open` / `terminal.dispose`). That is the
-        // caller's responsibility, exactly as NodeTerminalHost does not own
-        // `process.stdin`/`process.stdout`. start() is here so the runtime
-        // can call it uniformly across hosts; for this host there is
-        // nothing to do at this seam.
-    }
-    stop() {
-        // [LAW:one-source-of-truth] Symmetric teardown mirroring
-        // NodeTerminalHost.stop: drop every host-level subscriber and
-        // dispose the underlying terminal subscriptions. The terminal
-        // itself stays alive — re-subscribing via onData/onResize after
-        // stop() works, since the lazy-attach path re-creates the
-        // subscription on next subscribe. Calling stop() repeatedly is
-        // safe — the subscription guards make later calls no-ops.
-        if (this.dataSubscription) {
-            this.dataSubscription.dispose();
-            this.dataSubscription = undefined;
-        }
-        if (this.resizeSubscription) {
-            this.resizeSubscription.dispose();
-            this.resizeSubscription = undefined;
-        }
-        this.dataHandlers.clear();
-        this.resizeHandlers.clear();
-    }
-}

package/dist/index.d.ts

@@ -1,87 +0,0 @@
-export { cellLen, setCellSize, splitText, chopCells, cellFit, asCellCol, asCodePoint, } from "./core/cells.js";
-export type { CellCol, CodeUnit, CodePoint } from "./core/cells.js";
-export { ColorRgba, ColorTable, ColorDepth, ColorSpec, ColorParseError, TerminalTheme, parseRgbHex, parseRgbaHex, blendRgb, resolveColorSystem, detectColorSystem, STANDARD_TABLE, EIGHT_BIT_TABLE, WINDOWS_TABLE, ANSI_COLOR_NAMES, } from "./core/color.js";
-export type { DetectColorOptions } from "./core/color.js";
-export { Oklch, IDENTITY, INVERT_LIGHTNESS, isIdentityKey, } from "./core/oklch.js";
-export type { ThemeKey, OklchWeights } from "./core/oklch.js";
-export { Palette } from "./themes/palette.js";
-export { resolveColorRef, parseHexColor, ColorRefError, HEX_COLOR_RE, } from "./themes/colorRef.js";
-export { buildPalette } from "./themes/buildPalette.js";
-export type { BaseColors } from "./themes/buildPalette.js";
-export { DEFAULT_TERMINAL_THEME, MONOKAI, SVG_EXPORT_THEME, NORD, GRUVBOX, DRACULA, TOKYO_NIGHT, FLEXOKI, CYBERPUNK, CATPPUCCIN_MOCHA, CATPPUCCIN_LATTE, CATPPUCCIN_FRAPPE, CATPPUCCIN_MACCHIATO, SOLARIZED_DARK, SOLARIZED_LIGHT, ROSE_PINE, ROSE_PINE_MOON, ROSE_PINE_DAWN, ATOM_ONE_DARK, ATOM_ONE_LIGHT, TEXTUAL_DARK, TEXTUAL_LIGHT, TEXTUAL_ANSI, } from "./themes/terminalThemes.js";
-export { getThemePalette, listThemePalettes } from "./themes/registry.js";
-export type { ThemeName } from "./themes/registry.js";
-export { transposePalette, themeKeyForRoot, isAnchored, ANCHORED_ROOTS, } from "./themes/transpose.js";
-export { lighten, darken, relativeLuminance, contrastRatio, contrastFor, ensureContrast, ensureDrawn, drawnColour, } from "./themes/colorMath.js";
-export { ColorRamp, RAMP_EASING_NAMES, parseRampEasing } from "./themes/ramp.js";
-export type { ColorStop, RampEasing } from "./themes/ramp.js";
-export { Style, StyleSyntaxError, StyleStack, Theme, NULL_STYLE, DEFAULT_STYLES, } from "./core/style.js";
-export type { StyleOptions } from "./core/style.js";
-export { Segment, ControlType, } from "./core/segment.js";
-export type { ControlCode } from "./core/segment.js";
-export { Box } from "./core/box.js";
-export type { EdgeChars, ContentChars, RowLevel, SubstituteOptions } from "./core/box.js";
-export { ASCII, ASCII2, ASCII_DOUBLE_HEAD, SQUARE, SQUARE_DOUBLE_HEAD, MINIMAL, MINIMAL_HEAVY_HEAD, MINIMAL_DOUBLE_HEAD, SIMPLE, SIMPLE_HEAD, SIMPLE_HEAVY, HORIZONTALS, ROUNDED, HEAVY, HEAVY_EDGE, HEAVY_HEAD, DOUBLE, DOUBLE_EDGE, MARKDOWN, } from "./core/box.js";
-export { isRenderable, isMeasurable, withCellWidth, withBoundedWidth, } from "./core/protocol.js";
-export type { RenderOptions, Renderable, Measurable, StyleErrorHandler, } from "./core/protocol.js";
-export type { Unsubscribe } from "./core/subscription.js";
-export { Measurement, measureRenderables } from "./core/measure.js";
-export { Span, RichText } from "./core/text.js";
-export type { RichTextOptions } from "./core/text.js";
-export { Strip, PowerlineJoiner, SEAM_MIN_DELTA_E, POWERLINE_JOINER_GLYPHS, CapsuleJoiner, PlainJoiner, GradientJoiner, } from "./core/strip.js";
-export type { StyledRenderable, Joiner, PowerlineJoinerOptions, CapsuleJoinerOptions, PlainJoinerOptions, GradientJoinerOptions, } from "./core/strip.js";
-export { renderToString, segmentToString, segmentsToString, } from "./core/render.js";
-export type { RenderToStringOptions } from "./core/render.js";
-export { OSC8, osc8Sequences } from "./core/osc8.js";
-export type { Osc8Sequence } from "./core/osc8.js";
-export { MarkupRegistry, globalMarkupRegistry, renderMarkup, } from "./core/markup.js";
-export type { MarkupTagContext, MarkupTagHandler, RenderMarkupOptions, } from "./core/markup.js";
-export { EMOJI, emojiReplace, Emoji, NoEmoji } from "./core/emoji.js";
-export { MarkupError, MarkupSyntaxError, escape as escapeMarkup } from "./core/markup.js";
-export { Highlighter, NullHighlighter, RegexHighlighter, ReprHighlighter, JSONHighlighter, ISO8601Highlighter, } from "./core/highlighter.js";
-export { Pretty } from "./core/pretty.js";
-export type { PrettyOptions } from "./core/pretty.js";
-export { JSONRenderable } from "./core/json.js";
-export type { JSONOptions } from "./core/json.js";
-export { SPINNERS, DEFAULT_SPINNER } from "./core/spinnerData.js";
-export type { SpinnerData } from "./core/spinnerData.js";
-export { Console } from "./core/console.js";
-export type { ConsoleOptions, ConsoleSink, ConsoleStream, ConsoleEnvironment, PrintOptions, } from "./core/console.js";
-export { Constrain } from "./renderables/constrain.js";
-export { Align } from "./renderables/align.js";
-export type { Alignment } from "./renderables/align.js";
-export { Padding } from "./renderables/padding.js";
-export type { PaddingDimensions } from "./renderables/padding.js";
-export { Rule } from "./renderables/rule.js";
-export type { RuleAlign, RuleOptions } from "./renderables/rule.js";
-export { Panel } from "./renderables/panel.js";
-export type { PanelOptions } from "./renderables/panel.js";
-export { Group } from "./renderables/group.js";
-export { ProgressBar } from "./renderables/progressBar.js";
-export type { ProgressBarOptions } from "./renderables/progressBar.js";
-export { Spinner } from "./renderables/spinner.js";
-export type { SpinnerOptions } from "./renderables/spinner.js";
-export { Table, Column } from "./renderables/table.js";
-export type { TableOptions, ColumnOptions } from "./renderables/table.js";
-export { Tree } from "./renderables/tree.js";
-export type { TreeOptions } from "./renderables/tree.js";
-export { Columns } from "./renderables/columns.js";
-export type { ColumnsOptions } from "./renderables/columns.js";
-export { FlexStrip } from "./renderables/flexStrip.js";
-export type { FlexStripOptions, FlexAlign } from "./renderables/flexStrip.js";
-export { Live } from "./renderables/live.js";
-export type { LiveOptions } from "./renderables/live.js";
-export { Status } from "./renderables/status.js";
-export type { StatusOptions } from "./renderables/status.js";
-export { Progress, TextColumn, BarColumn, TaskProgressColumn, TimeRemainingColumn, TimeElapsedColumn, SpinnerColumn, MofNCompleteColumn, track, } from "./renderables/progress.js";
-export type { ProgressOptions, TaskOptions, TaskUpdateOptions } from "./renderables/progress.js";
-export { Prompt, IntPrompt, FloatPrompt, Confirm } from "./renderables/prompt.js";
-export type { PromptInput, PromptOptions } from "./renderables/prompt.js";
-export { Traceback } from "./renderables/traceback.js";
-export type { TracebackOptions } from "./renderables/traceback.js";
-export { Syntax } from "./renderables/syntax.js";
-export type { SyntaxOptions } from "./renderables/syntax.js";
-export { Markdown } from "./renderables/markdown.js";
-export type { MarkdownOptions } from "./renderables/markdown.js";
-export { Layout } from "./renderables/layout.js";
-export type { LayoutOptions } from "./renderables/layout.js";