@simon_he/vue-tui 0.0.8 → 1.0.0

package/dist/runtime-rfcZCyJq.js

@@ -0,0 +1,1197 @@
+//#region src/events/manager/selection-suppression.ts
+const SUPPRESS_TERMINAL_POINTER_UP = "__vueTuiSuppressTerminalPointerUp";
+const SUPPRESS_TERMINAL_POINTER_DOWN = "__vueTuiSuppressTerminalPointerDown";
+const SUPPRESS_TERMINAL_POINTER_MOVE = "__vueTuiSuppressTerminalPointerMove";
+
+//#endregion
+//#region src/events/manager/event-manager.ts
+function contains(rect, x, y) {
+	return x >= rect.x && y >= rect.y && x < rect.x + rect.w && y < rect.y + rect.h;
+}
+function isVisible(node) {
+	return node.visible !== false;
+}
+function containsRect(outer, inner) {
+	return inner.x >= outer.x && inner.y >= outer.y && inner.x + inner.w <= outer.x + outer.w && inner.y + inner.h <= outer.y + outer.h;
+}
+function area(rect) {
+	return Math.max(0, rect.w) * Math.max(0, rect.h);
+}
+function sameRect(a, b) {
+	return a.x === b.x && a.y === b.y && a.w === b.w && a.h === b.h;
+}
+function now() {
+	return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function rectRowRange(rect) {
+	const y0 = Math.floor(rect.y);
+	const y1 = Math.ceil(rect.y + rect.h) - 1;
+	if (!Number.isFinite(y0) || !Number.isFinite(y1)) return null;
+	if (y1 < y0) return null;
+	return {
+		y0,
+		y1
+	};
+}
+let nextId = 0;
+function createEventManager(container, metrics, options) {
+	let currentMetrics = metrics;
+	const nodes = new Map();
+	const rowBuckets = new Map();
+	const rowRangeById = new Map();
+	let focusedId = null;
+	let capturedId = null;
+	let hoverPath = [];
+	let lastPointerMoveEvent = null;
+	const rawRecord = options?.record;
+	const recordStart = now();
+	const record = rawRecord ? (event) => {
+		rawRecord({
+			...event,
+			time: now() - recordStart
+		});
+	} : void 0;
+	const onFocusChange = options?.onFocusChange;
+	const textInputTarget = options?.textInputTarget ?? null;
+	const MODAL_FOCUS_Z_THRESHOLD = 100;
+	const MODAL_ROOT_MIN_AREA = 40;
+	function focusLockTarget() {
+		let bestRoot = null;
+		let bestAny = null;
+		for (const n of nodes.values()) {
+			if (!n.focusable || !isVisible(n)) continue;
+			const z = n.zIndex ?? 0;
+			if (z < MODAL_FOCUS_Z_THRESHOLD) continue;
+			const a = area(n.rect);
+			if (!bestAny || z > bestAny.zIndex || z === bestAny.zIndex && a > bestAny.area) bestAny = {
+				id: n.id,
+				zIndex: z,
+				area: a
+			};
+			if (a >= MODAL_ROOT_MIN_AREA && (!bestRoot || z > bestRoot.zIndex || z === bestRoot.zIndex && a > bestRoot.area)) bestRoot = {
+				id: n.id,
+				zIndex: z,
+				area: a
+			};
+		}
+		const best = bestRoot ?? bestAny;
+		return best ? {
+			id: best.id,
+			zIndex: best.zIndex
+		} : null;
+	}
+	function resolveLockedFocusTarget(type) {
+		const lock = focusLockTarget();
+		let target = focusedId ? nodes.get(focusedId) ?? null : null;
+		const shouldRetarget = lock && (!target || !isVisible(target) || (target.zIndex ?? 0) < lock.zIndex);
+		if (!shouldRetarget || !lock) return target;
+		let best = null;
+		let bestScore = -Infinity;
+		for (const node of nodes.values()) {
+			if (!node.focusable || !isVisible(node)) continue;
+			const z = node.zIndex ?? 0;
+			if (z < lock.zIndex) continue;
+			const handlers = node.handlers ?? {};
+			const canHandle = type ? typeof handlers[type] === "function" : false;
+			const a = area(node.rect);
+			const score = z * 1e9 + (canHandle ? 1e6 : 0) - a;
+			if (score > bestScore) {
+				bestScore = score;
+				best = node;
+			}
+		}
+		if (best) {
+			setFocus(best.id);
+			target = best;
+		}
+		return target;
+	}
+	function resolveModalLockNode() {
+		const lock = focusLockTarget();
+		if (!lock) return null;
+		const node = nodes.get(lock.id) ?? null;
+		return node && isVisible(node) ? node : null;
+	}
+	function isAllowedModalPointerNode(node, target, lockNode) {
+		const nodeZ = node.zIndex ?? 0;
+		const targetZ = target.zIndex ?? 0;
+		const lockZ = lockNode.zIndex ?? 0;
+		if (nodeZ >= lockZ) return true;
+		return targetZ < lockZ && nodeZ >= targetZ && containsRect(node.rect, lockNode.rect);
+	}
+	const shouldDebugIme = () => Boolean(options?.debugIme) || Boolean(globalThis.__VT_DEBUG_IME__);
+	const imeLog = (msg, extra) => {
+		if (!shouldDebugIme()) return;
+		console.debug(`[vue-terminal][ime] ${msg}`, extra ?? {});
+	};
+	let domComposing = false;
+	const defaultUserSelect = container.style.userSelect || "text";
+	if (!container.hasAttribute("tabindex")) container.tabIndex = 0;
+	if (!container.style.userSelect) container.style.userSelect = defaultUserSelect;
+	let containerRect = null;
+	let containerRectDirty = true;
+	function markContainerRectDirty() {
+		containerRectDirty = true;
+	}
+	function getContainerRect() {
+		if (!containerRect || containerRectDirty) {
+			containerRect = container.getBoundingClientRect();
+			containerRectDirty = false;
+		}
+		return containerRect;
+	}
+	function removeFromRowBuckets(id) {
+		const prev = rowRangeById.get(id);
+		if (!prev) return;
+		for (let y = prev.y0; y <= prev.y1; y++) {
+			const bucket = rowBuckets.get(y);
+			if (!bucket) continue;
+			bucket.delete(id);
+			if (bucket.size === 0) rowBuckets.delete(y);
+		}
+		rowRangeById.delete(id);
+	}
+	function addToRowBuckets(id, node) {
+		if (!isVisible(node)) return;
+		const range = rectRowRange(node.rect);
+		if (!range) return;
+		rowRangeById.set(id, range);
+		for (let y = range.y0; y <= range.y1; y++) {
+			let bucket = rowBuckets.get(y);
+			if (!bucket) {
+				bucket = new Set();
+				rowBuckets.set(y, bucket);
+			}
+			bucket.add(id);
+		}
+	}
+	function updateRowBuckets(id, node) {
+		if (!isVisible(node)) {
+			removeFromRowBuckets(id);
+			return;
+		}
+		const next = rectRowRange(node.rect);
+		const prev = rowRangeById.get(id);
+		if (!next) {
+			removeFromRowBuckets(id);
+			return;
+		}
+		if (prev && prev.y0 === next.y0 && prev.y1 === next.y1) return;
+		removeFromRowBuckets(id);
+		rowRangeById.set(id, next);
+		for (let y = next.y0; y <= next.y1; y++) {
+			let bucket = rowBuckets.get(y);
+			if (!bucket) {
+				bucket = new Set();
+				rowBuckets.set(y, bucket);
+			}
+			bucket.add(id);
+		}
+	}
+	function candidatesAt(cellX, cellY) {
+		const list = [];
+		const bucket = rowBuckets.get(cellY);
+		if (!bucket) return list;
+		for (const id of bucket) {
+			const node = nodes.get(id);
+			if (!node) continue;
+			if (!isVisible(node)) continue;
+			if (contains(node.rect, cellX, cellY)) list.push(node);
+		}
+		return list.sort((a, b) => area(b.rect) - area(a.rect) || a.zIndex - b.zIndex);
+	}
+	function pickTarget(list) {
+		if (list.length === 0) return null;
+		let target = list[0];
+		for (const n of list) if (n.zIndex > target.zIndex) target = n;
+		else if (n.zIndex === target.zIndex && area(n.rect) <= area(target.rect)) target = n;
+		return target;
+	}
+	function pathOuterToInner(list, target) {
+		if (!target) return [];
+		const filtered = list.filter((n) => n.id !== target.id && (!n.focusable || !target.focusable || n.zIndex !== target.zIndex || !sameRect(n.rect, target.rect)));
+		return [...filtered, target];
+	}
+	function ancestorsForTarget(target) {
+		const range = rectRowRange(target.rect);
+		const seedBucket = range ? rowBuckets.get(range.y0) : null;
+		if (!seedBucket) {
+			const list$1 = [];
+			for (const node of nodes.values()) {
+				if (!isVisible(node)) continue;
+				if (containsRect(node.rect, target.rect)) list$1.push(node);
+			}
+			const sorted$1 = list$1.sort((a, b) => a.zIndex - b.zIndex || area(b.rect) - area(a.rect));
+			return pathOuterToInner(sorted$1, target);
+		}
+		const list = [];
+		for (const id of seedBucket) {
+			const node = nodes.get(id);
+			if (!node) continue;
+			if (!isVisible(node)) continue;
+			if (containsRect(node.rect, target.rect)) list.push(node);
+		}
+		const sorted = list.sort((a, b) => a.zIndex - b.zIndex || area(b.rect) - area(a.rect));
+		return pathOuterToInner(sorted, target);
+	}
+	function makeBaseEvent(type, path, nativeEvent) {
+		const e = {
+			type,
+			target: null,
+			currentTarget: null,
+			eventPhase: 2,
+			bubbles: true,
+			cancelable: true,
+			defaultPrevented: Boolean(nativeEvent?.defaultPrevented),
+			timeStamp: now(),
+			__stopped: false,
+			stopPropagation() {
+				this.__stopped = true;
+			},
+			preventDefault() {
+				this.defaultPrevented = true;
+				nativeEvent?.preventDefault?.();
+			},
+			composedPath() {
+				return [...path].reverse();
+			},
+			nativeEvent
+		};
+		return e;
+	}
+	function dispatchToNode(handlerKey, node, event) {
+		event.currentTarget = node;
+		if (!node) return;
+		const handler = node.handlers[handlerKey];
+		handler?.(event);
+	}
+	function dispatchWithPhases(type, path, target, event) {
+		event.target = target;
+		const captureKey = `${type}Capture`;
+		event.eventPhase = 1;
+		for (const node of path) {
+			dispatchToNode(captureKey, node, event);
+			if (event.__stopped) return;
+		}
+		if (target) {
+			event.eventPhase = 2;
+			dispatchToNode(type, target, event);
+			if (event.__stopped) return;
+		}
+		if (!event.bubbles) return;
+		event.eventPhase = 3;
+		for (let i = path.length - 2; i >= 0; i--) {
+			dispatchToNode(type, path[i], event);
+			if (event.__stopped) return;
+		}
+	}
+	function sharedPrefixLenById(a, b) {
+		const min = Math.min(a.length, b.length);
+		let i = 0;
+		for (; i < min; i++) if (a[i].id !== b[i].id) break;
+		return i;
+	}
+	function updateHover(nextTarget, native) {
+		const nextPath = nextTarget ? ancestorsForTarget(nextTarget) : [];
+		const shared = sharedPrefixLenById(hoverPath, nextPath);
+		for (let i = hoverPath.length - 1; i >= shared; i--) {
+			const target = hoverPath[i] ?? null;
+			if (!target) continue;
+			const path = hoverPath.slice(0, i + 1);
+			const ev = buildPointerEvent("pointerleave", path, native);
+			ev.bubbles = false;
+			dispatchWithPhases("pointerleave", path, target, ev);
+		}
+		for (let i = shared; i < nextPath.length; i++) {
+			const target = nextPath[i] ?? null;
+			if (!target) continue;
+			const path = nextPath.slice(0, i + 1);
+			const ev = buildPointerEvent("pointerenter", path, native);
+			ev.bubbles = false;
+			dispatchWithPhases("pointerenter", path, target, ev);
+		}
+		hoverPath = nextPath;
+	}
+	function setFocus(nextId$1) {
+		const lock = focusLockTarget();
+		if (lock) if (!nextId$1) nextId$1 = lock.id;
+		else {
+			const want = nodes.get(nextId$1) ?? null;
+			const wantZ = want?.zIndex ?? 0;
+			if (want && isVisible(want) && wantZ < lock.zIndex) return;
+		}
+		if (focusedId === nextId$1) return;
+		const prev = focusedId ? nodes.get(focusedId) ?? null : null;
+		const nextRaw = nextId$1 ? nodes.get(nextId$1) ?? null : null;
+		const next = nextRaw && isVisible(nextRaw) ? nextRaw : null;
+		focusedId = next?.id ?? null;
+		onFocusChange?.(prev?.id ?? null, focusedId);
+		if (prev) {
+			const path = ancestorsForTarget(prev);
+			const ev = makeBaseEvent("blur", path);
+			dispatchWithPhases("blur", path, prev, ev);
+		}
+		if (next) {
+			const path = ancestorsForTarget(next);
+			const ev = makeBaseEvent("focus", path);
+			dispatchWithPhases("focus", path, next, ev);
+		}
+	}
+	function toCell(clientX, clientY) {
+		const rect = getContainerRect();
+		const x = clientX - rect.left;
+		const y = clientY - rect.top;
+		return {
+			cellX: Math.max(0, Math.floor(x / currentMetrics.cellWidth)),
+			cellY: Math.max(0, Math.floor(y / currentMetrics.cellHeight))
+		};
+	}
+	function buildPointerEvent(type, path, native) {
+		const base = makeBaseEvent(type, path, native);
+		const { cellX, cellY } = toCell(native.clientX, native.clientY);
+		return Object.assign(base, {
+			clientX: native.clientX,
+			clientY: native.clientY,
+			cellX,
+			cellY,
+			button: "button" in native ? native.button : void 0,
+			buttons: "buttons" in native ? native.buttons : void 0,
+			ctrlKey: native.ctrlKey,
+			shiftKey: native.shiftKey,
+			altKey: native.altKey,
+			metaKey: native.metaKey,
+			deltaY: "deltaY" in native ? native.deltaY : void 0,
+			deltaMode: "deltaMode" in native ? native.deltaMode : void 0
+		});
+	}
+	function keyCombo(native) {
+		let out = "";
+		if (native.metaKey) out += "Meta+";
+		if (native.ctrlKey) out += "Ctrl+";
+		if (native.altKey) out += "Alt+";
+		if (native.shiftKey) out += "Shift+";
+		out += native.key;
+		return out;
+	}
+	function buildKeyboardEvent(type, path, native) {
+		const base = makeBaseEvent(type, path, native);
+		return Object.assign(base, {
+			key: native.key,
+			code: native.code,
+			combo: keyCombo(native),
+			ctrlKey: native.ctrlKey,
+			shiftKey: native.shiftKey,
+			altKey: native.altKey,
+			metaKey: native.metaKey,
+			repeat: native.repeat
+		});
+	}
+	function dispatchPointer(type, native, targetOverride) {
+		const { cellX, cellY } = toCell(native.clientX, native.clientY);
+		const list = candidatesAt(cellX, cellY);
+		const target = targetOverride ?? pickTarget(list);
+		const lockNode = resolveModalLockNode();
+		if (lockNode && target && !isAllowedModalPointerNode(target, target, lockNode)) return;
+		let path = target ? ancestorsForTarget(target) : [];
+		if (lockNode && target && path.length > 0) path = path.filter((n) => isAllowedModalPointerNode(n, target, lockNode));
+		const ev = buildPointerEvent(type, path, native);
+		dispatchWithPhases(type, path, target, ev);
+	}
+	function dispatchToFocused(type, native) {
+		const target = resolveLockedFocusTarget(type);
+		const path = target ? ancestorsForTarget(target) : [];
+		const ev = buildKeyboardEvent(type, path, native);
+		dispatchWithPhases(type, path, target, ev);
+		if (ev.defaultPrevented) native.preventDefault();
+	}
+	function buildInputEvent(type, path, native) {
+		const base = makeBaseEvent(type, path, native);
+		const anyNative = native;
+		const data = typeof anyNative.data === "string" ? anyNative.data : void 0;
+		const inputType = typeof anyNative.inputType === "string" ? anyNative.inputType : void 0;
+		const isComposing = Boolean(anyNative.isComposing);
+		let text;
+		if (type === "paste") {
+			const clipboard = anyNative.clipboardData;
+			if (clipboard?.getData) text = clipboard.getData("text/plain") || clipboard.getData("text") || "";
+		}
+		return Object.assign(base, {
+			data,
+			inputType,
+			isComposing,
+			text
+		});
+	}
+	function dispatchToFocusedText(type, native) {
+		const target = resolveLockedFocusTarget(type);
+		const path = target ? ancestorsForTarget(target) : [];
+		const ev = buildInputEvent(type, path, native);
+		dispatchWithPhases(type, path, target, ev);
+		if (ev.defaultPrevented) native.preventDefault?.();
+	}
+	function onPointerDown(e) {
+		if (e[SUPPRESS_TERMINAL_POINTER_DOWN]) {
+			if (textInputTarget && !container.contains(textInputTarget)) try {
+				textInputTarget.focus?.({ preventScroll: true });
+			} catch {
+				textInputTarget.focus?.();
+			}
+			else try {
+				container.focus?.({ preventScroll: true });
+			} catch {
+				container.focus?.();
+			}
+			const { cellX: cellX$1, cellY: cellY$1 } = toCell(e.clientX, e.clientY);
+			const list$1 = candidatesAt(cellX$1, cellY$1);
+			const target$1 = pickTarget(list$1);
+			if (target$1?.focusable) setFocus(target$1.id);
+			capturedId = target$1?.id ?? null;
+			updateHover(target$1, e);
+			record?.({
+				type: "pointerdown",
+				cellX: cellX$1,
+				cellY: cellY$1,
+				clientX: e.clientX,
+				clientY: e.clientY,
+				button: e.button,
+				buttons: e.buttons,
+				ctrlKey: e.ctrlKey,
+				shiftKey: e.shiftKey,
+				altKey: e.altKey,
+				metaKey: e.metaKey
+			});
+			return;
+		}
+		if (textInputTarget && !container.contains(textInputTarget)) {
+			try {
+				textInputTarget.focus?.({ preventScroll: true });
+			} catch {
+				textInputTarget.focus?.();
+			}
+			if (shouldDebugIme()) {
+				const active = typeof document !== "undefined" ? document.activeElement?.tagName ?? null : null;
+				imeLog("pointerdown focus textInputTarget", { active });
+			}
+		} else try {
+			container.focus?.({ preventScroll: true });
+		} catch {
+			container.focus?.();
+		}
+		const { cellX, cellY } = toCell(e.clientX, e.clientY);
+		const list = candidatesAt(cellX, cellY);
+		const target = pickTarget(list);
+		const lockNode = resolveModalLockNode();
+		if (lockNode && target && !isAllowedModalPointerNode(target, target, lockNode)) return;
+		let path = target ? ancestorsForTarget(target) : [];
+		if (lockNode && target && path.length > 0) path = path.filter((n) => isAllowedModalPointerNode(n, target, lockNode));
+		const allowSelection = target ? target.selectable ?? !target.focusable : true;
+		container.style.userSelect = allowSelection ? defaultUserSelect : "none";
+		if (target) if (target.focusable) setFocus(target.id);
+		else for (let i = path.length - 2; i >= 0; i--) {
+			const n = path[i];
+			if (n?.focusable) {
+				setFocus(n.id);
+				break;
+			}
+		}
+		capturedId = target?.id ?? null;
+		updateHover(target, e);
+		record?.({
+			type: "pointerdown",
+			cellX,
+			cellY,
+			clientX: e.clientX,
+			clientY: e.clientY,
+			button: e.button,
+			buttons: e.buttons,
+			ctrlKey: e.ctrlKey,
+			shiftKey: e.shiftKey,
+			altKey: e.altKey,
+			metaKey: e.metaKey
+		});
+		const ev = buildPointerEvent("pointerdown", path, e);
+		dispatchWithPhases("pointerdown", path, target, ev);
+	}
+	function onMouseDown(e) {
+		onPointerDown(e);
+	}
+	function onMouseMove(e) {
+		lastPointerMoveEvent = e;
+		onPointerMove(e);
+	}
+	function onMouseUp(e) {
+		onPointerUp(e);
+	}
+	function onMouseLeave(e) {
+		const native = lastPointerMoveEvent ?? e;
+		updateHover(null, native);
+	}
+	function onPointerMove(e) {
+		if (e[SUPPRESS_TERMINAL_POINTER_MOVE]) return;
+		lastPointerMoveEvent = e;
+		const { cellX, cellY } = toCell(e.clientX, e.clientY);
+		record?.({
+			type: "pointermove",
+			cellX,
+			cellY,
+			clientX: e.clientX,
+			clientY: e.clientY,
+			button: e.button,
+			buttons: e.buttons,
+			ctrlKey: e.ctrlKey,
+			shiftKey: e.shiftKey,
+			altKey: e.altKey,
+			metaKey: e.metaKey
+		});
+		if (capturedId) {
+			const target$1 = nodes.get(capturedId) ?? null;
+			if (!target$1) return;
+			updateHover(target$1, e);
+			const path = ancestorsForTarget(target$1);
+			const ev = buildPointerEvent("pointermove", path, e);
+			dispatchWithPhases("pointermove", path, target$1, ev);
+			return;
+		}
+		const list = candidatesAt(cellX, cellY);
+		const target = pickTarget(list);
+		updateHover(target, e);
+		dispatchPointer("pointermove", e, target);
+	}
+	function onPointerUp(e) {
+		const { cellX, cellY } = toCell(e.clientX, e.clientY);
+		record?.({
+			type: "pointerup",
+			cellX,
+			cellY,
+			clientX: e.clientX,
+			clientY: e.clientY,
+			button: e.button,
+			buttons: e.buttons,
+			ctrlKey: e.ctrlKey,
+			shiftKey: e.shiftKey,
+			altKey: e.altKey,
+			metaKey: e.metaKey
+		});
+		if (e[SUPPRESS_TERMINAL_POINTER_UP]) {
+			capturedId = null;
+			container.style.userSelect = defaultUserSelect;
+			return;
+		}
+		if (capturedId) {
+			const target = nodes.get(capturedId) ?? null;
+			const path = target ? ancestorsForTarget(target) : [];
+			const ev = buildPointerEvent("pointerup", path, e);
+			dispatchWithPhases("pointerup", path, target, ev);
+		} else dispatchPointer("pointerup", e);
+		capturedId = null;
+		container.style.userSelect = defaultUserSelect;
+	}
+	function onClick(e) {
+		const { cellX, cellY } = toCell(e.clientX, e.clientY);
+		record?.({
+			type: "click",
+			cellX,
+			cellY,
+			clientX: e.clientX,
+			clientY: e.clientY,
+			button: e.button,
+			buttons: e.buttons,
+			ctrlKey: e.ctrlKey,
+			shiftKey: e.shiftKey,
+			altKey: e.altKey,
+			metaKey: e.metaKey
+		});
+		dispatchPointer("click", e);
+	}
+	function onDblClick(e) {
+		const { cellX, cellY } = toCell(e.clientX, e.clientY);
+		record?.({
+			type: "dblclick",
+			cellX,
+			cellY,
+			clientX: e.clientX,
+			clientY: e.clientY,
+			button: e.button,
+			buttons: e.buttons,
+			ctrlKey: e.ctrlKey,
+			shiftKey: e.shiftKey,
+			altKey: e.altKey,
+			metaKey: e.metaKey
+		});
+		dispatchPointer("dblclick", e);
+	}
+	function onContextMenu(e) {
+		const { cellX, cellY } = toCell(e.clientX, e.clientY);
+		record?.({
+			type: "contextmenu",
+			cellX,
+			cellY,
+			clientX: e.clientX,
+			clientY: e.clientY,
+			button: e.button,
+			buttons: e.buttons,
+			ctrlKey: e.ctrlKey,
+			shiftKey: e.shiftKey,
+			altKey: e.altKey,
+			metaKey: e.metaKey
+		});
+		const list = candidatesAt(cellX, cellY);
+		const target = pickTarget(list);
+		const path = target ? ancestorsForTarget(target) : [];
+		const ev = buildPointerEvent("contextmenu", path, e);
+		dispatchWithPhases("contextmenu", path, target, ev);
+		if (ev.defaultPrevented) e.preventDefault();
+	}
+	function onWheel(e) {
+		const { cellX, cellY } = toCell(e.clientX, e.clientY);
+		const list = candidatesAt(cellX, cellY);
+		if (list.length > 0) e.preventDefault();
+		record?.({
+			type: "wheel",
+			cellX,
+			cellY,
+			clientX: e.clientX,
+			clientY: e.clientY,
+			deltaY: e.deltaY,
+			ctrlKey: e.ctrlKey,
+			shiftKey: e.shiftKey,
+			altKey: e.altKey,
+			metaKey: e.metaKey,
+			deltaMode: e.deltaMode
+		});
+		dispatchPointer("wheel", e);
+	}
+	function onKeyDown(e) {
+		const targetIsTextInput = Boolean(textInputTarget && (e.target === textInputTarget || e.target instanceof Node && textInputTarget.contains(e.target)));
+		if (targetIsTextInput) {
+			const anyNative = e;
+			const isComposing = Boolean(anyNative.isComposing);
+			const keyCode = typeof anyNative.keyCode === "number" ? anyNative.keyCode : void 0;
+			const key = e.key;
+			const isImeKey = domComposing || isComposing || key === "Process" || key === "Unidentified" || keyCode === 229;
+			if (isImeKey) {
+				imeLog("keydown ignored (ime composing)", {
+					key,
+					code: e.code,
+					keyCode,
+					isComposing,
+					domComposing,
+					focusedId
+				});
+				return;
+			}
+			const isPlainTextKey = key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey;
+			if (isPlainTextKey) {
+				imeLog("keydown ignored (textInput)", {
+					key,
+					code: e.code,
+					keyCode,
+					isComposing,
+					domComposing,
+					focusedId
+				});
+				return;
+			}
+		}
+		record?.({
+			type: "keydown",
+			key: e.key,
+			code: e.code,
+			ctrlKey: e.ctrlKey,
+			shiftKey: e.shiftKey,
+			altKey: e.altKey,
+			metaKey: e.metaKey,
+			repeat: e.repeat
+		});
+		dispatchToFocused("keydown", e);
+	}
+	function onKeyUp(e) {
+		const targetIsTextInput = Boolean(textInputTarget && (e.target === textInputTarget || e.target instanceof Node && textInputTarget.contains(e.target)));
+		if (targetIsTextInput) {
+			const anyNative = e;
+			const isComposing = Boolean(anyNative.isComposing);
+			const keyCode = typeof anyNative.keyCode === "number" ? anyNative.keyCode : void 0;
+			const key = e.key;
+			const isImeKey = domComposing || isComposing || key === "Process" || key === "Unidentified" || keyCode === 229;
+			if (isImeKey) {
+				imeLog("keyup ignored (ime composing)", {
+					key,
+					code: e.code,
+					keyCode,
+					isComposing,
+					domComposing,
+					focusedId
+				});
+				return;
+			}
+			const isPlainTextKey = key.length === 1 && !e.ctrlKey && !e.metaKey && !e.altKey;
+			if (isPlainTextKey) {
+				imeLog("keyup ignored (textInput)", {
+					key,
+					code: e.code,
+					keyCode,
+					isComposing,
+					domComposing,
+					focusedId
+				});
+				return;
+			}
+		}
+		record?.({
+			type: "keyup",
+			key: e.key,
+			code: e.code,
+			ctrlKey: e.ctrlKey,
+			shiftKey: e.shiftKey,
+			altKey: e.altKey,
+			metaKey: e.metaKey,
+			repeat: e.repeat
+		});
+		dispatchToFocused("keyup", e);
+	}
+	function onBeforeInput(e) {
+		const anyNative = e;
+		if (anyNative && typeof anyNative.isComposing === "boolean") domComposing = anyNative.isComposing;
+		const targetIsTextInput = Boolean(textInputTarget && (e.target === textInputTarget || e.target instanceof Node && textInputTarget.contains(e.target)));
+		const data = typeof anyNative.data === "string" ? anyNative.data : void 0;
+		const inputType = typeof anyNative.inputType === "string" ? anyNative.inputType : void 0;
+		const isPasteLike = inputType === "insertFromPaste" || inputType === "insertFromDrop";
+		if (targetIsTextInput && isPasteLike) {
+			anyNative?.preventDefault?.();
+			e?.preventDefault?.();
+			return;
+		}
+		const isLineBreakLike = inputType === "insertLineBreak" || inputType === "insertParagraph" || data?.includes("\n") && !isPasteLike;
+		if (targetIsTextInput && isLineBreakLike) {
+			anyNative?.preventDefault?.();
+			e?.preventDefault?.();
+			return;
+		}
+		record?.({
+			type: "beforeinput",
+			data,
+			inputType,
+			isComposing: Boolean(anyNative.isComposing)
+		});
+		dispatchToFocusedText("beforeinput", e);
+	}
+	function onInput(e) {
+		const anyNative = e;
+		if (anyNative && typeof anyNative.isComposing === "boolean") domComposing = anyNative.isComposing;
+		const targetIsTextInput = Boolean(textInputTarget && (e.target === textInputTarget || e.target instanceof Node && textInputTarget.contains(e.target)));
+		const data = typeof anyNative.data === "string" ? anyNative.data : void 0;
+		const inputType = typeof anyNative.inputType === "string" ? anyNative.inputType : void 0;
+		const isPasteLike = inputType === "insertFromPaste" || inputType === "insertFromDrop";
+		if (targetIsTextInput && isPasteLike) {
+			anyNative?.preventDefault?.();
+			e?.preventDefault?.();
+			return;
+		}
+		const isLineBreakLike = inputType === "insertLineBreak" || inputType === "insertParagraph" || data?.includes("\n") && !isPasteLike;
+		if (targetIsTextInput && isLineBreakLike) {
+			anyNative?.preventDefault?.();
+			e?.preventDefault?.();
+			return;
+		}
+		record?.({
+			type: "input",
+			data,
+			inputType,
+			isComposing: Boolean(anyNative.isComposing)
+		});
+		dispatchToFocusedText("input", e);
+	}
+	function onCompositionStart(e) {
+		const anyNative = e;
+		domComposing = true;
+		record?.({
+			type: "compositionstart",
+			data: typeof anyNative.data === "string" ? anyNative.data : void 0,
+			isComposing: Boolean(anyNative.isComposing)
+		});
+		imeLog("compositionstart", {
+			data: typeof anyNative.data === "string" ? anyNative.data : void 0,
+			isComposing: Boolean(anyNative.isComposing),
+			focusedId
+		});
+		dispatchToFocusedText("compositionstart", e);
+	}
+	function onCompositionUpdate(e) {
+		const anyNative = e;
+		record?.({
+			type: "compositionupdate",
+			data: typeof anyNative.data === "string" ? anyNative.data : void 0,
+			isComposing: Boolean(anyNative.isComposing)
+		});
+		imeLog("compositionupdate", {
+			data: typeof anyNative.data === "string" ? anyNative.data : void 0,
+			isComposing: Boolean(anyNative.isComposing),
+			focusedId
+		});
+		dispatchToFocusedText("compositionupdate", e);
+	}
+	function onCompositionEnd(e) {
+		const anyNative = e;
+		domComposing = false;
+		record?.({
+			type: "compositionend",
+			data: typeof anyNative.data === "string" ? anyNative.data : void 0,
+			isComposing: Boolean(anyNative.isComposing)
+		});
+		imeLog("compositionend", {
+			data: typeof anyNative.data === "string" ? anyNative.data : void 0,
+			isComposing: Boolean(anyNative.isComposing),
+			focusedId
+		});
+		dispatchToFocusedText("compositionend", e);
+	}
+	function onDragOver(e) {
+		e.preventDefault();
+	}
+	function onDrop(e) {
+		e.preventDefault();
+		let text = "";
+		if (e.dataTransfer) {
+			if (e.dataTransfer.files && e.dataTransfer.files.length > 0) {
+				const files = Array.from(e.dataTransfer.files);
+				const paths = files.map((file) => String(file?.path || file?.name || "").trim()).filter(Boolean);
+				text = paths.join("\n");
+			} else if (e.dataTransfer.types.includes("text/plain")) text = e.dataTransfer.getData("text/plain");
+		}
+		if (text) {
+			record?.({
+				type: "paste",
+				text
+			});
+			if (textInputTarget) try {
+				textInputTarget.focus?.({ preventScroll: true });
+			} catch {
+				textInputTarget.focus?.();
+			}
+			else try {
+				container.focus?.({ preventScroll: true });
+			} catch {
+				container.focus?.();
+			}
+			const focusableNodes = Array.from(nodes.values()).filter((n) => n.focusable && isVisible(n));
+			if (focusableNodes.length > 0) {
+				const targetNode = focusableNodes[0];
+				setFocus(targetNode.id);
+				const path = targetNode ? ancestorsForTarget(targetNode) : [];
+				const ev = buildInputEvent("paste", path, e);
+				ev.text = text;
+				dispatchWithPhases("paste", path, targetNode, ev);
+			}
+		}
+	}
+	function onPaste(e) {
+		const anyNative = e;
+		const clipboard = anyNative.clipboardData;
+		let text = "";
+		if (clipboard?.files && clipboard.files.length > 0) {
+			const file = clipboard.files[0];
+			text = file.path || file.name;
+		} else if (clipboard?.getData) text = clipboard.getData("text/plain") || clipboard.getData("text") || "";
+		record?.({
+			type: "paste",
+			text
+		});
+		if (focusedId) {
+			const targetNode = nodes.get(focusedId);
+			if (targetNode) {
+				const path = ancestorsForTarget(targetNode);
+				const ev = buildInputEvent("paste", path, e);
+				ev.text = text;
+				dispatchWithPhases("paste", path, targetNode, ev);
+				if (ev.defaultPrevented) {
+					anyNative?.preventDefault?.();
+					e?.preventDefault?.();
+				}
+			}
+		}
+	}
+	const textTargets = [container];
+	if (textInputTarget && textInputTarget !== container && !container.contains(textInputTarget)) textTargets.push(textInputTarget);
+	const keyboardTargets = [container];
+	if (textInputTarget && textInputTarget !== container && !container.contains(textInputTarget)) keyboardTargets.push(textInputTarget);
+	let attached = false;
+	function attach() {
+		if (attached) return;
+		attached = true;
+		container.addEventListener("pointerdown", onPointerDown);
+		container.addEventListener("pointermove", onPointerMove);
+		container.addEventListener("pointerup", onPointerUp);
+		container.addEventListener("mousedown", onMouseDown);
+		container.addEventListener("mousemove", onMouseMove);
+		container.addEventListener("mouseup", onMouseUp);
+		container.addEventListener("mouseleave", onMouseLeave);
+		container.addEventListener("click", onClick);
+		container.addEventListener("dblclick", onDblClick);
+		container.addEventListener("contextmenu", onContextMenu);
+		container.addEventListener("wheel", onWheel, { passive: false });
+		container.addEventListener("dragover", onDragOver);
+		container.addEventListener("drop", onDrop);
+		for (const target of keyboardTargets) {
+			target.addEventListener("keydown", onKeyDown);
+			target.addEventListener("keyup", onKeyUp);
+		}
+		for (const target of textTargets) {
+			target.addEventListener("beforeinput", onBeforeInput);
+			target.addEventListener("input", onInput);
+			target.addEventListener("compositionstart", onCompositionStart);
+			target.addEventListener("compositionupdate", onCompositionUpdate);
+			target.addEventListener("compositionend", onCompositionEnd);
+			target.addEventListener("paste", onPaste);
+		}
+		window.addEventListener("scroll", markContainerRectDirty, {
+			capture: true,
+			passive: true
+		});
+		window.addEventListener("resize", markContainerRectDirty, { passive: true });
+	}
+	if (!options?.deferAttach) attach();
+	return {
+		register(node) {
+			const id = node.id ?? `n${nextId++}`;
+			const focusable = node.focusable;
+			const full = {
+				id,
+				rect: node.rect,
+				zIndex: node.zIndex ?? 0,
+				visible: node.visible ?? true,
+				focusable,
+				selectable: node.selectable ?? !focusable,
+				selectionScrollBy: node.selectionScrollBy,
+				handlers: node.handlers ?? {}
+			};
+			if (nodes.has(id)) removeFromRowBuckets(id);
+			nodes.set(id, full);
+			addToRowBuckets(id, full);
+			return full;
+		},
+		update(id, next) {
+			const prev = nodes.get(id);
+			if (!prev) return;
+			const nextVisible = next.visible ?? prev.visible;
+			if (nextVisible === false) {
+				if (focusedId === id) setFocus(null);
+				if (capturedId === id) capturedId = null;
+				if (hoverPath.some((n) => n.id === id)) hoverPath = [];
+			}
+			nodes.set(id, {
+				...prev,
+				...next,
+				rect: next.rect ?? prev.rect,
+				zIndex: next.zIndex ?? prev.zIndex,
+				visible: nextVisible,
+				handlers: next.handlers ?? prev.handlers
+			});
+			const updated = nodes.get(id);
+			if (updated) updateRowBuckets(id, updated);
+		},
+		unregister(id) {
+			if (capturedId === id) capturedId = null;
+			if (hoverPath.some((n) => n.id === id)) hoverPath = [];
+			removeFromRowBuckets(id);
+			nodes.delete(id);
+			if (focusedId === id) setFocus(null);
+		},
+		setMetrics(next) {
+			currentMetrics = next;
+			markContainerRectDirty();
+		},
+		canSelectAt(cellX, cellY) {
+			const list = candidatesAt(cellX, cellY);
+			const target = pickTarget(list);
+			const lockNode = resolveModalLockNode();
+			if (lockNode) {
+				if (!target) return false;
+				if (!isAllowedModalPointerNode(target, target, lockNode)) return false;
+			}
+			return target ? Boolean(target.selectable) : true;
+		},
+		autoScrollSelectionAt(originCellX, originCellY, pointerCellY) {
+			const target = pickTarget(candidatesAt(originCellX, originCellY));
+			if (!target) return 0;
+			const lockNode = resolveModalLockNode();
+			if (lockNode && !isAllowedModalPointerNode(target, target, lockNode)) return 0;
+			const path = ancestorsForTarget(target);
+			let owner = null;
+			for (let i = path.length - 1; i >= 0; i--) {
+				const node = path[i];
+				if (typeof node.selectionScrollBy === "function") {
+					owner = node;
+					break;
+				}
+			}
+			if (!owner) return 0;
+			const rect = owner.rect;
+			const y = Math.floor(pointerCellY);
+			let delta = 0;
+			if (y <= rect.y) delta = -1;
+			else if (y >= rect.y + rect.h - 1) delta = 1;
+			if (!delta) return 0;
+			const scrolled = owner.selectionScrollBy?.(delta);
+			return scrolled === false ? 0 : delta;
+		},
+		focus(id) {
+			setFocus(id);
+		},
+		getFocused() {
+			return focusedId;
+		},
+		debugNodes() {
+			return Array.from(nodes.values()).map((n) => ({
+				id: n.id,
+				rect: n.rect,
+				zIndex: n.zIndex,
+				visible: isVisible(n),
+				focusable: Boolean(n.focusable)
+			}));
+		},
+		attach,
+		dispose() {
+			window.removeEventListener("scroll", markContainerRectDirty, true);
+			window.removeEventListener("resize", markContainerRectDirty);
+			if (!attached) return;
+			attached = false;
+			container.removeEventListener("pointerdown", onPointerDown);
+			container.removeEventListener("pointermove", onPointerMove);
+			container.removeEventListener("pointerup", onPointerUp);
+			container.removeEventListener("mousedown", onMouseDown);
+			container.removeEventListener("mousemove", onMouseMove);
+			container.removeEventListener("mouseup", onMouseUp);
+			container.removeEventListener("mouseleave", onMouseLeave);
+			container.removeEventListener("click", onClick);
+			container.removeEventListener("dblclick", onDblClick);
+			container.removeEventListener("contextmenu", onContextMenu);
+			container.removeEventListener("wheel", onWheel);
+			for (const target of keyboardTargets) {
+				target.removeEventListener("keydown", onKeyDown);
+				target.removeEventListener("keyup", onKeyUp);
+			}
+			for (const target of textTargets) {
+				target.removeEventListener("beforeinput", onBeforeInput);
+				target.removeEventListener("input", onInput);
+				target.removeEventListener("compositionstart", onCompositionStart);
+				target.removeEventListener("compositionupdate", onCompositionUpdate);
+				target.removeEventListener("compositionend", onCompositionEnd);
+				target.removeEventListener("paste", onPaste);
+			}
+			rowBuckets.clear();
+			rowRangeById.clear();
+			nodes.clear();
+			focusedId = null;
+			capturedId = null;
+			hoverPath = [];
+		}
+	};
+}
+
+//#endregion
+//#region src/runtime/index.ts
+function isNodeLike() {
+	const proc = globalThis.process;
+	return typeof proc?.versions?.node === "string";
+}
+function detectEnv() {
+	const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+	if (isBrowser) return "browser";
+	if (isNodeLike()) return "terminal";
+	return "unknown";
+}
+function createUnsupportedClipboard() {
+	return {
+		supported: false,
+		async readText() {
+			throw new Error("Clipboard not available in this runtime");
+		},
+		async writeText() {
+			throw new Error("Clipboard not available in this runtime");
+		}
+	};
+}
+function createClipboard(kind) {
+	if (kind === "browser") {
+		const supported = typeof navigator !== "undefined" && !!navigator.clipboard?.writeText && !!navigator.clipboard?.readText;
+		return {
+			supported,
+			async readText() {
+				if (!supported) throw new Error("Clipboard not available in this runtime");
+				return navigator.clipboard.readText();
+			},
+			async writeText(text) {
+				if (!supported) throw new Error("Clipboard not available in this runtime");
+				await navigator.clipboard.writeText(text);
+			}
+		};
+	}
+	return createUnsupportedClipboard();
+}
+function nowMs() {
+	return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function createRaf(kind, timer) {
+	const g = globalThis;
+	if (kind === "browser" && typeof g.requestAnimationFrame === "function" && typeof g.cancelAnimationFrame === "function") return {
+		request: (cb) => g.requestAnimationFrame(cb),
+		cancel: (id) => g.cancelAnimationFrame(id)
+	};
+	return {
+		request(cb) {
+			return timer.setTimeout(() => cb(nowMs()), 16);
+		},
+		cancel(id) {
+			timer.clearTimeout(id);
+		}
+	};
+}
+function createMeasureText(kind) {
+	if (kind !== "browser") return () => null;
+	return (text, opts) => {
+		try {
+			const doc = typeof document !== "undefined" ? document : null;
+			if (!doc || !("createElement" in doc)) return null;
+			const canvas = doc.createElement("canvas");
+			const ctx = canvas?.getContext?.("2d");
+			if (!ctx) return null;
+			if (opts?.font) ctx.font = opts.font;
+			const m = ctx.measureText(text);
+			return typeof m.width === "number" && Number.isFinite(m.width) ? m.width : null;
+		} catch {
+			return null;
+		}
+	};
+}
+function createRuntime(kind = detectEnv(), options = {}) {
+	const timer = {
+		setTimeout: globalThis.setTimeout.bind(globalThis),
+		clearTimeout: globalThis.clearTimeout.bind(globalThis),
+		setInterval: globalThis.setInterval.bind(globalThis),
+		clearInterval: globalThis.clearInterval.bind(globalThis)
+	};
+	const env = Object.freeze({
+		kind,
+		isBrowser: kind === "browser",
+		isTerminal: kind === "terminal"
+	});
+	return {
+		env,
+		now() {
+			return nowMs();
+		},
+		timer,
+		raf: createRaf(kind, timer),
+		clipboard: options.clipboard ?? createClipboard(kind),
+		getWindow() {
+			return env.isBrowser && typeof window !== "undefined" ? window : null;
+		},
+		getDocument() {
+			return env.isBrowser && typeof document !== "undefined" ? document : null;
+		},
+		measureText: createMeasureText(kind)
+	};
+}
+
+//#endregion
+export { SUPPRESS_TERMINAL_POINTER_DOWN, SUPPRESS_TERMINAL_POINTER_MOVE, SUPPRESS_TERMINAL_POINTER_UP, createEventManager, createRuntime };