@prosekit/web 0.5.7 → 0.5.9

package/dist/prosekit-web-table-handle.js

@@ -1,542 +1,415 @@
-import {
-  getStateWithDefaults
-} from "./chunk-ZGQ225UP.js";
-import {
-  useEditorExtension
-} from "./chunk-WTW6FOH3.js";
-
-// src/components/table-handle/table-handle-column-root/element.gen.ts
-import { defineCustomElement, registerCustomElement } from "@aria-ui/core";
-
-// src/components/table-handle/table-handle-column-root/setup.ts
-import {
-  createComputed,
-  createSignal,
-  useAttribute,
-  useEffect
-} from "@aria-ui/core";
-import {
-  menuRootProps,
-  useMenuRoot
-} from "@aria-ui/menu/elements";
+import { getStateWithDefaults } from "./get-default-state-CIEy7xrl.js";
+import { useEditorExtension } from "./use-editor-extension-Cc7ZG7uj.js";
+import { createComputed, createContext, createSignal, defineCustomElement, defineEmit, registerCustomElement, useAttribute, useEffect, useEventListener } from "@aria-ui/core";
+import { defineDOMEventHandler, union } from "@prosekit/core";
 import { useOverlayPositionerState } from "@aria-ui/overlay/elements";
 import { usePresence } from "@aria-ui/presence";
-
-// src/components/table-handle/context.ts
-import { createContext } from "@aria-ui/core";
-var tableHandleRootContext = createContext(
-  "prosekit-table-handle-root-context",
-  null
-);
-
-// src/components/table-handle/table-handle-column-root/setup.ts
+import { overlayPositionerEvents as overlayPositionerEvents$1, overlayPositionerProps as overlayPositionerProps$1 } from "@aria-ui/overlay";
+import { menuContentEvents, menuContentProps, menuRootEvents, menuRootProps, useMenuContent, useMenuItem, useMenuRoot, useMenuTrigger } from "@aria-ui/menu/elements";
+import { selectTableColumn, selectTableRow } from "@prosekit/extensions/table";
+import { menuItemEvents, menuItemProps } from "@aria-ui/menu";
+import { TableMap, cellAround } from "prosemirror-tables";
+
+//#region src/components/table-handle/context.ts
+/**
+* @internal
+*/
+const tableHandleRootContext = createContext("prosekit-table-handle-root-context", null);
+
+//#endregion
+//#region src/components/table-handle/table-handle-column-root/setup.ts
 function useTableHandleColumnRoot(host, { state }) {
-  const { editor, ...overlayState } = state;
-  const rootContext = tableHandleRootContext.consume(host);
-  const colFirstCellPos = createComputed(() => {
-    return rootContext.get()?.colFirstCellPos;
-  });
-  const referenceCell = createComputed(() => {
-    const pos = colFirstCellPos.get();
-    const view = editor.get()?.view;
-    if (!pos || !view) return null;
-    return view.nodeDOM(pos);
-  });
-  const contentOpen = createSignal(false);
-  useEffect(host, () => {
-    colFirstCellPos.get();
-    contentOpen.set(false);
-  });
-  useOverlayPositionerState(host, overlayState, {
-    reference: referenceCell
-  });
-  const presence = createComputed(() => !!referenceCell.get());
-  useAttribute(host, "data-state", () => presence.get() ? "open" : "closed");
-  usePresence(host, presence);
-  const menuRootState = getStateWithDefaults(
-    { open: contentOpen },
-    menuRootProps
-  );
-  useMenuRoot(host, {
-    state: menuRootState,
-    emit: () => void 0
-  });
+	const { editor,...overlayState } = state;
+	const rootContext = tableHandleRootContext.consume(host);
+	const colFirstCellPos = createComputed(() => {
+		return rootContext.get()?.colFirstCellPos;
+	});
+	const referenceCell = createComputed(() => {
+		const pos = colFirstCellPos.get();
+		const view = editor.get()?.view;
+		if (!pos || !view) return null;
+		return view.nodeDOM(pos);
+	});
+	const contentOpen = createSignal(false);
+	useEffect(host, () => {
+		colFirstCellPos.get();
+		contentOpen.set(false);
+	});
+	useOverlayPositionerState(host, overlayState, { reference: referenceCell });
+	const presence = createComputed(() => !!referenceCell.get());
+	useAttribute(host, "data-state", () => presence.get() ? "open" : "closed");
+	usePresence(host, presence);
+	const menuRootState = getStateWithDefaults({ open: contentOpen }, menuRootProps);
+	useMenuRoot(host, {
+		state: menuRootState,
+		emit: () => void 0
+	});
 }
 
