@tuidom/core 0.1.0

package/dist/common/measureTextWidth.js

@@ -0,0 +1,43 @@
+import { getCharDisplayWidth, getGraphemeDisplayWidth } from "./unicodeWidth.js";
+const segmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
+const DEFAULT_TAB_SIZE = 4;
+/**
+ * Display width of `raw` in terminal columns.
+ *
+ * Returns **exactly** the same number as
+ * `new DisplayLine(raw, tabSize, stopAfter).displayWidth`, but without
+ * allocating the per-grapheme slot array or the offset→column `Int32Array`.
+ * Used by the horizontal-scrollbar width cache ({@link LineWidthCache}), where
+ * only the width matters and building a full `DisplayLine` per document line is
+ * what freezes the editor on long lines.
+ *
+ * `stopAfter` bounds the scan: any grapheme whose start offset is at or past it
+ * is ignored (segmentation is lazy, so the tail is never touched). An extreme
+ * line therefore costs O(stopAfter), not O(length) — mirroring VS Code's
+ * `stopRenderingLineAfter`.
+ *
+ * The per-grapheme width rules are kept in lock-step with `DisplayLine`'s
+ * constructor: tab expands to the next tab stop, `\r` is zero-width, single
+ * code units go through {@link getCharDisplayWidth}, multi-code-unit clusters
+ * through {@link getGraphemeDisplayWidth}.
+ */
+export function measureTextWidth(raw, tabSize = DEFAULT_TAB_SIZE, stopAfter = Infinity) {
+    let column = 0;
+    for (const { segment, index } of segmenter.segment(raw)) {
+        if (index >= stopAfter)
+            break;
+        if (segment === "\t") {
+            column += tabSize - (column % tabSize);
+        }
+        else if (segment === "\r") {
+            // zero width
+        }
+        else if (segment.length === 1) {
+            column += getCharDisplayWidth(segment.charCodeAt(0));
+        }
+        else {
+            column += getGraphemeDisplayWidth(segment);
+        }
+    }
+    return column;
+}

package/dist/common/styleFlags.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Bit-mask flags for terminal text styles.
+ *
+ * Combine with bitwise OR:   `StyleFlags.Bold | StyleFlags.Italic`
+ * Test with bitwise AND:     `(style & StyleFlags.Bold) !== 0`
+ */
+export declare const StyleFlags: {
+    readonly None: 0;
+    readonly Bold: number;
+    readonly Italic: number;
+    readonly Underline: number;
+    readonly Undercurl: number;
+    readonly Inverse: number;
+    readonly Strikethrough: number;
+    readonly Dim: number;
+};
+export type StyleFlags = (typeof StyleFlags)[keyof typeof StyleFlags];

package/dist/common/styleFlags.js

@@ -0,0 +1,16 @@
+/**
+ * Bit-mask flags for terminal text styles.
+ *
+ * Combine with bitwise OR:   `StyleFlags.Bold | StyleFlags.Italic`
+ * Test with bitwise AND:     `(style & StyleFlags.Bold) !== 0`
+ */
+export const StyleFlags = {
+    None: 0,
+    Bold: 1 << 0, // 1
+    Italic: 1 << 1, // 2
+    Underline: 1 << 2, // 4
+    Undercurl: 1 << 3, // 8
+    Inverse: 1 << 4, // 16
+    Strikethrough: 1 << 5, // 32
+    Dim: 1 << 6, // 64
+};

