@textui/core 0.1.0

package/dist/util/text.d.ts

@@ -0,0 +1,65 @@
+import type { TextWrap } from '../types/style.js';
+/**
+ * Split into grapheme clusters. Falls back to code points without Intl.
+ *
+ * The ASCII path skips `Intl.Segmenter` entirely. It is not a micro-tweak:
+ * painting walks the graphemes of every string on screen every frame, and
+ * segmentation was measuring at about a sixth of the frame in a list of plain
+ * ASCII rows - all of it spent proving that `r`, `o` and `w` are one character
+ * each.
+ */
+export declare function graphemes(text: string): string[];
+/**
+ * Width of one grapheme cluster in cells. A cluster is measured by its base
+ * character; an emoji followed by VS16 counts as wide.
+ */
+export declare function graphemeWidth(cluster: string): number;
+/** Width of a string in terminal cells. */
+export declare function stringWidth(text: string): number;
+/** Take at most `width` cells from the front. Never splits a wide grapheme. */
+export declare function sliceByWidth(text: string, width: number): string;
+/**
+ * The slice of `text` covering display columns `[start, start + width)`.
+ *
+ * Cutting by index is wrong the moment a line contains a wide character: the
+ * horizontal scroll would drift against the gutter, one cell per CJK glyph.
+ * A wide grapheme straddling either edge is dropped rather than split, because
+ * half of one cannot be drawn.
+ */
+export declare function sliceColumns(text: string, start: number, width: number): string;
+/**
+ * Replace tabs with spaces to the next tab stop.
+ *
+ * A terminal cell is one column, so a raw tab is one blank cell and every
+ * indented line lands in a different place than it does in an editor. Doing
+ * this before highlighting keeps token offsets and screen columns the same
+ * number.
+ */
+export declare function expandTabs(text: string, tabWidth?: number): string;
+export type TruncateSide = 'end' | 'start' | 'middle';
+/** Fit into `width` cells, marking the cut with `ellipsis`. */
+export declare function truncate(text: string, width: number, ellipsis?: string, side?: TruncateSide): string;
+/** Pad to exactly `width` cells. Over-long input is returned unchanged. */
+export declare function padTo(text: string, width: number, align?: 'left' | 'center' | 'right', fill?: string): string;
+/** Fit to exactly `width`: truncate when long, pad when short. */
+export declare function fitTo(text: string, width: number, align?: 'left' | 'center' | 'right', ellipsis?: string): string;
+export type WrapMode = 'none' | 'word' | 'char';
+/**
+ * The end a `TextWrap` cuts at, or `undefined` when it wraps instead.
+ *
+ * The wrapping modes and the truncating ones live in one union because they
+ * answer one question - what happens at the edge - and a component that had to
+ * take both a `wrap` and a `truncate` prop could be handed the two answers at
+ * once. These two helpers are how the union is taken apart again.
+ */
+export declare function truncateSideOf(wrap: TextWrap | undefined): TruncateSide | undefined;
+/** The mode `wrapText` should run in. A truncating text does not wrap at all. */
+export declare function wrapModeOf(wrap: TextWrap | undefined): WrapMode;
+/** Break into lines of at most `width` cells. Honours existing newlines. */
+export declare function wrapText(text: string, width: number, mode?: WrapMode): string[];
+export declare function stripAnsi(text: string): string;
+/** Remove control characters that would corrupt the frame. Keeps newlines. */
+export declare function sanitize(text: string): string;
+/** Repeat a grapheme to exactly `width` cells (wide chars land short). */
+export declare function repeatToWidth(char: string, width: number): string;
+//# sourceMappingURL=text.d.ts.map

package/dist/util/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../src/util/text.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AA8BlD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAShD;AA8ED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAsBrD;AAED,2CAA2C;AAC3C,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAQhD;AAED,+EAA+E;AAC/E,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAYhE;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAgC/E;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,SAAI,GAAG,MAAM,CAuB7D;AAED,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,OAAO,GAAG,QAAQ,CAAC;AAEtD,+DAA+D;AAC/D,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,QAAQ,SAAM,EACd,IAAI,GAAE,YAAoB,GACzB,MAAM,CAkCR;AAED,2EAA2E;AAC3E,wBAAgB,KAAK,CACnB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,KAAK,GAAE,MAAM,GAAG,QAAQ,GAAG,OAAgB,EAC3C,IAAI,SAAM,GACT,MAAM,CAQR;AAED,kEAAkE;AAClE,wBAAgB,KAAK,CACnB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,KAAK,GAAE,MAAM,GAAG,QAAQ,GAAG,OAAgB,EAC3C,QAAQ,SAAM,GACb,MAAM,CAER;AAED,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAEhD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAOnF;AAED,iFAAiF;AACjF,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAE/D;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,QAAiB,GAAG,MAAM,EAAE,CAuDvF;AAOD,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,8EAA8E;AAC9E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG7C;AAED,0EAA0E;AAC1E,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAIjE"}

