@bud.sh/app 0.5.0 → 0.6.0

package/dist/node-host/assets/dist-BCSTeNf4.js

@@ -0,0 +1,4785 @@
+//#region ../../node_modules/.pnpm/@wterm+core@0.5.4/node_modules/@wterm/core/dist/wasm-loading.js
+var embedded;
+var modules = /* @__PURE__ */ new Map();
+var MAX_CACHED_MODULES = 4;
+function decodeBase64(base64) {
+	const binary = atob(base64);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes.buffer;
+}
+async function compileUrl(url) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`[wterm] Failed to load WASM from ${url}: ${response.status} ${response.statusText}`);
+	if (typeof WebAssembly.compileStreaming === "function" && response.headers.get("Content-Type")?.trim().toLowerCase() === "application/wasm") try {
+		return await WebAssembly.compileStreaming(response.clone());
+	} catch {}
+	return WebAssembly.compile(await response.arrayBuffer());
+}
+/** Share compiled code, including pending work; callers create fresh instances. */
+function loadWasmModule(url) {
+	if (!url) {
+		embedded ?? (embedded = import("./wasm-inline-Dl9tqabx.js").then(({ WASM_BASE64 }) => WebAssembly.compile(decodeBase64(WASM_BASE64))).catch((error) => {
+			embedded = void 0;
+			throw error;
+		}));
+		return embedded;
+	}
+	if (typeof document !== "undefined") url = new URL(url, document.baseURI).href;
+	else if (typeof location !== "undefined") url = new URL(url, location.href).href;
+	const key = url;
+	const cached = modules.get(key);
+	if (cached) {
+		modules.delete(key);
+		modules.set(key, cached);
+		return cached;
+	}
+	const pending = compileUrl(key).catch((error) => {
+		if (modules.get(key) === pending) modules.delete(key);
+		throw error;
+	});
+	modules.set(key, pending);
+	if (modules.size > MAX_CACHED_MODULES) modules.delete(modules.keys().next().value);
+	return pending;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+core@0.5.4/node_modules/@wterm/core/dist/wasm-bridge.js
+var WasmBridge = class WasmBridge {
+	get dv() {
+		if (this._dvBuffer !== this.memory.buffer) {
+			this._dvBuffer = this.memory.buffer;
+			this._dv = new DataView(this.memory.buffer);
+		}
+		return this._dv;
+	}
+	constructor(instance) {
+		this.gridPtr = 0;
+		this.dirtyPtr = 0;
+		this.writeBufferPtr = 0;
+		this.cellSize = 12;
+		this.gridStride = 0;
+		this.encoder = new TextEncoder();
+		this.decoder = new TextDecoder();
+		this._dvBuffer = null;
+		this.linkCache = /* @__PURE__ */ new Map();
+		this.exports = instance.exports;
+		this.memory = this.exports.memory;
+	}
+	static async load(url) {
+		const module = await loadWasmModule(url);
+		const instance = await WebAssembly.instantiate(module);
+		return new WasmBridge(instance);
+	}
+	init(cols, rows) {
+		this.exports.init(cols, rows);
+		this.linkCache.clear();
+		this._updatePointers();
+	}
+	_updatePointers() {
+		this.gridPtr = this.exports.getGridPtr();
+		this.dirtyPtr = this.exports.getDirtyPtr();
+		this.writeBufferPtr = this.exports.getWriteBuffer();
+		this.cellSize = this.exports.getCellSize();
+		this.gridStride = this.exports.getGridStride();
+	}
+	writeString(str, afterChunk) {
+		const encoded = this.encoder.encode(str);
+		this.writeRaw(encoded, afterChunk);
+	}
+	writeRaw(data, afterChunk) {
+		let offset = 0;
+		while (offset < data.length) {
+			const chunk = Math.min(data.length - offset, 8192);
+			new Uint8Array(this.memory.buffer, this.writeBufferPtr, 8192).set(data.subarray(offset, offset + chunk));
+			this.exports.writeBytes(chunk);
+			this._updatePointers();
+			offset += chunk;
+			afterChunk?.();
+		}
+	}
+	getCell(row, col) {
+		const offset = this.gridPtr + (row * this.gridStride + col) * this.cellSize;
+		const dv = this.dv;
+		const result = {
+			char: dv.getUint32(offset, true),
+			fg: dv.getUint16(offset + 4, true),
+			bg: dv.getUint16(offset + 6, true),
+			flags: dv.getUint8(offset + 8),
+			width: dv.getUint8(offset + 9)
+		};
+		Object.assign(result, this._readLink(dv.getUint16(offset + 10, true)));
+		return result;
+	}
+	isDirtyRow(row) {
+		return new Uint8Array(this.memory.buffer, this.dirtyPtr, this.getRows())[row] !== 0;
+	}
+	clearDirty() {
+		this.exports.clearDirty();
+	}
+	getCursor() {
+		const shape = this.exports.getCursorShape?.() ?? 0;
+		return {
+			row: this.exports.getCursorRow(),
+			col: this.exports.getCursorCol(),
+			visible: this.exports.getCursorVisible() !== 0,
+			shape: shape === 1 ? "underline" : shape === 2 ? "bar" : "block",
+			blinking: (this.exports.getCursorBlinking?.() ?? 0) !== 0
+		};
+	}
+	getCols() {
+		return this.exports.getCols();
+	}
+	getRows() {
+		return this.exports.getRows();
+	}
+	cursorKeysApp() {
+		return this.exports.getCursorKeysApp() !== 0;
+	}
+	bracketedPaste() {
+		return this.exports.getBracketedPaste() !== 0;
+	}
+	usingAltScreen() {
+		return this.exports.getUsingAltScreen() !== 0;
+	}
+	mouseTracking() {
+		const mode = this.exports.getMouseTracking();
+		return mode === 1e3 || mode === 1002 || mode === 1003 ? mode : 0;
+	}
+	mouseSgr() {
+		return this.exports.getMouseSgr() !== 0;
+	}
+	mouseEncoding() {
+		switch (this.exports.getMouseEncoding?.()) {
+			case 0: return "x10";
+			case 1: return "utf8";
+			case 2: return "sgr";
+			case 3: return "urxvt";
+			case 4: return "sgr-pixels";
+			case void 0: return this.mouseSgr() ? "sgr" : "x10";
+			default: return null;
+		}
+	}
+	focusEvents() {
+		return this.exports.getFocusEvents() !== 0;
+	}
+	synchronizedOutput() {
+		return this.exports.getSynchronizedOutput() !== 0;
+	}
+	synchronizedOutputGeneration() {
+		return this.exports.getSynchronizedOutputGeneration();
+	}
+	kittyKeyboardFlags() {
+		return this.exports.getKittyKeyboardFlags?.() ?? 0;
+	}
+	getTitle() {
+		if (this.exports.getTitleChanged() === 0) return null;
+		const ptr = this.exports.getTitlePtr();
+		const len = this.exports.getTitleLen();
+		const bytes = new Uint8Array(this.memory.buffer, ptr, len);
+		return this.decoder.decode(bytes);
+	}
+	getBellCount() {
+		return this.exports.getBellCount?.() ?? 0;
+	}
+	getResponse() {
+		const len = this.exports.getResponseLen();
+		if (len === 0) return null;
+		const ptr = this.exports.getResponsePtr();
+		const bytes = new Uint8Array(this.memory.buffer, ptr, len);
+		const str = this.decoder.decode(bytes);
+		this.exports.clearResponse();
+		return str;
+	}
+	getResourceState() {
+		const capacity = this.exports.getHyperlinkCapacity?.();
+		const used = this.exports.getHyperlinkCount?.();
+		const rejected = this.exports.getHyperlinkRejectedCount?.();
+		if (capacity === void 0 || used === void 0 || rejected === void 0) return {};
+		return { hyperlinks: {
+			capacity,
+			used,
+			rejected,
+			saturated: used >= capacity
+		} };
+	}
+	getScrollbackCount() {
+		return this.exports.getScrollbackCount();
+	}
+	getScrollbackDiscardedCount() {
+		return this.exports.getScrollbackDiscardedCount();
+	}
+	getScrollbackCell(offset, col) {
+		const off = this.exports.getScrollbackLine(offset) + col * this.cellSize;
+		const dv = this.dv;
+		const result = {
+			char: dv.getUint32(off, true),
+			fg: dv.getUint16(off + 4, true),
+			bg: dv.getUint16(off + 6, true),
+			flags: dv.getUint8(off + 8),
+			width: dv.getUint8(off + 9)
+		};
+		Object.assign(result, this._readLink(dv.getUint16(off + 10, true)));
+		return result;
+	}
+	getScrollbackLineLen(offset) {
+		return this.exports.getScrollbackLineLen(offset);
+	}
+	getUnhandledSequences() {
+		const count = this.exports.getDebugLogCount();
+		if (count === 0) return [];
+		const ptr = this.exports.getDebugLogPtr();
+		const entrySize = this.exports.getDebugLogEntrySize();
+		const maxEntries = this.exports.getDebugLogMax();
+		const total = Math.min(count, maxEntries);
+		const dv = new DataView(this.memory.buffer);
+		const entries = [];
+		const startIdx = count >= maxEntries ? count % maxEntries : 0;
+		for (let i = 0; i < total; i++) {
+			const off = ptr + (startIdx + i) % maxEntries * entrySize;
+			const finalByte = dv.getUint8(off);
+			if (finalByte === 0) continue;
+			const privateByte = dv.getUint8(off + 1);
+			const paramCount = dv.getUint8(off + 2);
+			const params = [];
+			for (let p = 0; p < Math.min(paramCount, 4); p++) params.push(dv.getUint16(off + 4 + p * 2, true));
+			entries.push({
+				final: String.fromCharCode(finalByte),
+				private: privateByte ? String.fromCharCode(privateByte) : "",
+				paramCount,
+				params
+			});
+		}
+		return entries;
+	}
+	resize(cols, rows) {
+		this.exports.resizeTerminal(cols, rows);
+		this._updatePointers();
+	}
+	_readLink(index) {
+		if (index === 0) return void 0;
+		const cached = this.linkCache.get(index);
+		if (cached) return cached;
+		const uriLen = this.exports.getLinkUriLen(index);
+		if (uriLen === 0) return void 0;
+		const uri = this.decoder.decode(new Uint8Array(this.memory.buffer, this.exports.getLinkUriPtr(index), uriLen));
+		const idLen = this.exports.getLinkIdLen(index);
+		const linkId = idLen === 0 ? void 0 : this.decoder.decode(new Uint8Array(this.memory.buffer, this.exports.getLinkIdPtr(index), idLen));
+		const value = {
+			linkUri: uri,
+			linkId,
+			linkKey: linkId ? `e\0${linkId}\0${uri}` : `b\0${index}`
+		};
+		this.linkCache.set(index, value);
+		return value;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/graphics-layer.js
+/**
+* Keep browser-owned image backing stores bounded independently of the core's
+* decoded image budget. This is deliberately a fixed layer limit: placement
+* geometry is terminal output and must not be allowed to choose an arbitrary
+* amount of browser memory.
+*/
+var GRAPHICS_CANVAS_BUDGET_BYTES = 33554432;
+var MAX_CANVAS_DIMENSION = 32768;
+function finitePositive(value) {
+	return value !== void 0 && Number.isFinite(value) && value > 0;
+}
+function safeNonNegativeInteger(value) {
+	return Number.isSafeInteger(value) && value >= 0;
+}
+function safeProduct(...values) {
+	let result = 1;
+	for (const value of values) {
+		if (!safeNonNegativeInteger(value)) return null;
+		result *= value;
+		if (!Number.isSafeInteger(result)) return null;
+	}
+	return result;
+}
+function placementKey(placement) {
+	return `${placement.placementKey}:${placement.imageId}:${placement.imageVersion}`;
+}
+/** Browser-owned canvas overlay for cores that expose normalized terminal images. */
+var GraphicsLayer = class {
+	constructor(container, options = {}) {
+		this.layer = null;
+		this.flowSpacer = null;
+		this.canvases = /* @__PURE__ */ new Map();
+		this.canvasAllocations = /* @__PURE__ */ new Map();
+		this.canvasBytes = 0;
+		this.cache = /* @__PURE__ */ new Map();
+		this.generation = -1;
+		this.flowRows = /* @__PURE__ */ new Map();
+		this.container = container;
+		this.maxImageWidth = finitePositive(options.maxImageWidth) ? options.maxImageWidth : void 0;
+		this.maxImageHeight = finitePositive(options.maxImageHeight) ? options.maxImageHeight : void 0;
+	}
+	setup() {
+		this.destroy();
+		const flowSpacer = document.createElement("div");
+		flowSpacer.className = "term-image-flow-spacer";
+		flowSpacer.setAttribute("aria-hidden", "true");
+		this.container.appendChild(flowSpacer);
+		this.flowSpacer = flowSpacer;
+		const layer = document.createElement("div");
+		layer.className = "term-images";
+		layer.setAttribute("aria-hidden", "true");
+		layer.setAttribute("role", "presentation");
+		this.container.appendChild(layer);
+		this.layer = layer;
+		this.generation = -1;
+	}
+	reconcile(core, viewport) {
+		const getState = core.getGraphicsState;
+		const getImage = core.getGraphicsImage;
+		if (!getState || !getImage || !this.layer) {
+			this.clearCanvases();
+			this.clearFlowReservations();
+			return;
+		}
+		let state;
+		try {
+			state = getState.call(core);
+		} catch {
+			this.clearCanvases();
+			this.clearFlowReservations();
+			return;
+		}
+		if (!state || !Number.isSafeInteger(state.generation) || !Array.isArray(state.images) || !Array.isArray(state.placements)) {
+			this.clearCanvases();
+			this.clearFlowReservations();
+			return;
+		}
+		const descriptors = /* @__PURE__ */ new Map();
+		for (const image of state.images) if (Number.isSafeInteger(image.imageId) && image.imageId > 0 && Number.isSafeInteger(image.version) && image.version > 0 && Number.isSafeInteger(image.width) && Number.isSafeInteger(image.height) && image.width > 0 && image.height > 0) descriptors.set(`${image.imageId}:${image.version}`, image);
+		const bounds = this.visiblePixelArea(core, viewport);
+		const flowOffsets = bounds ? this.reconcileFlowReservations(core, state, viewport, descriptors, bounds) : /* @__PURE__ */ new Map();
+		if (!bounds) this.clearFlowReservations();
+		const visible = bounds ? this.visiblePlacements(core, state, viewport, descriptors, bounds, flowOffsets) : [];
+		const wanted = /* @__PURE__ */ new Set();
+		const refs = /* @__PURE__ */ new Map();
+		for (const placement of visible) {
+			const key = placementKey(placement);
+			const imageKey = `${placement.imageId}:${placement.imageVersion}`;
+			if (!descriptors.has(imageKey)) continue;
+			wanted.add(key);
+			refs.set(imageKey, (refs.get(imageKey) ?? 0) + 1);
+		}
+		const changed = state.generation !== this.generation;
+		this.generation = state.generation;
+		for (const [key, canvas] of this.canvases) if (!wanted.has(key)) this.removeCanvas(key);
+		for (const [key, cached] of this.cache) if (!refs.has(key)) this.cache.delete(key);
+		else cached.refs = refs.get(key);
+		for (const placement of visible) {
+			const key = placementKey(placement);
+			const imageKey = `${placement.imageId}:${placement.imageVersion}`;
+			if (!wanted.has(key)) continue;
+			const descriptor = descriptors.get(imageKey);
+			if (!descriptor) continue;
+			let cached = this.cache.get(imageKey);
+			if (!cached) {
+				let data;
+				try {
+					data = getImage.call(core, placement.imageId, placement.imageVersion);
+				} catch {
+					data = null;
+				}
+				if (!data || !this.validImage(data, descriptor.width, descriptor.height)) continue;
+				cached = {
+					data,
+					refs: refs.get(imageKey) ?? 0
+				};
+				this.cache.set(imageKey, cached);
+			}
+			const existingCanvas = this.canvases.get(key);
+			const canvas = existingCanvas ?? this.createCanvas(key);
+			if (!canvas) continue;
+			if (changed || !existingCanvas) {
+				let painted = false;
+				try {
+					painted = this.paint(canvas, key, cached.data, placement, viewport, bounds, flowOffsets.get(placement.row) ?? 0);
+				} catch {
+					painted = false;
+				}
+				if (!painted) this.removeCanvas(key);
+			} else this.position(canvas, placement, viewport, flowOffsets.get(placement.row) ?? 0);
+		}
+	}
+	destroy() {
+		this.clearCanvases();
+		this.layer?.remove();
+		this.flowSpacer?.remove();
+		this.layer = null;
+		this.flowSpacer = null;
+		this.cache.clear();
+		this.generation = -1;
+		this.clearFlowReservations();
+	}
+	createCanvas(key) {
+		if (!this.layer) return null;
+		const canvas = document.createElement("canvas");
+		canvas.className = "term-image";
+		canvas.setAttribute("aria-hidden", "true");
+		canvas.tabIndex = -1;
+		canvas.draggable = false;
+		this.layer.appendChild(canvas);
+		this.canvases.set(key, canvas);
+		return canvas;
+	}
+	clearCanvases() {
+		for (const key of this.canvases.keys()) this.removeCanvas(key);
+		this.canvasAllocations.clear();
+		this.canvasBytes = 0;
+		this.cache.clear();
+	}
+	removeCanvas(key) {
+		this.canvases.get(key)?.remove();
+		this.canvases.delete(key);
+		const bytes = this.canvasAllocations.get(key) ?? 0;
+		this.canvasAllocations.delete(key);
+		this.canvasBytes = Math.max(0, this.canvasBytes - bytes);
+	}
+	/**
+	* An implicit Kitty placement has zero cell rows in its metadata. The
+	* terminal core still advances the shell cursor independently, so an
+	* absolute canvas alone would let the next prompt paint underneath it.
+	* Move the placement's row below the image while keeping the image itself
+	* anchored at the row where Kitty placed it. Transforms preserve the
+	* terminal screen's existing scroll geometry while changing the visual
+	* flow of rows after the image.
+	*/
+	reconcileFlowReservations(core, state, viewport, descriptors, bounds) {
+		let totalRows;
+		let screenRows;
+		try {
+			screenRows = core.getRows();
+			totalRows = viewport.scrollbackCount + screenRows;
+		} catch {
+			if (this.flowRows.size > 0) this.clearFlowReservations();
+			return /* @__PURE__ */ new Map();
+		}
+		if (!Number.isSafeInteger(screenRows) || screenRows < 0 || !Number.isSafeInteger(totalRows) || totalRows < 0) {
+			if (this.flowRows.size > 0) this.clearFlowReservations();
+			return /* @__PURE__ */ new Map();
+		}
+		const reservations = /* @__PURE__ */ new Map();
+		for (const placement of state.placements) {
+			if (!this.validPlacement(placement, totalRows)) continue;
+			if (placement.rows !== 0) continue;
+			if (placement.row < viewport.scrollbackCount) continue;
+			const image = descriptors.get(`${placement.imageId}:${placement.imageVersion}`);
+			if (!image) continue;
+			const size = this.destinationSize(placement, placement.sourceWidth || image.width, placement.sourceHeight || image.height, viewport, bounds);
+			if (!size) continue;
+			const reserve = placement.offsetY + size.height;
+			if (!finitePositive(reserve)) continue;
+			reservations.set(placement.row, Math.max(reservations.get(placement.row) ?? 0, reserve));
+		}
+		if (reservations.size === 0) {
+			if (this.flowRows.size > 0) this.clearFlowReservations();
+			return /* @__PURE__ */ new Map();
+		}
+		this.clearFlowReservations();
+		const rows = this.container.querySelectorAll(".term-row:not(.term-scrollback-row)");
+		for (const row of rows) row.style.transform = "";
+		const flowOffsets = /* @__PURE__ */ new Map();
+		let offset = 0;
+		const scrollbackCount = viewport.scrollbackCount;
+		for (let viewportRow = 0; viewportRow < screenRows; viewportRow++) {
+			const row = scrollbackCount + viewportRow;
+			if (offset > 0) flowOffsets.set(row, offset);
+			const reserve = reservations.get(row) ?? 0;
+			const rowElement = rows[viewportRow];
+			const rowOffset = offset + reserve;
+			if (rowElement && rowOffset > 0) rowElement.style.transform = `translateY(${rowOffset}px)`;
+			offset += reserve;
+		}
+		if (this.flowSpacer) this.flowSpacer.style.height = `${offset}px`;
+		this.container.parentElement?.classList.toggle("has-image-flow", offset > 0);
+		this.flowRows = reservations;
+		return flowOffsets;
+	}
+	clearFlowReservations() {
+		if (this.flowRows.size === 0) {
+			this.flowSpacer?.style.setProperty("height", "0px");
+			this.container.parentElement?.classList.remove("has-image-flow");
+			return;
+		}
+		const rows = this.container.querySelectorAll(".term-row:not(.term-scrollback-row)");
+		for (const row of rows) row.style.transform = "";
+		if (this.flowSpacer) this.flowSpacer.style.height = "0px";
+		this.container.parentElement?.classList.remove("has-image-flow");
+		this.flowRows.clear();
+	}
+	validImage(data, expectedWidth, expectedHeight) {
+		const byteLength = safeProduct(data.width, data.height, 4);
+		return Number.isSafeInteger(data.width) && Number.isSafeInteger(data.height) && data.width > 0 && data.height > 0 && data.width === expectedWidth && data.height === expectedHeight && data.rgba instanceof Uint8Array && byteLength !== null && data.rgba.byteLength === byteLength;
+	}
+	visiblePlacements(core, state, viewport, descriptors, bounds, flowOffsets) {
+		if (!finitePositive(viewport.rowHeight) || !finitePositive(viewport.charWidth) || !Number.isFinite(viewport.scrollTop)) return [];
+		let totalRows;
+		try {
+			totalRows = viewport.scrollbackCount + core.getRows();
+		} catch {
+			return [];
+		}
+		if (!Number.isSafeInteger(totalRows) || totalRows < 0) return [];
+		const viewportStart = viewport.scrollTop - viewport.overscanRows * viewport.rowHeight;
+		const viewportEnd = viewport.scrollTop + Math.max(viewport.clientHeight, viewport.rowHeight) + viewport.overscanRows * viewport.rowHeight;
+		return state.placements.filter((placement) => {
+			if (!this.validPlacement(placement, totalRows)) return false;
+			const image = descriptors.get(`${placement.imageId}:${placement.imageVersion}`);
+			if (!image) return false;
+			const size = this.destinationSize(placement, placement.sourceWidth || image.width, placement.sourceHeight || image.height, viewport, bounds);
+			if (!size) return false;
+			const placementTop = placement.row * viewport.rowHeight + placement.offsetY + (flowOffsets.get(placement.row) ?? 0);
+			const placementEnd = placementTop + size.height;
+			return Number.isFinite(placementTop) && Number.isFinite(placementEnd) && placementTop < viewportEnd && placementEnd > viewportStart;
+		});
+	}
+	validPlacement(placement, totalRows) {
+		return typeof placement.placementKey === "string" && placement.placementKey.length > 0 && safeNonNegativeInteger(placement.imageId) && placement.imageId > 0 && safeNonNegativeInteger(placement.imageVersion) && placement.imageVersion > 0 && safeNonNegativeInteger(placement.row) && placement.row < totalRows && safeNonNegativeInteger(placement.col) && safeNonNegativeInteger(placement.offsetX) && safeNonNegativeInteger(placement.offsetY) && safeNonNegativeInteger(placement.sourceX) && safeNonNegativeInteger(placement.sourceY) && safeNonNegativeInteger(placement.sourceWidth) && safeNonNegativeInteger(placement.sourceHeight) && safeNonNegativeInteger(placement.columns) && safeNonNegativeInteger(placement.rows) && Number.isSafeInteger(placement.z) && Number.isSafeInteger(placement.row + (placement.rows || 1));
+	}
+	position(canvas, placement, viewport, flowOffset = 0) {
+		const left = placement.rows === 0 ? placement.offsetX : placement.col * viewport.charWidth + placement.offsetX;
+		const top = placement.row * viewport.rowHeight + placement.offsetY + flowOffset;
+		if (Number.isFinite(left)) canvas.style.left = `${left}px`;
+		if (Number.isFinite(top)) canvas.style.top = `${top}px`;
+	}
+	paint(canvas, key, image, placement, viewport, bounds, flowOffset = 0) {
+		if (!this.validPlacement(placement, Number.MAX_SAFE_INTEGER)) return false;
+		const sourceX = placement.sourceX;
+		const sourceY = placement.sourceY;
+		const sourceWidth = placement.sourceWidth || image.width;
+		const sourceHeight = placement.sourceHeight || image.height;
+		if (!Number.isSafeInteger(sourceX) || !Number.isSafeInteger(sourceY) || !Number.isSafeInteger(sourceWidth) || !Number.isSafeInteger(sourceHeight) || sourceX < 0 || sourceY < 0 || sourceWidth <= 0 || sourceHeight <= 0 || sourceX + sourceWidth > image.width || sourceY + sourceHeight > image.height) return false;
+		const destination = this.destinationSize(placement, sourceWidth, sourceHeight, viewport, bounds);
+		if (!destination) return false;
+		const { width: destinationWidth, height: destinationHeight } = destination;
+		const pixelWidth = Math.max(1, Math.ceil(destinationWidth));
+		const pixelHeight = Math.max(1, Math.ceil(destinationHeight));
+		if (!Number.isSafeInteger(pixelWidth) || !Number.isSafeInteger(pixelHeight) || pixelWidth > MAX_CANVAS_DIMENSION || pixelHeight > MAX_CANVAS_DIMENSION) return false;
+		const allocationBytes = safeProduct(pixelWidth, pixelHeight, 4);
+		if (allocationBytes === null || !this.resizeCanvas(canvas, key, pixelWidth, pixelHeight, allocationBytes)) return false;
+		this.position(canvas, placement, viewport, flowOffset);
+		canvas.style.width = `${destinationWidth}px`;
+		canvas.style.height = `${destinationHeight}px`;
+		canvas.style.zIndex = String(placement.z);
+		canvas.style.pointerEvents = "none";
+		const context = canvas.getContext("2d");
+		if (!context) return false;
+		const source = document.createElement("canvas");
+		source.width = image.width;
+		source.height = image.height;
+		const sourceContext = source.getContext("2d");
+		if (!sourceContext) return false;
+		const rgba = new Uint8ClampedArray(image.rgba);
+		const imageData = typeof ImageData !== "undefined" ? new ImageData(rgba, image.width, image.height) : sourceContext.createImageData?.(image.width, image.height) ?? {
+			data: rgba,
+			width: image.width,
+			height: image.height
+		};
+		if ("data" in imageData && imageData.data !== rgba) imageData.data.set(rgba);
+		sourceContext.putImageData(imageData, 0, 0);
+		context.clearRect(0, 0, pixelWidth, pixelHeight);
+		context.drawImage(source, sourceX, sourceY, sourceWidth, sourceHeight, 0, 0, pixelWidth, pixelHeight);
+		return true;
+	}
+	destinationSize(placement, sourceWidth, sourceHeight, viewport, bounds) {
+		if (!safeNonNegativeInteger(sourceWidth) || !safeNonNegativeInteger(sourceHeight) || sourceWidth <= 0 || sourceHeight <= 0) return null;
+		const width = placement.columns * viewport.charWidth;
+		const height = placement.rows * viewport.rowHeight;
+		const destinationWidth = finitePositive(width) && placement.columns > 0 ? width : finitePositive(height) && placement.rows > 0 ? height * (sourceWidth / sourceHeight) : sourceWidth;
+		const destinationHeight = finitePositive(height) && placement.rows > 0 ? height : finitePositive(width) && placement.columns > 0 ? width * (sourceHeight / sourceWidth) : sourceHeight;
+		if (!finitePositive(destinationWidth) || !finitePositive(destinationHeight) || !Number.isFinite(placement.offsetY + destinationHeight)) return null;
+		if (!bounds) return null;
+		const scale = Math.min(1, bounds.width / destinationWidth, bounds.height / destinationHeight, this.maxImageWidth === void 0 ? 1 : this.maxImageWidth / destinationWidth, this.maxImageHeight === void 0 ? 1 : this.maxImageHeight / destinationHeight);
+		if (!finitePositive(scale)) return null;
+		return {
+			width: destinationWidth * scale,
+			height: destinationHeight * scale
+		};
+	}
+	visiblePixelArea(core, viewport) {
+		let cols;
+		let rows;
+		try {
+			cols = core.getCols();
+			rows = core.getRows();
+		} catch {
+			return null;
+		}
+		if (!safeNonNegativeInteger(cols) || !safeNonNegativeInteger(rows) || cols <= 0 || rows <= 0 || !finitePositive(viewport.charWidth) || !finitePositive(viewport.rowHeight)) return null;
+		const width = cols * viewport.charWidth;
+		const height = rows * viewport.rowHeight;
+		if (!finitePositive(width) || !finitePositive(height) || !Number.isSafeInteger(Math.ceil(width)) || !Number.isSafeInteger(Math.ceil(height))) return null;
+		return {
+			width: Math.min(width, MAX_CANVAS_DIMENSION),
+			height: Math.min(height, MAX_CANVAS_DIMENSION)
+		};
+	}
+	resizeCanvas(canvas, key, width, height, bytes) {
+		const previousBytes = this.canvasAllocations.get(key) ?? 0;
+		if (bytes > GRAPHICS_CANVAS_BUDGET_BYTES - this.canvasBytes + previousBytes) return false;
+		try {
+			canvas.width = width;
+			canvas.height = height;
+		} catch {
+			return false;
+		}
+		this.canvasBytes = this.canvasBytes - previousBytes + bytes;
+		this.canvasAllocations.set(key, bytes);
+		return true;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/selection.js
+/** Expand partial graphemes and remove layout-only wide-glyph spacer heads. */
+function selectedText(content, start, end) {
+	const parts = [];
+	let cursor = start;
+	for (const cell of content.specialCells) {
+		if (cell.end <= start) continue;
+		if (cell.start >= end) break;
+		if (cursor < cell.start) parts.push(content.text.slice(cursor, cell.start));
+		if (!cell.omit) parts.push(content.text.slice(cell.start, cell.end));
+		cursor = cell.end;
+	}
+	if (cursor < end) parts.push(content.text.slice(cursor, end));
+	return parts.join("");
+}
+/**
+* Extract only a selection wholly owned by this terminal. Work against the
+* painted snapshot: core state can already be ahead of the visible frame.
+* Unknown/missing rows, multiple ranges, and selections outside the terminal
+* stay with the browser rather than silently exporting incomplete history.
+*/
+function getSelectionText(terminal, rows) {
+	return readSelection(terminal, rows)?.text ?? null;
+}
+function readSelection(terminal, rows) {
+	const selection = terminal.ownerDocument.getSelection();
+	if (!selection || selection.isCollapsed || selection.rangeCount !== 1) return null;
+	const range = selection.getRangeAt(0);
+	if (!terminal.contains(range.startContainer) || !terminal.contains(range.endContainer)) return null;
+	const active = terminal.ownerDocument.activeElement;
+	if (active && (active.tagName === "INPUT" || active.tagName === "TEXTAREA")) {
+		const input = active;
+		if (input.selectionStart !== input.selectionEnd) return null;
+	}
+	const parts = [];
+	let first;
+	let last;
+	let previous;
+	for (const current of rows) {
+		const { element, content } = current;
+		if (!range.intersectsNode(element)) continue;
+		const selected = terminal.ownerDocument.createRange();
+		selected.selectNodeContents(element);
+		if (element.contains(range.startContainer)) selected.setStart(range.startContainer, range.startOffset);
+		if (element.contains(range.endContainer)) selected.setEnd(range.endContainer, range.endOffset);
+		const before = terminal.ownerDocument.createRange();
+		before.selectNodeContents(element);
+		before.setEnd(selected.startContainer, selected.startOffset);
+		const start = before.toString().length;
+		const end = start + selected.toString().length;
+		if (element.textContent !== content.text) return null;
+		first ?? (first = {
+			row: current,
+			offset: start
+		});
+		last = {
+			row: current,
+			offset: end === content.text.length && !content.metadata?.wrapsToNext ? Math.max(start, content.text.replace(/ +$/, "").length) : end
+		};
+		if (previous) {
+			if (current.row !== previous.row + 1) return null;
+			if (!(previous.content.metadata?.wrapsToNext && content.metadata?.continuesPrevious)) parts.push("\n");
+		}
+		let text = start === end ? "" : selectedText(content, start, end);
+		if (end === content.text.length && !content.metadata?.wrapsToNext) text = text.replace(/ +$/, "");
+		parts.push(text);
+		previous = current;
+	}
+	return first && last ? {
+		text: parts.join(""),
+		first,
+		last,
+		backward: selection.anchorNode !== range.startContainer || selection.anchorOffset !== range.startOffset
+	} : null;
+}
+/** Anchor an edge to an included cell, so an end at a wrap follows that cell. */
+function cellAtOffset(content, offset, end) {
+	let delta = 0;
+	for (const cell of content.specialCells) {
+		if (offset >= cell.start && offset < cell.end && !end || offset > cell.start && offset <= cell.end && end) return {
+			col: cell.col,
+			after: end
+		};
+		if (cell.end <= offset) delta += cell.width - (cell.end - cell.start);
+	}
+	const after = offset > 0 && (end || offset === content.text.length);
+	return {
+		col: offset + delta - (after ? 1 : 0),
+		after
+	};
+}
+function offsetAtCell(content, col, after) {
+	let delta = 0;
+	for (const cell of content.specialCells) {
+		if (col >= cell.col && col < cell.col + cell.width) return after ? cell.end : cell.start;
+		if (cell.col < col) delta += cell.end - cell.start - cell.width;
+	}
+	return col + delta + (after ? 1 : 0);
+}
+function textPoint(element, offset) {
+	const walker = element.ownerDocument.createTreeWalker(element, 4);
+	let node;
+	while (node = walker.nextNode()) {
+		const length = node.textContent?.length ?? 0;
+		if (offset <= length) return [node, offset];
+		offset -= length;
+	}
+	return null;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/selection-range.js
+var MAX_SELECTION_ROWS = 1e3;
+var MAX_SELECTION_TEXT = 1048576;
+var WORD_BOUNDARIES = /* @__PURE__ */ new Set(" 	'\"│`|:;,()[]{}<>$");
+/** Expand in retained-buffer coordinates without joining hard/unknown breaks. */
+function selectionRange(core, position, unit) {
+	const history = core.getScrollbackCount();
+	const total = history + core.getRows();
+	const cols = core.getCols();
+	const blank = {
+		char: 0,
+		fg: 256,
+		bg: 256,
+		flags: 0
+	};
+	if (!Number.isInteger(position.row) || !Number.isInteger(position.col) || position.row < 0 || position.row >= total || position.col < 0 || position.col >= cols) return null;
+	const cell = (p) => p.row < history ? p.col < core.getScrollbackLineLen(history - p.row - 1) ? core.getScrollbackCell(history - p.row - 1, p.col) : blank : core.getCell(p.row - history, p.col);
+	const metadata = (row) => row < history ? core.getScrollbackLineLen(history - row - 1) <= cols ? core.getScrollbackRowMetadata?.(history - row - 1) : null : core.getRowMetadata?.(row - history);
+	const wraps = (row) => row >= 0 && row + 1 < total && metadata(row)?.wrapsToNext && metadata(row + 1)?.continuesPrevious;
+	const advance = (p, direction) => {
+		const col = p.col + direction;
+		if (col >= 0 && col < cols) return {
+			row: p.row,
+			col
+		};
+		const row = p.row + direction;
+		if (!wraps(Math.min(row, p.row))) return null;
+		return {
+			row,
+			col: direction === 1 ? 0 : cols - 1
+		};
+	};
+	let origin = { ...position };
+	if (cell(origin).spacerHead) return null;
+	if (cell(origin).width === 0 && origin.col > 0) origin.col--;
+	const text = (p) => {
+		const value = cell(p);
+		return value.chars ?? String.fromCodePoint(value.char || 32);
+	};
+	const boundary = (text) => WORD_BOUNDARIES.has(String.fromCodePoint(text.codePointAt(0) ?? 32));
+	const expected = boundary(text(origin));
+	let length = text(origin).length;
+	let reads = 1;
+	let exceeded = length > MAX_SELECTION_TEXT;
+	let start = origin, end = origin;
+	const expand = (direction) => {
+		let current = origin;
+		let included = origin;
+		while (true) {
+			const next = advance(current, direction);
+			if (!next) return included;
+			if (++reads > 2097152) {
+				exceeded = true;
+				return included;
+			}
+			const value = cell(next);
+			if (value.width !== 0 && !value.spacerHead) {
+				const chars = value.chars ?? String.fromCodePoint(value.char || 32);
+				if (unit === "word" && boundary(chars) !== expected) return included;
+				length += chars.length;
+				included = next;
+			}
+			const first = direction === -1 ? next.row : start.row;
+			if ((direction === 1 ? next.row : origin.row) - first >= 1e3 || length > 1048576) {
+				exceeded = true;
+				return included;
+			}
+			current = next;
+		}
+	};
+	start = expand(-1);
+	if (!exceeded) end = expand(1);
+	return exceeded ? null : {
+		start,
+		end
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/rectangle-selection.js
+var MAX_RECTANGLE_CELLS = 65536;
+/** Inclusive corners in physical rows; wide glyphs at either edge stay whole. */
+function rectangleSelection(core, start, end) {
+	const history = core.getScrollbackCount();
+	const total = history + core.getRows();
+	const cols = core.getCols();
+	for (const point of [start, end]) if (!Number.isInteger(point.row) || !Number.isInteger(point.col) || point.row < 0 || point.row >= total || point.col < 0 || point.col >= cols) return null;
+	const top = Math.min(start.row, end.row), bottom = Math.max(start.row, end.row);
+	const left = Math.min(start.col, end.col), right = Math.max(start.col, end.col);
+	const count = bottom - top + 1;
+	if (count > 1e3 || count * (right - left + 2) > MAX_RECTANGLE_CELLS) return null;
+	const rows = [];
+	const text = [];
+	let length = count - 1;
+	for (let row = top; row <= bottom; row++) {
+		const offset = history - row - 1;
+		const width = row < history ? core.getScrollbackLineLen(offset) : cols;
+		const cell = (col) => col >= width ? null : row < history ? core.getScrollbackCell(offset, col) : core.getCell(row - history, col);
+		let first = left;
+		if (first > 0 && cell(first)?.width === 0 && cell(first - 1)?.width === 2) first--;
+		let last = right + 1;
+		let line = "";
+		for (let col = first; col <= right; col++) {
+			const value = cell(col);
+			if (value?.width === 0 || value?.spacerHead) continue;
+			const chars = value?.chars ?? String.fromCodePoint(value?.char || 32);
+			length += chars.length;
+			if (length > 1048576) return null;
+			line += chars;
+			last = Math.max(last, Math.min(cols, col + (value?.width ?? 1)));
+		}
+		rows.push({
+			row,
+			left: first,
+			right: last
+		});
+		text.push(line);
+	}
+	return {
+		rows,
+		text: text.join("\n")
+	};
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/tracked-selection.js
+var MAX_TRACKED_SELECTION_ROWS = MAX_SELECTION_ROWS;
+var TrackedSelection = class {
+	constructor(terminal) {
+		this.terminal = terminal;
+		this.current = null;
+		this.painted = true;
+	}
+	matches() {
+		const selection = this.terminal.ownerDocument.getSelection();
+		const native = this.current?.native;
+		return !!selection && !!native && selection.anchorNode === native.anchorNode && selection.anchorOffset === native.anchorOffset && selection.focusNode === native.focusNode && selection.focusOffset === native.focusOffset;
+	}
+	capture(core, rows) {
+		const active = this.terminal.ownerDocument.activeElement;
+		if (active && (active.tagName === "INPUT" || active.tagName === "TEXTAREA")) {
+			const input = active;
+			if (input.selectionStart !== input.selectionEnd) {
+				this.dispose();
+				return;
+			}
+		}
+		if (this.current && this.matches()) return;
+		this.dispose();
+		if (!this.painted || !core.trackPosition) return;
+		const value = readSelection(this.terminal, rows);
+		if (!value || !value.text.length || value.last.row.row - value.first.row.row >= MAX_TRACKED_SELECTION_ROWS || value.text.length > 1048576) return;
+		const start = cellAtOffset(value.first.row.content, value.first.offset, false);
+		const end = cellAtOffset(value.last.row.content, value.last.offset, true);
+		const a = core.trackPosition({
+			row: value.first.row.row,
+			col: start.col
+		});
+		if (!a) return;
+		const b = core.trackPosition({
+			row: value.last.row.row,
+			col: end.col
+		});
+		if (!b) {
+			a.dispose();
+			return;
+		}
+		const selection = this.terminal.ownerDocument.getSelection();
+		this.current = {
+			start: {
+				pin: a,
+				after: start.after
+			},
+			end: {
+				pin: b,
+				after: end.after
+			},
+			text: value.text,
+			backward: value.backward,
+			native: this.snapshot(selection)
+		};
+	}
+	beforeMutation(core, rows) {
+		this.capture(core, rows);
+		this.painted = false;
+	}
+	beforeRender(core, rows) {
+		this.capture(core, rows);
+		const start = this.current?.start.pin.resolve();
+		const end = this.current?.end.pin.resolve();
+		if (!start || !end || end.row < start.row || end.row === start.row && end.col < start.col || end.row - start.row >= MAX_TRACKED_SELECTION_ROWS) {
+			this.clear();
+			return null;
+		}
+		return {
+			start,
+			end
+		};
+	}
+	afterRender(rows, positions) {
+		this.painted = true;
+		const current = this.current;
+		if (!current || !positions) return;
+		const mounted = Array.from(rows);
+		const edge = (position, after) => {
+			const row = mounted.find((row) => row.row === position.row);
+			return row && textPoint(row.element, offsetAtCell(row.content, position.col, after));
+		};
+		const start = edge(positions.start, current.start.after);
+		const end = edge(positions.end, current.end.after);
+		const selection = this.terminal.ownerDocument.getSelection();
+		if (!start || !end || !selection) {
+			this.clear();
+			return;
+		}
+		const anchor = current.backward ? end : start;
+		const focus = current.backward ? start : end;
+		if (selection.anchorNode !== anchor[0] || selection.anchorOffset !== anchor[1] || selection.focusNode !== focus[0] || selection.focusOffset !== focus[1]) selection.setBaseAndExtent(...anchor, ...focus);
+		current.native = this.snapshot(selection);
+		if (readSelection(this.terminal, mounted)?.text !== current.text) this.clear();
+	}
+	snapshot(selection) {
+		return {
+			anchorNode: selection.anchorNode,
+			anchorOffset: selection.anchorOffset,
+			focusNode: selection.focusNode,
+			focusOffset: selection.focusOffset
+		};
+	}
+	clear() {
+		if (this.current && this.matches()) this.terminal.ownerDocument.getSelection()?.removeAllRanges();
+		this.dispose();
+	}
+	dispose() {
+		this.current?.start.pin.dispose();
+		this.current?.end.pin.dispose();
+		this.current = null;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/renderer.js
+var DEFAULT_COLOR = 256;
+var DEFAULT_FG_CSS = "var(--term-app-fg, var(--term-fg))";
+var DEFAULT_BG_CSS = "var(--term-app-bg, var(--term-bg))";
+var FLAG_BOLD = 1;
+var FLAG_DIM = 2;
+var FLAG_ITALIC = 4;
+var FLAG_UNDERLINE = 8;
+var FLAG_REVERSE = 32;
+var FLAG_INVISIBLE = 64;
+var FLAG_STRIKETHROUGH = 128;
+var DEFAULT_SCROLLBACK_OVERSCAN_ROWS = 10;
+function rgbToCSS(packed) {
+	return `rgb(${packed >> 16 & 255},${packed >> 8 & 255},${packed & 255})`;
+}
+function colorToCSS(index) {
+	if (index === DEFAULT_COLOR) return null;
+	if (index < 16) return `var(--term-color-${index})`;
+	if (index < 232) {
+		const n = index - 16;
+		return `rgb(${Math.floor(n / 36) * 51},${Math.floor(n / 6) % 6 * 51},${n % 6 * 51})`;
+	}
+	const level = (index - 232) * 10 + 8;
+	return `rgb(${level},${level},${level})`;
+}
+function cellFgCSS(fg, fgRgb) {
+	if (fgRgb !== void 0) return rgbToCSS(fgRgb);
+	return colorToCSS(fg);
+}
+function cellBgCSS(bg, bgRgb) {
+	if (bgRgb !== void 0) return rgbToCSS(bgRgb);
+	return colorToCSS(bg);
+}
+function buildCellStyle({ fg, bg, flags, fgRgb, bgRgb, underlineStyle, underlineRgb }) {
+	let fgCSS = cellFgCSS(fg, fgRgb);
+	let bgCSS = cellBgCSS(bg, bgRgb);
+	if (flags & FLAG_REVERSE) [fgCSS, bgCSS] = [bgCSS ?? DEFAULT_BG_CSS, fgCSS ?? DEFAULT_FG_CSS];
+	let style = "";
+	if (fgCSS) style += `color:${fgCSS};`;
+	if (bgCSS) style += `background:${bgCSS};`;
+	if (flags & FLAG_BOLD) style += "font-weight:bold;";
+	if (flags & FLAG_DIM) style += "opacity:0.5;";
+	if (flags & FLAG_ITALIC) style += "font-style:italic;";
+	const decorations = [];
+	const underline = underlineStyle ?? (flags & FLAG_UNDERLINE ? "single" : "none");
+	if (underline !== "none") decorations.push("underline");
+	if (flags & FLAG_STRIKETHROUGH) decorations.push("line-through");
+	if (decorations.length) style += `text-decoration:${decorations.join(" ")};`;
+	if (underline !== "none") {
+		style += `text-decoration-style:${underline === "curly" ? "wavy" : underline === "double" || underline === "dotted" || underline === "dashed" ? underline : "solid"};text-decoration-skip-ink:none;`;
+		if (underlineRgb !== void 0) style += `text-decoration-color:${rgbToCSS(underlineRgb)};`;
+	}
+	if (flags & FLAG_INVISIBLE) style += "visibility:hidden;";
+	return style;
+}
+function cursorCellStyle(style) {
+	return style.replace(/(^|;)color:/g, "$1--term-cell-fg:").replace(/(^|;)background:/g, "$1--term-cell-bg:");
+}
+function columnStyle(columns) {
+	return columns === 1 ? "" : `--term-span-cols:${columns};`;
+}
+function escapeHTML(text) {
+	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function cellSpanPart(className, style, text) {
+	let content = escapeHTML(text);
+	const flat = !style.includes("text-decoration:underline line-through;");
+	if (!flat) {
+		style = style.replace("text-decoration:underline line-through;", "text-decoration:underline;");
+		content = `<span style="text-decoration:line-through solid currentColor;">${content}</span>`;
+	}
+	const opening = `<span${className ? ` class="${className}"` : ""}${style ? ` style="${style}"` : ""}>`;
+	return {
+		html: `${opening}${content}</span>`,
+		opening: flat ? opening : void 0,
+		text: flat ? text : void 0
+	};
+}
+function safeLinkHref(uri) {
+	if (!uri) return void 0;
+	try {
+		const url = new URL(uri);
+		return url.protocol === "http:" || url.protocol === "https:" ? url.href : void 0;
+	} catch {
+		return;
+	}
+}
+function linkIdentity(cell) {
+	if (!cell.linkUri) return "";
+	return cell.linkKey ?? `fallback\0${cell.linkId ?? ""}\0${cell.linkUri}`;
+}
+function resolveColors(fg, bg, flags, fgRgb, bgRgb) {
+	const foreground = cellFgCSS(fg, fgRgb) || DEFAULT_FG_CSS;
+	const background = cellBgCSS(bg, bgRgb) || DEFAULT_BG_CSS;
+	return flags & FLAG_REVERSE ? {
+		fg: background,
+		bg: foreground
+	} : {
+		fg: foreground,
+		bg: background
+	};
+}
+var SNAP_1_8 = "round(calc(var(--term-row-height) * 0.125), 1px)";
+var SNAP_2_8 = "round(calc(var(--term-row-height) * 0.25), 1px)";
+var SNAP_3_8 = "round(calc(var(--term-row-height) * 0.375), 1px)";
+var SNAP_4_8 = "round(calc(var(--term-row-height) * 0.5), 1px)";
+var SNAP_5_8 = "round(calc(var(--term-row-height) * 0.625), 1px)";
+var SNAP_6_8 = "round(calc(var(--term-row-height) * 0.75), 1px)";
+var SNAP_7_8 = "round(calc(var(--term-row-height) * 0.875), 1px)";
+function getBlockBackground(cp, fg, bg) {
+	switch (cp) {
+		case 9600: return `linear-gradient(${fg} ${SNAP_4_8},${bg} ${SNAP_4_8})`;
+		case 9601: return `linear-gradient(${bg} ${SNAP_7_8},${fg} ${SNAP_7_8})`;
+		case 9602: return `linear-gradient(${bg} ${SNAP_6_8},${fg} ${SNAP_6_8})`;
+		case 9603: return `linear-gradient(${bg} ${SNAP_5_8},${fg} ${SNAP_5_8})`;
+		case 9604: return `linear-gradient(${bg} ${SNAP_4_8},${fg} ${SNAP_4_8})`;
+		case 9605: return `linear-gradient(${bg} ${SNAP_3_8},${fg} ${SNAP_3_8})`;
+		case 9606: return `linear-gradient(${bg} ${SNAP_2_8},${fg} ${SNAP_2_8})`;
+		case 9607: return `linear-gradient(${bg} ${SNAP_1_8},${fg} ${SNAP_1_8})`;
+		case 9608: return fg;
+		case 9609: return `linear-gradient(to right,${fg} 87.5%,${bg} 87.5%)`;
+		case 9610: return `linear-gradient(to right,${fg} 75%,${bg} 75%)`;
+		case 9611: return `linear-gradient(to right,${fg} 62.5%,${bg} 62.5%)`;
+		case 9612: return `linear-gradient(to right,${fg} 50%,${bg} 50%)`;
+		case 9613: return `linear-gradient(to right,${fg} 37.5%,${bg} 37.5%)`;
+		case 9614: return `linear-gradient(to right,${fg} 25%,${bg} 25%)`;
+		case 9615: return `linear-gradient(to right,${fg} 12.5%,${bg} 12.5%)`;
+		case 9616: return `linear-gradient(to right,${bg} 50%,${fg} 50%)`;
+		case 9617: return `color-mix(in srgb,${fg} 25%,${bg})`;
+		case 9618: return `color-mix(in srgb,${fg} 50%,${bg})`;
+		case 9619: return `color-mix(in srgb,${fg} 75%,${bg})`;
+		case 9620: return `linear-gradient(${fg} ${SNAP_1_8},${bg} ${SNAP_1_8})`;
+		case 9621: return `linear-gradient(to right,${bg} 87.5%,${fg} 87.5%)`;
+		default: {
+			const q = {
+				9622: [
+					false,
+					false,
+					true,
+					false
+				],
+				9623: [
+					false,
+					false,
+					false,
+					true
+				],
+				9624: [
+					true,
+					false,
+					false,
+					false
+				],
+				9625: [
+					true,
+					false,
+					true,
+					true
+				],
+				9626: [
+					true,
+					false,
+					false,
+					true
+				],
+				9627: [
+					true,
+					true,
+					true,
+					false
+				],
+				9628: [
+					true,
+					true,
+					false,
+					true
+				],
+				9629: [
+					false,
+					true,
+					false,
+					false
+				],
+				9630: [
+					false,
+					true,
+					true,
+					false
+				],
+				9631: [
+					false,
+					true,
+					true,
+					true
+				]
+			}[cp];
+			if (!q) return fg;
+			const [tl, tr, bl, br] = q;
+			if (tl && tr && bl && br) return fg;
+			const layers = [];
+			const POS = [
+				"0 0",
+				"100% 0",
+				"0 100%",
+				"100% 100%"
+			];
+			q.forEach((filled, i) => {
+				if (filled) layers.push(`linear-gradient(${fg},${fg}) ${POS[i]}/50% 50% no-repeat`);
+			});
+			layers.push(bg);
+			return layers.join(",");
+		}
+	}
+}
+var LIGHT_BOX_ARMS = {
+	9472: "lr",
+	9474: "ud",
+	9484: "dr",
+	9488: "dl",
+	9492: "ur",
+	9496: "ul",
+	9500: "udr",
+	9508: "udl",
+	9516: "dlr",
+	9524: "ulr",
+	9532: "udlr",
+	9588: "l",
+	9589: "u",
+	9590: "r",
+	9591: "d"
+};
+var HEAVY_BOX_ARMS = {
+	9473: "lr",
+	9475: "ud",
+	9487: "dr",
+	9491: "dl",
+	9495: "ur",
+	9499: "ul",
+	9507: "udr",
+	9515: "udl",
+	9523: "dlr",
+	9531: "ulr",
+	9547: "udlr",
+	9592: "l",
+	9593: "u",
+	9594: "r",
+	9595: "d"
+};
+var ROUNDED_BOX_CORNERS = {
+	9581: "tl",
+	9582: "tr",
+	9583: "br",
+	9584: "bl"
+};
+var BOX_STYLES = {};
+function addBoxStyles(characters, className) {
+	const stroke = "var(--term-box-stroke)";
+	const verticalLength = `calc(50% + ${stroke})`;
+	const horizontalLength = `calc(50% + ${stroke})`;
+	for (const [codepoint, arms] of Object.entries(characters)) {
+		const selected = [];
+		if (arms.includes("u") && arms.includes("d")) selected.push(["center center", `${stroke} 100%`]);
+		else {
+			if (arms.includes("u")) selected.push(["center top", `${stroke} ${verticalLength}`]);
+			if (arms.includes("d")) selected.push(["center bottom", `${stroke} ${verticalLength}`]);
+		}
+		if (arms.includes("l") && arms.includes("r")) selected.push(["center center", `100% ${stroke}`]);
+		else {
+			if (arms.includes("l")) selected.push(["left center", `${horizontalLength} ${stroke}`]);
+			if (arms.includes("r")) selected.push(["right center", `${horizontalLength} ${stroke}`]);
+		}
+		BOX_STYLES[Number(codepoint)] = {
+			className,
+			style: `background-image:${selected.map(() => "linear-gradient(currentColor,currentColor)").join(",")};background-position:${selected.map(([position]) => position).join(",")};background-size:${selected.map(([, size]) => size).join(",")};background-repeat:no-repeat;`
+		};
+	}
+}
+addBoxStyles(LIGHT_BOX_ARMS, "term-box");
+addBoxStyles(HEAVY_BOX_ARMS, "term-box term-box-heavy");
+for (const [codepoint, corner] of Object.entries(ROUNDED_BOX_CORNERS)) BOX_STYLES[Number(codepoint)] = {
+	className: `term-box term-box-round term-box-round-${corner}`,
+	style: ""
+};
+var Renderer = class {
+	get hasImageFlow() {
+		return this.container.parentElement?.classList.contains("has-image-flow") ?? false;
+	}
+	constructor(container, options = {}) {
+		this.rows = 0;
+		this.cols = 0;
+		this.rowEls = [];
+		this.prevCursorRow = -1;
+		this.prevCursorCol = -1;
+		this.prevCursorVisible = false;
+		this.prevRowBg = [];
+		this._scrollbackRowEls = [];
+		this._scrollbackKeys = [];
+		this._scrollbackRowHeight = 0;
+		this._scrollbackGapSpacers = [];
+		this._renderedScrollbackCount = -1;
+		this._renderedDiscardedCount = -1;
+		this._scrollbackTopSpacer = null;
+		this._scrollbackBottomSpacer = null;
+		this.rowText = /* @__PURE__ */ new WeakMap();
+		this.rowParts = /* @__PURE__ */ new WeakMap();
+		this.rowBackground = /* @__PURE__ */ new WeakMap();
+		this.selection = null;
+		this.needsSetup = false;
+		this.colorsChanged = false;
+		this.painted = false;
+		this.container = container;
+		this.colorHost = options.colorHost ?? container;
+		this.graphics = new GraphicsLayer(container, options);
+		this.searchLayer = document.createElement("div");
+		this.searchLayer.className = "term-search-layer";
+		this.searchLayer.setAttribute("aria-hidden", "true");
+	}
+	setup(cols, rows) {
+		this.cols = cols;
+		this.rows = rows;
+		this.container.innerHTML = "";
+		this.rowText = /* @__PURE__ */ new WeakMap();
+		this.rowParts = /* @__PURE__ */ new WeakMap();
+		this.rowBackground = /* @__PURE__ */ new WeakMap();
+		this.rowEls = [];
+		this.prevRowBg = [];
+		this._scrollbackRowEls = [];
+		this._scrollbackKeys = [];
+		this._scrollbackGapSpacers = [];
+		this._renderedScrollbackCount = -1;
+		this._renderedDiscardedCount = -1;
+		const fragment = document.createDocumentFragment();
+		this._scrollbackTopSpacer = document.createElement("div");
+		this._scrollbackTopSpacer.className = "term-scrollback-spacer";
+		fragment.appendChild(this._scrollbackTopSpacer);
+		this._scrollbackBottomSpacer = document.createElement("div");
+		this._scrollbackBottomSpacer.className = "term-scrollback-spacer";
+		fragment.appendChild(this._scrollbackBottomSpacer);
+		for (let r = 0; r < rows; r++) {
+			const rowEl = document.createElement("div");
+			rowEl.className = "term-row";
+			fragment.appendChild(rowEl);
+			this.rowEls.push(rowEl);
+		}
+		this.container.appendChild(fragment);
+		this.searchLayer.replaceChildren();
+		this.container.appendChild(this.searchLayer);
+		this.graphics.setup();
+		this.prevCursorRow = -1;
+		this.prevCursorCol = -1;
+	}
+	_buildRowContent(rowEl, getCell, lineLen, cursorCol, rowIndex) {
+		const parts = [];
+		let linkHtml = "";
+		const content = {
+			text: "",
+			specialCells: [],
+			metadata: null
+		};
+		const recordText = (text, col, width = 1, omit = false) => {
+			const start = content.text.length;
+			content.text += text;
+			if (text.length !== width || width > 1 || omit) content.specialCells.push({
+				start,
+				end: content.text.length,
+				col,
+				width,
+				omit
+			});
+		};
+		let runStyle = "";
+		let runText = "";
+		let runCells = [];
+		let runStart = 0;
+		let runLinkKey = "";
+		let runLinkUri;
+		let outputLinkKey = "";
+		let rowBackground;
+		let uniformBackground = lineLen >= this.cols;
+		const appendContent = (content, linkKey, uri) => {
+			const href = safeLinkHref(uri);
+			const nextLinkKey = href ? linkKey : "";
+			if (nextLinkKey !== outputLinkKey) {
+				if (outputLinkKey) parts.push({ html: linkHtml + "</a>" });
+				if (nextLinkKey) linkHtml = `<a class="term-link" href="${escapeHTML(href)}" target="_blank" rel="noopener noreferrer">`;
+				outputLinkKey = nextLinkKey;
+			}
+			if (outputLinkKey) linkHtml += content.html;
+			else parts.push(content);
+		};
+		const flushRun = (endCol) => {
+			if (!runText) return;
+			const append = (className, style, text) => appendContent(cellSpanPart(className, style, text), runLinkKey, runLinkUri);
+			if (cursorCol >= runStart && cursorCol < endCol) {
+				const offset = cursorCol - runStart;
+				const before = runCells.slice(0, offset).join("");
+				const cursorChar = runCells[offset] || " ";
+				const after = runCells.slice(offset + 1).join("");
+				if (before) append("", columnStyle(offset) + runStyle, before);
+				append("term-cursor", cursorCellStyle(runStyle), cursorChar);
+				if (after) append("", columnStyle(runCells.length - offset - 1) + runStyle, after);
+			} else append("", columnStyle(runCells.length) + runStyle, runText);
+			runText = "";
+			runCells = [];
+		};
+		const appendStyledSpan = (className, style, text, linkKey, linkUri) => {
+			appendContent(cellSpanPart(className, style, text), linkKey, linkUri);
+		};
+		for (let col = 0; col < this.cols; col++) {
+			const cell = getCell(col);
+			const inBounds = col < lineLen;
+			const cp = inBounds ? cell.char : 0;
+			const width = inBounds ? cell.width ?? 1 : 1;
+			const cellLinkKey = inBounds ? linkIdentity(cell) : "";
+			const cellLinkUri = inBounds ? cell.linkUri : void 0;
+			const continuesWide = inBounds && width === 0 && col > 0 && (getCell(col - 1).width ?? 1) === 2;
+			if (uniformBackground && !continuesWide) {
+				const bg = resolveColors(cell.fg, cell.bg, cell.flags, cell.fgRgb, cell.bgRgb).bg;
+				if (cell.flags & 66 || rowBackground !== void 0 && rowBackground !== bg) uniformBackground = false;
+				else rowBackground = bg;
+			}
+			if (inBounds && width === 0) {
+				flushRun(col);
+				if (!continuesWide) {
+					recordText(" ", col);
+					const style = buildCellStyle(cell);
+					const cursor = col === cursorCol;
+					appendStyledSpan(cursor ? "term-cursor" : "", cursor ? cursorCellStyle(style) : style, " ", cellLinkKey, cellLinkUri);
+				}
+				runStyle = "";
+				runLinkKey = "";
+				runLinkUri = void 0;
+				runText = "";
+				runCells = [];
+				runStart = col + 1;
+				continue;
+			}
+			if (inBounds && width === 2) {
+				flushRun(col);
+				if (col + 1 >= this.cols) {
+					recordText(" ", col);
+					const style = buildCellStyle(cell);
+					const cursor = col === cursorCol;
+					appendStyledSpan(cursor ? "term-cursor" : "", cursor ? cursorCellStyle(style) : style, " ", cellLinkKey, cellLinkUri);
+					runStyle = "";
+					runLinkKey = "";
+					runLinkUri = void 0;
+					runText = "";
+					runCells = [];
+					runStart = col + 1;
+					continue;
+				}
+				const ch = cell.chars ?? (cp >= 32 ? String.fromCodePoint(cp) : " ");
+				recordText(ch, col, 2);
+				const style = buildCellStyle(cell);
+				const cursor = cursorCol >= col && cursorCol < col + 2;
+				appendStyledSpan(cursor ? "term-wide term-cursor" : "term-wide", cursor ? cursorCellStyle(style) : style, ch, cellLinkKey, cellLinkUri);
+				runStyle = "";
+				runLinkKey = "";
+				runLinkUri = void 0;
+				runText = "";
+				runCells = [];
+				runStart = col + 2;
+				continue;
+			}
+			if (inBounds && cp >= 9600 && cp <= 9631) {
+				flushRun(col);
+				const ch = cell.chars ?? String.fromCodePoint(cp);
+				recordText(ch, col);
+				const colors = resolveColors(cell.fg, cell.bg, cell.flags, cell.fgRgb, cell.bgRgb);
+				const cls = col === cursorCol ? "term-block term-cursor" : "term-block";
+				const bg = getBlockBackground(cp, colors.fg, colors.bg);
+				const style = buildCellStyle(cell) + `color:${colors.fg};background:${bg};`;
+				appendStyledSpan(cls, col === cursorCol ? cursorCellStyle(style) : style, ch, cellLinkKey, cellLinkUri);
+				runStyle = "";
+				runLinkKey = "";
+				runLinkUri = void 0;
+				runText = "";
+				runCells = [];
+				runStart = col + 1;
+			} else {
+				const ch = cell.chars ?? (inBounds && cp >= 32 ? String.fromCodePoint(cp) : " ");
+				recordText(ch, col, 1, cell.spacerHead === true);
+				const style = inBounds ? buildCellStyle(cell) : "";
+				if (ch.length !== 1 || ch.charCodeAt(0) > 126) {
+					flushRun(col);
+					const cursor = col === cursorCol;
+					const box = BOX_STYLES[cp];
+					const boxStyle = box && ch === String.fromCodePoint(cp) ? box : null;
+					let className = boxStyle?.className ?? "";
+					if (boxStyle && cell.flags & FLAG_BOLD) className += " term-box-bold";
+					if (cursor) className += className ? " term-cursor" : "term-cursor";
+					appendStyledSpan(className, (cursor ? cursorCellStyle(style) : style) + (boxStyle?.style ?? ""), ch, cellLinkKey, cellLinkUri);
+					runStyle = "";
+					runLinkKey = "";
+					runLinkUri = void 0;
+					runStart = col + 1;
+					continue;
+				}
+				if (style !== runStyle || cellLinkKey !== runLinkKey) {
+					flushRun(col);
+					runStyle = style;
+					runLinkKey = cellLinkKey;
+					runLinkUri = cellLinkUri;
+					runText = ch;
+					runCells = [ch];
+					runStart = col;
+				} else {
+					runText += ch;
+					runCells.push(ch);
+				}
+			}
+		}
+		flushRun(this.cols);
+		if (outputLinkKey) parts.push({ html: linkHtml + "</a>" });
+		this.updateRowParts(rowEl, parts);
+		this.rowText.set(rowEl, content);
+		const bgCss = uniformBackground && rowBackground !== DEFAULT_BG_CSS ? rowBackground ?? "" : "";
+		if (rowIndex >= 0) {
+			if (bgCss !== (this.prevRowBg[rowIndex] ?? "")) {
+				rowEl.style.background = bgCss;
+				this.prevRowBg[rowIndex] = bgCss;
+			}
+		} else if (this.rowBackground.get(rowEl) !== bgCss) {
+			rowEl.style.background = bgCss;
+			this.rowBackground.set(rowEl, bgCss);
+		}
+	}
+	updateRowParts(row, parts) {
+		const previous = this.rowParts.get(row);
+		let start = 0;
+		let oldEnd = previous?.length ?? 0;
+		let newEnd = parts.length;
+		if (previous) {
+			while (start < oldEnd && start < newEnd && previous[start].html === parts[start].html) start++;
+			while (oldEnd > start && newEnd > start && previous[oldEnd - 1].html === parts[newEnd - 1].html) {
+				oldEnd--;
+				newEnd--;
+			}
+		}
+		if (start === oldEnd && start === newEnd) return;
+		let textOnly = previous !== void 0 && oldEnd === newEnd;
+		for (let i = start; textOnly && i < newEnd; i++) {
+			const child = row.childNodes[i];
+			textOnly = parts[i].opening !== void 0 && parts[i].opening === previous[i].opening && child?.childNodes.length === 1 && child.firstChild?.nodeType === 3;
+		}
+		if (textOnly) {
+			for (let i = start; i < newEnd; i++) if (parts[i].html !== previous[i].html) row.childNodes[i].firstChild.nodeValue = parts[i].text;
+			this.rowParts.set(row, parts);
+			return;
+		}
+		if (start + parts.length - newEnd < Math.max(oldEnd - start, newEnd - start)) row.innerHTML = parts.map((part) => part.html).join("");
+		else {
+			const range = row.ownerDocument.createRange();
+			range.setStart(row, start);
+			range.setEnd(row, oldEnd);
+			range.deleteContents();
+			const html = parts.slice(start, newEnd).map((part) => part.html).join("");
+			if (html) range.insertNode(range.createContextualFragment(html));
+		}
+		this.rowParts.set(row, parts);
+	}
+	_updateScrollbackRow(core, sbOffset, rowEl) {
+		const lineLen = core.getScrollbackLineLen(sbOffset);
+		this._buildRowContent(rowEl, (col) => core.getScrollbackCell(sbOffset, col), lineLen, -1, -1);
+		const content = this.rowText.get(rowEl);
+		const metadata = core.getScrollbackRowMetadata?.(sbOffset);
+		content.metadata = metadata && lineLen <= this.cols ? { ...metadata } : null;
+	}
+	syncScrollback(core, viewport) {
+		const scrollbackCount = core.getScrollbackCount();
+		const rowHeight = viewport?.rowHeight ?? 0;
+		const virtual = viewport !== void 0 && rowHeight > 0;
+		const overscan = viewport?.overscanRows ?? DEFAULT_SCROLLBACK_OVERSCAN_ROWS;
+		const hasDiscardedCount = viewport?.scrollbackDiscardedCount !== void 0;
+		const discardedCount = viewport?.scrollbackDiscardedCount ?? 0;
+		const viewportHeight = viewport && viewport.clientHeight > 0 ? viewport.clientHeight : this.rows * rowHeight;
+		const firstVisible = virtual ? Math.floor(viewport.scrollTop / rowHeight) : 0;
+		const visibleRows = virtual ? Math.ceil(viewportHeight / rowHeight) : scrollbackCount;
+		const start = virtual ? Math.max(0, Math.min(scrollbackCount, firstVisible - overscan)) : 0;
+		const end = virtual ? Math.max(start, Math.min(scrollbackCount, firstVisible + visibleRows + overscan)) : scrollbackCount;
+		const selection = this.container.ownerDocument.getSelection();
+		const selectionInContainer = selection !== null && !selection.isCollapsed && (this.container.contains(selection.anchorNode) || this.container.contains(selection.focusNode));
+		const contentUnchanged = this.painted && !this.colorsChanged && hasDiscardedCount && scrollbackCount === this._renderedScrollbackCount && discardedCount === this._renderedDiscardedCount;
+		const first = (this._scrollbackKeys[0] ?? Infinity) - discardedCount;
+		const last = (this._scrollbackKeys[this._scrollbackKeys.length - 1] ?? -Infinity) - discardedCount + 1;
+		const margin = Math.ceil(overscan / 2);
+		if (virtual && contentUnchanged && !selectionInContainer && !viewport?.selectedRows && rowHeight === this._scrollbackRowHeight && this._scrollbackKeys.length === last - first && this._scrollbackKeys.length <= visibleRows + 2 * overscan && first <= Math.max(0, Math.min(scrollbackCount, firstVisible - margin)) && last >= Math.min(scrollbackCount, firstVisible + visibleRows + margin)) return;
+		const indices = /* @__PURE__ */ new Set();
+		for (let index = start; index < end; index++) indices.add(index);
+		if (!viewport?.selectedRows && selectionInContainer && selection.rangeCount === 1) {
+			const range = selection.getRangeAt(0);
+			const selected = this._scrollbackRowEls.flatMap((row, i) => range.intersectsNode(row) ? [this._scrollbackKeys[i] - discardedCount] : []);
+			if (selected.length <= MAX_TRACKED_SELECTION_ROWS) {
+				for (const index of selected) if (index >= 0 && index < scrollbackCount) indices.add(index);
+			}
+		}
+		if (viewport?.selectedRows) for (let index = Math.max(0, viewport.selectedRows.start); index <= Math.min(scrollbackCount - 1, viewport.selectedRows.end); index++) indices.add(index);
+		const ordered = Array.from(indices).sort((a, b) => a - b);
+		const keys = ordered.map((index) => discardedCount + index);
+		if (contentUnchanged && rowHeight === this._scrollbackRowHeight && keys.length === this._scrollbackKeys.length && keys.every((key, index) => key === this._scrollbackKeys[index])) return;
+		const previous = /* @__PURE__ */ new Map();
+		for (let i = 0; i < this._scrollbackRowEls.length; i++) previous.set(this._scrollbackKeys[i], this._scrollbackRowEls[i]);
+		const retained = new Set(keys);
+		for (const [key, rowEl] of previous) if (!retained.has(key)) rowEl.remove();
+		for (const spacer of this._scrollbackGapSpacers) spacer.remove();
+		this._scrollbackGapSpacers = [];
+		const nextRows = [];
+		let nextSibling = this._scrollbackTopSpacer?.nextSibling ?? null;
+		let previousIndex = (ordered[0] ?? scrollbackCount) - 1;
+		for (const index of ordered) {
+			if (index > previousIndex + 1) {
+				const spacer = document.createElement("div");
+				spacer.className = "term-scrollback-spacer";
+				spacer.style.height = `${(index - previousIndex - 1) * rowHeight}px`;
+				this.container.insertBefore(spacer, nextSibling ?? this._scrollbackBottomSpacer);
+				this._scrollbackGapSpacers.push(spacer);
+			}
+			previousIndex = index;
+			const key = discardedCount + index;
+			const offset = scrollbackCount - 1 - index;
+			let rowEl = previous.get(key);
+			if (!rowEl) {
+				rowEl = document.createElement("div");
+				rowEl.className = "term-row term-scrollback-row";
+				this._updateScrollbackRow(core, offset, rowEl);
+			} else if (!contentUnchanged) this._updateScrollbackRow(core, offset, rowEl);
+			if (rowEl !== nextSibling) this.container.insertBefore(rowEl, nextSibling ?? this._scrollbackBottomSpacer);
+			nextSibling = rowEl.nextSibling;
+			nextRows.push(rowEl);
+		}
+		this._scrollbackRowEls = nextRows;
+		this._scrollbackKeys = keys;
+		this._renderedScrollbackCount = scrollbackCount;
+		this._renderedDiscardedCount = discardedCount;
+		this._scrollbackRowHeight = rowHeight;
+		if (this._scrollbackTopSpacer) this._scrollbackTopSpacer.style.height = `${(ordered[0] ?? scrollbackCount) * rowHeight}px`;
+		if (this._scrollbackBottomSpacer) this._scrollbackBottomSpacer.style.height = `${ordered.length ? (scrollbackCount - ordered[ordered.length - 1] - 1) * rowHeight : 0}px`;
+	}
+	syncColorOverrides(colors = {}) {
+		for (const [key, property] of [
+			["foreground", "--term-app-fg"],
+			["background", "--term-app-bg"],
+			["cursor", "--term-app-cursor"]
+		]) {
+			const value = colors[key];
+			const css = value === void 0 ? "" : rgbToCSS(value);
+			if (this.colorHost.style.getPropertyValue(property) === css) continue;
+			if (css) this.colorHost.style.setProperty(property, css);
+			else this.colorHost.style.removeProperty(property);
+		}
+	}
+	render(core, viewport) {
+		this.syncColorOverrides(core.getColorOverrides?.());
+		this.viewport = viewport;
+		this.selection ?? (this.selection = new TrackedSelection(this.container.parentElement ?? this.container));
+		const positions = this.selection.beforeRender(core, this.selectionRows());
+		const rows = core.getRows();
+		const cols = core.getCols();
+		let resized = false;
+		if (this.needsSetup || rows !== this.rows || cols !== this.cols) {
+			this.setup(cols, rows);
+			this.needsSetup = false;
+			resized = true;
+		}
+		this.syncScrollback(core, viewport && {
+			...viewport,
+			selectedRows: positions ? {
+				start: positions.start.row,
+				end: positions.end.row
+			} : void 0
+		});
+		const cursor = core.getCursor();
+		const cursorVisible = cursor.visible;
+		const shape = cursor.shape ?? "block";
+		const blink = String(cursor.blinking ?? false);
+		if (this.container.dataset.cursorShape !== shape) this.container.dataset.cursorShape = shape;
+		if (this.container.dataset.cursorBlink !== blink) this.container.dataset.cursorBlink = blink;
+		const needsCursorUpdate = cursor.row !== this.prevCursorRow || cursor.col !== this.prevCursorCol || cursorVisible !== this.prevCursorVisible;
+		for (let r = 0; r < this.rows; r++) {
+			const isDirty = this.colorsChanged || resized || core.isDirtyRow(r);
+			const hadCursor = r === this.prevCursorRow && needsCursorUpdate;
+			const hasCursor = r === cursor.row;
+			if (isDirty || hadCursor || hasCursor && needsCursorUpdate) {
+				const cCol = hasCursor && cursorVisible ? cursor.col : -1;
+				this._buildRowContent(this.rowEls[r], (col) => core.getCell(r, col), this.cols, cCol, r);
+			}
+			const content = this.rowText.get(this.rowEls[r]);
+			if (content) {
+				const metadata = core.getRowMetadata?.(r);
+				content.metadata = metadata ? { ...metadata } : null;
+			}
+		}
+		this.prevCursorRow = cursor.row;
+		this.prevCursorCol = cursor.col;
+		this.prevCursorVisible = cursorVisible;
+		core.clearDirty();
+		this.colorsChanged = false;
+		this.selection.afterRender(this.selectionRows(), positions);
+		this.painted = true;
+		this.graphics.reconcile(core, {
+			scrollTop: viewport?.scrollTop ?? 0,
+			clientHeight: viewport?.clientHeight ?? 0,
+			rowHeight: viewport?.rowHeight ?? 0,
+			charWidth: viewport?.charWidth ?? 0,
+			overscanRows: viewport?.overscanRows ?? DEFAULT_SCROLLBACK_OVERSCAN_ROWS,
+			scrollbackCount: core.getScrollbackCount()
+		});
+	}
+	/** Mounted rows in chronological, retained-buffer coordinates. */
+	*searchRows() {
+		for (let i = 0; i < this._scrollbackRowEls.length; i++) yield {
+			row: this._scrollbackKeys[i] - Math.max(0, this._renderedDiscardedCount),
+			element: this._scrollbackRowEls[i]
+		};
+		for (let i = 0; i < this.rowEls.length; i++) yield {
+			row: Math.max(0, this._renderedScrollbackCount) + i,
+			element: this.rowEls[i]
+		};
+	}
+	/** Plain text for the native selection, or null when this terminal does not own it. */
+	getSelectionText() {
+		const terminal = this.container.parentElement;
+		if (!terminal) return null;
+		return getSelectionText(terminal, this.selectionRows());
+	}
+	*selectionRows() {
+		for (const row of this.searchRows()) {
+			const content = this.rowText.get(row.element);
+			if (content) yield {
+				...row,
+				content
+			};
+		}
+	}
+	beforeMutation(core) {
+		this.selection?.beforeMutation(core, this.selectionRows());
+		this.painted = false;
+	}
+	/** Resolve a mounted row hit using cell geometry, including wide glyphs. */
+	positionAt(target, clientX, charWidth) {
+		if (!this.painted || this.needsSetup || charWidth <= 0) return null;
+		const element = target.closest(".term-row");
+		const mounted = Array.from(this.searchRows()).find((row) => row.element === element);
+		if (!mounted) return null;
+		const col = Math.floor((clientX - mounted.element.getBoundingClientRect().left) / charWidth);
+		return col >= 0 && col < this.cols ? {
+			row: mounted.row,
+			col
+		} : null;
+	}
+	select(core, position, unit, beforeSelect) {
+		if (!this.painted || this.needsSetup) return false;
+		const range = selectionRange(core, position, unit);
+		if (!range) return false;
+		beforeSelect();
+		if (!this.painted || this.needsSetup) return false;
+		this.syncScrollback(core, {
+			...this.viewport ?? {
+				scrollTop: 0,
+				clientHeight: 0,
+				rowHeight: 0
+			},
+			selectedRows: {
+				start: range.start.row,
+				end: range.end.row
+			}
+		});
+		const mounted = Array.from(this.selectionRows());
+		const edge = (position, after) => {
+			const row = mounted.find((row) => row.row === position.row);
+			return row && textPoint(row.element, offsetAtCell(row.content, position.col, after));
+		};
+		const start = edge(range.start, false), end = edge(range.end, true);
+		const native = this.container.ownerDocument.getSelection();
+		if (!start || !end || !native) return false;
+		native.setBaseAndExtent(...start, ...end);
+		this.selection?.capture(core, this.selectionRows());
+		return true;
+	}
+	rectangle(core, start, end, beforeSelect) {
+		if (!this.painted || this.needsSetup) return null;
+		const rectangle = rectangleSelection(core, start, end);
+		if (!rectangle) return null;
+		beforeSelect();
+		return this.painted && !this.needsSetup ? rectangle : null;
+	}
+	/** Clamp a drag to the nearest mounted row without mounting extra history. */
+	dragPositionAt(clientX, clientY, charWidth) {
+		if (!this.painted || this.needsSetup || charWidth <= 0) return null;
+		let nearest = null;
+		for (const { row, element } of this.searchRows()) {
+			const rect = element.getBoundingClientRect();
+			const distance = Math.max(rect.top - clientY, clientY - rect.bottom, 0);
+			if (!nearest || distance < nearest.distance) nearest = {
+				row,
+				distance,
+				col: Math.max(0, Math.min(this.cols - 1, Math.floor((clientX - rect.left) / charWidth)))
+			};
+		}
+		return nearest && {
+			row: nearest.row,
+			col: nearest.col
+		};
+	}
+	requestSetup() {
+		this.needsSetup = true;
+	}
+	/** Re-read indexed colors in live and retained rows without rebuilding the grid. */
+	invalidateColors() {
+		this.colorsChanged = true;
+	}
+	/** Replaces decorations only, preserving native text selection. */
+	setSearchDecorations(decorations) {
+		if (!decorations.firstChild && !this.searchLayer.firstChild) return;
+		this.searchLayer.replaceChildren(decorations);
+	}
+	destroy() {
+		this.syncColorOverrides();
+		this.painted = false;
+		this.selection?.dispose();
+		this.graphics.destroy();
+		this.container.innerHTML = "";
+		this.rowEls = [];
+		this._scrollbackRowEls = [];
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/input-accessibility.js
+var LABEL_ATTRIBUTES = [
+	"aria-label",
+	"aria-labelledby",
+	"aria-describedby",
+	"aria-description"
+];
+var KEYBOARD_EXIT_HINT = "Press Escape, then Tab to move focus out of the terminal, or Shift+Tab to move focus backward.";
+var nextHintId = 0;
+/** Keep host-provided names and tab order on the element receiving input. */
+var InputAccessibility = class {
+	constructor(host, input) {
+		this.host = host;
+		this.input = input;
+		this.destroyed = false;
+		this.hint = host.ownerDocument.createElement("span");
+		do
+			this.hint.id = `wterm-input-help-${++nextHintId}`;
+		while (host.getRootNode().querySelector(`#${this.hint.id}`));
+		this.hint.hidden = true;
+		this.hint.textContent = KEYBOARD_EXIT_HINT;
+		host.append(this.hint);
+		this.tabIndex = host.getAttribute("tabindex");
+		this.defaultRole = !host.hasAttribute("role");
+		if (this.defaultRole) host.setAttribute("role", "group");
+		this.observer = new MutationObserver((records) => this.sync(records));
+		this.sync();
+	}
+	sync(records = []) {
+		if (records.some((record) => record.attributeName === "tabindex")) this.tabIndex = this.host.getAttribute("tabindex");
+		for (const attribute of LABEL_ATTRIBUTES) {
+			const value = this.host.getAttribute(attribute);
+			if (value?.trim()) this.input.setAttribute(attribute, value);
+			else this.input.removeAttribute(attribute);
+		}
+		if (!this.input.hasAttribute("aria-label")) this.input.setAttribute("aria-label", "Terminal");
+		const describedBy = this.input.getAttribute("aria-describedby");
+		if (describedBy) this.input.setAttribute("aria-describedby", `${describedBy} ${this.hint.id}`);
+		this.input.setAttribute("aria-description", [this.input.getAttribute("aria-description"), KEYBOARD_EXIT_HINT].filter(Boolean).join(" "));
+		this.input.setAttribute("tabindex", this.tabIndex ?? "0");
+		this.observer.disconnect();
+		if (this.tabIndex !== null) this.host.setAttribute("tabindex", "-1");
+		this.observer.observe(this.host, {
+			attributes: true,
+			attributeFilter: [...LABEL_ATTRIBUTES, "tabindex"]
+		});
+	}
+	destroy() {
+		if (this.destroyed) return;
+		this.destroyed = true;
+		if (this.observer.takeRecords().some((record) => record.attributeName === "tabindex")) this.tabIndex = this.host.getAttribute("tabindex");
+		this.observer.disconnect();
+		this.hint.remove();
+		if (this.tabIndex === null) this.host.removeAttribute("tabindex");
+		else this.host.setAttribute("tabindex", this.tabIndex);
+		if (this.defaultRole && this.host.getAttribute("role") === "group") this.host.removeAttribute("role");
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/hyperlink.js
+function isLinkActivationModifier(event, navigator) {
+	return navigator.platform.startsWith("Mac") ? event.metaKey : event.ctrlKey;
+}
+var FUNCTIONAL_KEYS = {
+	Escape: {
+		code: 27,
+		final: "u"
+	},
+	Enter: {
+		code: 13,
+		final: "u"
+	},
+	Tab: {
+		code: 9,
+		final: "u"
+	},
+	Backspace: {
+		code: 127,
+		final: "u"
+	},
+	Insert: {
+		code: 2,
+		final: "~"
+	},
+	Delete: {
+		code: 3,
+		final: "~"
+	},
+	ArrowLeft: {
+		code: 1,
+		final: "D"
+	},
+	ArrowRight: {
+		code: 1,
+		final: "C"
+	},
+	ArrowUp: {
+		code: 1,
+		final: "A"
+	},
+	ArrowDown: {
+		code: 1,
+		final: "B"
+	},
+	PageUp: {
+		code: 5,
+		final: "~"
+	},
+	PageDown: {
+		code: 6,
+		final: "~"
+	},
+	Home: {
+		code: 1,
+		final: "H"
+	},
+	End: {
+		code: 1,
+		final: "F"
+	},
+	CapsLock: {
+		code: 57358,
+		final: "u",
+		modifier: true
+	},
+	ScrollLock: {
+		code: 57359,
+		final: "u"
+	},
+	NumLock: {
+		code: 57360,
+		final: "u",
+		modifier: true
+	},
+	PrintScreen: {
+		code: 57361,
+		final: "u"
+	},
+	Pause: {
+		code: 57362,
+		final: "u"
+	},
+	F1: {
+		code: 1,
+		final: "P"
+	},
+	F2: {
+		code: 1,
+		final: "Q"
+	},
+	F3: {
+		code: 13,
+		final: "~"
+	},
+	F4: {
+		code: 1,
+		final: "S"
+	},
+	F5: {
+		code: 15,
+		final: "~"
+	},
+	F6: {
+		code: 17,
+		final: "~"
+	},
+	F7: {
+		code: 18,
+		final: "~"
+	},
+	F8: {
+		code: 19,
+		final: "~"
+	},
+	F9: {
+		code: 20,
+		final: "~"
+	},
+	F10: {
+		code: 21,
+		final: "~"
+	},
+	F11: {
+		code: 23,
+		final: "~"
+	},
+	F12: {
+		code: 24,
+		final: "~"
+	},
+	ShiftLeft: {
+		code: 57441,
+		final: "u",
+		modifier: true
+	},
+	ControlLeft: {
+		code: 57442,
+		final: "u",
+		modifier: true
+	},
+	AltLeft: {
+		code: 57443,
+		final: "u",
+		modifier: true
+	},
+	MetaLeft: {
+		code: 57444,
+		final: "u",
+		modifier: true
+	},
+	ShiftRight: {
+		code: 57447,
+		final: "u",
+		modifier: true
+	},
+	ControlRight: {
+		code: 57448,
+		final: "u",
+		modifier: true
+	},
+	AltRight: {
+		code: 57449,
+		final: "u",
+		modifier: true
+	},
+	MetaRight: {
+		code: 57450,
+		final: "u",
+		modifier: true
+	},
+	Numpad0: {
+		code: 57399,
+		final: "u"
+	},
+	Numpad1: {
+		code: 57400,
+		final: "u"
+	},
+	Numpad2: {
+		code: 57401,
+		final: "u"
+	},
+	Numpad3: {
+		code: 57402,
+		final: "u"
+	},
+	Numpad4: {
+		code: 57403,
+		final: "u"
+	},
+	Numpad5: {
+		code: 57404,
+		final: "u"
+	},
+	Numpad6: {
+		code: 57405,
+		final: "u"
+	},
+	Numpad7: {
+		code: 57406,
+		final: "u"
+	},
+	Numpad8: {
+		code: 57407,
+		final: "u"
+	},
+	Numpad9: {
+		code: 57408,
+		final: "u"
+	},
+	NumpadDecimal: {
+		code: 57409,
+		final: "u"
+	},
+	NumpadDivide: {
+		code: 57410,
+		final: "u"
+	},
+	NumpadMultiply: {
+		code: 57411,
+		final: "u"
+	},
+	NumpadSubtract: {
+		code: 57412,
+		final: "u"
+	},
+	NumpadAdd: {
+		code: 57413,
+		final: "u"
+	},
+	NumpadEnter: {
+		code: 57414,
+		final: "u"
+	},
+	NumpadEqual: {
+		code: 57415,
+		final: "u"
+	},
+	NumpadComma: {
+		code: 57416,
+		final: "u"
+	}
+};
+var KEYPAD_BEGIN = {
+	code: 1,
+	final: "E"
+};
+for (let index = 13; index <= 25; index++) FUNCTIONAL_KEYS[`F${index}`] = {
+	code: 57363 + index,
+	final: "u"
+};
+function codePoint(value) {
+	const chars = Array.from(value);
+	return chars.length === 1 ? chars[0].codePointAt(0) : null;
+}
+function printableEntry(event) {
+	const current = codePoint(event.key);
+	if (current === null || current < 32 || current === 127) return null;
+	return {
+		code: codePoint(event.key.toLowerCase()) ?? current,
+		final: "u"
+	};
+}
+function resolveKey(event, normalizeKeypad) {
+	if (normalizeKeypad && event.code.startsWith("Numpad")) {
+		if (event.code === "Numpad5" && event.key === "Clear") return {
+			entry: KEYPAD_BEGIN,
+			functionalKey: "Begin"
+		};
+		if (event.key.length === 1) {
+			const entry = printableEntry(event);
+			return entry ? {
+				entry,
+				functionalKey: null
+			} : null;
+		}
+		const entry = FUNCTIONAL_KEYS[event.key];
+		return entry ? {
+			entry,
+			functionalKey: event.key
+		} : null;
+	}
+	const keypadNavigation = keypadNavigationEntry(event);
+	if (keypadNavigation) return {
+		entry: keypadNavigation,
+		functionalKey: event.code
+	};
+	const byCode = FUNCTIONAL_KEYS[event.code];
+	if (byCode) return {
+		entry: byCode,
+		functionalKey: event.code
+	};
+	const byKey = FUNCTIONAL_KEYS[event.key];
+	if (byKey) return {
+		entry: byKey,
+		functionalKey: event.key
+	};
+	const printable = printableEntry(event);
+	return printable ? {
+		entry: printable,
+		functionalKey: null
+	} : null;
+}
+function keypadNavigationEntry(event) {
+	const code = {
+		"Numpad4:ArrowLeft": 57417,
+		"Numpad6:ArrowRight": 57418,
+		"Numpad8:ArrowUp": 57419,
+		"Numpad2:ArrowDown": 57420,
+		"Numpad9:PageUp": 57421,
+		"Numpad3:PageDown": 57422,
+		"Numpad7:Home": 57423,
+		"Numpad1:End": 57424,
+		"Numpad0:Insert": 57425,
+		"NumpadDecimal:Delete": 57426,
+		"Numpad5:Clear": 57427
+	}[`${event.code}:${event.key}`];
+	return code === void 0 ? null : {
+		code,
+		final: "u"
+	};
+}
+function hasModifier(prefix, pressedModifiers) {
+	for (const code of pressedModifiers ?? []) if (code.startsWith(prefix)) return true;
+	return false;
+}
+function modifierValue(event, action, pressedModifiers) {
+	let value = 1;
+	const includeCurrent = action !== "release";
+	if (event.shiftKey || hasModifier("Shift", pressedModifiers) || includeCurrent && event.code.startsWith("Shift")) value += 1;
+	if (event.altKey || hasModifier("Alt", pressedModifiers) || includeCurrent && event.code.startsWith("Alt")) value += 2;
+	if (event.ctrlKey || hasModifier("Control", pressedModifiers) || includeCurrent && event.code.startsWith("Control")) value += 4;
+	if (event.metaKey || hasModifier("Meta", pressedModifiers) || includeCurrent && event.code.startsWith("Meta")) value += 8;
+	if (event.getModifierState("CapsLock")) value += 64;
+	if (event.getModifierState("NumLock")) value += 128;
+	return value;
+}
+function associatedText(event) {
+	if (event.ctrlKey || event.metaKey || event.altKey) return [];
+	return Array.from(event.key).map((char) => char.codePointAt(0)).filter((point) => point >= 32 && point !== 127);
+}
+/** ASCII control byte for a browser key, or null when no legacy mapping exists. */
+function legacyControlByte(key) {
+	if (key.length !== 1) return null;
+	const code = key.toLowerCase().charCodeAt(0);
+	if (code >= 97 && code <= 122) return String.fromCharCode(code - 96);
+	switch (key) {
+		case " ":
+		case "2":
+		case "@": return "\0";
+		case "3":
+		case "[": return "\x1B";
+		case "4":
+		case "\\": return "";
+		case "5":
+		case "]": return "";
+		case "6":
+		case "^":
+		case "~": return "";
+		case "7":
+		case "/":
+		case "_": return "";
+		case "8":
+		case "?": return "";
+		default: return null;
+	}
+}
+function legacyModifiedText(event) {
+	if (event.metaKey) return null;
+	const chars = Array.from(event.key);
+	if (chars.length !== 1 || chars[0].codePointAt(0) < 32 || chars[0].codePointAt(0) > 126) return null;
+	if (event.shiftKey && event.ctrlKey && /^[a-z]$/i.test(event.key)) return null;
+	if (event.ctrlKey) {
+		const key = event.key.toLowerCase();
+		const control = legacyControlByte(key) ?? key;
+		return event.altKey ? `\x1b${control}` : control;
+	}
+	return event.altKey ? `\x1b${event.key}` : null;
+}
+function legacyFunctionalSequence(functionalKey, flags, action, modifierBits, cursorKeysApp) {
+	const disambiguate = Boolean(flags & 1);
+	const reportEvents = Boolean(flags & 2);
+	const reportAll = Boolean(flags & 8);
+	const legacyMode = !disambiguate && !reportEvents && !reportAll;
+	const nonLockModifiers = modifierBits & -193;
+	if (cursorKeysApp && legacyMode && nonLockModifiers === 0) {
+		const appSequence = {
+			ArrowUp: "\x1BOA",
+			ArrowDown: "\x1BOB",
+			ArrowRight: "\x1BOC",
+			ArrowLeft: "\x1BOD",
+			Begin: "\x1BOE",
+			End: "\x1BOF",
+			Home: "\x1BOH"
+		}[functionalKey];
+		if (appSequence) return {
+			handled: true,
+			sequence: appSequence
+		};
+	}
+	if (nonLockModifiers === 0) {
+		if (!disambiguate && !reportAll && functionalKey === "Escape") return {
+			handled: true,
+			sequence: "\x1B"
+		};
+		if (legacyMode) {
+			const functionSequence = {
+				F1: "\x1BOP",
+				F2: "\x1BOQ",
+				F3: "\x1BOR",
+				F4: "\x1BOS"
+			}[functionalKey];
+			if (functionSequence) return {
+				handled: true,
+				sequence: functionSequence
+			};
+		}
+	}
+	if (legacyMode && modifierBits !== 0) {
+		const prefix = modifierBits & 2 ? "\x1B" : "";
+		if (functionalKey === "Enter") return {
+			handled: true,
+			sequence: `${prefix}\r`
+		};
+		if (functionalKey === "Escape") return {
+			handled: true,
+			sequence: `${prefix}\x1b`
+		};
+		if (functionalKey === "Backspace") return {
+			handled: true,
+			sequence: `${prefix}${modifierBits & 4 ? "\b" : ""}`
+		};
+		if (functionalKey === "Tab") {
+			if (modifierBits & 1) return {
+				handled: true,
+				sequence: `${modifierBits & 2 ? "\x1B\x1B" : "\x1B"}[Z`
+			};
+			return {
+				handled: true,
+				sequence: `${prefix}\t`
+			};
+		}
+	}
+	if (nonLockModifiers === 0 && !reportAll && (functionalKey === "Enter" || functionalKey === "Backspace" || functionalKey === "Tab")) return {
+		handled: true,
+		sequence: action === "release" ? null : functionalKey === "Enter" ? "\r" : functionalKey === "Backspace" ? "" : "	"
+	};
+	return {
+		handled: false,
+		sequence: null
+	};
+}
+function encodeKittyKey(event, flags, action, pressedModifiers, cursorKeysApp = false) {
+	if (flags === 0) return null;
+	if (action === "release" && !(flags & 2)) return null;
+	const normalizeKeypad = !(flags & 1) && !(flags & 8);
+	const resolved = resolveKey(event, normalizeKeypad);
+	const entry = resolved?.entry ?? null;
+	const textEntry = printableEntry(event);
+	const legacyText = !(flags & 8) && textEntry !== null && !event.altKey && !event.ctrlKey && !event.metaKey;
+	const legacyModified = !(flags & 1) && !(flags & 8) && (action === "press" || !(flags & 2)) && (event.ctrlKey || event.altKey) ? legacyModifiedText(event) : null;
+	if (action === "release" && !(flags & 8) && legacyText) return null;
+	if (action !== "release" && !(flags & 8) && !event.altKey && !event.ctrlKey && !event.metaKey) {
+		if (!event.shiftKey) {
+			if (event.key === "Enter" && (event.code !== "NumpadEnter" || normalizeKeypad)) return "\r";
+			if (event.key === "Tab") return "	";
+			if (event.key === "Backspace") return "";
+		}
+		if (legacyText) return event.key;
+	}
+	if (legacyModified !== null) return legacyModified;
+	if (!entry) return null;
+	if (entry.modifier && !(flags & 8)) return null;
+	const modifiers = modifierValue(event, action, pressedModifiers);
+	if (resolved?.functionalKey) {
+		const legacy = legacyFunctionalSequence(resolved.functionalKey, flags, action, modifiers - 1, cursorKeysApp);
+		if (legacy.handled) return legacy.sequence;
+	}
+	const eventType = flags & 2 ? action === "repeat" ? 2 : action === "release" ? 3 : 0 : 0;
+	if (entry.final !== "u" && entry.final !== "~") {
+		if (eventType !== 0) return `\x1b[1;${modifiers}:${eventType}${entry.final}`;
+		if (modifiers > 1) return `\x1b[1;${modifiers}${entry.final}`;
+		return `\x1b[${entry.final}`;
+	}
+	let sequence = `\x1b[${entry.code}`;
+	if (textEntry && flags & 4 && event.shiftKey) {
+		const shifted = codePoint(event.key);
+		if (shifted !== null && shifted !== entry.code) sequence += `:${shifted}`;
+	}
+	let emittedModifiers = false;
+	if (eventType === 2 || eventType === 3) {
+		sequence += `;${modifiers}:${eventType}`;
+		emittedModifiers = true;
+	} else if (modifiers > 1) {
+		sequence += `;${modifiers}`;
+		emittedModifiers = true;
+	}
+	if (textEntry && flags & 16 && action !== "release") {
+		const text = associatedText(event);
+		if (text.length > 0) {
+			sequence += emittedModifiers ? ";" : ";;";
+			sequence += text.join(":");
+		}
+	}
+	return sequence + entry.final;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/input.js
+var NORMAL_KEYS = {
+	ArrowUp: "\x1B[A",
+	ArrowDown: "\x1B[B",
+	ArrowRight: "\x1B[C",
+	ArrowLeft: "\x1B[D",
+	Home: "\x1B[H",
+	End: "\x1B[F"
+};
+var APP_KEYS = {
+	ArrowUp: "\x1BOA",
+	ArrowDown: "\x1BOB",
+	ArrowRight: "\x1BOC",
+	ArrowLeft: "\x1BOD",
+	Home: "\x1BOH",
+	End: "\x1BOF"
+};
+var MODIFIED_CSI_KEYS = {
+	ArrowUp: "A",
+	ArrowDown: "B",
+	ArrowRight: "C",
+	ArrowLeft: "D",
+	Home: "H",
+	End: "F",
+	F1: "P",
+	F2: "Q",
+	F3: "R",
+	F4: "S"
+};
+var MODIFIED_TILDE_KEYS = {
+	Insert: 2,
+	Delete: 3,
+	PageUp: 5,
+	PageDown: 6,
+	F5: 15,
+	F6: 17,
+	F7: 18,
+	F8: 19,
+	F9: 20,
+	F10: 21,
+	F11: 23,
+	F12: 24
+};
+var FIXED_KEYS = {
+	Enter: "\r",
+	Backspace: "",
+	Tab: "	",
+	Escape: "\x1B",
+	Insert: "\x1B[2~",
+	Delete: "\x1B[3~",
+	PageUp: "\x1B[5~",
+	PageDown: "\x1B[6~",
+	F1: "\x1BOP",
+	F2: "\x1BOQ",
+	F3: "\x1BOR",
+	F4: "\x1BOS",
+	F5: "\x1B[15~",
+	F6: "\x1B[17~",
+	F7: "\x1B[18~",
+	F8: "\x1B[19~",
+	F9: "\x1B[20~",
+	F10: "\x1B[21~",
+	F11: "\x1B[23~",
+	F12: "\x1B[24~"
+};
+var COMPOSITION_INPUT_DEDUP_MS = 250;
+var SCROLLBACK_BOTTOM_TOLERANCE = 5;
+var TOUCH_INPUT_PLACEHOLDER = "​";
+function isAltGraphTextInput(event, pressedModifiers) {
+	if (event.metaKey || !(event.getModifierState("AltGraph") || event.ctrlKey && event.altKey && pressedModifiers.has("AltRight"))) return false;
+	const chars = Array.from(event.key);
+	return chars.length === 1 && chars[0].codePointAt(0) >= 32 && chars[0] !== "";
+}
+var InputHandler = class {
+	constructor(element, onData, getBridge, getCellSize = () => null, prepareComposition = () => {}, onBinary, selectionActions) {
+		this.selectionActions = selectionActions;
+		this.composing = false;
+		this.compositionWidth = 0;
+		this.recentCompositionCommit = null;
+		this.suppressNextTouchDeleteInput = false;
+		this.mouseButtons = 0;
+		this.lastMouseMotion = null;
+		this.focused = false;
+		this.suppressedKeyUps = /* @__PURE__ */ new Set();
+		this.pressedModifiers = /* @__PURE__ */ new Set();
+		this.deliveredKeys = /* @__PURE__ */ new Set();
+		this.tabExitArmed = false;
+		this.element = element;
+		this.onData = onData;
+		this.onBinary = onBinary;
+		this.getBridge = getBridge;
+		this.getCellSize = getCellSize;
+		this.prepareComposition = prepareComposition;
+		this.touchPrimary = element.ownerDocument.defaultView?.matchMedia?.("(pointer: coarse)").matches ?? false;
+		this.textarea = document.createElement("textarea");
+		this.textarea.setAttribute("autocapitalize", "off");
+		this.textarea.setAttribute("autocomplete", "off");
+		this.textarea.setAttribute("autocorrect", "off");
+		this.textarea.setAttribute("spellcheck", "false");
+		this.textarea.setAttribute("enterkeyhint", "send");
+		this.textarea.wrap = "off";
+		const s = this.textarea.style;
+		s.position = "absolute";
+		s.left = "-9999px";
+		s.top = "0";
+		s.width = this.touchPrimary ? "var(--term-cell-width, 1ch)" : "1px";
+		s.height = this.touchPrimary ? "var(--term-row-height)" : "1px";
+		s.boxSizing = "border-box";
+		s.font = "inherit";
+		s.lineHeight = "var(--term-row-height)";
+		s.fontKerning = "none";
+		s.fontVariantLigatures = "none";
+		s.whiteSpace = "pre";
+		s.zIndex = "2";
+		s.opacity = this.touchPrimary ? "1" : "0";
+		s.overflow = "hidden";
+		s.border = "0";
+		s.padding = "0";
+		s.margin = "0";
+		s.outline = "none";
+		s.resize = "none";
+		s.pointerEvents = this.touchPrimary ? "auto" : "none";
+		s.caretColor = "transparent";
+		s.color = "transparent";
+		s.background = "transparent";
+		element.appendChild(this.textarea);
+		this.accessibility = new InputAccessibility(element, this.textarea);
+		this._onKeyDown = this.handleKeyDown.bind(this);
+		this._onKeyUp = this.handleKeyUp.bind(this);
+		this._onPaste = this.handlePaste.bind(this);
+		this._onCompositionStart = this.handleCompositionStart.bind(this);
+		this._onCompositionEnd = this.handleCompositionEnd.bind(this);
+		this._onInput = this.handleInput.bind(this);
+		this._onFocus = () => {
+			if (this.focused) return;
+			this.focused = true;
+			if (this.touchPrimary && !this.textarea.value) this.resetInputValue();
+			this.positionTextarea();
+			this.element.classList.add("focused");
+			if (this.getBridge()?.focusEvents?.()) this.onData("\x1B[I");
+		};
+		this._onBlur = () => {
+			this.tabExitArmed = false;
+			this.focused = false;
+			this.composing = false;
+			this.recentCompositionCommit = null;
+			this.suppressNextTouchDeleteInput = false;
+			this.hideComposition();
+			this.textarea.value = "";
+			this.element.classList.remove("focused");
+			this.stopMouseCapture();
+			this.lastMouseMotion = null;
+			this.pressedModifiers.clear();
+			this.deliveredKeys.clear();
+			if (this.getBridge()?.focusEvents?.()) this.onData("\x1B[O");
+		};
+		this._onMouseDown = (event) => {
+			this.tabExitArmed = false;
+			this.handleMouse(event, "press");
+		};
+		this._onHoverMove = (event) => {
+			if (this.mouseButtons !== 0) return;
+			if (event.buttons !== 0 || event.shiftKey) {
+				this.lastMouseMotion = null;
+				return;
+			}
+			this.handleMouse(event, "move");
+		};
+		this._onMouseMove = (event) => {
+			if (this.mouseButtons !== 0) this.handleMouse(event, "move");
+		};
+		this._onMouseUp = (event) => {
+			if (this.mouseButtons === 0) return;
+			this.handleMouse(event, "release");
+			this.mouseButtons = event.buttons & 7;
+			if (this.mouseButtons === 0) this.stopMouseCapture();
+		};
+		this._onMouseLeave = () => {
+			if (this.mouseButtons === 0) this.lastMouseMotion = null;
+		};
+		this._onWheel = (event) => this.handleMouse(event, "wheel");
+		this.textarea.addEventListener("keydown", this._onKeyDown);
+		this.textarea.addEventListener("keyup", this._onKeyUp);
+		this.textarea.addEventListener("paste", this._onPaste);
+		this.textarea.addEventListener("compositionstart", this._onCompositionStart);
+		this.textarea.addEventListener("compositionend", this._onCompositionEnd);
+		this.textarea.addEventListener("input", this._onInput);
+		this.textarea.addEventListener("focus", this._onFocus);
+		this.textarea.addEventListener("blur", this._onBlur);
+		this.element.addEventListener("mousedown", this._onMouseDown);
+		this.element.addEventListener("mousemove", this._onHoverMove);
+		this.element.addEventListener("mouseleave", this._onMouseLeave);
+		this.element.addEventListener("wheel", this._onWheel, { passive: false });
+	}
+	focus() {
+		if (this.touchPrimary) this.prepareComposition();
+		if (this.touchPrimary && !this.composing && !this.textarea.value) this.resetInputValue();
+		this.positionTextarea();
+		this.textarea.focus({ preventScroll: true });
+	}
+	syncInputPosition() {
+		if (this.composing || this.touchPrimary) this.positionTextarea();
+	}
+	destroy() {
+		this.accessibility.destroy();
+		this.textarea.removeEventListener("keydown", this._onKeyDown);
+		this.textarea.removeEventListener("keyup", this._onKeyUp);
+		this.textarea.removeEventListener("paste", this._onPaste);
+		this.textarea.removeEventListener("compositionstart", this._onCompositionStart);
+		this.textarea.removeEventListener("compositionend", this._onCompositionEnd);
+		this.textarea.removeEventListener("input", this._onInput);
+		this.textarea.removeEventListener("focus", this._onFocus);
+		this.textarea.removeEventListener("blur", this._onBlur);
+		this.element.removeEventListener("mousedown", this._onMouseDown);
+		this.element.removeEventListener("mousemove", this._onHoverMove);
+		this.element.removeEventListener("mouseleave", this._onMouseLeave);
+		this.stopMouseCapture();
+		this.element.removeEventListener("wheel", this._onWheel);
+		this.element.classList.remove("focused");
+		this.textarea.remove();
+	}
+	handleKeyDown(e) {
+		const keyId = e.code || e.key;
+		if (e.key !== "Backspace") this.suppressNextTouchDeleteInput = false;
+		const physicalModifier = /^(Shift|Control|Alt|Meta)(Left|Right)$/.test(e.code);
+		if (physicalModifier) this.pressedModifiers.add(e.code);
+		if (this.composing || e.isComposing || e.keyCode === 229) {
+			this.tabExitArmed = false;
+			this.positionTextarea();
+			this.suppressedKeyUps.add(keyId);
+			return;
+		}
+		this.recentCompositionCommit = null;
+		const bridge = this.getBridge();
+		const kittyFlags = bridge?.kittyKeyboardFlags?.() ?? 0;
+		const kittyOwnsModifier = physicalModifier && Boolean(kittyFlags & 8);
+		const delivered = this.deliveredKeys.has(keyId);
+		if (this.tabExitArmed && e.key === "Tab" && !e.altKey && !e.ctrlKey && !e.metaKey && !e.repeat && !delivered) {
+			this.tabExitArmed = false;
+			this.suppressedKeyUps.add(keyId);
+			return;
+		}
+		if (e.key !== "Shift" || e.altKey || e.ctrlKey || e.metaKey) this.tabExitArmed = e.key === "Escape" && !e.altKey && !e.ctrlKey && !e.metaKey && !e.shiftKey;
+		if (isAltGraphTextInput(e, this.pressedModifiers)) {
+			if (!delivered) this.suppressedKeyUps.add(keyId);
+			return;
+		}
+		if (!delivered && this.selectionActions && !e.altKey && (e.metaKey && !e.ctrlKey && !e.shiftKey || e.ctrlKey && e.shiftKey && !e.metaKey) && e.key.toLowerCase() === "a") {
+			e.preventDefault();
+			e.stopPropagation();
+			this.suppressedKeyUps.add(keyId);
+			this.selectionActions.selectAll();
+			return;
+		}
+		if (!delivered && e.key === "Escape" && !e.ctrlKey && !e.metaKey && !e.altKey && !e.shiftKey && this.selectionActions?.hasSelection()) {
+			e.preventDefault();
+			e.stopPropagation();
+			this.suppressedKeyUps.add(keyId);
+			this.selectionActions.clearSelection();
+			return;
+		}
+		if (!delivered && (e.metaKey || e.ctrlKey) && !e.altKey && e.key.toLowerCase() === "c") {
+			const sel = window.getSelection();
+			if (this.selectionActions?.hasSelection() || sel && sel.toString().length > 0) {
+				this.suppressedKeyUps.add(keyId);
+				if (e.ctrlKey && e.shiftKey && !e.metaKey) {
+					e.preventDefault();
+					e.stopPropagation();
+					this.element.ownerDocument.execCommand("copy");
+				}
+				return;
+			}
+		}
+		if (!delivered && (e.metaKey || e.ctrlKey) && e.key === "v") {
+			this.suppressedKeyUps.add(keyId);
+			this.textarea.focus();
+			return;
+		}
+		if (!delivered && !kittyOwnsModifier && e.metaKey && !e.ctrlKey) {
+			this.suppressedKeyUps.add(keyId);
+			if (e.key === "Backspace") {
+				e.preventDefault();
+				this.selectionActions?.clearSelection();
+				this.onData("");
+			} else if (e.key === "a") {
+				e.preventDefault();
+				const sel = window.getSelection();
+				if (sel) {
+					const range = document.createRange();
+					range.selectNodeContents(this.element);
+					sel.removeAllRanges();
+					sel.addRange(range);
+				}
+			}
+			return;
+		}
+		this.suppressedKeyUps.delete(keyId);
+		const nativeTouchDelete = this.touchPrimary && e.key === "Backspace" && !e.altKey && !e.ctrlKey && !e.metaKey;
+		if (kittyFlags !== 0) {
+			const seq = encodeKittyKey(e, kittyFlags, e.repeat ? "repeat" : "press", this.pressedModifiers, bridge?.cursorKeysApp?.() ?? false);
+			if (seq) {
+				if (!physicalModifier) this.selectionActions?.clearSelection();
+				if (nativeTouchDelete) this.suppressNextTouchDeleteInput = true;
+				else e.preventDefault();
+				e.stopPropagation();
+				this.deliveredKeys.add(keyId);
+				this.onData(seq, physicalModifier);
+			}
+			return;
+		}
+		const seq = this.keyToSequence(e);
+		if (seq) {
+			this.selectionActions?.clearSelection();
+			if (nativeTouchDelete) this.suppressNextTouchDeleteInput = true;
+			else e.preventDefault();
+			e.stopPropagation();
+			this.onData(seq);
+		}
+	}
+	handleKeyUp(e) {
+		const keyId = e.code || e.key;
+		this.pressedModifiers.delete(e.code);
+		const delivered = this.deliveredKeys.delete(keyId);
+		if (this.suppressedKeyUps.delete(keyId)) return;
+		if (!delivered) return;
+		if (this.composing) return;
+		const bridge = this.getBridge();
+		const kittyFlags = bridge?.kittyKeyboardFlags?.() ?? 0;
+		if (!(kittyFlags & 2)) return;
+		const seq = encodeKittyKey(e, kittyFlags, "release", this.pressedModifiers, bridge?.cursorKeysApp?.() ?? false);
+		if (!seq) return;
+		e.preventDefault();
+		this.onData(seq, true);
+	}
+	handlePaste(e) {
+		this.tabExitArmed = false;
+		this.recentCompositionCommit = null;
+		this.suppressNextTouchDeleteInput = false;
+		const text = e.clipboardData?.getData("text");
+		if (!text) return;
+		e.preventDefault();
+		this.sendPaste(text);
+	}
+	sendPaste(text) {
+		this.selectionActions?.clearSelection();
+		const bridge = this.getBridge();
+		if (bridge && bridge.bracketedPaste()) {
+			const safe = text.replace(/\x1b/g, "");
+			this.onData("\x1B[200~" + safe + "\x1B[201~");
+		} else this.onData(text);
+	}
+	handleCompositionStart() {
+		this.tabExitArmed = false;
+		this.prepareComposition();
+		this.composing = true;
+		this.recentCompositionCommit = null;
+		this.suppressNextTouchDeleteInput = false;
+		if (this.touchPrimary && this.textarea.value === TOUCH_INPUT_PLACEHOLDER) this.textarea.value = "";
+		this.positionTextarea();
+		const s = this.textarea.style;
+		s.opacity = "1";
+		s.color = "var(--term-fg, currentColor)";
+		s.background = "var(--term-bg, transparent)";
+		s.caretColor = "var(--term-fg, currentColor)";
+	}
+	handleCompositionEnd(e) {
+		this.composing = false;
+		this.hideComposition();
+		this.resetInputValue();
+		if (e.data) {
+			this.recentCompositionCommit = {
+				text: e.data,
+				at: performance.now()
+			};
+			this.onData(e.data);
+		}
+	}
+	hideComposition() {
+		this.compositionWidth = 0;
+		const s = this.textarea.style;
+		s.opacity = this.touchPrimary ? "1" : "0";
+		s.width = this.touchPrimary ? "var(--term-cell-width, 1ch)" : "1px";
+		s.height = this.touchPrimary ? "var(--term-row-height)" : "1px";
+		s.color = "transparent";
+		s.background = "transparent";
+		s.caretColor = "transparent";
+	}
+	positionTextarea() {
+		const bridge = this.getBridge();
+		const cellSize = this.getCellSize();
+		const firstRow = this.element.querySelector(".term-row:not(.term-scrollback-row)");
+		if (!bridge || !cellSize || !firstRow || !bridge.getCursor) {
+			this.textarea.style.left = "0px";
+			this.textarea.style.top = "0px";
+			if (this.composing) {
+				this.textarea.style.width = `${Math.max(1, this.compositionWidth)}px`;
+				this.textarea.style.height = `${cellSize?.rowHeight ?? 17}px`;
+			}
+			return;
+		}
+		const { charWidth, rowHeight } = cellSize;
+		if (charWidth <= 0 || rowHeight <= 0) return;
+		const cursor = bridge.getCursor();
+		const col = Math.max(0, Math.min(cursor.col, bridge.getCols() - 1));
+		const row = Math.max(0, Math.min(cursor.row, bridge.getRows() - 1));
+		const hostRect = this.element.getBoundingClientRect();
+		const rowRect = firstRow.getBoundingClientRect();
+		const s = this.textarea.style;
+		s.left = `${rowRect.left - hostRect.left - this.element.clientLeft + this.element.scrollLeft + col * charWidth}px`;
+		s.top = `${rowRect.top - hostRect.top - this.element.clientTop + this.element.scrollTop + row * rowHeight}px`;
+		if (this.composing) {
+			s.width = `${Math.min((bridge.getCols() - col) * charWidth, Math.max(charWidth, this.compositionWidth))}px`;
+			s.height = `${rowHeight}px`;
+		}
+	}
+	sizeComposition() {
+		const charWidth = this.getCellSize()?.charWidth;
+		if (!charWidth || charWidth <= 0) return;
+		this.textarea.style.width = "1px";
+		this.compositionWidth = this.textarea.value ? Math.max(charWidth, this.textarea.scrollWidth + charWidth) : charWidth;
+		this.positionTextarea();
+	}
+	resetInputValue() {
+		this.textarea.value = this.touchPrimary ? TOUCH_INPUT_PLACEHOLDER : "";
+		if (this.touchPrimary) this.textarea.setSelectionRange(1, 1);
+	}
+	sendTouchDelete() {
+		this.selectionActions?.clearSelection();
+		const bridge = this.getBridge();
+		const flags = bridge?.kittyKeyboardFlags?.() ?? 0;
+		const seq = flags ? encodeKittyKey(new KeyboardEvent("keydown", {
+			key: "Backspace",
+			code: "Backspace"
+		}), flags, "press", void 0, bridge?.cursorKeysApp?.() ?? false) : "";
+		if (seq) this.onData(seq);
+	}
+	handleInput(event) {
+		this.tabExitArmed = false;
+		if (this.composing) {
+			this.sizeComposition();
+			return;
+		}
+		const inputType = event.inputType;
+		const rawValue = this.textarea.value;
+		const value = this.touchPrimary && rawValue.startsWith(TOUCH_INPUT_PLACEHOLDER) ? rawValue.slice(1) : rawValue;
+		this.resetInputValue();
+		const recent = this.recentCompositionCommit;
+		this.recentCompositionCommit = null;
+		if (this.touchPrimary && inputType === "deleteContentBackward") {
+			if (this.suppressNextTouchDeleteInput) this.suppressNextTouchDeleteInput = false;
+			else this.sendTouchDelete();
+			return;
+		}
+		this.suppressNextTouchDeleteInput = false;
+		if (!value) return;
+		if (recent && value === recent.text && performance.now() - recent.at < COMPOSITION_INPUT_DEDUP_MS) return;
+		if (inputType === "insertFromPaste") this.sendPaste(value);
+		else {
+			this.selectionActions?.clearSelection();
+			this.onData(value);
+		}
+	}
+	handleMouse(event, kind) {
+		const bridge = this.getBridge();
+		const tracking = bridge?.mouseTracking?.() ?? 0;
+		const encoding = bridge?.mouseEncoding?.() ?? (bridge?.mouseSgr?.() ? "sgr" : null);
+		if (!bridge || tracking === 0 || encoding !== "sgr" && encoding !== "sgr-pixels" && encoding !== "x10" && encoding !== "utf8" && encoding !== "urxvt") {
+			this.lastMouseMotion = null;
+			return;
+		}
+		if (kind === "wheel") {
+			const wheel = event;
+			const maxScrollTop = this.element.scrollHeight - this.element.clientHeight;
+			if (maxScrollTop > 0 && (wheel.shiftKey || maxScrollTop - this.element.scrollTop > SCROLLBACK_BOTTOM_TOLERANCE)) {
+				this.lastMouseMotion = null;
+				if (wheel.shiftKey) {
+					const delta = Math.abs(wheel.deltaX) > Math.abs(wheel.deltaY) ? wheel.deltaX : wheel.deltaY;
+					const scale = wheel.deltaMode === 1 ? this.getCellSize()?.rowHeight ?? 16 : wheel.deltaMode === 2 ? this.element.clientHeight : 1;
+					if (delta !== 0) {
+						this.element.scrollTop += delta * scale;
+						wheel.preventDefault();
+					}
+				}
+				return;
+			}
+		}
+		if (kind === "press" && isLinkActivationModifier(event, this.element.ownerDocument.defaultView?.navigator ?? navigator) && event.target instanceof Element && event.target.closest(".term-link")) return;
+		if (kind === "press" && (event.shiftKey || event.button > 2)) return;
+		if (kind === "release" && event.button > 2) return;
+		const supportedButtons = event.buttons & 7;
+		if (kind === "move" && !(tracking === 1003 || tracking === 1002 && supportedButtons !== 0)) {
+			this.lastMouseMotion = null;
+			return;
+		}
+		const view = this.element.ownerDocument.defaultView;
+		if (!view) return;
+		const viewportRow = this.element.querySelector(".term-row:not(.term-scrollback-row)");
+		const hostRect = this.element.getBoundingClientRect();
+		const rowRect = viewportRow?.getBoundingClientRect();
+		const cellSize = this.getCellSize();
+		let left;
+		let top;
+		let charWidth;
+		let rowHeight;
+		if (rowRect && cellSize) {
+			left = rowRect.left;
+			top = rowRect.top;
+			charWidth = cellSize.charWidth;
+			rowHeight = cellSize.rowHeight;
+		} else {
+			const style = view.getComputedStyle(this.element);
+			const borderLeft = parseFloat(style.borderLeftWidth) || 0;
+			const borderRight = parseFloat(style.borderRightWidth) || 0;
+			const borderTop = parseFloat(style.borderTopWidth) || 0;
+			const borderBottom = parseFloat(style.borderBottomWidth) || 0;
+			const paddingLeft = parseFloat(style.paddingLeft) || 0;
+			const paddingRight = parseFloat(style.paddingRight) || 0;
+			const paddingTop = parseFloat(style.paddingTop) || 0;
+			const paddingBottom = parseFloat(style.paddingBottom) || 0;
+			left = rowRect?.left ?? hostRect.left + borderLeft + paddingLeft;
+			top = rowRect?.top ?? hostRect.top + borderTop + paddingTop;
+			charWidth = (hostRect.width - borderLeft - borderRight - paddingLeft - paddingRight) / bridge.getCols();
+			rowHeight = (hostRect.height - borderTop - borderBottom - paddingTop - paddingBottom) / bridge.getRows();
+		}
+		const cols = bridge.getCols();
+		const rows = bridge.getRows();
+		const gridWidth = charWidth * cols;
+		const gridHeight = rowHeight * rows;
+		if (!Number.isFinite(gridWidth) || !Number.isFinite(gridHeight) || gridWidth <= 0 || gridHeight <= 0) return;
+		if ((event.clientX < left || event.clientX >= left + gridWidth || event.clientY < top || event.clientY >= top + gridHeight) && (kind === "press" || kind === "wheel" || kind === "move" && supportedButtons === 0)) {
+			this.lastMouseMotion = null;
+			return;
+		}
+		const pixels = encoding === "sgr-pixels";
+		const x = Math.max(1, Math.min(pixels ? Math.ceil(gridWidth) : cols, Math.floor((event.clientX - left) / (pixels ? 1 : charWidth)) + 1));
+		const y = Math.max(1, Math.min(pixels ? Math.ceil(gridHeight) : rows, Math.floor((event.clientY - top) / (pixels ? 1 : rowHeight)) + 1));
+		const modifiers = (event.shiftKey ? 4 : 0) | (event.altKey ? 8 : 0) | (event.ctrlKey ? 16 : 0);
+		let code;
+		let final = "M";
+		if (kind === "wheel") {
+			const wheel = event;
+			if (Math.abs(wheel.deltaX) > Math.abs(wheel.deltaY)) {
+				if (wheel.deltaX === 0) return;
+				code = (wheel.deltaX < 0 ? 66 : 67) | modifiers;
+			} else {
+				if (wheel.deltaY === 0) return;
+				code = (wheel.deltaY < 0 ? 64 : 65) | modifiers;
+			}
+		} else {
+			code = (kind === "release" && encoding !== "sgr" && !pixels ? 3 : kind === "move" ? supportedButtons === 0 ? 3 : supportedButtons & 4 ? 1 : supportedButtons & 2 ? 2 : 0 : event.button === 1 ? 1 : event.button === 2 ? 2 : 0) | modifiers | (kind === "move" ? 32 : 0);
+			if (kind === "release") final = "m";
+		}
+		const legacy = encoding === "x10" ? Uint8Array.of(27, 91, 77, code + 32, x + 32, y + 32) : null;
+		if (legacy && (x > 223 || y > 223 || !this.onBinary && (legacy[4] > 127 || legacy[5] > 127))) {
+			this.lastMouseMotion = null;
+			return;
+		}
+		if (encoding === "utf8" && (x > 2015 || y > 2015)) {
+			this.lastMouseMotion = null;
+			return;
+		}
+		if (kind === "move") {
+			const previous = this.lastMouseMotion;
+			if (previous?.mode === tracking && previous.encoding === encoding && previous.code === code && previous.x === x && previous.y === y) return;
+			this.lastMouseMotion = {
+				mode: tracking,
+				encoding,
+				code,
+				x,
+				y
+			};
+		} else this.lastMouseMotion = null;
+		if (kind === "press") {
+			this.textarea.focus({ preventScroll: true });
+			if (!this.focused) this._onFocus();
+			this.mouseButtons = supportedButtons || (event.button === 1 ? 4 : event.button === 2 ? 2 : 1);
+			view.addEventListener("mousemove", this._onMouseMove);
+			view.addEventListener("mouseup", this._onMouseUp);
+		}
+		event.preventDefault();
+		if (legacy) {
+			if (this.onBinary) this.onBinary(legacy);
+			else this.onData(String.fromCharCode(...legacy));
+		} else if (encoding === "utf8") this.onData(`\x1b[M${String.fromCodePoint(code + 32, x + 32, y + 32)}`);
+		else if (encoding === "urxvt") this.onData(`\x1b[${code + 32};${x};${y}M`);
+		else this.onData(`\x1b[<${code};${x};${y}${final}`);
+	}
+	stopMouseCapture() {
+		this.mouseButtons = 0;
+		const view = this.element.ownerDocument.defaultView;
+		view?.removeEventListener("mousemove", this._onMouseMove);
+		view?.removeEventListener("mouseup", this._onMouseUp);
+	}
+	keyToSequence(e) {
+		if (e.ctrlKey && !e.altKey && !e.metaKey) {
+			const control = legacyControlByte(e.key);
+			if (control !== null) return control;
+			if (e.key === "Backspace") return "\b";
+		}
+		if (e.key === "Enter" && e.shiftKey) return "\x1B[13;2u";
+		if (e.key === "Tab" && e.shiftKey) return "\x1B[Z";
+		if (!e.metaKey && (e.shiftKey || e.altKey || e.ctrlKey)) {
+			const modifier = 1 + Number(e.shiftKey) + 2 * Number(e.altKey) + 4 * Number(e.ctrlKey);
+			const final = MODIFIED_CSI_KEYS[e.key];
+			if (final) return `\x1b[1;${modifier}${final}`;
+			const tilde = MODIFIED_TILDE_KEYS[e.key];
+			if (tilde) return `\x1b[${tilde};${modifier}~`;
+		}
+		const fixed = FIXED_KEYS[e.key];
+		if (fixed) return e.altKey ? "\x1B" + fixed : fixed;
+		const bridge = this.getBridge();
+		const nav = (bridge && bridge.cursorKeysApp() ? APP_KEYS : NORMAL_KEYS)[e.key];
+		if (nav) return e.altKey ? "\x1B" + nav : nav;
+		if (e.key.length === 1 && !e.ctrlKey && !e.metaKey) return e.altKey ? "\x1B" + e.key : e.key;
+		return null;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/text-capture.js
+var MAX_TEXT_LENGTH = 16777216;
+/** Copy cell text in small batches without mounting retained history. */
+function* scanText(core, limit = MAX_TEXT_LENGTH) {
+	const history = core.getScrollbackCount();
+	const parts = [];
+	let chunk = "";
+	let length = 0;
+	let work = 0;
+	let previousWrap = false;
+	const append = (text) => {
+		length += text.length;
+		if (length > limit) throw new RangeError("Terminal text exceeds 16,777,216 UTF-16 code units");
+		chunk += text;
+		if (chunk.length >= 8192) {
+			parts.push(chunk);
+			chunk = "";
+		}
+	};
+	for (let row = 0; row < history + core.getRows(); row++) {
+		const offset = history - row - 1;
+		const metadata = row < history ? core.getScrollbackRowMetadata?.(offset) : core.getRowMetadata?.(row - history);
+		if (row > 0 && !(previousWrap && metadata?.continuesPrevious)) append("\n");
+		previousWrap = metadata?.wrapsToNext ?? false;
+		const cols = row < history ? core.getScrollbackLineLen(offset) : core.getCols();
+		let spaces = 0;
+		for (let col = 0; col < cols; col++) {
+			if (++work >= 256) {
+				work = 0;
+				yield;
+			}
+			const cell = row < history ? core.getScrollbackCell(offset, col) : core.getCell(row - history, col);
+			if (cell.width === 0 || cell.spacerHead) continue;
+			const text = cell.chars ?? String.fromCodePoint(cell.char || 32);
+			if (/^ +$/.test(text)) spaces += text.length;
+			else {
+				if (length + spaces + text.length > limit) throw new RangeError("Terminal text exceeds 16,777,216 UTF-16 code units");
+				append(" ".repeat(spaces) + text);
+				spaces = 0;
+			}
+		}
+		if (previousWrap) {
+			if (length + spaces > limit) throw new RangeError("Terminal text exceeds 16,777,216 UTF-16 code units");
+			append(" ".repeat(spaces));
+		}
+		if (++work >= 256) {
+			work = 0;
+			yield;
+		}
+	}
+	parts.push(chunk);
+	return parts.join("");
+}
+function aborted(message) {
+	return new DOMException(message, "AbortError");
+}
+/** One cancellable capture, resumed only after WTerm paints its current state. */
+var TextCapture = class {
+	constructor() {
+		this.request = null;
+		this.timer = null;
+	}
+	read(signal) {
+		this.cancel(aborted("Replaced by another text capture"));
+		if (signal?.aborted) return Promise.reject(signal.reason);
+		return new Promise((resolve, reject) => {
+			const abort = () => this.cancel(signal?.reason);
+			this.request = {
+				resolve,
+				reject,
+				signal,
+				abort,
+				scan: null
+			};
+			signal?.addEventListener("abort", abort, { once: true });
+		});
+	}
+	resume(core) {
+		const request = this.request;
+		if (!request || request.scan) return;
+		const scan = request.scan = scanText(core);
+		const tick = () => {
+			if (this.request !== request) return;
+			this.timer = null;
+			const deadline = performance.now() + 4;
+			try {
+				for (let batch = 0; batch < 32; batch++) {
+					const next = scan.next();
+					if (next.done) {
+						this.release();
+						request.resolve(next.value);
+						return;
+					}
+					if (performance.now() >= deadline) break;
+				}
+				this.timer = setTimeout(tick, 0);
+			} catch (error) {
+				this.cancel(error);
+			}
+		};
+		this.timer = setTimeout(tick, 0);
+	}
+	cancel(error) {
+		const request = this.request;
+		if (!request) return;
+		this.release();
+		request.reject(error === void 0 ? aborted("Terminal changed during text capture") : error);
+	}
+	release() {
+		if (this.timer !== null) clearTimeout(this.timer);
+		this.timer = null;
+		this.request?.signal?.removeEventListener("abort", this.request.abort);
+		this.request?.scan?.return("");
+		this.request = null;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/history-selection.js
+var owners = /* @__PURE__ */ new WeakMap();
+/** A complete, immutable selection; no partial text is exposed while scanning. */
+var HistorySelection = class {
+	constructor(element) {
+		this.element = element;
+		this.text = null;
+		this.scan = null;
+		this.timer = null;
+		this.resolve = null;
+		this.rectangle = null;
+		this.decorated = /* @__PURE__ */ new Set();
+		this.onPointerDown = (event) => {
+			if (event.button === 2 && this.element.contains(event.target)) return;
+			this.clear();
+		};
+		this.onFocus = (event) => {
+			if (!this.element.contains(event.target)) this.clear();
+		};
+		this.onSelectionChange = () => {
+			if (!this.active) return;
+			const doc = this.element.ownerDocument;
+			const active = doc.activeElement;
+			if (active && (active.tagName === "INPUT" || active.tagName === "TEXTAREA")) {
+				const input = active;
+				if (input.selectionStart !== input.selectionEnd) {
+					this.clear();
+					return;
+				}
+			}
+			const selection = doc.getSelection();
+			if (selection && !selection.isCollapsed) this.clear();
+		};
+		this.status = element.ownerDocument.createElement("div");
+		this.status.className = "term-selection-status";
+		this.status.setAttribute("role", "status");
+		element.appendChild(this.status);
+		const doc = element.ownerDocument;
+		doc.addEventListener("pointerdown", this.onPointerDown, true);
+		doc.addEventListener("focusin", this.onFocus);
+		doc.addEventListener("selectionchange", this.onSelectionChange);
+	}
+	get pending() {
+		return this.resolve !== null;
+	}
+	get active() {
+		return this.pending || this.text !== null;
+	}
+	getText() {
+		this.onSelectionChange();
+		return this.text;
+	}
+	select() {
+		this.claim();
+		this.status.textContent = "Selecting terminal text…";
+		return new Promise((resolve) => {
+			this.resolve = resolve;
+		});
+	}
+	selectRectangle(rectangle) {
+		this.claim();
+		this.rectangle = rectangle;
+		this.text = rectangle.text;
+	}
+	paintRectangle(rows, charWidth) {
+		this.clearDecorations();
+		if (!this.rectangle || charWidth <= 0) return;
+		const first = this.rectangle.rows[0].row;
+		for (const { row, element } of rows) {
+			const range = this.rectangle.rows[row - first];
+			if (!range) continue;
+			element.classList.add("term-rectangle-row");
+			element.style.setProperty("--term-selection-left", `${range.left * charWidth}px`);
+			element.style.setProperty("--term-selection-width", `${(range.right - range.left) * charWidth}px`);
+			this.decorated.add(element);
+		}
+	}
+	clearDecorations() {
+		for (const element of this.decorated) {
+			element.classList.remove("term-rectangle-row");
+			element.style.removeProperty("--term-selection-left");
+			element.style.removeProperty("--term-selection-width");
+		}
+		this.decorated.clear();
+	}
+	claim() {
+		const doc = this.element.ownerDocument;
+		owners.get(doc)?.clear();
+		this.clear();
+		owners.set(doc, this);
+		const native = doc.getSelection();
+		if (native && !native.isCollapsed) native.removeAllRanges();
+	}
+	/** WTerm calls this only once its current frame has painted. */
+	resume(core) {
+		if (!this.pending || this.scan) return;
+		const scan = this.scan = scanText(core);
+		const tick = () => {
+			this.timer = null;
+			const deadline = performance.now() + 4;
+			try {
+				for (let batch = 0; batch < 32; batch++) {
+					const next = scan.next();
+					if (next.done) {
+						this.scan = null;
+						this.text = next.value;
+						this.element.classList.add("term-select-all");
+						this.status.textContent = "";
+						const resolve = this.resolve;
+						this.resolve = null;
+						resolve?.(true);
+						return;
+					}
+					if (performance.now() >= deadline) break;
+				}
+				this.timer = setTimeout(tick, 0);
+			} catch {
+				this.clear();
+				this.status.textContent = "Unable to select all text. Select a smaller range to copy.";
+			}
+		};
+		this.timer = setTimeout(tick, 0);
+	}
+	clear(message = "") {
+		if (!this.active && !this.status.textContent && !message) return;
+		if (this.timer !== null) clearTimeout(this.timer);
+		this.timer = null;
+		this.scan?.return("");
+		this.scan = null;
+		this.text = null;
+		this.rectangle = null;
+		this.clearDecorations();
+		this.element.classList.remove("term-select-all");
+		this.status.textContent = message;
+		if (owners.get(this.element.ownerDocument) === this) owners.delete(this.element.ownerDocument);
+		const resolve = this.resolve;
+		this.resolve = null;
+		resolve?.(false);
+	}
+	invalidate() {
+		if (!this.active) return;
+		this.clear(this.pending ? "Terminal changed. Select all again to copy." : "");
+	}
+	destroy() {
+		this.clear();
+		const doc = this.element.ownerDocument;
+		doc.removeEventListener("pointerdown", this.onPointerDown, true);
+		doc.removeEventListener("focusin", this.onFocus);
+		doc.removeEventListener("selectionchange", this.onSelectionChange);
+		this.status.remove();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/rectangle-drag.js
+/** Own only an Alt+left drag accepted by the terminal's painted-grid checks. */
+var RectangleDrag = class {
+	constructor(element, callbacks) {
+		this.element = element;
+		this.callbacks = callbacks;
+		this.anchor = null;
+		this.suppressClick = false;
+		this.owned = false;
+		this.lastEvent = null;
+		this.frame = null;
+		this.down = (event) => {
+			this.cancel();
+			this.owned = false;
+			this.suppressClick = false;
+			if (event.defaultPrevented || event.button !== 0 || !event.altKey || event.ctrlKey || event.metaKey) return;
+			const anchor = this.callbacks.start(event);
+			if (!anchor || !this.callbacks.select(anchor, anchor)) return;
+			this.anchor = anchor;
+			this.owned = true;
+			event.preventDefault();
+			event.stopImmediatePropagation();
+		};
+		this.move = (event) => {
+			if (!this.owned) return;
+			if (!(event.buttons & 1)) {
+				this.blur();
+				return;
+			}
+			event.preventDefault();
+			event.stopImmediatePropagation();
+			this.update(event);
+			this.lastEvent = event;
+			this.scheduleScroll();
+		};
+		this.up = (event) => {
+			if (!this.owned || event.button !== 0) return;
+			event.preventDefault();
+			event.stopImmediatePropagation();
+			this.update(event);
+			this.cancel();
+			this.owned = false;
+			this.suppressClick = true;
+		};
+		this.click = (event) => {
+			if (!this.suppressClick || event.detail === 0) return;
+			this.suppressClick = false;
+			event.preventDefault();
+			event.stopImmediatePropagation();
+		};
+		this.key = (event) => {
+			if (!this.anchor || event.key !== "Escape") return;
+			event.preventDefault();
+			event.stopImmediatePropagation();
+			this.cancel();
+			this.callbacks.clear();
+		};
+		this.cancel = () => {
+			this.anchor = null;
+			this.lastEvent = null;
+			if (this.frame !== null) cancelAnimationFrame(this.frame);
+			this.frame = null;
+		};
+		this.blur = () => {
+			this.cancel();
+			this.owned = false;
+		};
+		this.focus = (event) => {
+			if (!this.element.contains(event.target)) this.cancel();
+		};
+		element.addEventListener("mousedown", this.down, true);
+		element.addEventListener("click", this.click, true);
+		const doc = element.ownerDocument;
+		doc.addEventListener("mousemove", this.move, true);
+		doc.addEventListener("mouseup", this.up, true);
+		doc.addEventListener("keydown", this.key, true);
+		doc.addEventListener("focusin", this.focus);
+		doc.defaultView?.addEventListener("blur", this.blur);
+	}
+	update(event) {
+		const point = this.callbacks.position(event);
+		if (this.anchor && (!point || !this.callbacks.select(this.anchor, point))) this.callbacks.clear();
+	}
+	scheduleScroll() {
+		if (this.frame !== null || !this.anchor || !this.lastEvent) return;
+		this.frame = requestAnimationFrame(() => {
+			this.frame = null;
+			if (!this.anchor || !this.lastEvent) return;
+			const rect = this.element.getBoundingClientRect();
+			const y = this.lastEvent.clientY;
+			const delta = y < rect.top ? Math.max(-24, y - rect.top) : y > rect.bottom ? Math.min(24, y - rect.bottom) : 0;
+			const before = this.element.scrollTop;
+			this.element.scrollTop += delta;
+			this.update(this.lastEvent);
+			if (this.element.scrollTop !== before) this.scheduleScroll();
+		});
+	}
+	destroy() {
+		this.cancel();
+		this.element.removeEventListener("mousedown", this.down, true);
+		this.element.removeEventListener("click", this.click, true);
+		const doc = this.element.ownerDocument;
+		doc.removeEventListener("mousemove", this.move, true);
+		doc.removeEventListener("mouseup", this.up, true);
+		doc.removeEventListener("keydown", this.key, true);
+		doc.removeEventListener("focusin", this.focus);
+		doc.defaultView?.removeEventListener("blur", this.blur);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/output-announcements.js
+var INTERVAL_MS = 500;
+var MAX_CELLS = 32768;
+var MAX_TEXT = 65536;
+var MAX_LINES = 20;
+var MAX_CHARACTERS = 4e3;
+var LIMIT_MESSAGE = "Output announcements paused because there is too much output. Type in the terminal or turn announcements off and on to resume.";
+/** Bounded, opt-in summaries of changes to painted terminal text. */
+var OutputAnnouncements = class {
+	constructor(host, getCore, ready) {
+		this.host = host;
+		this.getCore = getCore;
+		this.ready = ready;
+		this.live = null;
+		this.timer = null;
+		this.previous = null;
+		this.lines = 0;
+		this.characters = 0;
+		this.paused = false;
+		/** Discard pending speech and baseline existing text after a user action. */
+		this.reset = () => {
+			this.invalidate();
+			this.lines = 0;
+			this.characters = 0;
+			this.paused = false;
+			const core = this.getCore();
+			if (core && this.active()) {
+				this.previous = this.snapshot(core);
+				if (!this.previous) this.limit();
+			}
+		};
+		host.addEventListener("focusin", this.reset);
+		host.addEventListener("focusout", this.reset);
+		host.ownerDocument.addEventListener("visibilitychange", this.reset);
+		host.ownerDocument.defaultView?.addEventListener("blur", this.reset);
+		host.ownerDocument.defaultView?.addEventListener("focus", this.reset);
+	}
+	setEnabled(enabled) {
+		if (enabled === !!this.live) return;
+		if (enabled) {
+			this.live = this.host.ownerDocument.createElement("div");
+			this.live.className = "term-announcements";
+			this.live.setAttribute("role", "log");
+			this.live.setAttribute("aria-label", "Terminal output");
+			this.live.setAttribute("aria-live", "polite");
+			this.live.setAttribute("aria-relevant", "additions");
+			this.live.setAttribute("aria-atomic", "false");
+			this.host.append(this.live);
+		} else {
+			this.live?.remove();
+			this.live = null;
+		}
+		this.reset();
+	}
+	active() {
+		return !!this.live && this.host.classList.contains("focused") && this.host.isConnected && this.host.ownerDocument.visibilityState !== "hidden" && this.host.ownerDocument.hasFocus();
+	}
+	input() {
+		if (this.paused) this.reset();
+		else {
+			this.lines = 0;
+			this.characters = 0;
+		}
+	}
+	/** A resize changes coordinates, not terminal output. */
+	invalidate() {
+		if (this.timer !== null) clearTimeout(this.timer);
+		this.timer = null;
+		this.previous = null;
+		this.live?.replaceChildren();
+	}
+	/** Called after painting. No cell reads or timers while disabled/unfocused. */
+	rendered() {
+		if (!this.active()) {
+			this.invalidate();
+			return;
+		}
+		if (this.paused || this.timer !== null) return;
+		const core = this.getCore();
+		if (!core) return;
+		if (!this.previous) {
+			this.previous = this.snapshot(core);
+			if (!this.previous) this.limit();
+			return;
+		}
+		this.timer = setTimeout(() => {
+			this.timer = null;
+			if (!this.active()) {
+				this.invalidate();
+				return;
+			}
+			if (!this.ready()) return;
+			const current = this.getCore();
+			if (current) this.announce(current);
+		}, INTERVAL_MS);
+	}
+	snapshot(core, start) {
+		const cols = core.getCols();
+		const rows = core.getRows();
+		const history = core.getScrollbackCount();
+		const discarded = core.getScrollbackDiscardedCount?.() ?? 0;
+		const base = history + discarded;
+		const first = start ?? base;
+		if (first < discarded || (base + rows - first) * cols > MAX_CELLS) return null;
+		const lines = [];
+		let length = 0;
+		for (let row = first; row < base + rows; row++) {
+			const offset = base - row - 1;
+			const width = row < base ? core.getScrollbackLineLen(offset) : cols;
+			if (width > cols) return null;
+			let text = "";
+			for (let col = 0; col < width; col++) {
+				const cell = row < base ? core.getScrollbackCell(offset, col) : core.getCell(row - base, col);
+				if (cell.width === 0 || cell.spacerHead) continue;
+				const chars = cell.chars ?? String.fromCodePoint(cell.char || 32);
+				length += chars.length;
+				if (length > MAX_TEXT) return null;
+				text += chars;
+			}
+			lines.push(text.replace(/ +$/, ""));
+		}
+		return {
+			base: first,
+			cols,
+			rows,
+			alternate: core.usingAltScreen(),
+			lines
+		};
+	}
+	announce(core) {
+		const previous = this.previous;
+		if (!previous) return;
+		const base = core.getScrollbackCount() + (core.getScrollbackDiscardedCount?.() ?? 0);
+		if (previous.cols !== core.getCols() || previous.rows !== core.getRows() || previous.alternate !== core.usingAltScreen() || base < previous.base) {
+			this.previous = this.snapshot(core);
+			return;
+		}
+		const current = this.snapshot(core, previous.base);
+		if (!current) {
+			this.limit();
+			return;
+		}
+		const changed = current.lines.filter((line, index) => line.trim() && line !== previous.lines[index]);
+		this.previous = {
+			...current,
+			base,
+			lines: current.lines.slice(base - current.base)
+		};
+		if (!changed.length) return;
+		const text = changed.join("\n");
+		if (this.lines + changed.length > MAX_LINES || this.characters + text.length > MAX_CHARACTERS) {
+			this.limit();
+			return;
+		}
+		this.lines += changed.length;
+		this.characters += text.length;
+		this.publish(text);
+	}
+	publish(text) {
+		if (!this.live) return;
+		const entry = this.host.ownerDocument.createElement("div");
+		entry.textContent = text;
+		this.live.replaceChildren(entry);
+	}
+	limit() {
+		this.paused = true;
+		this.previous = null;
+		this.publish(LIMIT_MESSAGE);
+	}
+	destroy() {
+		this.setEnabled(false);
+		this.host.removeEventListener("focusin", this.reset);
+		this.host.removeEventListener("focusout", this.reset);
+		this.host.ownerDocument.removeEventListener("visibilitychange", this.reset);
+		this.host.ownerDocument.defaultView?.removeEventListener("blur", this.reset);
+		this.host.ownerDocument.defaultView?.removeEventListener("focus", this.reset);
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/debug.js
+var FLAG_NAMES = {
+	1: "bold",
+	2: "dim",
+	4: "italic",
+	8: "underline",
+	16: "blink",
+	32: "reverse",
+	64: "invisible",
+	128: "strikethrough"
+};
+function flagsToNames(flags) {
+	const names = [];
+	for (const [bit, name] of Object.entries(FLAG_NAMES)) if (flags & Number(bit)) names.push(name);
+	return names;
+}
+var ESC = 27;
+function scanSequences(data) {
+	const entries = [];
+	const ts = Date.now();
+	let i = 0;
+	let textStart = 0;
+	const flushText = () => {
+		if (i > textStart) {
+			const raw = data.slice(textStart, i);
+			if (raw.length > 0 && !/^[\x00-\x1f]+$/.test(raw)) entries.push({
+				ts,
+				type: "text",
+				raw: raw.slice(0, 60)
+			});
+		}
+	};
+	while (i < data.length) {
+		if (data.charCodeAt(i) !== ESC) {
+			i++;
+			continue;
+		}
+		flushText();
+		const seqStart = i;
+		i++;
+		if (i >= data.length) break;
+		const next = data[i];
+		if (next === "[") {
+			i++;
+			let priv = "";
+			if (i < data.length && (data[i] === "?" || data[i] === ">" || data[i] === "!")) {
+				priv = data[i];
+				i++;
+			}
+			let paramStr = "";
+			while (i < data.length && (data.charCodeAt(i) >= 48 && data.charCodeAt(i) <= 59 || data[i] === ":")) {
+				paramStr += data[i];
+				i++;
+			}
+			while (i < data.length && data.charCodeAt(i) >= 32 && data.charCodeAt(i) <= 47) i++;
+			let final = "";
+			if (i < data.length && data.charCodeAt(i) >= 64 && data.charCodeAt(i) <= 126) {
+				final = data[i];
+				i++;
+			}
+			const raw = data.slice(seqStart, i);
+			const params = paramStr ? paramStr.split(/[;:]/).map(Number).filter((n) => !isNaN(n)) : [];
+			const type = final === "m" ? "sgr" : "csi";
+			entries.push({
+				ts,
+				type,
+				raw,
+				params: params.length > 0 ? params : void 0,
+				private: priv || void 0,
+				final
+			});
+		} else if (next === "]") {
+			i++;
+			while (i < data.length && data.charCodeAt(i) !== 7 && !(data.charCodeAt(i) === ESC && i + 1 < data.length && data[i + 1] === "\\")) i++;
+			if (i < data.length) {
+				if (data.charCodeAt(i) === 7) i++;
+				else if (data.charCodeAt(i) === ESC) i += 2;
+			}
+			const raw = data.slice(seqStart, i);
+			entries.push({
+				ts,
+				type: "osc",
+				raw: raw.slice(0, 80)
+			});
+		} else if (next >= " " && next <= "~") {
+			i++;
+			entries.push({
+				ts,
+				type: "esc",
+				raw: data.slice(seqStart, i),
+				final: next
+			});
+		} else i++;
+		textStart = i;
+	}
+	flushText();
+	return entries;
+}
+var MAX_TRACES = 500;
+var DebugAdapter = class {
+	constructor() {
+		this._traces = [];
+		this._bridge = null;
+		this._perf = {
+			frameCount: 0,
+			totalRenderMs: 0,
+			avgRenderMs: 0,
+			maxRenderMs: 0,
+			lastDirtyRows: 0
+		};
+	}
+	get traces() {
+		return this._traces;
+	}
+	get perf() {
+		return this._perf;
+	}
+	setBridge(bridge) {
+		this._bridge = bridge;
+	}
+	traceWrite(data) {
+		const entries = scanSequences(typeof data === "string" ? data : new TextDecoder().decode(data));
+		for (const entry of entries) this._traces.push(entry);
+		if (this._traces.length > MAX_TRACES) this._traces = this._traces.slice(-500);
+	}
+	recordRender(renderMs, dirtyRows) {
+		this._perf.frameCount++;
+		this._perf.totalRenderMs += renderMs;
+		this._perf.avgRenderMs = this._perf.totalRenderMs / this._perf.frameCount;
+		if (renderMs > this._perf.maxRenderMs) this._perf.maxRenderMs = renderMs;
+		this._perf.lastDirtyRows = dirtyRows;
+	}
+	resetPerf() {
+		this._perf = {
+			frameCount: 0,
+			totalRenderMs: 0,
+			avgRenderMs: 0,
+			maxRenderMs: 0,
+			lastDirtyRows: 0
+		};
+	}
+	cell(row, col) {
+		if (!this._bridge) return null;
+		const c = this._bridge.getCell(row, col);
+		return {
+			...c,
+			charStr: c.chars ?? (c.char >= 32 ? String.fromCodePoint(c.char) : ""),
+			flagNames: flagsToNames(c.flags)
+		};
+	}
+	row(row) {
+		if (!this._bridge) return null;
+		const cols = this._bridge.getCols();
+		const cells = [];
+		for (let c = 0; c < cols; c++) cells.push(this.cell(row, c));
+		return cells;
+	}
+	grid() {
+		if (!this._bridge) return null;
+		const cursor = this._bridge.getCursor();
+		return {
+			rows: this._bridge.getRows(),
+			cols: this._bridge.getCols(),
+			cursor,
+			altScreen: this._bridge.usingAltScreen(),
+			scrollbackCount: this._bridge.getScrollbackCount()
+		};
+	}
+	unhandled() {
+		if (!this._bridge) return [];
+		return this._bridge.getUnhandledSequences();
+	}
+	dump(count = 50) {
+		const entries = this._traces.slice(-count);
+		console.group(`%cwterm debug — last ${entries.length} traces`, "color: #569cd6; font-weight: bold");
+		for (const e of entries) {
+			const badge = e.type === "sgr" ? "%cSGR" : e.type === "csi" ? "%cCSI" : e.type === "osc" ? "%cOSC" : e.type === "esc" ? "%cESC" : "%cTXT";
+			const color = e.type === "sgr" ? "background:#2d5a27;color:#fff;padding:1px 4px;border-radius:2px" : e.type === "csi" ? "background:#1e4a7a;color:#fff;padding:1px 4px;border-radius:2px" : "background:#555;color:#fff;padding:1px 4px;border-radius:2px";
+			const detail = [
+				e.private ? `private=${e.private}` : "",
+				e.params ? `params=[${e.params}]` : "",
+				e.final ? `final=${e.final}` : ""
+			].filter(Boolean).join(" ");
+			console.log(`${badge} ${e.raw.slice(0, 40)}`, color, detail ? `  ${detail}` : "");
+		}
+		console.groupEnd();
+	}
+	dumpUnhandled() {
+		const entries = this.unhandled();
+		if (entries.length === 0) {
+			console.log("%cwterm debug — no unhandled sequences", "color: #6a9955");
+			return;
+		}
+		console.group(`%cwterm debug — ${entries.length} unhandled sequences`, "color: #d7ba7d; font-weight: bold");
+		for (const e of entries) console.log(`  final=${e.final} private=${e.private || "-"} params=[${e.params.slice(0, e.paramCount)}]`);
+		console.groupEnd();
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/search.js
+function fold(text, caseSensitive) {
+	if (caseSensitive) return text;
+	if (text.length <= 1) return text.toLowerCase();
+	let folded = "";
+	for (const char of text) folded += char.toLowerCase();
+	return folded;
+}
+/** Streams cells without materializing history or an arbitrarily long line. */
+function* scanSearch(core, query, caseSensitive) {
+	const needle = fold(query, caseSensitive);
+	if (!needle) return;
+	const prefix = new Uint32Array(needle.length);
+	for (let i = 1, length = 0; i < needle.length; i++) {
+		while (length > 0 && needle[i] !== needle[length]) length = prefix[length - 1];
+		if (needle[i] === needle[length]) length++;
+		prefix[i] = length;
+	}
+	const positions = new Array(needle.length);
+	const history = core.getScrollbackCount();
+	let matched = 0;
+	let index = 0;
+	let work = 0;
+	let previousWrap = false;
+	let previousMatch;
+	for (let row = 0; row < history + core.getRows(); row++) {
+		const offset = history - 1 - row;
+		const metadata = row < history ? core.getScrollbackRowMetadata?.(offset) : core.getRowMetadata?.(row - history);
+		if (!previousWrap || !metadata?.continuesPrevious) matched = 0;
+		previousWrap = metadata?.wrapsToNext ?? false;
+		const cols = row < history ? core.getScrollbackLineLen(offset) : core.getCols();
+		for (let col = 0; col < cols; col++) {
+			if (++work >= 256) {
+				work = 0;
+				yield null;
+			}
+			const cell = row < history ? core.getScrollbackCell(offset, col) : core.getCell(row - history, col);
+			if (cell.width === 0 || cell.spacerHead) continue;
+			const text = fold(cell.chars ?? String.fromCodePoint(cell.char || 32), caseSensitive);
+			if (matched === 0 && text.length === 1 && text !== needle[0]) continue;
+			const position = {
+				row,
+				col,
+				endCol: Math.min(cols, col + (cell.width ?? 1))
+			};
+			for (let unit = 0; unit < text.length; unit++) {
+				if (++work >= 256) {
+					work = 0;
+					yield null;
+				}
+				positions[index++ % needle.length] = position;
+				while (matched > 0 && text[unit] !== needle[matched]) matched = prefix[matched - 1];
+				if (text[unit] === needle[matched]) matched++;
+				if (matched === needle.length) {
+					const match = {
+						start: positions[(index - needle.length) % needle.length],
+						end: position
+					};
+					if (!previousMatch || previousMatch.start.row !== match.start.row || previousMatch.start.col !== match.start.col || previousMatch.end.row !== match.end.row || previousMatch.end.endCol !== match.end.endCol) {
+						yield match;
+						previousMatch = match;
+					}
+					matched = prefix[matched - 1];
+				}
+			}
+		}
+		if (++work >= 256) {
+			work = 0;
+			yield null;
+		}
+	}
+}
+/** Owns cancellation and small scan slices; WTerm resumes only after painting. */
+var SearchController = class {
+	constructor(changed) {
+		this.changed = changed;
+		this.matches = [];
+		this.state = {
+			query: "",
+			caseSensitive: false,
+			count: 0,
+			activeIndex: -1,
+			searching: false,
+			limited: false
+		};
+		this.timer = null;
+		this.channel = null;
+		this.scan = null;
+		this.pending = false;
+		this.revealFirst = false;
+	}
+	snapshot() {
+		return { ...this.state };
+	}
+	search(query, options) {
+		if (query.length > 1024) throw new RangeError("Search query exceeds 1,024 UTF-16 code units");
+		this.state.query = query;
+		this.state.caseSensitive = options.caseSensitive ?? false;
+		this.revealFirst = true;
+		this.invalidate();
+	}
+	invalidate() {
+		this.cancel();
+		this.matches = [];
+		this.state.count = 0;
+		this.state.activeIndex = -1;
+		this.state.limited = false;
+		this.pending = this.state.searching = this.state.query.length > 0;
+		this.changed(false);
+	}
+	resume(core) {
+		if (!this.pending) return;
+		this.pending = false;
+		const scan = this.scan = scanSearch(core, this.state.query, this.state.caseSensitive);
+		const tick = () => {
+			if (this.scan !== scan) return;
+			this.timer = null;
+			const deadline = performance.now() + 4;
+			let done = false;
+			do {
+				const next = scan.next();
+				if (next.done) {
+					done = true;
+					break;
+				}
+				if (next.value) {
+					if (this.matches.length === 1e4) {
+						this.state.limited = true;
+						done = true;
+						break;
+					}
+					this.matches.push(next.value);
+				}
+			} while (performance.now() < deadline);
+			this.state.count = this.matches.length;
+			const reveal = this.revealFirst && this.matches.length > 0;
+			if (this.matches.length && this.state.activeIndex === -1) this.state.activeIndex = 0;
+			if (reveal) this.revealFirst = false;
+			this.state.searching = !done;
+			if (done) {
+				scan.return(void 0);
+				this.scan = null;
+				this.clearTask();
+			}
+			this.changed(reveal);
+			if (this.scan === scan) this.schedule(tick);
+		};
+		this.schedule(tick);
+	}
+	schedule(tick) {
+		if (typeof MessageChannel === "undefined") this.timer = setTimeout(tick, 0);
+		else {
+			const channel = this.channel ?? (this.channel = new MessageChannel());
+			channel.port1.onmessage = tick;
+			channel.port2.postMessage(null);
+		}
+	}
+	clearTask() {
+		if (this.timer !== null) clearTimeout(this.timer);
+		this.timer = null;
+		if (this.channel) {
+			this.channel.port1.onmessage = null;
+			this.channel.port1.close();
+			this.channel.port2.close();
+			this.channel = null;
+		}
+	}
+	navigate(direction) {
+		if (!this.matches.length) return false;
+		this.state.activeIndex = (this.state.activeIndex + direction + this.matches.length) % this.matches.length;
+		this.revealFirst = false;
+		this.changed(true);
+		return true;
+	}
+	cancel() {
+		this.clearTask();
+		this.scan?.return(void 0);
+		this.scan = null;
+		this.pending = false;
+		this.matches = [];
+		this.state.count = 0;
+		this.state.activeIndex = -1;
+		this.state.searching = false;
+		this.state.limited = false;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@wterm+dom@0.5.4/node_modules/@wterm/dom/dist/wterm.js
+var SYNCHRONIZED_OUTPUT_TIMEOUT_MS = 1e3;
+var PROGRAMMATIC_SCROLL_TOLERANCE = 1;
+var WTerm = class {
+	constructor(element, options = {}) {
+		this.bridge = null;
+		this.debug = null;
+		this._themeColors = null;
+		this.renderer = null;
+		this.input = null;
+		this.rafId = null;
+		this._synchronizedOutputTimer = null;
+		this._synchronizedOutputState = "idle";
+		this._synchronizedOutputGeneration = 0;
+		this._rendererNeedsSetup = false;
+		this.resizeObserver = null;
+		this._destroyed = false;
+		this._shouldScrollToBottom = false;
+		this._scrollbackDiscardedCount = 0;
+		this._programmaticScrollTop = null;
+		this._pendingResizeScrollTop = null;
+		this._rowHeight = 0;
+		this._charWidth = 0;
+		this._windowSizeQueryState = 0;
+		this._textCapture = new TextCapture();
+		this._searchReveal = false;
+		this.element = element;
+		this._coreOption = options.core;
+		this._initialColsExplicit = options.cols !== void 0;
+		this._initialRowsExplicit = options.rows !== void 0;
+		this.wasmUrl = options.wasmUrl;
+		this.maxImageWidth = options.maxImageWidth;
+		this.maxImageHeight = options.maxImageHeight;
+		this.cols = options.cols || 80;
+		this.rows = options.rows || 24;
+		this.autoResize = options.autoResize !== false;
+		this._debugEnabled = options.debug ?? false;
+		this._renderingPaused = options.renderingPaused ?? false;
+		this.onData = options.onData || null;
+		this.onBinary = options.onBinary || null;
+		this.onTitle = options.onTitle || null;
+		this.onWorkingDirectory = options.onWorkingDirectory || null;
+		this.onBell = options.onBell || null;
+		this.onShellIntegration = options.onShellIntegration || null;
+		this.onClipboardWrite = options.onClipboardWrite || null;
+		this.onResize = options.onResize || null;
+		this.onSearchChange = options.onSearchChange || null;
+		this._search = new SearchController((reveal) => {
+			this._searchReveal || (this._searchReveal = reveal);
+			if (reveal) {
+				const match = this._search.matches[this.getSearchState().activeIndex];
+				if (match) {
+					this._shouldScrollToBottom = false;
+					this._pendingResizeScrollTop = null;
+					this._setScrollTop((match.start.row + .5) * this._rowHeight - this.element.clientHeight / 2);
+				}
+			}
+			if (this._synchronizedOutputState !== "held") this._scheduleRender();
+			this.onSearchChange?.(this.getSearchState());
+		});
+		this._container = document.createElement("div");
+		this._container.className = "term-grid";
+		this.element.appendChild(this._container);
+		this.element.classList.add("wterm");
+		this._historySelection = new HistorySelection(this.element);
+		this._rectangleDrag = new RectangleDrag(this.element, {
+			start: (event) => {
+				if (!(event.target instanceof Element) || !this.bridge || !this._canRender()) return null;
+				const point = this.renderer?.positionAt(event.target, event.clientX, this._charWidth);
+				if (!point || !event.shiftKey && this.bridge.mouseTracking?.() && point.row >= this.bridge.getScrollbackCount()) return null;
+				return point;
+			},
+			position: (event) => {
+				const bounds = this.element.getBoundingClientRect();
+				return this.renderer?.dragPositionAt(event.clientX, Math.max(bounds.top + 1, Math.min(bounds.bottom - 1, event.clientY)), this._charWidth) ?? null;
+			},
+			select: (start, end) => this.selectRectangle(start, end),
+			clear: () => this._historySelection.clear()
+		});
+		this._outputAnnouncements = new OutputAnnouncements(this.element, () => this.bridge, () => this._canRender() && this.rafId === null && this._synchronizedOutputState !== "held");
+		this._outputAnnouncements.setEnabled(options.announceOutput ?? false);
+		this._onVisibilityChange = () => {
+			if (this._canRender()) this._scheduleRender();
+			else {
+				this._rectangleDrag.cancel();
+				this._cancelScheduledRender();
+				this._outputAnnouncements.invalidate();
+			}
+		};
+		this.element.ownerDocument.addEventListener("visibilitychange", this._onVisibilityChange);
+		this.element.classList.toggle("cursor-blink", options.cursorBlink === true);
+		this.element.classList.toggle("cursor-steady", options.cursorBlink === false);
+		this._onClickFocus = (event) => {
+			if (event.defaultPrevented || this._historySelection.active) return;
+			const target = event.target;
+			if (target instanceof Element && target.closest(".term-link")) {
+				if (isLinkActivationModifier(event, this.element.ownerDocument.defaultView?.navigator ?? navigator) || event.detail === 0) return;
+				event.preventDefault();
+			}
+			const sel = window.getSelection();
+			if (!sel || sel.isCollapsed) this.input?.focus();
+		};
+		this._onMouseSelect = (event) => {
+			if (event.defaultPrevented || event.button !== 0 || event.detail !== 2 && event.detail !== 3 || event.altKey || event.ctrlKey || event.metaKey || !(event.target instanceof Element)) return;
+			const position = this.renderer?.positionAt(event.target, event.clientX, this._charWidth);
+			if (!position || !this.bridge) return;
+			if (!event.shiftKey && this.bridge.mouseTracking?.() && position.row >= this.bridge.getScrollbackCount()) return;
+			if (event.detail === 2 ? this.selectWord(position) : this.selectLine(position.row)) event.preventDefault();
+		};
+		this.element.addEventListener("click", this._onMouseSelect);
+		this.element.addEventListener("click", this._onClickFocus);
+		this._onModifierChange = (event) => {
+			this.element.classList.toggle("link-modifier-active", isLinkActivationModifier(event, this.element.ownerDocument.defaultView?.navigator ?? navigator));
+		};
+		this._onWindowBlur = () => {
+			this.element.classList.remove("link-modifier-active");
+		};
+		this.element.ownerDocument.addEventListener("keydown", this._onModifierChange);
+		this.element.ownerDocument.addEventListener("keyup", this._onModifierChange);
+		this.element.ownerDocument.defaultView?.addEventListener("blur", this._onWindowBlur);
+		this._onScroll = () => {
+			if (this._pendingResizeScrollTop !== null) return;
+			if (this._shouldScrollToBottom && this._isScrolledToBottom()) {
+				this._programmaticScrollTop = null;
+				return;
+			}
+			if (this._programmaticScrollTop !== null && Math.abs(this.element.scrollTop - this._programmaticScrollTop) <= PROGRAMMATIC_SCROLL_TOLERANCE) {
+				this._programmaticScrollTop = null;
+				return;
+			}
+			this._programmaticScrollTop = null;
+			this._shouldScrollToBottom = false;
+			this._scheduleRender();
+		};
+		this.element.addEventListener("scroll", this._onScroll, { passive: true });
+		this._onCopy = (event) => {
+			if (event.defaultPrevented || !event.clipboardData) return;
+			const target = event.target;
+			if (target instanceof Element && !this.element.contains(target) && (target.closest("input, textarea") || target.isContentEditable)) return;
+			const text = this.getSelectionText();
+			if (this._historySelection.pending) {
+				event.preventDefault();
+				return;
+			}
+			if (text === null) return;
+			event.clipboardData.setData("text/plain", text);
+			event.preventDefault();
+		};
+		this.element.ownerDocument.addEventListener("copy", this._onCopy);
+	}
+	async init() {
+		try {
+			if (this._coreOption) this.bridge = this._coreOption;
+			else this.bridge = await WasmBridge.load(this.wasmUrl);
+			if (this._destroyed) return this;
+			const initialCols = this.cols;
+			const initialRows = this.rows;
+			this._setRowHeight();
+			if (this.autoResize) {
+				const size = this._measureGridSize();
+				if (size) {
+					if (!this._initialColsExplicit) this.cols = size.cols;
+					if (!this._initialRowsExplicit) this.rows = size.rows;
+				}
+			}
+			this.bridge.init(this.cols, this.rows);
+			if (this._themeColors) this.bridge.setThemeColors?.(this._themeColors);
+			this.cols = this.bridge.getCols();
+			this.rows = this.bridge.getRows();
+			if (this._debugEnabled) {
+				this.debug = new DebugAdapter();
+				this.debug.setBridge(this.bridge);
+				globalThis.__wterm = this;
+			}
+			this._measureCharSize();
+			this.renderer = new Renderer(this._container, {
+				colorHost: this.element,
+				maxImageWidth: this.maxImageWidth,
+				maxImageHeight: this.maxImageHeight
+			});
+			this.renderer.setup(this.cols, this.rows);
+			this.input = new InputHandler(this.element, (data, preserveScroll = false) => {
+				if (!preserveScroll) {
+					this._outputAnnouncements.input();
+					this._scrollToBottom();
+				}
+				if (this.onData) this.onData(data);
+				else this.write(data);
+			}, () => this.bridge, () => this._charWidth > 0 && this._rowHeight > 0 ? {
+				charWidth: this._charWidth,
+				rowHeight: this._rowHeight
+			} : null, () => {
+				this._rectangleDrag.cancel();
+				this._historySelection.clear();
+				this._scrollToBottom();
+			}, (data) => {
+				this._outputAnnouncements.input();
+				this._rectangleDrag.cancel();
+				this._historySelection.clear();
+				this._scrollToBottom();
+				if (this.onBinary) this.onBinary(data);
+				else if (!this.onData) this.write(data);
+				else if (data.every((byte) => byte < 128)) this.onData(String.fromCharCode(...data));
+			}, {
+				selectAll: () => {
+					this.selectAll();
+				},
+				hasSelection: () => this._historySelection.active,
+				clearSelection: () => {
+					this._rectangleDrag.cancel();
+					this._historySelection.clear();
+				}
+			});
+			this._setupResizeObserver();
+			if (!this.autoResize) this._lockHeight();
+			this.input.focus();
+			this._initialRender();
+			if (this.cols !== initialCols || this.rows !== initialRows) this.onResize?.(this.cols, this.rows);
+		} catch (err) {
+			this.destroy();
+			throw new Error(`wterm: failed to initialize: ${err instanceof Error ? err.message : err}`);
+		}
+		return this;
+	}
+	_isScrolledToBottom() {
+		const el = this.element;
+		return el.scrollHeight - el.scrollTop - el.clientHeight < 5;
+	}
+	_scrollToBottom() {
+		this._setScrollTop(this.element.scrollHeight);
+	}
+	_setScrollTop(value) {
+		const before = this.element.scrollTop;
+		this.element.scrollTop = value;
+		const after = this.element.scrollTop;
+		if (after === before) return;
+		this._programmaticScrollTop = after;
+	}
+	/** Apply host colors without writing terminal input or restarting the session. */
+	setThemeColors(colors) {
+		const values = [
+			colors.foreground,
+			colors.background,
+			colors.cursor,
+			...colors.palette
+		];
+		if (colors.palette.length !== 16 || values.some((value) => !Number.isInteger(value) || value < 0 || value > 16777215)) throw new RangeError("Theme colors must be 24-bit RGB values with exactly 16 palette entries");
+		if (this._destroyed) return;
+		const copy = {
+			...colors,
+			palette: [...colors.palette]
+		};
+		this.bridge?.setThemeColors?.(copy);
+		this._themeColors = copy;
+		const properties = [
+			"--term-fg",
+			"--term-bg",
+			"--term-cursor",
+			...colors.palette.map((_, index) => `--term-color-${index}`)
+		];
+		values.forEach((value, index) => this.element.style.setProperty(properties[index], `#${value.toString(16).padStart(6, "0")}`));
+		this.renderer?.invalidateColors();
+		this._scheduleRender();
+	}
+	write(data) {
+		if (!this.bridge || this._destroyed) return;
+		this._textCapture.cancel();
+		this._rectangleDrag.cancel();
+		this._historySelection.invalidate();
+		this.renderer?.beforeMutation(this.bridge);
+		if (this.debug) this.debug.traceWrite(data);
+		this._shouldScrollToBottom = this._isScrolledToBottom();
+		const windowSizeQueries = this._collectWindowSizeQueries(data);
+		let deliveryError;
+		let hasDeliveryError = false;
+		const recordDeliveryError = (error) => {
+			if (hasDeliveryError) return;
+			hasDeliveryError = true;
+			deliveryError = error;
+		};
+		const drain = () => {
+			const result = this._drainResponses();
+			if (result.hasError) recordDeliveryError(result.error);
+			const bells = this.bridge?.getBellCount?.() ?? 0;
+			if (bells > 0) try {
+				this.onBell?.(bells);
+			} catch (error) {
+				recordDeliveryError(error);
+			}
+			try {
+				this._deliverTitle();
+			} catch (error) {
+				recordDeliveryError(error);
+			}
+			try {
+				const text = this.bridge?.getClipboardWrite?.() ?? null;
+				if (text !== null && !this._destroyed) this.onClipboardWrite?.(text);
+			} catch (error) {
+				recordDeliveryError(error);
+			}
+			try {
+				const state = this.bridge?.getShellIntegrationState?.() ?? null;
+				if (state !== null && !this._destroyed) this.onShellIntegration?.(state);
+			} catch (error) {
+				recordDeliveryError(error);
+			}
+			try {
+				const uri = this.bridge?.getWorkingDirectory?.() ?? null;
+				if (uri !== null && !this._destroyed) this.onWorkingDirectory?.(uri);
+			} catch (error) {
+				recordDeliveryError(error);
+			}
+		};
+		if (typeof data === "string") this.bridge.writeString(data, drain);
+		else this.bridge.writeRaw(data, drain);
+		const synchronized = this.bridge.synchronizedOutput?.() ?? false;
+		const generation = this.bridge.synchronizedOutputGeneration?.() ?? 0;
+		this._updateSynchronizedOutput(synchronized, generation);
+		this._invalidateSearch();
+		if (this._synchronizedOutputState !== "held") {
+			this._setupRendererIfNeeded();
+			this._scheduleRender();
+		}
+		drain();
+		for (const query of windowSizeQueries) try {
+			this.onData?.(this._windowSizeResponse(query));
+		} catch (error) {
+			recordDeliveryError(error);
+		}
+		if (hasDeliveryError) throw deliveryError;
+	}
+	/** Fit the grid to the current element and font metrics. */
+	fit() {
+		if (!this.bridge || this._destroyed) return;
+		const size = this._measureGridSize();
+		if (size && (size.cols !== this.cols || size.rows !== this.rows)) this.resize(size.cols, size.rows);
+	}
+	_measureGridSize() {
+		const measured = this._measureCharSize();
+		if (!measured) return null;
+		const style = getComputedStyle(this.element);
+		const rect = this.element.getBoundingClientRect();
+		const pixels = (value) => parseFloat(value) || 0;
+		const bordersX = pixels(style.borderLeftWidth) + pixels(style.borderRightWidth);
+		const bordersY = pixels(style.borderTopWidth) + pixels(style.borderBottomWidth);
+		const scrollbarWidth = Math.max(0, this.element.offsetWidth - this.element.clientWidth - bordersX);
+		const scrollbarHeight = Math.max(0, this.element.offsetHeight - this.element.clientHeight - bordersY);
+		const width = rect.width - pixels(style.paddingLeft) - pixels(style.paddingRight) - bordersX - scrollbarWidth;
+		const height = rect.height - pixels(style.paddingTop) - pixels(style.paddingBottom) - bordersY - scrollbarHeight;
+		if (width <= 0 || height <= 0) return null;
+		return {
+			cols: Math.max(1, Math.floor(width / measured.charWidth)),
+			rows: Math.max(1, Math.floor(height / measured.rowHeight))
+		};
+	}
+	resize(cols, rows) {
+		if (!this.bridge || this._destroyed) return;
+		this._textCapture.cancel();
+		this._rectangleDrag.cancel();
+		this._historySelection.invalidate();
+		this.renderer?.beforeMutation(this.bridge);
+		this._shouldScrollToBottom = this._pendingResizeScrollTop === null && this._isScrolledToBottom();
+		this.bridge.resize(cols, rows);
+		this._outputAnnouncements.invalidate();
+		this.cols = this.bridge.getCols();
+		this.rows = this.bridge.getRows();
+		const synchronized = this.bridge.synchronizedOutput?.() ?? false;
+		const generation = this.bridge.synchronizedOutputGeneration?.() ?? 0;
+		if (this._updateSynchronizedOutput(synchronized, generation)) this._rendererNeedsSetup = true;
+		else {
+			this._setupRenderer();
+			this._scheduleRender();
+		}
+		this._invalidateSearch();
+		if (this.onResize) this.onResize(this.cols, this.rows);
+	}
+	/** Search retained history and the active screen, using plain text. */
+	search(query, options = {}) {
+		if (this._destroyed) return;
+		this._search.search(query, options);
+		this._paintSearch();
+	}
+	findNext() {
+		return !this._destroyed && this._search.navigate(1);
+	}
+	findPrevious() {
+		return !this._destroyed && this._search.navigate(-1);
+	}
+	clearSearch() {
+		this.search("");
+	}
+	getSearchState() {
+		return this._search.snapshot();
+	}
+	/** Scroll to the previous (-1) or next (1) shell prompt from the viewport top. */
+	scrollToPrompt(direction) {
+		if (!this._canRender() || !this.bridge?.findPrompt || !this.renderer || this._synchronizedOutputState === "held" || this.bridge.usingAltScreen() || direction !== -1 && direction !== 1) return false;
+		this._cancelScheduledRender();
+		this._doRender();
+		if (direction === 1 && this._isScrolledToBottom()) return false;
+		const bounds = this.element.getBoundingClientRect();
+		const origin = this.renderer.dragPositionAt(bounds.left, bounds.top + this.element.clientTop + 1, this._charWidth);
+		if (!origin) return false;
+		const target = this.bridge.findPrompt(origin.row, direction);
+		if (target === null || !Number.isInteger(target) || target < 0 || target >= this.bridge.getScrollbackCount() + this.rows || (direction < 0 ? target >= origin.row : target <= origin.row)) return false;
+		const before = this.element.scrollTop;
+		this._shouldScrollToBottom = false;
+		this._searchReveal = false;
+		this._pendingResizeScrollTop = target * this._rowHeight;
+		this._doRender();
+		const mounted = Array.from(this.renderer.searchRows()).find(({ row }) => row === target);
+		if (mounted) this._setScrollTop(this.element.scrollTop + mounted.element.getBoundingClientRect().top - bounds.top - this.element.clientTop);
+		this._scheduleRender();
+		return Math.abs(this.element.scrollTop - before) > PROGRAMMATIC_SCROLL_TOLERANCE;
+	}
+	/** Enable or stop polite announcements without changing terminal focus. */
+	setOutputAnnouncements(enabled) {
+		if (!this._destroyed) this._outputAnnouncements.setEnabled(enabled);
+	}
+	/** Pause pane painting without buffering output or stopping terminal effects. */
+	setRenderingPaused(paused) {
+		if (this._destroyed || paused === this._renderingPaused) return;
+		this._renderingPaused = paused;
+		this._onVisibilityChange();
+	}
+	_canRender() {
+		return !this._destroyed && !this._renderingPaused && this.element.ownerDocument.visibilityState !== "hidden";
+	}
+	/** Capture retained history and the active screen without changing selection. */
+	readText(options = {}) {
+		if (this._destroyed || !this.renderer || !this.bridge) return Promise.reject(/* @__PURE__ */ new Error("Terminal is not initialized"));
+		const captured = this._textCapture.read(options.signal);
+		this._scheduleRender();
+		return captured;
+	}
+	/** Read the terminal selection with terminal line and cell semantics. */
+	getSelectionText() {
+		if (this._destroyed) return null;
+		return this._historySelection.getText() ?? this.renderer?.getSelectionText() ?? null;
+	}
+	/** Select retained history and the active screen without mounting extra rows. */
+	selectAll() {
+		if (this._destroyed || !this.renderer || !this.bridge) return Promise.resolve(false);
+		this._rectangleDrag.cancel();
+		const selected = this._historySelection.select();
+		this._scheduleRender();
+		return selected;
+	}
+	/** Select a word at a cell, with row zero at the oldest retained row. */
+	selectWord(position) {
+		return this._selectUnit(position, "word");
+	}
+	/** Select the logical line containing a retained-buffer row. */
+	selectLine(row) {
+		return this._selectUnit({
+			row,
+			col: 0
+		}, "line");
+	}
+	/** Select inclusive rectangle corners in retained physical-row coordinates. */
+	selectRectangle(start, end) {
+		if (this._destroyed || !this.bridge || !this.renderer || !this._canRender()) return false;
+		const rectangle = this.renderer.rectangle(this.bridge, start, end, () => {
+			this.input?.focus();
+		});
+		if (!rectangle) return false;
+		this._historySelection.selectRectangle(rectangle);
+		this._historySelection.paintRectangle(this.renderer.searchRows(), this._charWidth);
+		return true;
+	}
+	_selectUnit(position, unit) {
+		if (this._destroyed || !this.bridge || !this.renderer) return false;
+		return this.renderer.select(this.bridge, position, unit, () => {
+			this._rectangleDrag.cancel();
+			this._historySelection.clear();
+			const active = this.element.ownerDocument.activeElement;
+			if (active instanceof HTMLElement && this.element.contains(active) && active.tagName === "TEXTAREA") active.blur();
+		});
+	}
+	/** Clear custom selection and any native selection wholly owned by this terminal. */
+	clearSelection() {
+		this._rectangleDrag.cancel();
+		this._historySelection.clear();
+		const selection = this.element.ownerDocument.getSelection();
+		if (!selection || selection.isCollapsed) return;
+		for (let index = 0; index < selection.rangeCount; index++) {
+			const range = selection.getRangeAt(index);
+			if (!this.element.contains(range.startContainer) || !this.element.contains(range.endContainer)) return;
+		}
+		selection.removeAllRanges();
+	}
+	_invalidateSearch() {
+		if (!this.getSearchState().query) return;
+		this._searchReveal = false;
+		this._search.invalidate();
+		this._paintSearch();
+	}
+	_paintSearch() {
+		if (!this.renderer || !this.bridge || !this._canRender()) return;
+		const fragment = document.createDocumentFragment();
+		const matches = this._search.matches;
+		if (!matches.length) {
+			this.renderer.setSearchDecorations(fragment);
+			return;
+		}
+		const active = this.getSearchState().activeIndex;
+		const viewport = this.element.getBoundingClientRect();
+		for (const { row, element } of this.renderer.searchRows()) {
+			const rect = element.getBoundingClientRect();
+			if (rect.bottom <= viewport.top || rect.top >= viewport.bottom) continue;
+			let low = 0, high = matches.length;
+			while (low < high) {
+				const mid = low + high >>> 1;
+				if (matches[mid].end.row < row) low = mid + 1;
+				else high = mid;
+			}
+			const history = this.bridge.getScrollbackCount();
+			const offset = history - row - 1;
+			let cols = row < history ? this.bridge.getScrollbackLineLen(offset) : this.cols;
+			if (cols <= 0) continue;
+			if ((row < history ? this.bridge.getScrollbackCell(offset, cols - 1) : this.bridge.getCell(row - history, cols - 1)).spacerHead) cols--;
+			let rangeStart = -1, rangeEnd = -1;
+			const draw = (start, end, selected) => {
+				if (end <= start) return;
+				const mark = document.createElement("div");
+				mark.className = `term-search-match${selected ? " term-search-active" : ""}`;
+				mark.style.cssText = `left:${start * this._charWidth}px;top:${element.offsetTop}px;width:${(end - start) * this._charWidth}px;height:${rect.height}px`;
+				fragment.appendChild(mark);
+			};
+			for (let i = low; i < matches.length && matches[i].start.row <= row; i++) {
+				const match = matches[i];
+				const start = match.start.row === row ? match.start.col : 0;
+				const end = Math.min(cols, match.end.row === row ? match.end.endCol : cols);
+				if (rangeStart >= 0 && start > rangeEnd) {
+					draw(rangeStart, rangeEnd, false);
+					rangeStart = -1;
+				}
+				if (rangeStart < 0) rangeStart = start;
+				rangeEnd = Math.max(rangeEnd, end);
+			}
+			if (rangeStart >= 0) draw(rangeStart, rangeEnd, false);
+			const selected = matches[active];
+			if (selected && selected.start.row <= row && selected.end.row >= row) draw(selected.start.row === row ? selected.start.col : 0, Math.min(cols, selected.end.row === row ? selected.end.endCol : cols), true);
+		}
+		this.renderer.setSearchDecorations(fragment);
+	}
+	focus() {
+		if (this.input) this.input.focus();
+		else this.element.focus();
+	}
+	_scheduleRender() {
+		if (!this._canRender() || this._synchronizedOutputState === "held" || this.rafId != null) return;
+		this.rafId = requestAnimationFrame(() => {
+			this.rafId = null;
+			this._doRender();
+		});
+	}
+	_cancelScheduledRender() {
+		if (this.rafId != null) {
+			cancelAnimationFrame(this.rafId);
+			this.rafId = null;
+		}
+	}
+	_updateSynchronizedOutput(synchronized, generation) {
+		if (!synchronized) {
+			if (this._synchronizedOutputState === "held") this._cancelSynchronizedOutputFallback();
+			this._synchronizedOutputState = "idle";
+			return false;
+		}
+		if (this._synchronizedOutputState === "held" && generation !== this._synchronizedOutputGeneration) {
+			this._armSynchronizedOutputFallback(generation);
+			return true;
+		} else if (this._synchronizedOutputState === "passthrough" && generation !== this._synchronizedOutputGeneration) this._synchronizedOutputState = "idle";
+		if (this._synchronizedOutputState !== "idle") return this._synchronizedOutputState === "held";
+		this._synchronizedOutputState = "held";
+		this._cancelScheduledRender();
+		this._armSynchronizedOutputFallback(generation);
+		return true;
+	}
+	_armSynchronizedOutputFallback(generation) {
+		this._cancelSynchronizedOutputFallback();
+		this._synchronizedOutputGeneration = generation;
+		this._synchronizedOutputTimer = setTimeout(() => {
+			if (this._synchronizedOutputState !== "held" || this._synchronizedOutputGeneration !== generation) return;
+			this._synchronizedOutputTimer = null;
+			this._synchronizedOutputState = "passthrough";
+			this._setupRendererIfNeeded();
+			this._cancelScheduledRender();
+			this._doRender();
+		}, SYNCHRONIZED_OUTPUT_TIMEOUT_MS);
+	}
+	_cancelSynchronizedOutputFallback() {
+		if (this._synchronizedOutputTimer == null) return;
+		clearTimeout(this._synchronizedOutputTimer);
+		this._synchronizedOutputTimer = null;
+	}
+	_setupRendererIfNeeded() {
+		if (!this._rendererNeedsSetup) return;
+		this._setupRenderer();
+		this._rendererNeedsSetup = false;
+	}
+	_setupRenderer() {
+		if (!this._shouldScrollToBottom && this._pendingResizeScrollTop === null) this._pendingResizeScrollTop = this.element.scrollTop;
+		this.renderer?.requestSetup();
+	}
+	_initialRender() {
+		this._doRender();
+	}
+	_doRender() {
+		if (!this._canRender() || !this.bridge || !this.renderer || this._synchronizedOutputState === "held") return;
+		let dirtyCount = 0;
+		const t0 = this.debug ? performance.now() : 0;
+		if (this.debug) {
+			for (let r = 0; r < this.rows; r++) if (this.bridge.isDirtyRow(r)) dirtyCount++;
+		}
+		const rowHeight = this._rowHeight || 17;
+		const scrollbackCount = this.bridge.getScrollbackCount();
+		const discardedCount = this.bridge.getScrollbackDiscardedCount?.();
+		const discardedDelta = discardedCount !== void 0 && discardedCount >= this._scrollbackDiscardedCount ? discardedCount - this._scrollbackDiscardedCount : 0;
+		if (discardedCount !== void 0) this._scrollbackDiscardedCount = discardedCount;
+		let scrollTop = this._pendingResizeScrollTop !== null ? this._pendingResizeScrollTop : this.element.scrollTop;
+		if (!this._shouldScrollToBottom && discardedDelta > 0) {
+			scrollTop = Math.max(0, scrollTop - discardedDelta * rowHeight);
+			if (this._pendingResizeScrollTop !== null) this._pendingResizeScrollTop = scrollTop;
+			else this._setScrollTop(scrollTop);
+		}
+		this.renderer.render(this.bridge, {
+			scrollTop: this._shouldScrollToBottom ? Math.max(0, (scrollbackCount + this.rows) * rowHeight - this.element.clientHeight) : scrollTop,
+			clientHeight: this.element.clientHeight,
+			rowHeight,
+			scrollbackDiscardedCount: discardedCount,
+			charWidth: this._charWidth
+		});
+		if (this.debug) this.debug.recordRender(performance.now() - t0, dirtyCount);
+		const hasScrollback = scrollbackCount > 0 || this.renderer.hasImageFlow;
+		this.element.classList.toggle("has-scrollback", hasScrollback);
+		if (this._shouldScrollToBottom) this._scrollToBottom();
+		else if (this._pendingResizeScrollTop !== null) {
+			const pendingScrollTop = this._pendingResizeScrollTop;
+			this._pendingResizeScrollTop = null;
+			this._setScrollTop(pendingScrollTop);
+		} else if (!hasScrollback && this.element.scrollTop !== 0) this._setScrollTop(0);
+		this.input?.syncInputPosition();
+		if (this._searchReveal) {
+			this._searchReveal = false;
+			const match = this._search.matches[this.getSearchState().activeIndex];
+			const target = match && Array.from(this.renderer.searchRows()).find(({ row }) => row === match.start.row);
+			if (target) {
+				const rect = target.element.getBoundingClientRect();
+				const viewport = this.element.getBoundingClientRect();
+				this._setScrollTop(this.element.scrollTop + rect.top - viewport.top - (this.element.clientHeight - rect.height) / 2);
+			}
+		}
+		this._paintSearch();
+		this._search.resume(this.bridge);
+		this._historySelection.resume(this.bridge);
+		this._historySelection.paintRectangle(this.renderer.searchRows(), this._charWidth);
+		this._textCapture.resume(this.bridge);
+		this._outputAnnouncements.rendered();
+		this._deliverTitle();
+		this._drainResponses();
+	}
+	_deliverTitle() {
+		const title = this.bridge?.getTitle() ?? null;
+		if (title !== null) this.onTitle?.(title);
+	}
+	_drainResponses() {
+		if (!this.bridge) return { hasError: false };
+		let response;
+		let firstError;
+		let hasError = false;
+		while ((response = this.bridge.getResponse()) !== null) try {
+			if (this.onData) this.onData(response);
+		} catch (error) {
+			if (!hasError) {
+				hasError = true;
+				firstError = error;
+			}
+		}
+		return {
+			hasError,
+			error: firstError
+		};
+	}
+	/**
+	* Kitty uses xterm window reports to discover the pixel geometry needed for
+	* image placement. The core intentionally does not know about the browser
+	* viewport, so these two queries are answered at the DOM boundary.
+	*/
+	_collectWindowSizeQueries(data) {
+		const queries = [];
+		let state = this._windowSizeQueryState;
+		let index = 0;
+		while (index < data.length) {
+			if (state === 0) {
+				index = typeof data === "string" ? data.indexOf("\x1B", index) : data.indexOf(27, index);
+				if (index < 0) break;
+				state = 1;
+				index++;
+				continue;
+			}
+			const code = typeof data === "string" ? data.charCodeAt(index) : data[index];
+			index++;
+			const restart = code === 27 ? 1 : 0;
+			switch (state) {
+				case 1:
+					state = code === 91 ? 2 : restart;
+					break;
+				case 2:
+					state = code === 49 ? 3 : restart;
+					break;
+				case 3:
+					state = code === 52 ? 4 : code === 54 ? 6 : restart;
+					break;
+				case 4:
+				case 6:
+					if (code === 116) queries.push(state === 4 ? 14 : 16);
+					state = restart;
+			}
+		}
+		this._windowSizeQueryState = state;
+		return queries;
+	}
+	_windowSizeResponse(query) {
+		const { width, height } = this._pixelSize();
+		if (query === 14) return `\x1b[4;${height};${width}t`;
+		const cellWidth = Math.max(1, Math.round(this._charWidth));
+		return `\x1b[6;${Math.max(1, Math.round(this._rowHeight))};${cellWidth}t`;
+	}
+	_pixelSize() {
+		const style = getComputedStyle(this.element);
+		const horizontalPadding = (parseFloat(style.paddingLeft) || 0) + (parseFloat(style.paddingRight) || 0);
+		const verticalPadding = (parseFloat(style.paddingTop) || 0) + (parseFloat(style.paddingBottom) || 0);
+		let width = this.element.clientWidth - horizontalPadding;
+		let height = this.element.clientHeight - verticalPadding;
+		if (width <= 0 || height <= 0) {
+			const rect = this.element.getBoundingClientRect();
+			width = rect.width - horizontalPadding;
+			height = rect.height - verticalPadding;
+		}
+		if (width <= 0 && this._charWidth > 0) width = this.cols * this._charWidth;
+		if (height <= 0 && this._rowHeight > 0) height = this.rows * this._rowHeight;
+		return {
+			width: Math.max(1, Math.round(width)),
+			height: Math.max(1, Math.round(height))
+		};
+	}
+	_lockHeight() {
+		const rh = this._rowHeight || 17;
+		const gridHeight = this.rows * rh;
+		const cs = getComputedStyle(this.element);
+		let extra = (parseFloat(cs.paddingTop) || 0) + (parseFloat(cs.paddingBottom) || 0);
+		if (cs.boxSizing === "border-box") extra += (parseFloat(cs.borderTopWidth) || 0) + (parseFloat(cs.borderBottomWidth) || 0);
+		this.element.style.height = `${gridHeight + extra}px`;
+	}
+	_setRowHeight() {
+		const probe = document.createElement("div");
+		probe.className = "term-row";
+		probe.style.visibility = "hidden";
+		probe.style.position = "absolute";
+		probe.textContent = "W";
+		this._container.appendChild(probe);
+		const h = probe.getBoundingClientRect().height;
+		probe.remove();
+		if (h > 0) {
+			this._rowHeight = h;
+			this.element.style.setProperty("--term-row-height", `${h}px`);
+		}
+	}
+	_measureCharSize() {
+		const row = document.createElement("div");
+		row.className = "term-row";
+		row.style.visibility = "hidden";
+		row.style.position = "absolute";
+		const probe = document.createElement("span");
+		probe.style.width = "auto";
+		probe.textContent = "W";
+		row.appendChild(probe);
+		this._container.appendChild(row);
+		const charWidth = probe.getBoundingClientRect().width;
+		const rowHeight = row.getBoundingClientRect().height;
+		row.remove();
+		if (charWidth === 0 || rowHeight === 0) return null;
+		this._charWidth = charWidth;
+		this._rowHeight = rowHeight;
+		this.element.style.setProperty("--term-cell-width", `${charWidth}px`);
+		return {
+			charWidth,
+			rowHeight
+		};
+	}
+	_setupResizeObserver() {
+		const probe = document.createElement("span");
+		probe.className = "term-size-probe";
+		probe.setAttribute("aria-hidden", "true");
+		probe.textContent = "W";
+		this.element.appendChild(probe);
+		let containerRect;
+		this.resizeObserver = new ResizeObserver((entries) => {
+			if (this._destroyed) return;
+			for (const entry of entries) if (entry.target === this.element) containerRect = entry.contentRect;
+			const measured = this._measureCharSize();
+			if (!measured || !this.autoResize || !containerRect) return;
+			const { charWidth, rowHeight } = measured;
+			const newCols = Math.max(1, Math.floor(containerRect.width / charWidth));
+			const newRows = Math.max(1, Math.floor(containerRect.height / rowHeight));
+			if (newCols !== this.cols || newRows !== this.rows) this.resize(newCols, newRows);
+		});
+		this.resizeObserver.observe(probe);
+		if (this.autoResize) this.resizeObserver.observe(this.element);
+	}
+	destroy() {
+		this._destroyed = true;
+		this._textCapture.cancel();
+		this._historySelection.destroy();
+		this._rectangleDrag.destroy();
+		this._outputAnnouncements.destroy();
+		this._search.cancel();
+		this.onSearchChange = null;
+		this._windowSizeQueryState = 0;
+		this._cancelScheduledRender();
+		this._cancelSynchronizedOutputFallback();
+		if (this.resizeObserver) this.resizeObserver.disconnect();
+		if (this.input) this.input.destroy();
+		this.renderer?.destroy();
+		this.renderer = null;
+		this.element.removeEventListener("click", this._onClickFocus);
+		this.element.removeEventListener("click", this._onMouseSelect);
+		this.element.removeEventListener("scroll", this._onScroll);
+		this.element.ownerDocument.removeEventListener("copy", this._onCopy);
+		this.element.ownerDocument.removeEventListener("visibilitychange", this._onVisibilityChange);
+		this.element.ownerDocument.removeEventListener("keydown", this._onModifierChange);
+		this.element.ownerDocument.removeEventListener("keyup", this._onModifierChange);
+		this.element.ownerDocument.defaultView?.removeEventListener("blur", this._onWindowBlur);
+		this.element.classList.remove("link-modifier-active");
+		this.element.innerHTML = "";
+		if (this.debug && globalThis.__wterm === this) delete globalThis.__wterm;
+		this.debug = null;
+	}
+};
+//#endregion
+export { WTerm };