package/dist/common/textTruncation.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Truncate `text` to `maxWidth` columns, putting the ellipsis at the END:
+ *   "VeryLongFileName.ts" → "VeryLongFile…"
+ *
+ * The kept prefix is preserved grapheme-for-grapheme (so byte offsets of the
+ * prefix are unchanged — important for match highlighting). Returns `text`
+ * unchanged when it already fits, and "" when even the ellipsis doesn't fit.
+ */
+export declare function truncateEnd(text: string, maxWidth: number, ellipsis?: string): string;
+/**
+ * Truncate `text` to `maxWidth` columns, putting the ellipsis in the MIDDLE:
+ *   "VeryLongFileName" → "VeryL…Name"
+ *
+ * Returns `text` unchanged when it fits, the ellipsis alone when only one
+ * column (its width) is available, and "" when even that doesn't fit.
+ */
+export declare function truncateMiddle(text: string, maxWidth: number, ellipsis?: string): string;
+/**
+ * Abbreviate a `/`-separated path to fit in `maxWidth` columns, keeping the
+ * most useful segments visible. Priority of what stays visible:
+ *   1. the first segment,
+ *   2. the last segment,
+ *   3. then segments from the 2nd onward, filling the remaining space.
+ * The ellipsis sits between them, so it usually lands in the middle:
+ *   "src/components/widgets/popups/menu" → "src/components/…/menu"
+ *
+ * Returns the path unchanged when it fits. Degrades gracefully on very narrow
+ * widths: "…/last", then a middle-truncated last segment.
+ */
+export declare function abbreviatePath(path: string, maxWidth: number, ellipsis?: string): string;

package/dist/common/textTruncation.js

@@ -0,0 +1,124 @@
+import { DisplayLine } from "./displayLine.js";
+/**
+ * Display-width-aware text truncation helpers.
+ *
+ * All widths are measured in terminal columns via {@link DisplayLine}, so wide
+ * (CJK / emoji) characters and combining marks are handled correctly. The
+ * ellipsis is whatever string you pass (default "…", width 1).
+ */
+const DEFAULT_ELLIPSIS = "…";
+function width(text) {
+    return new DisplayLine(text).displayWidth;
+}
+/** Take the longest leading run of graphemes that fits in `maxWidth` columns. */
+function takePrefix(dl, maxWidth) {
+    let w = 0;
+    let out = "";
+    for (const slot of dl.slots) {
+        if (w + slot.displayWidth > maxWidth)
+            break;
+        out += slot.grapheme;
+        w += slot.displayWidth;
+    }
+    return { text: out, width: w };
+}
+/** Take the longest trailing run of graphemes that fits in `maxWidth` columns. */
+function takeSuffix(dl, maxWidth) {
+    let w = 0;
+    let out = "";
+    for (let i = dl.slots.length - 1; i >= 0; i--) {
+        const slot = dl.slots[i];
+        if (w + slot.displayWidth > maxWidth)
+            break;
+        out = slot.grapheme + out;
+        w += slot.displayWidth;
+    }
+    return { text: out, width: w };
+}
+/**
+ * Truncate `text` to `maxWidth` columns, putting the ellipsis at the END:
+ *   "VeryLongFileName.ts" → "VeryLongFile…"
+ *
+ * The kept prefix is preserved grapheme-for-grapheme (so byte offsets of the
+ * prefix are unchanged — important for match highlighting). Returns `text`
+ * unchanged when it already fits, and "" when even the ellipsis doesn't fit.
+ */
+export function truncateEnd(text, maxWidth, ellipsis = DEFAULT_ELLIPSIS) {
+    if (maxWidth <= 0)
+        return "";
+    const dl = new DisplayLine(text);
+    if (dl.displayWidth <= maxWidth)
+        return text;
+    const ew = width(ellipsis);
+    if (maxWidth < ew)
+        return "";
+    return takePrefix(dl, maxWidth - ew).text + ellipsis;
+}
+/**
+ * Truncate `text` to `maxWidth` columns, putting the ellipsis in the MIDDLE:
+ *   "VeryLongFileName" → "VeryL…Name"
+ *
+ * Returns `text` unchanged when it fits, the ellipsis alone when only one
+ * column (its width) is available, and "" when even that doesn't fit.
+ */
+export function truncateMiddle(text, maxWidth, ellipsis = DEFAULT_ELLIPSIS) {
+    if (maxWidth <= 0)
+        return "";
+    const dl = new DisplayLine(text);
+    if (dl.displayWidth <= maxWidth)
+        return text;
+    const ew = width(ellipsis);
+    if (maxWidth < ew)
+        return "";
+    if (maxWidth === ew)
+        return ellipsis;
+    const budget = maxWidth - ew;
+    const headBudget = Math.ceil(budget / 2);
+    const tailBudget = budget - headBudget;
+    const head = takePrefix(dl, headBudget);
+    const tail = takeSuffix(dl, tailBudget);
+    return head.text + ellipsis + tail.text;
+}
+/**
+ * Abbreviate a `/`-separated path to fit in `maxWidth` columns, keeping the
+ * most useful segments visible. Priority of what stays visible:
+ *   1. the first segment,
+ *   2. the last segment,
+ *   3. then segments from the 2nd onward, filling the remaining space.
+ * The ellipsis sits between them, so it usually lands in the middle:
+ *   "src/components/widgets/popups/menu" → "src/components/…/menu"
+ *
+ * Returns the path unchanged when it fits. Degrades gracefully on very narrow
+ * widths: "…/last", then a middle-truncated last segment.
+ */
+export function abbreviatePath(path, maxWidth, ellipsis = DEFAULT_ELLIPSIS) {
+    if (maxWidth <= 0)
+        return "";
+    if (width(path) <= maxWidth)
+        return path;
+    const segments = path.split("/").filter((s) => s.length > 0);
+    // One segment (or a degenerate path) has no directory structure to exploit.
+    // Two segments can't show "first/…/last" shorter than "first/last" itself,
+    // so fall back to middle-truncating the whole string.
+    if (segments.length <= 2)
+        return truncateMiddle(path, maxWidth, ellipsis);
+    const first = segments[0];
+    const last = segments[segments.length - 1];
+    const base = `${first}/${ellipsis}/${last}`;
+    if (width(base) > maxWidth) {
+        const tailOnly = `${ellipsis}/${last}`;
+        if (width(tailOnly) <= maxWidth)
+            return tailOnly;
+        return truncateMiddle(last, maxWidth, ellipsis);
+    }
+    // Greedily grow the visible prefix from the 2nd segment onward, never
+    // including the last segment (it is always shown separately).
+    let best = 1;
+    for (let p = 2; p <= segments.length - 2; p++) {
+        const candidate = `${segments.slice(0, p).join("/")}/${ellipsis}/${last}`;
+        if (width(candidate) > maxWidth)
+            break;
+        best = p;
+    }
+    return `${segments.slice(0, best).join("/")}/${ellipsis}/${last}`;
+}

