@simon_he/vue-tui 1.0.1 → 1.1.0

package/dist/frame-perf-CHpWhbC4.js

@@ -0,0 +1,111 @@
+//#region src/observability/frame-perf.ts
+const FRAME_PERF_REASON_PRIORITY = {
+	unknown: 0,
+	manual: 1,
+	data: 2,
+	selection: 3,
+	stream: 4,
+	resize: 5,
+	scroll: 6,
+	input: 7
+};
+const EMPTY_METRIC_STATS = Object.freeze({
+	avg: 0,
+	max: 0,
+	min: 0
+});
+function metricStats(values) {
+	if (!values.length) return EMPTY_METRIC_STATS;
+	let sum = 0;
+	let max = Number.NEGATIVE_INFINITY;
+	let min = Number.POSITIVE_INFINITY;
+	for (const value of values) {
+		sum += value;
+		if (value > max) max = value;
+		if (value < min) min = value;
+	}
+	return {
+		avg: sum / values.length,
+		max,
+		min
+	};
+}
+function summarizeFramePerf(samples) {
+	const durationMs = [];
+	const renderManagerMs = [];
+	const commitMs = [];
+	const domFlushMs = [];
+	const stdoutFlushMs = [];
+	const dirtyRows = [];
+	const scannedNodes = [];
+	const paintedNodes = [];
+	const reasons = {};
+	const activePlanes = {};
+	let fullDirtyFrames = 0;
+	let coalescedInvalidates = 0;
+	let coalescedFrameTasks = 0;
+	let droppedUpdates = 0;
+	let maxQueueDepth = 0;
+	let rowBucketFallbacks = 0;
+	for (const sample of samples) {
+		durationMs.push(sample.durationMs);
+		renderManagerMs.push(sample.renderManagerMs);
+		commitMs.push(sample.commitMs);
+		scannedNodes.push(sample.scannedNodes);
+		paintedNodes.push(sample.paintedNodes);
+		if (sample.domFlushMs != null) domFlushMs.push(sample.domFlushMs);
+		if (sample.stdoutFlushMs != null) stdoutFlushMs.push(sample.stdoutFlushMs);
+		if (sample.dirtyRows == null) fullDirtyFrames++;
+		else dirtyRows.push(sample.dirtyRows);
+		reasons[sample.reason] = (reasons[sample.reason] ?? 0) + 1;
+		const planes = sample.activePlanes;
+		if (!planes) activePlanes.all = (activePlanes.all ?? 0) + 1;
+		else for (const plane of planes) activePlanes[plane] = (activePlanes[plane] ?? 0) + 1;
+		coalescedInvalidates += sample.coalescedInvalidates;
+		coalescedFrameTasks += sample.coalescedFrameTasks;
+		droppedUpdates += sample.droppedUpdates;
+		if (sample.queueDepth > maxQueueDepth) maxQueueDepth = sample.queueDepth;
+		rowBucketFallbacks += sample.rowBucketFallbacks?.length ?? 0;
+	}
+	const first = samples[0] ?? null;
+	const latest = samples[samples.length - 1] ?? null;
+	return {
+		frames: samples.length,
+		firstFrameId: first?.frameId ?? null,
+		latestFrameId: latest?.frameId ?? null,
+		windowMs: first && latest ? Math.max(0, latest.startedAt - first.startedAt) : 0,
+		durationMs: metricStats(durationMs),
+		renderManagerMs: metricStats(renderManagerMs),
+		commitMs: metricStats(commitMs),
+		domFlushMs: metricStats(domFlushMs),
+		stdoutFlushMs: metricStats(stdoutFlushMs),
+		dirtyRows: {
+			avg: dirtyRows.length ? dirtyRows.reduce((sum, value) => sum + value, 0) / dirtyRows.length : 0,
+			max: dirtyRows.length ? Math.max(...dirtyRows) : 0,
+			sampledFrames: dirtyRows.length,
+			fullFrames: fullDirtyFrames
+		},
+		scannedNodes: metricStats(scannedNodes),
+		paintedNodes: metricStats(paintedNodes),
+		coalescedInvalidates,
+		coalescedFrameTasks,
+		droppedUpdates,
+		maxQueueDepth,
+		rowBucketFallbacks,
+		reasons,
+		activePlanes
+	};
+}
+function framePerfNow() {
+	const p = globalThis.performance;
+	if (p && typeof p.now === "function") return p.now();
+	return Date.now();
+}
+function mergeFramePerfReason(prev, next) {
+	const a = prev ?? "unknown";
+	const b = next ?? "unknown";
+	return FRAME_PERF_REASON_PRIORITY[b] > FRAME_PERF_REASON_PRIORITY[a] ? b : a;
+}
+
+//#endregion
+export { framePerfNow, mergeFramePerfReason, summarizeFramePerf };

