@domternal/extension-block-controls 0.10.0

package/dist/index.js

@@ -0,0 +1,2878 @@
+import { Extension, createFloatingMenuPlugin, floatingMenuPluginKey, defaultFloatingMenuShouldShow, defaultIcons, FloatingMenuController, showFloatingMenu, groupFloatingMenuItems, positionFloatingOnce, insertAsListItemChild, writeToClipboard, liftCurrentListItem, stripInlineColorConflicts } from '@domternal/core';
+export { createFloatingMenuPlugin, floatingMenuPluginKey } from '@domternal/core';
+import { PluginKey, TextSelection, Plugin, NodeSelection, Selection, EditorState } from '@domternal/pm/state';
+import { Fragment } from '@domternal/pm/model';
+import { canJoin, ReplaceStep } from '@domternal/pm/transform';
+import { DecorationSet, Decoration } from '@domternal/pm/view';
+
+// src/FloatingMenu.ts
+var FloatingMenu = Extension.create({
+  name: "floatingMenu",
+  addOptions() {
+    return {
+      element: null,
+      shouldShow: defaultFloatingMenuShouldShow,
+      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 = [], options = {}) {
+  if (allowedTypes.length === 0) return null;
+  const incumbentPos = options.incumbentPos ?? null;
+  const band = incumbentPos !== null ? Math.max(0, options.hysteresisBand ?? 0) : 0;
+  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 - band || clientY > rect.bottom + band) return false;
+    if (allowedTypes.includes(node.type.name)) {
+      if (matchers.length > 0 && isRejectedByMatchers(view, node, pos, parent, index, matchers)) {
+        return true;
+      }
+      const strictlyContains = clientY >= rect.top && clientY <= rect.bottom;
+      const incumbentContains = pos === incumbentPos && clientY >= rect.top - band && clientY <= rect.bottom + band;
+      if ((strictlyContains || incumbentContains) && (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` 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 LIST_WRAPPER_TYPES = /* @__PURE__ */ new Set(["bulletList", "orderedList", "taskList"]);
+function rejoinAtSeam(tr, seam) {
+  if (seam <= 0 || seam >= tr.doc.content.size) return;
+  const $seam = tr.doc.resolve(seam);
+  const before = $seam.nodeBefore;
+  const after = $seam.nodeAfter;
+  if (!before || !after) return;
+  if (before.type !== after.type) return;
+  if (!LIST_WRAPPER_TYPES.has(before.type.name)) return;
+  if (canJoin(tr.doc, seam)) tr.join(seam);
+}
+
+// src/helpers/moveBlock.ts
+var LIST_ITEM_TYPES = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+var LIST_WRAPPER_TYPES2 = /* @__PURE__ */ new Set(["bulletList", "orderedList", "taskList"]);
+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 sourceWrapperType = tr.doc.resolve(sourcePos).parent.type;
+  const { from, to } = expandToEmptyWrappers(tr.doc, sourcePos, sourceEnd);
+  if (targetPos >= from && targetPos <= to) return tr;
+  const stepsBefore = tr.steps.length;
+  const slice = tr.doc.slice(sourcePos, sourceEnd);
+  tr.delete(from, to);
+  const adjustedTarget = targetPos > from ? targetPos - (to - from) : targetPos;
+  const $target = tr.doc.resolve(adjustedTarget);
+  const targetParent = $target.parent;
+  const targetWrapperName = LIST_WRAPPER_TYPES2.has(targetParent.type.name) ? targetParent.type.name : null;
+  const sourceIsListItem = LIST_ITEM_TYPES.has(sourceNode.type.name);
+  const splitsList = targetWrapperName !== null && (!sourceIsListItem || sourceWrapperType.name !== targetWrapperName);
+  if (splitsList) {
+    const content = sourceIsListItem ? Fragment.from(sourceWrapperType.create(null, slice.content)) : slice.content;
+    insertBlockSplittingList(tr, $target, content);
+  } else {
+    const adaptedContent = sourceIsListItem && targetWrapperName === null ? Fragment.from(sourceWrapperType.create(null, slice.content)) : slice.content;
+    tr.insert(adjustedTarget, adaptedContent);
+    rejoinAtSeam(tr, adjustedTarget + adaptedContent.size);
+    rejoinAtSeam(tr, adjustedTarget);
+  }
+  rejoinAtSeam(tr, tr.mapping.slice(stepsBefore).map(from));
+  return tr;
+}
+function insertBlockSplittingList(tr, $gap, content) {
+  const wrapper = $gap.parent;
+  const index = $gap.index();
+  if (index === 0) {
+    const at2 = $gap.before();
+    tr.insert(at2, content);
+    return at2;
+  }
+  if (index === wrapper.childCount) {
+    const at2 = $gap.after();
+    tr.insert(at2, content);
+    return at2;
+  }
+  const splitPos = $gap.pos;
+  tr.split(splitPos, 1);
+  const at = splitPos + 1;
+  tr.insert(at, content);
+  return at;
+}
+var LIST_ITEM_TYPES2 = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+function moveBlockAsNestedChild(tr, sourcePos, wrapperPos, targetItemPos, childIndex) {
+  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 sourceWrapperType = tr.doc.resolve(sourcePos).parent.type;
+  const stepsBefore = tr.steps.length;
+  const { from: expandedFrom, to: expandedTo } = expandToEmptyWrappers(tr.doc, sourcePos, sourceEnd);
+  let blockNode;
+  const wrapped = LIST_ITEM_TYPES2.has(sourceNode.type.name);
+  if (wrapped) {
+    blockNode = sourceWrapperType.create(null, Fragment.from(sourceNode));
+  } else {
+    blockNode = sourceNode;
+  }
+  const result = insertAsListItemChild({
+    tr,
+    wrapperPos,
+    targetItemPos,
+    blockNode,
+    sourceRange: { from: expandedFrom, to: expandedTo },
+    // Spread: exactOptionalPropertyTypes forbids passing `childIndex: undefined`.
+    ...childIndex !== void 0 ? { childIndex } : {}
+  });
+  if (!result.ok || result.insertedAt === void 0) return result.ok;
+  if (wrapped) {
+    rejoinAtSeam(tr, result.insertedAt + blockNode.nodeSize);
+    rejoinAtSeam(tr, result.insertedAt);
+  }
+  rejoinAtSeam(tr, tr.mapping.slice(stepsBefore).map(expandedFrom));
+  return true;
+}
+
+// src/helpers/dropSlots.ts
+var LIST_ITEM_TYPES3 = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+var LIST_WRAPPER_TYPES3 = /* @__PURE__ */ new Set(["bulletList", "orderedList", "taskList"]);
+var DROP_SLOT_INDENT_PX = 24;
+function collectRows(view, nestedEnabled = true) {
+  const rows = [];
+  const doc = view.state.doc;
+  const pushItem = (itemPos, item, level) => {
+    const itemDom = view.nodeDOM(itemPos);
+    const labelDom = view.nodeDOM(itemPos + 1);
+    const rectEl = labelDom instanceof HTMLElement ? labelDom : itemDom;
+    if (!(rectEl instanceof HTMLElement) || !(itemDom instanceof HTMLElement)) return;
+    const labelRect = rectEl.getBoundingClientRect();
+    const itemRect = itemDom.getBoundingClientRect();
+    rows.push({
+      pos: itemPos,
+      end: itemPos + item.nodeSize,
+      node: item,
+      isItem: true,
+      level,
+      top: labelRect.top,
+      bottom: labelRect.bottom,
+      left: itemRect.left,
+      right: itemRect.right
+    });
+    let childPos = itemPos + 1;
+    for (let j = 0; j < item.childCount; j++) {
+      const child = item.child(j);
+      if (LIST_WRAPPER_TYPES3.has(child.type.name)) walkWrapper(childPos, child, level + 1);
+      childPos += child.nodeSize;
+    }
+  };
+  function walkWrapper(wrapperPos, wrapper, level) {
+    let itemPos = wrapperPos + 1;
+    for (let i = 0; i < wrapper.childCount; i++) {
+      const item = wrapper.child(i);
+      if (LIST_ITEM_TYPES3.has(item.type.name)) pushItem(itemPos, item, level);
+      itemPos += item.nodeSize;
+    }
+  }
+  let pos = 0;
+  for (let i = 0; i < doc.childCount; i++) {
+    const node = doc.child(i);
+    if (nestedEnabled && LIST_WRAPPER_TYPES3.has(node.type.name)) {
+      walkWrapper(pos, node, 1);
+    } else {
+      const dom = view.nodeDOM(pos);
+      if (dom instanceof HTMLElement) {
+        const r = dom.getBoundingClientRect();
+        rows.push({ pos, end: pos + node.nodeSize, node, isItem: false, level: 0, top: r.top, bottom: r.bottom, left: r.left, right: r.right });
+      }
+    }
+    pos += node.nodeSize;
+  }
+  return rows;
+}
+function nearestRow(rows, clientY) {
+  let best = -1;
+  let bestDist = Infinity;
+  for (let i = 0; i < rows.length; i++) {
+    const r = rows[i];
+    if (!r) continue;
+    if (clientY >= r.top && clientY <= r.bottom) return i;
+    const d = clientY < r.top ? r.top - clientY : clientY - r.bottom;
+    if (d < bestDist) {
+      bestDist = d;
+      best = i;
+    }
+  }
+  return best;
+}
+function siblingOption(row, insertPos, level) {
+  return {
+    level,
+    lineLeft: row.left,
+    lineWidth: Math.max(0, row.right - row.left),
+    insert: { kind: "sibling", pos: insertPos }
+  };
+}
+function closeChain(view, upper) {
+  const doc = view.state.doc;
+  if (!upper.isItem) return [siblingOption(upper, upper.end, 0)];
+  const opts = [];
+  const $ = doc.resolve(upper.pos + 1);
+  let depth = $.depth;
+  let level = upper.level;
+  while (depth >= 1) {
+    const item = $.node(depth);
+    if (!LIST_ITEM_TYPES3.has(item.type.name)) break;
+    const itemPos = $.before(depth);
+    const dom = view.nodeDOM(itemPos);
+    const rect = dom instanceof HTMLElement ? dom.getBoundingClientRect() : null;
+    const left = rect ? rect.left : upper.left;
+    const right = rect ? rect.right : upper.right;
+    opts.push({
+      level,
+      lineLeft: left,
+      lineWidth: Math.max(0, right - left),
+      insert: { kind: "sibling", pos: itemPos + item.nodeSize }
+    });
+    if ($.index(depth - 1) !== $.node(depth - 1).childCount - 1) break;
+    if (depth - 2 < 0 || !LIST_ITEM_TYPES3.has($.node(depth - 2).type.name)) break;
+    depth -= 2;
+    level -= 1;
+  }
+  return opts;
+}
+function nestOption(view, item, childIndex, indentStep) {
+  const doc = view.state.doc;
+  const $item = doc.resolve(item.pos);
+  if (!LIST_WRAPPER_TYPES3.has($item.parent.type.name)) return null;
+  const wrapperPos = $item.before();
+  const lineLeft = item.left + indentStep;
+  return {
+    level: item.level + 1,
+    lineLeft,
+    lineWidth: Math.max(0, item.right - lineLeft),
+    insert: { kind: "nested", wrapperPos, targetItemPos: item.pos, childIndex }
+  };
+}
+function lastChildIndex(view, item) {
+  const node = view.state.doc.nodeAt(item.pos);
+  return node ? node.childCount : 1;
+}
+function wrapperColumn(view, insertPos) {
+  const $p = view.state.doc.resolve(insertPos);
+  if (!LIST_WRAPPER_TYPES3.has($p.parent.type.name)) return null;
+  const dom = view.nodeDOM($p.before());
+  if (!(dom instanceof HTMLElement)) return null;
+  const r = dom.getBoundingClientRect();
+  return { left: r.left, width: Math.max(0, r.right - r.left), type: $p.parent.type.name };
+}
+function dedupeOptions(options) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const o of options.filter((x) => x !== null).sort((a, b) => a.level - b.level)) {
+    const i = o.insert;
+    const key = i.kind === "sibling" ? `s:${String(i.pos)}` : `n:${String(i.targetItemPos)}:${String(i.childIndex)}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push(o);
+  }
+  return out;
+}
+function resolveDropSlot(args) {
+  const { view, clientX, clientY } = args;
+  const indentStep = args.indentStep ?? DROP_SLOT_INDENT_PX;
+  const nestedEnabled = args.nestedEnabled ?? true;
+  const offerNest = (args.offerNest ?? true) && nestedEnabled;
+  const incumbent = args.incumbent ?? null;
+  const bandY = args.bandY ?? 0;
+  const bandX = args.bandX ?? 0;
+  const sourceWrapperName = args.sourceWrapperName;
+  const rows = args.rows ?? collectRows(view, nestedEnabled);
+  if (rows.length === 0) return null;
+  const idx = nearestRow(rows, clientY);
+  if (idx < 0) return null;
+  const row = rows[idx];
+  if (!row) return null;
+  const rowMid = (row.top + row.bottom) / 2;
+  let after = clientY >= rowMid;
+  if (bandY > 0 && incumbent && Math.abs(clientY - rowMid) <= bandY) {
+    if (incumbent.upperPos === row.pos) after = true;
+    else if (incumbent.lowerPos === row.pos) after = false;
+  }
+  const upper = after ? row : rows[idx - 1] ?? null;
+  const lower = after ? rows[idx + 1] ?? null : row;
+  const gapY = upper?.bottom ?? lower?.top ?? row.bottom;
+  let options;
+  if (upper && lower && lower.pos < upper.end) {
+    options = dedupeOptions([
+      siblingOption(lower, lower.pos, lower.level),
+      lower.isItem && offerNest ? nestOption(view, lower, 1, indentStep) : null
+    ]);
+  } else {
+    options = dedupeOptions([
+      ...upper ? closeChain(view, upper) : [],
+      lower ? siblingOption(lower, lower.pos, lower.level) : null,
+      upper?.isItem && offerNest ? nestOption(view, upper, lastChildIndex(view, upper), indentStep) : null
+    ]);
+  }
+  if (options.length === 0) return null;
+  if (sourceWrapperName !== void 0) {
+    options = options.map((o) => {
+      if (o.insert.kind !== "sibling") return o;
+      const col = wrapperColumn(view, o.insert.pos);
+      if (!col) return o;
+      const joins = sourceWrapperName !== null && sourceWrapperName === col.type;
+      return joins ? o : { ...o, lineLeft: col.left, lineWidth: col.width };
+    });
+  }
+  const byGuide = [...options].sort((a, b) => a.lineLeft - b.lineLeft);
+  let chosen = byGuide[0];
+  if (!chosen) return null;
+  for (const o of byGuide) {
+    if (clientX >= o.lineLeft) chosen = o;
+  }
+  if (bandX > 0 && incumbent && incumbent.level !== null) {
+    const inc = byGuide.find((o) => o.level === incumbent.level);
+    if (inc && inc !== chosen && Math.abs(chosen.level - inc.level) === 1) {
+      const deeper = chosen.lineLeft >= inc.lineLeft ? chosen : inc;
+      if (Math.abs(clientX - deeper.lineLeft) <= bandX) chosen = inc;
+    }
+  }
+  return { gapY, option: chosen, options: byGuide, upperPos: upper?.pos ?? null, lowerPos: lower?.pos ?? null };
+}
+
+// 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 OPAQUE_CONTAINER_TYPES = /* @__PURE__ */ new Set(["details", "detailsContent", "blockquote"]);
+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 insideOpaqueContainer = {
+  name: "insideOpaqueContainer",
+  test(candidate) {
+    const $pos = candidate.editorView.state.doc.resolve(candidate.documentPos);
+    for (let d = $pos.depth; d >= 1; d--) {
+      if (OPAQUE_CONTAINER_TYPES.has($pos.node(d).type.name)) return "reject";
+    }
+    return "allow";
+  }
+};
+var DEFAULT_BLOCK_MATCHERS = Object.freeze([
+  firstChildOfListItem,
+  listContainerSkip,
+  tableInternals,
+  inlineNodes,
+  insideOpaqueContainer
+]);
+
+// 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_TYPES4 = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+var DEFAULT_NEST_THRESHOLD = 28;
+var DROP_HYSTERESIS_Y_PX = 6;
+var DROP_HYSTERESIS_X_PX = 8;
+var NESTED_INDICATOR_INDENT_PX = 24;
+var DROP_ZONE_TOL_LEFT = 80;
+var DROP_ZONE_TOL = 16;
+var blockHandlePluginKey = new 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, incumbentPos = null) {
+  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, {
+    incumbentPos,
+    hysteresisBand: DROP_HYSTERESIS_Y_PX
+  });
+  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 nearestChildItem(view, wrapperPos, wrapper, clientY) {
+  let childPos = wrapperPos + 1;
+  let best = null;
+  for (let i = 0; i < wrapper.childCount; i++) {
+    const child = wrapper.child(i);
+    if (LIST_ITEM_TYPES4.has(child.type.name)) {
+      const dom = view.nodeDOM(childPos);
+      if (dom instanceof HTMLElement) {
+        const rect = dom.getBoundingClientRect();
+        const dist = clientY < rect.top ? rect.top - clientY : clientY > rect.bottom ? clientY - rect.bottom : 0;
+        if (best === null || dist < best.dist) best = { block: { pos: childPos, rect, dom }, dist };
+      }
+    }
+    childPos += child.nodeSize;
+  }
+  return best?.block ?? null;
+}
+function findNestedListChild(view, itemPos, item) {
+  let childPos = itemPos + 1;
+  for (let i = 0; i < item.childCount; i++) {
+    const child = item.child(i);
+    if (LIST_WRAPPER_TYPE_NAMES.has(child.type.name)) {
+      const dom = view.nodeDOM(childPos);
+      if (dom instanceof HTMLElement) return { pos: childPos, node: child, rect: dom.getBoundingClientRect() };
+      return null;
+    }
+    childPos += child.nodeSize;
+  }
+  return null;
+}
+function descendToNearestHoverItem(view, resolved, clientY) {
+  let current = resolved;
+  for (let guard = 0; guard < 20; guard++) {
+    const node = view.state.doc.nodeAt(current.pos);
+    if (!node) return current;
+    if (LIST_WRAPPER_TYPE_NAMES.has(node.type.name)) {
+      const next = nearestChildItem(view, current.pos, node, clientY);
+      if (!next || next.pos === current.pos) return current;
+      current = next;
+      continue;
+    }
+    if (LIST_ITEM_TYPES4.has(node.type.name)) {
+      const nested = findNestedListChild(view, current.pos, node);
+      if (!nested || clientY < nested.rect.top) return current;
+      const next = nearestChildItem(view, nested.pos, nested.node, clientY);
+      if (!next || next.pos === current.pos) return current;
+      current = next;
+      continue;
+    }
+    return current;
+  }
+  return current;
+}
+function computeDropPlacement(view, clientX, clientY, nested, nestThreshold = DEFAULT_NEST_THRESHOLD, options = {}) {
+  const incumbent = options.hysteresis ? { upperPos: options.incumbentUpperPos ?? null, lowerPos: options.incumbentLowerPos ?? null, level: options.incumbentLevel ?? null } : null;
+  const slot = resolveDropSlot({
+    view,
+    clientX,
+    clientY,
+    indentStep: nestThreshold > 0 ? nestThreshold : DROP_SLOT_INDENT_PX,
+    nestedEnabled: nested.allowedNodes.length > 0,
+    offerNest: nestThreshold > 0,
+    incumbent,
+    bandY: options.hysteresis ? DROP_HYSTERESIS_Y_PX : 0,
+    bandX: options.hysteresis ? DROP_HYSTERESIS_X_PX : 0,
+    ...options.sourceWrapperName !== void 0 ? { sourceWrapperName: options.sourceWrapperName } : {}
+  });
+  if (!slot) return null;
+  const opt = slot.option;
+  const feedback = {
+    gapUpperPos: slot.upperPos,
+    gapLowerPos: slot.lowerPos,
+    depthLevel: opt.level
+  };
+  if (opt.insert.kind === "nested") {
+    const itemPos = opt.insert.targetItemPos;
+    const itemNode = view.state.doc.nodeAt(itemPos);
+    const itemDom = view.nodeDOM(itemPos);
+    const itemRect = itemDom instanceof HTMLElement ? itemDom.getBoundingClientRect() : null;
+    let childIndex = opt.insert.childIndex;
+    let gapRect = { top: slot.gapY, bottom: slot.gapY, left: opt.lineLeft - NESTED_INDICATOR_INDENT_PX, width: opt.lineWidth + NESTED_INDICATOR_INDENT_PX };
+    if (itemNode && itemRect) {
+      const childBand = options.hysteresis ? DROP_HYSTERESIS_Y_PX : 0;
+      const cs = resolveChildSlot(view, itemNode, itemPos, itemRect, clientY, options.incumbentChildIndex ?? null, childBand);
+      childIndex = cs.childIndex;
+      gapRect = cs.gapRect;
+    }
+    return {
+      pos: itemPos,
+      rect: itemRect ?? new DOMRect(opt.lineLeft, slot.gapY, opt.lineWidth, 0),
+      insertAfter: false,
+      mode: "nested",
+      targetItemPos: itemPos,
+      wrapperPos: opt.insert.wrapperPos,
+      childIndex,
+      nestedGapRect: gapRect,
+      indicatorLine: { top: gapRect.top, left: gapRect.left + NESTED_INDICATOR_INDENT_PX, width: Math.max(0, gapRect.width - NESTED_INDICATOR_INDENT_PX) },
+      ...feedback
+    };
+  }
+  const insertPos = opt.insert.pos;
+  return {
+    pos: insertPos,
+    rect: new DOMRect(opt.lineLeft, slot.gapY, opt.lineWidth, 0),
+    insertAfter: false,
+    mode: "sibling",
+    insertPos,
+    indicatorLine: { top: slot.gapY, left: opt.lineLeft, width: opt.lineWidth },
+    ...feedback
+  };
+}
+function buildDropTr(view, draggedFrom, sourceNode, placement) {
+  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,
+      placement.childIndex
+    );
+    if (ok) return tr;
+    const targetItem = view.state.doc.nodeAt(placement.targetItemPos);
+    const targetItemEnd = targetItem ? placement.targetItemPos + targetItem.nodeSize : placement.targetItemPos;
+    const sourceEnd = draggedFrom + sourceNode.nodeSize;
+    const sourceInTarget = draggedFrom >= placement.targetItemPos && draggedFrom < targetItemEnd;
+    const targetInSource = placement.targetItemPos >= draggedFrom && placement.targetItemPos < sourceEnd;
+    if (sourceInTarget || targetInSource) return tr;
+  }
+  let targetPos = placement.insertPos;
+  if (targetPos === void 0) {
+    const targetNode = view.state.doc.nodeAt(placement.pos);
+    const targetEnd = targetNode ? placement.pos + targetNode.nodeSize : placement.pos;
+    targetPos = placement.insertAfter ? targetEnd : placement.pos;
+  }
+  moveBlock(tr, draggedFrom, targetPos);
+  return tr;
+}
+function resolveChildSlot(view, item, itemStart, itemRect, clientY, incumbentChildIndex, band) {
+  const childCount = item.childCount;
+  const gap = (top, bottom) => ({
+    top,
+    bottom,
+    left: itemRect.left,
+    width: itemRect.width
+  });
+  const append = { childIndex: childCount, gapRect: gap(itemRect.bottom, itemRect.bottom) };
+  const $item = view.state.doc.resolve(itemStart + 1);
+  const rects = [];
+  for (let i = 0; i < childCount; i++) {
+    const dom = view.nodeDOM($item.posAtIndex(i, $item.depth));
+    if (!(dom instanceof HTMLElement)) return append;
+    rects.push(dom.getBoundingClientRect());
+  }
+  const label = rects[0];
+  if (!label) return append;
+  if (childCount === 1) return { childIndex: 1, gapRect: gap(label.bottom, label.bottom) };
+  let index = 1;
+  for (let i = 1; i < childCount; i++) {
+    const r = rects[i];
+    if (r && clientY >= (r.top + r.bottom) / 2) index = i + 1;
+  }
+  index = Math.min(Math.max(index, 1), childCount);
+  if (band > 0 && incumbentChildIndex !== null && incumbentChildIndex >= 1 && incumbentChildIndex <= childCount && Math.abs(index - incumbentChildIndex) === 1) {
+    const r = rects[Math.min(index, incumbentChildIndex)];
+    if (r && Math.abs(clientY - (r.top + r.bottom) / 2) <= band) index = incumbentChildIndex;
+  }
+  const above = rects[index - 1];
+  const below = index < childCount ? rects[index] : void 0;
+  if (!above) return append;
+  return { childIndex: index, gapRect: gap(above.bottom, below ? below.top : above.bottom) };
+}
+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 = 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 = 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;
+  let dropRaf = null;
+  let pendingDropCoords = null;
+  let currentDropKey = null;
+  const dragHyst = {
+    upperPos: null,
+    lowerPos: null,
+    level: null,
+    childIndex: null
+  };
+  const resetDragHyst = () => {
+    dragHyst.upperPos = null;
+    dragHyst.lowerPos = null;
+    dragHyst.level = null;
+    dragHyst.childIndex = null;
+  };
+  const resetDropState = () => {
+    if (dropRaf !== null) {
+      cancelAnimationFrame(dropRaf);
+      dropRaf = null;
+    }
+    pendingDropCoords = null;
+    currentDropKey = null;
+    resetDragHyst();
+  };
+  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 initial = resolveBlockAtCoords(editor.view, coords.x, coords.y, nested);
+      if (!initial) {
+        scheduleHide();
+        return;
+      }
+      const resolved = descendToNearestHoverItem(editor.view, initial, coords.y);
+      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 = pluginKey.getState(editor.view.state);
+    const pos = state?.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 = 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) return;
+    if (!inZone) {
+      if (dropRaf !== null) {
+        cancelAnimationFrame(dropRaf);
+        dropRaf = null;
+      }
+      pendingDropCoords = null;
+      currentDropKey = null;
+      resetDragHyst();
+      indicator.removeAttribute("data-show");
+      return;
+    }
+    pendingDropCoords = { x: event.clientX, y: event.clientY };
+    if (dropRaf !== null) return;
+    dropRaf = requestAnimationFrame(() => {
+      dropRaf = null;
+      const coords = pendingDropCoords;
+      pendingDropCoords = null;
+      if (coords) updateDropIndicator(coords.x, coords.y);
+    });
+  };
+  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;
+    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, {
+      incumbentUpperPos: dragHyst.upperPos,
+      incumbentLowerPos: dragHyst.lowerPos,
+      incumbentLevel: dragHyst.level,
+      incumbentChildIndex: dragHyst.childIndex,
+      hysteresis: true,
+      sourceWrapperName: LIST_ITEM_TYPES4.has(sourceNode.type.name) ? view.state.doc.resolve(draggedFrom).parent.type.name : null
+    });
+    if (!placement) return false;
+    const tr = buildDropTr(view, draggedFrom, sourceNode, placement);
+    if (tr.doc.eq(view.state.doc)) return false;
+    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 draggedSourceWrapperName = () => {
+    const from = pluginKey.getState(editor.view.state)?.draggedFrom ?? pendingDraggedFrom;
+    if (from === null) return null;
+    const node = editor.view.state.doc.nodeAt(from);
+    if (!node || !LIST_ITEM_TYPES4.has(node.type.name)) return null;
+    return editor.view.state.doc.resolve(from).parent.type.name;
+  };
+  const updateDropIndicator = (clientX, clientY) => {
+    if (!editorEl) return;
+    const placement = computeDropPlacement(editor.view, clientX, clientY, nested, nestThreshold, {
+      incumbentUpperPos: dragHyst.upperPos,
+      incumbentLowerPos: dragHyst.lowerPos,
+      incumbentLevel: dragHyst.level,
+      incumbentChildIndex: dragHyst.childIndex,
+      hysteresis: true,
+      sourceWrapperName: draggedSourceWrapperName()
+    });
+    if (!placement) {
+      indicator.removeAttribute("data-show");
+      currentDropKey = null;
+      return;
+    }
+    dragHyst.upperPos = placement.gapUpperPos ?? null;
+    dragHyst.lowerPos = placement.gapLowerPos ?? null;
+    dragHyst.level = placement.depthLevel ?? null;
+    dragHyst.childIndex = placement.mode === "nested" ? placement.childIndex ?? null : null;
+    const indicatorDraggedFrom = pluginKey.getState(editor.view.state)?.draggedFrom ?? pendingDraggedFrom;
+    if (indicatorDraggedFrom !== null) {
+      const indicatorSource = editor.view.state.doc.nodeAt(indicatorDraggedFrom);
+      if (indicatorSource && buildDropTr(editor.view, indicatorDraggedFrom, indicatorSource, placement).doc.eq(editor.view.state.doc)) {
+        indicator.removeAttribute("data-show");
+        currentDropKey = null;
+        return;
+      }
+    }
+    const editorRect = editorEl.getBoundingClientRect();
+    let lineY;
+    let left;
+    let width;
+    if (placement.indicatorLine) {
+      lineY = placement.indicatorLine.top - editorRect.top;
+      left = placement.indicatorLine.left - editorRect.left;
+      width = placement.indicatorLine.width;
+    } else if (placement.mode === "nested") {
+      const indent = NESTED_INDICATOR_INDENT_PX;
+      const gap = placement.nestedGapRect ?? {
+        top: placement.rect.bottom,
+        left: placement.rect.left,
+        width: placement.rect.width
+      };
+      lineY = gap.top - editorRect.top;
+      left = gap.left - editorRect.left + indent;
+      width = Math.max(0, gap.width - indent);
+    } else {
+      lineY = (placement.insertAfter ? placement.rect.bottom : placement.rect.top) - editorRect.top;
+      left = placement.rect.left - editorRect.left;
+      width = placement.rect.width;
+    }
+    const slotPart = placement.mode === "nested" ? String(placement.childIndex ?? -1) : "s";
+    const key = `${placement.mode}|${slotPart}|${String(Math.round(lineY))}|${String(Math.round(left))}|${String(Math.round(width))}`;
+    if (key === currentDropKey && indicator.hasAttribute("data-show")) return;
+    currentDropKey = key;
+    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");
+    currentDropKey = null;
+  };
+  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;
+    resetDropState();
+  };
+  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 = pluginKey.getState(editor.view.state);
+    const pos = state?.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 = 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);
+    resetDropState();
+    startAutoScroll();
+    startDragListeners();
+    if (dropIndicator) editorEl?.classList.add("dm-block-handle-dragging");
+  };
+  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();
+    editorEl?.classList.remove("dm-block-handle-dragging");
+  };
+  return new 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 for Notion-like block semantics (above-mid → insert
+      // before, below-mid → after), instead of PM's default `posAtCoords +
+      // dropPoint` which rounds short paragraphs to an arbitrary neighbour.
+      // `moveBlock` does the delete+insert + position fix so the block keeps its
+      // attrs (UniqueID, colors).
+      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");
+          editorEl?.classList.remove("dm-block-handle-dragging");
+          root.remove();
+          editorEl = null;
+          hoverEl = null;
+        }
+      };
+    }
+  });
+}
+var BlockHandle = 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 = 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, view } = editor;
+  const { $from } = state.selection;
+  const topLevel = findTopLevelBlock(state.doc, $from.pos);
+  if (!topLevel) return false;
+  if (direction === "up" && topLevel.index === 0) return false;
+  if (direction === "down" && topLevel.index >= state.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.doc.resolve(topLevel.pos).posAtIndex(topLevel.index - 1, 0);
+  } else {
+    const nextSibling = state.doc.child(topLevel.index + 1);
+    const nextStart = state.doc.resolve(topLevel.pos).posAtIndex(topLevel.index + 1, 0);
+    targetPos = nextStart + nextSibling.nodeSize;
+  }
+  const tr = state.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(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(TextSelection.near(tr.doc.resolve(from + 1)));
+    return tr;
+  }
+  tr.delete(from, to);
+  rejoinAtSeam(tr, from);
+  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 } = editor.view;
+  if (blockPos < 0 || blockPos >= state.doc.content.size) return false;
+  const node = state.doc.nodeAt(blockPos);
+  if (!node?.type.isTextblock) return false;
+  const isListTarget = command !== "toggleBlockquote";
+  const needsStepDown = isListTarget && node.type.name !== "paragraph";
+  const tr = state.tr;
+  if (needsStepDown) {
+    const paragraphType = state.schema.nodes["paragraph"];
+    if (!paragraphType) return false;
+    tr.setBlockType(blockPos, blockPos + node.nodeSize, paragraphType);
+  }
+  tr.setSelection(TextSelection.create(tr.doc, blockPos + 1));
+  editor.view.dispatch(tr);
+  switch (command) {
+    case "turnIntoBulletList":
+      return editor.commands.turnIntoBulletList();
+    case "turnIntoOrderedList":
+      return editor.commands.turnIntoOrderedList();
+    case "turnIntoTaskList":
+      return editor.commands.turnIntoTaskList();
+    case "toggleBlockquote":
+      return editor.commands.toggleBlockquote();
+  }
+}
+
+// src/BlockContextMenu.ts
+var blockContextMenuPluginKey = new PluginKey("blockContextMenu");
+var LIST_WRAPPER_TYPES4 = /* @__PURE__ */ new Set(["bulletList", "orderedList", "taskList"]);
+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: "turnIntoBulletList" },
+  { label: "Ordered list", icon: "listNumbers", nodeType: "orderedList", command: "turnIntoOrderedList" },
+  { label: "To-do list", icon: "listChecks", nodeType: "taskList", command: "turnIntoTaskList" },
+  { 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 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 blockPos = currentBlockPos;
+    const sourceNode = editor.view.state.doc.nodeAt(blockPos);
+    if (!sourceNode) return;
+    const sourceIsTextblock = sourceNode.type.isTextblock;
+    const pos = sourceIsTextblock ? blockPos : blockPos + 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;
+    if (sourceIsTextblock) {
+      runAndClose((tr) => {
+        turnIntoBlock(tr, pos, targetType, target.attrs);
+      });
+      return;
+    }
+    runAndClose((tr) => {
+      const labelInner = Math.min(blockPos + 2, tr.doc.content.size);
+      tr.setSelection(TextSelection.create(tr.doc, labelInner));
+      const liftState = EditorState.create({ doc: tr.doc, selection: tr.selection });
+      if (!liftCurrentListItem(liftState, tr)) return;
+      if (targetType.name !== "paragraph") {
+        tr.setBlockType(
+          tr.selection.from,
+          tr.selection.to,
+          targetType,
+          (node) => ({ ...node.attrs, ...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 });
+      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;
+    const sourceIsListItem = node.type.name === "listItem" || node.type.name === "taskItem";
+    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);
+      }
+      let labelWrapperType = null;
+      for (let d = $pos.depth; d >= 1; d--) {
+        const t = $pos.node(d).type.name;
+        if (t === "listItem" || t === "taskItem") {
+          if ($pos.index(d) === 0) labelWrapperType = $pos.node(d - 1).type.name;
+          break;
+        }
+      }
+      const eligible = turnIntoTargets.filter((target) => {
+        const type = editor.view.state.schema.nodes[target.nodeType];
+        if (!type) return false;
+        if (target.command) {
+          if (LIST_WRAPPER_TYPES4.has(target.nodeType)) {
+            return target.nodeType !== labelWrapperType;
+          }
+          return !ancestorTypeNames.has(target.nodeType);
+        }
+        if (!sourceIsTextblock && !sourceIsListItem) 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 = 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 openTr = editor.view.state.tr.setMeta(pluginKey, { activeBlockPos: detail.blockPos });
+    openTr.setMeta("addToHistory", false);
+    editor.view.dispatch(openTr);
+    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 = 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 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 DecorationSet.create(state.doc, [
+          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 = 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 = 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 ? 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 = 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 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 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 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 = 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);
+              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: {
+      // 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 DecorationSet.empty;
+        return DecorationSet.create(state.doc, [
+          Decoration.inline(pluginState.range.from, pluginState.range.to, {
+            class: "dm-slash-command-query",
+            nodeName: "span"
+          })
+        ]);
+      }
+    }
+  });
+}
+var SlashCommand = 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_TYPES5 = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
+var SmartPaste = Extension.create({
+  name: "smartPaste",
+  addOptions() {
+    return {
+      enabled: true
+    };
+  },
+  addProseMirrorPlugins() {
+    if (this.options.enabled === false) return [];
+    return [
+      new 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;
+  const isListItemLabel = $pos.depth >= 2 && LIST_ITEM_TYPES5.has($pos.node($pos.depth - 1).type.name) && $pos.index($pos.depth - 1) === 0;
+  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) {
+    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) {
+    if (isListItemLabel) {
+      const $gap = tr.doc.resolve($pos.before($pos.depth - 1));
+      const insertedAt = insertBlockSplittingList(tr, $gap, slice.content);
+      setCaretAtEndOfInserted(tr, insertedAt, slice.content);
+    } else {
+      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 } = 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 sameKind = sliceTop.type === listParent.type;
+  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;
+  if (sameKind) {
+    const adapted = sliceTop.content;
+    if (adapted.childCount === 0) return false;
+    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, typesAfterUncheckedTail($pos, listItemDepth));
+      insertAt = cursorPos + 2;
+      tr.insert(insertAt, adapted);
+    }
+    setCaretAtEndOfInserted(tr, insertAt, adapted);
+    view.dispatch(tr.scrollIntoView());
+    return true;
+  }
+  const content = Fragment.from(sliceTop);
+  let insertedAt;
+  if (hasTrailingHardBreakAtCursor(parent, offset, parentSize)) {
+    const hbStart = parentEnd - 2;
+    const hbEnd = parentEnd - 1;
+    tr.delete(hbStart, hbEnd);
+    insertedAt = insertBlockSplittingList(tr, tr.doc.resolve(liEnd - 1), content);
+  } else if (parentSize === 0 && itemHasOnlyOneChild) {
+    const wrapperNode = $pos.node(listDepth);
+    if (wrapperNode.childCount === 1) {
+      const wrapperStart = $pos.before(listDepth);
+      const wrapperEnd = $pos.after(listDepth);
+      tr.replaceWith(wrapperStart, wrapperEnd, sliceTop);
+      insertedAt = wrapperStart;
+    } else {
+      tr.delete(liStart, liEnd);
+      insertedAt = insertBlockSplittingList(tr, tr.doc.resolve(liStart), content);
+    }
+  } else if (offset === 0) {
+    insertedAt = insertBlockSplittingList(tr, tr.doc.resolve(liStart), content);
+  } else if (offset === parentSize) {
+    insertedAt = insertBlockSplittingList(tr, tr.doc.resolve(liEnd), content);
+  } else {
+    const cursorPos = $pos.pos;
+    tr.split(cursorPos, 2, typesAfterUncheckedTail($pos, listItemDepth));
+    insertedAt = insertBlockSplittingList(tr, tr.doc.resolve(cursorPos + 2), content);
+  }
+  setCaretAtEndOfInserted(tr, insertedAt, content);
+  view.dispatch(tr.scrollIntoView());
+  return true;
+}
+function typesAfterUncheckedTail($pos, listItemDepth) {
+  const item = $pos.node(listItemDepth);
+  if (item.type.name !== "taskItem") return void 0;
+  return [
+    { type: item.type, attrs: { ...item.attrs, checked: false } },
+    { type: $pos.parent.type }
+  ];
+}
+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(TextSelection.create(tr.doc, target));
+  } else {
+    tr.setSelection(Selection.near($target, -1));
+  }
+}
+
+export { BlockContextMenu, BlockHandle, DEFAULT_BLOCK_MATCHERS, DEFAULT_NESTED_NODES, FloatingMenu, KeyboardReorder, SlashCommand, SmartPaste, blockContextMenuPluginKey, blockHandlePluginKey, createBlockContextMenuPlugin, createBlockHandlePlugin, createSlashCommandPlugin, createSlashSuggestionRenderer, dismissSlashCommand, filterSlashItems, slashCommandPluginKey };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map