jazz-tools 0.14.27 → 0.15.0

package/dist/prosemirror/index.js

@@ -0,0 +1,2185 @@
+// src/prosemirror/lib/plugin.ts
+import { Plugin, PluginKey } from "prosemirror-state";
+
+// ../../node_modules/prosemirror-view/dist/index.js
+import { TextSelection, NodeSelection, AllSelection, Selection } from "prosemirror-state";
+import { DOMSerializer, Fragment, Mark, Slice, DOMParser as DOMParser2 } from "prosemirror-model";
+import { dropPoint } from "prosemirror-transform";
+var domIndex = function(node) {
+  for (var index = 0; ; index++) {
+    node = node.previousSibling;
+    if (!node)
+      return index;
+  }
+};
+var isEquivalentPosition = function(node, off, targetNode, targetOff) {
+  return targetNode && (scanFor(node, off, targetNode, targetOff, -1) || scanFor(node, off, targetNode, targetOff, 1));
+};
+var atomElements = /^(img|br|input|textarea|hr)$/i;
+function scanFor(node, off, targetNode, targetOff, dir) {
+  for (; ; ) {
+    if (node == targetNode && off == targetOff)
+      return true;
+    if (off == (dir < 0 ? 0 : nodeSize(node))) {
+      let parent = node.parentNode;
+      if (!parent || parent.nodeType != 1 || hasBlockDesc(node) || atomElements.test(node.nodeName) || node.contentEditable == "false")
+        return false;
+      off = domIndex(node) + (dir < 0 ? 0 : 1);
+      node = parent;
+    } else if (node.nodeType == 1) {
+      node = node.childNodes[off + (dir < 0 ? -1 : 0)];
+      if (node.contentEditable == "false")
+        return false;
+      off = dir < 0 ? nodeSize(node) : 0;
+    } else {
+      return false;
+    }
+  }
+}
+function nodeSize(node) {
+  return node.nodeType == 3 ? node.nodeValue.length : node.childNodes.length;
+}
+function isOnEdge(node, offset, parent) {
+  for (let atStart = offset == 0, atEnd = offset == nodeSize(node); atStart || atEnd; ) {
+    if (node == parent)
+      return true;
+    let index = domIndex(node);
+    node = node.parentNode;
+    if (!node)
+      return false;
+    atStart = atStart && index == 0;
+    atEnd = atEnd && index == nodeSize(node);
+  }
+}
+function hasBlockDesc(dom) {
+  let desc;
+  for (let cur = dom; cur; cur = cur.parentNode)
+    if (desc = cur.pmViewDesc)
+      break;
+  return desc && desc.node && desc.node.isBlock && (desc.dom == dom || desc.contentDOM == dom);
+}
+var selectionCollapsed = function(domSel) {
+  return domSel.focusNode && isEquivalentPosition(domSel.focusNode, domSel.focusOffset, domSel.anchorNode, domSel.anchorOffset);
+};
+function keyEvent(keyCode, key) {
+  let event = document.createEvent("Event");
+  event.initEvent("keydown", true, true);
+  event.keyCode = keyCode;
+  event.key = event.code = key;
+  return event;
+}
+var nav = typeof navigator != "undefined" ? navigator : null;
+var doc = typeof document != "undefined" ? document : null;
+var agent = nav && nav.userAgent || "";
+var ie_edge = /Edge\/(\d+)/.exec(agent);
+var ie_upto10 = /MSIE \d/.exec(agent);
+var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(agent);
+var ie = !!(ie_upto10 || ie_11up || ie_edge);
+var ie_version = ie_upto10 ? document.documentMode : ie_11up ? +ie_11up[1] : ie_edge ? +ie_edge[1] : 0;
+var gecko = !ie && /gecko\/(\d+)/i.test(agent);
+gecko && +(/Firefox\/(\d+)/.exec(agent) || [0, 0])[1];
+var _chrome = !ie && /Chrome\/(\d+)/.exec(agent);
+var chrome = !!_chrome;
+var chrome_version = _chrome ? +_chrome[1] : 0;
+var safari = !ie && !!nav && /Apple Computer/.test(nav.vendor);
+var ios = safari && (/Mobile\/\w+/.test(agent) || !!nav && nav.maxTouchPoints > 2);
+var mac = ios || (nav ? /Mac/.test(nav.platform) : false);
+var windows = nav ? /Win/.test(nav.platform) : false;
+var android = /Android \d/.test(agent);
+var webkit = !!doc && "webkitFontSmoothing" in doc.documentElement.style;
+var webkit_version = webkit ? +(/\bAppleWebKit\/(\d+)/.exec(navigator.userAgent) || [0, 0])[1] : 0;
+var OuterDecoLevel = function(nodeName) {
+  if (nodeName)
+    this.nodeName = nodeName;
+};
+OuterDecoLevel.prototype = /* @__PURE__ */ Object.create(null);
+var noDeco = [new OuterDecoLevel()];
+function selectionFromDOM(view, origin = null) {
+  let domSel = view.domSelectionRange(), doc2 = view.state.doc;
+  if (!domSel.focusNode)
+    return null;
+  let nearestDesc = view.docView.nearestDesc(domSel.focusNode), inWidget = nearestDesc && nearestDesc.size == 0;
+  let head = view.docView.posFromDOM(domSel.focusNode, domSel.focusOffset, 1);
+  if (head < 0)
+    return null;
+  let $head = doc2.resolve(head), anchor, selection;
+  if (selectionCollapsed(domSel)) {
+    anchor = head;
+    while (nearestDesc && !nearestDesc.node)
+      nearestDesc = nearestDesc.parent;
+    let nearestDescNode = nearestDesc.node;
+    if (nearestDesc && nearestDescNode.isAtom && NodeSelection.isSelectable(nearestDescNode) && nearestDesc.parent && !(nearestDescNode.isInline && isOnEdge(domSel.focusNode, domSel.focusOffset, nearestDesc.dom))) {
+      let pos = nearestDesc.posBefore;
+      selection = new NodeSelection(head == pos ? $head : doc2.resolve(pos));
+    }
+  } else {
+    if (domSel instanceof view.dom.ownerDocument.defaultView.Selection && domSel.rangeCount > 1) {
+      let min = head, max = head;
+      for (let i = 0; i < domSel.rangeCount; i++) {
+        let range = domSel.getRangeAt(i);
+        min = Math.min(min, view.docView.posFromDOM(range.startContainer, range.startOffset, 1));
+        max = Math.max(max, view.docView.posFromDOM(range.endContainer, range.endOffset, -1));
+      }
+      if (min < 0)
+        return null;
+      [anchor, head] = max == view.state.selection.anchor ? [max, min] : [min, max];
+      $head = doc2.resolve(head);
+    } else {
+      anchor = view.docView.posFromDOM(domSel.anchorNode, domSel.anchorOffset, 1);
+    }
+    if (anchor < 0)
+      return null;
+  }
+  let $anchor = doc2.resolve(anchor);
+  if (!selection) {
+    let bias = origin == "pointer" || view.state.selection.head < $head.pos && !inWidget ? 1 : -1;
+    selection = selectionBetween(view, $anchor, $head, bias);
+  }
+  return selection;
+}
+function editorOwnsSelection(view) {
+  return view.editable ? view.hasFocus() : hasSelection(view) && document.activeElement && document.activeElement.contains(view.dom);
+}
+function selectionToDOM(view, force = false) {
+  let sel = view.state.selection;
+  syncNodeSelection(view, sel);
+  if (!editorOwnsSelection(view))
+    return;
+  if (!force && view.input.mouseDown && view.input.mouseDown.allowDefault && chrome) {
+    let domSel = view.domSelectionRange(), curSel = view.domObserver.currentSelection;
+    if (domSel.anchorNode && curSel.anchorNode && isEquivalentPosition(domSel.anchorNode, domSel.anchorOffset, curSel.anchorNode, curSel.anchorOffset)) {
+      view.input.mouseDown.delayedSelectionSync = true;
+      view.domObserver.setCurSelection();
+      return;
+    }
+  }
+  view.domObserver.disconnectSelection();
+  if (view.cursorWrapper) {
+    selectCursorWrapper(view);
+  } else {
+    let { anchor, head } = sel, resetEditableFrom, resetEditableTo;
+    if (brokenSelectBetweenUneditable && !(sel instanceof TextSelection)) {
+      if (!sel.$from.parent.inlineContent)
+        resetEditableFrom = temporarilyEditableNear(view, sel.from);
+      if (!sel.empty && !sel.$from.parent.inlineContent)
+        resetEditableTo = temporarilyEditableNear(view, sel.to);
+    }
+    view.docView.setSelection(anchor, head, view, force);
+    if (brokenSelectBetweenUneditable) {
+      if (resetEditableFrom)
+        resetEditable(resetEditableFrom);
+      if (resetEditableTo)
+        resetEditable(resetEditableTo);
+    }
+    if (sel.visible) {
+      view.dom.classList.remove("ProseMirror-hideselection");
+    } else {
+      view.dom.classList.add("ProseMirror-hideselection");
+      if ("onselectionchange" in document)
+        removeClassOnSelectionChange(view);
+    }
+  }
+  view.domObserver.setCurSelection();
+  view.domObserver.connectSelection();
+}
+var brokenSelectBetweenUneditable = safari || chrome && chrome_version < 63;
+function temporarilyEditableNear(view, pos) {
+  let { node, offset } = view.docView.domFromPos(pos, 0);
+  let after = offset < node.childNodes.length ? node.childNodes[offset] : null;
+  let before = offset ? node.childNodes[offset - 1] : null;
+  if (safari && after && after.contentEditable == "false")
+    return setEditable(after);
+  if ((!after || after.contentEditable == "false") && (!before || before.contentEditable == "false")) {
+    if (after)
+      return setEditable(after);
+    else if (before)
+      return setEditable(before);
+  }
+}
+function setEditable(element) {
+  element.contentEditable = "true";
+  if (safari && element.draggable) {
+    element.draggable = false;
+    element.wasDraggable = true;
+  }
+  return element;
+}
+function resetEditable(element) {
+  element.contentEditable = "false";
+  if (element.wasDraggable) {
+    element.draggable = true;
+    element.wasDraggable = null;
+  }
+}
+function removeClassOnSelectionChange(view) {
+  let doc2 = view.dom.ownerDocument;
+  doc2.removeEventListener("selectionchange", view.input.hideSelectionGuard);
+  let domSel = view.domSelectionRange();
+  let node = domSel.anchorNode, offset = domSel.anchorOffset;
+  doc2.addEventListener("selectionchange", view.input.hideSelectionGuard = () => {
+    if (domSel.anchorNode != node || domSel.anchorOffset != offset) {
+      doc2.removeEventListener("selectionchange", view.input.hideSelectionGuard);
+      setTimeout(() => {
+        if (!editorOwnsSelection(view) || view.state.selection.visible)
+          view.dom.classList.remove("ProseMirror-hideselection");
+      }, 20);
+    }
+  });
+}
+function selectCursorWrapper(view) {
+  let domSel = view.domSelection(), range = document.createRange();
+  if (!domSel)
+    return;
+  let node = view.cursorWrapper.dom, img = node.nodeName == "IMG";
+  if (img)
+    range.setStart(node.parentNode, domIndex(node) + 1);
+  else
+    range.setStart(node, 0);
+  range.collapse(true);
+  domSel.removeAllRanges();
+  domSel.addRange(range);
+  if (!img && !view.state.selection.visible && ie && ie_version <= 11) {
+    node.disabled = true;
+    node.disabled = false;
+  }
+}
+function syncNodeSelection(view, sel) {
+  if (sel instanceof NodeSelection) {
+    let desc = view.docView.descAt(sel.from);
+    if (desc != view.lastSelectedViewDesc) {
+      clearNodeSelection(view);
+      if (desc)
+        desc.selectNode();
+      view.lastSelectedViewDesc = desc;
+    }
+  } else {
+    clearNodeSelection(view);
+  }
+}
+function clearNodeSelection(view) {
+  if (view.lastSelectedViewDesc) {
+    if (view.lastSelectedViewDesc.parent)
+      view.lastSelectedViewDesc.deselectNode();
+    view.lastSelectedViewDesc = void 0;
+  }
+}
+function selectionBetween(view, $anchor, $head, bias) {
+  return view.someProp("createSelectionBetween", (f) => f(view, $anchor, $head)) || TextSelection.between($anchor, $head, bias);
+}
+function hasSelection(view) {
+  let sel = view.domSelectionRange();
+  if (!sel.anchorNode)
+    return false;
+  try {
+    return view.dom.contains(sel.anchorNode.nodeType == 3 ? sel.anchorNode.parentNode : sel.anchorNode) && (view.editable || view.dom.contains(sel.focusNode.nodeType == 3 ? sel.focusNode.parentNode : sel.focusNode));
+  } catch (_) {
+    return false;
+  }
+}
+function moveSelectionBlock(state, dir) {
+  let { $anchor, $head } = state.selection;
+  let $side = dir > 0 ? $anchor.max($head) : $anchor.min($head);
+  let $start = !$side.parent.inlineContent ? $side : $side.depth ? state.doc.resolve(dir > 0 ? $side.after() : $side.before()) : null;
+  return $start && Selection.findFrom($start, dir);
+}
+function apply(view, sel) {
+  view.dispatch(view.state.tr.setSelection(sel).scrollIntoView());
+  return true;
+}
+function selectHorizontally(view, dir, mods) {
+  let sel = view.state.selection;
+  if (sel instanceof TextSelection) {
+    if (mods.indexOf("s") > -1) {
+      let { $head } = sel, node = $head.textOffset ? null : dir < 0 ? $head.nodeBefore : $head.nodeAfter;
+      if (!node || node.isText || !node.isLeaf)
+        return false;
+      let $newHead = view.state.doc.resolve($head.pos + node.nodeSize * (dir < 0 ? -1 : 1));
+      return apply(view, new TextSelection(sel.$anchor, $newHead));
+    } else if (!sel.empty) {
+      return false;
+    } else if (view.endOfTextblock(dir > 0 ? "forward" : "backward")) {
+      let next = moveSelectionBlock(view.state, dir);
+      if (next && next instanceof NodeSelection)
+        return apply(view, next);
+      return false;
+    } else if (!(mac && mods.indexOf("m") > -1)) {
+      let $head = sel.$head, node = $head.textOffset ? null : dir < 0 ? $head.nodeBefore : $head.nodeAfter, desc;
+      if (!node || node.isText)
+        return false;
+      let nodePos = dir < 0 ? $head.pos - node.nodeSize : $head.pos;
+      if (!(node.isAtom || (desc = view.docView.descAt(nodePos)) && !desc.contentDOM))
+        return false;
+      if (NodeSelection.isSelectable(node)) {
+        return apply(view, new NodeSelection(dir < 0 ? view.state.doc.resolve($head.pos - node.nodeSize) : $head));
+      } else if (webkit) {
+        return apply(view, new TextSelection(view.state.doc.resolve(dir < 0 ? nodePos : nodePos + node.nodeSize)));
+      } else {
+        return false;
+      }
+    }
+  } else if (sel instanceof NodeSelection && sel.node.isInline) {
+    return apply(view, new TextSelection(dir > 0 ? sel.$to : sel.$from));
+  } else {
+    let next = moveSelectionBlock(view.state, dir);
+    if (next)
+      return apply(view, next);
+    return false;
+  }
+}
+function nodeLen(node) {
+  return node.nodeType == 3 ? node.nodeValue.length : node.childNodes.length;
+}
+function isIgnorable(dom, dir) {
+  let desc = dom.pmViewDesc;
+  return desc && desc.size == 0 && (dir < 0 || dom.nextSibling || dom.nodeName != "BR");
+}
+function skipIgnoredNodes(view, dir) {
+  return dir < 0 ? skipIgnoredNodesBefore(view) : skipIgnoredNodesAfter(view);
+}
+function skipIgnoredNodesBefore(view) {
+  let sel = view.domSelectionRange();
+  let node = sel.focusNode, offset = sel.focusOffset;
+  if (!node)
+    return;
+  let moveNode, moveOffset, force = false;
+  if (gecko && node.nodeType == 1 && offset < nodeLen(node) && isIgnorable(node.childNodes[offset], -1))
+    force = true;
+  for (; ; ) {
+    if (offset > 0) {
+      if (node.nodeType != 1) {
+        break;
+      } else {
+        let before = node.childNodes[offset - 1];
+        if (isIgnorable(before, -1)) {
+          moveNode = node;
+          moveOffset = --offset;
+        } else if (before.nodeType == 3) {
+          node = before;
+          offset = node.nodeValue.length;
+        } else
+          break;
+      }
+    } else if (isBlockNode(node)) {
+      break;
+    } else {
+      let prev = node.previousSibling;
+      while (prev && isIgnorable(prev, -1)) {
+        moveNode = node.parentNode;
+        moveOffset = domIndex(prev);
+        prev = prev.previousSibling;
+      }
+      if (!prev) {
+        node = node.parentNode;
+        if (node == view.dom)
+          break;
+        offset = 0;
+      } else {
+        node = prev;
+        offset = nodeLen(node);
+      }
+    }
+  }
+  if (force)
+    setSelFocus(view, node, offset);
+  else if (moveNode)
+    setSelFocus(view, moveNode, moveOffset);
+}
+function skipIgnoredNodesAfter(view) {
+  let sel = view.domSelectionRange();
+  let node = sel.focusNode, offset = sel.focusOffset;
+  if (!node)
+    return;
+  let len = nodeLen(node);
+  let moveNode, moveOffset;
+  for (; ; ) {
+    if (offset < len) {
+      if (node.nodeType != 1)
+        break;
+      let after = node.childNodes[offset];
+      if (isIgnorable(after, 1)) {
+        moveNode = node;
+        moveOffset = ++offset;
+      } else
+        break;
+    } else if (isBlockNode(node)) {
+      break;
+    } else {
+      let next = node.nextSibling;
+      while (next && isIgnorable(next, 1)) {
+        moveNode = next.parentNode;
+        moveOffset = domIndex(next) + 1;
+        next = next.nextSibling;
+      }
+      if (!next) {
+        node = node.parentNode;
+        if (node == view.dom)
+          break;
+        offset = len = 0;
+      } else {
+        node = next;
+        offset = 0;
+        len = nodeLen(node);
+      }
+    }
+  }
+  if (moveNode)
+    setSelFocus(view, moveNode, moveOffset);
+}
+function isBlockNode(dom) {
+  let desc = dom.pmViewDesc;
+  return desc && desc.node && desc.node.isBlock;
+}
+function textNodeAfter(node, offset) {
+  while (node && offset == node.childNodes.length && !hasBlockDesc(node)) {
+    offset = domIndex(node) + 1;
+    node = node.parentNode;
+  }
+  while (node && offset < node.childNodes.length) {
+    let next = node.childNodes[offset];
+    if (next.nodeType == 3)
+      return next;
+    if (next.nodeType == 1 && next.contentEditable == "false")
+      break;
+    node = next;
+    offset = 0;
+  }
+}
+function textNodeBefore(node, offset) {
+  while (node && !offset && !hasBlockDesc(node)) {
+    offset = domIndex(node);
+    node = node.parentNode;
+  }
+  while (node && offset) {
+    let next = node.childNodes[offset - 1];
+    if (next.nodeType == 3)
+      return next;
+    if (next.nodeType == 1 && next.contentEditable == "false")
+      break;
+    node = next;
+    offset = node.childNodes.length;
+  }
+}
+function setSelFocus(view, node, offset) {
+  if (node.nodeType != 3) {
+    let before, after;
+    if (after = textNodeAfter(node, offset)) {
+      node = after;
+      offset = 0;
+    } else if (before = textNodeBefore(node, offset)) {
+      node = before;
+      offset = before.nodeValue.length;
+    }
+  }
+  let sel = view.domSelection();
+  if (!sel)
+    return;
+  if (selectionCollapsed(sel)) {
+    let range = document.createRange();
+    range.setEnd(node, offset);
+    range.setStart(node, offset);
+    sel.removeAllRanges();
+    sel.addRange(range);
+  } else if (sel.extend) {
+    sel.extend(node, offset);
+  }
+  view.domObserver.setCurSelection();
+  let { state } = view;
+  setTimeout(() => {
+    if (view.state == state)
+      selectionToDOM(view);
+  }, 50);
+}
+function findDirection(view, pos) {
+  let $pos = view.state.doc.resolve(pos);
+  if (!(chrome || windows) && $pos.parent.inlineContent) {
+    let coords = view.coordsAtPos(pos);
+    if (pos > $pos.start()) {
+      let before = view.coordsAtPos(pos - 1);
+      let mid = (before.top + before.bottom) / 2;
+      if (mid > coords.top && mid < coords.bottom && Math.abs(before.left - coords.left) > 1)
+        return before.left < coords.left ? "ltr" : "rtl";
+    }
+    if (pos < $pos.end()) {
+      let after = view.coordsAtPos(pos + 1);
+      let mid = (after.top + after.bottom) / 2;
+      if (mid > coords.top && mid < coords.bottom && Math.abs(after.left - coords.left) > 1)
+        return after.left > coords.left ? "ltr" : "rtl";
+    }
+  }
+  let computed = getComputedStyle(view.dom).direction;
+  return computed == "rtl" ? "rtl" : "ltr";
+}
+function selectVertically(view, dir, mods) {
+  let sel = view.state.selection;
+  if (sel instanceof TextSelection && !sel.empty || mods.indexOf("s") > -1)
+    return false;
+  if (mac && mods.indexOf("m") > -1)
+    return false;
+  let { $from, $to } = sel;
+  if (!$from.parent.inlineContent || view.endOfTextblock(dir < 0 ? "up" : "down")) {
+    let next = moveSelectionBlock(view.state, dir);
+    if (next && next instanceof NodeSelection)
+      return apply(view, next);
+  }
+  if (!$from.parent.inlineContent) {
+    let side = dir < 0 ? $from : $to;
+    let beyond = sel instanceof AllSelection ? Selection.near(side, dir) : Selection.findFrom(side, dir);
+    return beyond ? apply(view, beyond) : false;
+  }
+  return false;
+}
+function stopNativeHorizontalDelete(view, dir) {
+  if (!(view.state.selection instanceof TextSelection))
+    return true;
+  let { $head, $anchor, empty: empty2 } = view.state.selection;
+  if (!$head.sameParent($anchor))
+    return true;
+  if (!empty2)
+    return false;
+  if (view.endOfTextblock(dir > 0 ? "forward" : "backward"))
+    return true;
+  let nextNode = !$head.textOffset && (dir < 0 ? $head.nodeBefore : $head.nodeAfter);
+  if (nextNode && !nextNode.isText) {
+    let tr = view.state.tr;
+    if (dir < 0)
+      tr.delete($head.pos - nextNode.nodeSize, $head.pos);
+    else
+      tr.delete($head.pos, $head.pos + nextNode.nodeSize);
+    view.dispatch(tr);
+    return true;
+  }
+  return false;
+}
+function switchEditable(view, node, state) {
+  view.domObserver.stop();
+  node.contentEditable = state;
+  view.domObserver.start();
+}
+function safariDownArrowBug(view) {
+  if (!safari || view.state.selection.$head.parentOffset > 0)
+    return false;
+  let { focusNode, focusOffset } = view.domSelectionRange();
+  if (focusNode && focusNode.nodeType == 1 && focusOffset == 0 && focusNode.firstChild && focusNode.firstChild.contentEditable == "false") {
+    let child = focusNode.firstChild;
+    switchEditable(view, child, "true");
+    setTimeout(() => switchEditable(view, child, "false"), 20);
+  }
+  return false;
+}
+function getMods(event) {
+  let result = "";
+  if (event.ctrlKey)
+    result += "c";
+  if (event.metaKey)
+    result += "m";
+  if (event.altKey)
+    result += "a";
+  if (event.shiftKey)
+    result += "s";
+  return result;
+}
+function captureKeyDown(view, event) {
+  let code = event.keyCode, mods = getMods(event);
+  if (code == 8 || mac && code == 72 && mods == "c") {
+    return stopNativeHorizontalDelete(view, -1) || skipIgnoredNodes(view, -1);
+  } else if (code == 46 && !event.shiftKey || mac && code == 68 && mods == "c") {
+    return stopNativeHorizontalDelete(view, 1) || skipIgnoredNodes(view, 1);
+  } else if (code == 13 || code == 27) {
+    return true;
+  } else if (code == 37 || mac && code == 66 && mods == "c") {
+    let dir = code == 37 ? findDirection(view, view.state.selection.from) == "ltr" ? -1 : 1 : -1;
+    return selectHorizontally(view, dir, mods) || skipIgnoredNodes(view, dir);
+  } else if (code == 39 || mac && code == 70 && mods == "c") {
+    let dir = code == 39 ? findDirection(view, view.state.selection.from) == "ltr" ? 1 : -1 : 1;
+    return selectHorizontally(view, dir, mods) || skipIgnoredNodes(view, dir);
+  } else if (code == 38 || mac && code == 80 && mods == "c") {
+    return selectVertically(view, -1, mods) || skipIgnoredNodes(view, -1);
+  } else if (code == 40 || mac && code == 78 && mods == "c") {
+    return safariDownArrowBug(view) || selectVertically(view, 1, mods) || skipIgnoredNodes(view, 1);
+  } else if (mods == (mac ? "m" : "c") && (code == 66 || code == 73 || code == 89 || code == 90)) {
+    return true;
+  }
+  return false;
+}
+function serializeForClipboard(view, slice) {
+  view.someProp("transformCopied", (f) => {
+    slice = f(slice, view);
+  });
+  let context = [], { content, openStart, openEnd } = slice;
+  while (openStart > 1 && openEnd > 1 && content.childCount == 1 && content.firstChild.childCount == 1) {
+    openStart--;
+    openEnd--;
+    let node = content.firstChild;
+    context.push(node.type.name, node.attrs != node.type.defaultAttrs ? node.attrs : null);
+    content = node.content;
+  }
+  let serializer = view.someProp("clipboardSerializer") || DOMSerializer.fromSchema(view.state.schema);
+  let doc2 = detachedDoc(), wrap = doc2.createElement("div");
+  wrap.appendChild(serializer.serializeFragment(content, { document: doc2 }));
+  let firstChild = wrap.firstChild, needsWrap, wrappers = 0;
+  while (firstChild && firstChild.nodeType == 1 && (needsWrap = wrapMap[firstChild.nodeName.toLowerCase()])) {
+    for (let i = needsWrap.length - 1; i >= 0; i--) {
+      let wrapper = doc2.createElement(needsWrap[i]);
+      while (wrap.firstChild)
+        wrapper.appendChild(wrap.firstChild);
+      wrap.appendChild(wrapper);
+      wrappers++;
+    }
+    firstChild = wrap.firstChild;
+  }
+  if (firstChild && firstChild.nodeType == 1)
+    firstChild.setAttribute("data-pm-slice", `${openStart} ${openEnd}${wrappers ? ` -${wrappers}` : ""} ${JSON.stringify(context)}`);
+  let text = view.someProp("clipboardTextSerializer", (f) => f(slice, view)) || slice.content.textBetween(0, slice.content.size, "\n\n");
+  return { dom: wrap, text, slice };
+}
+function parseFromClipboard(view, text, html, plainText, $context) {
+  let inCode = $context.parent.type.spec.code;
+  let dom, slice;
+  if (!html && !text)
+    return null;
+  let asText = text && (plainText || inCode || !html);
+  if (asText) {
+    view.someProp("transformPastedText", (f) => {
+      text = f(text, inCode || plainText, view);
+    });
+    if (inCode)
+      return text ? new Slice(Fragment.from(view.state.schema.text(text.replace(/\r\n?/g, "\n"))), 0, 0) : Slice.empty;
+    let parsed = view.someProp("clipboardTextParser", (f) => f(text, $context, plainText, view));
+    if (parsed) {
+      slice = parsed;
+    } else {
+      let marks = $context.marks();
+      let { schema } = view.state, serializer = DOMSerializer.fromSchema(schema);
+      dom = document.createElement("div");
+      text.split(/(?:\r\n?|\n)+/).forEach((block) => {
+        let p = dom.appendChild(document.createElement("p"));
+        if (block)
+          p.appendChild(serializer.serializeNode(schema.text(block, marks)));
+      });
+    }
+  } else {
+    view.someProp("transformPastedHTML", (f) => {
+      html = f(html, view);
+    });
+    dom = readHTML(html);
+    if (webkit)
+      restoreReplacedSpaces(dom);
+  }
+  let contextNode = dom && dom.querySelector("[data-pm-slice]");
+  let sliceData = contextNode && /^(\d+) (\d+)(?: -(\d+))? (.*)/.exec(contextNode.getAttribute("data-pm-slice") || "");
+  if (sliceData && sliceData[3])
+    for (let i = +sliceData[3]; i > 0; i--) {
+      let child = dom.firstChild;
+      while (child && child.nodeType != 1)
+        child = child.nextSibling;
+      if (!child)
+        break;
+      dom = child;
+    }
+  if (!slice) {
+    let parser = view.someProp("clipboardParser") || view.someProp("domParser") || DOMParser2.fromSchema(view.state.schema);
+    slice = parser.parseSlice(dom, {
+      preserveWhitespace: !!(asText || sliceData),
+      context: $context,
+      ruleFromNode(dom2) {
+        if (dom2.nodeName == "BR" && !dom2.nextSibling && dom2.parentNode && !inlineParents.test(dom2.parentNode.nodeName))
+          return { ignore: true };
+        return null;
+      }
+    });
+  }
+  if (sliceData) {
+    slice = addContext(closeSlice(slice, +sliceData[1], +sliceData[2]), sliceData[4]);
+  } else {
+    slice = Slice.maxOpen(normalizeSiblings(slice.content, $context), true);
+    if (slice.openStart || slice.openEnd) {
+      let openStart = 0, openEnd = 0;
+      for (let node = slice.content.firstChild; openStart < slice.openStart && !node.type.spec.isolating; openStart++, node = node.firstChild) {
+      }
+      for (let node = slice.content.lastChild; openEnd < slice.openEnd && !node.type.spec.isolating; openEnd++, node = node.lastChild) {
+      }
+      slice = closeSlice(slice, openStart, openEnd);
+    }
+  }
+  view.someProp("transformPasted", (f) => {
+    slice = f(slice, view);
+  });
+  return slice;
+}
+var inlineParents = /^(a|abbr|acronym|b|cite|code|del|em|i|ins|kbd|label|output|q|ruby|s|samp|span|strong|sub|sup|time|u|tt|var)$/i;
+function normalizeSiblings(fragment, $context) {
+  if (fragment.childCount < 2)
+    return fragment;
+  for (let d = $context.depth; d >= 0; d--) {
+    let parent = $context.node(d);
+    let match = parent.contentMatchAt($context.index(d));
+    let lastWrap, result = [];
+    fragment.forEach((node) => {
+      if (!result)
+        return;
+      let wrap = match.findWrapping(node.type), inLast;
+      if (!wrap)
+        return result = null;
+      if (inLast = result.length && lastWrap.length && addToSibling(wrap, lastWrap, node, result[result.length - 1], 0)) {
+        result[result.length - 1] = inLast;
+      } else {
+        if (result.length)
+          result[result.length - 1] = closeRight(result[result.length - 1], lastWrap.length);
+        let wrapped = withWrappers(node, wrap);
+        result.push(wrapped);
+        match = match.matchType(wrapped.type);
+        lastWrap = wrap;
+      }
+    });
+    if (result)
+      return Fragment.from(result);
+  }
+  return fragment;
+}
+function withWrappers(node, wrap, from = 0) {
+  for (let i = wrap.length - 1; i >= from; i--)
+    node = wrap[i].create(null, Fragment.from(node));
+  return node;
+}
+function addToSibling(wrap, lastWrap, node, sibling, depth) {
+  if (depth < wrap.length && depth < lastWrap.length && wrap[depth] == lastWrap[depth]) {
+    let inner = addToSibling(wrap, lastWrap, node, sibling.lastChild, depth + 1);
+    if (inner)
+      return sibling.copy(sibling.content.replaceChild(sibling.childCount - 1, inner));
+    let match = sibling.contentMatchAt(sibling.childCount);
+    if (match.matchType(depth == wrap.length - 1 ? node.type : wrap[depth + 1]))
+      return sibling.copy(sibling.content.append(Fragment.from(withWrappers(node, wrap, depth + 1))));
+  }
+}
+function closeRight(node, depth) {
+  if (depth == 0)
+    return node;
+  let fragment = node.content.replaceChild(node.childCount - 1, closeRight(node.lastChild, depth - 1));
+  let fill = node.contentMatchAt(node.childCount).fillBefore(Fragment.empty, true);
+  return node.copy(fragment.append(fill));
+}
+function closeRange(fragment, side, from, to, depth, openEnd) {
+  let node = side < 0 ? fragment.firstChild : fragment.lastChild, inner = node.content;
+  if (fragment.childCount > 1)
+    openEnd = 0;
+  if (depth < to - 1)
+    inner = closeRange(inner, side, from, to, depth + 1, openEnd);
+  if (depth >= from)
+    inner = side < 0 ? node.contentMatchAt(0).fillBefore(inner, openEnd <= depth).append(inner) : inner.append(node.contentMatchAt(node.childCount).fillBefore(Fragment.empty, true));
+  return fragment.replaceChild(side < 0 ? 0 : fragment.childCount - 1, node.copy(inner));
+}
+function closeSlice(slice, openStart, openEnd) {
+  if (openStart < slice.openStart)
+    slice = new Slice(closeRange(slice.content, -1, openStart, slice.openStart, 0, slice.openEnd), openStart, slice.openEnd);
+  if (openEnd < slice.openEnd)
+    slice = new Slice(closeRange(slice.content, 1, openEnd, slice.openEnd, 0, 0), slice.openStart, openEnd);
+  return slice;
+}
+var wrapMap = {
+  thead: ["table"],
+  tbody: ["table"],
+  tfoot: ["table"],
+  caption: ["table"],
+  colgroup: ["table"],
+  col: ["table", "colgroup"],
+  tr: ["table", "tbody"],
+  td: ["table", "tbody", "tr"],
+  th: ["table", "tbody", "tr"]
+};
+var _detachedDoc = null;
+function detachedDoc() {
+  return _detachedDoc || (_detachedDoc = document.implementation.createHTMLDocument("title"));
+}
+var _policy = null;
+function maybeWrapTrusted(html) {
+  let trustedTypes = window.trustedTypes;
+  if (!trustedTypes)
+    return html;
+  if (!_policy)
+    _policy = trustedTypes.defaultPolicy || trustedTypes.createPolicy("ProseMirrorClipboard", { createHTML: (s) => s });
+  return _policy.createHTML(html);
+}
+function readHTML(html) {
+  let metas = /^(\s*<meta [^>]*>)*/.exec(html);
+  if (metas)
+    html = html.slice(metas[0].length);
+  let elt = detachedDoc().createElement("div");
+  let firstTag = /<([a-z][^>\s]+)/i.exec(html), wrap;
+  if (wrap = firstTag && wrapMap[firstTag[1].toLowerCase()])
+    html = wrap.map((n) => "<" + n + ">").join("") + html + wrap.map((n) => "</" + n + ">").reverse().join("");
+  elt.innerHTML = maybeWrapTrusted(html);
+  if (wrap)
+    for (let i = 0; i < wrap.length; i++)
+      elt = elt.querySelector(wrap[i]) || elt;
+  return elt;
+}
+function restoreReplacedSpaces(dom) {
+  let nodes = dom.querySelectorAll(chrome ? "span:not([class]):not([style])" : "span.Apple-converted-space");
+  for (let i = 0; i < nodes.length; i++) {
+    let node = nodes[i];
+    if (node.childNodes.length == 1 && node.textContent == "\xA0" && node.parentNode)
+      node.parentNode.replaceChild(dom.ownerDocument.createTextNode(" "), node);
+  }
+}
+function addContext(slice, context) {
+  if (!slice.size)
+    return slice;
+  let schema = slice.content.firstChild.type.schema, array;
+  try {
+    array = JSON.parse(context);
+  } catch (e) {
+    return slice;
+  }
+  let { content, openStart, openEnd } = slice;
+  for (let i = array.length - 2; i >= 0; i -= 2) {
+    let type = schema.nodes[array[i]];
+    if (!type || type.hasRequiredAttrs())
+      break;
+    content = Fragment.from(type.create(array[i + 1], content));
+    openStart++;
+    openEnd++;
+  }
+  return new Slice(content, openStart, openEnd);
+}
+var handlers = {};
+var editHandlers = {};
+function setSelectionOrigin(view, origin) {
+  view.input.lastSelectionOrigin = origin;
+  view.input.lastSelectionTime = Date.now();
+}
+editHandlers.keydown = (view, _event) => {
+  let event = _event;
+  view.input.shiftKey = event.keyCode == 16 || event.shiftKey;
+  if (inOrNearComposition(view, event))
+    return;
+  view.input.lastKeyCode = event.keyCode;
+  view.input.lastKeyCodeTime = Date.now();
+  if (android && chrome && event.keyCode == 13)
+    return;
+  if (event.keyCode != 229)
+    view.domObserver.forceFlush();
+  if (ios && event.keyCode == 13 && !event.ctrlKey && !event.altKey && !event.metaKey) {
+    let now = Date.now();
+    view.input.lastIOSEnter = now;
+    view.input.lastIOSEnterFallbackTimeout = setTimeout(() => {
+      if (view.input.lastIOSEnter == now) {
+        view.someProp("handleKeyDown", (f) => f(view, keyEvent(13, "Enter")));
+        view.input.lastIOSEnter = 0;
+      }
+    }, 200);
+  } else if (view.someProp("handleKeyDown", (f) => f(view, event)) || captureKeyDown(view, event)) {
+    event.preventDefault();
+  } else {
+    setSelectionOrigin(view, "key");
+  }
+};
+editHandlers.keyup = (view, event) => {
+  if (event.keyCode == 16)
+    view.input.shiftKey = false;
+};
+editHandlers.keypress = (view, _event) => {
+  let event = _event;
+  if (inOrNearComposition(view, event) || !event.charCode || event.ctrlKey && !event.altKey || mac && event.metaKey)
+    return;
+  if (view.someProp("handleKeyPress", (f) => f(view, event))) {
+    event.preventDefault();
+    return;
+  }
+  let sel = view.state.selection;
+  if (!(sel instanceof TextSelection) || !sel.$from.sameParent(sel.$to)) {
+    let text = String.fromCharCode(event.charCode);
+    if (!/[\r\n]/.test(text) && !view.someProp("handleTextInput", (f) => f(view, sel.$from.pos, sel.$to.pos, text)))
+      view.dispatch(view.state.tr.insertText(text).scrollIntoView());
+    event.preventDefault();
+  }
+};
+function eventCoords(event) {
+  return { left: event.clientX, top: event.clientY };
+}
+function isNear(event, click) {
+  let dx = click.x - event.clientX, dy = click.y - event.clientY;
+  return dx * dx + dy * dy < 100;
+}
+function runHandlerOnContext(view, propName, pos, inside, event) {
+  if (inside == -1)
+    return false;
+  let $pos = view.state.doc.resolve(inside);
+  for (let i = $pos.depth + 1; i > 0; i--) {
+    if (view.someProp(propName, (f) => i > $pos.depth ? f(view, pos, $pos.nodeAfter, $pos.before(i), event, true) : f(view, pos, $pos.node(i), $pos.before(i), event, false)))
+      return true;
+  }
+  return false;
+}
+function updateSelection(view, selection, origin) {
+  if (!view.focused)
+    view.focus();
+  if (view.state.selection.eq(selection))
+    return;
+  let tr = view.state.tr.setSelection(selection);
+  if (origin == "pointer")
+    tr.setMeta("pointer", true);
+  view.dispatch(tr);
+}
+function selectClickedLeaf(view, inside) {
+  if (inside == -1)
+    return false;
+  let $pos = view.state.doc.resolve(inside), node = $pos.nodeAfter;
+  if (node && node.isAtom && NodeSelection.isSelectable(node)) {
+    updateSelection(view, new NodeSelection($pos), "pointer");
+    return true;
+  }
+  return false;
+}
+function selectClickedNode(view, inside) {
+  if (inside == -1)
+    return false;
+  let sel = view.state.selection, selectedNode, selectAt;
+  if (sel instanceof NodeSelection)
+    selectedNode = sel.node;
+  let $pos = view.state.doc.resolve(inside);
+  for (let i = $pos.depth + 1; i > 0; i--) {
+    let node = i > $pos.depth ? $pos.nodeAfter : $pos.node(i);
+    if (NodeSelection.isSelectable(node)) {
+      if (selectedNode && sel.$from.depth > 0 && i >= sel.$from.depth && $pos.before(sel.$from.depth + 1) == sel.$from.pos)
+        selectAt = $pos.before(sel.$from.depth);
+      else
+        selectAt = $pos.before(i);
+      break;
+    }
+  }
+  if (selectAt != null) {
+    updateSelection(view, NodeSelection.create(view.state.doc, selectAt), "pointer");
+    return true;
+  } else {
+    return false;
+  }
+}
+function handleSingleClick(view, pos, inside, event, selectNode) {
+  return runHandlerOnContext(view, "handleClickOn", pos, inside, event) || view.someProp("handleClick", (f) => f(view, pos, event)) || (selectNode ? selectClickedNode(view, inside) : selectClickedLeaf(view, inside));
+}
+function handleDoubleClick(view, pos, inside, event) {
+  return runHandlerOnContext(view, "handleDoubleClickOn", pos, inside, event) || view.someProp("handleDoubleClick", (f) => f(view, pos, event));
+}
+function handleTripleClick(view, pos, inside, event) {
+  return runHandlerOnContext(view, "handleTripleClickOn", pos, inside, event) || view.someProp("handleTripleClick", (f) => f(view, pos, event)) || defaultTripleClick(view, inside, event);
+}
+function defaultTripleClick(view, inside, event) {
+  if (event.button != 0)
+    return false;
+  let doc2 = view.state.doc;
+  if (inside == -1) {
+    if (doc2.inlineContent) {
+      updateSelection(view, TextSelection.create(doc2, 0, doc2.content.size), "pointer");
+      return true;
+    }
+    return false;
+  }
+  let $pos = doc2.resolve(inside);
+  for (let i = $pos.depth + 1; i > 0; i--) {
+    let node = i > $pos.depth ? $pos.nodeAfter : $pos.node(i);
+    let nodePos = $pos.before(i);
+    if (node.inlineContent)
+      updateSelection(view, TextSelection.create(doc2, nodePos + 1, nodePos + 1 + node.content.size), "pointer");
+    else if (NodeSelection.isSelectable(node))
+      updateSelection(view, NodeSelection.create(doc2, nodePos), "pointer");
+    else
+      continue;
+    return true;
+  }
+}
+function forceDOMFlush(view) {
+  return endComposition(view);
+}
+var selectNodeModifier = mac ? "metaKey" : "ctrlKey";
+handlers.mousedown = (view, _event) => {
+  let event = _event;
+  view.input.shiftKey = event.shiftKey;
+  let flushed = forceDOMFlush(view);
+  let now = Date.now(), type = "singleClick";
+  if (now - view.input.lastClick.time < 500 && isNear(event, view.input.lastClick) && !event[selectNodeModifier]) {
+    if (view.input.lastClick.type == "singleClick")
+      type = "doubleClick";
+    else if (view.input.lastClick.type == "doubleClick")
+      type = "tripleClick";
+  }
+  view.input.lastClick = { time: now, x: event.clientX, y: event.clientY, type };
+  let pos = view.posAtCoords(eventCoords(event));
+  if (!pos)
+    return;
+  if (type == "singleClick") {
+    if (view.input.mouseDown)
+      view.input.mouseDown.done();
+    view.input.mouseDown = new MouseDown(view, pos, event, !!flushed);
+  } else if ((type == "doubleClick" ? handleDoubleClick : handleTripleClick)(view, pos.pos, pos.inside, event)) {
+    event.preventDefault();
+  } else {
+    setSelectionOrigin(view, "pointer");
+  }
+};
+var MouseDown = class {
+  constructor(view, pos, event, flushed) {
+    this.view = view;
+    this.pos = pos;
+    this.event = event;
+    this.flushed = flushed;
+    this.delayedSelectionSync = false;
+    this.mightDrag = null;
+    this.startDoc = view.state.doc;
+    this.selectNode = !!event[selectNodeModifier];
+    this.allowDefault = event.shiftKey;
+    let targetNode, targetPos;
+    if (pos.inside > -1) {
+      targetNode = view.state.doc.nodeAt(pos.inside);
+      targetPos = pos.inside;
+    } else {
+      let $pos = view.state.doc.resolve(pos.pos);
+      targetNode = $pos.parent;
+      targetPos = $pos.depth ? $pos.before() : 0;
+    }
+    const target = flushed ? null : event.target;
+    const targetDesc = target ? view.docView.nearestDesc(target, true) : null;
+    this.target = targetDesc && targetDesc.dom.nodeType == 1 ? targetDesc.dom : null;
+    let { selection } = view.state;
+    if (event.button == 0 && targetNode.type.spec.draggable && targetNode.type.spec.selectable !== false || selection instanceof NodeSelection && selection.from <= targetPos && selection.to > targetPos)
+      this.mightDrag = {
+        node: targetNode,
+        pos: targetPos,
+        addAttr: !!(this.target && !this.target.draggable),
+        setUneditable: !!(this.target && gecko && !this.target.hasAttribute("contentEditable"))
+      };
+    if (this.target && this.mightDrag && (this.mightDrag.addAttr || this.mightDrag.setUneditable)) {
+      this.view.domObserver.stop();
+      if (this.mightDrag.addAttr)
+        this.target.draggable = true;
+      if (this.mightDrag.setUneditable)
+        setTimeout(() => {
+          if (this.view.input.mouseDown == this)
+            this.target.setAttribute("contentEditable", "false");
+        }, 20);
+      this.view.domObserver.start();
+    }
+    view.root.addEventListener("mouseup", this.up = this.up.bind(this));
+    view.root.addEventListener("mousemove", this.move = this.move.bind(this));
+    setSelectionOrigin(view, "pointer");
+  }
+  done() {
+    this.view.root.removeEventListener("mouseup", this.up);
+    this.view.root.removeEventListener("mousemove", this.move);
+    if (this.mightDrag && this.target) {
+      this.view.domObserver.stop();
+      if (this.mightDrag.addAttr)
+        this.target.removeAttribute("draggable");
+      if (this.mightDrag.setUneditable)
+        this.target.removeAttribute("contentEditable");
+      this.view.domObserver.start();
+    }
+    if (this.delayedSelectionSync)
+      setTimeout(() => selectionToDOM(this.view));
+    this.view.input.mouseDown = null;
+  }
+  up(event) {
+    this.done();
+    if (!this.view.dom.contains(event.target))
+      return;
+    let pos = this.pos;
+    if (this.view.state.doc != this.startDoc)
+      pos = this.view.posAtCoords(eventCoords(event));
+    this.updateAllowDefault(event);
+    if (this.allowDefault || !pos) {
+      setSelectionOrigin(this.view, "pointer");
+    } else if (handleSingleClick(this.view, pos.pos, pos.inside, event, this.selectNode)) {
+      event.preventDefault();
+    } else if (event.button == 0 && (this.flushed || // Safari ignores clicks on draggable elements
+    safari && this.mightDrag && !this.mightDrag.node.isAtom || // Chrome will sometimes treat a node selection as a
+    // cursor, but still report that the node is selected
+    // when asked through getSelection. You'll then get a
+    // situation where clicking at the point where that
+    // (hidden) cursor is doesn't change the selection, and
+    // thus doesn't get a reaction from ProseMirror. This
+    // works around that.
+    chrome && !this.view.state.selection.visible && Math.min(Math.abs(pos.pos - this.view.state.selection.from), Math.abs(pos.pos - this.view.state.selection.to)) <= 2)) {
+      updateSelection(this.view, Selection.near(this.view.state.doc.resolve(pos.pos)), "pointer");
+      event.preventDefault();
+    } else {
+      setSelectionOrigin(this.view, "pointer");
+    }
+  }
+  move(event) {
+    this.updateAllowDefault(event);
+    setSelectionOrigin(this.view, "pointer");
+    if (event.buttons == 0)
+      this.done();
+  }
+  updateAllowDefault(event) {
+    if (!this.allowDefault && (Math.abs(this.event.x - event.clientX) > 4 || Math.abs(this.event.y - event.clientY) > 4))
+      this.allowDefault = true;
+  }
+};
+handlers.touchstart = (view) => {
+  view.input.lastTouch = Date.now();
+  forceDOMFlush(view);
+  setSelectionOrigin(view, "pointer");
+};
+handlers.touchmove = (view) => {
+  view.input.lastTouch = Date.now();
+  setSelectionOrigin(view, "pointer");
+};
+handlers.contextmenu = (view) => forceDOMFlush(view);
+function inOrNearComposition(view, event) {
+  if (view.composing)
+    return true;
+  if (safari && Math.abs(event.timeStamp - view.input.compositionEndedAt) < 500) {
+    view.input.compositionEndedAt = -2e8;
+    return true;
+  }
+  return false;
+}
+var timeoutComposition = android ? 5e3 : -1;
+editHandlers.compositionstart = editHandlers.compositionupdate = (view) => {
+  if (!view.composing) {
+    view.domObserver.flush();
+    let { state } = view, $pos = state.selection.$to;
+    if (state.selection instanceof TextSelection && (state.storedMarks || !$pos.textOffset && $pos.parentOffset && $pos.nodeBefore.marks.some((m) => m.type.spec.inclusive === false))) {
+      view.markCursor = view.state.storedMarks || $pos.marks();
+      endComposition(view, true);
+      view.markCursor = null;
+    } else {
+      endComposition(view, !state.selection.empty);
+      if (gecko && state.selection.empty && $pos.parentOffset && !$pos.textOffset && $pos.nodeBefore.marks.length) {
+        let sel = view.domSelectionRange();
+        for (let node = sel.focusNode, offset = sel.focusOffset; node && node.nodeType == 1 && offset != 0; ) {
+          let before = offset < 0 ? node.lastChild : node.childNodes[offset - 1];
+          if (!before)
+            break;
+          if (before.nodeType == 3) {
+            let sel2 = view.domSelection();
+            if (sel2)
+              sel2.collapse(before, before.nodeValue.length);
+            break;
+          } else {
+            node = before;
+            offset = -1;
+          }
+        }
+      }
+    }
+    view.input.composing = true;
+  }
+  scheduleComposeEnd(view, timeoutComposition);
+};
+editHandlers.compositionend = (view, event) => {
+  if (view.composing) {
+    view.input.composing = false;
+    view.input.compositionEndedAt = event.timeStamp;
+    view.input.compositionPendingChanges = view.domObserver.pendingRecords().length ? view.input.compositionID : 0;
+    view.input.compositionNode = null;
+    if (view.input.compositionPendingChanges)
+      Promise.resolve().then(() => view.domObserver.flush());
+    view.input.compositionID++;
+    scheduleComposeEnd(view, 20);
+  }
+};
+function scheduleComposeEnd(view, delay) {
+  clearTimeout(view.input.composingTimeout);
+  if (delay > -1)
+    view.input.composingTimeout = setTimeout(() => endComposition(view), delay);
+}
+function clearComposition(view) {
+  if (view.composing) {
+    view.input.composing = false;
+    view.input.compositionEndedAt = timestampFromCustomEvent();
+  }
+  while (view.input.compositionNodes.length > 0)
+    view.input.compositionNodes.pop().markParentsDirty();
+}
+function timestampFromCustomEvent() {
+  let event = document.createEvent("Event");
+  event.initEvent("event", true, true);
+  return event.timeStamp;
+}
+function endComposition(view, restarting = false) {
+  if (android && view.domObserver.flushingSoon >= 0)
+    return;
+  view.domObserver.forceFlush();
+  clearComposition(view);
+  if (restarting || view.docView && view.docView.dirty) {
+    let sel = selectionFromDOM(view);
+    if (sel && !sel.eq(view.state.selection))
+      view.dispatch(view.state.tr.setSelection(sel));
+    else if ((view.markCursor || restarting) && !view.state.selection.empty)
+      view.dispatch(view.state.tr.deleteSelection());
+    else
+      view.updateState(view.state);
+    return true;
+  }
+  return false;
+}
+function captureCopy(view, dom) {
+  if (!view.dom.parentNode)
+    return;
+  let wrap = view.dom.parentNode.appendChild(document.createElement("div"));
+  wrap.appendChild(dom);
+  wrap.style.cssText = "position: fixed; left: -10000px; top: 10px";
+  let sel = getSelection(), range = document.createRange();
+  range.selectNodeContents(dom);
+  view.dom.blur();
+  sel.removeAllRanges();
+  sel.addRange(range);
+  setTimeout(() => {
+    if (wrap.parentNode)
+      wrap.parentNode.removeChild(wrap);
+    view.focus();
+  }, 50);
+}
+var brokenClipboardAPI = ie && ie_version < 15 || ios && webkit_version < 604;
+handlers.copy = editHandlers.cut = (view, _event) => {
+  let event = _event;
+  let sel = view.state.selection, cut = event.type == "cut";
+  if (sel.empty)
+    return;
+  let data = brokenClipboardAPI ? null : event.clipboardData;
+  let slice = sel.content(), { dom, text } = serializeForClipboard(view, slice);
+  if (data) {
+    event.preventDefault();
+    data.clearData();
+    data.setData("text/html", dom.innerHTML);
+    data.setData("text/plain", text);
+  } else {
+    captureCopy(view, dom);
+  }
+  if (cut)
+    view.dispatch(view.state.tr.deleteSelection().scrollIntoView().setMeta("uiEvent", "cut"));
+};
+function sliceSingleNode(slice) {
+  return slice.openStart == 0 && slice.openEnd == 0 && slice.content.childCount == 1 ? slice.content.firstChild : null;
+}
+function capturePaste(view, event) {
+  if (!view.dom.parentNode)
+    return;
+  let plainText = view.input.shiftKey || view.state.selection.$from.parent.type.spec.code;
+  let target = view.dom.parentNode.appendChild(document.createElement(plainText ? "textarea" : "div"));
+  if (!plainText)
+    target.contentEditable = "true";
+  target.style.cssText = "position: fixed; left: -10000px; top: 10px";
+  target.focus();
+  let plain = view.input.shiftKey && view.input.lastKeyCode != 45;
+  setTimeout(() => {
+    view.focus();
+    if (target.parentNode)
+      target.parentNode.removeChild(target);
+    if (plainText)
+      doPaste(view, target.value, null, plain, event);
+    else
+      doPaste(view, target.textContent, target.innerHTML, plain, event);
+  }, 50);
+}
+function doPaste(view, text, html, preferPlain, event) {
+  let slice = parseFromClipboard(view, text, html, preferPlain, view.state.selection.$from);
+  if (view.someProp("handlePaste", (f) => f(view, event, slice || Slice.empty)))
+    return true;
+  if (!slice)
+    return false;
+  let singleNode = sliceSingleNode(slice);
+  let tr = singleNode ? view.state.tr.replaceSelectionWith(singleNode, preferPlain) : view.state.tr.replaceSelection(slice);
+  view.dispatch(tr.scrollIntoView().setMeta("paste", true).setMeta("uiEvent", "paste"));
+  return true;
+}
+function getText(clipboardData) {
+  let text = clipboardData.getData("text/plain") || clipboardData.getData("Text");
+  if (text)
+    return text;
+  let uris = clipboardData.getData("text/uri-list");
+  return uris ? uris.replace(/\r?\n/g, " ") : "";
+}
+editHandlers.paste = (view, _event) => {
+  let event = _event;
+  if (view.composing && !android)
+    return;
+  let data = brokenClipboardAPI ? null : event.clipboardData;
+  let plain = view.input.shiftKey && view.input.lastKeyCode != 45;
+  if (data && doPaste(view, getText(data), data.getData("text/html"), plain, event))
+    event.preventDefault();
+  else
+    capturePaste(view, event);
+};
+var Dragging = class {
+  constructor(slice, move, node) {
+    this.slice = slice;
+    this.move = move;
+    this.node = node;
+  }
+};
+var dragCopyModifier = mac ? "altKey" : "ctrlKey";
+function dragMoves(view, event) {
+  let moves = view.someProp("dragCopies", (test) => !test(event));
+  return moves != null ? moves : !event[dragCopyModifier];
+}
+handlers.dragstart = (view, _event) => {
+  let event = _event;
+  let mouseDown = view.input.mouseDown;
+  if (mouseDown)
+    mouseDown.done();
+  if (!event.dataTransfer)
+    return;
+  let sel = view.state.selection;
+  let pos = sel.empty ? null : view.posAtCoords(eventCoords(event));
+  let node;
+  if (pos && pos.pos >= sel.from && pos.pos <= (sel instanceof NodeSelection ? sel.to - 1 : sel.to)) ;
+  else if (mouseDown && mouseDown.mightDrag) {
+    node = NodeSelection.create(view.state.doc, mouseDown.mightDrag.pos);
+  } else if (event.target && event.target.nodeType == 1) {
+    let desc = view.docView.nearestDesc(event.target, true);
+    if (desc && desc.node.type.spec.draggable && desc != view.docView)
+      node = NodeSelection.create(view.state.doc, desc.posBefore);
+  }
+  let draggedSlice = (node || view.state.selection).content();
+  let { dom, text, slice } = serializeForClipboard(view, draggedSlice);
+  if (!event.dataTransfer.files.length || !chrome || chrome_version > 120)
+    event.dataTransfer.clearData();
+  event.dataTransfer.setData(brokenClipboardAPI ? "Text" : "text/html", dom.innerHTML);
+  event.dataTransfer.effectAllowed = "copyMove";
+  if (!brokenClipboardAPI)
+    event.dataTransfer.setData("text/plain", text);
+  view.dragging = new Dragging(slice, dragMoves(view, event), node);
+};
+handlers.dragend = (view) => {
+  let dragging = view.dragging;
+  window.setTimeout(() => {
+    if (view.dragging == dragging)
+      view.dragging = null;
+  }, 50);
+};
+editHandlers.dragover = editHandlers.dragenter = (_, e) => e.preventDefault();
+editHandlers.drop = (view, _event) => {
+  let event = _event;
+  let dragging = view.dragging;
+  view.dragging = null;
+  if (!event.dataTransfer)
+    return;
+  let eventPos = view.posAtCoords(eventCoords(event));
+  if (!eventPos)
+    return;
+  let $mouse = view.state.doc.resolve(eventPos.pos);
+  let slice = dragging && dragging.slice;
+  if (slice) {
+    view.someProp("transformPasted", (f) => {
+      slice = f(slice, view);
+    });
+  } else {
+    slice = parseFromClipboard(view, getText(event.dataTransfer), brokenClipboardAPI ? null : event.dataTransfer.getData("text/html"), false, $mouse);
+  }
+  let move = !!(dragging && dragMoves(view, event));
+  if (view.someProp("handleDrop", (f) => f(view, event, slice || Slice.empty, move))) {
+    event.preventDefault();
+    return;
+  }
+  if (!slice)
+    return;
+  event.preventDefault();
+  let insertPos = slice ? dropPoint(view.state.doc, $mouse.pos, slice) : $mouse.pos;
+  if (insertPos == null)
+    insertPos = $mouse.pos;
+  let tr = view.state.tr;
+  if (move) {
+    let { node } = dragging;
+    if (node)
+      node.replace(tr);
+    else
+      tr.deleteSelection();
+  }
+  let pos = tr.mapping.map(insertPos);
+  let isNode = slice.openStart == 0 && slice.openEnd == 0 && slice.content.childCount == 1;
+  let beforeInsert = tr.doc;
+  if (isNode)
+    tr.replaceRangeWith(pos, pos, slice.content.firstChild);
+  else
+    tr.replaceRange(pos, pos, slice);
+  if (tr.doc.eq(beforeInsert))
+    return;
+  let $pos = tr.doc.resolve(pos);
+  if (isNode && NodeSelection.isSelectable(slice.content.firstChild) && $pos.nodeAfter && $pos.nodeAfter.sameMarkup(slice.content.firstChild)) {
+    tr.setSelection(new NodeSelection($pos));
+  } else {
+    let end = tr.mapping.map(insertPos);
+    tr.mapping.maps[tr.mapping.maps.length - 1].forEach((_from, _to, _newFrom, newTo) => end = newTo);
+    tr.setSelection(selectionBetween(view, $pos, tr.doc.resolve(end)));
+  }
+  view.focus();
+  view.dispatch(tr.setMeta("uiEvent", "drop"));
+};
+handlers.focus = (view) => {
+  view.input.lastFocus = Date.now();
+  if (!view.focused) {
+    view.domObserver.stop();
+    view.dom.classList.add("ProseMirror-focused");
+    view.domObserver.start();
+    view.focused = true;
+    setTimeout(() => {
+      if (view.docView && view.hasFocus() && !view.domObserver.currentSelection.eq(view.domSelectionRange()))
+        selectionToDOM(view);
+    }, 20);
+  }
+};
+handlers.blur = (view, _event) => {
+  let event = _event;
+  if (view.focused) {
+    view.domObserver.stop();
+    view.dom.classList.remove("ProseMirror-focused");
+    view.domObserver.start();
+    if (event.relatedTarget && view.dom.contains(event.relatedTarget))
+      view.domObserver.currentSelection.clear();
+    view.focused = false;
+  }
+};
+handlers.beforeinput = (view, _event) => {
+  let event = _event;
+  if (chrome && android && event.inputType == "deleteContentBackward") {
+    view.domObserver.flushSoon();
+    let { domChangeCount } = view.input;
+    setTimeout(() => {
+      if (view.input.domChangeCount != domChangeCount)
+        return;
+      view.dom.blur();
+      view.focus();
+      if (view.someProp("handleKeyDown", (f) => f(view, keyEvent(8, "Backspace"))))
+        return;
+      let { $cursor } = view.state.selection;
+      if ($cursor && $cursor.pos > 0)
+        view.dispatch(view.state.tr.delete($cursor.pos - 1, $cursor.pos).scrollIntoView());
+    }, 50);
+  }
+};
+for (let prop in editHandlers)
+  handlers[prop] = editHandlers[prop];
+function compareObjs(a, b) {
+  if (a == b)
+    return true;
+  for (let p in a)
+    if (a[p] !== b[p])
+      return false;
+  for (let p in b)
+    if (!(p in a))
+      return false;
+  return true;
+}
+var WidgetType = class _WidgetType {
+  constructor(toDOM, spec) {
+    this.toDOM = toDOM;
+    this.spec = spec || noSpec;
+    this.side = this.spec.side || 0;
+  }
+  map(mapping, span, offset, oldOffset) {
+    let { pos, deleted } = mapping.mapResult(span.from + oldOffset, this.side < 0 ? -1 : 1);
+    return deleted ? null : new Decoration(pos - offset, pos - offset, this);
+  }
+  valid() {
+    return true;
+  }
+  eq(other) {
+    return this == other || other instanceof _WidgetType && (this.spec.key && this.spec.key == other.spec.key || this.toDOM == other.toDOM && compareObjs(this.spec, other.spec));
+  }
+  destroy(node) {
+    if (this.spec.destroy)
+      this.spec.destroy(node);
+  }
+};
+var InlineType = class _InlineType {
+  constructor(attrs, spec) {
+    this.attrs = attrs;
+    this.spec = spec || noSpec;
+  }
+  map(mapping, span, offset, oldOffset) {
+    let from = mapping.map(span.from + oldOffset, this.spec.inclusiveStart ? -1 : 1) - offset;
+    let to = mapping.map(span.to + oldOffset, this.spec.inclusiveEnd ? 1 : -1) - offset;
+    return from >= to ? null : new Decoration(from, to, this);
+  }
+  valid(_, span) {
+    return span.from < span.to;
+  }
+  eq(other) {
+    return this == other || other instanceof _InlineType && compareObjs(this.attrs, other.attrs) && compareObjs(this.spec, other.spec);
+  }
+  static is(span) {
+    return span.type instanceof _InlineType;
+  }
+  destroy() {
+  }
+};
+var NodeType = class _NodeType {
+  constructor(attrs, spec) {
+    this.attrs = attrs;
+    this.spec = spec || noSpec;
+  }
+  map(mapping, span, offset, oldOffset) {
+    let from = mapping.mapResult(span.from + oldOffset, 1);
+    if (from.deleted)
+      return null;
+    let to = mapping.mapResult(span.to + oldOffset, -1);
+    if (to.deleted || to.pos <= from.pos)
+      return null;
+    return new Decoration(from.pos - offset, to.pos - offset, this);
+  }
+  valid(node, span) {
+    let { index, offset } = node.content.findIndex(span.from), child;
+    return offset == span.from && !(child = node.child(index)).isText && offset + child.nodeSize == span.to;
+  }
+  eq(other) {
+    return this == other || other instanceof _NodeType && compareObjs(this.attrs, other.attrs) && compareObjs(this.spec, other.spec);
+  }
+  destroy() {
+  }
+};
+var Decoration = class _Decoration {
+  /**
+  @internal
+  */
+  constructor(from, to, type) {
+    this.from = from;
+    this.to = to;
+    this.type = type;
+  }
+  /**
+  @internal
+  */
+  copy(from, to) {
+    return new _Decoration(from, to, this.type);
+  }
+  /**
+  @internal
+  */
+  eq(other, offset = 0) {
+    return this.type.eq(other.type) && this.from + offset == other.from && this.to + offset == other.to;
+  }
+  /**
+  @internal
+  */
+  map(mapping, offset, oldOffset) {
+    return this.type.map(mapping, this, offset, oldOffset);
+  }
+  /**
+  Creates a widget decoration, which is a DOM node that's shown in
+  the document at the given position. It is recommended that you
+  delay rendering the widget by passing a function that will be
+  called when the widget is actually drawn in a view, but you can
+  also directly pass a DOM node. `getPos` can be used to find the
+  widget's current document position.
+  */
+  static widget(pos, toDOM, spec) {
+    return new _Decoration(pos, pos, new WidgetType(toDOM, spec));
+  }
+  /**
+  Creates an inline decoration, which adds the given attributes to
+  each inline node between `from` and `to`.
+  */
+  static inline(from, to, attrs, spec) {
+    return new _Decoration(from, to, new InlineType(attrs, spec));
+  }
+  /**
+  Creates a node decoration. `from` and `to` should point precisely
+  before and after a node in the document. That node, and only that
+  node, will receive the given attributes.
+  */
+  static node(from, to, attrs, spec) {
+    return new _Decoration(from, to, new NodeType(attrs, spec));
+  }
+  /**
+  The spec provided when creating this decoration. Can be useful
+  if you've stored extra information in that object.
+  */
+  get spec() {
+    return this.type.spec;
+  }
+  /**
+  @internal
+  */
+  get inline() {
+    return this.type instanceof InlineType;
+  }
+  /**
+  @internal
+  */
+  get widget() {
+    return this.type instanceof WidgetType;
+  }
+};
+var none = [];
+var noSpec = {};
+var DecorationSet = class _DecorationSet {
+  /**
+  @internal
+  */
+  constructor(local, children) {
+    this.local = local.length ? local : none;
+    this.children = children.length ? children : none;
+  }
+  /**
+  Create a set of decorations, using the structure of the given
+  document. This will consume (modify) the `decorations` array, so
+  you must make a copy if you want need to preserve that.
+  */
+  static create(doc2, decorations) {
+    return decorations.length ? buildTree(decorations, doc2, 0, noSpec) : empty;
+  }
+  /**
+  Find all decorations in this set which touch the given range
+  (including decorations that start or end directly at the
+  boundaries) and match the given predicate on their spec. When
+  `start` and `end` are omitted, all decorations in the set are
+  considered. When `predicate` isn't given, all decorations are
+  assumed to match.
+  */
+  find(start, end, predicate) {
+    let result = [];
+    this.findInner(start == null ? 0 : start, end == null ? 1e9 : end, result, 0, predicate);
+    return result;
+  }
+  findInner(start, end, result, offset, predicate) {
+    for (let i = 0; i < this.local.length; i++) {
+      let span = this.local[i];
+      if (span.from <= end && span.to >= start && (!predicate || predicate(span.spec)))
+        result.push(span.copy(span.from + offset, span.to + offset));
+    }
+    for (let i = 0; i < this.children.length; i += 3) {
+      if (this.children[i] < end && this.children[i + 1] > start) {
+        let childOff = this.children[i] + 1;
+        this.children[i + 2].findInner(start - childOff, end - childOff, result, offset + childOff, predicate);
+      }
+    }
+  }
+  /**
+  Map the set of decorations in response to a change in the
+  document.
+  */
+  map(mapping, doc2, options) {
+    if (this == empty || mapping.maps.length == 0)
+      return this;
+    return this.mapInner(mapping, doc2, 0, 0, options || noSpec);
+  }
+  /**
+  @internal
+  */
+  mapInner(mapping, node, offset, oldOffset, options) {
+    let newLocal;
+    for (let i = 0; i < this.local.length; i++) {
+      let mapped = this.local[i].map(mapping, offset, oldOffset);
+      if (mapped && mapped.type.valid(node, mapped))
+        (newLocal || (newLocal = [])).push(mapped);
+      else if (options.onRemove)
+        options.onRemove(this.local[i].spec);
+    }
+    if (this.children.length)
+      return mapChildren(this.children, newLocal || [], mapping, node, offset, oldOffset, options);
+    else
+      return newLocal ? new _DecorationSet(newLocal.sort(byPos), none) : empty;
+  }
+  /**
+  Add the given array of decorations to the ones in the set,
+  producing a new set. Consumes the `decorations` array. Needs
+  access to the current document to create the appropriate tree
+  structure.
+  */
+  add(doc2, decorations) {
+    if (!decorations.length)
+      return this;
+    if (this == empty)
+      return _DecorationSet.create(doc2, decorations);
+    return this.addInner(doc2, decorations, 0);
+  }
+  addInner(doc2, decorations, offset) {
+    let children, childIndex = 0;
+    doc2.forEach((childNode, childOffset) => {
+      let baseOffset = childOffset + offset, found;
+      if (!(found = takeSpansForNode(decorations, childNode, baseOffset)))
+        return;
+      if (!children)
+        children = this.children.slice();
+      while (childIndex < children.length && children[childIndex] < childOffset)
+        childIndex += 3;
+      if (children[childIndex] == childOffset)
+        children[childIndex + 2] = children[childIndex + 2].addInner(childNode, found, baseOffset + 1);
+      else
+        children.splice(childIndex, 0, childOffset, childOffset + childNode.nodeSize, buildTree(found, childNode, baseOffset + 1, noSpec));
+      childIndex += 3;
+    });
+    let local = moveSpans(childIndex ? withoutNulls(decorations) : decorations, -offset);
+    for (let i = 0; i < local.length; i++)
+      if (!local[i].type.valid(doc2, local[i]))
+        local.splice(i--, 1);
+    return new _DecorationSet(local.length ? this.local.concat(local).sort(byPos) : this.local, children || this.children);
+  }
+  /**
+  Create a new set that contains the decorations in this set, minus
+  the ones in the given array.
+  */
+  remove(decorations) {
+    if (decorations.length == 0 || this == empty)
+      return this;
+    return this.removeInner(decorations, 0);
+  }
+  removeInner(decorations, offset) {
+    let children = this.children, local = this.local;
+    for (let i = 0; i < children.length; i += 3) {
+      let found;
+      let from = children[i] + offset, to = children[i + 1] + offset;
+      for (let j = 0, span; j < decorations.length; j++)
+        if (span = decorations[j]) {
+          if (span.from > from && span.to < to) {
+            decorations[j] = null;
+            (found || (found = [])).push(span);
+          }
+        }
+      if (!found)
+        continue;
+      if (children == this.children)
+        children = this.children.slice();
+      let removed = children[i + 2].removeInner(found, from + 1);
+      if (removed != empty) {
+        children[i + 2] = removed;
+      } else {
+        children.splice(i, 3);
+        i -= 3;
+      }
+    }
+    if (local.length) {
+      for (let i = 0, span; i < decorations.length; i++)
+        if (span = decorations[i]) {
+          for (let j = 0; j < local.length; j++)
+            if (local[j].eq(span, offset)) {
+              if (local == this.local)
+                local = this.local.slice();
+              local.splice(j--, 1);
+            }
+        }
+    }
+    if (children == this.children && local == this.local)
+      return this;
+    return local.length || children.length ? new _DecorationSet(local, children) : empty;
+  }
+  forChild(offset, node) {
+    if (this == empty)
+      return this;
+    if (node.isLeaf)
+      return _DecorationSet.empty;
+    let child, local;
+    for (let i = 0; i < this.children.length; i += 3)
+      if (this.children[i] >= offset) {
+        if (this.children[i] == offset)
+          child = this.children[i + 2];
+        break;
+      }
+    let start = offset + 1, end = start + node.content.size;
+    for (let i = 0; i < this.local.length; i++) {
+      let dec = this.local[i];
+      if (dec.from < end && dec.to > start && dec.type instanceof InlineType) {
+        let from = Math.max(start, dec.from) - start, to = Math.min(end, dec.to) - start;
+        if (from < to)
+          (local || (local = [])).push(dec.copy(from, to));
+      }
+    }
+    if (local) {
+      let localSet = new _DecorationSet(local.sort(byPos), none);
+      return child ? new DecorationGroup([localSet, child]) : localSet;
+    }
+    return child || empty;
+  }
+  /**
+  @internal
+  */
+  eq(other) {
+    if (this == other)
+      return true;
+    if (!(other instanceof _DecorationSet) || this.local.length != other.local.length || this.children.length != other.children.length)
+      return false;
+    for (let i = 0; i < this.local.length; i++)
+      if (!this.local[i].eq(other.local[i]))
+        return false;
+    for (let i = 0; i < this.children.length; i += 3)
+      if (this.children[i] != other.children[i] || this.children[i + 1] != other.children[i + 1] || !this.children[i + 2].eq(other.children[i + 2]))
+        return false;
+    return true;
+  }
+  /**
+  @internal
+  */
+  locals(node) {
+    return removeOverlap(this.localsInner(node));
+  }
+  /**
+  @internal
+  */
+  localsInner(node) {
+    if (this == empty)
+      return none;
+    if (node.inlineContent || !this.local.some(InlineType.is))
+      return this.local;
+    let result = [];
+    for (let i = 0; i < this.local.length; i++) {
+      if (!(this.local[i].type instanceof InlineType))
+        result.push(this.local[i]);
+    }
+    return result;
+  }
+  forEachSet(f) {
+    f(this);
+  }
+};
+DecorationSet.empty = new DecorationSet([], []);
+DecorationSet.removeOverlap = removeOverlap;
+var empty = DecorationSet.empty;
+var DecorationGroup = class _DecorationGroup {
+  constructor(members) {
+    this.members = members;
+  }
+  map(mapping, doc2) {
+    const mappedDecos = this.members.map((member) => member.map(mapping, doc2, noSpec));
+    return _DecorationGroup.from(mappedDecos);
+  }
+  forChild(offset, child) {
+    if (child.isLeaf)
+      return DecorationSet.empty;
+    let found = [];
+    for (let i = 0; i < this.members.length; i++) {
+      let result = this.members[i].forChild(offset, child);
+      if (result == empty)
+        continue;
+      if (result instanceof _DecorationGroup)
+        found = found.concat(result.members);
+      else
+        found.push(result);
+    }
+    return _DecorationGroup.from(found);
+  }
+  eq(other) {
+    if (!(other instanceof _DecorationGroup) || other.members.length != this.members.length)
+      return false;
+    for (let i = 0; i < this.members.length; i++)
+      if (!this.members[i].eq(other.members[i]))
+        return false;
+    return true;
+  }
+  locals(node) {
+    let result, sorted = true;
+    for (let i = 0; i < this.members.length; i++) {
+      let locals = this.members[i].localsInner(node);
+      if (!locals.length)
+        continue;
+      if (!result) {
+        result = locals;
+      } else {
+        if (sorted) {
+          result = result.slice();
+          sorted = false;
+        }
+        for (let j = 0; j < locals.length; j++)
+          result.push(locals[j]);
+      }
+    }
+    return result ? removeOverlap(sorted ? result : result.sort(byPos)) : none;
+  }
+  // Create a group for the given array of decoration sets, or return
+  // a single set when possible.
+  static from(members) {
+    switch (members.length) {
+      case 0:
+        return empty;
+      case 1:
+        return members[0];
+      default:
+        return new _DecorationGroup(members.every((m) => m instanceof DecorationSet) ? members : members.reduce((r, m) => r.concat(m instanceof DecorationSet ? m : m.members), []));
+    }
+  }
+  forEachSet(f) {
+    for (let i = 0; i < this.members.length; i++)
+      this.members[i].forEachSet(f);
+  }
+};
+function mapChildren(oldChildren, newLocal, mapping, node, offset, oldOffset, options) {
+  let children = oldChildren.slice();
+  for (let i = 0, baseOffset = oldOffset; i < mapping.maps.length; i++) {
+    let moved = 0;
+    mapping.maps[i].forEach((oldStart, oldEnd, newStart, newEnd) => {
+      let dSize = newEnd - newStart - (oldEnd - oldStart);
+      for (let i2 = 0; i2 < children.length; i2 += 3) {
+        let end = children[i2 + 1];
+        if (end < 0 || oldStart > end + baseOffset - moved)
+          continue;
+        let start = children[i2] + baseOffset - moved;
+        if (oldEnd >= start) {
+          children[i2 + 1] = oldStart <= start ? -2 : -1;
+        } else if (oldStart >= baseOffset && dSize) {
+          children[i2] += dSize;
+          children[i2 + 1] += dSize;
+        }
+      }
+      moved += dSize;
+    });
+    baseOffset = mapping.maps[i].map(baseOffset, -1);
+  }
+  let mustRebuild = false;
+  for (let i = 0; i < children.length; i += 3)
+    if (children[i + 1] < 0) {
+      if (children[i + 1] == -2) {
+        mustRebuild = true;
+        children[i + 1] = -1;
+        continue;
+      }
+      let from = mapping.map(oldChildren[i] + oldOffset), fromLocal = from - offset;
+      if (fromLocal < 0 || fromLocal >= node.content.size) {
+        mustRebuild = true;
+        continue;
+      }
+      let to = mapping.map(oldChildren[i + 1] + oldOffset, -1), toLocal = to - offset;
+      let { index, offset: childOffset } = node.content.findIndex(fromLocal);
+      let childNode = node.maybeChild(index);
+      if (childNode && childOffset == fromLocal && childOffset + childNode.nodeSize == toLocal) {
+        let mapped = children[i + 2].mapInner(mapping, childNode, from + 1, oldChildren[i] + oldOffset + 1, options);
+        if (mapped != empty) {
+          children[i] = fromLocal;
+          children[i + 1] = toLocal;
+          children[i + 2] = mapped;
+        } else {
+          children[i + 1] = -2;
+          mustRebuild = true;
+        }
+      } else {
+        mustRebuild = true;
+      }
+    }
+  if (mustRebuild) {
+    let decorations = mapAndGatherRemainingDecorations(children, oldChildren, newLocal, mapping, offset, oldOffset, options);
+    let built = buildTree(decorations, node, 0, options);
+    newLocal = built.local;
+    for (let i = 0; i < children.length; i += 3)
+      if (children[i + 1] < 0) {
+        children.splice(i, 3);
+        i -= 3;
+      }
+    for (let i = 0, j = 0; i < built.children.length; i += 3) {
+      let from = built.children[i];
+      while (j < children.length && children[j] < from)
+        j += 3;
+      children.splice(j, 0, built.children[i], built.children[i + 1], built.children[i + 2]);
+    }
+  }
+  return new DecorationSet(newLocal.sort(byPos), children);
+}
+function moveSpans(spans, offset) {
+  if (!offset || !spans.length)
+    return spans;
+  let result = [];
+  for (let i = 0; i < spans.length; i++) {
+    let span = spans[i];
+    result.push(new Decoration(span.from + offset, span.to + offset, span.type));
+  }
+  return result;
+}
+function mapAndGatherRemainingDecorations(children, oldChildren, decorations, mapping, offset, oldOffset, options) {
+  function gather(set, oldOffset2) {
+    for (let i = 0; i < set.local.length; i++) {
+      let mapped = set.local[i].map(mapping, offset, oldOffset2);
+      if (mapped)
+        decorations.push(mapped);
+      else if (options.onRemove)
+        options.onRemove(set.local[i].spec);
+    }
+    for (let i = 0; i < set.children.length; i += 3)
+      gather(set.children[i + 2], set.children[i] + oldOffset2 + 1);
+  }
+  for (let i = 0; i < children.length; i += 3)
+    if (children[i + 1] == -1)
+      gather(children[i + 2], oldChildren[i] + oldOffset + 1);
+  return decorations;
+}
+function takeSpansForNode(spans, node, offset) {
+  if (node.isLeaf)
+    return null;
+  let end = offset + node.nodeSize, found = null;
+  for (let i = 0, span; i < spans.length; i++) {
+    if ((span = spans[i]) && span.from > offset && span.to < end) {
+      (found || (found = [])).push(span);
+      spans[i] = null;
+    }
+  }
+  return found;
+}
+function withoutNulls(array) {
+  let result = [];
+  for (let i = 0; i < array.length; i++)
+    if (array[i] != null)
+      result.push(array[i]);
+  return result;
+}
+function buildTree(spans, node, offset, options) {
+  let children = [], hasNulls = false;
+  node.forEach((childNode, localStart) => {
+    let found = takeSpansForNode(spans, childNode, localStart + offset);
+    if (found) {
+      hasNulls = true;
+      let subtree = buildTree(found, childNode, offset + localStart + 1, options);
+      if (subtree != empty)
+        children.push(localStart, localStart + childNode.nodeSize, subtree);
+    }
+  });
+  let locals = moveSpans(hasNulls ? withoutNulls(spans) : spans, -offset).sort(byPos);
+  for (let i = 0; i < locals.length; i++)
+    if (!locals[i].type.valid(node, locals[i])) {
+      if (options.onRemove)
+        options.onRemove(locals[i].spec);
+      locals.splice(i--, 1);
+    }
+  return locals.length || children.length ? new DecorationSet(locals, children) : empty;
+}
+function byPos(a, b) {
+  return a.from - b.from || a.to - b.to;
+}
+function removeOverlap(spans) {
+  let working = spans;
+  for (let i = 0; i < working.length - 1; i++) {
+    let span = working[i];
+    if (span.from != span.to)
+      for (let j = i + 1; j < working.length; j++) {
+        let next = working[j];
+        if (next.from == span.from) {
+          if (next.to != span.to) {
+            if (working == spans)
+              working = spans.slice();
+            working[j] = next.copy(next.from, span.to);
+            insertAhead(working, j + 1, next.copy(span.to, next.to));
+          }
+          continue;
+        } else {
+          if (next.from < span.to) {
+            if (working == spans)
+              working = spans.slice();
+            working[i] = span.copy(span.from, next.from);
+            insertAhead(working, j, span.copy(next.from, span.to));
+          }
+          break;
+        }
+      }
+  }
+  return working;
+}
+function insertAhead(array, i, deco) {
+  while (i < array.length && byPos(deco, array[i]) > 0)
+    i++;
+  array.splice(i, 0, deco);
+}
+var useCharData = ie && ie_version <= 11;
+
+// src/prosemirror/lib/converter.ts
+import {
+  DOMParser as PMDOMParser,
+  DOMSerializer as PMDOMSerializer
+} from "prosemirror-model";
+function htmlToProseMirror(content, schema) {
+  const doc2 = new DOMParser().parseFromString(content, "text/html");
+  return PMDOMParser.fromSchema(schema).parse(doc2);
+}
+function proseMirrorToHtml(doc2) {
+  return new XMLSerializer().serializeToString(
+    PMDOMSerializer.fromSchema(doc2.type.schema).serializeFragment(
+      doc2.content
+    )
+  ).replace(/\sxmlns="[^"]+"/g, "");
+}
+
+// src/prosemirror/lib/sync.ts
+import { recreateTransform } from "@manuscripts/prosemirror-recreate-steps";
+var META_KEY = "fromJazz";
+function createSyncHandlers(coRichText) {
+  let view;
+  function handleCoRichTextChange(newText) {
+    if (!view || !newText) return;
+    const pmDoc = htmlToProseMirror(
+      newText.toString(),
+      view.state.doc.type.schema
+    );
+    const transform = recreateTransform(view.state.doc, pmDoc);
+    const tr = view.state.tr;
+    transform.steps.forEach((step) => {
+      tr.step(step);
+    });
+    tr.setMeta(META_KEY, true);
+    view.dispatch(tr);
+  }
+  function handleProseMirrorChange(tr) {
+    if (!coRichText || tr.getMeta(META_KEY)) return;
+    if (tr.docChanged) {
+      const str = proseMirrorToHtml(tr.doc);
+      coRichText.applyDiff(str);
+    }
+  }
+  return {
+    setView: (newView) => {
+      view = newView;
+    },
+    handleCoRichTextChange,
+    handleProseMirrorChange
+  };
+}
+
+// src/prosemirror/lib/plugin.ts
+var jazzPluginKey = new PluginKey("jazz");
+function createJazzPlugin(coRichText, config = {}) {
+  const { setView, handleCoRichTextChange, handleProseMirrorChange } = createSyncHandlers(coRichText);
+  return new Plugin({
+    key: jazzPluginKey,
+    view(editorView) {
+      setView(editorView);
+      if (coRichText) {
+        coRichText.subscribe(handleCoRichTextChange);
+      }
+      return {
+        destroy() {
+          setView(void 0);
+        }
+      };
+    },
+    state: {
+      init(_config, state) {
+        if (coRichText) {
+          const pmDoc = htmlToProseMirror(coRichText.toString(), state.schema);
+          state.doc = pmDoc;
+        }
+        return { coRichText };
+      },
+      apply(tr, value) {
+        handleProseMirrorChange(tr);
+        return value;
+      }
+    },
+    props: {
+      decorations(state) {
+        if (!config.showDecorations) {
+          return null;
+        }
+        const selection = state.selection;
+        if (selection.empty) {
+          const caret = Decoration.widget(selection.from, () => {
+            const div = document.createElement("span");
+            div.className = "jazz-caret";
+            div.style.borderLeft = "2px solid red";
+            div.style.marginLeft = "-2px";
+            div.style.backgroundColor = "rgba(255,0,0,0.1)";
+            return div;
+          });
+          return DecorationSet.create(state.doc, [caret]);
+        }
+        const selectionDecoration = Decoration.inline(
+          selection.from,
+          selection.to,
+          {
+            class: "jazz-caret-selection",
+            style: "border-left: 2px solid red; margin-left: -2px; background: rgba(255,0,0,0.1);"
+          }
+        );
+        return DecorationSet.create(state.doc, [selectionDecoration]);
+      }
+    }
+  });
+}
+export {
+  createJazzPlugin
+};
+//# sourceMappingURL=index.js.map