indusagi 0.12.19 → 0.12.21

package/dist/tui/utils.js

@@ -32,7 +32,7 @@ export const textWidthCalculator = new TextWidthCalculator();
  * The tested Unicode blocks are deliberately broad to account for future
  * Unicode additions.
  */
-function couldBeEmoji(segment) {
+function looksLikeEmojiCandidate(segment) {
     const cp = segment.codePointAt(0);
     return ((cp >= 0x1f000 && cp <= 0x1fbff) || // Emoji and Pictograph
         (cp >= 0x2300 && cp <= 0x23ff) || // Misc technical
@@ -43,9 +43,34 @@ function couldBeEmoji(segment) {
     );
 }
 // Regexes for character classification (same as string-width library)
-const zeroWidthRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Mark}|\p{Surrogate})+$/v;
-const leadingNonPrintingRegex = /^[\p{Default_Ignorable_Code_Point}\p{Control}\p{Format}\p{Mark}\p{Surrogate}]+/v;
-const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+// Use dynamic construction to keep compatibility with ts target < es2024 while
+// still preferring Unicode Sets (v-flag) when available at runtime.
+function createUnicodeRegex(vPattern, uFallback) {
+    try {
+        return new RegExp(vPattern, "v");
+    }
+    catch {
+        return new RegExp(uFallback, "u");
+    }
+}
+const zeroWidthRegex = createUnicodeRegex("^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Mark}|\\p{Surrogate})+$", "^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Mark}|\\p{Surrogate})+$");
+const leadingNonPrintingRegex = createUnicodeRegex("^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Mark}\\p{Surrogate}]+", "^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Mark}\\p{Surrogate}]+");
+const rgiEmojiRegex = createUnicodeRegex("^\\p{RGI_Emoji}$", "^\\p{Extended_Pictographic}$");
+const AnsiStripper = {
+    strip(text) {
+        if (!text.includes("\x1b")) {
+            return text;
+        }
+        let cleaned = text;
+        // Strip SGR codes (\x1b[...m) and cursor codes (\x1b[...G/K/H/J)
+        cleaned = cleaned.replace(/\x1b\[[0-9;]*[mGKHJ]/g, "");
+        // Strip OSC 8 hyperlinks: \x1b]8;;URL\x07 and \x1b]8;;\x07
+        cleaned = cleaned.replace(/\x1b\]8;;[^\x07]*\x07/g, "");
+        // Strip APC sequences: \x1b_...\x07 or \x1b_...\x1b\\ (cursor marker)
+        cleaned = cleaned.replace(/\x1b_[^\x07\x1b]*(?:\x07|\x1b\\)/g, "");
+        return cleaned;
+    },
+};
 // Cache for non-ASCII strings
 const WIDTH_CACHE_SIZE = 512;
 const widthCache = new Map();
@@ -54,13 +79,13 @@ const widthCache = new Map();
  * Based on code from the string-width library, but includes a possible-emoji
  * check to avoid running the RGI_Emoji regex unnecessarily.
  */