package/dist/common/typingUtils.d.ts

@@ -0,0 +1 @@
+export declare function reject(): never;

package/dist/common/typingUtils.js

@@ -0,0 +1,3 @@
+export function reject() {
+    throw new Error("Unexpected state");
+}

package/dist/common/unicodeWidth.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Determines the display width of a Unicode code point in a terminal.
+ *
+ * Returns:
+ *  - 0 for control characters, combining marks, zero-width chars
+ *  - 2 for East Asian Wide / Fullwidth characters and emoji
+ *  - 1 for everything else
+ *
+ * Does NOT handle tabs — tab width depends on column position and is
+ * computed by DisplayLine.
+ */
+export declare function getCharDisplayWidth(codePoint: number): number;
+/**
+ * Compute the display width of a grapheme cluster.
+ * A cluster may contain multiple code points (e.g. emoji + ZWJ sequences).
+ * The width is determined by the widest non-zero-width code point.
+ */
+export declare function getGraphemeDisplayWidth(grapheme: string): number;

package/dist/common/unicodeWidth.js

@@ -0,0 +1,339 @@
+/**
+ * Determines the display width of a Unicode code point in a terminal.
+ *
+ * Returns:
+ *  - 0 for control characters, combining marks, zero-width chars
+ *  - 2 for East Asian Wide / Fullwidth characters and emoji
+ *  - 1 for everything else
+ *
+ * Does NOT handle tabs — tab width depends on column position and is
+ * computed by DisplayLine.
+ */
+export function getCharDisplayWidth(codePoint) {
+    // Control characters (C0, DEL, C1)
+    if (codePoint < 0x20 || (codePoint >= 0x7f && codePoint < 0xa0)) {
+        return 0;
+    }
+    // Zero-width characters
+    if (isZeroWidth(codePoint)) {
+        return 0;
+    }
+    // Wide / Fullwidth characters
+    if (isWide(codePoint)) {
+        return 2;
+    }
+    return 1;
+}
+function isZeroWidth(cp) {
+    // Combining Diacritical Marks
+    if (cp >= 0x0300 && cp <= 0x036f)
+        return true;
+    // Combining Diacritical Marks Extended
+    if (cp >= 0x1ab0 && cp <= 0x1aff)
+        return true;
+    // Combining Diacritical Marks Supplement
+    if (cp >= 0x1dc0 && cp <= 0x1dff)
+        return true;
+    // Combining Diacritical Marks for Symbols
+    if (cp >= 0x20d0 && cp <= 0x20ff)
+        return true;
+    // Combining Half Marks
+    if (cp >= 0xfe20 && cp <= 0xfe2f)
+        return true;
+    // Thai combining marks
+    if (cp >= 0x0e31 && cp <= 0x0e3a)
+        return true;
+    if (cp >= 0x0e47 && cp <= 0x0e4e)
+        return true;
+    // General combining marks (Mn, Mc, Me categories — major blocks)
+    // Hebrew points
+    if (cp >= 0x0591 && cp <= 0x05bd)
+        return true;
+    if (cp === 0x05bf)
+        return true;
+    if (cp >= 0x05c1 && cp <= 0x05c2)
+        return true;
+    if (cp >= 0x05c4 && cp <= 0x05c5)
+        return true;
+    if (cp === 0x05c7)
+        return true;
+    // Arabic combining
+    if (cp >= 0x0610 && cp <= 0x061a)
+        return true;
+    if (cp >= 0x064b && cp <= 0x065f)
+        return true;
+    if (cp === 0x0670)
+        return true;
+    if (cp >= 0x06d6 && cp <= 0x06dc)
+        return true;
+    if (cp >= 0x06df && cp <= 0x06e4)
+        return true;
+    if (cp >= 0x06e7 && cp <= 0x06e8)
+        return true;
+    if (cp >= 0x06ea && cp <= 0x06ed)
+        return true;
+    // Devanagari combining
+    if (cp >= 0x0900 && cp <= 0x0903)
+        return true;
+    if (cp >= 0x093a && cp <= 0x094f)
+        return true;
+    if (cp >= 0x0951 && cp <= 0x0957)
+        return true;
+    // Hangul Jamo combining (medial/final)
+    if (cp >= 0x1160 && cp <= 0x11ff)
+        return true;
+    // Variation Selectors
+    if (cp >= 0xfe00 && cp <= 0xfe0f)
+        return true;
+    // Variation Selectors Supplement
+    if (cp >= 0xe0100 && cp <= 0xe01ef)
+        return true;
+    // Zero Width Space, ZWNJ, ZWJ, Soft Hyphen
+    if (cp === 0x200b || cp === 0x200c || cp === 0x200d || cp === 0x00ad)
+        return true;
+    // Word Joiner, BOM
+    if (cp === 0x2060 || cp === 0xfeff)
+        return true;
+    // CGJ (Combining Grapheme Joiner)
+    /* v8 ignore start -- unreachable: U+034F already matches the Combining Diacritical Marks range (0x0300..0x036f) above */
+    if (cp === 0x034f)
+        return true;
+    /* v8 ignore stop */
+    return false;
+}
+function isWide(cp) {
+    // CJK Radicals Supplement .. Kangxi Radicals
+    if (cp >= 0x2e80 && cp <= 0x2fdf)
+        return true;
+    // Ideographic Description Characters .. CJK Symbols and Punctuation
+    if (cp >= 0x2ff0 && cp <= 0x303e)
+        return true;
+    // Hiragana, Katakana, Bopomofo, Hangul Compatibility Jamo, Kanbun, etc.
+    if (cp >= 0x3040 && cp <= 0x33bf)
+        return true;
+    // CJK Compatibility (3300–33FF already covered), CJK Unified Ideographs Extension A
+    if (cp >= 0x33c0 && cp <= 0x4dbf)
+        return true;
+    // CJK Unified Ideographs
+    if (cp >= 0x4e00 && cp <= 0x9fff)
+        return true;
+    // Yi Syllables, Yi Radicals
+    if (cp >= 0xa000 && cp <= 0xa4cf)
+        return true;
+    // Hangul Syllables
+    if (cp >= 0xac00 && cp <= 0xd7a3)
+        return true;
+    // CJK Compatibility Ideographs
+    if (cp >= 0xf900 && cp <= 0xfaff)
+        return true;
+    // Vertical Forms
+    if (cp >= 0xfe10 && cp <= 0xfe19)
+        return true;
+    // CJK Compatibility Forms
+    if (cp >= 0xfe30 && cp <= 0xfe6f)
+        return true;
+    // Fullwidth forms (excluding halfwidth katakana)
+    if (cp >= 0xff01 && cp <= 0xff60)
+        return true;
+    if (cp >= 0xffe0 && cp <= 0xffe6)
+        return true;
+    // CJK Unified Ideographs Extension B .. Extension H (SIP/TIP)
+    if (cp >= 0x20000 && cp <= 0x3134f)
+        return true;
+    // Emoji — only code points with Emoji_Presentation = Yes.
+    // Source: Unicode 15 emoji-data.txt
+    //
+    // Miscellaneous Symbols and Pictographs (1F300-1F5FF)
+    // Emoji_Presentation=Yes sub-ranges only (text-presentation chars excluded):
+    if (cp >= 0x1f300 && cp <= 0x1f320)
+        return true; // weather, misc
+    if (cp >= 0x1f32d && cp <= 0x1f335)
+        return true; // food
+    if (cp >= 0x1f337 && cp <= 0x1f37c)
+        return true; // food, plants
+    if (cp >= 0x1f37e && cp <= 0x1f393)
+        return true; // activities
+    if (cp >= 0x1f3a0 && cp <= 0x1f3ca)
+        return true; // entertainment
+    if (cp >= 0x1f3cf && cp <= 0x1f3d3)
+        return true; // sports
+    if (cp >= 0x1f3e0 && cp <= 0x1f3f0)
+        return true; // buildings
+    if (cp === 0x1f3f4)
+        return true; // BLACK FLAG
+    if (cp >= 0x1f3f8 && cp <= 0x1f43e)
+        return true; // animals, nature
+    if (cp === 0x1f440)
+        return true; // EYES
+    if (cp >= 0x1f442 && cp <= 0x1f4fc)
+        return true; // objects
+    if (cp >= 0x1f4ff && cp <= 0x1f53d)
+        return true; // more objects
+    if (cp >= 0x1f54b && cp <= 0x1f54e)
+        return true; // religious
+    if (cp >= 0x1f550 && cp <= 0x1f567)
+        return true; // clocks
+    if (cp === 0x1f57a)
+        return true; // MAN DANCING
+    if (cp >= 0x1f595 && cp <= 0x1f596)
+        return true; // hand gestures
+    if (cp === 0x1f5a4)
+        return true; // BLACK HEART
+    if (cp >= 0x1f5fb && cp <= 0x1f5ff)
+        return true; // MOUNT FUJI..MOYAI
+    // Emoticons (1F600-1F64F) — all Emoji_Presentation=Yes
+    if (cp >= 0x1f600 && cp <= 0x1f64f)
+        return true;
+    // Transport and Map Symbols (1F680-1F6FF) — Emoji_Presentation=Yes sub-ranges
+    if (cp >= 0x1f680 && cp <= 0x1f6ca)
+        return true;
+    if (cp === 0x1f6cc)
+        return true; // 🛌 SLEEPING ACCOMMODATION
+    if (cp >= 0x1f6d0 && cp <= 0x1f6d2)
+        return true;
+    if (cp >= 0x1f6d5 && cp <= 0x1f6d7)
+        return true;
+    if (cp === 0x1f6dc)
+        return true; // 🛜 WIRELESS (added Unicode 15)
+    if (cp >= 0x1f6dd && cp <= 0x1f6df)
+        return true;
+    if (cp >= 0x1f6eb && cp <= 0x1f6ec)
+        return true;
+    if (cp >= 0x1f6f4 && cp <= 0x1f6fc)
+        return true;
+    // Geometric Shapes Extended (1F7E0–1F7EB) — colored circles/squares 🟠🟡🟢🔵🟣🟤 🟥🟦🟨🟩🟧🟪🟫
+    if (cp >= 0x1f7e0 && cp <= 0x1f7eb)
+        return true;
+    if (cp === 0x1f7f0)
+        return true; // 🟰 HEAVY EQUALS SIGN (added Unicode 14)
+    // Supplemental Symbols and Pictographs
+    if (cp >= 0x1f900 && cp <= 0x1f9ff)
+        return true;
+    // Symbols and Pictographs Extended-A
+    if (cp >= 0x1fa00 && cp <= 0x1fa6f)
+        return true;
+    // Symbols and Pictographs Extended-B  (added Unicode 14+)
+    if (cp >= 0x1fa70 && cp <= 0x1faff)
+        return true;
+    // Dingbats (2700–27BF) — only the Emoji_Presentation=Yes code points are wide.
+    // The rest (e.g. ✕ U+2715, ✓ U+2713, scissors U+2700) are narrow text symbols.
+    // Source: Unicode 15 emoji-data.txt
+    if (cp === 0x2705)
+        return true; // ✅ WHITE HEAVY CHECK MARK
+    if (cp >= 0x270a && cp <= 0x270b)
+        return true; // ✊ RAISED FIST .. ✋ RAISED HAND
+    if (cp === 0x2728)
+        return true; // ✨ SPARKLES
+    if (cp === 0x274c)
+        return true; // ❌ CROSS MARK
+    if (cp === 0x274e)
+        return true; // ❎ NEGATIVE SQUARED CROSS MARK
+    if (cp >= 0x2753 && cp <= 0x2755)
+        return true; // ❓ .. ❕ question / exclamation ornaments
+    if (cp === 0x2757)
+        return true; // ❗ HEAVY EXCLAMATION MARK SYMBOL
+    if (cp >= 0x2795 && cp <= 0x2797)
+        return true; // ➕ ➖ ➗ heavy plus / minus / division
+    if (cp === 0x27b0)
+        return true; // ➰ CURLY LOOP
+    if (cp === 0x27bf)
+        return true; // ➿ DOUBLE CURLY LOOP
+    // BMP emoji with Emoji_Presentation=Yes that live outside the Dingbats and
+    // SMP blocks above — Miscellaneous Technical, Misc Symbols (2600–26FF),
+    // Geometric Shapes and the 2B00 block. Terminals render all of these two
+    // columns wide; omitting them desynced our column model from the terminal
+    // and left glyph tails as scrolling artifacts (e.g. ⭐ U+2B50, ⚡ U+26A1).
+    // Source: Unicode 15 emoji-data.txt (Emoji_Presentation=Yes).
+    if (cp >= 0x231a && cp <= 0x231b)
+        return true; // ⌚ WATCH .. ⌛ HOURGLASS
+    if (cp >= 0x23e9 && cp <= 0x23ec)
+        return true; // ⏩⏪⏫⏬ fast-forward/rewind
+    if (cp === 0x23f0)
+        return true; // ⏰ ALARM CLOCK
+    if (cp === 0x23f3)
+        return true; // ⏳ HOURGLASS WITH FLOWING SAND
+    if (cp >= 0x25fd && cp <= 0x25fe)
+        return true; // ◽ ◾ medium-small squares
+    if (cp >= 0x2614 && cp <= 0x2615)
+        return true; // ☔ UMBRELLA WITH RAIN .. ☕ HOT BEVERAGE
+    if (cp >= 0x2648 && cp <= 0x2653)
+        return true; // ♈..♓ zodiac signs
+    if (cp === 0x267f)
+        return true; // ♿ WHEELCHAIR SYMBOL
+    if (cp === 0x2693)
+        return true; // ⚓ ANCHOR
+    if (cp === 0x26a1)
+        return true; // ⚡ HIGH VOLTAGE SIGN
+    if (cp >= 0x26aa && cp <= 0x26ab)
+        return true; // ⚪ ⚫ medium circles
+    if (cp >= 0x26bd && cp <= 0x26be)
+        return true; // ⚽ SOCCER BALL .. ⚾ BASEBALL
+    if (cp >= 0x26c4 && cp <= 0x26c5)
+        return true; // ⛄ SNOWMAN .. ⛅ SUN BEHIND CLOUD
+    if (cp === 0x26ce)
+        return true; // ⛎ OPHIUCHUS
+    if (cp === 0x26d4)
+        return true; // ⛔ NO ENTRY
+    if (cp === 0x26ea)
+        return true; // ⛪ CHURCH
+    if (cp >= 0x26f2 && cp <= 0x26f3)
+        return true; // ⛲ FOUNTAIN .. ⛳ FLAG IN HOLE
+    if (cp === 0x26f5)
+        return true; // ⛵ SAILBOAT
+    if (cp === 0x26fa)
+        return true; // ⛺ TENT
+    if (cp === 0x26fd)
+        return true; // ⛽ FUEL PUMP
+    if (cp >= 0x2b1b && cp <= 0x2b1c)
+        return true; // ⬛ ⬜ large squares
+    if (cp === 0x2b50)
+        return true; // ⭐ WHITE MEDIUM STAR
+    if (cp === 0x2b55)
+        return true; // ⭕ HEAVY LARGE CIRCLE
+    // Enclosed Alphanumeric Supplement (circled numbers, emoji)
+    if (cp >= 0x1f100 && cp <= 0x1f1ff)
+        return true;
+    // Mahjong Tiles / Playing Cards — Emoji_Presentation=Yes code points
+    if (cp === 0x1f004)
+        return true; // 🀄 MAHJONG TILE RED DRAGON
+    if (cp === 0x1f0cf)
+        return true; // 🃏 PLAYING CARD BLACK JOKER
+    // Enclosed Ideographic Supplement (1F200–1F2FF) — Emoji_Presentation=Yes squared CJK
+    if (cp === 0x1f201)
+        return true; // 🈁 SQUARED KATAKANA KOKO
+    if (cp === 0x1f21a)
+        return true; // 🈚 SQUARED CJK UNIFIED IDEOGRAPH-7121
+    if (cp === 0x1f22f)
+        return true; // 🈯 SQUARED CJK UNIFIED IDEOGRAPH-6307
+    if (cp >= 0x1f232 && cp <= 0x1f236)
+        return true; // 🈲🈳🈴🈵🈶
+    if (cp >= 0x1f238 && cp <= 0x1f23a)
+        return true; // 🈸🈹🈺
+    if (cp >= 0x1f250 && cp <= 0x1f251)
+        return true; // 🉐🉑
+    return false;
+}
+/**
+ * Compute the display width of a grapheme cluster.
+ * A cluster may contain multiple code points (e.g. emoji + ZWJ sequences).
+ * The width is determined by the widest non-zero-width code point.
+ */
+export function getGraphemeDisplayWidth(grapheme) {
+    // VS16 (U+FE0F, Variation Selector-16) forces emoji presentation.
+    // Any cluster containing VS16 is rendered as wide (2 columns) by terminals.
+    if (grapheme.includes("\uFE0F")) {
+        return 2;
+    }
+    let width = 0;
+    for (const ch of grapheme) {
+        /* v8 ignore start -- defensive: `ch` from a string for-of is always a non-empty code point, so codePointAt(0) is never undefined */
+        const cp = ch.codePointAt(0) ?? 0;
+        /* v8 ignore stop */
+        const w = getCharDisplayWidth(cp);
+        if (w > width)
+            width = w;
+    }
+    // A grapheme cluster always occupies at least 1 column unless it's empty
+    // or entirely zero-width (which shouldn't happen for properly segmented graphemes).
+    return width || (grapheme.length > 0 ? 1 : 0);
+}

