pi2dsh 0.2.0

package/dist/pi-tui-utils-CcaVtm-3.mjs

@@ -0,0 +1,895 @@
+
+import { eastAsianWidth } from "get-east-asian-width";
+//#region src/compat/vendor/pi-tui-utils.ts
+const graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+const wordSegmenter = new Intl.Segmenter(void 0, { granularity: "word" });
+/**
+* Get the shared grapheme segmenter instance.
+*/
+function getGraphemeSegmenter() {
+	return graphemeSegmenter;
+}
+/**
+* Get the shared word segmenter instance.
+*/
+function getWordSegmenter() {
+	return wordSegmenter;
+}
+/**
+* Check if a grapheme cluster (after segmentation) could possibly be an RGI emoji.
+* This is a fast heuristic to avoid the expensive rgiEmojiRegex test.
+* The tested Unicode blocks are deliberately broad to account for future
+* Unicode additions.
+*/
+function couldBeEmoji(segment) {
+	const cp = segment.codePointAt(0);
+	return cp >= 126976 && cp <= 130047 || cp >= 8960 && cp <= 9215 || cp >= 9728 && cp <= 10175 || cp >= 11088 && cp <= 11093 || segment.includes("️") || segment.length > 2;
+}
+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 nonPrintingCharRegex = /^(?:\p{Default_Ignorable_Code_Point}|\p{Control}|\p{Format}|\p{Mark}|\p{Surrogate})$/v;
+const markCharRegex = /^\p{Mark}$/v;
+const terminalSpacingMarkRegex = /^(?:[\p{Spacing_Mark}--[\u1734\u302E\u302F]]|[\u065F\u0F7F\u102B\u102C\u1031\u1033-\u1035\u1038\u103A-\u103E])+$/v;
+const rgiEmojiRegex = /^\p{RGI_Emoji}$/v;
+const WIDTH_CACHE_SIZE = 512;
+const widthCache = /* @__PURE__ */ new Map();
+const cjkBreakRegex = /[\p{Script_Extensions=Han}\p{Script_Extensions=Hiragana}\p{Script_Extensions=Katakana}\p{Script_Extensions=Hangul}\p{Script_Extensions=Bopomofo}]/u;
+function isPrintableAscii(str) {
+	for (let i = 0; i < str.length; i++) {
+		const code = str.charCodeAt(i);
+		if (code < 32 || code > 126) return false;
+	}
+	return true;
+}
+function truncateFragmentToWidth(text, maxWidth) {
+	if (maxWidth <= 0 || text.length === 0) return {
+		text: "",
+		width: 0
+	};
+	if (isPrintableAscii(text)) {
+		const clipped = text.slice(0, maxWidth);
+		return {
+			text: clipped,
+			width: clipped.length
+		};
+	}
+	const hasAnsi = text.includes("\x1B");
+	const hasTabs = text.includes("	");
+	if (!hasAnsi && !hasTabs) {
+		let result = "";
+		let width = 0;
+		for (const { segment } of graphemeSegmenter.segment(text)) {
+			const w = graphemeWidth(segment);
+			if (width + w > maxWidth) break;
+			result += segment;
+			width += w;
+		}
+		return {
+			text: result,
+			width
+		};
+	}
+	let result = "";
+	let width = 0;
+	let i = 0;
+	let pendingAnsi = "";
+	while (i < text.length) {
+		const ansi = extractAnsiCode(text, i);
+		if (ansi) {
+			pendingAnsi += ansi.code;
+			i += ansi.length;
+			continue;
+		}
+		if (text[i] === "	") {
+			if (width + 3 > maxWidth) break;
+			if (pendingAnsi) {
+				result += pendingAnsi;
+				pendingAnsi = "";
+			}
+			result += "	";
+			width += 3;
+			i++;
+			continue;
+		}
+		let end = i;
+		while (end < text.length && text[end] !== "	") {
+			if (extractAnsiCode(text, end)) break;
+			end++;
+		}
+		for (const { segment } of graphemeSegmenter.segment(text.slice(i, end))) {
+			const w = graphemeWidth(segment);
+			if (width + w > maxWidth) return {
+				text: result,
+				width
+			};
+			if (pendingAnsi) {
+				result += pendingAnsi;
+				pendingAnsi = "";
+			}
+			result += segment;
+			width += w;
+		}
+		i = end;
+	}
+	return {
+		text: result,
+		width
+	};
+}
+function finalizeTruncatedResult(prefix, prefixWidth, ellipsis, ellipsisWidth, maxWidth, pad) {
+	const reset = "\x1B[0m";
+	const hyperlinkClose = getActiveOsc8Close(prefix);
+	const visibleWidth = prefixWidth + ellipsisWidth;
+	let result;
+	if (ellipsis.length > 0) result = `${prefix}${hyperlinkClose}${reset}${ellipsis}${reset}`;
+	else result = `${prefix}${hyperlinkClose}${reset}`;
+	return pad ? result + " ".repeat(Math.max(0, maxWidth - visibleWidth)) : result;
+}
+/**
+* Calculate the terminal width of a single grapheme cluster.
+* 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) {
+	if (segment === "	") return 3;
+	if (terminalSpacingMarkRegex.test(segment)) return [...segment].length;
+	if (zeroWidthRegex.test(segment)) return 0;
+	if (couldBeEmoji(segment) && rgiEmojiRegex.test(segment)) return 2;
+	const base = segment.replace(leadingNonPrintingRegex, "");
+	const cp = base.codePointAt(0);
+	if (cp === void 0) return 0;
+	if (cp >= 127462 && cp <= 127487) return 2;
+	let width = eastAsianWidth(cp);
+	let followsMark = false;
+	const chars = [...base];
+	for (const char of chars.slice(1)) if (terminalSpacingMarkRegex.test(char)) {
+		width += 1;
+		followsMark = false;
+	} else if (markCharRegex.test(char)) followsMark = true;
+	else if (!nonPrintingCharRegex.test(char)) {
+		const c = char.codePointAt(0);
+		if (followsMark || c >= 65280 && c <= 65519) width += eastAsianWidth(c);
+		else if (c === 3635 || c === 3763) width += 1;
+		followsMark = false;
+	}
+	return width;
+}
+/**
+* Calculate the visible width of a string in terminal columns.
+*/
+function visibleWidth(str) {
+	if (str.length === 0) return 0;
+	if (isPrintableAscii(str)) return str.length;
+	const cached = widthCache.get(str);
+	if (cached !== void 0) return cached;
+	let clean = str;
+	if (str.includes("	")) clean = clean.replace(/\t/g, "   ");
+	if (clean.includes("\x1B")) {
+		let stripped = "";
+		let i = 0;
+		while (i < clean.length) {
+			const ansi = extractAnsiCode(clean, i);
+			if (ansi) {
+				i += ansi.length;
+				continue;
+			}
+			stripped += clean[i];
+			i++;
+		}
+		clean = stripped;
+	}
+	let width = 0;
+	for (const { segment } of graphemeSegmenter.segment(clean)) width += graphemeWidth(segment);
+	if (widthCache.size >= WIDTH_CACHE_SIZE) {
+		const firstKey = widthCache.keys().next().value;
+		if (firstKey !== void 0) widthCache.delete(firstKey);
+	}
+	widthCache.set(str, width);
+	return width;
+}
+/** Remove ANSI, OSC, and APC control sequences while preserving visible text. */
+function stripTerminalSequences(str) {
+	if (!str.includes("\x1B")) return str;
+	let result = "";
+	let i = 0;
+	while (i < str.length) {
+		const ansi = extractAnsiCode(str, i);
+		if (ansi) {
+			i += ansi.length;
+			continue;
+		}
+		result += str[i];
+		i++;
+	}
+	return result;
+}
+/** Return the terminal-cell range occupied by the grapheme at a visible column. */
+function getGraphemeCellRange(line, column) {
+	let currentCol = 0;
+	let i = 0;
+	while (i < line.length) {
+		const ansi = extractAnsiCode(line, i);
+		if (ansi) {
+			i += ansi.length;
+			continue;
+		}
+		let textEnd = i;
+		while (textEnd < line.length && !extractAnsiCode(line, textEnd)) textEnd++;
+		for (const { segment } of graphemeSegmenter.segment(line.slice(i, textEnd))) {
+			const width = graphemeWidth(segment);
+			if (width > 0 && column >= currentCol && column < currentCol + width) return {
+				start: currentCol,
+				end: currentCol + width
+			};
+			currentCol += width;
+		}
+		i = textEnd;
+	}
+}
+/** Return the OSC 8 hyperlink covering a visible terminal column. */
+function getOsc8LinkAtColumn(line, column) {
+	let activeUrl;
+	let currentCol = 0;
+	let i = 0;
+	while (i < line.length) {
+		const ansi = extractAnsiCode(line, i);
+		if (ansi) {
+			const hyperlink = /^\x1b\]8;[^;]*;([^\x07\x1b]*)(?:\x07|\x1b\\)$/.exec(ansi.code);
+			if (hyperlink) activeUrl = hyperlink[1] || void 0;
+			i += ansi.length;
+			continue;
+		}
+		let textEnd = i;
+		while (textEnd < line.length && !extractAnsiCode(line, textEnd)) textEnd++;
+		for (const { segment } of graphemeSegmenter.segment(line.slice(i, textEnd))) {
+			const width = segment === "	" ? 3 : graphemeWidth(segment);
+			if (column >= currentCol && column < currentCol + width) return activeUrl;
+			currentCol += width;
+		}
+		i = textEnd;
+	}
+}
+/**
+* Normalize text for terminal output without changing logical editor content.
+* Some terminals render precomposed Thai/Lao AM vowels inconsistently during
+* differential repaint. Their compatibility decompositions have the same cell
+* width but avoid stale-cell artifacts in terminal renderers. Visible tabs are
+* expanded to the fixed width used by layout so terminal tab stops cannot wrap
+* a logical line, while tabs inside terminal string sequences stay untouched.
+*/
+const THAI_LAO_AM_REGEX = /[\u0e33\u0eb3]/;
+const THAI_LAO_AM_GLOBAL_REGEX = /[\u0e33\u0eb3]/g;
+function normalizeTerminalOutput(str) {
+	let normalized = str;
+	if (THAI_LAO_AM_REGEX.test(normalized)) normalized = normalized.replace(THAI_LAO_AM_GLOBAL_REGEX, (char) => char === "ำ" ? "ํา" : "ໍາ");
+	if (!normalized.includes("	")) return normalized;
+	let result = "";
+	let i = 0;
+	while (i < normalized.length) {
+		const ansi = extractAnsiCode(normalized, i);
+		if (ansi) {
+			result += ansi.code;
+			i += ansi.length;
+			continue;
+		}
+		result += normalized[i] === "	" ? "   " : normalized[i];
+		i++;
+	}
+	return result;
+}
+/**
+* Extract ANSI escape sequences from a string at the given position.
+*/
+function extractAnsiCode(str, pos) {
+	if (pos >= str.length || str[pos] !== "\x1B") return null;
+	const next = str[pos + 1];
+	if (next === "[") {
+		let j = pos + 2;
+		while (j < str.length && !/[mGKHJ]/.test(str[j])) j++;
+		if (j < str.length) return {
+			code: str.substring(pos, j + 1),
+			length: j + 1 - pos
+		};
+		return null;
+	}
+	if (next === "]") {
+		let j = pos + 2;
+		while (j < str.length) {
+			if (str[j] === "\x07") return {
+				code: str.substring(pos, j + 1),
+				length: j + 1 - pos
+			};
+			if (str[j] === "\x1B" && str[j + 1] === "\\") return {
+				code: str.substring(pos, j + 2),
+				length: j + 2 - pos
+			};
+			j++;
+		}
+		return null;
+	}
+	if (next === "_") {
+		let j = pos + 2;
+		while (j < str.length) {
+			if (str[j] === "\x07") return {
+				code: str.substring(pos, j + 1),
+				length: j + 1 - pos
+			};
+			if (str[j] === "\x1B" && str[j + 1] === "\\") return {
+				code: str.substring(pos, j + 2),
+				length: j + 2 - pos
+			};
+			j++;
+		}
+		return null;
+	}
+	return null;
+}
+function parseOsc8Hyperlink(ansiCode) {
+	if (!ansiCode.startsWith("\x1B]8;")) return;
+	const terminator = ansiCode.endsWith("\x07") ? "\x07" : "\x1B\\";
+	const body = ansiCode.slice(4, terminator === "\x07" ? -1 : -2);
+	const separatorIndex = body.indexOf(";");
+	if (separatorIndex === -1) return;
+	const params = body.slice(0, separatorIndex);
+	const url = body.slice(separatorIndex + 1);
+	if (!url) return null;
+	return {
+		params,
+		url,
+		terminator
+	};
+}
+function formatOsc8Hyperlink(hyperlink) {
+	return `\x1b]8;${hyperlink.params};${hyperlink.url}${hyperlink.terminator}`;
+}
+function formatOsc8Close(terminator) {
+	return `\x1b]8;;${terminator}`;
+}
+function getActiveOsc8Close(prefix) {
+	if (!prefix.includes("\x1B]8;")) return "";
+	let activeHyperlink = null;
+	let i = 0;
+	while (i < prefix.length) {
+		const ansi = extractAnsiCode(prefix, i);
+		if (ansi) {
+			const hyperlink = parseOsc8Hyperlink(ansi.code);
+			if (hyperlink !== void 0) activeHyperlink = hyperlink;
+			i += ansi.length;
+		} else i++;
+	}
+	return activeHyperlink ? formatOsc8Close(activeHyperlink.terminator) : "";
+}
+/**
+* Track active ANSI SGR codes to preserve styling across line breaks.
+*/
+var AnsiCodeTracker = class {
+	bold = false;
+	dim = false;
+	italic = false;
+	underline = false;
+	blink = false;
+	inverse = false;
+	hidden = false;
+	strikethrough = false;
+	fgColor = null;
+	bgColor = null;
+	activeHyperlink = null;
+	process(ansiCode) {
+		const hyperlink = parseOsc8Hyperlink(ansiCode);
+		if (hyperlink !== void 0) {
+			this.activeHyperlink = hyperlink;
+			return;
+		}
+		if (!ansiCode.endsWith("m")) return;
+		const match = ansiCode.match(/\x1b\[([\d;]*)m/);
+		if (!match) return;
+		const params = match[1];
+		if (params === "" || params === "0") {
+			this.reset();
+			return;
+		}
+		const parts = params.split(";");
+		let i = 0;
+		while (i < parts.length) {
+			const code = Number.parseInt(parts[i], 10);
+			if (code === 38 || code === 48) {
+				if (parts[i + 1] === "5" && parts[i + 2] !== void 0) {
+					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] !== void 0) {
+					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;
+				}
+			}
+			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;
+				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;
+				case 49:
+					this.bgColor = null;
+					break;
+				default: if (code >= 30 && code <= 37 || code >= 90 && code <= 97) this.fgColor = String(code);
+				else if (code >= 40 && code <= 47 || code >= 100 && code <= 107) this.bgColor = String(code);
+			}
+			i++;
+		}
+	}
+	reset() {
+		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;
+	}
+	/** Clear all state for reuse. */
+	clear() {
+		this.reset();
+		this.activeHyperlink = null;
+	}
+	getActiveCodes() {
+		const codes = [];
+		if (this.bold) codes.push("1");
+		if (this.dim) codes.push("2");
+		if (this.italic) codes.push("3");
+		if (this.underline) codes.push("4");
+		if (this.blink) codes.push("5");
+		if (this.inverse) codes.push("7");
+		if (this.hidden) codes.push("8");
+		if (this.strikethrough) codes.push("9");
+		if (this.fgColor) codes.push(this.fgColor);
+		if (this.bgColor) codes.push(this.bgColor);
+		let result = codes.length > 0 ? `\x1b[${codes.join(";")}m` : "";
+		if (this.activeHyperlink) result += formatOsc8Hyperlink(this.activeHyperlink);
+		return result;
+	}
+	hasActiveCodes() {
+		return this.bold || this.dim || this.italic || this.underline || this.blink || this.inverse || this.hidden || this.strikethrough || this.fgColor !== null || this.bgColor !== null || this.activeHyperlink !== null;
+	}
+	/**
+	* Get reset codes for attributes that need to be turned off at line end.
+	* Underline must be closed to prevent bleeding into padding.
+	* Active OSC 8 hyperlinks must be closed and re-opened on the next line.
+	* Returns empty string if no attributes need closing.
+	*/
+	getLineEndReset() {
+		let result = "";
+		if (this.underline) result += "\x1B[24m";
+		if (this.activeHyperlink) result += formatOsc8Close(this.activeHyperlink.terminator);
+		return result;
+	}
+};
+function updateTrackerFromText(text, tracker) {
+	let i = 0;
+	while (i < text.length) {
+		const ansiResult = extractAnsiCode(text, i);
+		if (ansiResult) {
+			tracker.process(ansiResult.code);
+			i += ansiResult.length;
+		} else i++;
+	}
+}
+/**
+* Split text into words while keeping ANSI codes attached.
+*/
+function splitIntoTokensWithAnsi(text) {
+	const tokens = [];
+	let current = "";
+	let pendingAnsi = "";
+	let currentKind = null;
+	let i = 0;
+	const flushCurrent = () => {
+		if (!current) return;
+		tokens.push(current);
+		current = "";
+		currentKind = null;
+	};
+	while (i < text.length) {
+		const ansiResult = extractAnsiCode(text, i);
+		if (ansiResult) {
+			pendingAnsi += ansiResult.code;
+			i += ansiResult.length;
+			continue;
+		}
+		let end = i;
+		while (end < text.length && !extractAnsiCode(text, end)) end++;
+		for (const { segment } of graphemeSegmenter.segment(text.slice(i, end))) {
+			const segmentIsSpace = segment === " ";
+			if (!segmentIsSpace && cjkBreakRegex.test(segment)) {
+				flushCurrent();
+				const token = pendingAnsi + segment;
+				pendingAnsi = "";
+				tokens.push(token);
+				continue;
+			}
+			const segmentKind = segmentIsSpace ? "space" : "word";
+			if (current && currentKind !== segmentKind) flushCurrent();
+			if (pendingAnsi) {
+				current += pendingAnsi;
+				pendingAnsi = "";
+			}
+			currentKind = segmentKind;
+			current += segment;
+		}
+		i = end;
+	}
+	if (pendingAnsi) {
+		if (current) current += pendingAnsi;
+		else if (tokens.length > 0) tokens[tokens.length - 1] += pendingAnsi;
+		else current = pendingAnsi;
+	}
+	if (current) tokens.push(current);
+	return tokens;
+}
+/**
+* Wrap text with ANSI codes preserved.
+*
+* ONLY does word wrapping - NO padding, NO background colors.
+* Returns lines where each line is <= width visible chars.
+* Active ANSI codes are preserved across line breaks.
+*
+* @param text - Text to wrap (may contain ANSI codes and newlines)
+* @param width - Maximum visible width per line
+* @returns Array of wrapped lines (NOT padded to width)
+*/
+function wrapTextWithAnsi(text, width) {
+	if (!text) return [""];
+	const inputLines = text.split(/\r\n|\r|\n/);
+	const result = [];
+	const tracker = new AnsiCodeTracker();
+	for (const inputLine of inputLines) {
+		const wrappedLines = wrapSingleLine((result.length > 0 ? tracker.getActiveCodes() : "") + inputLine, width);
+		for (const wrappedLine of wrappedLines) result.push(wrappedLine);
+		updateTrackerFromText(inputLine, tracker);
+	}
+	return result.length > 0 ? result : [""];
+}
+function wrapSingleLine(line, width) {
+	if (!line) return [""];
+	if (visibleWidth(line) <= 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() === "";
+		if (tokenVisibleLength > width && !isWhitespace) {
+			if (currentLine) {
+				const lineEndReset = tracker.getLineEndReset();
+				if (lineEndReset) currentLine += lineEndReset;
+				wrapped.push(currentLine);
+				currentLine = "";
+				currentVisibleLength = 0;
+			}
+			const broken = breakLongWord(token, width, tracker);
+			for (let i = 0; i < broken.length - 1; i++) wrapped.push(broken[i]);
+			currentLine = broken[broken.length - 1];
+			currentVisibleLength = visibleWidth(currentLine);
+			continue;
+		}
+		if (currentVisibleLength + tokenVisibleLength > 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;
+		}
+		updateTrackerFromText(token, tracker);
+	}
+	if (currentLine) wrapped.push(currentLine);
+	return wrapped.length > 0 ? wrapped.map((line) => line.trimEnd()) : [""];
+}
+const PUNCTUATION_REGEX = /[(){}[\]<>.,;:'"!?+\-=*/\\|&%^$#@~`]/;
+/**
+* Check if a character is whitespace.
+*/
+function isWhitespaceChar(char) {
+	return /\s/.test(char);
+}
+/**
+* Check if a character is punctuation.
+*/
+function isPunctuationChar(char) {
+	return PUNCTUATION_REGEX.test(char);
+}
+function breakLongWord(word, width, tracker) {
+	const lines = [];
+	let currentLine = tracker.getActiveCodes();
+	let currentWidth = 0;
+	let i = 0;
+	const segments = [];
+	while (i < word.length) {
+		const ansiResult = extractAnsiCode(word, i);
+		if (ansiResult) {
+			segments.push({
+				type: "ansi",
+				value: ansiResult.code
+			});
+			i += ansiResult.length;
+		} else {
+			let end = i;
+			while (end < word.length) {
+				if (extractAnsiCode(word, end)) break;
+				end++;
+			}
+			const textPortion = word.slice(i, end);
+			for (const seg of graphemeSegmenter.segment(textPortion)) segments.push({
+				type: "grapheme",
+				value: seg.segment
+			});
+			i = end;
+		}
+	}
+	for (const seg of segments) {
+		if (seg.type === "ansi") {
+			currentLine += seg.value;
+			tracker.process(seg.value);
+			continue;
+		}
+		const grapheme = seg.value;
+		if (!grapheme) continue;
+		const graphemeWidth = visibleWidth(grapheme);
+		if (currentWidth + graphemeWidth > width) {
+			const lineEndReset = tracker.getLineEndReset();
+			if (lineEndReset) currentLine += lineEndReset;
+			lines.push(currentLine);
+			currentLine = tracker.getActiveCodes();
+			currentWidth = 0;
+		}
+		currentLine += grapheme;
+		currentWidth += graphemeWidth;
+	}
+	if (currentLine) lines.push(currentLine);
+	return lines.length > 0 ? lines : [""];
+}
+/**
+* Apply background color to a line, padding to full width.
+*
+* @param line - Line of text (may contain ANSI codes)
+* @param width - Total width to pad to
+* @param bgFn - Background color function
+* @returns Line with background applied and padded to width
+*/
+function applyBackgroundToLine(line, width, bgFn) {
+	const visibleLen = visibleWidth(line);
+	const paddingNeeded = Math.max(0, width - visibleLen);
+	return bgFn(line + " ".repeat(paddingNeeded));
+}
+/**
+* Truncate text to fit within a maximum visible width, adding ellipsis if needed.
+* Optionally pad with spaces to reach exactly maxWidth.
+* Properly handles ANSI escape codes (they don't count toward width).
+*
+* @param text - Text to truncate (may contain ANSI codes)
+* @param maxWidth - Maximum visible width
+* @param ellipsis - Ellipsis string to append when truncating (default: "...")
+* @param pad - If true, pad result with spaces to exactly maxWidth (default: false)
+* @returns Truncated text, optionally padded to exactly maxWidth
+*/
+function truncateToWidth(text, maxWidth, ellipsis = "...", pad = false) {
+	if (maxWidth <= 0) return "";
+	if (text.length === 0) return pad ? " ".repeat(maxWidth) : "";
+	const ellipsisWidth = visibleWidth(ellipsis);
+	if (ellipsisWidth >= maxWidth) {
+		const textWidth = visibleWidth(text);
+		if (textWidth <= maxWidth) return pad ? text + " ".repeat(maxWidth - textWidth) : text;
+		const clippedEllipsis = truncateFragmentToWidth(ellipsis, maxWidth);
+		if (clippedEllipsis.width === 0) return pad ? " ".repeat(maxWidth) : "";
+		return finalizeTruncatedResult("", 0, clippedEllipsis.text, clippedEllipsis.width, maxWidth, pad);
+	}
+	if (isPrintableAscii(text)) {
+		if (text.length <= maxWidth) return pad ? text + " ".repeat(maxWidth - text.length) : text;
+		const targetWidth = maxWidth - ellipsisWidth;
+		return finalizeTruncatedResult(text.slice(0, targetWidth), targetWidth, ellipsis, ellipsisWidth, maxWidth, pad);
+	}
+	const targetWidth = maxWidth - ellipsisWidth;
+	let result = "";
+	let pendingAnsi = "";
+	let visibleSoFar = 0;
+	let keptWidth = 0;
+	let keepContiguousPrefix = true;
+	let overflowed = false;
+	let exhaustedInput = false;
+	const hasAnsi = text.includes("\x1B");
+	const hasTabs = text.includes("	");
+	if (!hasAnsi && !hasTabs) {
+		for (const { segment } of graphemeSegmenter.segment(text)) {
+			const width = graphemeWidth(segment);
+			if (keepContiguousPrefix && keptWidth + width <= targetWidth) {
+				result += segment;
+				keptWidth += width;
+			} else keepContiguousPrefix = false;
+			visibleSoFar += width;
+			if (visibleSoFar > maxWidth) {
+				overflowed = true;
+				break;
+			}
+		}
+		exhaustedInput = !overflowed;
+	} else {
+		let i = 0;
+		while (i < text.length) {
+			const ansi = extractAnsiCode(text, i);
+			if (ansi) {
+				pendingAnsi += ansi.code;
+				i += ansi.length;
+				continue;
+			}
+			if (text[i] === "	") {
+				if (keepContiguousPrefix && keptWidth + 3 <= targetWidth) {
+					if (pendingAnsi) {
+						result += pendingAnsi;
+						pendingAnsi = "";
+					}
+					result += "	";
+					keptWidth += 3;
+				} else {
+					keepContiguousPrefix = false;
+					pendingAnsi = "";
+				}
+				visibleSoFar += 3;
+				if (visibleSoFar > maxWidth) {
+					overflowed = true;
+					break;
+				}
+				i++;
+				continue;
+			}
+			let end = i;
+			while (end < text.length && text[end] !== "	") {
+				if (extractAnsiCode(text, end)) break;
+				end++;
+			}
+			for (const { segment } of graphemeSegmenter.segment(text.slice(i, end))) {
+				const width = graphemeWidth(segment);
+				if (keepContiguousPrefix && keptWidth + width <= targetWidth) {
+					if (pendingAnsi) {
+						result += pendingAnsi;
+						pendingAnsi = "";
+					}
+					result += segment;
+					keptWidth += width;
+				} else {
+					keepContiguousPrefix = false;
+					pendingAnsi = "";
+				}
+				visibleSoFar += width;
+				if (visibleSoFar > maxWidth) {
+					overflowed = true;
+					break;
+				}
+			}
+			if (overflowed) break;
+			i = end;
+		}
+		exhaustedInput = i >= text.length;
+	}
+	if (!overflowed && exhaustedInput) return pad ? text + " ".repeat(Math.max(0, maxWidth - visibleSoFar)) : text;
+	return finalizeTruncatedResult(result, keptWidth, ellipsis, ellipsisWidth, maxWidth, pad);
+}
+/**
+* Extract a range of visible columns from a line. Handles ANSI codes and wide chars.
+* @param strict - If true, exclude wide chars at boundary that would extend past the range
+*/
+function sliceByColumn(line, startCol, length, strict = false) {
+	return sliceWithWidth(line, startCol, length, strict).text;
+}
+/** Like sliceByColumn but also returns the actual visible width of the result. */
+function sliceWithWidth(line, startCol, length, strict = false) {
+	if (length <= 0) return {
+		text: "",
+		width: 0
+	};
+	const endCol = startCol + length;
+	let result = "", resultWidth = 0, currentCol = 0, i = 0, pendingAnsi = "";
+	while (i < line.length) {
+		const ansi = extractAnsiCode(line, i);
+		if (ansi) {
+			if (currentCol >= startCol && currentCol < endCol) result += ansi.code;
+			else if (currentCol < startCol) pendingAnsi += ansi.code;
+			i += ansi.length;
+			continue;
+		}
+		let textEnd = i;
+		while (textEnd < line.length && !extractAnsiCode(line, textEnd)) textEnd++;
+		for (const { segment } of graphemeSegmenter.segment(line.slice(i, textEnd))) {
+			const w = graphemeWidth(segment);
+			const inRange = currentCol >= startCol && currentCol < endCol;
+			const fits = !strict || currentCol + w <= endCol;
+			if (inRange && fits) {
+				if (pendingAnsi) {
+					result += pendingAnsi;
+					pendingAnsi = "";
+				}
+				result += segment;
+				resultWidth += w;
+			}
+			currentCol += w;
+			if (currentCol >= endCol) break;
+		}
+		i = textEnd;
+		if (currentCol >= endCol) break;
+	}
+	return {
+		text: result,
+		width: resultWidth
+	};
+}
+new AnsiCodeTracker();
+//#endregion
+export { wrapTextWithAnsi as _, getGraphemeCellRange as a, getWordSegmenter as c, normalizeTerminalOutput as d, sliceByColumn as f, visibleWidth as g, truncateToWidth as h, extractAnsiCode as i, isPunctuationChar as l, stripTerminalSequences as m, applyBackgroundToLine as n, getGraphemeSegmenter as o, sliceWithWidth as p, cjkBreakRegex as r, getOsc8LinkAtColumn as s, PUNCTUATION_REGEX as t, isWhitespaceChar as u };
+
+//# sourceMappingURL=pi-tui-utils-CcaVtm-3.mjs.map