-// src/components/table-handle/table-handle-column-root/types.ts
-import {
-  overlayPositionerEvents,
-  overlayPositionerProps
-} from "@aria-ui/overlay";
-var tableHandleColumnRootProps = Object.freeze({
-  ...overlayPositionerProps,
-  editor: { default: null },
-  placement: { default: "top" }
+//#endregion
+//#region src/components/table-handle/table-handle-column-root/types.ts
+/** @internal */
+const tableHandleColumnRootProps = Object.freeze({
+	...overlayPositionerProps$1,
+	editor: { default: null },
+	placement: { default: "top" }
 });
-var tableHandleColumnRootEvents = overlayPositionerEvents;
-
-// src/components/table-handle/table-handle-column-root/element.gen.ts
-var TableHandleColumnRootElement = class extends defineCustomElement({
-  props: tableHandleColumnRootProps,
-  events: tableHandleColumnRootEvents,
-  setup: useTableHandleColumnRoot
-}) {
-};
+/** @internal */
+const tableHandleColumnRootEvents = overlayPositionerEvents$1;
+
+//#endregion
+//#region src/components/table-handle/table-handle-column-root/element.gen.ts
+const TableHandleColumnRootElementBase = defineCustomElement({
+	props: tableHandleColumnRootProps,
+	events: tableHandleColumnRootEvents,
+	setup: useTableHandleColumnRoot
+});
+var TableHandleColumnRootElement = class extends TableHandleColumnRootElementBase {};
 registerCustomElement("prosekit-table-handle-column-root", TableHandleColumnRootElement);
 
-// src/components/table-handle/table-handle-column-trigger/element.gen.ts
-import { defineCustomElement as defineCustomElement2, registerCustomElement as registerCustomElement2 } from "@aria-ui/core";
-
-// src/components/table-handle/table-handle-column-trigger/setup.ts
-import {
-  useEventListener
-} from "@aria-ui/core";
-import { useMenuTrigger } from "@aria-ui/menu/elements";
-import { selectTableColumn } from "@prosekit/extensions/table";
+//#endregion
+//#region src/components/table-handle/table-handle-column-trigger/setup.ts
 function useTableHandleColumnTrigger(host, { state }) {
-  useMenuTrigger(host);
-  const context = tableHandleRootContext.consume(host);
-  useEventListener(host, "pointerdown", () => {
-    const editor = state.editor.peek();
-    const cellPos = context.peek()?.cellPos;
-    if (!editor || !cellPos) return;
-    editor.exec(selectTableColumn({ head: cellPos }));
-  });
+	useMenuTrigger(host);
+	const context = tableHandleRootContext.consume(host);
+	useEventListener(host, "pointerdown", () => {
+		const editor = state.editor.peek();
+		const cellPos = context.peek()?.cellPos;
+		if (!editor || !cellPos) return;
+		editor.exec(selectTableColumn({ head: cellPos }));
+	});
 }
 
-// src/components/table-handle/table-handle-column-trigger/types.ts
-var tableHandleColumnTriggerProps = {
-  editor: { default: null }
-};
-var tableHandleColumnTriggerEvents = {};
-
-// src/components/table-handle/table-handle-column-trigger/element.gen.ts
-var TableHandleColumnTriggerElement = class extends defineCustomElement2({
-  props: tableHandleColumnTriggerProps,
-  events: tableHandleColumnTriggerEvents,
-  setup: useTableHandleColumnTrigger
-}) {
-};
-registerCustomElement2("prosekit-table-handle-column-trigger", TableHandleColumnTriggerElement);
-
-// src/components/table-handle/table-handle-popover-content/element.gen.ts
-import { defineCustomElement as defineCustomElement3, registerCustomElement as registerCustomElement3 } from "@aria-ui/core";
-
-// src/components/table-handle/table-handle-popover-content/setup.ts
-import {
-  createComputed as createComputed2,
-  createSignal as createSignal2,
-  useEffect as useEffect2
-} from "@aria-ui/core";
-import {
-  menuContentProps,
-  useMenuContent
-} from "@aria-ui/menu/elements";
-function useTableHandlePopoverContent(host, {
-  state,
-  emit
-}) {
-  const rootContext = tableHandleRootContext.consume(host);
-  const open = createComputed2(() => !!rootContext.get());
-  const keyDownTarget = useKeyDownTarget(host, open);
-  const menuContentState = getStateWithDefaults(
-    {
-      placement: state.placement,
-      offset: state.offset,
-      eventTarget: createSignal2(keyDownTarget)
-    },
-    menuContentProps
-  );
-  useMenuContent(host, { state: menuContentState, emit });
+//#endregion
+//#region src/components/table-handle/table-handle-column-trigger/types.ts
+/** @internal */
+const tableHandleColumnTriggerProps = { editor: { default: null } };
+/** @internal */
+const tableHandleColumnTriggerEvents = {};
+
+//#endregion
+//#region src/components/table-handle/table-handle-column-trigger/element.gen.ts
+const TableHandleColumnTriggerElementBase = defineCustomElement({
+	props: tableHandleColumnTriggerProps,
+	events: tableHandleColumnTriggerEvents,
+	setup: useTableHandleColumnTrigger
+});
+var TableHandleColumnTriggerElement = class extends TableHandleColumnTriggerElementBase {};
+registerCustomElement("prosekit-table-handle-column-trigger", TableHandleColumnTriggerElement);
+
+//#endregion
+//#region src/components/table-handle/table-handle-popover-content/setup.ts
+function useTableHandlePopoverContent(host, { state, emit }) {
+	const rootContext = tableHandleRootContext.consume(host);
+	const open = createComputed(() => !!rootContext.get());
+	const keyDownTarget = useKeyDownTarget(host, open);
+	const menuContentState = getStateWithDefaults({
+		placement: state.placement,
+		offset: state.offset,
+		eventTarget: createSignal(keyDownTarget)
+	}, menuContentProps);
+	useMenuContent(host, {
+		state: menuContentState,
+		emit
+	});
 }
 function useKeyDownTarget(element, open) {
-  const keydownHandlers = [];
-  useEffect2(element, () => {
-    const handleKeydown = (event) => {
-      if (event.isComposing || event.defaultPrevented || !open.get()) {
-        return false;
-      }
-      keydownHandlers.forEach((handler) => handler(event));
-    };
-    document.addEventListener("keydown", handleKeydown);
-    return () => {
-      document.removeEventListener("keydown", handleKeydown);
-    };
-  });
-  return {
-    addEventListener: (type, listener) => {
-      if (type === "keydown") {
-        keydownHandlers.push(listener);
-      }
-    },
-    removeEventListener: (type, listener) => {
-      if (type === "keydown") {
-        const index = keydownHandlers.indexOf(listener);
-        if (index !== -1) {
-          keydownHandlers.splice(index, 1);
-        }
-      }
-    }
-  };
+	const keydownHandlers = [];
+	useEffect(element, () => {
+		const handleKeydown = (event) => {
+			if (event.isComposing || event.defaultPrevented || !open.get()) return false;
+			keydownHandlers.forEach((handler) => handler(event));
+		};
+		document.addEventListener("keydown", handleKeydown);
+		return () => {
+			document.removeEventListener("keydown", handleKeydown);
+		};
+	});
+	return {
+		addEventListener: (type, listener) => {
+			if (type === "keydown") keydownHandlers.push(listener);
+		},
+		removeEventListener: (type, listener) => {
+			if (type === "keydown") {
+				const index = keydownHandlers.indexOf(listener);
+				if (index !== -1) keydownHandlers.splice(index, 1);
+			}
+		}
+	};
 }
 
-// src/components/table-handle/table-handle-popover-content/types.ts
-import {
-  menuContentEvents,
-  menuContentProps as menuContentProps2
-} from "@aria-ui/menu/elements";
-var tableHandlePopoverContentProps = Object.freeze({
-  ...menuContentProps2,
-  placement: { default: "right-start" },
-  offset: { default: { mainAxis: -4, crossAxis: 4 } },
-  editor: { default: null }
+//#endregion
+//#region src/components/table-handle/table-handle-popover-content/types.ts
+/** @internal */
+const tableHandlePopoverContentProps = Object.freeze({
+	...menuContentProps,
+	placement: { default: "right-start" },
+	offset: { default: {
+		mainAxis: -4,
+		crossAxis: 4
+	} },
+	editor: { default: null }
 });
-var tableHandlePopoverContentEvents = Object.freeze({
-  ...menuContentEvents
+/** @internal */
+const tableHandlePopoverContentEvents = Object.freeze({ ...menuContentEvents });
+
+//#endregion
+//#region src/components/table-handle/table-handle-popover-content/element.gen.ts
+const TableHandlePopoverContentElementBase = defineCustomElement({
+	props: tableHandlePopoverContentProps,
+	events: tableHandlePopoverContentEvents,
+	setup: useTableHandlePopoverContent
 });
-
-// src/components/table-handle/table-handle-popover-content/element.gen.ts
-var TableHandlePopoverContentElement = class extends defineCustomElement3({
-  props: tableHandlePopoverContentProps,
-  events: tableHandlePopoverContentEvents,
-  setup: useTableHandlePopoverContent
-}) {
-};
-registerCustomElement3("prosekit-table-handle-popover-content", TableHandlePopoverContentElement);
-
-// src/components/table-handle/table-handle-popover-item/element.gen.ts
-import { defineCustomElement as defineCustomElement4, registerCustomElement as registerCustomElement4 } from "@aria-ui/core";
-
-// src/components/table-handle/table-handle-popover-item/setup.ts
-import "@aria-ui/core";
-import { useMenuItem } from "@aria-ui/menu/elements";
-function useTableHandlePopoverItem(element, {
-  state,
-  emit
-}) {
-  useMenuItem(element, { state, emit });
+var TableHandlePopoverContentElement = class extends TableHandlePopoverContentElementBase {};
+registerCustomElement("prosekit-table-handle-popover-content", TableHandlePopoverContentElement);
+
+//#endregion
+//#region src/components/table-handle/table-handle-popover-item/setup.ts
+function useTableHandlePopoverItem(element, { state, emit }) {
+	useMenuItem(element, {
+		state,
+		emit
+	});
 }
 
-// src/components/table-handle/table-handle-popover-item/types.ts
-import {
-  menuItemEvents,
-  menuItemProps
-} from "@aria-ui/menu";
-var tableHandlePopoverItemProps = {
-  ...menuItemProps
-};
-var tableHandlePopoverItemEvents = {
-  ...menuItemEvents
-};
-
-// src/components/table-handle/table-handle-popover-item/element.gen.ts
-var TableHandlePopoverItemElement = class extends defineCustomElement4({
-  props: tableHandlePopoverItemProps,
-  events: tableHandlePopoverItemEvents,
-  setup: useTableHandlePopoverItem
-}) {
-};
-registerCustomElement4("prosekit-table-handle-popover-item", TableHandlePopoverItemElement);
-
-// src/components/table-handle/table-handle-root/element.gen.ts
-import { defineCustomElement as defineCustomElement5, registerCustomElement as registerCustomElement5 } from "@aria-ui/core";
-
-// src/components/table-handle/table-handle-root/setup.ts
-import {
-  createComputed as createComputed3,
-  createSignal as createSignal4,
-  useEffect as useEffect3
-} from "@aria-ui/core";
-import {
-  defineDOMEventHandler as defineDOMEventHandler2
-} from "@prosekit/core";
+//#endregion
+//#region src/components/table-handle/table-handle-popover-item/types.ts
+/** @internal */
+const tableHandlePopoverItemProps = { ...menuItemProps };
+/** @internal */
+const tableHandlePopoverItemEvents = { ...menuItemEvents };
+
+//#endregion
+//#region src/components/table-handle/table-handle-popover-item/element.gen.ts
+const TableHandlePopoverItemElementBase = defineCustomElement({
+	props: tableHandlePopoverItemProps,
+	events: tableHandlePopoverItemEvents,
+	setup: useTableHandlePopoverItem
+});
+var TableHandlePopoverItemElement = class extends TableHandlePopoverItemElementBase {};
+registerCustomElement("prosekit-table-handle-popover-item", TableHandlePopoverItemElement);
 
-// src/hooks/use-editor-typing.ts
-import {
-  createSignal as createSignal3
-} from "@aria-ui/core";
-import {
-  defineDOMEventHandler,
-  union
-} from "@prosekit/core";
+//#endregion
+//#region src/hooks/use-editor-typing.ts
 function useEditorTyping(host, editor) {
-  const typing = createSignal3(false);
-  const handleKeypress = () => {
-    typing.set(true);
-  };
-  const handlePointerMove = () => {
-    typing.set(false);
-  };
-  const extension = union(
-    defineDOMEventHandler("keypress", handleKeypress),
-    defineDOMEventHandler("pointermove", handlePointerMove)
-  );
-  useEditorExtension(host, editor, extension);
-  return typing;
+	const typing = createSignal(false);
+	const handleKeypress = () => {
+		typing.set(true);
+	};
+	const handlePointerMove = () => {
+		typing.set(false);
+	};
+	const extension = union(defineDOMEventHandler("keypress", handleKeypress), defineDOMEventHandler("pointermove", handlePointerMove));
+	useEditorExtension(host, editor, extension);
+	return typing;
 }
 
-// src/components/table-handle/utils.ts
-import {
-  cellAround,
-  TableMap
-} from "prosemirror-tables";
+//#endregion
+//#region src/components/table-handle/utils.ts
 function isHoveringCellInfoEqual(a, b) {
-  if (!a && !b) return true;
-  if (!a || !b) return false;
-  return a.rowIndex === b.rowIndex && a.colIndex === b.colIndex && a.cellPos === b.cellPos && a.rowFirstCellPos === b.rowFirstCellPos && a.colFirstCellPos === b.colFirstCellPos;
+	if (!a && !b) return true;
+	if (!a || !b) return false;
+	return a.rowIndex === b.rowIndex && a.colIndex === b.colIndex && a.cellPos === b.cellPos && a.rowFirstCellPos === b.rowFirstCellPos && a.colFirstCellPos === b.colFirstCellPos;
 }
+/**
+* Copied from https://github.com/ProseMirror/prosemirror-tables/blob/v1.5.0/src/columnresizing.ts#L256
+*
+* @internal
+*/
 function domCellAround(target) {
-  while (target && target.nodeName != "TD" && target.nodeName != "TH") {
-    target = target.classList?.contains("ProseMirror") ? null : target.parentNode;
-  }
-  return target;
+	while (target && target.nodeName != "TD" && target.nodeName != "TH") target = target.classList?.contains("ProseMirror") ? null : target.parentNode;
+	return target;
 }
 function getHoveringCell(view, event) {
-  const domCell = domCellAround(event.target);
-  if (!domCell) return;
-  const { left, top, width, height } = domCell.getBoundingClientRect();
-  const eventPos = view.posAtCoords({
-    // Use the center coordinates of the cell to ensure we're within the
-    // selected cell. This prevents potential issues when the mouse is on the
-    // border of two cells.
-    left: left + width / 2,
-    top: top + height / 2
-  });
-  if (!eventPos) return;
-  const $cellPos = cellAround(view.state.doc.resolve(eventPos.pos));
-  if (!$cellPos) return;
-  const map = TableMap.get($cellPos.node(-1));
-  const tableStart = $cellPos.start(-1);
-  const cellRect = map.findCell($cellPos.pos - tableStart);
-  const rowIndex = cellRect.top;
-  const colIndex = cellRect.left;
-  return {
-    rowIndex,
-    colIndex,
-    cellPos: $cellPos.pos,
-    rowFirstCellPos: getCellPos(map, tableStart, rowIndex, 0),
-    colFirstCellPos: getCellPos(map, tableStart, 0, colIndex)
-  };
+	const domCell = domCellAround(event.target);
+	if (!domCell) return;
+	const { left, top, width, height } = domCell.getBoundingClientRect();
+	const eventPos = view.posAtCoords({
+		left: left + width / 2,
+		top: top + height / 2
+	});
+	if (!eventPos) return;
+	const $cellPos = cellAround(view.state.doc.resolve(eventPos.pos));
+	if (!$cellPos) return;
+	const map = TableMap.get($cellPos.node(-1));
+	const tableStart = $cellPos.start(-1);
+	const cellRect = map.findCell($cellPos.pos - tableStart);
+	const rowIndex = cellRect.top;
+	const colIndex = cellRect.left;
+	return {
+		rowIndex,
+		colIndex,
+		cellPos: $cellPos.pos,
+		rowFirstCellPos: getCellPos(map, tableStart, rowIndex, 0),
+		colFirstCellPos: getCellPos(map, tableStart, 0, colIndex)
+	};
 }
 function getCellPos(map, tableStart, rowIndex, colIndex) {
-  const cellIndex = getCellIndex(map, rowIndex, colIndex);
-  const posInTable = map.map[cellIndex];
-  return tableStart + posInTable;
+	const cellIndex = getCellIndex(map, rowIndex, colIndex);
+	const posInTable = map.map[cellIndex];
+	return tableStart + posInTable;
 }
 function getCellIndex(map, rowIndex, colIndex) {
-  return map.width * rowIndex + colIndex;
+	return map.width * rowIndex + colIndex;
 }
 
-// src/components/table-handle/table-handle-root/setup.ts
+//#endregion
+//#region src/components/table-handle/table-handle-root/setup.ts
 function useTableHandleRoot(host, { state }) {
-  const { editor } = state;
-  const context = createSignal4(null);
-  const hoveringCell = useHoveringCell(host, editor);
-  const typing = useEditorTyping(host, editor);
-  const isInTable = createComputed3(() => !!hoveringCell.get());
-  const selecting = useSelecting(host, editor, isInTable);
-  useEffect3(host, () => {
-    const typingValue = typing.get();
-    const selectingValue = selecting.get();
-    const hoveringCellValue = hoveringCell.get();
-    context.set(typingValue || selectingValue ? null : hoveringCellValue);
-  });
-  tableHandleRootContext.provide(host, context);
+	const { editor } = state;
+	const context = createSignal(null);
+	const hoveringCell = useHoveringCell(host, editor);
+	const typing = useEditorTyping(host, editor);
+	const isInTable = createComputed(() => !!hoveringCell.get());
+	const selecting = useSelecting(host, editor, isInTable);
+	useEffect(host, () => {
+		const typingValue = typing.get();
+		const selectingValue = selecting.get();
+		const hoveringCellValue = hoveringCell.get();
+		context.set(typingValue || selectingValue ? null : hoveringCellValue);
+	});
+	tableHandleRootContext.provide(host, context);
 }
 function useHoveringCell(host, editor) {
-  const hoveringCell = createSignal4(null);
-  const extension = defineCellHoverHandler((curr) => {
-    const prev = hoveringCell.peek();
-    if (!isHoveringCellInfoEqual(prev, curr)) {
-      hoveringCell.set(curr);
-    }
-  });
-  useEditorExtension(host, editor, extension);
-  return hoveringCell;
+	const hoveringCell = createSignal(null);
+	const extension = defineCellHoverHandler((curr) => {
+		const prev = hoveringCell.peek();
+		if (!isHoveringCellInfoEqual(prev, curr)) hoveringCell.set(curr);
+	});
+	useEditorExtension(host, editor, extension);
+	return hoveringCell;
 }
 function defineCellHoverHandler(handler) {
-  const pointerHandler = (view, event) => {
-    const hoveringCell = getHoveringCell(view, event);
-    return handler(hoveringCell ?? null);
-  };
-  return defineDOMEventHandler2("pointerover", pointerHandler);
+	const pointerHandler = (view, event) => {
+		const hoveringCell = getHoveringCell(view, event);
+		return handler(hoveringCell ?? null);
+	};
+	return defineDOMEventHandler("pointerover", pointerHandler);
 }
+/**
+* Detect if the user is selecting text by dragging.
+*/
 function useSelecting(host, editor, isInTable) {
-  const selecting = createSignal4(false);
-  useEffect3(host, () => {
-    if (!isInTable.get()) {
-      return;
-    }
-    const root = editor.peek()?.view.root;
-    if (!root) {
-      return;
-    }
-    const pointerDownHandler = (event) => {
-      const target = event.target;
-      if (!target || host.contains(event.target)) {
-        return;
-      }
-      selecting.set(true);
-    };
-    const pointerUpHandler = () => {
-      selecting.set(false);
-    };
-    root.addEventListener("pointerdown", pointerDownHandler);
-    root.addEventListener("pointerup", pointerUpHandler);
-    return () => {
-      root.removeEventListener("pointerdown", pointerDownHandler);
-      root.removeEventListener("pointerup", pointerUpHandler);
-    };
-  });
-  return selecting;
+	const selecting = createSignal(false);
+	useEffect(host, () => {
+		if (!isInTable.get()) return;
+		const root = editor.peek()?.view.root;
+		if (!root) return;
+		const pointerDownHandler = (event) => {
+			const target = event.target;
+			if (!target || host.contains(event.target)) return;
+			selecting.set(true);
+		};
+		const pointerUpHandler = () => {
+			selecting.set(false);
+		};
+		root.addEventListener("pointerdown", pointerDownHandler);
+		root.addEventListener("pointerup", pointerUpHandler);
+		return () => {
+			root.removeEventListener("pointerdown", pointerDownHandler);
+			root.removeEventListener("pointerup", pointerUpHandler);
+		};
+	});
+	return selecting;
 }
 
-// src/components/table-handle/table-handle-root/types.ts
-var tableHandleRootProps = {
-  editor: { default: null }
-};
-var tableHandleRootEvents = {};
-
-// src/components/table-handle/table-handle-root/element.gen.ts
-var TableHandleRootElement = class extends defineCustomElement5({
-  props: tableHandleRootProps,
-  events: tableHandleRootEvents,
-  setup: useTableHandleRoot
-}) {
-};
-registerCustomElement5("prosekit-table-handle-root", TableHandleRootElement);
-
-// src/components/table-handle/table-handle-row-root/element.gen.ts
-import { defineCustomElement as defineCustomElement6, registerCustomElement as registerCustomElement6 } from "@aria-ui/core";
+//#endregion
+//#region src/components/table-handle/table-handle-root/types.ts
+/** @internal */
+const tableHandleRootProps = { editor: { default: null } };
+/** @internal */
+const tableHandleRootEvents = {};
+
+//#endregion
+//#region src/components/table-handle/table-handle-root/element.gen.ts
+const TableHandleRootElementBase = defineCustomElement({
+	props: tableHandleRootProps,
+	events: tableHandleRootEvents,
+	setup: useTableHandleRoot
+});
+var TableHandleRootElement = class extends TableHandleRootElementBase {};
+registerCustomElement("prosekit-table-handle-root", TableHandleRootElement);
 
-// src/components/table-handle/table-handle-row-root/setup.ts
-import {
-  createComputed as createComputed4,
-  createSignal as createSignal5,
-  defineEmit,
-  useAttribute as useAttribute2,
-  useEffect as useEffect4
-} from "@aria-ui/core";
-import {
-  menuRootEvents,
-  menuRootProps as menuRootProps2,
-  useMenuRoot as useMenuRoot2
-} from "@aria-ui/menu/elements";
-import { useOverlayPositionerState as useOverlayPositionerState2 } from "@aria-ui/overlay/elements";
-import { usePresence as usePresence2 } from "@aria-ui/presence";
+//#endregion
+//#region src/components/table-handle/table-handle-row-root/setup.ts
 function useTableHandleRowRoot(host, { state }) {
-  const { editor, ...overlayState } = state;
-  const rootContext = tableHandleRootContext.consume(host);
-  const rowFirstCellPos = createComputed4(() => {
-    return rootContext.get()?.rowFirstCellPos;
-  });
-  const referenceCell = createComputed4(() => {
-    const pos = rowFirstCellPos.get();
-    const view = editor.get()?.view;
-    if (!pos || !view) return null;
-    return view.nodeDOM(pos);
-  });
-  const contentOpen = createSignal5(false);
-  useEffect4(host, () => {
-    rowFirstCellPos.get();
-    contentOpen.set(false);
-  });
-  useOverlayPositionerState2(host, overlayState, {
-    reference: referenceCell
-  });
-  const presence = createComputed4(() => !!referenceCell.get());
-  useAttribute2(host, "data-state", () => presence.get() ? "open" : "closed");
-  usePresence2(host, presence);
-  const menuRootState = getStateWithDefaults(
-    {
-      open: contentOpen
-    },
-    menuRootProps2
-  );
-  useMenuRoot2(host, {
-    state: menuRootState,
-    emit: defineEmit(host, menuRootEvents)
-  });
+	const { editor,...overlayState } = state;
+	const rootContext = tableHandleRootContext.consume(host);
+	const rowFirstCellPos = createComputed(() => {
+		return rootContext.get()?.rowFirstCellPos;
+	});
+	const referenceCell = createComputed(() => {
+		const pos = rowFirstCellPos.get();
+		const view = editor.get()?.view;
+		if (!pos || !view) return null;
+		return view.nodeDOM(pos);
+	});
+	const contentOpen = createSignal(false);
+	useEffect(host, () => {
+		rowFirstCellPos.get();
+		contentOpen.set(false);
+	});
+	useOverlayPositionerState(host, overlayState, { reference: referenceCell });
+	const presence = createComputed(() => !!referenceCell.get());
+	useAttribute(host, "data-state", () => presence.get() ? "open" : "closed");
+	usePresence(host, presence);
+	const menuRootState = getStateWithDefaults({ open: contentOpen }, menuRootProps);
+	useMenuRoot(host, {
+		state: menuRootState,
+		emit: defineEmit(host, menuRootEvents)
+	});
 }
 
-// src/components/table-handle/table-handle-row-root/types.ts
-import {
-  overlayPositionerProps as overlayPositionerProps2
-} from "@aria-ui/overlay";
-var tableHandleRowRootProps = {
-  ...overlayPositionerProps2,
-  editor: { default: null },
-  placement: { default: "left" }
+//#endregion
+//#region src/components/table-handle/table-handle-row-root/types.ts
+/** @internal */
+const tableHandleRowRootProps = {
+	...overlayPositionerProps$1,
+	editor: { default: null },
+	placement: { default: "left" }
 };
-var tableHandleRowRootEvents = {};
-
-// src/components/table-handle/table-handle-row-root/element.gen.ts
-var TableHandleRowRootElement = class extends defineCustomElement6({
-  props: tableHandleRowRootProps,
-  events: tableHandleRowRootEvents,
-  setup: useTableHandleRowRoot
-}) {
-};
-registerCustomElement6("prosekit-table-handle-row-root", TableHandleRowRootElement);
-
-// src/components/table-handle/table-handle-row-trigger/element.gen.ts
-import { defineCustomElement as defineCustomElement7, registerCustomElement as registerCustomElement7 } from "@aria-ui/core";
-
-// src/components/table-handle/table-handle-row-trigger/setup.ts
-import {
-  useEventListener as useEventListener2
-} from "@aria-ui/core";
-import { useMenuTrigger as useMenuTrigger2 } from "@aria-ui/menu/elements";
-import { selectTableRow } from "@prosekit/extensions/table";
-function useTableHandleRowTrigger(host, {
-  state
-}) {
-  useMenuTrigger2(host);
-  const context = tableHandleRootContext.consume(host);
-  useEventListener2(host, "pointerdown", () => {
-    const editor = state.editor.peek();
-    const cellPos = context.peek()?.cellPos;
-    if (!editor || !cellPos) return;
-    editor.exec(selectTableRow({ head: cellPos }));
-  });
+/** @internal */
+const tableHandleRowRootEvents = {};
+
+//#endregion
+//#region src/components/table-handle/table-handle-row-root/element.gen.ts
+const TableHandleRowRootElementBase = defineCustomElement({
+	props: tableHandleRowRootProps,
+	events: tableHandleRowRootEvents,
+	setup: useTableHandleRowRoot
+});
+var TableHandleRowRootElement = class extends TableHandleRowRootElementBase {};
+registerCustomElement("prosekit-table-handle-row-root", TableHandleRowRootElement);
+
+//#endregion
+//#region src/components/table-handle/table-handle-row-trigger/setup.ts
+function useTableHandleRowTrigger(host, { state }) {
+	useMenuTrigger(host);
+	const context = tableHandleRootContext.consume(host);
+	useEventListener(host, "pointerdown", () => {
+		const editor = state.editor.peek();
+		const cellPos = context.peek()?.cellPos;
+		if (!editor || !cellPos) return;
+		editor.exec(selectTableRow({ head: cellPos }));
+	});
 }
 
-// src/components/table-handle/table-handle-row-trigger/types.ts
-var tableHandleRowTriggerProps = {
-  editor: { default: null }
-};
-var tableHandleRowTriggerEvents = {
-  select: {}
-};
+//#endregion
+//#region src/components/table-handle/table-handle-row-trigger/types.ts
+/** @internal */
+const tableHandleRowTriggerProps = { editor: { default: null } };
+/** @internal */
+const tableHandleRowTriggerEvents = { select: {} };
+
+//#endregion
+//#region src/components/table-handle/table-handle-row-trigger/element.gen.ts
+const TableHandleRowTriggerElementBase = defineCustomElement({
+	props: tableHandleRowTriggerProps,
+	events: tableHandleRowTriggerEvents,
+	setup: useTableHandleRowTrigger
+});
+var TableHandleRowTriggerElement = class extends TableHandleRowTriggerElementBase {};
+registerCustomElement("prosekit-table-handle-row-trigger", TableHandleRowTriggerElement);
 
-// src/components/table-handle/table-handle-row-trigger/element.gen.ts
-var TableHandleRowTriggerElement = class extends defineCustomElement7({
-  props: tableHandleRowTriggerProps,
-  events: tableHandleRowTriggerEvents,
-  setup: useTableHandleRowTrigger
-}) {
-};
-registerCustomElement7("prosekit-table-handle-row-trigger", TableHandleRowTriggerElement);
-export {
-  TableHandleColumnRootElement,
-  TableHandleColumnTriggerElement,
-  TableHandlePopoverContentElement,
-  TableHandlePopoverItemElement,
-  TableHandleRootElement,
-  TableHandleRowRootElement,
-  TableHandleRowTriggerElement,
-  tableHandleColumnRootEvents,
-  tableHandleColumnRootProps,
-  tableHandleColumnTriggerEvents,
-  tableHandleColumnTriggerProps,
-  tableHandlePopoverContentEvents,
-  tableHandlePopoverContentProps,
-  tableHandlePopoverItemEvents,
-  tableHandlePopoverItemProps,
-  tableHandleRootEvents,
-  tableHandleRootProps,
-  tableHandleRowRootEvents,
-  tableHandleRowRootProps,
-  tableHandleRowTriggerEvents,
-  tableHandleRowTriggerProps
-};
+//#endregion
+export { TableHandleColumnRootElement, TableHandleColumnTriggerElement, TableHandlePopoverContentElement, TableHandlePopoverItemElement, TableHandleRootElement, TableHandleRowRootElement, TableHandleRowTriggerElement, tableHandleColumnRootEvents, tableHandleColumnRootProps, tableHandleColumnTriggerEvents, tableHandleColumnTriggerProps, tableHandlePopoverContentEvents, tableHandlePopoverContentProps, tableHandlePopoverItemEvents, tableHandlePopoverItemProps, tableHandleRootEvents, tableHandleRootProps, tableHandleRowRootEvents, tableHandleRowRootProps, tableHandleRowTriggerEvents, tableHandleRowTriggerProps };