package/dist/dom/borderStyle.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Толщина рамки drawBox в ячейках. В клеточном терминале рамка — это
+ * box-drawing-глиф, физически всегда 1 ячейка; константа никогда не сменит
+ * значение. Её ценность — имя: все места, где рамка участвует в формулах
+ * размеров/смещений, находятся грепом и отличимы от настоящих отступов.
+ */
+export declare const BORDER_THICKNESS = 1;
+/**
+ * Набор box-drawing глифов для рамки виджета. Используется общим хелпером
+ * {@link RenderContext.drawBox}, чтобы отрисовка рамок не дублировалась по
+ * виджетам и стиль углов был единым.
+ *
+ * `leftJoint`/`rightJoint` — T-коннекторы (`├`/`┤`) для строк-сепараторов
+ * (ряд-разделитель внутри рамки).
+ */
+export interface BorderStyle {
+    topLeft: string;
+    topRight: string;
+    bottomLeft: string;
+    bottomRight: string;
+    horizontal: string;
+    vertical: string;
+    leftJoint: string;
+    rightJoint: string;
+}
+/** Прямые углы `┌┐└┘`. Пресет на будущее (по умолчанию не используется). */
+export declare const BORDER_SINGLE: BorderStyle;
+/** Скруглённые углы `╭╮╰╯` (nvchad-стиль) — канонический стиль рамок во всех оверлеях Vexx. */
+export declare const BORDER_ROUNDED: BorderStyle;
+/** Двойные линии `╔╗╚╝`. Пресет на будущее (по умолчанию не используется). */
+export declare const BORDER_DOUBLE: BorderStyle;