-function graphemeWidth(segment) {
+function measureClusterWidth(segment) {
     // Zero-width clusters
     if (zeroWidthRegex.test(segment)) {
         return 0;
     }
     // Emoji check with pre-filter
-    if (couldBeEmoji(segment) && rgiEmojiRegex.test(segment)) {
+    if (looksLikeEmojiCandidate(segment) && rgiEmojiRegex.test(segment)) {
         return 2;
     }
     // Get base visible codepoint
@@ -110,18 +135,11 @@ export function visibleWidth(str) {
     if (str.includes("\t")) {
         clean = clean.replace(/\t/g, "   ");
     }
-    if (clean.includes("\x1b")) {
-        // Strip SGR codes (\x1b[...m) and cursor codes (\x1b[...G/K/H/J)
-        clean = clean.replace(/\x1b\[[0-9;]*[mGKHJ]/g, "");
-        // Strip OSC 8 hyperlinks: \x1b]8;;URL\x07 and \x1b]8;;\x07
-        clean = clean.replace(/\x1b\]8;;[^\x07]*\x07/g, "");
-        // Strip APC sequences: \x1b_...\x07 or \x1b_...\x1b\\ (used for cursor marker)
-        clean = clean.replace(/\x1b_[^\x07\x1b]*(?:\x07|\x1b\\)/g, "");
-    }
+    clean = AnsiStripper.strip(clean);
     // Calculate width
     let width = 0;
     for (const { segment } of segmenter.segment(clean)) {
-        width += graphemeWidth(segment);
+        width += measureClusterWidth(segment);
     }
     // Cache result
     if (widthCache.size >= WIDTH_CACHE_SIZE) {
@@ -180,20 +198,17 @@ export function extractAnsiCode(str, pos) {
 /**
  * Track active ANSI SGR codes to preserve styling across line breaks.
  */
-class AnsiCodeTracker {
-    constructor() {
-        // Track individual attributes separately so we can reset them specifically
-        this.bold = false;
-        this.dim = false;
-        this.italic = false;
-        this.underline = false;
-        this.blink = false;
-        this.inverse = false;
-        this.hidden = false;
-        this.strikethrough = false;
-        this.fgColor = null; // Stores the full code like "31" or "38;5;240"
-        this.bgColor = null; // Stores the full code like "41" or "48;5;240"
-    }
+class AnsiStateTracker {
+    // Track individual attributes separately so we can reset them specifically
+    _bold = false;
+    _dim = false;
+    italic = false;
+    underline = false;
+    blink = false;
+    inverse = false;
+    hidden = false;
+    strikethrough = false;
+    _colors = { fg: null, bg: null };
     process(ansiCode) {
         if (!ansiCode.endsWith("m")) {
             return;
@@ -212,121 +227,127 @@ class AnsiCodeTracker {
         const parts = params.split(";");
         let i = 0;
         while (i < parts.length) {
-            const code = Number.parseInt(parts[i], 10);
-            // Handle 256-color and RGB codes which consume multiple parameters
-            if (code === 38 || code === 48) {
-                // 38;5;N (256 color fg) or 38;2;R;G;B (RGB fg)
-                // 48;5;N (256 color bg) or 48;2;R;G;B (RGB bg)
-                if (parts[i + 1] === "5" && parts[i + 2] !== undefined) {
-                    // 256 color: 38;5;N or 48;5;N
-                    const colorCode = `${parts[i]};${parts[i + 1]};${parts[i + 2]}`;
-                    if (code === 38) {
-                        this.fgColor = colorCode;
-                    }
-                    else {
-                        this.bgColor = colorCode;
-                    }
-                    i += 3;
-                    continue;
-                }
-                else if (parts[i + 1] === "2" && parts[i + 4] !== undefined) {
-                    // RGB color: 38;2;R;G;B or 48;2;R;G;B
-                    const colorCode = `${parts[i]};${parts[i + 1]};${parts[i + 2]};${parts[i + 3]};${parts[i + 4]}`;
-                    if (code === 38) {
-                        this.fgColor = colorCode;
-                    }
-                    else {
-                        this.bgColor = colorCode;
-                    }
-                    i += 5;
-                    continue;
-                }
+            const code = Number.parseInt(parts[i] ?? "", 10);
+            if (Number.isNaN(code)) {
+                i++;
+                continue;
             }
-            // Standard SGR codes
-            switch (code) {
-                case 0:
-                    this.reset();
-                    break;
-                case 1:
-                    this.bold = true;
-                    break;
-                case 2:
-                    this.dim = true;
-                    break;
-                case 3:
-                    this.italic = true;
-                    break;
-                case 4:
-                    this.underline = true;
-                    break;
-                case 5:
-                    this.blink = true;
-                    break;
-                case 7:
-                    this.inverse = true;
-                    break;
-                case 8:
-                    this.hidden = true;
-                    break;
-                case 9:
-                    this.strikethrough = true;
-                    break;
-                case 21:
-                    this.bold = false;
-                    break; // Some terminals
-                case 22:
-                    this.bold = false;
-                    this.dim = false;
-                    break;
-                case 23:
-                    this.italic = false;
-                    break;
-                case 24:
-                    this.underline = false;
-                    break;
-                case 25:
-                    this.blink = false;
-                    break;
-                case 27:
-                    this.inverse = false;
-                    break;
-                case 28:
-                    this.hidden = false;
-                    break;
-                case 29:
-                    this.strikethrough = false;
-                    break;
-                case 39:
-                    this.fgColor = null;
-                    break; // Default fg
-                case 49:
-                    this.bgColor = null;
-                    break; // Default bg
-                default:
-                    // Standard foreground colors 30-37, 90-97
-                    if ((code >= 30 && code <= 37) || (code >= 90 && code <= 97)) {
-                        this.fgColor = String(code);
-                    }
-                    // Standard background colors 40-47, 100-107
-                    else if ((code >= 40 && code <= 47) || (code >= 100 && code <= 107)) {
-                        this.bgColor = String(code);
-                    }
-                    break;
+            const consumed = this.tryConsumeColorCode(parts, i, code);
+            if (consumed > 0) {
+                i += consumed;
+                continue;
             }
+            this.applyStandardCode(code);
             i++;
         }
     }
+    tryConsumeColorCode(parts, index, code) {
+        if (code !== 38 && code !== 48) {
+            return 0;
+        }
+        if (parts[index + 1] === "5" && parts[index + 2] !== undefined) {
+            const colorCode = `${parts[index]};${parts[index + 1]};${parts[index + 2]}`;
+            if (code === 38) {
+                this._colors.fg = colorCode;
+            }
+            else {
+                this._colors.bg = colorCode;
+            }
+            return 3;
+        }
+        if (parts[index + 1] === "2" && parts[index + 4] !== undefined) {
+            const colorCode = `${parts[index]};${parts[index + 1]};${parts[index + 2]};${parts[index + 3]};${parts[index + 4]}`;
+            if (code === 38) {
+                this._colors.fg = colorCode;
+            }
+            else {
+                this._colors.bg = colorCode;
+            }
+            return 5;
+        }
+        return 0;
+    }
+    applyStandardCode(code) {
+        switch (code) {
+            case 0:
+                this.reset();
+                return;
+            case 1:
+                this._bold = true;
+                return;
+            case 2:
+                this._dim = true;
+                return;
+            case 3:
+                this.italic = true;
+                return;
+            case 4:
+                this.underline = true;
+                return;
+            case 5:
+                this.blink = true;
+                return;
+            case 7:
+                this.inverse = true;
+                return;
+            case 8:
+                this.hidden = true;
+                return;
+            case 9:
+                this.strikethrough = true;
+                return;
+            case 21:
+                this._bold = false;
+                return;
+            case 22:
+                this._bold = false;
+                this._dim = false;
+                return;
+            case 23:
+                this.italic = false;
+                return;
+            case 24:
+                this.underline = false;
+                return;
+            case 25:
+                this.blink = false;
+                return;
+            case 27:
+                this.inverse = false;
+                return;
+            case 28:
+                this.hidden = false;
+                return;
+            case 29:
+                this.strikethrough = false;
+                return;
+            case 39:
+                this._colors.fg = null;
+                return;
+            case 49:
+                this._colors.bg = null;
+                return;
+            default:
+                if ((code >= 30 && code <= 37) || (code >= 90 && code <= 97)) {
+                    this._colors.fg = String(code);
+                    return;
+                }
+                if ((code >= 40 && code <= 47) || (code >= 100 && code <= 107)) {
+                    this._colors.bg = String(code);
+                }
+        }
+    }
     reset() {
-        this.bold = false;
-        this.dim = false;
+        this._bold = false;
+        this._dim = false;
         this.italic = false;
         this.underline = false;
         this.blink = false;
         this.inverse = false;
         this.hidden = false;
         this.strikethrough = false;
-        this.fgColor = null;
-        this.bgColor = null;
+        this._colors.fg = null;
+        this._colors.bg = null;
     }
     /** Clear all state for reuse. */
     clear() {
@@ -334,9 +355,9 @@ class AnsiCodeTracker {
     }
     getActiveCodes() {
         const codes = [];
-        if (this.bold)
+        if (this._bold)
             codes.push("1");
-        if (this.dim)
+        if (this._dim)
             codes.push("2");
         if (this.italic)
             codes.push("3");
@@ -350,25 +371,25 @@ class AnsiCodeTracker {
             codes.push("8");
         if (this.strikethrough)
             codes.push("9");
-        if (this.fgColor)
-            codes.push(this.fgColor);
-        if (this.bgColor)
-            codes.push(this.bgColor);
+        if (this._colors.fg)
+            codes.push(this._colors.fg);
+        if (this._colors.bg)
+            codes.push(this._colors.bg);
         if (codes.length === 0)
             return "";
         return `\x1b[${codes.join(";")}m`;
     }
     hasActiveCodes() {
-        return (this.bold ||
-            this.dim ||
+        return (this._bold ||
+            this._dim ||
             this.italic ||
             this.underline ||
             this.blink ||
             this.inverse ||
             this.hidden ||
             this.strikethrough ||
-            this.fgColor !== null ||
-            this.bgColor !== null);
+            this._colors.fg !== null ||
+            this._colors.bg !== null);
     }
     /**
      * Get reset codes for attributes that need to be turned off at line end,
@@ -384,7 +405,7 @@ class AnsiCodeTracker {
         return "";
     }
 }
-function updateTrackerFromText(text, tracker) {
+function mergeTextIntoTracker(text, tracker) {
     let i = 0;
     while (i < text.length) {
         const ansiResult = extractAnsiCode(text, i);
@@ -400,7 +421,7 @@ function updateTrackerFromText(text, tracker) {
 /**
  * Split text into words while keeping ANSI codes attached.
  */
-function splitIntoTokensWithAnsi(text) {
+function tokenizeTextWithAnsi(text) {
     const tokens = [];
     let current = "";
     let pendingAnsi = ""; // ANSI codes waiting to be attached to next visible content
@@ -451,9 +472,7 @@ function splitIntoTokensWithAnsi(text) {
  * @returns Array of wrapped lines (NOT padded to width)
  */
 export class AnsiCodeManager {
-    constructor() {
-        this.tracker = new AnsiCodeTracker();
-    }
+    tracker = new AnsiStateTracker();
     process(ansiCode) {
         this.tracker.process(ansiCode);
     }
@@ -470,6 +489,57 @@ export class TextWrapper {
     }
 }
 export const textWrapper = new TextWrapper();
+const TokenWrapEngine = {
+    wrap(tokens, width, tracker) {
+        const wrapped = [];
+        let currentLine = "";
+        let currentVisibleLength = 0;
+        for (const token of tokens) {
+            const tokenVisibleLength = visibleWidth(token);
+            const isWhitespace = token.trim() === "";
+            // Token itself is too long - break it character by character
+            if (tokenVisibleLength > width && !isWhitespace) {
+                if (currentLine) {
+                    const lineEndReset = tracker.getLineEndReset();
+                    if (lineEndReset) {
+                        currentLine += lineEndReset;
+                    }
+                    wrapped.push(currentLine);
+                    currentLine = "";
+                    currentVisibleLength = 0;
+                }
+                const broken = splitLongToken(token, width, tracker);
+                wrapped.push(...broken.slice(0, -1));
+                currentLine = broken[broken.length - 1];
+                currentVisibleLength = visibleWidth(currentLine);
+                continue;
+            }
+            const totalNeeded = currentVisibleLength + tokenVisibleLength;
+            if (totalNeeded > width && currentVisibleLength > 0) {
+                let lineToWrap = currentLine.trimEnd();
+                const lineEndReset = tracker.getLineEndReset();
+                if (lineEndReset) {
+                    lineToWrap += lineEndReset;
+                }
+                wrapped.push(lineToWrap);
+                if (isWhitespace) {
+                    currentLine = tracker.getActiveCodes();
+                    currentVisibleLength = 0;
+                }
+                else {
+                    currentLine = tracker.getActiveCodes() + token;
+                    currentVisibleLength = tokenVisibleLength;
+                }
+            }
+            else {
+                currentLine += token;
+                currentVisibleLength += tokenVisibleLength;
+            }
+            mergeTextIntoTracker(token, tracker);
+        }
+        return { wrapped, currentLine, currentVisibleLength };
+    },
+};
 export function wrapTextWithAnsi(text, width) {
     if (!text) {
         return [""];
@@ -478,17 +548,17 @@ export function wrapTextWithAnsi(text, width) {
     // Track ANSI state across lines so styles carry over after literal newlines
     const inputLines = text.split("\n");
     const result = [];
-    const tracker = new AnsiCodeTracker();
+    const tracker = new AnsiStateTracker();
     for (const inputLine of inputLines) {
         // Prepend active ANSI codes from previous lines (except for first line)
         const prefix = result.length > 0 ? tracker.getActiveCodes() : "";
-        result.push(...wrapSingleLine(prefix + inputLine, width));
+        result.push(...wrapLinePreservingAnsi(prefix + inputLine, width));
         // Update tracker with codes from this line for next iteration
-        updateTrackerFromText(inputLine, tracker);
+        mergeTextIntoTracker(inputLine, tracker);
     }
     return result.length > 0 ? result : [""];
 }
-function wrapSingleLine(line, width) {
+function wrapLinePreservingAnsi(line, width) {
     if (!line) {
         return [""];
     }
@@ -496,66 +566,15 @@ function wrapSingleLine(line, width) {
     if (visibleLength <= width) {
         return [line];
     }
-    const wrapped = [];
-    const tracker = new AnsiCodeTracker();
-    const tokens = splitIntoTokensWithAnsi(line);
-    let currentLine = "";
-    let currentVisibleLength = 0;
-    for (const token of tokens) {
-        const tokenVisibleLength = visibleWidth(token);
-        const isWhitespace = token.trim() === "";
-        // Token itself is too long - break it character by character
-        if (tokenVisibleLength > width && !isWhitespace) {
-            if (currentLine) {
-                // Add specific reset for underline only (preserves background)
-                const lineEndReset = tracker.getLineEndReset();
-                if (lineEndReset) {
-                    currentLine += lineEndReset;
-                }
-                wrapped.push(currentLine);
-                currentLine = "";
-                currentVisibleLength = 0;
-            }
-            // Break long token - breakLongWord handles its own resets
-            const broken = breakLongWord(token, width, tracker);
-            wrapped.push(...broken.slice(0, -1));
-            currentLine = broken[broken.length - 1];
-            currentVisibleLength = visibleWidth(currentLine);
-            continue;
-        }
-        // Check if adding this token would exceed width
-        const totalNeeded = currentVisibleLength + tokenVisibleLength;
-        if (totalNeeded > width && currentVisibleLength > 0) {
-            // Trim trailing whitespace, then add underline reset (not full reset, to preserve background)
-            let lineToWrap = currentLine.trimEnd();
-            const lineEndReset = tracker.getLineEndReset();
-            if (lineEndReset) {
-                lineToWrap += lineEndReset;
-            }
-            wrapped.push(lineToWrap);
-            if (isWhitespace) {
-                // Don't start new line with whitespace
-                currentLine = tracker.getActiveCodes();
-                currentVisibleLength = 0;
-            }
-            else {
-                currentLine = tracker.getActiveCodes() + token;
-                currentVisibleLength = tokenVisibleLength;
-            }
-        }
-        else {
-            // Add to current line
-            currentLine += token;
-            currentVisibleLength += tokenVisibleLength;
-        }
-        updateTrackerFromText(token, tracker);
-    }
+    const tracker = new AnsiStateTracker();
+    const tokens = tokenizeTextWithAnsi(line);
+    const { wrapped, currentLine } = TokenWrapEngine.wrap(tokens, width, tracker);
     if (currentLine) {
         // No reset at end of final line - let caller handle it
         wrapped.push(currentLine);
     }
     // Trailing whitespace can cause lines to exceed the requested width
-    return wrapped.length > 0 ? wrapped.map((line) => line.trimEnd()) : [""];
+    return wrapped.length > 0 ? wrapped.map((segmentLine) => segmentLine.trimEnd()) : [""];
 }
 const PUNCTUATION_REGEX = /[(){}[\]<>.,;:'"!?+\-=*/\\|&%^$#@~`]/;
 /**
@@ -570,7 +589,7 @@ export function isWhitespaceChar(char) {
 export function isPunctuationChar(char) {
     return PUNCTUATION_REGEX.test(char);
 }
-function breakLongWord(word, width, tracker) {
+function splitLongToken(word, width, tracker) {
     const lines = [];
     let currentLine = tracker.getActiveCodes();
     let currentWidth = 0;
@@ -612,8 +631,8 @@ function breakLongWord(word, width, tracker) {
         // Skip empty graphemes to avoid issues with string-width calculation
         if (!grapheme)
             continue;
-        const graphemeWidth = visibleWidth(grapheme);
-        if (currentWidth + graphemeWidth > width) {
+        const clusterWidth = visibleWidth(grapheme);
+        if (currentWidth + clusterWidth > width) {
             // Add specific reset for underline only (preserves background)
             const lineEndReset = tracker.getLineEndReset();
             if (lineEndReset) {
@@ -624,7 +643,7 @@ function breakLongWord(word, width, tracker) {
             currentWidth = 0;
         }
         currentLine += grapheme;
-        currentWidth += graphemeWidth;
+        currentWidth += clusterWidth;
     }
     if (currentLine) {
         // No reset at end of final segment - caller handles continuation
@@ -708,12 +727,12 @@ export function truncateToWidth(text, maxWidth, ellipsis = "...", pad = false) {
         // Skip empty graphemes to avoid issues with string-width calculation
         if (!grapheme)
             continue;
-        const graphemeWidth = visibleWidth(grapheme);
-        if (currentWidth + graphemeWidth > targetWidth) {
+        const clusterWidth = visibleWidth(grapheme);
+        if (currentWidth + clusterWidth > targetWidth) {
             break;
         }
         result += grapheme;
-        currentWidth += graphemeWidth;
+        currentWidth += clusterWidth;
     }
     // Add reset code before ellipsis to prevent styling leaking into it
     const truncated = `${result}\x1b[0m${ellipsis}`;
@@ -750,7 +769,7 @@ export function sliceWithWidth(line, startCol, length, strict = false) {
         while (textEnd < line.length && !extractAnsiCode(line, textEnd))
             textEnd++;
         for (const { segment } of segmenter.segment(line.slice(i, textEnd))) {
-            const w = graphemeWidth(segment);
+            const w = measureClusterWidth(segment);
             const inRange = currentCol >= startCol && currentCol < endCol;
             const fits = !strict || currentCol + w <= endCol;
             if (inRange && fits) {
@@ -772,7 +791,7 @@ export function sliceWithWidth(line, startCol, length, strict = false) {
     return { text: result, width: resultWidth };
 }
 // Pooled tracker instance for extractSegments (avoids allocation per call)
-const pooledStyleTracker = new AnsiCodeTracker();
+const pooledStyleTracker = new AnsiStateTracker();
 /**
  * Extract "before" and "after" segments from a line in a single pass.
  * Used for overlay compositing where we need content before and after the overlay region.
@@ -806,7 +825,7 @@ export function extractSegments(line, beforeEnd, afterStart, afterLen, strictAft
         while (textEnd < line.length && !extractAnsiCode(line, textEnd))
             textEnd++;
         for (const { segment } of segmenter.segment(line.slice(i, textEnd))) {
-            const w = graphemeWidth(segment);
+            const w = measureClusterWidth(segment);
             if (currentCol < beforeEnd) {
                 if (pendingAnsiBefore) {
                     before += pendingAnsiBefore;