@portone/docx-editor 0.1.0

package/dist/editor/plugins/tabLayout.js

@@ -0,0 +1,328 @@
+// src/editor/plugins/tabLayout.ts
+import { Plugin } from "prosemirror-state";
+import { DEFAULT_TAB_STOP_PT } from "../../docx/documentSettings.js";
+import { toParagraphFormat } from "../../model/format.js";
+import { docxSchema } from "../../schema/index.js";
+import { editorClassNames, editorCssVariables } from "../../styles/classNames.js";
+import { documentDefaultTabStopPt } from "../documentStyles.js";
+import { setTabWidths, tabWidths } from "./tabDecorations.js";
+var PX_PER_PT = 96 / 72;
+var POSITION_EPSILON_PT = 0.01;
+var WIDTH_EPSILON_PX = 0.1;
+var NATURAL_WIDTH_PX = 1e5;
+var MAX_LAYOUT_PASSES = 4;
+function nextTabTarget(currentPt, stops, defaultStopPt) {
+  const custom = stops.find(
+    (stop) => stop.align !== "bar" && stop.positionPt > currentPt + POSITION_EPSILON_PT
+  );
+  if (custom && custom.align !== "bar") {
+    return {
+      align: custom.align === "num" ? "start" : custom.align,
+      targetPt: custom.positionPt
+    };
+  }
+  const interval = defaultStopPt > 0 ? defaultStopPt : DEFAULT_TAB_STOP_PT;
+  return {
+    align: "start",
+    targetPt: (Math.floor(currentPt / interval) + 1) * interval
+  };
+}
+function alignedPrefix(align, segment) {
+  if (align === "center") return segment.wholePt / 2;
+  if (align === "end") return segment.wholePt;
+  if (align === "decimal") return segment.decimalPrefixPt;
+  return 0;
+}
+function tabAdvancePt(currentPt, target, segment) {
+  return Math.max(
+    0,
+    target.targetPt - currentPt - alignedPrefix(target.align, segment)
+  );
+}
+function numeric(value) {
+  const parsed = Number.parseFloat(value);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function computedStyle(element) {
+  return element.ownerDocument.defaultView?.getComputedStyle(element) ?? getComputedStyle(element);
+}
+function scaleOf(view) {
+  const layer = view.dom.closest(`.${editorClassNames.pageLayer}`);
+  const parsed = Number.parseFloat(layer ? computedStyle(layer).zoom : "");
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : 1;
+}
+function paragraphLayoutContext(view, slot) {
+  const $pos = view.state.doc.resolve(view.posAtDOM(slot, 0));
+  for (let depth = $pos.depth; depth > 0; depth -= 1) {
+    const node = $pos.node(depth);
+    if (node.type === docxSchema.nodes.paragraph) {
+      return { format: toParagraphFormat(node.attrs.format) ?? {}, node };
+    }
+  }
+  return null;
+}
+function resetSlot(slot) {
+  slot.removeAttribute("data-tab-layout");
+  slot.style.removeProperty(editorCssVariables.tabWidth);
+}
+function cloneParagraph(paragraph, widthPx, resetTabs) {
+  const clone = paragraph.cloneNode(true);
+  const computed = computedStyle(paragraph);
+  for (let index = 0; index < computed.length; index += 1) {
+    const property = computed.item(index);
+    clone.style.setProperty(
+      property,
+      computed.getPropertyValue(property),
+      computed.getPropertyPriority(property)
+    );
+  }
+  clone.style.position = "fixed";
+  clone.style.inset = "0 auto auto -200000px";
+  clone.style.boxSizing = "border-box";
+  clone.style.width = `${widthPx}px`;
+  clone.style.maxWidth = "none";
+  clone.style.textAlign = "start";
+  clone.style.visibility = "hidden";
+  clone.style.pointerEvents = "none";
+  clone.style.zoom = "1";
+  clone.setAttribute("aria-hidden", "true");
+  if (resetTabs) {
+    for (const slot of clone.querySelectorAll(
+      `.${editorClassNames.tabSlot}`
+    )) {
+      resetSlot(slot);
+    }
+  }
+  return clone;
+}
+function rangeAfter(slot, paragraph) {
+  const boundaries = Array.from(
+    paragraph.querySelectorAll(`.${editorClassNames.tabSlot}, br`)
+  );
+  const next = boundaries[boundaries.indexOf(slot) + 1];
+  const range = paragraph.ownerDocument.createRange();
+  range.setStartAfter(slot);
+  if (next) range.setEndBefore(next);
+  else range.setEnd(paragraph, paragraph.childNodes.length);
+  return range;
+}
+function rangeWidth(range) {
+  const rects = Array.from(range.getClientRects()).filter(
+    (rect) => rect.width > 0 || rect.height > 0
+  );
+  if (rects.length === 0) return 0;
+  return Math.max(...rects.map((rect) => rect.right)) - Math.min(...rects.map((rect) => rect.left));
+}
+function decimalSeparator(node, paragraph) {
+  const language = node.parentElement?.closest("[lang]")?.lang || paragraph.lang || paragraph.ownerDocument.documentElement.lang || void 0;
+  try {
+    const parts = new Intl.NumberFormat(language).formatToParts(1.1);
+    return parts.find((part) => part.type === "decimal")?.value ?? ".";
+  } catch {
+    return ".";
+  }
+}
+function decimalPrefix(range, paragraph) {
+  const walker = paragraph.ownerDocument.createTreeWalker(
+    paragraph,
+    paragraph.ownerDocument.defaultView?.NodeFilter.SHOW_TEXT ?? 4
+  );
+  let node = walker.nextNode();
+  while (node) {
+    if (range.intersectsNode(node)) {
+      const at = node.textContent?.indexOf(decimalSeparator(node, paragraph)) ?? -1;
+      if (at >= 0) {
+        const prefix = range.cloneRange();
+        prefix.setEnd(node, at);
+        return prefix;
+      }
+    }
+    node = walker.nextNode();
+  }
+  return null;
+}
+function segmentMetrics(slot, paragraph) {
+  const whole = rangeAfter(slot, paragraph);
+  return {
+    wholePt: rangeWidth(whole) / PX_PER_PT,
+    decimalPrefixPt: rangeWidth(decimalPrefix(whole, paragraph) ?? whole) / PX_PER_PT
+  };
+}
+function currentPositionPt(paragraph, slot) {
+  const paragraphRect = paragraph.getBoundingClientRect();
+  const slotRect = slot.getBoundingClientRect();
+  const style = computedStyle(paragraph);
+  const rtl = style.direction === "rtl";
+  const margin = numeric(rtl ? style.marginRight : style.marginLeft);
+  const origin = rtl ? paragraphRect.right + margin : paragraphRect.left - margin;
+  return (rtl ? origin - slotRect.right : slotRect.left - origin) / PX_PER_PT;
+}
+function applyWidth(slot, widthPx) {
+  slot.setAttribute("data-tab-layout", "");
+  slot.style.setProperty(editorCssVariables.tabWidth, `${widthPx}px`);
+}
+function slotPosition(slot) {
+  const parsed = Number.parseInt(slot.dataset.tabPosition ?? "", 10);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function measureParagraph(paragraph, actualSlots, format, defaultStopPt, scale, widths) {
+  const paragraphWidth = paragraph.getBoundingClientRect().width / scale;
+  if (paragraphWidth <= 0) return;
+  const measured = cloneParagraph(paragraph, paragraphWidth, false);
+  const natural = cloneParagraph(paragraph, NATURAL_WIDTH_PX, true);
+  paragraph.ownerDocument.body.append(measured, natural);
+  try {
+    const measuredSlots = Array.from(
+      measured.querySelectorAll(`.${editorClassNames.tabSlot}`)
+    );
+    const naturalSlots = Array.from(
+      natural.querySelectorAll(`.${editorClassNames.tabSlot}`)
+    );
+    for (let pass = 0; pass < MAX_LAYOUT_PASSES; pass += 1) {
+      let changed = false;
+      measuredSlots.forEach((slot, index) => {
+        const actual = actualSlots[index];
+        const naturalSlot = naturalSlots[index];
+        if (!actual || !naturalSlot) return;
+        const position = slotPosition(actual);
+        if (position === null) return;
+        const currentPt = currentPositionPt(measured, slot);
+        const segment = segmentMetrics(naturalSlot, natural);
+        const target = nextTabTarget(
+          currentPt,
+          format.tabStops ?? [],
+          defaultStopPt
+        );
+        const widthPx = tabAdvancePt(currentPt, target, segment) * PX_PER_PT;
+        const previous = numeric(
+          slot.style.getPropertyValue(editorCssVariables.tabWidth)
+        );
+        if (!slot.hasAttribute("data-tab-layout") || Math.abs(previous - widthPx) > WIDTH_EPSILON_PX) {
+          changed = true;
+        }
+        widths.set(position, widthPx);
+        applyWidth(slot, widthPx);
+      });
+      if (!changed) break;
+    }
+  } finally {
+    measured.remove();
+    natural.remove();
+  }
+}
+function sameWidths(left, right) {
+  if (left.size !== right.size) return false;
+  for (const [position, width] of left) {
+    const other = right.get(position);
+    if (other === void 0 || Math.abs(other - width) > WIDTH_EPSILON_PX) {
+      return false;
+    }
+  }
+  return true;
+}
+function measureTabs(view, cache, generation) {
+  const scale = scaleOf(view);
+  const defaultStopPt = documentDefaultTabStopPt(view.state);
+  const widths = new Map(tabWidths(view.state));
+  const paragraphs = /* @__PURE__ */ new Map();
+  for (const slot of view.dom.querySelectorAll(
+    `.${editorClassNames.tabSlot}`
+  )) {
+    const closest = slot.closest(`.${editorClassNames.paragraph}`);
+    if (!closest) continue;
+    const paragraph = closest;
+    const entries = paragraphs.get(paragraph);
+    if (entries) entries.push(slot);
+    else paragraphs.set(paragraph, [slot]);
+  }
+  for (const [paragraph, slots] of paragraphs) {
+    const context = paragraphLayoutContext(view, slots[0]);
+    if (!context) continue;
+    const paragraphWidth = paragraph.getBoundingClientRect().width / scale;
+    const cached = cache.get(context.node);
+    if (cached && cached.generation === generation && cached.defaultStopPt === defaultStopPt && cached.scale === scale && Math.abs(cached.paragraphWidth - paragraphWidth) <= WIDTH_EPSILON_PX && cached.widths.length === slots.length) {
+      slots.forEach((slot, index) => {
+        const position = slotPosition(slot);
+        const width = cached.widths[index];
+        if (position !== null && width !== void 0)
+          widths.set(position, width);
+      });
+      continue;
+    }
+    measureParagraph(
+      paragraph,
+      slots,
+      context.format,
+      defaultStopPt,
+      scale,
+      widths
+    );
+    cache.set(context.node, {
+      defaultStopPt,
+      generation,
+      paragraphWidth,
+      scale,
+      widths: slots.map((slot) => {
+        const position = slotPosition(slot);
+        return position === null ? 0 : widths.get(position) ?? 0;
+      })
+    });
+  }
+  return widths;
+}
+function tabLayout() {
+  return new Plugin({
+    view(view) {
+      let frame = 0;
+      let live = true;
+      let generation = 0;
+      const cache = /* @__PURE__ */ new WeakMap();
+      const ownerWindow = view.dom.ownerDocument.defaultView;
+      const requestFrame = ownerWindow?.requestAnimationFrame.bind(ownerWindow);
+      const cancelFrame = ownerWindow?.cancelAnimationFrame.bind(ownerWindow);
+      const schedule = () => {
+        if (!live || frame !== 0) return;
+        frame = (requestFrame ?? requestAnimationFrame)(() => {
+          frame = 0;
+          const widths = measureTabs(view, cache, generation);
+          if (sameWidths(widths, tabWidths(view.state))) return;
+          view.dispatch(
+            setTabWidths(view.state.tr, widths).setMeta("addToHistory", false)
+          );
+        });
+      };
+      const ResizeObserverClass = ownerWindow?.ResizeObserver;
+      const resize = typeof ResizeObserverClass === "undefined" ? null : new ResizeObserverClass(schedule);
+      resize?.observe(view.dom);
+      const onResize = () => schedule();
+      ownerWindow?.addEventListener("resize", onResize);
+      const fonts = view.dom.ownerDocument.fonts;
+      const onFontsChanged = () => {
+        generation += 1;
+        schedule();
+      };
+      fonts?.addEventListener("loadingdone", onFontsChanged);
+      fonts?.addEventListener("loadingerror", onFontsChanged);
+      fonts?.ready.then(onFontsChanged);
+      schedule();
+      return {
+        update(next, previous) {
+          if (!next.state.doc.eq(previous.doc)) schedule();
+        },
+        destroy() {
+          live = false;
+          if (frame !== 0) (cancelFrame ?? cancelAnimationFrame)(frame);
+          resize?.disconnect();
+          ownerWindow?.removeEventListener("resize", onResize);
+          fonts?.removeEventListener("loadingdone", onFontsChanged);
+          fonts?.removeEventListener("loadingerror", onFontsChanged);
+        }
+      };
+    }
+  });
+}
+export {
+  nextTabTarget,
+  tabAdvancePt,
+  tabLayout
+};

package/dist/editor/plugins/tabPointer.d.ts

@@ -0,0 +1,7 @@
+import { Plugin } from "prosemirror-state";
+type TabSide = "before" | "after";
+/** Maps the visual half of a tab to its logical side in the text flow. */
+export declare function tabSideAtX(left: number, right: number, clientX: number, direction: "ltr" | "rtl"): TabSide;
+/** Gives a tab deterministic click and drag selection boundaries. */
+export declare function tabPointer(): Plugin;
+export {};

package/dist/editor/plugins/tabPointer.js

@@ -0,0 +1,95 @@
+// src/editor/plugins/tabPointer.ts
+import { Plugin, TextSelection } from "prosemirror-state";
+import { editorClassNames } from "../../styles/classNames.js";
+function tabSideAtX(left, right, clientX, direction) {
+  const leftHalf = clientX < (left + right) / 2;
+  return leftHalf === (direction === "ltr") ? "before" : "after";
+}
+function tabSlot(target) {
+  if (!target || typeof target.closest !== "function") return null;
+  return target.closest(
+    `.${editorClassNames.tabSlot}`
+  );
+}
+function tabPosition(view, slot, clientX) {
+  const paragraph = slot.closest(`.${editorClassNames.paragraph}`);
+  const direction = paragraph && paragraph.ownerDocument.defaultView?.getComputedStyle(paragraph).direction === "rtl" ? "rtl" : "ltr";
+  const rect = slot.getBoundingClientRect();
+  const side = tabSideAtX(rect.left, rect.right, clientX, direction);
+  return view.posAtDOM(slot, side === "before" ? 0 : slot.childNodes.length);
+}
+function pointerPosition(view, event) {
+  const direct = tabSlot(event.target);
+  const ownerDocument = view.dom.ownerDocument;
+  const pointed = typeof ownerDocument.elementFromPoint === "function" ? ownerDocument.elementFromPoint(event.clientX, event.clientY) : null;
+  const slot = direct ?? tabSlot(pointed);
+  if (slot && view.dom.contains(slot)) {
+    return tabPosition(view, slot, event.clientX);
+  }
+  return view.posAtCoords({ left: event.clientX, top: event.clientY })?.pos ?? null;
+}
+function select(view, anchor, head) {
+  const size = view.state.doc.content.size;
+  const boundedAnchor = Math.max(0, Math.min(anchor, size));
+  const boundedHead = Math.max(0, Math.min(head, size));
+  const selection = TextSelection.between(
+    view.state.doc.resolve(boundedAnchor),
+    view.state.doc.resolve(boundedHead)
+  );
+  view.dispatch(view.state.tr.setSelection(selection));
+}
+function tabPointer() {
+  let stopDragging = null;
+  return new Plugin({
+    props: {
+      handleDOMEvents: {
+        mousedown(view, event) {
+          if (event.button !== 0) return false;
+          const slot = tabSlot(event.target);
+          if (!slot || !view.dom.contains(slot)) return false;
+          event.preventDefault();
+          view.focus();
+          const head = tabPosition(view, slot, event.clientX);
+          const anchor = event.shiftKey ? view.state.selection.anchor : head;
+          select(view, anchor, head);
+          stopDragging?.();
+          const onMove = (move) => {
+            const next = pointerPosition(view, move);
+            if (next === null) return;
+            move.preventDefault();
+            select(view, anchor, next);
+          };
+          const onUp = (up) => {
+            const next = pointerPosition(view, up);
+            if (next !== null) select(view, anchor, next);
+            stopDragging?.();
+          };
+          const ownerDocument = view.dom.ownerDocument;
+          stopDragging = () => {
+            ownerDocument.removeEventListener("mousemove", onMove, true);
+            ownerDocument.removeEventListener("mouseup", onUp, true);
+            stopDragging = null;
+          };
+          ownerDocument.addEventListener("mousemove", onMove, true);
+          ownerDocument.addEventListener("mouseup", onUp, true);
+          return true;
+        }
+      }
+    },
+    view: (view) => {
+      const ownerWindow = view.dom.ownerDocument.defaultView;
+      const onBlur = () => stopDragging?.();
+      ownerWindow?.addEventListener("blur", onBlur);
+      return {
+        destroy() {
+          ownerWindow?.removeEventListener("blur", onBlur);
+          stopDragging?.();
+        }
+      };
+    }
+  });
+}
+export {
+  tabPointer,
+  tabSideAtX
+};

package/dist/editor/plugins/tableContextMenu.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Right-clicking in a table cell brings up our own menu.
+ *
+ * This file does two things: block the browser's default menu, and report where the menu should
+ * stand. Drawing the menu is the React side's job.
+ *
+ * Only the click that asks for the row and column actions reaches this plugin: a click on
+ * selected text is taken first by the text menu (`editor/textContextMenu`), which stands ahead
+ * of this one and hands back a click with nothing selected inside a cell.
+ */
+import { type Command, type EditorState, Plugin } from "prosemirror-state";
+/** Where the menu should stand (viewport coordinates) */
+export interface TableMenuAnchor {
+    clientX: number;
+    clientY: number;
+}
+/** The anchor of the currently open table menu. Null when it is closed */
+export declare function tableMenuAnchor(state: EditorState): TableMenuAnchor | null;
+/** Closes the menu. Called on running an item, Escape, clicking outside, and scrolling */
+export declare const closeTableMenu: Command;
+export declare function tableContextMenu(): Plugin<TableMenuAnchor | null>;

package/dist/editor/plugins/tableContextMenu.js

@@ -0,0 +1,88 @@
+// src/editor/plugins/tableContextMenu.ts
+import {
+  Plugin,
+  PluginKey,
+  TextSelection
+} from "prosemirror-state";
+var CLOSE = "close";
+var menuKey = new PluginKey("docxEditorTableMenu");
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function toAnchor(value) {
+  if (!isRecord(value)) return null;
+  const { clientX, clientY } = value;
+  if (typeof clientX !== "number" || typeof clientY !== "number") return null;
+  return { clientX, clientY };
+}
+function tableMenuAnchor(state) {
+  return menuKey.getState(state) ?? null;
+}
+var closeTableMenu = (state, dispatch) => {
+  if (tableMenuAnchor(state) === null) return false;
+  if (dispatch) dispatch(state.tr.setMeta(menuKey, CLOSE));
+  return true;
+};
+function cellStart($pos) {
+  for (let depth = $pos.depth; depth > 0; depth -= 1) {
+    if ($pos.node(depth).type.spec.tableRole === "cell") {
+      return $pos.before(depth);
+    }
+  }
+  return null;
+}
+function cellAtEvent(view, target) {
+  const node = target instanceof Node ? target : null;
+  const element = node instanceof Element ? node : node?.parentElement;
+  const cell = element?.closest("td");
+  if (!cell || !view.dom.contains(cell)) return null;
+  return cellStart(view.state.doc.resolve(view.posAtDOM(cell, 0)));
+}
+function selectionCovers(state, cellPos) {
+  return state.selection.ranges.some(
+    (range) => cellStart(range.$from) === cellPos
+  );
+}
+function openMenu(view, cellPos, anchor) {
+  const state = view.state;
+  const tr = state.tr.setMeta(menuKey, anchor);
+  if (!selectionCovers(state, cellPos)) {
+    tr.setSelection(TextSelection.near(tr.doc.resolve(cellPos + 1)));
+  }
+  view.dispatch(tr);
+}
+function tableContextMenu() {
+  return new Plugin({
+    key: menuKey,
+    state: {
+      init: () => null,
+      apply: (tr, current) => {
+        const meta = tr.getMeta(menuKey);
+        if (meta === CLOSE) return null;
+        const anchor = toAnchor(meta);
+        if (anchor) return anchor;
+        return tr.docChanged ? null : current;
+      }
+    },
+    props: {
+      handleDOMEvents: {
+        contextmenu(view, event) {
+          if (!view.editable) return false;
+          const cellPos = cellAtEvent(view, event.target);
+          if (cellPos === null) return false;
+          event.preventDefault();
+          openMenu(view, cellPos, {
+            clientX: event.clientX,
+            clientY: event.clientY
+          });
+          return true;
+        }
+      }
+    }
+  });
+}
+export {
+  closeTableMenu,
+  tableContextMenu,
+  tableMenuAnchor
+};

package/dist/editor/plugins/textContextMenu.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Replaces the native text context menu and moves the selection to the clicked position. Unselected
+ * table cells are left to the table context-menu plugin.
+ */
+import { type Command, type EditorState, Plugin } from "prosemirror-state";
+/** Where the menu should stand (viewport coordinates) */
+export interface TextMenuAnchor {
+    clientX: number;
+    clientY: number;
+}
+/** The anchor of the currently open text menu. Null when it is closed */
+export declare function textMenuAnchor(state: EditorState): TextMenuAnchor | null;
+/** Closes the menu. Called on running an item, Escape, clicking outside, and scrolling */
+export declare const closeTextMenu: Command;
+export declare function textContextMenu(): Plugin<TextMenuAnchor | null>;

package/dist/editor/plugins/textContextMenu.js

@@ -0,0 +1,90 @@
+// src/editor/plugins/textContextMenu.ts
+import {
+  Plugin,
+  PluginKey,
+  TextSelection
+} from "prosemirror-state";
+import { CellSelection } from "prosemirror-tables";
+var CLOSE = "close";
+var menuKey = new PluginKey("docxEditorTextMenu");
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function toAnchor(value) {
+  if (!isRecord(value)) return null;
+  const { clientX, clientY } = value;
+  if (typeof clientX !== "number" || typeof clientY !== "number") return null;
+  return { clientX, clientY };
+}
+function textMenuAnchor(state) {
+  return menuKey.getState(state) ?? null;
+}
+var closeTextMenu = (state, dispatch) => {
+  if (textMenuAnchor(state) === null) return false;
+  if (dispatch) dispatch(state.tr.setMeta(menuKey, CLOSE));
+  return true;
+};
+function isInEditor(view, target) {
+  return target instanceof Node && view.dom.contains(target);
+}
+function isInTableCell(view, target) {
+  const node = target instanceof Node ? target : null;
+  const element = node instanceof Element ? node : node?.parentElement;
+  const cell = element?.closest("td");
+  return !!cell && view.dom.contains(cell);
+}
+function clickedSpot(view, event) {
+  const found = view.posAtCoords({ left: event.clientX, top: event.clientY });
+  return found?.pos ?? view.state.selection.head;
+}
+function isInSelection(state, spot) {
+  const selection = state.selection;
+  return !selection.empty && selection.ranges.some(
+    (range) => range.$from.pos <= spot && spot <= range.$to.pos
+  );
+}
+function forTableMenu(view, target, spot) {
+  const aboutCells = view.state.selection instanceof CellSelection || !isInSelection(view.state, spot);
+  return aboutCells && isInTableCell(view, target);
+}
+function openMenu(state, event, spot) {
+  const tr = state.tr.setMeta(menuKey, {
+    clientX: event.clientX,
+    clientY: event.clientY
+  });
+  if (isInSelection(state, spot)) return tr;
+  return tr.setSelection(TextSelection.near(tr.doc.resolve(spot)));
+}
+function textContextMenu() {
+  return new Plugin({
+    key: menuKey,
+    state: {
+      init: () => null,
+      apply: (tr, current) => {
+        const meta = tr.getMeta(menuKey);
+        if (meta === CLOSE) return null;
+        const anchor = toAnchor(meta);
+        if (anchor) return anchor;
+        return tr.docChanged ? null : current;
+      }
+    },
+    props: {
+      handleDOMEvents: {
+        contextmenu(view, event) {
+          if (!view.editable) return false;
+          if (!isInEditor(view, event.target)) return false;
+          const spot = clickedSpot(view, event);
+          if (forTableMenu(view, event.target, spot)) return false;
+          event.preventDefault();
+          view.dispatch(openMenu(view.state, event, spot));
+          return true;
+        }
+      }
+    }
+  });
+}
+export {
+  closeTextMenu,
+  textContextMenu,
+  textMenuAnchor
+};