package/dist/dom/borderStyle.js

@@ -0,0 +1,40 @@
+/**
+ * Толщина рамки drawBox в ячейках. В клеточном терминале рамка — это
+ * box-drawing-глиф, физически всегда 1 ячейка; константа никогда не сменит
+ * значение. Её ценность — имя: все места, где рамка участвует в формулах
+ * размеров/смещений, находятся грепом и отличимы от настоящих отступов.
+ */
+export const BORDER_THICKNESS = 1;
+/** Прямые углы `┌┐└┘`. Пресет на будущее (по умолчанию не используется). */
+export const BORDER_SINGLE = {
+    topLeft: "┌",
+    topRight: "┐",
+    bottomLeft: "└",
+    bottomRight: "┘",
+    horizontal: "─",
+    vertical: "│",
+    leftJoint: "├",
+    rightJoint: "┤",
+};
+/** Скруглённые углы `╭╮╰╯` (nvchad-стиль) — канонический стиль рамок во всех оверлеях Vexx. */
+export const BORDER_ROUNDED = {
+    topLeft: "╭",
+    topRight: "╮",
+    bottomLeft: "╰",
+    bottomRight: "╯",
+    horizontal: "─",
+    vertical: "│",
+    leftJoint: "├",
+    rightJoint: "┤",
+};
+/** Двойные линии `╔╗╚╝`. Пресет на будущее (по умолчанию не используется). */
+export const BORDER_DOUBLE = {
+    topLeft: "╔",
+    topRight: "╗",
+    bottomLeft: "╚",
+    bottomRight: "╝",
+    horizontal: "═",
+    vertical: "║",
+    leftJoint: "╠",
+    rightJoint: "╣",
+};