@alchemy.run/sigil 0.0.0-alpha.4 → 0.0.0-alpha.6

package/dist/tokenize-Dx1y_l5H.d.ts

@@ -0,0 +1,57 @@
+//#region src/ansi/tokenize.d.ts
+/**
+An ANSI code paired with the code that ends its effect.
+*/
+type AnsiCode = {
+  readonly code: string;
+  readonly endCode: string;
+};
+type AnsiToken = AnsiCode & {
+  readonly type: "ansi";
+};
+type ControlToken = {
+  readonly type: "control";
+  readonly code: string;
+};
+type CharToken = {
+  readonly type: "char";
+  readonly value: string;
+  readonly fullWidth: boolean;
+};
+type Token = AnsiToken | ControlToken | CharToken;
+type StyledChar = CharToken & {
+  readonly styles: AnsiCode[];
+};
+declare const endCodesSet: Set<string>;
+declare function getLinkStartCode(url: string, params?: Record<string, string>): string;
+declare function getEndCode(code: string): string;
+declare function ansiCodesToString(codes: readonly AnsiCode[]): string;
+/**
+Check if a code is an intensity code (bold or dim) — these share the end code
+`22m` but can coexist.
+*/
+declare function isIntensityCode(code: AnsiCode): boolean;
+declare function tokenize(string: string, endChar?: number): Token[];
+/**
+Reduces the given array of ANSI codes to the minimum necessary to render with
+the same style.
+*/
+declare function reduceAnsiCodes(codes: readonly AnsiCode[]): AnsiCode[];
+/**
+Like {@link reduceAnsiCodes}, but assumes that `codes` is already reduced.
+Further reductions are only done for the items in `newCodes`.
+*/
+declare function reduceAnsiCodesIncremental(codes: readonly AnsiCode[], newCodes: readonly AnsiCode[]): AnsiCode[];
+/**
+Returns the combination of ANSI codes needed to undo the given ANSI codes.
+*/
+declare function undoAnsiCodes(codes: readonly AnsiCode[]): AnsiCode[];
+/**
+Returns the minimum amount of ANSI codes necessary to get from the compound
+style `from` to `to`. Both are expected to be reduced.
+*/
+declare function diffAnsiCodes(from: readonly AnsiCode[], to: readonly AnsiCode[]): AnsiCode[];
+declare function styledCharsFromTokens(tokens: readonly Token[]): StyledChar[];
+declare function styledCharsToString(chars: readonly StyledChar[]): string;
+//#endregion
+export { tokenize as _, StyledChar as a, diffAnsiCodes as c, getLinkStartCode as d, isIntensityCode as f, styledCharsToString as g, styledCharsFromTokens as h, ControlToken as i, endCodesSet as l, reduceAnsiCodesIncremental as m, AnsiToken as n, Token as o, reduceAnsiCodes as p, CharToken as r, ansiCodesToString as s, AnsiCode as t, getEndCode as u, undoAnsiCodes as v };

package/dist/truncate-D31fhU6i.js

