@simon_he/vue-tui 0.0.8 → 1.0.0

package/dist/runtime.cjs

@@ -0,0 +1,1698 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  createEventManager: () => createEventManager,
+  createRuntime: () => createRuntime,
+  createTerminalSelectionController: () => createTerminalSelectionController,
+  terminalSelectionRowSpans: () => terminalSelectionRowSpans,
+  terminalSelectionVisibleRowSpans: () => terminalSelectionVisibleRowSpans
+});
+module.exports = __toCommonJS(runtime_exports);
+
+// src/events/manager/selection-suppression.ts
+var SUPPRESS_TERMINAL_POINTER_UP = "__vueTuiSuppressTerminalPointerUp";
+var SUPPRESS_TERMINAL_POINTER_DOWN = "__vueTuiSuppressTerminalPointerDown";
+var SUPPRESS_TERMINAL_POINTER_MOVE = "__vueTuiSuppressTerminalPointerMove";
+
+// 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 };
+}
+var nextId = 0;
+function createEventManager(container, metrics, options) {
+  let currentMetrics = metrics;
+  const nodes = /* @__PURE__ */ new Map();
+  const rowBuckets = /* @__PURE__ */ new Map();
+  const rowRangeById = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 list2 = [];
+      for (const node of nodes.values()) {
+        if (!isVisible(node))
+          continue;
+        if (containsRect(node.rect, target.rect))
+          list2.push(node);
+      }
+      const sorted2 = list2.sort((a, b) => a.zIndex - b.zIndex || area(b.rect) - area(a.rect));
+      return pathOuterToInner(sorted2, 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(nextId2) {
+    const lock = focusLockTarget();
+    if (lock) {
+      if (!nextId2) {
+        nextId2 = lock.id;
+      } else {
+        const want = nodes.get(nextId2) ?? null;
+        const wantZ = want?.zIndex ?? 0;
+        if (want && isVisible(want) && wantZ < lock.zIndex) {
+          return;
+        }
+      }
+    }
+    if (focusedId === nextId2)
+      return;
+    const prev = focusedId ? nodes.get(focusedId) ?? null : null;
+    const nextRaw = nextId2 ? nodes.get(nextId2) ?? 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: cellX2, cellY: cellY2 } = toCell(e.clientX, e.clientY);
+      const list2 = candidatesAt(cellX2, cellY2);
+      const target2 = pickTarget(list2);
+      if (target2?.focusable) {
+        setFocus(target2.id);
+      }
+      capturedId = target2?.id ?? null;
+      updateHover(target2, e);
+      record?.({
+        type: "pointerdown",
+        cellX: cellX2,
+        cellY: cellY2,
+        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 target2 = nodes.get(capturedId) ?? null;
+      if (!target2)
+        return;
+      updateHover(target2, e);
+      const path = ancestorsForTarget(target2);
+      const ev = buildPointerEvent("pointermove", path, e);
+      dispatchWithPhases("pointermove", path, target2, 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 = [];
+    }
+  };
+}
+
+// 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)
+  };
+}
+
+// src/selection/terminal-selection.ts
+var import_vue = require("vue");
+var EMPTY_STATE = Object.freeze({
+  active: false,
+  anchor: null,
+  focus: null,
+  text: "",
+  hasRange: false
+});
+function clampPoint(point, cols, rows) {
+  return {
+    x: Math.max(0, Math.min(Math.max(0, cols - 1), Math.floor(point.x))),
+    y: Math.max(0, Math.min(Math.max(0, rows - 1), Math.floor(point.y)))
+  };
+}
+function comparePoints(a, b) {
+  return a.y - b.y || a.x - b.x;
+}
+function pointKey(point) {
+  return `${point.x}:${point.y}`;
+}
+function providerPointsDiffer(a, b) {
+  return Boolean(
+    a && b && a.providerId === b.providerId && pointKey(a.point) !== pointKey(b.point)
+  );
+}
+function terminalSelectionRowSpans(range, cols, rows) {
+  if (cols <= 0 || rows <= 0)
+    return [];
+  const anchor = clampPoint(range.anchor, cols, rows);
+  const focus = clampPoint(range.focus, cols, rows);
+  if (pointKey(anchor) === pointKey(focus))
+    return [];
+  const start = comparePoints(anchor, focus) <= 0 ? anchor : focus;
+  const end = start === anchor ? focus : anchor;
+  const spans = [];
+  for (let y = start.y; y <= end.y; y++) {
+    const x0 = y === start.y ? start.x : 0;
+    const x1 = y === end.y ? end.x + 1 : cols;
+    if (x1 > x0)
+      spans.push({ y, x0, x1 });
+  }
+  return spans;
+}
+function terminalSelectionVisibleRowSpans(range, cols, rows, visibleStartY, visibleEndY) {
+  if (cols <= 0 || rows <= 0)
+    return [];
+  const anchor = clampPoint(range.anchor, cols, rows);
+  const focus = clampPoint(range.focus, cols, rows);
+  if (pointKey(anchor) === pointKey(focus))
+    return [];
+  const start = comparePoints(anchor, focus) <= 0 ? anchor : focus;
+  const end = start === anchor ? focus : anchor;
+  const fromY = Math.max(start.y, Math.floor(visibleStartY), 0);
+  const toY = Math.min(end.y, Math.ceil(visibleEndY) - 1, rows - 1);
+  if (toY < fromY)
+    return [];
+  const spans = [];
+  for (let y = fromY; y <= toY; y++) {
+    const x0 = y === start.y ? start.x : 0;
+    const x1 = y === end.y ? end.x + 1 : cols;
+    if (x1 > x0)
+      spans.push({ y, x0, x1 });
+  }
+  return spans;
+}
+function selectedRowText(row, x0, x1, cols) {
+  let out = "";
+  for (let x = x0; x < x1; x++) {
+    const cell = row[x];
+    if (!cell || cell.continuation)
+      continue;
+    out += cell.ch || " ";
+  }
+  return x1 >= cols ? out.trimEnd() : out;
+}
+function copyPayload(text, ok, error) {
+  return {
+    text,
+    rows: text ? text.split("\n").length : 0,
+    chars: text.length,
+    ok,
+    ...error === void 0 ? {} : { error }
+  };
+}
+function clampPointToRect(point, rect) {
+  return {
+    x: Math.max(rect.x, Math.min(rect.x + Math.max(0, rect.w - 1), Math.floor(point.x))),
+    y: Math.max(rect.y, Math.min(rect.y + Math.max(0, rect.h - 1), Math.floor(point.y)))
+  };
+}
+function createTerminalSelectionController(options) {
+  const state = (0, import_vue.shallowRef)(EMPTY_STATE);
+  let range = null;
+  let providerAnchor = null;
+  let providerFocus = null;
+  let overlaySpans = /* @__PURE__ */ new Map();
+  let dirtyRows = /* @__PURE__ */ new Set();
+  const readOptions = () => ({
+    autoCopy: true,
+    copyOnMouseUp: true,
+    style: { inverse: true },
+    ...options.getOptions?.() ?? {}
+  });
+  const markDirty = (prev, next) => {
+    const rows = /* @__PURE__ */ new Set();
+    for (const y of prev)
+      rows.add(y);
+    for (const y of next)
+      rows.add(y);
+    if (rows.size)
+      options.onDirtyRows?.(Array.from(rows).sort((a, b) => a - b));
+  };
+  const providers = () => options.getTextProviders?.() ?? [];
+  const getRow = (y) => options.getRow?.(y) ?? options.terminal.getRow(y);
+  const providerById = (id) => providers().find((provider) => provider.id === id) ?? null;
+  const providerForCell = (point) => {
+    let best = null;
+    let bestArea = Infinity;
+    for (const provider of providers()) {
+      const rect = provider.rect;
+      if (point.x < rect.x || point.y < rect.y || point.x >= rect.x + rect.w || point.y >= rect.y + rect.h) {
+        continue;
+      }
+      const area2 = Math.max(0, rect.w) * Math.max(0, rect.h);
+      if (area2 < bestArea) {
+        best = provider;
+        bestArea = area2;
+      }
+    }
+    return best;
+  };
+  const providerPointForCell = (provider, point, options2) => {
+    const inputPoint = options2?.clampToRect ? clampPointToRect(point, provider.rect) : point;
+    const providerPoint = provider.pointForCell?.(inputPoint) ?? inputPoint;
+    return providerPoint ? { providerId: provider.id, point: providerPoint } : null;
+  };
+  const textFromTerminalBuffer = (nextRange) => {
+    const size = options.terminal.size();
+    const spans = terminalSelectionRowSpans(nextRange, size.cols, size.rows);
+    const lines = [];
+    for (const span of spans) {
+      lines.push(selectedRowText(getRow(span.y), span.x0, span.x1, size.cols));
+    }
+    return lines.join("\n");
+  };
+  const providerRangeFor = (provider, screenRange, anchorOverride, focusOverride) => {
+    if (anchorOverride && focusOverride && anchorOverride.providerId === provider.id && focusOverride.providerId === provider.id) {
+      return {
+        anchor: anchorOverride.point,
+        focus: focusOverride.point,
+        mode: screenRange.mode
+      };
+    }
+    const anchor = providerPointForCell(provider, screenRange.anchor, { clampToRect: true });
+    const focus = providerPointForCell(provider, screenRange.focus, { clampToRect: true });
+    if (!anchor || !focus)
+      return null;
+    if (anchor.providerId !== provider.id || focus.providerId !== provider.id)
+      return null;
+    return {
+      anchor: anchor.point,
+      focus: focus.point,
+      mode: screenRange.mode
+    };
+  };
+  const selectedText = () => {
+    if (!range)
+      return "";
+    const currentRange = range;
+    if (providerAnchor && providerFocus && providerAnchor.providerId === providerFocus.providerId) {
+      const provider2 = providerById(providerAnchor.providerId);
+      if (provider2) {
+        const providerRange = providerRangeFor(
+          provider2,
+          currentRange,
+          providerAnchor,
+          providerFocus
+        );
+        if (providerRange)
+          return provider2.getText(providerRange);
+      }
+    }
+    const provider = providers().find((candidate) => candidate.canHandle(currentRange));
+    if (provider) {
+      const providerRange = providerRangeFor(provider, currentRange);
+      if (providerRange)
+        return provider.getText(providerRange);
+    }
+    return textFromTerminalBuffer(currentRange);
+  };
+  const setResolvedText = (text) => {
+    if (!range || !state.value.active || state.value.text === text)
+      return;
+    state.value = { ...state.value, text };
+  };
+  const resolveProvider = (nextRange, nextProviderAnchor) => {
+    if (!nextRange)
+      return null;
+    if (nextProviderAnchor) {
+      const provider = providerById(nextProviderAnchor.providerId);
+      if (provider)
+        return provider;
+    }
+    return providers().find((candidate) => candidate.canHandle(nextRange)) ?? null;
+  };
+  const rebuild = (nextRange, nextProviderAnchor, nextProviderFocus) => {
+    const previousRows = dirtyRows;
+    const size = options.terminal.size();
+    const nextOverlaySpans = /* @__PURE__ */ new Map();
+    const nextDirtyRows = /* @__PURE__ */ new Set();
+    let hasRange = false;
+    if (nextRange) {
+      const activeProvider = resolveProvider(nextRange, nextProviderAnchor);
+      let spans;
+      const providerRange = activeProvider != null ? providerRangeFor(activeProvider, nextRange, nextProviderAnchor, nextProviderFocus) : null;
+      if (activeProvider?.getVisibleSpans && providerRange) {
+        spans = activeProvider.getVisibleSpans(providerRange, nextRange);
+      } else {
+        spans = terminalSelectionRowSpans(nextRange, size.cols, size.rows);
+      }
+      hasRange = spans.length > 0 || providerPointsDiffer(nextProviderAnchor, nextProviderFocus);
+      for (const span of spans) {
+        const x0 = Math.max(0, Math.min(size.cols, Math.floor(span.x0)));
+        const x1 = Math.max(0, Math.min(size.cols, Math.floor(span.x1)));
+        const y = Math.floor(span.y);
+        if (y < 0 || y >= size.rows || x1 <= x0)
+          continue;
+        let list = nextOverlaySpans.get(y);
+        if (!list) {
+          list = [];
+          nextOverlaySpans.set(y, list);
+        }
+        list.push({ y, x0, x1 });
+        nextDirtyRows.add(y);
+      }
+    }
+    range = nextRange;
+    providerAnchor = nextProviderAnchor;
+    providerFocus = nextProviderFocus;
+    overlaySpans = nextOverlaySpans;
+    dirtyRows = nextDirtyRows;
+    state.value = nextRange ? {
+      active: true,
+      anchor: nextRange.anchor,
+      focus: nextRange.focus,
+      text: "",
+      hasRange
+    } : EMPTY_STATE;
+    markDirty(previousRows, nextDirtyRows);
+  };
+  const controller = {
+    state,
+    start(point, startOptions) {
+      const size = options.terminal.size();
+      const focus = clampPoint(point, size.cols, size.rows);
+      const anchor = startOptions?.extend && range?.anchor ? clampPoint(range.anchor, size.cols, size.rows) : focus;
+      const anchorProvider = providerForCell(anchor);
+      const focusProvider = providerForCell(focus);
+      const activeProvider = startOptions?.extend && providerAnchor ? providerById(providerAnchor.providerId) : null;
+      const nextProviderAnchor = startOptions?.extend && providerAnchor ? providerAnchor : anchorProvider ? providerPointForCell(anchorProvider, anchor) : null;
+      const nextProviderFocus = activeProvider ? providerPointForCell(activeProvider, focus, { clampToRect: true }) : nextProviderAnchor && focusProvider?.id === nextProviderAnchor.providerId ? providerPointForCell(focusProvider, focus) : null;
+      rebuild({ anchor, focus, mode: "linear" }, nextProviderAnchor, nextProviderFocus);
+    },
+    update(point) {
+      if (!range)
+        return;
+      const size = options.terminal.size();
+      const focus = clampPoint(point, size.cols, size.rows);
+      const activeProvider = providerAnchor ? providerById(providerAnchor.providerId) : null;
+      const nextProviderFocus = activeProvider ? providerPointForCell(activeProvider, focus, { clampToRect: true }) : null;
+      rebuild(
+        {
+          ...range,
+          focus
+        },
+        providerAnchor,
+        nextProviderFocus
+      );
+    },
+    async finish() {
+      if (!range)
+        return;
+      if (!state.value.hasRange) {
+        controller.clear();
+        return;
+      }
+      const current = readOptions();
+      if (!current.autoCopy || !current.copyOnMouseUp) {
+        return;
+      }
+      await controller.copy();
+    },
+    clear() {
+      if (!range && !dirtyRows.size)
+        return;
+      rebuild(null, null, null);
+    },
+    async copy() {
+      const text = state.value.text || selectedText();
+      if (!text)
+        return false;
+      setResolvedText(text);
+      if (!options.clipboard.supported) {
+        options.onCopy?.(copyPayload(text, false, new Error("Clipboard unavailable")));
+        return false;
+      }
+      try {
+        await options.clipboard.writeText(text);
+        options.onCopy?.(copyPayload(text, true));
+        return true;
+      } catch (error) {
+        options.onCopy?.(copyPayload(text, false, error));
+        return false;
+      }
+    },
+    paint(dirtyRowsHint) {
+      const rows = dirtyRowsHint ?? Array.from(overlaySpans.keys());
+      const selectionStyle = readOptions().style;
+      for (const y of rows) {
+        const spans = overlaySpans.get(y);
+        if (!spans?.length)
+          continue;
+        const row = getRow(y);
+        for (const span of spans) {
+          for (let x = span.x0; x < span.x1; x++) {
+            const cell = row[x];
+            if (!cell || cell.continuation)
+              continue;
+            const { href: _href, ...baseStyle } = cell.style;
+            options.overlayTerminal.put(x, y, cell.ch || " ", {
+              ...baseStyle,
+              ...selectionStyle
+            });
+          }
+        }
+      }
+    },
+    refresh(refreshOptions) {
+      if (!range)
+        return;
+      if (refreshOptions?.remapFocus) {
+        const activeProvider = providerAnchor ? providerById(providerAnchor.providerId) : resolveProvider(range, null);
+        const nextProviderFocus = activeProvider ? providerPointForCell(activeProvider, range.focus, { clampToRect: true }) : providerFocus;
+        rebuild(range, providerAnchor, nextProviderFocus);
+        return;
+      }
+      rebuild(range, providerAnchor, providerFocus);
+    },
+    clearProvider(providerId) {
+      if (providerAnchor?.providerId === providerId || providerFocus?.providerId === providerId) {
+        controller.clear();
+      }
+    }
+  };
+  return controller;
+}