package/dist/util/text.js

@@ -0,0 +1,419 @@
+/**
+ * Terminal text measurement.
+ *
+ * Everything the layout engine knows about size comes from here, so the rules
+ * are worth stating: a cell holds one grapheme cluster, a grapheme is 0, 1 or
+ * 2 cells wide, and a string's width is the sum - never its `.length`.
+ */
+const segmenter = typeof Intl !== 'undefined' && 'Segmenter' in Intl
+    ? new Intl.Segmenter(undefined, { granularity: 'grapheme' })
+    : null;
+/**
+ * True for a string that is entirely printable ASCII.
+ *
+ * Worth asking, because the answer is yes for very nearly all of it: source
+ * code, file names, labels, key hints. Every character is then one grapheme
+ * one cell wide, and none of the Unicode machinery below has anything to do.
+ */
+function isAscii(text) {
+    for (let i = 0; i < text.length; i++) {
+        const c = text.charCodeAt(i);
+        if (c < 0x20 || c > 0x7e)
+            return false;
+    }
+    return true;
+}
+/**
+ * Split into grapheme clusters. Falls back to code points without Intl.
+ *
+ * The ASCII path skips `Intl.Segmenter` entirely. It is not a micro-tweak:
+ * painting walks the graphemes of every string on screen every frame, and
+ * segmentation was measuring at about a sixth of the frame in a list of plain
+ * ASCII rows - all of it spent proving that `r`, `o` and `w` are one character
+ * each.
+ */
+export function graphemes(text) {
+    if (text === '')
+        return [];
+    if (isAscii(text))
+        return text.split('');
+    if (segmenter) {
+        const out = [];
+        for (const { segment } of segmenter.segment(text))
+            out.push(segment);
+        return out;
+    }
+    return Array.from(text);
+}
+// Zero-width: combining marks, variation selectors, ZWJ, control chars.
+function isZeroWidth(cp) {
+    return (cp === 0x200b || cp === 0x200c || cp === 0x200d || cp === 0xfeff ||
+        (cp >= 0x0300 && cp <= 0x036f) ||
+        (cp >= 0x0483 && cp <= 0x0489) ||
+        (cp >= 0x0591 && cp <= 0x05bd) ||
+        (cp >= 0x0610 && cp <= 0x061a) ||
+        (cp >= 0x064b && cp <= 0x065f) ||
+        (cp >= 0x0e31 && cp <= 0x0e3a) ||
+        (cp >= 0x1ab0 && cp <= 0x1aff) ||
+        (cp >= 0x1dc0 && cp <= 0x1dff) ||
+        (cp >= 0x20d0 && cp <= 0x20f0) ||
+        (cp >= 0xfe00 && cp <= 0xfe0f) ||
+        (cp >= 0xfe20 && cp <= 0xfe2f) ||
+        (cp >= 0xe0100 && cp <= 0xe01ef));
+}
+// East Asian Wide + Fullwidth, and the emoji ranges that render double-width.
+function isWide(cp) {
+    return ((cp >= 0x1100 && cp <= 0x115f) ||
+        (cp >= 0x2e80 && cp <= 0x303e) ||
+        (cp >= 0x3041 && cp <= 0x33ff) ||
+        (cp >= 0x3400 && cp <= 0x4dbf) ||
+        (cp >= 0x4e00 && cp <= 0x9fff) ||
+        (cp >= 0xa000 && cp <= 0xa4cf) ||
+        (cp >= 0xac00 && cp <= 0xd7a3) ||
+        (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0xfe10 && cp <= 0xfe19) ||
+        (cp >= 0xfe30 && cp <= 0xfe6f) ||
+        (cp >= 0xff00 && cp <= 0xff60) ||
+        (cp >= 0xffe0 && cp <= 0xffe6) ||
+        // The pictograph blocks are *mostly* wide, and the exceptions matter.
+        // `1F300..1F64F` as one range called U+1F5C0 FOLDER two cells; Unicode
+        // says East Asian Width Neutral, and a terminal following wcwidth draws
+        // it in one. Those blocks are full of such symbols - the whole
+        // `1F5A5..1F5FA` run of them - and a glyph measured as two and drawn as
+        // one leaves the rest of the row shifted by a column.
+        //
+        // Generated from EastAsianWidth (Unicode 15.1), W and F only. A symbol
+        // that takes emoji presentation is handled by the VS16 rule below, which
+        // is the thing that actually makes one of these wide when it is wide.
+        (cp >= 0x1f300 && cp <= 0x1f320) ||
+        (cp >= 0x1f32d && cp <= 0x1f335) ||
+        (cp >= 0x1f337 && cp <= 0x1f37c) ||
+        (cp >= 0x1f37e && cp <= 0x1f393) ||
+        (cp >= 0x1f3a0 && cp <= 0x1f3ca) ||
+        (cp >= 0x1f3cf && cp <= 0x1f3d3) ||
+        (cp >= 0x1f3e0 && cp <= 0x1f3f0) ||
+        cp === 0x1f3f4 ||
+        (cp >= 0x1f3f8 && cp <= 0x1f43e) ||
+        cp === 0x1f440 ||
+        (cp >= 0x1f442 && cp <= 0x1f4fc) ||
+        (cp >= 0x1f4ff && cp <= 0x1f53d) ||
+        (cp >= 0x1f54b && cp <= 0x1f54e) ||
+        (cp >= 0x1f550 && cp <= 0x1f567) ||
+        cp === 0x1f57a ||
+        (cp >= 0x1f595 && cp <= 0x1f596) ||
+        cp === 0x1f5a4 ||
+        (cp >= 0x1f5fb && cp <= 0x1f64f) ||
+        (cp >= 0x1f90c && cp <= 0x1f93a) ||
+        (cp >= 0x1f93c && cp <= 0x1f945) ||
+        (cp >= 0x1f947 && cp <= 0x1f9ff) ||
+        (cp >= 0x1fa70 && cp <= 0x1fa7c) ||
+        (cp >= 0x1fa80 && cp <= 0x1fa88) ||
+        (cp >= 0x1fa90 && cp <= 0x1fabd) ||
+        (cp >= 0x1fabf && cp <= 0x1fac5) ||
+        (cp >= 0x1face && cp <= 0x1fadb) ||
+        (cp >= 0x1fae0 && cp <= 0x1fae8) ||
+        (cp >= 0x1faf0 && cp <= 0x1faf8) ||
+        (cp >= 0x20000 && cp <= 0x3fffd));
+}
+/**
+ * Width of one grapheme cluster in cells. A cluster is measured by its base
+ * character; an emoji followed by VS16 counts as wide.
+ */
+export function graphemeWidth(cluster) {
+    if (cluster === '')
+        return 0;
+    /*
+     * One printable ASCII character is one cell, and that is the overwhelming
+     * majority of every cluster this is ever asked about.
+     *
+     * The general path below builds two arrays - `Array.from` then `.map` - for
+     * every cluster, which is two allocations per cell per frame. Answering the
+     * common case from the character code costs nothing and allocates nothing.
+     */
+    if (cluster.length === 1) {
+        const only = cluster.charCodeAt(0);
+        if (only >= 0x20 && only <= 0x7e)
+            return 1;
+    }
+    const cps = Array.from(cluster).map((c) => c.codePointAt(0));
+    const base = cps[0];
+    if (base < 0x20 || base === 0x7f)
+        return 0;
+    if (isZeroWidth(base))
+        return 0;
+    // VS16 promotes a text-presentation symbol to emoji presentation.
+    if (cps.includes(0xfe0f))
+        return 2;
+    if (isWide(base))
+        return 2;
+    return 1;
+}
+/** Width of a string in terminal cells. */
+export function stringWidth(text) {
+    if (text === '')
+        return 0;
+    // Fast path: pure ASCII printable.
+    if (isAscii(text))
+        return text.length;
+    let w = 0;
+    for (const g of graphemes(text))
+        w += graphemeWidth(g);
+    return w;
+}
+/** Take at most `width` cells from the front. Never splits a wide grapheme. */
+export function sliceByWidth(text, width) {
+    if (width <= 0)
+        return '';
+    if (stringWidth(text) <= width)
+        return text;
+    let out = '';
+    let w = 0;
+    for (const g of graphemes(text)) {
+        const gw = graphemeWidth(g);
+        if (w + gw > width)
+            break;
+        out += g;
+        w += gw;
+    }
+    return out;
+}
+/**
+ * The slice of `text` covering display columns `[start, start + width)`.
+ *
+ * Cutting by index is wrong the moment a line contains a wide character: the
+ * horizontal scroll would drift against the gutter, one cell per CJK glyph.
+ * A wide grapheme straddling either edge is dropped rather than split, because
+ * half of one cannot be drawn.
+ */
+export function sliceColumns(text, start, width) {
+    if (width <= 0)
+        return '';
+    const end = start + width;
+    let column = 0;
+    let out = '';
+    for (const g of graphemes(text)) {
+        const gw = graphemeWidth(g);
+        if (gw === 0) {
+            // A combining mark belongs to the grapheme before it, if that survived.
+            if (out !== '')
+                out += g;
+            continue;
+        }
+        const next = column + gw;
+        if (next <= start) {
+            column = next;
+            continue;
+        }
+        if (column >= end)
+            break;
+        if (column >= start && next <= end) {
+            out += g;
+        }
+        else {
+            // A wide grapheme half inside the window becomes blanks for the half
+            // that shows. Splitting it is impossible and dropping it silently would
+            // slide the rest of the line one cell against the gutter.
+            out += ' '.repeat(Math.min(next, end) - Math.max(column, start));
+        }
+        column = next;
+    }
+    return out;
+}
+/**
+ * Replace tabs with spaces to the next tab stop.
+ *
+ * A terminal cell is one column, so a raw tab is one blank cell and every
+ * indented line lands in a different place than it does in an editor. Doing
+ * this before highlighting keeps token offsets and screen columns the same
+ * number.
+ */
+export function expandTabs(text, tabWidth = 4) {
+    if (!text.includes('\t'))
+        return text;
+    const width = Math.max(1, tabWidth);
+    return text
+        .split('\n')
+        .map((line) => {
+        if (!line.includes('\t'))
+            return line;
+        let out = '';
+        let column = 0;
+        for (const g of graphemes(line)) {
+            if (g === '\t') {
+                const advance = width - (column % width);
+                out += ' '.repeat(advance);
+                column += advance;
+                continue;
+            }
+            out += g;
+            column += graphemeWidth(g);
+        }
+        return out;
+    })
+        .join('\n');
+}
+/** Fit into `width` cells, marking the cut with `ellipsis`. */
+export function truncate(text, width, ellipsis = '…', side = 'end') {
+    const total = stringWidth(text);
+    if (total <= width)
+        return text;
+    if (width <= 0)
+        return '';
+    const ew = stringWidth(ellipsis);
+    if (width <= ew)
+        return sliceByWidth(ellipsis, width);
+    // A space either side of the ellipsis is a typographic mistake, not a cell
+    // of content, so the cut is tidied before the mark goes on. It also means a
+    // truncated string can come back narrower than `width`, which is correct:
+    // `width` is a limit, and nothing here is padding.
+    const keep = width - ew;
+    if (side === 'end')
+        return sliceByWidth(text, keep).trimEnd() + ellipsis;
+    const gs = graphemes(text);
+    if (side === 'start') {
+        let w = 0;
+        let i = gs.length;
+        while (i > 0 && w + graphemeWidth(gs[i - 1]) <= keep) {
+            i--;
+            w += graphemeWidth(gs[i]);
+        }
+        return ellipsis + gs.slice(i).join('').trimStart();
+    }
+    const left = Math.ceil(keep / 2);
+    const right = keep - left;
+    let w = 0;
+    let j = gs.length;
+    while (j > 0 && w + graphemeWidth(gs[j - 1]) <= right) {
+        j--;
+        w += graphemeWidth(gs[j]);
+    }
+    return sliceByWidth(text, left).trimEnd() + ellipsis + gs.slice(j).join('').trimStart();
+}
+/** Pad to exactly `width` cells. Over-long input is returned unchanged. */
+export function padTo(text, width, align = 'left', fill = ' ') {
+    const w = stringWidth(text);
+    if (w >= width)
+        return text;
+    const pad = width - w;
+    if (align === 'left')
+        return text + fill.repeat(pad);
+    if (align === 'right')
+        return fill.repeat(pad) + text;
+    const left = Math.floor(pad / 2);
+    return fill.repeat(left) + text + fill.repeat(pad - left);
+}
+/** Fit to exactly `width`: truncate when long, pad when short. */
+export function fitTo(text, width, align = 'left', ellipsis = '…') {
+    return padTo(truncate(text, width, ellipsis), width, align);
+}
+/**
+ * The end a `TextWrap` cuts at, or `undefined` when it wraps instead.
+ *
+ * The wrapping modes and the truncating ones live in one union because they
+ * answer one question - what happens at the edge - and a component that had to
+ * take both a `wrap` and a `truncate` prop could be handed the two answers at
+ * once. These two helpers are how the union is taken apart again.
+ */
+export function truncateSideOf(wrap) {
+    switch (wrap) {
+        case 'truncate':
+        case 'truncate-end': return 'end';
+        case 'truncate-start': return 'start';
+        case 'truncate-middle': return 'middle';
+        default: return undefined;
+    }
+}
+/** The mode `wrapText` should run in. A truncating text does not wrap at all. */
+export function wrapModeOf(wrap) {
+    return wrap === 'word' || wrap === 'char' ? wrap : 'none';
+}
+/** Break into lines of at most `width` cells. Honours existing newlines. */
+export function wrapText(text, width, mode = 'word') {
+    if (width <= 0)
+        return [];
+    const paragraphs = text.split('\n');
+    if (mode === 'none')
+        return paragraphs;
+    const out = [];
+    for (const para of paragraphs) {
+        if (para === '') {
+            out.push('');
+            continue;
+        }
+        if (stringWidth(para) <= width) {
+            out.push(para);
+            continue;
+        }
+        if (mode === 'char') {
+            let rest = para;
+            while (stringWidth(rest) > width) {
+                const head = sliceByWidth(rest, width);
+                out.push(head);
+                rest = rest.slice(head.length);
+            }
+            if (rest !== '')
+                out.push(rest);
+            continue;
+        }
+        // word wrap; a word longer than the line falls back to char wrap
+        let line = '';
+        let lineW = 0;
+        for (const word of para.split(/(\s+)/)) {
+            if (word === '')
+                continue;
+            const ww = stringWidth(word);
+            const isSpace = /^\s+$/.test(word);
+            if (lineW + ww <= width) {
+                line += word;
+                lineW += ww;
+                continue;
+            }
+            if (isSpace) {
+                out.push(line.trimEnd());
+                line = '';
+                lineW = 0;
+                continue;
+            }
+            if (line !== '') {
+                out.push(line.trimEnd());
+                line = '';
+                lineW = 0;
+            }
+            if (ww <= width) {
+                line = word;
+                lineW = ww;
+                continue;
+            }
+            let rest = word;
+            while (stringWidth(rest) > width) {
+                const head = sliceByWidth(rest, width);
+                out.push(head);
+                rest = rest.slice(head.length);
+            }
+            line = rest;
+            lineW = stringWidth(rest);
+        }
+        if (line !== '')
+            out.push(line.trimEnd());
+    }
+    return out;
+}
+// CSI / OSC / SS2 / SS3 and friends. Input sanitation only, never output.
+const ANSI_RE = 
+// eslint-disable-next-line no-control-regex
+/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~]|\][^\x07\x1B]*(?:\x07|\x1B\\))/g;
+export function stripAnsi(text) {
+    return text.replace(ANSI_RE, '');
+}
+/** Remove control characters that would corrupt the frame. Keeps newlines. */
+export function sanitize(text) {
+    // eslint-disable-next-line no-control-regex
+    return stripAnsi(text).replace(/[\x00-\x08\x0B-\x1F\x7F]/g, '');
+}
+/** Repeat a grapheme to exactly `width` cells (wide chars land short). */
+export function repeatToWidth(char, width) {
+    if (width <= 0)
+        return '';
+    const w = graphemeWidth(char) || 1;
+    return char.repeat(Math.max(0, Math.floor(width / w)));
+}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@textui/core",
+  "version": "0.1.0",
+  "description": "Graph-mounted terminal UI runtime - store, registries, renderer, host primitives",
+  "keywords": [
+    "terminal",
+    "tui",
+    "cli",
+    "jsx",
+    "ui",
+    "runtime",
+    "ansi",
+    "text-ui",
+    "console",
+    "no-dependencies"
+  ],
+  "homepage": "https://softov.github.io/textui/",
+  "bugs": {
+    "url": "https://github.com/softov/textui/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/softov/textui.git",
+    "directory": "packages/core"
+  },
+  "license": "MIT",
+  "author": "Softov <softov@brbyte.com>",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js"
+    },
+    "./jsx-runtime": {
+      "types": "./dist/jsx/jsx-runtime.d.ts",
+      "import": "./dist/jsx/jsx-runtime.js"
+    },
+    "./jsx-dev-runtime": {
+      "types": "./dist/jsx/jsx-dev-runtime.d.ts",
+      "import": "./dist/jsx/jsx-dev-runtime.js"
+    },
+    "./themes": {
+      "types": "./dist/themes/index.d.ts",
+      "import": "./dist/themes/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}

package/src/adapters/index.ts

@@ -0,0 +1,11 @@
+/**
+ * Adapters.
+ *
+ * Nothing here is registered by default. An adapter is a choice - what a kind
+ * means, what opens it, what can be done to it - and choices belong to the
+ * application, not to the library that ships them.
+ *
+ * The adapters that have an opinion about *content* live in
+ * `@textui/documents`, beside the buffers they read and write.
+ */
+export {};