package/dist/{create-terminal-C2oiWFJU.js → hyperlink-_1FAj7Wq.js}

@@ -1,5 +1,4 @@
-import { charCellWidth, segmentedGraphemes } from "./hyperlink-Bn02UXJb.js";
-import { parseAnsiSgr } from "./sgr-BmzxEjAO.js";
+import { charCellWidth, segmentedGraphemes } from "./width-GqllnV8C.js";
 
 //#region src/core/render-plane.ts
 const TERMINAL_RENDER_PLANES = [
@@ -9,6 +8,309 @@ const TERMINAL_RENDER_PLANES = [
 	"overlay"
 ];
 
+//#endregion
+//#region src/core/ansi/sgr.ts
+const ESC = "\x1B";
+function ansi16ToColorName(code) {
+	switch (code) {
+		case 30: return "black";
+		case 31: return "red";
+		case 32: return "green";
+		case 33: return "yellow";
+		case 34: return "blue";
+		case 35: return "magenta";
+		case 36: return "cyan";
+		case 37: return "white";
+		case 90: return "blackBright";
+		case 91: return "redBright";
+		case 92: return "greenBright";
+		case 93: return "yellowBright";
+		case 94: return "blueBright";
+		case 95: return "magentaBright";
+		case 96: return "cyanBright";
+		case 97: return "whiteBright";
+		default: return void 0;
+	}
+}
+function ansi16BgToColorName(code) {
+	const fgCode = code >= 40 && code <= 47 ? code - 10 : code >= 100 && code <= 107 ? code - 10 : null;
+	if (fgCode == null) return void 0;
+	return ansi16ToColorName(fgCode);
+}
+const ANSI16_RGB = {
+	black: {
+		r: 0,
+		g: 0,
+		b: 0
+	},
+	red: {
+		r: 201,
+		g: 27,
+		b: 0
+	},
+	green: {
+		r: 0,
+		g: 194,
+		b: 0
+	},
+	yellow: {
+		r: 199,
+		g: 196,
+		b: 0
+	},
+	blue: {
+		r: 2,
+		g: 37,
+		b: 199
+	},
+	magenta: {
+		r: 201,
+		g: 48,
+		b: 199
+	},
+	cyan: {
+		r: 0,
+		g: 197,
+		b: 199
+	},
+	white: {
+		r: 199,
+		g: 199,
+		b: 199
+	},
+	blackBright: {
+		r: 104,
+		g: 104,
+		b: 104
+	},
+	redBright: {
+		r: 255,
+		g: 110,
+		b: 103
+	},
+	greenBright: {
+		r: 95,
+		g: 250,
+		b: 104
+	},
+	yellowBright: {
+		r: 255,
+		g: 252,
+		b: 103
+	},
+	blueBright: {
+		r: 104,
+		g: 113,
+		b: 255
+	},
+	magentaBright: {
+		r: 255,
+		g: 118,
+		b: 255
+	},
+	cyanBright: {
+		r: 95,
+		g: 253,
+		b: 255
+	},
+	whiteBright: {
+		r: 255,
+		g: 255,
+		b: 255
+	}
+};
+function nearestAnsi16(r, g, b) {
+	let best = "white";
+	let bestDist = Number.POSITIVE_INFINITY;
+	for (const [name, rgb] of Object.entries(ANSI16_RGB)) {
+		const dr = r - rgb.r;
+		const dg = g - rgb.g;
+		const db = b - rgb.b;
+		const d = dr * dr + dg * dg + db * db;
+		if (d < bestDist) {
+			bestDist = d;
+			best = name;
+		}
+	}
+	return best;
+}
+function ansi256ToRgb(index) {
+	const n = Math.max(0, Math.min(255, Math.trunc(index)));
+	if (n < 16) {
+		const map = [
+			"black",
+			"red",
+			"green",
+			"yellow",
+			"blue",
+			"magenta",
+			"cyan",
+			"white",
+			"blackBright",
+			"redBright",
+			"greenBright",
+			"yellowBright",
+			"blueBright",
+			"magentaBright",
+			"cyanBright",
+			"whiteBright"
+		];
+		const name = map[n] ?? "white";
+		return ANSI16_RGB[name];
+	}
+	if (n >= 232) {
+		const c = 8 + (n - 232) * 10;
+		return {
+			r: c,
+			g: c,
+			b: c
+		};
+	}
+	const i = n - 16;
+	const rr = Math.floor(i / 36);
+	const gg = Math.floor(i % 36 / 6);
+	const bb = i % 6;
+	const toComponent = (v) => v === 0 ? 0 : 55 + v * 40;
+	return {
+		r: toComponent(rr),
+		g: toComponent(gg),
+		b: toComponent(bb)
+	};
+}
+function applyAnsiSgrStyle(current, codes) {
+	let next = { ...current };
+	for (let i = 0; i < codes.length; i++) {
+		const code = codes[i];
+		if (code === 0) {
+			next = {};
+			continue;
+		}
+		if (code === 1) next = {
+			...next,
+			bold: true
+		};
+		else if (code === 2) next = {
+			...next,
+			dim: true
+		};
+		else if (code === 3) next = {
+			...next,
+			italic: true
+		};
+		else if (code === 4) next = {
+			...next,
+			underline: true
+		};
+		else if (code === 7) next = {
+			...next,
+			inverse: true
+		};
+		else if (code === 22) next = {
+			...next,
+			bold: false,
+			dim: false
+		};
+		else if (code === 23) next = {
+			...next,
+			italic: false
+		};
+		else if (code === 24) next = {
+			...next,
+			underline: false
+		};
+		else if (code === 27) next = {
+			...next,
+			inverse: false
+		};
+		else if (code === 39) next = {
+			...next,
+			fg: void 0
+		};
+		else if (code === 49) next = {
+			...next,
+			bg: void 0
+		};
+		else if (code >= 30 && code <= 37 || code >= 90 && code <= 97) {
+			const fg = ansi16ToColorName(code);
+			next = {
+				...next,
+				fg: fg ?? next.fg
+			};
+		} else if (code >= 40 && code <= 47 || code >= 100 && code <= 107) {
+			const bg = ansi16BgToColorName(code);
+			next = {
+				...next,
+				bg: bg ?? next.bg
+			};
+		} else if (code === 38 || code === 48) {
+			const mode = codes[i + 1];
+			if (mode === 5) {
+				const idx = codes[i + 2];
+				if (idx != null) {
+					const { r, g, b } = ansi256ToRgb(idx);
+					const name = nearestAnsi16(r, g, b);
+					next = code === 38 ? {
+						...next,
+						fg: name
+					} : {
+						...next,
+						bg: name
+					};
+				}
+				i += 2;
+			} else if (mode === 2) {
+				const r = codes[i + 2];
+				const g = codes[i + 3];
+				const b = codes[i + 4];
+				if (r != null && g != null && b != null) {
+					const name = nearestAnsi16(r, g, b);
+					next = code === 38 ? {
+						...next,
+						fg: name
+					} : {
+						...next,
+						bg: name
+					};
+				}
+				i += 4;
+			}
+		}
+	}
+	return next;
+}
+function parseAnsiSgr(input, baseStyle = {}) {
+	const segments = [];
+	let style = { ...baseStyle };
+	let lastIndex = 0;
+	for (let i = 0; i < input.length; i++) {
+		if (input[i] !== ESC || input[i + 1] !== "[") continue;
+		let j = i + 2;
+		while (j < input.length) {
+			const c = input.charCodeAt(j);
+			if (c >= 48 && c <= 57 || c === 59) {
+				j++;
+				continue;
+			}
+			break;
+		}
+		if (j >= input.length || input[j] !== "m") continue;
+		if (i > lastIndex) segments.push({
+			text: input.slice(lastIndex, i),
+			style
+		});
+		const body = input.slice(i + 2, j);
+		const codes = body.split(";").filter(Boolean).map((n) => Number.parseInt(n, 10)).filter((n) => Number.isFinite(n));
+		style = applyAnsiSgrStyle(style, codes.length ? codes : [0]);
+		lastIndex = j + 1;
+		i = j;
+	}
+	if (lastIndex < input.length) segments.push({
+		text: input.slice(lastIndex),
+		style
+	});
+	return segments;
+}
+
 //#endregion
 //#region src/core/buffer/buffer.ts
 const DEFAULT_STYLE = Object.freeze({});
@@ -106,14 +408,14 @@ function clamp(n, min, max) {
 	return Math.max(min, Math.min(max, n));
 }
 /**
-* Register a fingerprint function on the buffer. This enables SoA fingerprint
+* Register or clear a fingerprint function on the buffer. This enables SoA fingerprint
 * pre-computation: cell writes will update fingerprints inline, and the renderer
 * can read them via getRowFingerprints() instead of per-cell hash computation.
 */
 function setFingerprintFn(buffer, fn) {
 	buffer.fingerprintFn = fn;
 	const len = buffer.rows * buffer.cols;
-	if (!len) {
+	if (!fn || !len) {
 		buffer.soaFingerprints = null;
 		return;
 	}
@@ -134,7 +436,10 @@ function setFingerprintFn(buffer, fn) {
 */
 function getRowFingerprints(buffer, y) {
 	if (!buffer.soaFingerprints) return null;
-	const physY = physicalRowIndex(buffer, y);
+	if (buffer.rows <= 0 || buffer.cols <= 0) return null;
+	const yy = Math.floor(y);
+	if (!Number.isFinite(yy) || yy < 0 || yy >= buffer.rows) return null;
+	const physY = physicalRowIndex(buffer, yy);
 	const base = physY * buffer.cols;
 	return buffer.soaFingerprints.subarray(base, base + buffer.cols);
 }
@@ -424,9 +729,12 @@ function resizeBuffer(buffer, cols, rows) {
 	const nextCols = Math.max(0, Math.floor(cols));
 	const nextRows = Math.max(0, Math.floor(rows));
 	if (nextCols === buffer.cols && nextRows === buffer.rows) return;
+	const prevRows = buffer.rows;
+	const prevDirtyAll = buffer.dirtyAll;
+	const prevDirtyBits = buffer.dirtyBits;
 	const blank = createBlankCell();
 	const nextGrid = Array.from({ length: nextRows }, () => Array.from({ length: nextCols }, () => blank));
-	const copyRows = Math.min(buffer.rows, nextRows);
+	const copyRows = Math.min(prevRows, nextRows);
 	const copyCols = Math.min(buffer.cols, nextCols);
 	for (let y = 0; y < copyRows; y++) {
 		const src = getBufferRow(buffer, y);
@@ -450,10 +758,21 @@ function resizeBuffer(buffer, cols, rows) {
 	buffer.cols = nextCols;
 	buffer.rows = nextRows;
 	buffer.dirtyBits = new Uint8Array(nextRows);
-	buffer.dirtyCount = nextRows || 0;
-	buffer.dirtyMin = nextRows ? 0 : Number.POSITIVE_INFINITY;
-	buffer.dirtyMax = nextRows ? nextRows - 1 : -1;
-	buffer.dirtyAll = nextRows > 0;
+	buffer.dirtyCount = 0;
+	buffer.dirtyMin = Number.POSITIVE_INFINITY;
+	buffer.dirtyMax = -1;
+	buffer.dirtyAll = prevDirtyAll && nextRows > 0;
+	if (buffer.dirtyAll) {
+		buffer.dirtyCount = nextRows;
+		buffer.dirtyMin = 0;
+		buffer.dirtyMax = nextRows - 1;
+	} else for (let y = 0; y < copyRows; y++) {
+		if (prevDirtyBits[y] !== 1) continue;
+		buffer.dirtyBits[y] = 1;
+		buffer.dirtyCount++;
+		if (y < buffer.dirtyMin) buffer.dirtyMin = y;
+		if (y > buffer.dirtyMax) buffer.dirtyMax = y;
+	}
 	buffer.cursorX = clamp(buffer.cursorX, 0, Math.max(0, nextCols));
 	buffer.cursorY = clamp(buffer.cursorY, 0, Math.max(0, nextRows - 1));
 	if (buffer.fingerprintFn) {
@@ -526,6 +845,10 @@ function mergePlanes(prev, next) {
 	return Array.from(merged);
 }
 const TERMINAL_PLANE_INTERNALS = Symbol.for("@simon_he/vue-tui:v1:terminal-plane-internals");
+const TERMINAL_ROOT = Symbol.for("@simon_he/vue-tui:v1:terminal-root");
+function getRootTerminal(terminal) {
+	return terminal[TERMINAL_ROOT] ?? terminal;
+}
 function createCoverage(cols, rows) {
 	return Array.from({ length: rows }, () => new Uint8Array(cols));
 }
@@ -609,6 +932,8 @@ function markPlaneCoverageRange(state, x0, y0, x1, y1, value) {
 	}
 }
 function markPlaneCoverageForPut(state, x, y, ch, prevCell) {
+	if (!Number.isSafeInteger(x) || !Number.isSafeInteger(y)) return;
+	if (x < 0 || x >= state.buffer.cols || y < 0 || y >= state.buffer.rows) return;
 	const row = state.coverage[y];
 	if (!row) return;
 	if (prevCell?.continuation && x > 0) row[x - 1] = 1;
@@ -724,10 +1049,14 @@ function createTerminal(opts) {
 	}
 	function putForPlane(plane, x, y, ch, style) {
 		const state = getPlaneState(plane);
-		if (y < 0 || y >= state.buffer.rows || x < 0 || x >= state.buffer.cols) return;
-		const prevCell = getBufferCell(state.buffer, x, y);
-		putCell(state.buffer, x, y, ch, style);
-		markPlaneCoverageForPut(state, x, y, ch, prevCell);
+		if (typeof x !== "number" || typeof y !== "number") return;
+		const cellX = Math.floor(x);
+		const cellY = Math.floor(y);
+		if (!Number.isFinite(cellX) || !Number.isFinite(cellY)) return;
+		if (cellY < 0 || cellY >= state.buffer.rows || cellX < 0 || cellX >= state.buffer.cols) return;
+		const prevCell = getBufferCell(state.buffer, cellX, cellY);
+		putCell(state.buffer, cellX, cellY, ch, style);
+		markPlaneCoverageForPut(state, cellX, cellY, ch, prevCell);
 	}
 	function writeAtForPlane(plane, text, x, y, style) {
 		const state = getPlaneState(plane);
@@ -1219,13 +1548,18 @@ function createTerminal(opts) {
 			},
 			setFingerprintFn(fn) {
 				assertNotDisposed();
-				base.setFingerprintFn(fn);
+				const state = getPlaneState(plane);
+				setFingerprintFn(state.buffer, fn);
 			},
 			getRowFingerprints(y) {
 				assertNotDisposed();
-				return base.getRowFingerprints(y);
+				const yy = Math.floor(y);
+				const state = getPlaneState(plane);
+				if (!Number.isFinite(yy) || yy < 0 || yy >= state.buffer.rows) throw new RangeError("Row out of bounds");
+				return getRowFingerprints(state.buffer, yy);
 			}
 		};
+		api[TERMINAL_ROOT] = base;
 		planeTerminals.set(plane, api);
 		return api;
 	}
@@ -1307,7 +1641,7 @@ function createTerminal(opts) {
 				const rows = collectAndClearDirtyRows(state.buffer);
 				if (rows === null) {
 					composeAllRows = true;
-					break;
+					continue;
 				}
 				for (const y of rows) dirtyRows.add(y);
 			}
@@ -1397,7 +1731,9 @@ function createTerminal(opts) {
 		},
 		getRowFingerprints(y) {
 			assertNotDisposed();
-			return getRowFingerprints(compositeBuffer, y);
+			const yy = Math.floor(y);
+			if (!Number.isFinite(yy) || yy < 0 || yy >= compositeBuffer.rows) throw new RangeError("Row out of bounds");
+			return getRowFingerprints(compositeBuffer, yy);
 		}
 	};
 	base[TERMINAL_PLANE_INTERNALS] = {
@@ -1427,8 +1763,108 @@ function createTerminal(opts) {
 			scrollRowsForPlane(plane, startY, endY, lines);
 		}
 	};
+	base[TERMINAL_ROOT] = base;
 	return base;
 }
 
 //#endregion
-export { TERMINAL_RENDER_PLANES, createTerminal, getPlaneTerminal, resetPlaneRowsForRender, scrollPlaneRows };
+//#region src/utils/url-safety.ts
+const ENCODED_ASCII_CONTROL_RE = /%(?:0[0-9a-f]|1[0-9a-f]|7f)/i;
+function hasControlCodePoint(value) {
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (code <= 31 || code >= 127 && code <= 159) return true;
+	}
+	return false;
+}
+function hasEncodedControl(value) {
+	let current = String(value ?? "");
+	for (let depth = 0; depth < 3; depth++) {
+		if (ENCODED_ASCII_CONTROL_RE.test(current)) return true;
+		let decoded;
+		try {
+			decoded = decodeURIComponent(current);
+		} catch {
+			return true;
+		}
+		if (hasControlCodePoint(decoded)) return true;
+		if (decoded === current) return false;
+		current = decoded;
+	}
+	return ENCODED_ASCII_CONTROL_RE.test(current) || hasControlCodePoint(current);
+}
+
+//#endregion
+//#region src/core/hyperlink.ts
+const SCHEME_RE = /^[a-z][a-z0-9+.-]*:/i;
+const BLOCKED_SCHEME_RE = /^(?:javascript|data|vbscript):/i;
+const SAFE_RELATIVE_HREF_RE = /^(?:[A-Za-z0-9._~!$&()*+,;=:@/?#-]|%[0-9A-Fa-f]{2})+$/u;
+function normalizeRawHref(value) {
+	if (typeof value !== "string") return null;
+	const raw = value.trim();
+	if (!raw) return null;
+	if (raw !== value) return null;
+	for (let i = 0; i < value.length; i++) {
+		const code = value.charCodeAt(i);
+		if (code <= 31 || code >= 127 && code <= 159) return null;
+	}
+	if (/\s/u.test(raw)) return null;
+	if (raw.startsWith("//")) return null;
+	if (BLOCKED_SCHEME_RE.test(raw)) return null;
+	if (hasEncodedControl(raw)) return null;
+	return raw;
+}
+function hrefScheme(raw) {
+	return raw.match(SCHEME_RE)?.[0].toLowerCase() ?? null;
+}
+function parseSafeAbsoluteUrl(raw) {
+	if (raw.includes("\\")) return null;
+	try {
+		return new URL(raw);
+	} catch {
+		return null;
+	}
+}
+function sanitizeAbsoluteHref(raw, options = {}) {
+	const url = parseSafeAbsoluteUrl(raw);
+	if (!url) return null;
+	if (url.protocol === "http:" || url.protocol === "https:") {
+		if (!/^https?:\/\//i.test(raw)) return null;
+		return options.preserveHttpHref ? raw : url.toString();
+	}
+	if (url.protocol === "mailto:") return raw;
+	return null;
+}
+function isSafeNormalizedRelativeHref(raw) {
+	if (raw.includes("\\")) return false;
+	if (raw.startsWith("//")) return false;
+	if (SCHEME_RE.test(raw)) return false;
+	if (hasEncodedControl(raw)) return false;
+	if (!SAFE_RELATIVE_HREF_RE.test(raw)) return false;
+	return raw.startsWith("#") || raw.startsWith("?") || raw.startsWith("/") || raw.startsWith("./") || raw.startsWith("../") || /^[A-Za-z0-9._~-]/u.test(raw);
+}
+function isSafeRelativeHref(value) {
+	const raw = normalizeRawHref(value);
+	return raw != null && isSafeNormalizedRelativeHref(raw);
+}
+function sanitizeTerminalHref(value, options = {}) {
+	const raw = normalizeRawHref(value);
+	if (!raw) return null;
+	const sanitized = sanitizeAbsoluteHref(raw, { preserveHttpHref: true });
+	if (sanitized) return sanitized;
+	if (options.allowFileUrls) {
+		const url = parseSafeAbsoluteUrl(raw);
+		if (url?.protocol === "file:") return url.toString();
+	}
+	return null;
+}
+function sanitizeDomHref(value, options = {}) {
+	const raw = normalizeRawHref(value);
+	if (!raw) return null;
+	const scheme = hrefScheme(raw);
+	if (!scheme) return options.allowRelative !== false && isSafeNormalizedRelativeHref(raw) ? raw : null;
+	return sanitizeAbsoluteHref(raw);
+}
+
+//#endregion
+export { TERMINAL_RENDER_PLANES, applyAnsiSgrStyle, createTerminal, getPlaneTerminal, getRootTerminal, hasEncodedControl, isSafeRelativeHref, parseAnsiSgr, resetPlaneRowsForRender, sanitizeDomHref, sanitizeTerminalHref, scrollPlaneRows };