@domternal/extension-block-menu 0.7.0

package/dist/index.cjs

@@ -0,0 +1,2622 @@
+'use strict';
+
+var core = require('@domternal/core');
+var state = require('@domternal/pm/state');
+var model = require('@domternal/pm/model');
+var view = require('@domternal/pm/view');
+var transform = require('@domternal/pm/transform');
+
+// src/FloatingMenu.ts
+var floatingMenuPluginKey = new state.PluginKey("floatingMenu");
+function defaultShouldShow({
+  editor,
+  state
+}) {
+  if (!editor.isEditable) return false;
+  const { selection } = state;
+  const { $from, empty } = selection;
+  if (!empty) return false;
+  if ($from.parent.type.name !== "paragraph") return false;
+  if ($from.parent.content.size !== 0) return false;
+  if ($from.parentOffset !== 0) return false;
+  return true;
+}
+var DEFAULT_ENTER_MENU_SHORTCUTS = ["Alt-F10", "Mod-/"];
+var FLOATING_MENU_META = "dm:floatingMenuTrigger";
+function showFloatingMenu(view) {
+  view.dispatch(view.state.tr.setMeta(FLOATING_MENU_META, "show"));
+}
+var IS_MAC = typeof navigator !== "undefined" && /Mac|iPhone|iPad|iPod/i.test(navigator.userAgent);
+function matchShortcut(event, shortcut) {
+  const parts = shortcut.split("-");
+  let keyPart = parts.pop();
+  if (!keyPart) return false;
+  if (keyPart === "Space") keyPart = " ";
+  let needCtrl = false;
+  let needMeta = false;
+  let needAlt = false;
+  let needShift = false;
+  for (const mod of parts) {
+    switch (mod) {
+      case "Mod":
+      case "mod":
+        if (IS_MAC) needMeta = true;
+        else needCtrl = true;
+        break;
+      case "Cmd":
+      case "cmd":
+      case "Meta":
+      case "meta":
+      case "m":
+        needMeta = true;
+        break;
+      case "Ctrl":
+      case "ctrl":
+      case "Control":
+      case "control":
+      case "c":
+        needCtrl = true;
+        break;
+      case "Alt":
+      case "alt":
+      case "a":
+        needAlt = true;
+        break;
+      case "Shift":
+      case "shift":
+      case "s":
+        needShift = true;
+        break;
+      default:
+        return false;
+    }
+  }
+  if (event.altKey !== needAlt) return false;
+  if (event.ctrlKey !== needCtrl) return false;
+  if (event.metaKey !== needMeta) return false;
+  if (keyPart.length > 1 && event.shiftKey !== needShift) return false;
+  return event.key === keyPart || event.key.toLowerCase() === keyPart.toLowerCase();
+}
+function createFloatingMenuPlugin(options) {
+  const {
+    pluginKey,
+    editor,
+    element,
+    shouldShow = defaultShouldShow,
+    offset = 0,
+    keymap,
+    requireExplicitTrigger = false
+  } = options;
+  const enterShortcuts = keymap?.enterMenu ?? DEFAULT_ENTER_MENU_SHORTCUTS;
+  if (!element.getAttribute("role")) {
+    element.setAttribute("role", "menu");
+    element.setAttribute("aria-label", "Insert block");
+  }
+  let cleanupFloating = null;
+  let editorEl = null;
+  let clickOutsideHandler = null;
+  let dismissOverlayHandler = null;
+  const isVisible = () => element.hasAttribute("data-show");
+  const updatePosition = (view) => {
+    const { selection } = view.state;
+    const { $from } = selection;
+    const depth = $from.depth;
+    const startPos = $from.start(depth);
+    const domNode = view.nodeDOM(startPos - 1);
+    if (domNode instanceof HTMLElement) {
+      cleanupFloating?.();
+      cleanupFloating = core.positionFloatingOnce(domNode, element, {
+        placement: "bottom-start",
+        offsetValue: offset
+      });
+      element.setAttribute("data-show", "");
+    }
+  };
+  const hideMenu = () => {
+    cleanupFloating?.();
+    cleanupFloating = null;
+    element.removeAttribute("data-show");
+  };
+  const focusFirstItem = () => {
+    const first = element.querySelector('[data-floating-menu-item]:not([aria-disabled="true"])') ?? element.querySelector('button, [tabindex]:not([tabindex="-1"])');
+    if (!first) return false;
+    first.focus();
+    return true;
+  };
+  hideMenu();
+  const isVisibleNow = (view) => {
+    const wantsShow = shouldShow({ editor, view, state: view.state });
+    if (!requireExplicitTrigger) return wantsShow;
+    const triggered = pluginKey.getState(view.state)?.triggered ?? false;
+    return triggered && wantsShow;
+  };
+  return new state.Plugin({
+    key: pluginKey,
+    state: {
+      init: () => ({ triggered: false }),
+      apply: (tr, prev) => {
+        const meta = tr.getMeta(FLOATING_MENU_META);
+        if (meta === "show") return { triggered: true };
+        if (meta === "hide") return { triggered: false };
+        return prev;
+      }
+    },
+    props: {
+      // Keyboard entry from the editor. ProseMirror's handleKeyDown fires
+      // before browser defaults, so we can intercept without risking
+      // interference with typing. We only act while the menu is visible.
+      handleKeyDown(_view, event) {
+        if (!isVisible()) return false;
+        for (const shortcut of enterShortcuts) {
+          if (matchShortcut(event, shortcut)) {
+            if (focusFirstItem()) {
+              event.preventDefault();
+              return true;
+            }
+            return false;
+          }
+        }
+        return false;
+      }
+    },
+    view: (editorView) => {
+      editorEl = editorView.dom.closest(".dm-editor");
+      if (editorEl && element.parentElement !== editorEl) {
+        editorEl.appendChild(element);
+      }
+      const dismiss = () => {
+        hideMenu();
+        if (requireExplicitTrigger) {
+          const triggered = pluginKey.getState(editor.view.state)?.triggered ?? false;
+          if (triggered) {
+            editor.view.dispatch(editor.view.state.tr.setMeta(FLOATING_MENU_META, "hide"));
+          }
+        }
+      };
+      const onFocus = () => {
+        if (isVisibleNow(editor.view)) updatePosition(editor.view);
+        else dismiss();
+      };
+      const onBlur = ({ event }) => {
+        const related = event.relatedTarget;
+        if (related instanceof Node && element.contains(related)) return;
+        dismiss();
+      };
+      clickOutsideHandler = (e) => {
+        if (!isVisible()) return;
+        const target = e.target;
+        if (!(target instanceof Node)) return;
+        if (element.contains(target)) return;
+        if (editor.view.dom.contains(target)) return;
+        dismiss();
+      };
+      document.addEventListener("mousedown", clickOutsideHandler, true);
+      if (editorEl) {
+        dismissOverlayHandler = () => {
+          dismiss();
+        };
+        editorEl.addEventListener("dm:dismiss-overlays", dismissOverlayHandler);
+      }
+      editor.on("focus", onFocus);
+      editor.on("blur", onBlur);
+      return {
+        update: (view) => {
+          if (isVisibleNow(view)) updatePosition(view);
+          else {
+            hideMenu();
+            if (requireExplicitTrigger) {
+              const triggered = pluginKey.getState(view.state)?.triggered ?? false;
+              if (triggered) {
+                view.dispatch(view.state.tr.setMeta(FLOATING_MENU_META, "hide"));
+              }
+            }
+          }
+        },
+        destroy: () => {
+          hideMenu();
+          editor.off("focus", onFocus);
+          editor.off("blur", onBlur);
+          if (clickOutsideHandler) {
+            document.removeEventListener("mousedown", clickOutsideHandler, true);
+            clickOutsideHandler = null;
+          }
+          if (dismissOverlayHandler && editorEl) {
+            editorEl.removeEventListener("dm:dismiss-overlays", dismissOverlayHandler);
+            dismissOverlayHandler = null;
+          }
+          editorEl = null;
+        }
+      };
+    }
+  });
+}
+var FloatingMenu = core.Extension.create({
+  name: "floatingMenu",
+  addOptions() {
+    return {
+      element: null,
+      shouldShow: defaultShouldShow,
+      offset: 0,
+      requireExplicitTrigger: false
+    };
+  },
+  addProseMirrorPlugins() {
+    const { element, shouldShow, offset, keymap, requireExplicitTrigger } = this.options;
+    if (!element) return [];
+    const editor = this.editor;
+    if (!editor) return [];
+    return [
+      createFloatingMenuPlugin({
+        pluginKey: floatingMenuPluginKey,
+        editor,
+        element,
+        shouldShow,
+        offset,
+        keymap,
+        ...requireExplicitTrigger !== void 0 && { requireExplicitTrigger }
+      })
+    ];
+  }
+});
+
+// src/helpers/findTopLevelBlock.ts
+function findTopLevelBlock(doc, pos) {
+  if (pos < 0 || pos > doc.content.size) return null;
+  const $pos = doc.resolve(pos);
+  if ($pos.depth === 0) {
+    const node2 = doc.nodeAt(pos);
+    if (!node2) return null;
+    return {
+      node: node2,
+      pos,
+      end: pos + node2.nodeSize,
+      index: $pos.index(0)
+    };
+  }
+  const node = $pos.node(1);
+  const blockPos = $pos.before(1);
+  const index = $pos.index(0);
+  return {
+    node,
+    pos: blockPos,
+    end: blockPos + node.nodeSize,
+    index
+  };
+}
+function findDeepestBlockAtY(view, clientY, allowedTypes, matchers = []) {
+  if (allowedTypes.length === 0) return null;
+  let best = null;
+  view.state.doc.descendants((node, pos, parent, index) => {
+    const dom = view.nodeDOM(pos);
+    if (!(dom instanceof HTMLElement)) return true;
+    const rect = dom.getBoundingClientRect();
+    if (clientY < rect.top || clientY > rect.bottom) return false;
+    if (allowedTypes.includes(node.type.name)) {
+      if (matchers.length > 0 && isRejectedByMatchers(view, node, pos, parent, index, matchers)) {
+        return true;
+      }
+      if (best === null || rect.height < best.rect.height) {
+        best = { node, pos, dom, rect };
+      }
+    }
+    return true;
+  });
+  return best;
+}
+function isRejectedByMatchers(view, node, pos, parent, index, matchers) {
+  const $pos = view.state.doc.resolve(pos);
+  const candidate = {
+    block: node,
+    documentPos: pos,
+    // `pos` sits right BEFORE `node`, so $pos.depth is the parent's depth
+    // and `node` itself lives one level deeper.
+    treeDepth: $pos.depth + 1,
+    container: parent,
+    positionInContainer: index,
+    isFirstChild: index === 0,
+    isLastChild: parent !== null ? index === parent.childCount - 1 : true,
+    resolvedPos: $pos,
+    editorView: view
+  };
+  for (const matcher of matchers) {
+    if (matcher.test(candidate) === "reject") return true;
+  }
+  return false;
+}
+
+// src/helpers/expandToEmptyWrappers.ts
+function expandToEmptyWrappers(doc, from, to) {
+  let curFrom = from;
+  let curTo = to;
+  let $pos = doc.resolve(curFrom);
+  while ($pos.depth > 0 && isCollapsibleParent($pos.node($pos.depth), $pos.index($pos.depth))) {
+    curFrom = $pos.before($pos.depth);
+    curTo = $pos.after($pos.depth);
+    $pos = doc.resolve(curFrom);
+  }
+  return { from: curFrom, to: curTo };
+}
+function isCollapsibleParent(parent, sourceIndex) {
+  if (parent.childCount === 1) return true;
+  if (parent.childCount !== 2) return false;
+  const otherIndex = sourceIndex === 0 ? 1 : 0;
+  const other = parent.child(otherIndex);
+  return other.type.name === "paragraph" && other.content.size === 0;
+}
+var TASK_LIST_TYPE = "taskList";
+var BULLET_LIST_TYPES = /* @__PURE__ */ new Set(["bulletList", "orderedList"]);
+var TASK_ITEM_TYPE = "taskItem";
+var LIST_ITEM_TYPE = "listItem";
+function convertListItemForParent(schema, content, parentType) {
+  const expectsTaskItem = parentType.name === TASK_LIST_TYPE;
+  const expectsListItem = BULLET_LIST_TYPES.has(parentType.name);
+  if (!expectsTaskItem && !expectsListItem) return content;
+  const targetTypeName = expectsTaskItem ? TASK_ITEM_TYPE : LIST_ITEM_TYPE;
+  const oppositeTypeName = expectsTaskItem ? LIST_ITEM_TYPE : TASK_ITEM_TYPE;
+  const targetItemType = schema.nodes[targetTypeName];
+  if (!targetItemType) return content;
+  const children = [];
+  content.forEach((child) => {
+    children.push(child);
+  });
+  const allMatch = children.every((c) => c.type.name === targetTypeName);
+  if (allMatch) return content;
+  const replaced = children.map((child) => {
+    if (child.type.name === targetTypeName) return child;
+    if (child.type.name === oppositeTypeName) {
+      const newAttrs = expectsTaskItem ? { ...child.attrs, checked: false } : { ...child.attrs };
+      return targetItemType.create(newAttrs, child.content, child.marks);
+    }
+    const wrapperAttrs = expectsTaskItem ? { checked: false } : {};
+    if (child.type.name === "paragraph") {
+      return targetItemType.create(wrapperAttrs, [child]);
+    }
+    const paragraphType = schema.nodes["paragraph"];
+    const labelParagraph = paragraphType?.createAndFill();
+    const content2 = labelParagraph ? [labelParagraph, child] : [child];
+    return targetItemType.create(wrapperAttrs, content2);
+  });
+  return model.Fragment.from(replaced);
+}
+
+// src/helpers/moveBlock.ts
+function moveBlock(tr, sourcePos, targetPos) {
+  if (sourcePos < 0 || sourcePos >= tr.doc.content.size) return tr;
+  const sourceNode = tr.doc.nodeAt(sourcePos);
+  if (!sourceNode) return tr;
+  const sourceEnd = sourcePos + sourceNode.nodeSize;
+  const { from, to } = expandToEmptyWrappers(tr.doc, sourcePos, sourceEnd);
+  if (targetPos >= from && targetPos <= to) return tr;
+  const slice = tr.doc.slice(sourcePos, sourceEnd);
+  tr.delete(from, to);
+  const adjustedTarget = targetPos > from ? targetPos - (to - from) : targetPos;
+  const targetParent = tr.doc.resolve(adjustedTarget).parent;
+  const adaptedContent = convertListItemForParent(
+    tr.doc.type.schema,
+    slice.content,
+    targetParent.type
+  );
+  tr.insert(adjustedTarget, adaptedContent);
+  return tr;
+}
+var LIST_ITEM_TYPES = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+function moveBlockAsNestedChild(tr, sourcePos, wrapperPos, targetItemPos) {
+  if (sourcePos < 0 || sourcePos >= tr.doc.content.size) return false;
+  const sourceNode = tr.doc.nodeAt(sourcePos);
+  if (!sourceNode) return false;
+  const sourceEnd = sourcePos + sourceNode.nodeSize;
+  if (targetItemPos >= sourcePos && targetItemPos < sourceEnd) return false;
+  if (wrapperPos >= sourcePos && wrapperPos < sourceEnd) return false;
+  const { from: expandedFrom, to: expandedTo } = expandToEmptyWrappers(tr.doc, sourcePos, sourceEnd);
+  let blockNode;
+  if (LIST_ITEM_TYPES.has(sourceNode.type.name)) {
+    const wrapperNode = tr.doc.nodeAt(wrapperPos);
+    if (!wrapperNode) return false;
+    const adaptedFragment = convertListItemForParent(
+      tr.doc.type.schema,
+      model.Fragment.from(sourceNode),
+      wrapperNode.type
+    );
+    if (adaptedFragment.childCount === 0) return false;
+    blockNode = wrapperNode.type.create(null, adaptedFragment);
+  } else {
+    blockNode = sourceNode;
+  }
+  const result = core.insertAsListItemChild({
+    tr,
+    wrapperPos,
+    targetItemPos,
+    blockNode,
+    sourceRange: { from: expandedFrom, to: expandedTo }
+  });
+  return result.ok;
+}
+
+// src/helpers/dragGhost.ts
+function createDragGhost(source) {
+  const wrapper = makeWrapper(source);
+  const clone = deepCloneWithStyles(source);
+  wrapper.appendChild(clone);
+  document.body.appendChild(wrapper);
+  return { wrapper };
+}
+function makeWrapper(source) {
+  const w = document.createElement("div");
+  w.setAttribute("aria-hidden", "true");
+  Object.assign(w.style, {
+    position: "absolute",
+    top: "-10000px",
+    left: "-10000px",
+    pointerEvents: "none",
+    width: `${String(source.getBoundingClientRect().width)}px`
+  });
+  return w;
+}
+function deepCloneWithStyles(source) {
+  const clone = source.cloneNode(true);
+  freezeStylesIntoClone(source, clone);
+  return clone;
+}
+function freezeStylesIntoClone(src, dst) {
+  if (src instanceof HTMLElement && dst instanceof HTMLElement) {
+    dst.style.cssText = getComputedStyle(src).cssText;
+  }
+  const srcKids = src.children;
+  const dstKids = dst.children;
+  const n = Math.min(srcKids.length, dstKids.length);
+  for (let i = 0; i < n; i++) {
+    const s = srcKids.item(i);
+    const d = dstKids.item(i);
+    if (s !== null && d !== null) freezeStylesIntoClone(s, d);
+  }
+}
+
+// src/helpers/clampCoords.ts
+var DEFAULT_INSET_PX = 5;
+function clampToContent(view, clientX, clientY, inset = DEFAULT_INSET_PX) {
+  const first = view.dom.firstElementChild;
+  const last = view.dom.lastElementChild;
+  if (!first || !last) return null;
+  const topRect = first.getBoundingClientRect();
+  const bottomRect = last.getBoundingClientRect();
+  let clampedY = clientY;
+  if (clientY < topRect.top) clampedY = topRect.top + inset;
+  else if (clientY > bottomRect.bottom) clampedY = bottomRect.bottom - inset;
+  const minX = topRect.left + inset;
+  const maxX = topRect.right - inset;
+  const clampedX = Math.max(minX, Math.min(clientX, maxX));
+  return { x: clampedX, y: clampedY };
+}
+
+// src/helpers/gutterBias.ts
+var PRESET_DEFAULT = {
+  edges: ["left", "top"],
+  threshold: 12,
+  strength: 500
+};
+var PRESET_RIGHT = { ...PRESET_DEFAULT, edges: ["right", "top"] };
+var PRESET_BOTH = { ...PRESET_DEFAULT, edges: ["left", "right", "top"] };
+function resolveGutterBias(input) {
+  switch (input) {
+    case void 0:
+    case false:
+    case "none":
+      return null;
+    case true:
+    case "left":
+      return { ...PRESET_DEFAULT };
+    case "right":
+      return { ...PRESET_RIGHT };
+    case "both":
+      return { ...PRESET_BOTH };
+    default:
+      return {
+        edges: input.edges ?? PRESET_DEFAULT.edges,
+        threshold: input.threshold ?? PRESET_DEFAULT.threshold,
+        strength: input.strength ?? PRESET_DEFAULT.strength
+      };
+  }
+}
+function isInGutter(x, y, rect, config) {
+  const t = config.threshold;
+  for (const edge of config.edges) {
+    if (edge === "left" && x - rect.left <= t) return true;
+    if (edge === "right" && rect.right - x <= t) return true;
+    if (edge === "top" && y - rect.top <= t) return true;
+    if (edge === "bottom" && rect.bottom - y <= t) return true;
+  }
+  return false;
+}
+function gutterBiasWeight(x, y, rect, depth, config) {
+  return isInGutter(x, y, rect, config) ? config.strength * depth : 0;
+}
+
+// src/helpers/defaultMatchers.ts
+var LIST_ITEM_NODE_TYPES = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+var TABLE_PLUMBING_TYPES = /* @__PURE__ */ new Set(["tableRow", "tableCell", "tableHeader"]);
+var firstChildOfListItem = {
+  name: "firstChildOfListItem",
+  test(candidate) {
+    if (!candidate.isFirstChild) return "allow";
+    const parent = candidate.container;
+    if (parent === null) return "allow";
+    return LIST_ITEM_NODE_TYPES.has(parent.type.name) ? "reject" : "allow";
+  }
+};
+var listContainerSkip = {
+  name: "listContainerSkip",
+  test(candidate) {
+    const firstChild = candidate.block.firstChild;
+    if (firstChild === null) return "allow";
+    return LIST_ITEM_NODE_TYPES.has(firstChild.type.name) ? "reject" : "allow";
+  }
+};
+var tableInternals = {
+  name: "tableInternals",
+  test(candidate) {
+    if (TABLE_PLUMBING_TYPES.has(candidate.block.type.name)) return "reject";
+    if (candidate.container?.type.name === "tableHeader") return "reject";
+    return "allow";
+  }
+};
+var inlineNodes = {
+  name: "inlineNodes",
+  test(candidate) {
+    const { block } = candidate;
+    return block.isText || block.isInline ? "reject" : "allow";
+  }
+};
+var DEFAULT_BLOCK_MATCHERS = Object.freeze([
+  firstChildOfListItem,
+  listContainerSkip,
+  tableInternals,
+  inlineNodes
+]);
+
+// src/helpers/resolveDragTarget.ts
+function resolveDragTarget(view, x, y, options) {
+  const coord = view.posAtCoords({ left: x, top: y });
+  if (coord === null) return null;
+  const $pos = view.state.doc.resolve(coord.pos);
+  const survivors = [];
+  collectAncestors($pos, view, options, survivors);
+  collectAtomLeaf($pos, view, options, survivors);
+  if (survivors.length === 0) return null;
+  applyGutterBias(survivors, x, y, options.gutterBias);
+  return chooseWinner(survivors);
+}
+function collectAncestors($pos, view, options, out) {
+  for (let depth = $pos.depth; depth >= 1; depth--) {
+    const block = $pos.node(depth);
+    const documentPos = $pos.before(depth);
+    const container = depth > 0 ? $pos.node(depth - 1) : null;
+    const positionInContainer = depth > 0 ? $pos.index(depth - 1) : 0;
+    const containerSize = container?.childCount ?? 1;
+    if (!passesScopeFilters(block, $pos, depth, options)) continue;
+    const candidate = {
+      block,
+      documentPos,
+      treeDepth: depth,
+      container,
+      positionInContainer,
+      isFirstChild: positionInContainer === 0,
+      isLastChild: positionInContainer === containerSize - 1,
+      resolvedPos: $pos,
+      editorView: view
+    };
+    if (rejectedByMatchers(candidate, options.matchers)) continue;
+    const dom = view.nodeDOM(documentPos);
+    if (!(dom instanceof HTMLElement)) continue;
+    out.push({
+      pos: documentPos,
+      rect: dom.getBoundingClientRect(),
+      dom,
+      depth,
+      rank: depth,
+      node: block
+    });
+  }
+}
+function collectAtomLeaf($pos, view, options, out) {
+  const leaf = $pos.nodeAfter;
+  if (leaf === null) return;
+  if (!leaf.isAtom || leaf.isInline) return;
+  const synthDepth = $pos.depth + 1;
+  if (!passesScopeFilters(leaf, $pos, synthDepth, options)) return;
+  const parent = $pos.parent;
+  const positionInContainer = $pos.index();
+  const containerSize = parent.childCount;
+  const candidate = {
+    block: leaf,
+    documentPos: $pos.pos,
+    treeDepth: synthDepth,
+    container: parent,
+    positionInContainer,
+    isFirstChild: positionInContainer === 0,
+    isLastChild: positionInContainer === containerSize - 1,
+    resolvedPos: $pos,
+    editorView: view
+  };
+  if (rejectedByMatchers(candidate, options.matchers)) return;
+  const dom = view.nodeDOM($pos.pos);
+  if (!(dom instanceof HTMLElement)) return;
+  out.push({
+    pos: $pos.pos,
+    rect: dom.getBoundingClientRect(),
+    dom,
+    depth: synthDepth,
+    rank: synthDepth,
+    node: leaf
+  });
+}
+function passesScopeFilters(block, $pos, depth, options) {
+  const { allowedTypes, requiredAncestorTypes } = options;
+  if (allowedTypes !== void 0 && allowedTypes.length > 0) {
+    if (!allowedTypes.includes(block.type.name)) return false;
+  }
+  if (requiredAncestorTypes !== void 0 && requiredAncestorTypes.length > 0) {
+    if (!hasMatchingAncestor($pos, depth, requiredAncestorTypes)) return false;
+  }
+  return true;
+}
+function hasMatchingAncestor($pos, depth, acceptableTypes) {
+  for (let d = depth - 1; d >= 1; d--) {
+    const ancestor = $pos.node(d);
+    if (acceptableTypes.includes(ancestor.type.name)) return true;
+  }
+  return false;
+}
+function rejectedByMatchers(candidate, matchers) {
+  for (const matcher of matchers) {
+    const verdict = matcher.test(candidate);
+    if (verdict === "reject") return true;
+  }
+  return false;
+}
+function applyGutterBias(candidates, x, y, config) {
+  if (config === null) return;
+  for (const c of candidates) {
+    const penalty = gutterBiasWeight(x, y, c.rect, c.depth, config);
+    c.rank = c.depth - penalty;
+  }
+}
+function chooseWinner(candidates) {
+  return candidates.reduce((best, c) => {
+    if (c.rank > best.rank) return c;
+    if (c.rank === best.rank && c.depth > best.depth) return c;
+    return best;
+  });
+}
+
+// src/BlockHandle.ts
+var DEFAULT_NESTED_NODES = ["listItem", "taskItem"];
+var LIST_ITEM_TYPES2 = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+var DEFAULT_NEST_THRESHOLD = 28;
+var NESTED_INDICATOR_INDENT_PX = 24;
+var DROP_ZONE_TOL_LEFT = 80;
+var DROP_ZONE_TOL = 16;
+var blockHandlePluginKey = new state.PluginKey("blockHandle");
+function asDragView(view) {
+  return view;
+}
+function findScrollableAncestor(el) {
+  let cur = el;
+  while (cur) {
+    const style = getComputedStyle(cur);
+    const overflowY = style.overflowY;
+    if ((overflowY === "auto" || overflowY === "scroll") && cur.scrollHeight > cur.clientHeight) {
+      return cur;
+    }
+    cur = cur.parentElement;
+  }
+  return null;
+}
+function resolveBlockAtCoords(view, clientX, clientY, nested) {
+  if (nested.allowedNodes.length === 0) {
+    return resolveTopLevelByY(view, clientY);
+  }
+  const clamped = clampToContent(view, clientX, clientY);
+  if (!clamped) return null;
+  if (nested.gutterBias) {
+    const target = resolveDragTarget(view, clamped.x, clamped.y, {
+      matchers: nested.matchers,
+      gutterBias: nested.gutterBias,
+      allowedTypes: nested.allowedNodes,
+      requiredAncestorTypes: nested.allowedContainers
+    });
+    if (target) {
+      return { pos: target.pos, rect: target.rect, dom: target.dom };
+    }
+    return resolveTopLevelByY(view, clamped.y);
+  }
+  const found = findDeepestBlockAtY(view, clamped.y, nested.allowedNodes, nested.matchers);
+  if (found) {
+    return { pos: found.pos, rect: found.rect, dom: found.dom };
+  }
+  return resolveTopLevelByY(view, clamped.y);
+}
+function resolveTopLevelByY(view, clientY) {
+  const doc = view.state.doc;
+  let offset = 0;
+  let closest = null;
+  for (let i = 0; i < doc.childCount; i++) {
+    const child = doc.child(i);
+    const dom = view.nodeDOM(offset);
+    if (dom instanceof HTMLElement) {
+      const rect = dom.getBoundingClientRect();
+      if (clientY >= rect.top && clientY <= rect.bottom) {
+        return { pos: offset, rect, dom };
+      }
+      const dist = clientY < rect.top ? rect.top - clientY : clientY - rect.bottom;
+      if (closest === null || dist < closest.dist) {
+        closest = { pos: offset, rect, dom, dist };
+      }
+    }
+    offset += child.nodeSize;
+  }
+  if (closest) return { pos: closest.pos, rect: closest.rect, dom: closest.dom };
+  return null;
+}
+var LIST_WRAPPER_TYPE_NAMES = /* @__PURE__ */ new Set(["bulletList", "orderedList", "taskList"]);
+function adjustDropTargetForListWrapper(view, resolved, clientY) {
+  const node = view.state.doc.nodeAt(resolved.pos);
+  if (!node) return resolved;
+  if (!LIST_WRAPPER_TYPE_NAMES.has(node.type.name)) return resolved;
+  if (node.childCount === 0) return resolved;
+  const isAbove = clientY < resolved.rect.top;
+  const isBelow = clientY > resolved.rect.bottom;
+  if (!isAbove && !isBelow) return resolved;
+  const targetIndex = isBelow ? node.childCount - 1 : 0;
+  let childPos = resolved.pos + 1;
+  for (let i = 0; i < targetIndex; i++) {
+    childPos += node.child(i).nodeSize;
+  }
+  const childDom = view.nodeDOM(childPos);
+  if (!(childDom instanceof HTMLElement)) return resolved;
+  return { pos: childPos, rect: childDom.getBoundingClientRect(), dom: childDom };
+}
+function computeDropPlacement(view, clientX, clientY, nested, nestThreshold = DEFAULT_NEST_THRESHOLD) {
+  const initial = resolveBlockAtCoords(view, clientX, clientY, nested);
+  if (!initial) return null;
+  const resolved = adjustDropTargetForListWrapper(view, initial, clientY);
+  if (nestThreshold > 0) {
+    const targetNode = view.state.doc.nodeAt(resolved.pos);
+    if (targetNode && LIST_ITEM_TYPES2.has(targetNode.type.name)) {
+      const targetRect = resolved.rect;
+      const xInTarget = clientX - targetRect.left;
+      const isInsideX = xInTarget >= 0 && xInTarget <= targetRect.width;
+      const isInNestZone = xInTarget >= nestThreshold;
+      const isInsideY = clientY >= targetRect.top && clientY <= targetRect.bottom;
+      if (isInsideX && isInNestZone && isInsideY) {
+        const $resolved = view.state.doc.resolve(resolved.pos);
+        const wrapperPos = $resolved.before();
+        const midY2 = targetRect.top + targetRect.height / 2;
+        return {
+          pos: resolved.pos,
+          rect: targetRect,
+          insertAfter: clientY > midY2,
+          mode: "nested",
+          targetItemPos: resolved.pos,
+          wrapperPos
+        };
+      }
+    }
+  }
+  const rect = resolved.rect;
+  const midY = rect.top + rect.height / 2;
+  const insertAfter = clientY > midY;
+  if (!insertAfter) {
+    const prev = findPreviousSiblingAtSameDepth(view, resolved.pos);
+    if (prev) {
+      return { pos: prev.pos, rect: prev.rect, insertAfter: true, mode: "sibling" };
+    }
+  }
+  return { pos: resolved.pos, rect, insertAfter, mode: "sibling" };
+}
+function findPreviousSiblingAtSameDepth(view, pos) {
+  const doc = view.state.doc;
+  if (pos <= 0) return null;
+  const $pos = doc.resolve(pos);
+  if ($pos.index() === 0) return null;
+  const prevNode = $pos.parent.child($pos.index() - 1);
+  const prevPos = pos - prevNode.nodeSize;
+  const prevDom = view.nodeDOM(prevPos);
+  if (!(prevDom instanceof HTMLElement)) return null;
+  return { pos: prevPos, rect: prevDom.getBoundingClientRect() };
+}
+function createBlockHandlePlugin(options) {
+  const { pluginKey, editor, hideDelay, disableDrag, autoScroll, autoScrollThreshold, autoScrollMaxSpeed, nested, dropIndicator, nestThreshold } = options;
+  const root = document.createElement("div");
+  root.className = "dm-block-handle";
+  root.setAttribute("data-dm-editor-ui", "");
+  const dragBtn = document.createElement("button");
+  dragBtn.type = "button";
+  dragBtn.className = "dm-block-handle-btn dm-block-handle-drag";
+  dragBtn.setAttribute("aria-label", "Drag to reorder, click for options");
+  dragBtn.setAttribute("draggable", "true");
+  dragBtn.innerHTML = core.defaultIcons["dotsSixVertical"] ?? "";
+  const plusBtn = document.createElement("button");
+  plusBtn.type = "button";
+  plusBtn.className = "dm-block-handle-btn dm-block-handle-plus";
+  plusBtn.setAttribute("aria-label", "Add block below");
+  plusBtn.innerHTML = core.defaultIcons["plus"] ?? "";
+  root.appendChild(dragBtn);
+  root.appendChild(plusBtn);
+  const indicator = document.createElement("div");
+  indicator.className = "dm-block-drop-indicator";
+  indicator.setAttribute("data-dm-editor-ui", "");
+  let editorEl = null;
+  let hoverEl = null;
+  let hideTimer = null;
+  let hoverRaf = null;
+  let pendingHoverCoords = null;
+  let currentHoveredPos = null;
+  let dragPressActive = false;
+  let dragPreview = null;
+  let pendingDraggedFrom = null;
+  const DRAGOVER_SILENCE_MS = 1500;
+  const autoScrollState = { raf: null, target: null, lastClientY: null, lastAt: 0 };
+  const resetAutoScroll = () => {
+    if (autoScrollState.raf !== null) {
+      cancelAnimationFrame(autoScrollState.raf);
+    }
+    autoScrollState.raf = null;
+    autoScrollState.target = null;
+    autoScrollState.lastClientY = null;
+    autoScrollState.lastAt = 0;
+  };
+  const clearHideTimer = () => {
+    if (hideTimer !== null) {
+      window.clearTimeout(hideTimer);
+      hideTimer = null;
+    }
+  };
+  const hide = () => {
+    root.removeAttribute("data-show");
+    currentHoveredPos = null;
+  };
+  const scheduleHide = () => {
+    if (editorEl?.hasAttribute("data-block-context-menu-open")) return;
+    clearHideTimer();
+    hideTimer = window.setTimeout(() => {
+      hide();
+      hideTimer = null;
+    }, hideDelay);
+  };
+  const show = (blockEl, blockRect, editorRect) => {
+    const cs = getComputedStyle(blockEl);
+    let lineHeight = parseFloat(cs.lineHeight);
+    if (!Number.isFinite(lineHeight)) {
+      const fontSize = parseFloat(cs.fontSize) || 16;
+      lineHeight = fontSize * 1.2;
+    }
+    const handleHeight = root.offsetHeight || 24;
+    const offsetIntoBlock = Math.max(0, (lineHeight - handleHeight) / 2);
+    const top = blockRect.top - editorRect.top + offsetIntoBlock;
+    root.style.top = `${String(top)}px`;
+    root.setAttribute("data-show", "");
+  };
+  const updateHoverState = (view, pos) => {
+    const current = pluginKey.getState(view.state)?.hoveredPos ?? null;
+    if (current === pos) return;
+    view.dispatch(view.state.tr.setMeta(pluginKey, { hoveredPos: pos }));
+  };
+  const setDraggedFrom = (view, pos) => {
+    view.dispatch(view.state.tr.setMeta(pluginKey, { draggedFrom: pos }));
+  };
+  const onMouseMove = (event) => {
+    if (!editorEl) return;
+    if (dragPressActive) return;
+    if (editorEl.hasAttribute("data-block-context-menu-open")) return;
+    pendingHoverCoords = { x: event.clientX, y: event.clientY };
+    if (hoverRaf !== null) return;
+    hoverRaf = requestAnimationFrame(() => {
+      hoverRaf = null;
+      const coords = pendingHoverCoords;
+      pendingHoverCoords = null;
+      if (!coords || !editorEl) return;
+      if (editorEl.hasAttribute("data-block-context-menu-open")) return;
+      const resolved = resolveBlockAtCoords(editor.view, coords.x, coords.y, nested);
+      if (!resolved) {
+        scheduleHide();
+        return;
+      }
+      clearHideTimer();
+      updateHoverState(editor.view, resolved.pos);
+      if (resolved.pos === currentHoveredPos && root.hasAttribute("data-show")) {
+        return;
+      }
+      currentHoveredPos = resolved.pos;
+      const editorRect = editorEl.getBoundingClientRect();
+      show(resolved.dom, resolved.rect, editorRect);
+    });
+  };
+  const onMouseLeave = () => {
+    scheduleHide();
+  };
+  const onMouseEnter = () => {
+    clearHideTimer();
+  };
+  const onDismissOverlays = () => {
+    if (editorEl?.hasAttribute("data-block-context-menu-open")) return;
+    hide();
+    updateHoverState(editor.view, null);
+  };
+  const onPlusClick = (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    if (!editor.isEditable) return;
+    const state$1 = pluginKey.getState(editor.view.state);
+    const pos = state$1?.hoveredPos ?? null;
+    if (pos === null) return;
+    const node = editor.view.state.doc.nodeAt(pos);
+    if (!node) return;
+    const paragraphType = editor.view.state.schema.nodes["paragraph"];
+    if (!paragraphType) return;
+    editorEl?.dispatchEvent(new Event("dm:dismiss-overlays", { bubbles: false }));
+    const blockEnd = pos + node.nodeSize;
+    const tr = editor.view.state.tr;
+    tr.insert(blockEnd, paragraphType.create());
+    const sel = state.TextSelection.near(tr.doc.resolve(blockEnd + 1));
+    tr.setSelection(sel);
+    editor.view.dispatch(tr.scrollIntoView());
+    editor.view.focus();
+    showFloatingMenu(editor.view);
+  };
+  const onPlusBtnMouseDown = (event) => {
+    event.preventDefault();
+  };
+  const onDragBtnMouseDown = () => {
+    dragPressActive = true;
+    document.addEventListener("mouseup", releaseDragPress, { once: true });
+  };
+  const releaseDragPress = () => {
+    dragPressActive = false;
+    document.removeEventListener("mouseup", releaseDragPress);
+  };
+  const onDragBtnClick = (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    if (!editor.isEditable) return;
+    const state = pluginKey.getState(editor.view.state);
+    const pos = state?.hoveredPos ?? null;
+    if (pos === null) return;
+    editorEl?.dispatchEvent(new CustomEvent("dm:block-context-menu-open", {
+      bubbles: false,
+      detail: { blockPos: pos, anchorElement: dragBtn }
+    }));
+  };
+  const onDocumentDragover = (event) => {
+    autoScrollState.lastClientY = event.clientY;
+    autoScrollState.lastAt = performance.now();
+    const inZone = isCursorOverDropZone(event.clientX, event.clientY);
+    if (inZone) event.preventDefault();
+    if (dropIndicator) {
+      if (!inZone) {
+        indicator.removeAttribute("data-show");
+        return;
+      }
+      updateDropIndicator(event.clientX, event.clientY);
+    }
+  };
+  const onDocumentDrop = (event) => {
+    if (event.defaultPrevented) return;
+    const view = editor.view;
+    const dragging = asDragView(view).dragging;
+    if (!dragging) return;
+    if (!isCursorOverDropZone(event.clientX, event.clientY)) return;
+    if (performBlockDrop(event.clientX, event.clientY)) {
+      event.preventDefault();
+    }
+  };
+  const performBlockDrop = (clientX, clientY) => {
+    const view = editor.view;
+    const state = pluginKey.getState(view.state);
+    const draggedFrom = state?.draggedFrom ?? pendingDraggedFrom ?? asDragView(view).dragging?.node?.from ?? null;
+    if (draggedFrom === null) return false;
+    const sourceNode = view.state.doc.nodeAt(draggedFrom);
+    if (!sourceNode) return false;
+    const placement = computeDropPlacement(view, clientX, clientY, nested, nestThreshold);
+    if (!placement) return false;
+    const tr = view.state.tr;
+    if (placement.mode === "nested" && placement.targetItemPos !== void 0 && placement.wrapperPos !== void 0) {
+      const ok = moveBlockAsNestedChild(tr, draggedFrom, placement.wrapperPos, placement.targetItemPos);
+      if (ok) {
+        view.dispatch(tr.scrollIntoView());
+        return true;
+      }
+    }
+    const targetNode = view.state.doc.nodeAt(placement.pos);
+    const targetEnd = targetNode ? placement.pos + targetNode.nodeSize : placement.pos;
+    const targetPos = placement.insertAfter ? targetEnd : placement.pos;
+    moveBlock(tr, draggedFrom, targetPos);
+    view.dispatch(tr.scrollIntoView());
+    return true;
+  };
+  const isCursorOverDropZone = (clientX, clientY) => {
+    if (!editorEl) return false;
+    const rect = editorEl.getBoundingClientRect();
+    return clientX >= rect.left - DROP_ZONE_TOL_LEFT && clientX <= rect.right + DROP_ZONE_TOL && clientY >= rect.top - DROP_ZONE_TOL && clientY <= rect.bottom + DROP_ZONE_TOL;
+  };
+  const updateDropIndicator = (clientX, clientY) => {
+    if (!editorEl) return;
+    const placement = computeDropPlacement(editor.view, clientX, clientY, nested, nestThreshold);
+    if (!placement) {
+      indicator.removeAttribute("data-show");
+      return;
+    }
+    const editorRect = editorEl.getBoundingClientRect();
+    let lineY;
+    let left;
+    let width;
+    if (placement.mode === "nested") {
+      const indent = NESTED_INDICATOR_INDENT_PX;
+      lineY = placement.rect.bottom - editorRect.top;
+      left = placement.rect.left - editorRect.left + indent;
+      width = Math.max(0, placement.rect.width - indent);
+    } else {
+      lineY = (placement.insertAfter ? placement.rect.bottom : placement.rect.top) - editorRect.top;
+      left = placement.rect.left - editorRect.left;
+      width = placement.rect.width;
+    }
+    indicator.style.top = `${String(lineY)}px`;
+    indicator.style.left = `${String(left)}px`;
+    indicator.style.width = `${String(width)}px`;
+    indicator.setAttribute("data-show", "");
+    indicator.setAttribute("data-mode", placement.mode);
+  };
+  const stopAutoScroll = () => {
+    resetAutoScroll();
+  };
+  const hideDropIndicator = () => {
+    indicator.removeAttribute("data-show");
+  };
+  let dragoverAttached = false;
+  const startDragListeners = () => {
+    if (dragoverAttached) return;
+    document.addEventListener("dragover", onDocumentDragover);
+    document.addEventListener("drop", onDocumentDrop);
+    dragoverAttached = true;
+  };
+  const stopDragListeners = () => {
+    if (!dragoverAttached) return;
+    document.removeEventListener("dragover", onDocumentDragover);
+    document.removeEventListener("drop", onDocumentDrop);
+    dragoverAttached = false;
+  };
+  const autoScrollTick = () => {
+    const target = autoScrollState.target;
+    if (target === null) {
+      autoScrollState.raf = null;
+      return;
+    }
+    if (autoScrollState.lastAt > 0 && performance.now() - autoScrollState.lastAt > DRAGOVER_SILENCE_MS) {
+      stopAutoScroll();
+      stopDragListeners();
+      hideDropIndicator();
+      return;
+    }
+    if (autoScrollState.lastClientY !== null) {
+      const rect = target.getBoundingClientRect();
+      const distFromTop = autoScrollState.lastClientY - rect.top;
+      const distFromBottom = rect.bottom - autoScrollState.lastClientY;
+      let delta = 0;
+      if (distFromTop < autoScrollThreshold && distFromTop >= 0) {
+        delta = -Math.round(autoScrollMaxSpeed * (1 - distFromTop / autoScrollThreshold));
+      } else if (distFromBottom < autoScrollThreshold && distFromBottom >= 0) {
+        delta = Math.round(autoScrollMaxSpeed * (1 - distFromBottom / autoScrollThreshold));
+      }
+      if (delta !== 0) {
+        target.scrollBy(0, delta);
+      }
+    }
+    autoScrollState.raf = requestAnimationFrame(autoScrollTick);
+  };
+  const startAutoScroll = () => {
+    if (!autoScroll) return;
+    if (!editorEl) return;
+    const target = findScrollableAncestor(editorEl);
+    if (!target) return;
+    autoScrollState.target = target;
+    autoScrollState.lastClientY = null;
+    autoScrollState.lastAt = performance.now();
+    autoScrollState.raf = requestAnimationFrame(autoScrollTick);
+  };
+  const onDragStart = (event) => {
+    if (disableDrag || !editor.isEditable) {
+      event.preventDefault();
+      return;
+    }
+    const state$1 = pluginKey.getState(editor.view.state);
+    const pos = state$1?.hoveredPos ?? null;
+    if (pos === null) {
+      event.preventDefault();
+      return;
+    }
+    pendingDraggedFrom = pos;
+    const node = editor.view.state.doc.nodeAt(pos);
+    if (!node) {
+      event.preventDefault();
+      return;
+    }
+    const sourceEnd = pos + node.nodeSize;
+    const slice = editor.view.state.doc.slice(pos, sourceEnd);
+    const nodeSelection = state.NodeSelection.create(editor.view.state.doc, pos);
+    if (event.dataTransfer) {
+      event.dataTransfer.effectAllowed = "move";
+      event.dataTransfer.setData("text/plain", node.textContent);
+      const dom = editor.view.nodeDOM(pos);
+      if (dom instanceof HTMLElement) {
+        const ghost = createDragGhost(dom);
+        dragPreview = ghost.wrapper;
+        event.dataTransfer.setDragImage(ghost.wrapper, 10, 10);
+      }
+    }
+    asDragView(editor.view).dragging = {
+      slice,
+      move: true,
+      node: nodeSelection
+    };
+    window.setTimeout(() => {
+      if (pendingDraggedFrom === null) return;
+      editor.view.dispatch(
+        editor.view.state.tr.setSelection(nodeSelection).setMeta(pluginKey, { draggedFrom: pos })
+      );
+      editorEl?.dispatchEvent(new Event("dm:dismiss-overlays", { bubbles: false }));
+      hide();
+    }, 0);
+    startAutoScroll();
+    startDragListeners();
+  };
+  const teardownDragPreview = () => {
+    if (dragPreview) {
+      dragPreview.remove();
+      dragPreview = null;
+    }
+  };
+  const onDragEnd = () => {
+    asDragView(editor.view).dragging = null;
+    setDraggedFrom(editor.view, null);
+    pendingDraggedFrom = null;
+    stopAutoScroll();
+    stopDragListeners();
+    hideDropIndicator();
+    teardownDragPreview();
+    releaseDragPress();
+  };
+  return new state.Plugin({
+    key: pluginKey,
+    state: {
+      init: () => ({ hoveredPos: null, draggedFrom: null }),
+      apply(tr, prev) {
+        const meta = tr.getMeta(pluginKey);
+        let next = prev;
+        if (meta) {
+          if ("hoveredPos" in meta) {
+            next = { ...next, hoveredPos: meta.hoveredPos ?? null };
+          }
+          if ("draggedFrom" in meta) {
+            next = { ...next, draggedFrom: meta.draggedFrom ?? null };
+          }
+        }
+        if (tr.docChanged) {
+          if (next.hoveredPos !== null) {
+            const mapped = tr.mapping.mapResult(next.hoveredPos, 1);
+            next = { ...next, hoveredPos: mapped.deleted ? null : mapped.pos };
+          }
+          if (next.draggedFrom !== null) {
+            const mapped = tr.mapping.mapResult(next.draggedFrom, 1);
+            next = { ...next, draggedFrom: mapped.deleted ? null : mapped.pos };
+          }
+        }
+        return next;
+      }
+    },
+    props: {
+      // Custom drop handler - gives Notion-like "above-mid → insert before,
+      // below-mid → insert after" block-level semantics instead of PM's
+      // default `posAtCoords + dropPoint` which for short paragraphs
+      // rounds to an arbitrary neighbour boundary and surprises users.
+      // The `moveBlock` helper handles the delete+insert + position
+      // adjustment so the block keeps its attrs (UniqueID, colors) and
+      // the doc ends up in a predictable state.
+      handleDrop(_view, event, _slice, moved) {
+        if (!moved) return false;
+        if (performBlockDrop(event.clientX, event.clientY)) {
+          event.preventDefault();
+          return true;
+        }
+        event.preventDefault();
+        return true;
+      }
+    },
+    view: (editorView) => {
+      editorEl = editorView.dom.closest(".dm-editor");
+      if (!editorEl) {
+        return { destroy: () => {
+        } };
+      }
+      editorEl.classList.add("dm-editor--has-block-handle");
+      editorEl.appendChild(root);
+      if (dropIndicator) {
+        editorEl.appendChild(indicator);
+      }
+      hide();
+      hideDropIndicator();
+      hoverEl = editorEl.parentElement ?? editorEl;
+      hoverEl.addEventListener("mousemove", onMouseMove);
+      hoverEl.addEventListener("mouseleave", onMouseLeave);
+      hoverEl.addEventListener("mouseenter", onMouseEnter);
+      editorEl.addEventListener("dm:dismiss-overlays", onDismissOverlays);
+      plusBtn.addEventListener("mousedown", onPlusBtnMouseDown);
+      plusBtn.addEventListener("click", onPlusClick);
+      dragBtn.addEventListener("mousedown", onDragBtnMouseDown);
+      dragBtn.addEventListener("click", onDragBtnClick);
+      dragBtn.addEventListener("dragstart", onDragStart);
+      dragBtn.addEventListener("dragend", onDragEnd);
+      return {
+        destroy: () => {
+          clearHideTimer();
+          stopAutoScroll();
+          stopDragListeners();
+          hideDropIndicator();
+          indicator.remove();
+          teardownDragPreview();
+          if (hoverRaf !== null) {
+            cancelAnimationFrame(hoverRaf);
+            hoverRaf = null;
+          }
+          hoverEl?.removeEventListener("mousemove", onMouseMove);
+          hoverEl?.removeEventListener("mouseleave", onMouseLeave);
+          hoverEl?.removeEventListener("mouseenter", onMouseEnter);
+          editorEl?.removeEventListener("dm:dismiss-overlays", onDismissOverlays);
+          plusBtn.removeEventListener("mousedown", onPlusBtnMouseDown);
+          plusBtn.removeEventListener("click", onPlusClick);
+          dragBtn.removeEventListener("mousedown", onDragBtnMouseDown);
+          document.removeEventListener("mouseup", releaseDragPress);
+          dragBtn.removeEventListener("click", onDragBtnClick);
+          dragBtn.removeEventListener("dragstart", onDragStart);
+          dragBtn.removeEventListener("dragend", onDragEnd);
+          editorEl?.classList.remove("dm-editor--has-block-handle");
+          root.remove();
+          editorEl = null;
+          hoverEl = null;
+        }
+      };
+    }
+  });
+}
+var BlockHandle = core.Extension.create({
+  name: "blockHandle",
+  addOptions() {
+    return {
+      hideDelay: 200,
+      disableDrag: false,
+      autoScroll: true,
+      autoScrollThreshold: 48,
+      autoScrollMaxSpeed: 18,
+      nested: false,
+      dropIndicator: true,
+      nestThreshold: DEFAULT_NEST_THRESHOLD
+    };
+  },
+  addProseMirrorPlugins() {
+    const editor = this.editor;
+    if (!editor) return [];
+    return [
+      createBlockHandlePlugin({
+        pluginKey: blockHandlePluginKey,
+        editor,
+        hideDelay: this.options.hideDelay ?? 200,
+        disableDrag: this.options.disableDrag ?? false,
+        autoScroll: this.options.autoScroll ?? true,
+        autoScrollThreshold: this.options.autoScrollThreshold ?? 48,
+        autoScrollMaxSpeed: this.options.autoScrollMaxSpeed ?? 18,
+        nested: resolveNestedConfig(this.options.nested),
+        dropIndicator: this.options.dropIndicator ?? true,
+        nestThreshold: this.options.nestThreshold ?? DEFAULT_NEST_THRESHOLD
+      })
+    ];
+  }
+});
+function resolveNestedConfig(nested) {
+  if (nested === true) {
+    return {
+      allowedNodes: [...DEFAULT_NESTED_NODES],
+      allowedContainers: [],
+      gutterBias: null,
+      matchers: [...DEFAULT_BLOCK_MATCHERS]
+    };
+  }
+  if (nested && typeof nested === "object") {
+    const allowedNodes = nested.allowedNodes ?? DEFAULT_NESTED_NODES;
+    if (allowedNodes.length === 0) {
+      return { allowedNodes: [], allowedContainers: [], gutterBias: null, matchers: [] };
+    }
+    const useDefaults = nested.defaultMatchers ?? true;
+    const matchers = [];
+    if (useDefaults) matchers.push(...DEFAULT_BLOCK_MATCHERS);
+    if (nested.matchers) matchers.push(...nested.matchers);
+    return {
+      allowedNodes: [...allowedNodes],
+      allowedContainers: nested.allowedContainers ? [...nested.allowedContainers] : [],
+      gutterBias: resolveGutterBias(nested.promoteOnEdge),
+      matchers
+    };
+  }
+  return { allowedNodes: [], allowedContainers: [], gutterBias: null, matchers: [] };
+}
+var KeyboardReorder = core.Extension.create({
+  name: "keyboardReorder",
+  addKeyboardShortcuts() {
+    const { editor } = this;
+    return {
+      "Mod-Shift-ArrowUp": () => moveCurrentBlock(editor, "up"),
+      "Mod-Shift-ArrowDown": () => moveCurrentBlock(editor, "down")
+    };
+  }
+});
+function moveCurrentBlock(editor, direction) {
+  if (!editor || editor.isDestroyed) return false;
+  if (!editor.isEditable) return false;
+  const { state: state$1, view } = editor;
+  const { $from } = state$1.selection;
+  const topLevel = findTopLevelBlock(state$1.doc, $from.pos);
+  if (!topLevel) return false;
+  if (direction === "up" && topLevel.index === 0) return false;
+  if (direction === "down" && topLevel.index >= state$1.doc.childCount - 1) return false;
+  const selectionOffsetInBlock = Math.max(
+    0,
+    Math.min($from.pos - topLevel.pos, topLevel.node.nodeSize - 1)
+  );
+  let targetPos;
+  if (direction === "up") {
+    targetPos = state$1.doc.resolve(topLevel.pos).posAtIndex(topLevel.index - 1, 0);
+  } else {
+    const nextSibling = state$1.doc.child(topLevel.index + 1);
+    const nextStart = state$1.doc.resolve(topLevel.pos).posAtIndex(topLevel.index + 1, 0);
+    targetPos = nextStart + nextSibling.nodeSize;
+  }
+  const tr = state$1.tr;
+  moveBlock(tr, topLevel.pos, targetPos);
+  const newBlockPos = direction === "up" ? targetPos : targetPos - topLevel.node.nodeSize;
+  const selectionPos = Math.min(
+    newBlockPos + selectionOffsetInBlock,
+    Math.max(0, tr.doc.content.size - 1)
+  );
+  tr.setSelection(state.TextSelection.near(tr.doc.resolve(selectionPos)));
+  view.dispatch(tr.scrollIntoView());
+  return true;
+}
+function deleteBlock(tr, blockPos) {
+  if (blockPos < 0 || blockPos >= tr.doc.content.size) return tr;
+  const node = tr.doc.nodeAt(blockPos);
+  if (!node) return tr;
+  const blockEnd = blockPos + node.nodeSize;
+  const { from, to } = expandToEmptyWrappers(tr.doc, blockPos, blockEnd);
+  const wouldEmptyDoc = from === 0 && to === tr.doc.content.size;
+  if (wouldEmptyDoc) {
+    const paragraphType = tr.doc.type.schema.nodes["paragraph"];
+    if (!paragraphType) {
+      return tr;
+    }
+    const replacement = paragraphType.createAndFill();
+    if (!replacement) return tr;
+    tr.replaceWith(from, to, replacement);
+    tr.setSelection(state.TextSelection.near(tr.doc.resolve(from + 1)));
+    return tr;
+  }
+  tr.delete(from, to);
+  return tr;
+}
+function duplicateBlock(tr, blockPos, transformAttrs) {
+  if (blockPos < 0 || blockPos >= tr.doc.content.size) return tr;
+  const node = tr.doc.nodeAt(blockPos);
+  if (!node) return tr;
+  const blockEnd = blockPos + node.nodeSize;
+  const attrs = transformAttrs ? transformAttrs(node.attrs) : node.attrs;
+  const copy = node.type.create(attrs, node.content, node.marks);
+  tr.insert(blockEnd, copy);
+  return tr;
+}
+function turnIntoBlock(tr, blockPos, targetType, attrs) {
+  if (blockPos < 0 || blockPos >= tr.doc.content.size) return tr;
+  const node = tr.doc.nodeAt(blockPos);
+  if (!node) return tr;
+  if (!targetType.isTextblock) return tr;
+  const blockEnd = blockPos + node.nodeSize;
+  const validKeys = Object.keys(targetType.spec.attrs ?? {});
+  const preserved = {};
+  const sourceAttrs = node.attrs;
+  for (const key of validKeys) {
+    if (key in sourceAttrs) preserved[key] = sourceAttrs[key];
+  }
+  const mergedAttrs = attrs ? { ...preserved, ...attrs } : preserved;
+  tr.setBlockType(blockPos, blockEnd, targetType, mergedAttrs);
+  return tr;
+}
+function turnIntoWrapper(editor, blockPos, command) {
+  const { state: state$1 } = editor.view;
+  if (blockPos < 0 || blockPos >= state$1.doc.content.size) return false;
+  const node = state$1.doc.nodeAt(blockPos);
+  if (!node?.type.isTextblock) return false;
+  const isListTarget = command !== "toggleBlockquote";
+  const needsStepDown = isListTarget && node.type.name !== "paragraph";
+  const tr = state$1.tr;
+  if (needsStepDown) {
+    const paragraphType = state$1.schema.nodes["paragraph"];
+    if (!paragraphType) return false;
+    tr.setBlockType(blockPos, blockPos + node.nodeSize, paragraphType);
+  }
+  tr.setSelection(state.TextSelection.create(tr.doc, blockPos + 1));
+  editor.view.dispatch(tr);
+  switch (command) {
+    case "toggleBulletList":
+      return editor.commands.toggleBulletList();
+    case "toggleOrderedList":
+      return editor.commands.toggleOrderedList();
+    case "toggleTaskList":
+      return editor.commands.toggleTaskList();
+    case "toggleBlockquote":
+      return editor.commands.toggleBlockquote();
+  }
+}
+
+// src/BlockContextMenu.ts
+var blockContextMenuPluginKey = new state.PluginKey("blockContextMenu");
+var DEFAULT_TURN_INTO = [
+  { label: "Paragraph", icon: "textT", nodeType: "paragraph" },
+  { label: "Heading 1", icon: "textHOne", nodeType: "heading", attrs: { level: 1 } },
+  { label: "Heading 2", icon: "textHTwo", nodeType: "heading", attrs: { level: 2 } },
+  { label: "Heading 3", icon: "textHThree", nodeType: "heading", attrs: { level: 3 } },
+  { label: "Bullet list", icon: "listBullets", nodeType: "bulletList", command: "toggleBulletList" },
+  { label: "Ordered list", icon: "listNumbers", nodeType: "orderedList", command: "toggleOrderedList" },
+  { label: "To-do list", icon: "listChecks", nodeType: "taskList", command: "toggleTaskList" },
+  { label: "Quote", icon: "quotes", nodeType: "blockquote", command: "toggleBlockquote" },
+  { label: "Code block", icon: "codeBlock", nodeType: "codeBlock" }
+];
+function defaultCopyLinkUrl(blockId) {
+  if (typeof window === "undefined") return `#${blockId}`;
+  const { pathname, search } = window.location;
+  return `${pathname}${search}#${blockId}`;
+}
+function matchingSelectorFor(anchor) {
+  const ariaLabel = anchor.getAttribute("aria-label");
+  if (ariaLabel) {
+    const escaped = ariaLabel.replace(/"/g, '\\"');
+    return `button[aria-label="${escaped}"]`;
+  }
+  return null;
+}
+function createBlockContextMenuPlugin(options) {
+  const { pluginKey, editor, turnIntoEnabled, turnIntoTargets, copyLinkEnabled, onCopyLink, blockColorEnabled } = options;
+  const uniqueIDExt = editor.extensionManager.extensions.find((ext) => ext.name === "uniqueID");
+  const uniqueIDAttrName = uniqueIDExt ? uniqueIDExt.options.attributeName ?? "id" : null;
+  const uniqueIDGenerate = uniqueIDExt ? uniqueIDExt.options.generateID ?? null : null;
+  const blockColorExt = editor.extensionManager.extensions.find((ext) => ext.name === "blockColor");
+  const blockColorOpts = blockColorExt ? blockColorExt.options : null;
+  const blockColorTypes = blockColorOpts?.types ?? null;
+  const blockBgPalette = blockColorOpts?.bgColors ?? [];
+  const blockTextPalette = blockColorOpts?.textColors ?? [];
+  const root = document.createElement("div");
+  root.className = "dm-block-context-menu";
+  root.setAttribute("role", "menu");
+  root.setAttribute("aria-label", "Block options");
+  root.setAttribute("data-dm-editor-ui", "");
+  let editorEl = null;
+  let cleanupFloating = null;
+  let currentBlockPos = null;
+  let focusedIndex = 0;
+  let menuItemButtons = [];
+  let initialFocusRaf = null;
+  let scrollLocked = false;
+  const isOpen = () => root.hasAttribute("data-show");
+  const onBlockScroll = (event) => {
+    const target = event.target;
+    if (target instanceof Node && root.contains(target)) {
+      const hasOverflow = root.scrollHeight > root.clientHeight;
+      if (hasOverflow) return;
+    }
+    event.preventDefault();
+  };
+  const lockScroll = () => {
+    if (scrollLocked) return;
+    scrollLocked = true;
+    document.addEventListener("wheel", onBlockScroll, { passive: false });
+    document.addEventListener("touchmove", onBlockScroll, { passive: false });
+  };
+  const unlockScroll = () => {
+    if (!scrollLocked) return;
+    scrollLocked = false;
+    document.removeEventListener("wheel", onBlockScroll);
+    document.removeEventListener("touchmove", onBlockScroll);
+  };
+  const hide = () => {
+    if (initialFocusRaf !== null) {
+      cancelAnimationFrame(initialFocusRaf);
+      initialFocusRaf = null;
+    }
+    cleanupFloating?.();
+    cleanupFloating = null;
+    unlockScroll();
+    editorEl?.removeAttribute("data-block-context-menu-open");
+    const view = editor.view;
+    if (view) {
+      const tr = view.state.tr.setMeta(pluginKey, { activeBlockPos: null });
+      tr.setMeta("addToHistory", false);
+      view.dispatch(tr);
+    }
+    root.removeAttribute("data-show");
+    currentBlockPos = null;
+    menuItemButtons = [];
+    focusedIndex = 0;
+  };
+  const focusItem = (index) => {
+    if (menuItemButtons.length === 0) return;
+    const clamped = Math.max(0, Math.min(index, menuItemButtons.length - 1));
+    for (let i = 0; i < menuItemButtons.length; i++) {
+      const btn = menuItemButtons[i];
+      if (btn) btn.tabIndex = i === clamped ? 0 : -1;
+    }
+    focusedIndex = clamped;
+    menuItemButtons[clamped]?.focus();
+  };
+  const runAndClose = (apply) => {
+    const tr = editor.view.state.tr;
+    try {
+      apply(tr);
+      editor.view.dispatch(tr.scrollIntoView());
+    } finally {
+      hide();
+      editor.view.focus();
+    }
+  };
+  const runDelete = () => {
+    if (currentBlockPos === null) return;
+    const pos = currentBlockPos;
+    runAndClose((tr) => {
+      deleteBlock(tr, pos);
+    });
+  };
+  const runDuplicate = () => {
+    if (currentBlockPos === null) return;
+    const pos = currentBlockPos;
+    const transformAttrs = uniqueIDAttrName && uniqueIDGenerate ? (attrs) => ({ ...attrs, [uniqueIDAttrName]: uniqueIDGenerate() }) : void 0;
+    runAndClose((tr) => {
+      duplicateBlock(tr, pos, transformAttrs);
+    });
+  };
+  const runCopyLink = (blockId) => {
+    const url = onCopyLink(blockId, editor);
+    void core.writeToClipboard(url).then((ok) => {
+      const name = ok ? "dm:copy-link-success" : "dm:copy-link-error";
+      editorEl?.dispatchEvent(new CustomEvent(name, {
+        bubbles: false,
+        detail: { url, blockId }
+      }));
+    });
+    hide();
+    editor.view.focus();
+  };
+  const runTurnInto = (target) => {
+    if (currentBlockPos === null) return;
+    const sourceNode = editor.view.state.doc.nodeAt(currentBlockPos);
+    if (!sourceNode) return;
+    const pos = sourceNode.type.isTextblock ? currentBlockPos : currentBlockPos + 1;
+    if (target.command) {
+      turnIntoWrapper(editor, pos, target.command);
+      hide();
+      editor.view.focus();
+      return;
+    }
+    const targetType = editor.view.state.schema.nodes[target.nodeType];
+    if (!targetType) return;
+    runAndClose((tr) => {
+      turnIntoBlock(tr, pos, targetType, target.attrs);
+    });
+  };
+  const runSetColor = (attr, color) => {
+    if (currentBlockPos === null) return;
+    const pos = currentBlockPos;
+    runAndClose((tr) => {
+      const n = tr.doc.nodeAt(pos);
+      if (!n) return;
+      tr.setNodeMarkup(pos, void 0, { ...n.attrs, [attr]: color });
+      core.stripInlineColorConflicts(
+        tr,
+        editor.view.state,
+        pos,
+        pos + n.nodeSize,
+        attr === "textColor" ? "text" : "bg"
+      );
+    });
+  };
+  const renderItems = (blockPos) => {
+    root.innerHTML = "";
+    menuItemButtons = [];
+    const node = editor.view.state.doc.nodeAt(blockPos);
+    if (!node) return;
+    const primaryGroup = document.createElement("div");
+    primaryGroup.className = "dm-block-context-menu-group";
+    primaryGroup.setAttribute("role", "group");
+    primaryGroup.appendChild(
+      makeItem("Delete", "trash", runDelete)
+    );
+    if (node.type.name !== "horizontalRule") {
+      primaryGroup.appendChild(
+        makeItem("Duplicate", "copy", runDuplicate)
+      );
+    }
+    if (copyLinkEnabled && uniqueIDAttrName) {
+      const id = node.attrs[uniqueIDAttrName];
+      if (typeof id === "string" && id.length > 0) {
+        primaryGroup.appendChild(
+          makeItem("Copy link", "link", () => {
+            runCopyLink(id);
+          })
+        );
+      }
+    }
+    root.appendChild(primaryGroup);
+    if (blockColorEnabled && blockColorTypes?.includes(node.type.name)) {
+      const label = document.createElement("div");
+      label.className = "dm-block-context-menu-group-label";
+      label.textContent = "Colors";
+      root.appendChild(label);
+      const currentBg = node.attrs["bgColor"];
+      const currentText = node.attrs["textColor"];
+      root.appendChild(
+        buildSwatchRow(
+          "Text color",
+          "text",
+          blockTextPalette,
+          currentText,
+          (color) => {
+            runSetColor("textColor", color);
+          }
+        )
+      );
+      root.appendChild(
+        buildSwatchRow(
+          "Background",
+          "bg",
+          blockBgPalette,
+          currentBg,
+          (color) => {
+            runSetColor("bgColor", color);
+          }
+        )
+      );
+    }
+    const sourceIsTextblock = node.type.isTextblock;
+    const sourceIsWrapper = !sourceIsTextblock && node.firstChild?.isTextblock === true;
+    if (turnIntoEnabled && (sourceIsTextblock || sourceIsWrapper)) {
+      const ancestorPos = sourceIsTextblock ? blockPos : blockPos + 1;
+      const $pos = editor.view.state.doc.resolve(ancestorPos);
+      const ancestorTypeNames = /* @__PURE__ */ new Set();
+      for (let d = 0; d <= $pos.depth; d++) {
+        ancestorTypeNames.add($pos.node(d).type.name);
+      }
+      const isListItemFamilySource = node.type.name === "listItem" || node.type.name === "taskItem";
+      const eligible = turnIntoTargets.filter((target) => {
+        const type = editor.view.state.schema.nodes[target.nodeType];
+        if (!type) return false;
+        if (target.command) {
+          if (ancestorTypeNames.has(target.nodeType)) return false;
+          if (target.command === "toggleBlockquote" && isListItemFamilySource) return false;
+          return true;
+        }
+        if (!sourceIsTextblock) return false;
+        if (!type.isTextblock) return false;
+        if (type.name !== node.type.name) return true;
+        const targetAttrs = target.attrs;
+        if (!targetAttrs) return false;
+        const nodeAttrs = node.attrs;
+        for (const k of Object.keys(targetAttrs)) {
+          if (nodeAttrs[k] !== targetAttrs[k]) return true;
+        }
+        return false;
+      });
+      if (eligible.length > 0) {
+        const label = document.createElement("div");
+        label.className = "dm-block-context-menu-group-label";
+        label.textContent = "Turn into";
+        root.appendChild(label);
+        const group = document.createElement("div");
+        group.className = "dm-block-context-menu-group";
+        group.setAttribute("role", "group");
+        group.setAttribute("aria-label", "Turn into");
+        for (const target of eligible) {
+          group.appendChild(
+            makeItem(target.label, target.icon, () => {
+              runTurnInto(target);
+            })
+          );
+        }
+        root.appendChild(group);
+      }
+    }
+  };
+  const createMenuButton = (config) => {
+    const btn = document.createElement("button");
+    btn.type = "button";
+    btn.className = config.className;
+    btn.setAttribute("role", "menuitem");
+    btn.setAttribute("aria-label", config.ariaLabel);
+    if (config.attributes) {
+      for (const [k, v] of Object.entries(config.attributes)) {
+        btn.setAttribute(k, v);
+      }
+    }
+    btn.tabIndex = menuItemButtons.length === 0 ? 0 : -1;
+    btn.addEventListener("mousedown", (e) => {
+      e.preventDefault();
+    });
+    btn.addEventListener("click", (e) => {
+      e.preventDefault();
+      config.onClick();
+    });
+    menuItemButtons.push(btn);
+    return btn;
+  };
+  const makeItem = (label, iconKey, onClick) => {
+    const btn = createMenuButton({
+      className: "dm-block-context-menu-item",
+      ariaLabel: label,
+      onClick
+    });
+    const iconHTML = core.defaultIcons[iconKey] ?? "";
+    const iconSpan = document.createElement("span");
+    iconSpan.className = "dm-block-context-menu-item-icon";
+    iconSpan.setAttribute("aria-hidden", "true");
+    iconSpan.innerHTML = iconHTML;
+    const labelSpan = document.createElement("span");
+    labelSpan.className = "dm-block-context-menu-item-label";
+    labelSpan.textContent = label;
+    btn.appendChild(iconSpan);
+    btn.appendChild(labelSpan);
+    return btn;
+  };
+  const makeSwatch = (variant, color, current, onClick) => {
+    const ariaLabel = color === null ? variant === "bg" ? "No background" : "Default text color" : `${variant === "bg" ? "Background" : "Text color"}: ${color}`;
+    const isPressed = current === color || color === null && !current;
+    return createMenuButton({
+      className: `dm-block-color-swatch dm-block-color-swatch--${variant}`,
+      ariaLabel,
+      onClick: () => {
+        onClick(color);
+      },
+      attributes: {
+        "data-color": color ?? "null",
+        "aria-pressed": isPressed ? "true" : "false"
+      }
+    });
+  };
+  const buildSwatchRow = (rowLabel, variant, palette, current, onClick) => {
+    const row = document.createElement("div");
+    row.className = "dm-block-color-row";
+    row.setAttribute("role", "group");
+    row.setAttribute("aria-label", rowLabel);
+    const visuallyHidden = document.createElement("span");
+    visuallyHidden.className = "dm-block-color-row-label";
+    visuallyHidden.textContent = rowLabel;
+    row.appendChild(visuallyHidden);
+    row.appendChild(makeSwatch(variant, null, current, onClick));
+    for (const c of palette) {
+      row.appendChild(makeSwatch(variant, c, current, onClick));
+    }
+    return row;
+  };
+  const open = (detail) => {
+    if (!editorEl) return;
+    const node = editor.view.state.doc.nodeAt(detail.blockPos);
+    if (!node) return;
+    currentBlockPos = detail.blockPos;
+    renderItems(detail.blockPos);
+    if (menuItemButtons.length === 0) return;
+    editorEl.setAttribute("data-block-context-menu-open", "");
+    editorEl.dispatchEvent(new Event("dm:dismiss-overlays", { bubbles: false }));
+    root.setAttribute("data-show", "");
+    lockScroll();
+    {
+      const tr = editor.view.state.tr.setMeta(pluginKey, { activeBlockPos: detail.blockPos });
+      tr.setMeta("addToHistory", false);
+      editor.view.dispatch(tr);
+    }
+    cleanupFloating?.();
+    let anchorEl = detail.anchorElement;
+    const bubbleMenuRef = anchorEl.closest(".dm-bubble-menu");
+    const matchingSelector = matchingSelectorFor(anchorEl);
+    let lastRect = anchorEl.getBoundingClientRect();
+    const virtualRef = {
+      getBoundingClientRect: () => {
+        if (anchorEl.isConnected) {
+          lastRect = anchorEl.getBoundingClientRect();
+          return lastRect;
+        }
+        if (matchingSelector && bubbleMenuRef?.isConnected) {
+          const fresh = bubbleMenuRef.querySelector(matchingSelector);
+          if (fresh) {
+            anchorEl = fresh;
+            lastRect = fresh.getBoundingClientRect();
+            return lastRect;
+          }
+        }
+        return lastRect;
+      }
+    };
+    cleanupFloating = core.positionFloatingOnce(virtualRef, root, {
+      placement: "right-start",
+      offsetValue: 4
+    });
+    focusedIndex = 0;
+    initialFocusRaf = requestAnimationFrame(() => {
+      initialFocusRaf = null;
+      menuItemButtons[0]?.focus();
+    });
+  };
+  const onOpen = (event) => {
+    const detail = event.detail;
+    if (!detail) return;
+    open(detail);
+  };
+  const onDismiss = () => {
+    if (!isOpen()) return;
+    hide();
+  };
+  const onClickOutside = (event) => {
+    if (!isOpen()) return;
+    const target = event.target;
+    if (!(target instanceof Node)) return;
+    if (root.contains(target)) return;
+    hide();
+  };
+  const onKeyDown = (event) => {
+    if (!isOpen()) return;
+    switch (event.key) {
+      case "ArrowDown":
+        event.preventDefault();
+        focusItem((focusedIndex + 1) % menuItemButtons.length);
+        return;
+      case "ArrowUp":
+        event.preventDefault();
+        focusItem((focusedIndex - 1 + menuItemButtons.length) % menuItemButtons.length);
+        return;
+      case "Home":
+        event.preventDefault();
+        focusItem(0);
+        return;
+      case "End":
+        event.preventDefault();
+        focusItem(menuItemButtons.length - 1);
+        return;
+      case "Escape":
+        event.preventDefault();
+        event.stopPropagation();
+        hide();
+        editor.view.focus();
+        return;
+      default:
+        return;
+    }
+  };
+  return new state.Plugin({
+    key: pluginKey,
+    state: {
+      init: () => ({ activeBlockPos: null }),
+      apply(tr, value) {
+        const meta = tr.getMeta(pluginKey);
+        if (meta && "activeBlockPos" in meta) {
+          return { activeBlockPos: meta.activeBlockPos ?? null };
+        }
+        if (value.activeBlockPos !== null && tr.docChanged) {
+          const mapped = tr.mapping.mapResult(value.activeBlockPos, 1);
+          return { activeBlockPos: mapped.deleted ? null : mapped.pos };
+        }
+        return value;
+      }
+    },
+    props: {
+      decorations(state) {
+        const plugin = pluginKey.getState(state);
+        const activePos = plugin?.activeBlockPos ?? null;
+        if (activePos === null) return null;
+        const node = state.doc.nodeAt(activePos);
+        if (!node) return null;
+        return view.DecorationSet.create(state.doc, [
+          view.Decoration.node(activePos, activePos + node.nodeSize, { class: "dm-block-context-active" })
+        ]);
+      }
+    },
+    view: (editorView) => {
+      editorEl = editorView.dom.closest(".dm-editor");
+      if (!editorEl) return { destroy: () => {
+      } };
+      editorEl.appendChild(root);
+      hide();
+      editorEl.addEventListener("dm:block-context-menu-open", onOpen);
+      editorEl.addEventListener("dm:dismiss-overlays", onDismiss);
+      document.addEventListener("mousedown", onClickOutside, true);
+      root.addEventListener("keydown", onKeyDown);
+      return {
+        destroy: () => {
+          hide();
+          editorEl?.removeEventListener("dm:block-context-menu-open", onOpen);
+          editorEl?.removeEventListener("dm:dismiss-overlays", onDismiss);
+          document.removeEventListener("mousedown", onClickOutside, true);
+          root.removeEventListener("keydown", onKeyDown);
+          root.remove();
+          editorEl = null;
+        }
+      };
+    }
+  });
+}
+var BlockContextMenu = core.Extension.create({
+  name: "blockContextMenu",
+  addOptions() {
+    return {
+      turnIntoEnabled: true,
+      turnIntoTargets: DEFAULT_TURN_INTO,
+      copyLinkEnabled: true,
+      onCopyLink: defaultCopyLinkUrl,
+      blockColorEnabled: true
+    };
+  },
+  addProseMirrorPlugins() {
+    const editor = this.editor;
+    if (!editor) return [];
+    const opts = this.options;
+    return [
+      createBlockContextMenuPlugin({
+        pluginKey: blockContextMenuPluginKey,
+        editor,
+        turnIntoEnabled: opts.turnIntoEnabled ?? true,
+        turnIntoTargets: opts.turnIntoTargets ?? DEFAULT_TURN_INTO,
+        copyLinkEnabled: opts.copyLinkEnabled ?? true,
+        onCopyLink: opts.onCopyLink ?? defaultCopyLinkUrl,
+        blockColorEnabled: opts.blockColorEnabled ?? true
+      })
+    ];
+  }
+});
+var idCounter = 0;
+function createSlashSuggestionRenderer() {
+  let root = null;
+  let cleanupFloating = null;
+  let itemButtons = [];
+  let flatItems = [];
+  let selectedIndex = 0;
+  let currentCommand = null;
+  let destroyed = false;
+  const rendererId = `dm-slash-${String(++idCounter)}`;
+  const renderPopup = (props) => {
+    if (!root) return;
+    root.innerHTML = "";
+    itemButtons = [];
+    flatItems = [];
+    if (props.items.length === 0) {
+      const empty = document.createElement("div");
+      empty.className = "dm-slash-command-empty";
+      empty.setAttribute("role", "status");
+      empty.setAttribute("aria-live", "polite");
+      empty.textContent = "No matches";
+      root.appendChild(empty);
+      return;
+    }
+    const groups = core.groupFloatingMenuItems(props.items);
+    for (const group of groups) {
+      if (group.name) {
+        const label = document.createElement("div");
+        label.className = "dm-slash-command-group-label";
+        label.textContent = group.name;
+        root.appendChild(label);
+      }
+      const groupEl = document.createElement("div");
+      groupEl.className = "dm-slash-command-group";
+      groupEl.setAttribute("role", "group");
+      if (group.name) groupEl.setAttribute("aria-label", group.name);
+      for (const item of group.items) {
+        const btn = document.createElement("button");
+        btn.type = "button";
+        btn.className = "dm-slash-command-item";
+        btn.setAttribute("role", "menuitem");
+        btn.setAttribute("aria-label", item.label);
+        btn.tabIndex = -1;
+        btn.id = `${rendererId}-item-${String(flatItems.length)}`;
+        const iconHTML = item.icon ? core.defaultIcons[item.icon] ?? "" : "";
+        if (iconHTML) {
+          const iconSpan = document.createElement("span");
+          iconSpan.className = "dm-slash-command-item-icon";
+          iconSpan.setAttribute("aria-hidden", "true");
+          iconSpan.innerHTML = iconHTML;
+          btn.appendChild(iconSpan);
+        }
+        const textSpan = document.createElement("span");
+        textSpan.className = "dm-slash-command-item-text";
+        const labelSpan = document.createElement("span");
+        labelSpan.className = "dm-slash-command-item-label";
+        labelSpan.textContent = item.label;
+        textSpan.appendChild(labelSpan);
+        if (item.description) {
+          const descSpan = document.createElement("span");
+          descSpan.className = "dm-slash-command-item-description";
+          descSpan.textContent = item.description;
+          textSpan.appendChild(descSpan);
+        }
+        btn.appendChild(textSpan);
+        if (item.shortcut) {
+          const shortcutSpan = document.createElement("span");
+          shortcutSpan.className = "dm-slash-command-item-shortcut";
+          shortcutSpan.setAttribute("aria-hidden", "true");
+          shortcutSpan.textContent = item.shortcut;
+          btn.appendChild(shortcutSpan);
+        }
+        const indexForItem = flatItems.length;
+        btn.addEventListener("mousedown", (e) => {
+          e.preventDefault();
+        });
+        btn.addEventListener("mouseenter", () => {
+          selectItem(indexForItem);
+        });
+        btn.addEventListener("click", (e) => {
+          e.preventDefault();
+          if (destroyed) return;
+          currentCommand?.(item);
+        });
+        itemButtons.push(btn);
+        flatItems.push(item);
+        groupEl.appendChild(btn);
+      }
+      root.appendChild(groupEl);
+    }
+    if (selectedIndex >= flatItems.length) selectedIndex = 0;
+    highlight(selectedIndex);
+  };
+  const highlight = (index) => {
+    for (const [i, btn] of itemButtons.entries()) {
+      if (i === index) {
+        btn.setAttribute("data-selected", "");
+      } else {
+        btn.removeAttribute("data-selected");
+      }
+    }
+    const selected = itemButtons[index];
+    if (root && selected) {
+      const btnTop = selected.offsetTop;
+      const btnBottom = btnTop + selected.offsetHeight;
+      const viewTop = root.scrollTop;
+      const viewBottom = viewTop + root.clientHeight;
+      if (btnTop < viewTop) root.scrollTop = btnTop;
+      else if (btnBottom > viewBottom) root.scrollTop = btnBottom - root.clientHeight;
+      root.setAttribute("aria-activedescendant", selected.id);
+    } else {
+      root?.removeAttribute("aria-activedescendant");
+    }
+  };
+  const selectItem = (index) => {
+    if (index < 0 || index >= itemButtons.length) return;
+    selectedIndex = index;
+    highlight(index);
+  };
+  const reposition = (props) => {
+    if (!root) return;
+    cleanupFloating?.();
+    const virtualRef = {
+      getBoundingClientRect: () => props.clientRect() ?? new DOMRect()
+    };
+    cleanupFloating = core.positionFloatingOnce(
+      virtualRef,
+      root,
+      { placement: "bottom-start", offsetValue: 4 }
+    );
+  };
+  return {
+    onStart(props) {
+      currentCommand = props.command;
+      selectedIndex = 0;
+      destroyed = false;
+      root = document.createElement("div");
+      root.className = "dm-slash-command-menu";
+      root.setAttribute("role", "menu");
+      root.setAttribute("aria-label", "Insert block");
+      root.setAttribute("data-dm-editor-ui", "");
+      const editorEl = props.element.closest(".dm-editor");
+      (editorEl ?? document.body).appendChild(root);
+      root.setAttribute("data-show", "");
+      renderPopup(props);
+      reposition(props);
+    },
+    onUpdate(props) {
+      currentCommand = props.command;
+      if (!root) return;
+      renderPopup(props);
+      reposition(props);
+    },
+    onExit() {
+      destroyed = true;
+      cleanupFloating?.();
+      cleanupFloating = null;
+      root?.remove();
+      root = null;
+      itemButtons = [];
+      flatItems = [];
+      selectedIndex = 0;
+      currentCommand = null;
+    },
+    onKeyDown(event) {
+      if (!root || flatItems.length === 0) return false;
+      switch (event.key) {
+        case "ArrowDown":
+          selectItem((selectedIndex + 1) % flatItems.length);
+          return true;
+        case "ArrowUp":
+          selectItem((selectedIndex - 1 + flatItems.length) % flatItems.length);
+          return true;
+        case "Home":
+          selectItem(0);
+          return true;
+        case "End":
+          selectItem(flatItems.length - 1);
+          return true;
+        case "Enter":
+        case "Tab": {
+          const item = flatItems[selectedIndex];
+          if (item && currentCommand) currentCommand(item);
+          return true;
+        }
+        default:
+          return false;
+      }
+    }
+  };
+}
+
+// src/SlashCommand.ts
+var slashCommandPluginKey = new state.PluginKey("slashCommand");
+var PM_LEAF_PLACEHOLDER = "\uFFFC";
+var INITIAL_STATE = {
+  active: false,
+  query: "",
+  range: null
+};
+function justTypedTrigger(tr, char) {
+  if (tr.steps.length !== 1) return false;
+  const step = tr.steps[0];
+  if (!(step instanceof transform.ReplaceStep)) return false;
+  const slice = step.slice;
+  if (slice.size !== 1 || slice.openStart !== 0 || slice.openEnd !== 0) return false;
+  const node = slice.content.firstChild;
+  return !!(node && node.isText && node.text === char);
+}
+function findSlashQuery(state, triggerChar, invalidNodes) {
+  const { selection } = state;
+  if (!selection.empty) return null;
+  const { $from } = selection;
+  if ($from.parent.type.spec.code) return null;
+  if (invalidNodes.includes($from.parent.type.name)) return null;
+  const textBefore = $from.parent.textBetween(
+    0,
+    $from.parentOffset,
+    void 0,
+    PM_LEAF_PLACEHOLDER
+  );
+  const triggerIndex = textBefore.lastIndexOf(triggerChar);
+  if (triggerIndex === -1) return null;
+  if (triggerIndex > 0 && !/\s/.test(textBefore[triggerIndex - 1] ?? "")) return null;
+  const queryText = textBefore.slice(triggerIndex + triggerChar.length);
+  if (/[\n\t]/.test(queryText)) return null;
+  const from = $from.start() + triggerIndex;
+  const to = $from.pos;
+  return { query: queryText, range: { from, to } };
+}
+function filterByCursorAncestors(items, editor) {
+  const { $from } = editor.view.state.selection;
+  let wrappingListType = null;
+  for (let d = $from.depth; d >= 1; d--) {
+    const t = $from.node(d).type.name;
+    if (t === "listItem" || t === "taskItem") {
+      if ($from.index(d) === 0 && d >= 1) {
+        wrappingListType = $from.node(d - 1).type.name;
+      }
+      break;
+    }
+  }
+  return items.filter((item) => {
+    if (!item.hideWhenInside || item.hideWhenInside.length === 0) return true;
+    if (!wrappingListType) return true;
+    return !item.hideWhenInside.includes(wrappingListType);
+  });
+}
+function filterSlashItems(items, query) {
+  if (query.length === 0) return items;
+  const q = query.toLowerCase();
+  const ranked = [];
+  for (const item of items) {
+    const label = item.label.toLowerCase();
+    if (label.startsWith(q)) {
+      ranked.push({ item, score: 0 });
+      continue;
+    }
+    if (label.includes(q)) {
+      ranked.push({ item, score: 1 });
+      continue;
+    }
+    const keywords = item.keywords ?? [];
+    const kwIndex = keywords.findIndex((k) => k.toLowerCase().includes(q));
+    if (kwIndex !== -1) {
+      ranked.push({ item, score: 2 + kwIndex * 0.01 });
+    }
+  }
+  ranked.sort((a, b) => a.score - b.score);
+  return ranked.map((r) => r.item);
+}
+function createSlashCommandPlugin(options) {
+  const { pluginKey, editor, char, items: itemsOverride, render, invalidNodes } = options;
+  let renderer = null;
+  return new state.Plugin({
+    key: pluginKey,
+    state: {
+      init: () => ({ ...INITIAL_STATE }),
+      apply(tr, prev, _oldState, newState) {
+        if (tr.getMeta(pluginKey) === "dismiss") return { ...INITIAL_STATE };
+        if (!tr.docChanged && !tr.selectionSet) return prev;
+        if (prev.active && prev.range) {
+          let { from, to } = prev.range;
+          if (tr.docChanged) {
+            const fromResult = tr.mapping.mapResult(from);
+            const toResult = tr.mapping.mapResult(to);
+            if (fromResult.deleted) return { ...INITIAL_STATE };
+            from = fromResult.pos;
+            to = toResult.pos;
+            if (newState.doc.textBetween(from, from + 1, void 0, PM_LEAF_PLACEHOLDER) !== char) {
+              return { ...INITIAL_STATE };
+            }
+          }
+          if (!newState.selection.empty) return { ...INITIAL_STATE };
+          const cursor = newState.selection.from;
+          if (cursor < from + 1) return { ...INITIAL_STATE };
+          if (cursor > to) {
+            if (!tr.docChanged) return { ...INITIAL_STATE };
+            to = cursor;
+          }
+          const $cursor = newState.doc.resolve(cursor);
+          if ($cursor.parent.type.spec.code) return { ...INITIAL_STATE };
+          if (invalidNodes.includes($cursor.parent.type.name)) {
+            return { ...INITIAL_STATE };
+          }
+          const query = newState.doc.textBetween(
+            from + 1,
+            to,
+            void 0,
+            PM_LEAF_PLACEHOLDER
+          );
+          if (/[\n\t]/.test(query)) return { ...INITIAL_STATE };
+          return { active: true, query, range: { from, to } };
+        }
+        if (!tr.docChanged) return prev;
+        if (!justTypedTrigger(tr, char)) return prev;
+        const result = findSlashQuery(newState, char, invalidNodes);
+        if (result) return { active: true, query: result.query, range: result.range };
+        return prev;
+      }
+    },
+    view(editorView) {
+      const editorEl = editorView.dom.closest(".dm-editor");
+      let suppressDismissHandler = false;
+      const dismissHandler = () => {
+        if (suppressDismissHandler) return;
+        const state = pluginKey.getState(editor.view.state);
+        if (state?.active) dismissSlashCommand(editor.view);
+      };
+      editorEl?.addEventListener("dm:dismiss-overlays", dismissHandler);
+      let wasActive = false;
+      return {
+        update(view) {
+          const state = pluginKey.getState(view.state);
+          if (!state) return;
+          const becameActive = state.active && !wasActive;
+          wasActive = state.active;
+          if (becameActive) {
+            suppressDismissHandler = true;
+            try {
+              editorEl?.dispatchEvent(new Event("dm:dismiss-overlays", { bubbles: false }));
+            } finally {
+              suppressDismissHandler = false;
+            }
+          }
+          if (state.active && state.range) {
+            const items = core.FloatingMenuController.resolveItems(editor, itemsOverride);
+            const contextual = filterByCursorAncestors(items, editor);
+            const filtered = filterSlashItems(contextual, state.query);
+            const command = (item) => {
+              const current = pluginKey.getState(view.state);
+              if (!current?.range) return;
+              const tr = view.state.tr;
+              tr.delete(current.range.from, current.range.to);
+              tr.setMeta(pluginKey, "dismiss");
+              view.dispatch(tr);
+              core.FloatingMenuController.executeItem(editor, item);
+            };
+            const clientRect = () => {
+              const current = pluginKey.getState(view.state);
+              if (!current?.range) return null;
+              try {
+                const coords = view.coordsAtPos(current.range.from);
+                return new DOMRect(
+                  coords.left,
+                  coords.top,
+                  0,
+                  coords.bottom - coords.top
+                );
+              } catch {
+                return null;
+              }
+            };
+            const props = {
+              editor,
+              query: state.query,
+              range: state.range,
+              items: filtered,
+              command,
+              clientRect,
+              element: view.dom
+            };
+            if (!renderer) {
+              renderer = render();
+              renderer.onStart(props);
+            } else {
+              renderer.onUpdate(props);
+            }
+          } else if (renderer) {
+            renderer.onExit();
+            renderer = null;
+          }
+        },
+        destroy() {
+          editorEl?.removeEventListener("dm:dismiss-overlays", dismissHandler);
+          if (renderer) {
+            try {
+              renderer.onExit();
+            } finally {
+              renderer = null;
+            }
+          }
+        }
+      };
+    },
+    props: {
+      // Use handleDOMEvents.keydown (not handleKeyDown) so we intercept
+      // keys BEFORE other keymap plugins claim them (same trick as Mention).
+      handleDOMEvents: {
+        keydown(view, event) {
+          const state = pluginKey.getState(view.state);
+          if (!state?.active) return false;
+          if (event.key === "Escape") {
+            event.preventDefault();
+            const tr = view.state.tr;
+            tr.setMeta(pluginKey, "dismiss");
+            view.dispatch(tr);
+            return true;
+          }
+          if (renderer) {
+            const handled = renderer.onKeyDown(event);
+            if (handled) event.preventDefault();
+            return handled;
+          }
+          return false;
+        }
+      },
+      decorations(state) {
+        const pluginState = pluginKey.getState(state);
+        if (!pluginState?.active || !pluginState.range) return view.DecorationSet.empty;
+        return view.DecorationSet.create(state.doc, [
+          view.Decoration.inline(pluginState.range.from, pluginState.range.to, {
+            class: "dm-slash-command-query",
+            nodeName: "span"
+          })
+        ]);
+      }
+    }
+  });
+}
+var SlashCommand = core.Extension.create({
+  name: "slashCommand",
+  addOptions() {
+    return {
+      char: "/",
+      invalidNodes: ["codeBlock"]
+    };
+  },
+  addProseMirrorPlugins() {
+    const editor = this.editor;
+    if (!editor) return [];
+    return [
+      createSlashCommandPlugin({
+        pluginKey: slashCommandPluginKey,
+        editor,
+        char: this.options.char ?? "/",
+        ...this.options.items !== void 0 && { items: this.options.items },
+        render: this.options.render ?? createSlashSuggestionRenderer,
+        invalidNodes: this.options.invalidNodes ?? ["codeBlock"]
+      })
+    ];
+  }
+});
+function dismissSlashCommand(view) {
+  view.dispatch(view.state.tr.setMeta(slashCommandPluginKey, "dismiss"));
+}
+var LIST_TYPES = /* @__PURE__ */ new Set(["bulletList", "orderedList", "taskList"]);
+var LIST_ITEM_TYPES3 = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+var SmartPaste = core.Extension.create({
+  name: "smartPaste",
+  addOptions() {
+    return {
+      enabled: true
+    };
+  },
+  addProseMirrorPlugins() {
+    if (this.options.enabled === false) return [];
+    return [
+      new state.Plugin({
+        props: {
+          handlePaste: (view, _event, slice) => handleSmartPaste(view, slice)
+        }
+      })
+    ];
+  }
+});
+function handleSmartPaste(view, slice) {
+  const { state } = view;
+  const { selection } = state;
+  const $from = selection.$from;
+  if (!$from.parent.isTextblock) return false;
+  if (!sliceHasNonParagraphBlock(slice)) return false;
+  if (sliceIsSingleSameTypeAsParent(slice, $from.parent.type.name)) return false;
+  if (tryPasteListSliceIntoList(view, slice)) return true;
+  const tr = state.tr;
+  if (!selection.empty) tr.deleteSelection();
+  const $pos = tr.selection.$from;
+  const parent = $pos.parent;
+  const parentStart = $pos.before($pos.depth);
+  const parentEnd = $pos.after($pos.depth);
+  const offset = $pos.parentOffset;
+  const parentSize = parent.content.size;
+  if (hasTrailingHardBreakAtCursor(parent, offset, parentSize)) {
+    const hbStart = parentEnd - 2;
+    const hbEnd = parentEnd - 1;
+    tr.delete(hbStart, hbEnd);
+    const adjustedParentEnd = parentEnd - 1;
+    tr.insert(adjustedParentEnd, slice.content);
+    setCaretAtEndOfInserted(tr, adjustedParentEnd, slice.content);
+  } else if (parentSize === 0) {
+    const isListItemLabel = $pos.depth >= 2 && LIST_ITEM_TYPES3.has($pos.node($pos.depth - 1).type.name) && $pos.index($pos.depth - 1) === 0;
+    if (isListItemLabel) {
+      tr.insert(parentEnd, slice.content);
+      setCaretAtEndOfInserted(tr, parentEnd, slice.content);
+    } else {
+      tr.replaceWith(parentStart, parentEnd, slice.content);
+      setCaretAtEndOfInserted(tr, parentStart, slice.content);
+    }
+  } else if (offset === 0) {
+    tr.insert(parentStart, slice.content);
+    setCaretAtEndOfInserted(tr, parentStart, slice.content);
+  } else if (offset === parentSize) {
+    tr.insert(parentEnd, slice.content);
+    setCaretAtEndOfInserted(tr, parentEnd, slice.content);
+  } else {
+    const cursorPos = $pos.pos;
+    tr.split(cursorPos);
+    const insertAt = cursorPos + 1;
+    tr.insert(insertAt, slice.content);
+    setCaretAtEndOfInserted(tr, insertAt, slice.content);
+  }
+  view.dispatch(tr.scrollIntoView());
+  return true;
+}
+function sliceHasNonParagraphBlock(slice) {
+  let result = false;
+  slice.content.forEach((child) => {
+    if (child.isBlock && child.type.name !== "paragraph") result = true;
+  });
+  return result;
+}
+function sliceIsSingleSameTypeAsParent(slice, parentTypeName) {
+  if (slice.content.childCount !== 1) return false;
+  return slice.content.firstChild?.type.name === parentTypeName;
+}
+function hasTrailingHardBreakAtCursor(parent, offset, parentSize) {
+  if (offset !== parentSize) return false;
+  return parent.lastChild?.type.name === "hardBreak";
+}
+function tryPasteListSliceIntoList(view, slice) {
+  const { state } = view;
+  const { selection, schema } = state;
+  if (slice.content.childCount !== 1) return false;
+  const sliceTop = slice.content.firstChild;
+  if (!sliceTop || !LIST_TYPES.has(sliceTop.type.name)) return false;
+  const $from = selection.$from;
+  let listDepth = -1;
+  for (let d = $from.depth; d > 0; d--) {
+    if (LIST_TYPES.has($from.node(d).type.name)) {
+      listDepth = d;
+      break;
+    }
+  }
+  if (listDepth === -1) return false;
+  const listItemDepth = listDepth + 1;
+  if ($from.depth < listItemDepth) return false;
+  const listParent = $from.node(listDepth);
+  const adapted = convertListItemForParent(schema, sliceTop.content, listParent.type);
+  if (adapted.childCount === 0) return false;
+  const tr = state.tr;
+  if (!selection.empty) tr.deleteSelection();
+  const $pos = tr.selection.$from;
+  if ($pos.depth < listItemDepth) return false;
+  if (!LIST_TYPES.has($pos.node(listDepth).type.name)) return false;
+  const parent = $pos.parent;
+  const parentEnd = $pos.after($pos.depth);
+  const offset = $pos.parentOffset;
+  const parentSize = parent.content.size;
+  const liStart = $pos.before(listItemDepth);
+  const liEnd = $pos.after(listItemDepth);
+  const itemHasOnlyOneChild = $pos.node(listItemDepth).childCount === 1;
+  let insertAt;
+  if (hasTrailingHardBreakAtCursor(parent, offset, parentSize)) {
+    const hbStart = parentEnd - 2;
+    const hbEnd = parentEnd - 1;
+    tr.delete(hbStart, hbEnd);
+    const adjustedLiEnd = liEnd - 1;
+    tr.insert(adjustedLiEnd, adapted);
+    insertAt = adjustedLiEnd;
+  } else if (parentSize === 0 && itemHasOnlyOneChild) {
+    tr.replaceWith(liStart, liEnd, adapted);
+    insertAt = liStart;
+  } else if (offset === 0) {
+    tr.insert(liStart, adapted);
+    insertAt = liStart;
+  } else if (offset === parentSize) {
+    tr.insert(liEnd, adapted);
+    insertAt = liEnd;
+  } else {
+    const cursorPos = $pos.pos;
+    tr.split(cursorPos, 2);
+    insertAt = cursorPos + 2;
+    tr.insert(insertAt, adapted);
+  }
+  setCaretAtEndOfInserted(tr, insertAt, adapted);
+  view.dispatch(tr.scrollIntoView());
+  return true;
+}
+function setCaretAtEndOfInserted(tr, insertAt, content) {
+  if (content.childCount === 0) return;
+  const target = Math.max(0, Math.min(tr.doc.content.size, insertAt + content.size - 1));
+  const $target = tr.doc.resolve(target);
+  if ($target.parent.isTextblock) {
+    tr.setSelection(state.TextSelection.create(tr.doc, target));
+  } else {
+    tr.setSelection(state.Selection.near($target, -1));
+  }
+}
+
+exports.BlockContextMenu = BlockContextMenu;
+exports.BlockHandle = BlockHandle;
+exports.DEFAULT_BLOCK_MATCHERS = DEFAULT_BLOCK_MATCHERS;
+exports.DEFAULT_NESTED_NODES = DEFAULT_NESTED_NODES;
+exports.FloatingMenu = FloatingMenu;
+exports.KeyboardReorder = KeyboardReorder;
+exports.SlashCommand = SlashCommand;
+exports.SmartPaste = SmartPaste;
+exports.blockContextMenuPluginKey = blockContextMenuPluginKey;
+exports.blockHandlePluginKey = blockHandlePluginKey;
+exports.createBlockContextMenuPlugin = createBlockContextMenuPlugin;
+exports.createBlockHandlePlugin = createBlockHandlePlugin;
+exports.createFloatingMenuPlugin = createFloatingMenuPlugin;
+exports.createSlashCommandPlugin = createSlashCommandPlugin;
+exports.createSlashSuggestionRenderer = createSlashSuggestionRenderer;
+exports.dismissSlashCommand = dismissSlashCommand;
+exports.filterSlashItems = filterSlashItems;
+exports.floatingMenuPluginKey = floatingMenuPluginKey;
+exports.slashCommandPluginKey = slashCommandPluginKey;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map