@@ -0,0 +1,562 @@
+import { i as codes } from "./sgr-BhwaWAJB.js";
+import { d as tokenize, l as styledCharsFromTokens, u as styledCharsToString } from "./tokenize-AjqbvtiT.js";
+import { t as stringWidth } from "./string-width-CijQwpIk.js";
+//#region src/ansi/wrap.ts
+const ANSI_ESCAPE = "\x1B";
+const ANSI_ESCAPE_BELL = "\x07";
+const ANSI_CSI = "[";
+const ANSI_OSC = "]";
+const ANSI_SGR_TERMINATOR = "m";
+const ANSI_SGR_RESET = 0;
+const ANSI_SGR_RESET_FOREGROUND = 39;
+const ANSI_SGR_RESET_BACKGROUND = 49;
+const ANSI_SGR_RESET_UNDERLINE_COLOR = 59;
+const ANSI_SGR_FOREGROUND_EXTENDED = 38;
+const ANSI_SGR_BACKGROUND_EXTENDED = 48;
+const ANSI_SGR_UNDERLINE_COLOR_EXTENDED = 58;
+const ANSI_SGR_COLOR_MODE_RGB = 2;
+const ANSI_SGR_COLOR_MODE_256 = 5;
+const ANSI_ESCAPE_LINK = `${ANSI_OSC}8;`;
+const ESCAPES = /* @__PURE__ */ new Set([ANSI_ESCAPE, "›"]);
+const ESCAPE_CHARACTERS = [...ESCAPES].join("");
+const CSI_INTRODUCER = `(?:${ANSI_ESCAPE}\\${ANSI_CSI}|›)`;
+const CSI_PARAMETERS = "[0-?]*[ -/]*[@-~]";
+const SGR_PARAMETERS = `(?<sgr>[0-9;:]*)${ANSI_SGR_TERMINATOR}`;
+const OSC_STRING_TERMINATOR = `(?:${ANSI_ESCAPE_BELL}|${ANSI_ESCAPE}\\\\)`;
+const OSC_STRING_PAYLOAD = String.raw`[^\u0000-\u001F\u007F-\u009F]*`;
+const LINK_PARAMETERS = String.raw`8;(?<parameters>[^;\u0000-\u001F\u007F-\u009F]*);(?<uri>${OSC_STRING_PAYLOAD})${OSC_STRING_TERMINATOR}`;
+const OSC_STRING = `${OSC_STRING_PAYLOAD}${OSC_STRING_TERMINATOR}`;
+const ANSI_ESCAPE_REGEX = new RegExp(`${CSI_INTRODUCER}(?:${SGR_PARAMETERS}|${CSI_PARAMETERS})|${ANSI_ESCAPE}\\${ANSI_OSC}(?:${LINK_PARAMETERS}|${OSC_STRING})`, "y");
+const ANSI_SGR_MODIFIER_CLOSE_CODES = new Set(codes.values());
+ANSI_SGR_MODIFIER_CLOSE_CODES.delete(ANSI_SGR_RESET);
+const segmenter = new Intl.Segmenter();
+const getStringWidth = (string) => stringWidth(string);
+const TAB_SIZE = 8;
+const ESCAPE_INTRODUCER_REGEX = new RegExp(`[${ESCAPE_CHARACTERS}]`, "g");
+const ROW_BOUNDARY_REGEX = new RegExp(`[\\n${ESCAPE_CHARACTERS}]`, "g");
+const ASCII_PRINTABLE_REGEX = /^[ -~]*$/;
+const wrapAnsiCode = (code) => `${ANSI_ESCAPE}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`;
+const wrapAnsiHyperlink = (url, parameters = "") => `${ANSI_ESCAPE}${ANSI_ESCAPE_LINK}${parameters};${url}${ANSI_ESCAPE_BELL}`;
+const matchAnsiEscape = (string, index) => {
+	if (!ESCAPES.has(string[index])) return;
+	ANSI_ESCAPE_REGEX.lastIndex = index;
+	return ANSI_ESCAPE_REGEX.exec(string) ?? void 0;
+};
+const forEachSegment = (string, onPlainText, onEscape = () => {}) => {
+	let plainStart = 0;
+	let index = 0;
+	while (index < string.length) {
+		ESCAPE_INTRODUCER_REGEX.lastIndex = index;
+		const introducer = ESCAPE_INTRODUCER_REGEX.exec(string);
+		if (!introducer) break;
+		const escape = matchAnsiEscape(string, introducer.index);
+		if (!escape) {
+			index = introducer.index + 1;
+			continue;
+		}
+		if (introducer.index > plainStart) onPlainText(string.slice(plainStart, introducer.index));
+		onEscape(escape[0]);
+		index = introducer.index + escape[0].length;
+		plainStart = index;
+	}
+	if (plainStart < string.length) onPlainText(string.slice(plainStart));
+};
+const getWidth = (string) => {
+	let plainText = "";
+	forEachSegment(string, (part) => {
+		plainText += part;
+	});
+	return getStringWidth(plainText);
+};
+const getTokens = (string) => {
+	const tokens = [];
+	forEachSegment(string, (plainText) => {
+		if (ASCII_PRINTABLE_REGEX.test(plainText)) {
+			for (const character of plainText) tokens.push({
+				value: character,
+				width: 1
+			});
+			return;
+		}
+		for (const { segment } of segmenter.segment(plainText)) tokens.push({
+			value: segment,
+			width: getStringWidth(segment)
+		});
+	}, (escape) => {
+		tokens.push({
+			value: escape,
+			width: 0
+		});
+	});
+	return tokens;
+};
+const splitWords = (string) => {
+	let currentWord = {
+		value: "",
+		plainText: "",
+		width: 0
+	};
+	const words = [currentWord];
+	forEachSegment(string, (plainText) => {
+		const parts = plainText.split(" ");
+		currentWord.value += parts[0];
+		currentWord.plainText += parts[0];
+		for (let index = 1; index < parts.length; index++) {
+			currentWord = {
+				value: parts[index],
+				plainText: parts[index],
+				width: 0
+			};
+			words.push(currentWord);
+		}
+	}, (escape) => {
+		currentWord.value += escape;
+	});
+	for (const word of words) word.width = getStringWidth(word.plainText);
+	return words;
+};
+const EXTENDED_COLOR_CODES = /* @__PURE__ */ new Set([
+	ANSI_SGR_FOREGROUND_EXTENDED,
+	ANSI_SGR_BACKGROUND_EXTENDED,
+	ANSI_SGR_UNDERLINE_COLOR_EXTENDED
+]);
+const getColonColorToken = (parameter) => {
+	const parts = parameter.split(":");
+	const code = Number.parseInt(parts[0], 10);
+	const mode = Number.parseInt(parts[1], 10);
+	if (!EXTENDED_COLOR_CODES.has(code)) return;
+	if (mode === ANSI_SGR_COLOR_MODE_256 && parts.length === 3 && /^\d+$/.test(parts[2])) return {
+		code,
+		open: parameter,
+		hasArguments: true
+	};
+	if (mode !== ANSI_SGR_COLOR_MODE_RGB) return;
+	const components = parts.length === 6 ? parts.slice(3) : parts.slice(2);
+	const colorSpace = parts.length === 6 ? parts[2] : void 0;
+	if (components.length === 3 && components.every((component) => /^\d+$/.test(component)) && (colorSpace === void 0 || /^\d*$/.test(colorSpace))) return {
+		code,
+		open: parameter,
+		hasArguments: true
+	};
+};
+const getSgrTokens = (sgrParameters) => {
+	const parameters = sgrParameters.split(";");
+	const sgrTokens = [];
+	for (let index = 0; index < parameters.length; index++) {
+		const parameter = parameters[index];
+		if (parameter.includes(":")) {
+			const colonColorToken = getColonColorToken(parameter);
+			if (colonColorToken) sgrTokens.push(colonColorToken);
+			continue;
+		}
+		const code = parameter === "" ? ANSI_SGR_RESET : Number.parseInt(parameter, 10);
+		if (!Number.isFinite(code)) continue;
+		if (code === ANSI_SGR_FOREGROUND_EXTENDED || code === ANSI_SGR_BACKGROUND_EXTENDED || code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED) {
+			if (index + 1 >= parameters.length) break;
+			const mode = Number.parseInt(parameters[index + 1], 10);
+			const colorIndex = Number.parseInt(parameters[index + 2] ?? "", 10);
+			if (mode === ANSI_SGR_COLOR_MODE_256 && Number.isFinite(colorIndex)) {
+				sgrTokens.push({
+					code,
+					open: [
+						code,
+						mode,
+						colorIndex
+					].join(";"),
+					hasArguments: true
+				});
+				index += 2;
+				continue;
+			}
+			const red = Number.parseInt(parameters[index + 2] ?? "", 10);
+			const green = Number.parseInt(parameters[index + 3] ?? "", 10);
+			const blue = Number.parseInt(parameters[index + 4] ?? "", 10);
+			if (mode === ANSI_SGR_COLOR_MODE_RGB && Number.isFinite(red) && Number.isFinite(green) && Number.isFinite(blue)) {
+				sgrTokens.push({
+					code,
+					open: [
+						code,
+						mode,
+						red,
+						green,
+						blue
+					].join(";"),
+					hasArguments: true
+				});
+				index += 4;
+				continue;
+			}
+			break;
+		}
+		sgrTokens.push({
+			code,
+			open: String(code),
+			hasArguments: false
+		});
+	}
+	return sgrTokens;
+};
+const removeActiveStyle = (activeStyles, family) => {
+	const activeStyleIndex = activeStyles.findIndex((activeStyle) => activeStyle.family === family);
+	if (activeStyleIndex !== -1) activeStyles.splice(activeStyleIndex, 1);
+};
+const upsertActiveStyle = (activeStyles, nextActiveStyle) => {
+	removeActiveStyle(activeStyles, nextActiveStyle.family);
+	activeStyles.push(nextActiveStyle);
+};
+const removeModifierStylesByClose = (activeStyles, closeCode) => {
+	for (let index = activeStyles.length - 1; index >= 0; index--) {
+		const activeStyle = activeStyles[index];
+		if (activeStyle.family.startsWith("modifier-") && activeStyle.close === closeCode) activeStyles.splice(index, 1);
+	}
+};
+const getColorStyle = (sgrToken) => {
+	const { code, open, hasArguments } = sgrToken;
+	if (code >= 30 && code <= 37 || code >= 90 && code <= 97 || code === ANSI_SGR_FOREGROUND_EXTENDED && hasArguments) return {
+		family: "foreground",
+		open,
+		close: ANSI_SGR_RESET_FOREGROUND
+	};
+	if (code >= 40 && code <= 47 || code >= 100 && code <= 107 || code === ANSI_SGR_BACKGROUND_EXTENDED && hasArguments) return {
+		family: "background",
+		open,
+		close: ANSI_SGR_RESET_BACKGROUND
+	};
+	if (code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED && hasArguments) return {
+		family: "underlineColor",
+		open,
+		close: ANSI_SGR_RESET_UNDERLINE_COLOR
+	};
+};
+const applySgrResetCode = (code, activeStyles) => {
+	if (code === ANSI_SGR_RESET) {
+		activeStyles.length = 0;
+		return true;
+	}
+	if (code === ANSI_SGR_RESET_FOREGROUND) {
+		removeActiveStyle(activeStyles, "foreground");
+		return true;
+	}
+	if (code === ANSI_SGR_RESET_BACKGROUND) {
+		removeActiveStyle(activeStyles, "background");
+		return true;
+	}
+	if (code === ANSI_SGR_RESET_UNDERLINE_COLOR) {
+		removeActiveStyle(activeStyles, "underlineColor");
+		return true;
+	}
+	if (ANSI_SGR_MODIFIER_CLOSE_CODES.has(code)) {
+		removeModifierStylesByClose(activeStyles, code);
+		return true;
+	}
+	return false;
+};
+const applySgrToken = (sgrToken, activeStyles) => {
+	const { code } = sgrToken;
+	if (applySgrResetCode(code, activeStyles)) return;
+	const colorStyle = getColorStyle(sgrToken);
+	if (colorStyle) {
+		upsertActiveStyle(activeStyles, colorStyle);
+		return;
+	}
+	const close = codes.get(code);
+	if (close !== void 0 && close !== ANSI_SGR_RESET) upsertActiveStyle(activeStyles, {
+		family: `modifier-${code}`,
+		open: sgrToken.open,
+		close
+	});
+};
+const applySgrParameters = (sgrParameters, activeStyles) => {
+	for (const sgrToken of getSgrTokens(sgrParameters)) applySgrToken(sgrToken, activeStyles);
+};
+const applySgrResets = (sgrParameters, activeStyles) => {
+	for (const { code } of getSgrTokens(sgrParameters)) applySgrResetCode(code, activeStyles);
+};
+const applyLeadingSgrResets = (string, startIndex, activeStyles) => {
+	let index = startIndex;
+	while (index < string.length) {
+		const match = matchAnsiEscape(string, index);
+		if (!match) break;
+		if (match.groups?.["sgr"] !== void 0) applySgrResets(match.groups["sgr"], activeStyles);
+		index += match[0].length;
+	}
+};
+const getClosingSgrSequence = (activeStyles) => activeStyles.toReversed().map((activeStyle) => wrapAnsiCode(activeStyle.close)).join("");
+const getOpeningSgrSequence = (activeStyles) => activeStyles.map((activeStyle) => wrapAnsiCode(activeStyle.open)).join("");
+const wrapWord = (rows, word, columns, rowWidth) => {
+	const tokens = getTokens(word);
+	let visible = rowWidth;
+	for (let index = 0; index < tokens.length; index++) {
+		const token = tokens[index];
+		if (token.width > 0 && visible > 0 && visible + token.width > columns) {
+			rows.push("");
+			visible = 0;
+		}
+		rows[rows.length - 1] += token.value;
+		visible += token.width;
+		if (visible === columns && index < tokens.length - 1) {
+			rows.push("");
+			visible = 0;
+		}
+	}
+	if (!visible && rows.at(-1).length > 0 && rows.length > 1) {
+		const lastRow = rows.pop();
+		rows[rows.length - 1] = rows[rows.length - 1] + lastRow;
+	}
+	return getWidth(rows.at(-1));
+};
+const stringVisibleTrimSpacesRight = (string) => {
+	if (!string.includes(" ")) return string;
+	const segments = [];
+	forEachSegment(string, (plainText) => {
+		segments.push({
+			value: plainText,
+			isEscape: false
+		});
+	}, (escape) => {
+		segments.push({
+			value: escape,
+			isEscape: true
+		});
+	});
+	for (let index = segments.length - 1; index >= 0; index--) {
+		const segment = segments[index];
+		if (segment.isEscape) continue;
+		let end = segment.value.length;
+		while (end > 0 && segment.value[end - 1] === " ") end--;
+		segment.value = segment.value.slice(0, end);
+		if (getStringWidth(segment.value) > 0) break;
+	}
+	return segments.map((segment) => segment.value).join("");
+};
+const expandTabs = (line) => {
+	if (!line.includes("	")) return line;
+	let visible = 0;
+	let expandedLine = "";
+	let plainTextSinceTab = "";
+	const expandPlainText = (plainText) => {
+		const segments = plainText.split("	");
+		for (const [index, segment] of segments.entries()) {
+			expandedLine += segment;
+			plainTextSinceTab += segment;
+			if (index < segments.length - 1) {
+				visible += getStringWidth(plainTextSinceTab);
+				plainTextSinceTab = "";
+				const spaces = TAB_SIZE - visible % TAB_SIZE;
+				expandedLine += " ".repeat(spaces);
+				visible += spaces;
+			}
+		}
+	};
+	forEachSegment(line, expandPlainText, (escape) => {
+		expandedLine += escape;
+	});
+	return expandedLine;
+};
+const restoreStylesAcrossRows = (preString) => {
+	let returnValue = "";
+	let activeHyperlink;
+	const activeStyles = [];
+	let index = 0;
+	let copiedIndex = 0;
+	while (index < preString.length) {
+		ROW_BOUNDARY_REGEX.lastIndex = index;
+		const boundary = ROW_BOUNDARY_REGEX.exec(preString);
+		if (!boundary) break;
+		index = boundary.index;
+		if (boundary[0] !== "\n") {
+			const escape = matchAnsiEscape(preString, index);
+			if (!escape) {
+				index++;
+				continue;
+			}
+			const groups = escape.groups ?? {};
+			if (groups["sgr"] !== void 0) applySgrParameters(groups["sgr"], activeStyles);
+			else if (groups["uri"] !== void 0) activeHyperlink = groups["uri"].length === 0 ? void 0 : {
+				parameters: groups["parameters"] ?? "",
+				uri: groups["uri"]
+			};
+			index += escape[0].length;
+			continue;
+		}
+		returnValue += preString.slice(copiedIndex, index);
+		if (index > copiedIndex) {
+			if (activeHyperlink) returnValue += wrapAnsiHyperlink("");
+			returnValue += getClosingSgrSequence(activeStyles);
+		}
+		returnValue += "\n";
+		index++;
+		copiedIndex = index;
+		if (index < preString.length && preString[index] !== "\n") {
+			const openingStyles = [...activeStyles];
+			applyLeadingSgrResets(preString, index, openingStyles);
+			returnValue += getOpeningSgrSequence(openingStyles);
+			if (activeHyperlink) returnValue += wrapAnsiHyperlink(activeHyperlink.uri, activeHyperlink.parameters);
+		}
+	}
+	return returnValue + preString.slice(copiedIndex);
+};
+const exec = (string, columns, options = {}) => {
+	if (options.trim !== false && string.trim() === "") return "";
+	const words = splitWords(string);
+	let rows = [""];
+	let rowLength = 0;
+	let trimmedRowIndex = -1;
+	let isFirstWord = true;
+	for (const word of words) {
+		const rowIndex = rows.length - 1;
+		if (options.trim !== false && trimmedRowIndex !== rowIndex) {
+			const row = rows[rowIndex];
+			const trimmedRow = row.trimStart();
+			if (trimmedRow.length !== row.length) {
+				rows[rowIndex] = trimmedRow;
+				rowLength = getWidth(trimmedRow);
+			}
+			if (trimmedRow.length > 0) trimmedRowIndex = rowIndex;
+		}
+		if (isFirstWord) isFirstWord = false;
+		else {
+			if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+				rows.push("");
+				rowLength = 0;
+			}
+			if (rowLength > 0 || options.trim === false) {
+				rows[rows.length - 1] += " ";
+				rowLength++;
+			}
+		}
+		if (options.hard && options.wordWrap !== false && word.width > columns) {
+			const remainingColumns = columns - rowLength;
+			const breaksStartingThisLine = 1 + Math.floor((word.width - remainingColumns - 1) / columns);
+			if (Math.floor((word.width - 1) / columns) < breaksStartingThisLine) {
+				rows.push("");
+				rowLength = 0;
+			}
+			rowLength = wrapWord(rows, word.value, columns, rowLength);
+			continue;
+		}
+		if (rowLength + word.width > columns && rowLength > 0 && word.width > 0) {
+			if (options.wordWrap === false && rowLength < columns) {
+				rowLength = wrapWord(rows, word.value, columns, rowLength);
+				continue;
+			}
+			rows.push("");
+			rowLength = 0;
+		}
+		if (rowLength + word.width > columns && options.wordWrap === false) {
+			rowLength = wrapWord(rows, word.value, columns, rowLength);
+			continue;
+		}
+		rows[rows.length - 1] += word.value;
+		rowLength += word.width;
+	}
+	if (options.trim !== false) rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+	return restoreStylesAcrossRows(rows.join("\n"));
+};
+function wrapAnsi(string, columns, options) {
+	return string.normalize().replaceAll("\r\n", "\n").split("\n").map((line) => exec(expandTabs(line), columns, options)).join("\n");
+}
+//#endregion
+//#region src/ansi/slice.ts
+function sliceAnsi(string, start, end) {
+	const sliceEnd = end ?? Number.POSITIVE_INFINITY;
+	if (start >= sliceEnd || string === "") return "";
+	if (start === 0 && sliceEnd === Number.POSITIVE_INFINITY) return string;
+	const chars = styledCharsFromTokens(tokenize(string));
+	const included = [];
+	let column = 0;
+	for (const char of chars) {
+		const width = char.fullWidth ? 2 : 1;
+		if (column + width > sliceEnd) break;
+		if (column >= start) included.push(char);
+		column += width;
+	}
+	return styledCharsToString(included);
+}
+//#endregion
+//#region src/ansi/truncate.ts
+function getIndexOfNearestSpace(string, wantedIndex, shouldSearchRight = false) {
+	if (string.charAt(wantedIndex) === " ") return wantedIndex;
+	const direction = shouldSearchRight ? 1 : -1;
+	for (let index = 0; index <= 3; index++) {
+		const finalIndex = wantedIndex + index * direction;
+		if (string.charAt(finalIndex) === " ") return finalIndex;
+	}
+	return wantedIndex;
+}
+const ANSI_ESC = 27;
+const ANSI_LEFT_BRACKET = 91;
+const ANSI_LETTER_M = 109;
+const isSgrParameter = (code) => code >= 48 && code <= 57 || code === 59 || code === 58;
+function leadingSgrSpanEndIndex(string) {
+	let index = 0;
+	while (index + 2 < string.length && string.codePointAt(index) === ANSI_ESC && string.codePointAt(index + 1) === ANSI_LEFT_BRACKET) {
+		let scan = index + 2;
+		while (scan < string.length && isSgrParameter(string.codePointAt(scan))) scan++;
+		if (scan < string.length && string.codePointAt(scan) === ANSI_LETTER_M) {
+			index = scan + 1;
+			continue;
+		}
+		break;
+	}
+	return index;
+}
+function trailingSgrSpanStartIndex(string) {
+	let start = string.length;
+	while (start > 1 && string.codePointAt(start - 1) === ANSI_LETTER_M) {
+		let scan = start - 2;
+		while (scan >= 0 && isSgrParameter(string.codePointAt(scan))) scan--;
+		if (scan >= 1 && string.codePointAt(scan - 1) === ANSI_ESC && string.codePointAt(scan) === ANSI_LEFT_BRACKET) {
+			start = scan - 1;
+			continue;
+		}
+		break;
+	}
+	return start;
+}
+function appendWithInheritedStyleFromEnd(visible, suffix) {
+	const start = trailingSgrSpanStartIndex(visible);
+	if (start === visible.length) return visible + suffix;
+	return visible.slice(0, start) + suffix + visible.slice(start);
+}
+function prependWithInheritedStyleFromStart(prefix, visible) {
+	const end = leadingSgrSpanEndIndex(visible);
+	if (end === 0) return prefix + visible;
+	return visible.slice(0, end) + prefix + visible.slice(end);
+}
+function cliTruncate(text, columns, options = {}) {
+	const { position = "end", space = false, preferTruncationOnSpace = false } = options;
+	let { truncationCharacter = "…" } = options;
+	if (columns < 1) return "";
+	const length = stringWidth(text);
+	if (length <= columns) return text;
+	if (columns === 1) return truncationCharacter;
+	if (position === "start") {
+		if (preferTruncationOnSpace) {
+			const right = sliceAnsi(text, getIndexOfNearestSpace(text, length - columns + stringWidth(truncationCharacter), true), length).trim();
+			return prependWithInheritedStyleFromStart(truncationCharacter, right);
+		}
+		if (space) truncationCharacter += " ";
+		const right = sliceAnsi(text, length - columns + stringWidth(truncationCharacter), length);
+		return prependWithInheritedStyleFromStart(truncationCharacter, right);
+	}
+	if (position === "middle") {
+		if (space) {
+			truncationCharacter = ` ${truncationCharacter} `;
+			if (stringWidth(truncationCharacter) >= columns) truncationCharacter = truncationCharacter.trim();
+		}
+		const truncationWidth = stringWidth(truncationCharacter);
+		const half = Math.min(Math.floor(columns / 2), Math.max(0, columns - truncationWidth));
+		if (preferTruncationOnSpace) {
+			const spaceNearFirstBreakPoint = getIndexOfNearestSpace(text, half);
+			const spaceNearSecondBreakPoint = getIndexOfNearestSpace(text, length - (columns - half) + truncationWidth, true);
+			return sliceAnsi(text, 0, spaceNearFirstBreakPoint) + truncationCharacter + sliceAnsi(text, spaceNearSecondBreakPoint, length).trim();
+		}
+		return sliceAnsi(text, 0, half) + truncationCharacter + sliceAnsi(text, length - (columns - half) + truncationWidth, length);
+	}
+	if (preferTruncationOnSpace) return appendWithInheritedStyleFromEnd(sliceAnsi(text, 0, getIndexOfNearestSpace(text, columns - stringWidth(truncationCharacter))), truncationCharacter);
+	if (space) truncationCharacter = ` ${truncationCharacter}`;
+	return appendWithInheritedStyleFromEnd(sliceAnsi(text, 0, columns - stringWidth(truncationCharacter)), truncationCharacter);
+}
+//#endregion
+export { sliceAnsi as n, wrapAnsi as r, cliTruncate as t };