{"version":3,"sources":["webpack:///./node_modules/prosemirror-commands/dist/index.es.js","webpack:///./node_modules/prosemirror-gapcursor/dist/index.es.js","webpack:///./node_modules/prosemirror-dropcursor/dist/index.es.js","webpack:///./node_modules/prosemirror-collab/dist/index.es.js"],"names":["deleteSelection","state","dispatch","selection","empty","tr","scrollIntoView","joinBackward","view","ref","$cursor","endOfTextblock","parentOffset","$cut","findCutBefore","range","blockRange","target","lift","before","nodeBefore","type","spec","isolating","deleteBarrier","parent","content","size","textblockAt","isSelectable","deleteRange","after","setSelection","findFrom","doc","resolve","mapping","map","pos","create","nodeSize","isAtom","depth","delete","node","side","only","firstChild","lastChild","isTextblock","childCount","selectNodeBackward","$head","$pos","i","index","joinForward","findCutAfter","nodeAfter","selectNodeForward","$from","$to","newlineInCode","$anchor","code","sameParent","insertText","defaultBlockAt","match","edgeCount","edge","hasRequiredAttrs","exitCode","above","indexAfter","contentMatchAt","canReplaceWith","replaceWith","createAndFill","near","createParagraphNear","sel","inlineContent","insert","liftEmptyBlock","end","split","splitBlock","isBlock","atEnd","deflt","types","can","first","$first","setNodeMarkup","selectAll","joinMaybeClear","compatibleContent","canReplace","clearIncompatible","join","conn","canDelAfter","findWrapping","matchType","validEnd","wrap","length","from","copy","step","joinAt","selAfter","at","wrap$1","push","afterText","afterDepth","end$1","i$1","tr$1","wrapIn","nodeType","attrs","wrapping","setBlockType","to","applicable","nodesBetween","hasMarkup","markApplies","ranges","loop","allowsMarkType","v","returned","toggleMark","markType","isInSet","storedMarks","marks","removeStoredMark","addStoredMark","has","ref$1","rangeHasMark","ref$2","$from$1","$to$1","removeMark","start","spaceStart","isText","exec","text","spaceEnd","addMark","chainCommands","commands","len","arguments","backspace","del","pcBaseKeymap","macBaseKeymap","key","mac","navigator","test","platform","os","baseKeymap","GapCursor","Selection","call","this","__proto__","prototype","Object","constructor","head","valid","eq","other","toJSON","fromJSON","json","RangeError","getBookmark","GapBookmark","anchor","closedBefore","closedAfter","override","allowGapCursor","defaultType","dir","mustMove","search","next","d","child","$cur","inside","$cur$1","visible","jsonID","gapCursor","props","decorations","drawGapCursor","createSelectionBetween","_view","handleClick","handleKeyDown","arrow","axis","dirStr","$start","$found","event","editable","posAtCoords","left","clientX","top","clientY","nodeAt","document","createElement","className","widget","dropCursor","options","editorView","DropCursorView","this$1","width","color","class","cursorPos","element","timeout","handlers","name","handler","e","dom","addEventListener","destroy","forEach","removeEventListener","update","prevState","setCursor","updateOverlay","parentNode","removeChild","rect","nodeRect","nodeDOM","getBoundingClientRect","bottom","right","coords","coordsAtPos","parentLeft","parentTop","offsetParent","appendChild","style","cssText","body","getComputedStyle","position","pageXOffset","pageYOffset","rect$1","scrollLeft","scrollTop","height","scheduleRemoval","clearTimeout","setTimeout","dragover","dragging","slice","dragend","drop","dragleave","contains","relatedTarget","Rebaseable","inverted","origin","rebaseSteps","steps","over","transform","result","i$2","mapFrom","mapped","maybeStep","failed","setMirror","invert","docs","CollabState","version","unconfirmed","unconfirmedFrom","collabKey","collab","config","clientID","Math","floor","random","init","apply","newState","getMeta","docChanged","concat","historyPreserveItems","receiveTransaction","clientIDs","collabState","getState","ourID","get","ours","setMeta","nUnconfirmed","newCollabState","mapSelectionBackward","between","updated","sendableSteps","s","_origins","getVersion"],"mappings":"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","file":"js/chunk-vendors~e2ef4635.8a0d51bc.js","sourcesContent":["import { liftTarget, canJoin, joinPoint, canSplit, ReplaceAroundStep, findWrapping } from 'prosemirror-transform';\nimport { Fragment, Slice } from 'prosemirror-model';\nimport { NodeSelection, Selection, AllSelection, TextSelection } from 'prosemirror-state';\n\n// :: (EditorState, ?(tr: Transaction)) → bool\n// Delete the selection, if there is one.\nfunction deleteSelection(state, dispatch) {\n  if (state.selection.empty) { return false }\n  if (dispatch) { dispatch(state.tr.deleteSelection().scrollIntoView()); }\n  return true\n}\n\n// :: (EditorState, ?(tr: Transaction), ?EditorView) → bool\n// If the selection is empty and at the start of a textblock, try to\n// reduce the distance between that block and the one before it—if\n// there's a block directly before it that can be joined, join them.\n// If not, try to move the selected block closer to the next one in\n// the document structure by lifting it out of its parent or moving it\n// into a parent of the previous block. Will use the view for accurate\n// (bidi-aware) start-of-textblock detection if given.\nfunction joinBackward(state, dispatch, view) {\n  var ref = state.selection;\n  var $cursor = ref.$cursor;\n  if (!$cursor || (view ? !view.endOfTextblock(\"backward\", state)\n                        : $cursor.parentOffset > 0))\n    { return false }\n\n  var $cut = findCutBefore($cursor);\n\n  // If there is no node before this, try to lift\n  if (!$cut) {\n    var range = $cursor.blockRange(), target = range && liftTarget(range);\n    if (target == null) { return false }\n    if (dispatch) { dispatch(state.tr.lift(range, target).scrollIntoView()); }\n    return true\n  }\n\n  var before = $cut.nodeBefore;\n  // Apply the joining algorithm\n  if (!before.type.spec.isolating && deleteBarrier(state, $cut, dispatch))\n    { return true }\n\n  // If the node below has no content and the node above is\n  // selectable, delete the node below and select the one above.\n  if ($cursor.parent.content.size == 0 &&\n      (textblockAt(before, \"end\") || NodeSelection.isSelectable(before))) {\n    if (dispatch) {\n      var tr = state.tr.deleteRange($cursor.before(), $cursor.after());\n      tr.setSelection(textblockAt(before, \"end\") ? Selection.findFrom(tr.doc.resolve(tr.mapping.map($cut.pos, -1)), -1)\n                      : NodeSelection.create(tr.doc, $cut.pos - before.nodeSize));\n      dispatch(tr.scrollIntoView());\n    }\n    return true\n  }\n\n  // If the node before is an atom, delete it\n  if (before.isAtom && $cut.depth == $cursor.depth - 1) {\n    if (dispatch) { dispatch(state.tr.delete($cut.pos - before.nodeSize, $cut.pos).scrollIntoView()); }\n    return true\n  }\n\n  return false\n}\n\nfunction textblockAt(node, side, only) {\n  for (; node; node = (side == \"start\" ? node.firstChild : node.lastChild)) {\n    if (node.isTextblock) { return true }\n    if (only && node.childCount != 1) { return false }\n  }\n  return false\n}\n\n// :: (EditorState, ?(tr: Transaction), ?EditorView) → bool\n// When the selection is empty and at the start of a textblock, select\n// the node before that textblock, if possible. This is intended to be\n// bound to keys like backspace, after\n// [`joinBackward`](#commands.joinBackward) or other deleting\n// commands, as a fall-back behavior when the schema doesn't allow\n// deletion at the selected point.\nfunction selectNodeBackward(state, dispatch, view) {\n  var ref = state.selection;\n  var $head = ref.$head;\n  var empty = ref.empty;\n  var $cut = $head;\n  if (!empty) { return false }\n\n  if ($head.parent.isTextblock) {\n    if (view ? !view.endOfTextblock(\"backward\", state) : $head.parentOffset > 0) { return false }\n    $cut = findCutBefore($head);\n  }\n  var node = $cut && $cut.nodeBefore;\n  if (!node || !NodeSelection.isSelectable(node)) { return false }\n  if (dispatch)\n    { dispatch(state.tr.setSelection(NodeSelection.create(state.doc, $cut.pos - node.nodeSize)).scrollIntoView()); }\n  return true\n}\n\nfunction findCutBefore($pos) {\n  if (!$pos.parent.type.spec.isolating) { for (var i = $pos.depth - 1; i >= 0; i--) {\n    if ($pos.index(i) > 0) { return $pos.doc.resolve($pos.before(i + 1)) }\n    if ($pos.node(i).type.spec.isolating) { break }\n  } }\n  return null\n}\n\n// :: (EditorState, ?(tr: Transaction), ?EditorView) → bool\n// If the selection is empty and the cursor is at the end of a\n// textblock, try to reduce or remove the boundary between that block\n// and the one after it, either by joining them or by moving the other\n// block closer to this one in the tree structure. Will use the view\n// for accurate start-of-textblock detection if given.\nfunction joinForward(state, dispatch, view) {\n  var ref = state.selection;\n  var $cursor = ref.$cursor;\n  if (!$cursor || (view ? !view.endOfTextblock(\"forward\", state)\n                        : $cursor.parentOffset < $cursor.parent.content.size))\n    { return false }\n\n  var $cut = findCutAfter($cursor);\n\n  // If there is no node after this, there's nothing to do\n  if (!$cut) { return false }\n\n  var after = $cut.nodeAfter;\n  // Try the joining algorithm\n  if (deleteBarrier(state, $cut, dispatch)) { return true }\n\n  // If the node above has no content and the node below is\n  // selectable, delete the node above and select the one below.\n  if ($cursor.parent.content.size == 0 &&\n      (textblockAt(after, \"start\") || NodeSelection.isSelectable(after))) {\n    if (dispatch) {\n      var tr = state.tr.deleteRange($cursor.before(), $cursor.after());\n      tr.setSelection(textblockAt(after, \"start\") ? Selection.findFrom(tr.doc.resolve(tr.mapping.map($cut.pos)), 1)\n                      : NodeSelection.create(tr.doc, tr.mapping.map($cut.pos)));\n      dispatch(tr.scrollIntoView());\n    }\n    return true\n  }\n\n  // If the next node is an atom, delete it\n  if (after.isAtom && $cut.depth == $cursor.depth - 1) {\n    if (dispatch) { dispatch(state.tr.delete($cut.pos, $cut.pos + after.nodeSize).scrollIntoView()); }\n    return true\n  }\n\n  return false\n}\n\n// :: (EditorState, ?(tr: Transaction), ?EditorView) → bool\n// When the selection is empty and at the end of a textblock, select\n// the node coming after that textblock, if possible. This is intended\n// to be bound to keys like delete, after\n// [`joinForward`](#commands.joinForward) and similar deleting\n// commands, to provide a fall-back behavior when the schema doesn't\n// allow deletion at the selected point.\nfunction selectNodeForward(state, dispatch, view) {\n  var ref = state.selection;\n  var $head = ref.$head;\n  var empty = ref.empty;\n  var $cut = $head;\n  if (!empty) { return false }\n  if ($head.parent.isTextblock) {\n    if (view ? !view.endOfTextblock(\"forward\", state) : $head.parentOffset < $head.parent.content.size)\n      { return false }\n    $cut = findCutAfter($head);\n  }\n  var node = $cut && $cut.nodeAfter;\n  if (!node || !NodeSelection.isSelectable(node)) { return false }\n  if (dispatch)\n    { dispatch(state.tr.setSelection(NodeSelection.create(state.doc, $cut.pos)).scrollIntoView()); }\n  return true\n}\n\nfunction findCutAfter($pos) {\n  if (!$pos.parent.type.spec.isolating) { for (var i = $pos.depth - 1; i >= 0; i--) {\n    var parent = $pos.node(i);\n    if ($pos.index(i) + 1 < parent.childCount) { return $pos.doc.resolve($pos.after(i + 1)) }\n    if (parent.type.spec.isolating) { break }\n  } }\n  return null\n}\n\n// :: (EditorState, ?(tr: Transaction)) → bool\n// Join the selected block or, if there is a text selection, the\n// closest ancestor block of the selection that can be joined, with\n// the sibling above it.\nfunction joinUp(state, dispatch) {\n  var sel = state.selection, nodeSel = sel instanceof NodeSelection, point;\n  if (nodeSel) {\n    if (sel.node.isTextblock || !canJoin(state.doc, sel.from)) { return false }\n    point = sel.from;\n  } else {\n    point = joinPoint(state.doc, sel.from, -1);\n    if (point == null) { return false }\n  }\n  if (dispatch) {\n    var tr = state.tr.join(point);\n    if (nodeSel) { tr.setSelection(NodeSelection.create(tr.doc, point - state.doc.resolve(point).nodeBefore.nodeSize)); }\n    dispatch(tr.scrollIntoView());\n  }\n  return true\n}\n\n// :: (EditorState, ?(tr: Transaction)) → bool\n// Join the selected block, or the closest ancestor of the selection\n// that can be joined, with the sibling after it.\nfunction joinDown(state, dispatch) {\n  var sel = state.selection, point;\n  if (sel instanceof NodeSelection) {\n    if (sel.node.isTextblock || !canJoin(state.doc, sel.to)) { return false }\n    point = sel.to;\n  } else {\n    point = joinPoint(state.doc, sel.to, 1);\n    if (point == null) { return false }\n  }\n  if (dispatch)\n    { dispatch(state.tr.join(point).scrollIntoView()); }\n  return true\n}\n\n// :: (EditorState, ?(tr: Transaction)) → bool\n// Lift the selected block, or the closest ancestor block of the\n// selection that can be lifted, out of its parent node.\nfunction lift(state, dispatch) {\n  var ref = state.selection;\n  var $from = ref.$from;\n  var $to = ref.$to;\n  var range = $from.blockRange($to), target = range && liftTarget(range);\n  if (target == null) { return false }\n  if (dispatch) { dispatch(state.tr.lift(range, target).scrollIntoView()); }\n  return true\n}\n\n// :: (EditorState, ?(tr: Transaction)) → bool\n// If the selection is in a node whose type has a truthy\n// [`code`](#model.NodeSpec.code) property in its spec, replace the\n// selection with a newline character.\nfunction newlineInCode(state, dispatch) {\n  var ref = state.selection;\n  var $head = ref.$head;\n  var $anchor = ref.$anchor;\n  if (!$head.parent.type.spec.code || !$head.sameParent($anchor)) { return false }\n  if (dispatch) { dispatch(state.tr.insertText(\"\\n\").scrollIntoView()); }\n  return true\n}\n\nfunction defaultBlockAt(match) {\n  for (var i = 0; i < match.edgeCount; i++) {\n    var ref = match.edge(i);\n    var type = ref.type;\n    if (type.isTextblock && !type.hasRequiredAttrs()) { return type }\n  }\n  return null\n}\n\n// :: (EditorState, ?(tr: Transaction)) → bool\n// When the selection is in a node with a truthy\n// [`code`](#model.NodeSpec.code) property in its spec, create a\n// default block after the code block, and move the cursor there.\nfunction exitCode(state, dispatch) {\n  var ref = state.selection;\n  var $head = ref.$head;\n  var $anchor = ref.$anchor;\n  if (!$head.parent.type.spec.code || !$head.sameParent($anchor)) { return false }\n  var above = $head.node(-1), after = $head.indexAfter(-1), type = defaultBlockAt(above.contentMatchAt(after));\n  if (!above.canReplaceWith(after, after, type)) { return false }\n  if (dispatch) {\n    var pos = $head.after(), tr = state.tr.replaceWith(pos, pos, type.createAndFill());\n    tr.setSelection(Selection.near(tr.doc.resolve(pos), 1));\n    dispatch(tr.scrollIntoView());\n  }\n  return true\n}\n\n// :: (EditorState, ?(tr: Transaction)) → bool\n// If a block node is selected, create an empty paragraph before (if\n// it is its parent's first child) or after it.\nfunction createParagraphNear(state, dispatch) {\n  var sel = state.selection;\n  var $from = sel.$from;\n  var $to = sel.$to;\n  if (sel instanceof AllSelection || $from.parent.inlineContent || $to.parent.inlineContent) { return false }\n  var type = defaultBlockAt($to.parent.contentMatchAt($to.indexAfter()));\n  if (!type || !type.isTextblock) { return false }\n  if (dispatch) {\n    var side = (!$from.parentOffset && $to.index() < $to.parent.childCount ? $from : $to).pos;\n    var tr = state.tr.insert(side, type.createAndFill());\n    tr.setSelection(TextSelection.create(tr.doc, side + 1));\n    dispatch(tr.scrollIntoView());\n  }\n  return true\n}\n\n// :: (EditorState, ?(tr: Transaction)) → bool\n// If the cursor is in an empty textblock that can be lifted, lift the\n// block.\nfunction liftEmptyBlock(state, dispatch) {\n  var ref = state.selection;\n  var $cursor = ref.$cursor;\n  if (!$cursor || $cursor.parent.content.size) { return false }\n  if ($cursor.depth > 1 && $cursor.after() != $cursor.end(-1)) {\n    var before = $cursor.before();\n    if (canSplit(state.doc, before)) {\n      if (dispatch) { dispatch(state.tr.split(before).scrollIntoView()); }\n      return true\n    }\n  }\n  var range = $cursor.blockRange(), target = range && liftTarget(range);\n  if (target == null) { return false }\n  if (dispatch) { dispatch(state.tr.lift(range, target).scrollIntoView()); }\n  return true\n}\n\n// :: (EditorState, ?(tr: Transaction)) → bool\n// Split the parent block of the selection. If the selection is a text\n// selection, also delete its content.\nfunction splitBlock(state, dispatch) {\n  var ref = state.selection;\n  var $from = ref.$from;\n  var $to = ref.$to;\n  if (state.selection instanceof NodeSelection && state.selection.node.isBlock) {\n    if (!$from.parentOffset || !canSplit(state.doc, $from.pos)) { return false }\n    if (dispatch) { dispatch(state.tr.split($from.pos).scrollIntoView()); }\n    return true\n  }\n\n  if (!$from.parent.isBlock) { return false }\n\n  if (dispatch) {\n    var atEnd = $to.parentOffset == $to.parent.content.size;\n    var tr = state.tr;\n    if (state.selection instanceof TextSelection || state.selection instanceof AllSelection) { tr.deleteSelection(); }\n    var deflt = $from.depth == 0 ? null : defaultBlockAt($from.node(-1).contentMatchAt($from.indexAfter(-1)));\n    var types = atEnd && deflt ? [{type: deflt}] : null;\n    var can = canSplit(tr.doc, tr.mapping.map($from.pos), 1, types);\n    if (!types && !can && canSplit(tr.doc, tr.mapping.map($from.pos), 1, deflt && [{type: deflt}])) {\n      types = [{type: deflt}];\n      can = true;\n    }\n    if (can) {\n      tr.split(tr.mapping.map($from.pos), 1, types);\n      if (!atEnd && !$from.parentOffset && $from.parent.type != deflt) {\n        var first = tr.mapping.map($from.before()), $first = tr.doc.resolve(first);\n        if ($from.node(-1).canReplaceWith($first.index(), $first.index() + 1, deflt))\n          { tr.setNodeMarkup(tr.mapping.map($from.before()), deflt); }\n      }\n    }\n    dispatch(tr.scrollIntoView());\n  }\n  return true\n}\n\n// :: (EditorState, ?(tr: Transaction)) → bool\n// Acts like [`splitBlock`](#commands.splitBlock), but without\n// resetting the set of active marks at the cursor.\nfunction splitBlockKeepMarks(state, dispatch) {\n  return splitBlock(state, dispatch && (function (tr) {\n    var marks = state.storedMarks || (state.selection.$to.parentOffset && state.selection.$from.marks());\n    if (marks) { tr.ensureMarks(marks); }\n    dispatch(tr);\n  }))\n}\n\n// :: (EditorState, ?(tr: Transaction)) → bool\n// Move the selection to the node wrapping the current selection, if\n// any. (Will not select the document node.)\nfunction selectParentNode(state, dispatch) {\n  var ref = state.selection;\n  var $from = ref.$from;\n  var to = ref.to;\n  var pos;\n  var same = $from.sharedDepth(to);\n  if (same == 0) { return false }\n  pos = $from.before(same);\n  if (dispatch) { dispatch(state.tr.setSelection(NodeSelection.create(state.doc, pos))); }\n  return true\n}\n\n// :: (EditorState, ?(tr: Transaction)) → bool\n// Select the whole document.\nfunction selectAll(state, dispatch) {\n  if (dispatch) { dispatch(state.tr.setSelection(new AllSelection(state.doc))); }\n  return true\n}\n\nfunction joinMaybeClear(state, $pos, dispatch) {\n  var before = $pos.nodeBefore, after = $pos.nodeAfter, index = $pos.index();\n  if (!before || !after || !before.type.compatibleContent(after.type)) { return false }\n  if (!before.content.size && $pos.parent.canReplace(index - 1, index)) {\n    if (dispatch) { dispatch(state.tr.delete($pos.pos - before.nodeSize, $pos.pos).scrollIntoView()); }\n    return true\n  }\n  if (!$pos.parent.canReplace(index, index + 1) || !(after.isTextblock || canJoin(state.doc, $pos.pos)))\n    { return false }\n  if (dispatch)\n    { dispatch(state.tr\n             .clearIncompatible($pos.pos, before.type, before.contentMatchAt(before.childCount))\n             .join($pos.pos)\n             .scrollIntoView()); }\n  return true\n}\n\nfunction deleteBarrier(state, $cut, dispatch) {\n  var before = $cut.nodeBefore, after = $cut.nodeAfter, conn, match;\n  if (before.type.spec.isolating || after.type.spec.isolating) { return false }\n  if (joinMaybeClear(state, $cut, dispatch)) { return true }\n\n  var canDelAfter = $cut.parent.canReplace($cut.index(), $cut.index() + 1);\n  if (canDelAfter &&\n      (conn = (match = before.contentMatchAt(before.childCount)).findWrapping(after.type)) &&\n      match.matchType(conn[0] || after.type).validEnd) {\n    if (dispatch) {\n      var end = $cut.pos + after.nodeSize, wrap = Fragment.empty;\n      for (var i = conn.length - 1; i >= 0; i--)\n        { wrap = Fragment.from(conn[i].create(null, wrap)); }\n      wrap = Fragment.from(before.copy(wrap));\n      var tr = state.tr.step(new ReplaceAroundStep($cut.pos - 1, end, $cut.pos, end, new Slice(wrap, 1, 0), conn.length, true));\n      var joinAt = end + 2 * conn.length;\n      if (canJoin(tr.doc, joinAt)) { tr.join(joinAt); }\n      dispatch(tr.scrollIntoView());\n    }\n    return true\n  }\n\n  var selAfter = Selection.findFrom($cut, 1);\n  var range = selAfter && selAfter.$from.blockRange(selAfter.$to), target = range && liftTarget(range);\n  if (target != null && target >= $cut.depth) {\n    if (dispatch) { dispatch(state.tr.lift(range, target).scrollIntoView()); }\n    return true\n  }\n\n  if (canDelAfter && textblockAt(after, \"start\", true) && textblockAt(before, \"end\")) {\n    var at = before, wrap$1 = [];\n    for (;;) {\n      wrap$1.push(at);\n      if (at.isTextblock) { break }\n      at = at.lastChild;\n    }\n    var afterText = after, afterDepth = 1;\n    for (; !afterText.isTextblock; afterText = afterText.firstChild) { afterDepth++; }\n    if (at.canReplace(at.childCount, at.childCount, afterText.content)) {\n      if (dispatch) {\n        var end$1 = Fragment.empty;\n        for (var i$1 = wrap$1.length - 1; i$1 >= 0; i$1--) { end$1 = Fragment.from(wrap$1[i$1].copy(end$1)); }\n        var tr$1 = state.tr.step(new ReplaceAroundStep($cut.pos - wrap$1.length, $cut.pos + after.nodeSize,\n                                                     $cut.pos + afterDepth, $cut.pos + after.nodeSize - afterDepth,\n                                                     new Slice(end$1, wrap$1.length, 0), 0, true));\n        dispatch(tr$1.scrollIntoView());\n      }\n      return true\n    }\n  }\n\n  return false\n}\n\n// Parameterized commands\n\n// :: (NodeType, ?Object) → (state: EditorState, dispatch: ?(tr: Transaction)) → bool\n// Wrap the selection in a node of the given type with the given\n// attributes.\nfunction wrapIn(nodeType, attrs) {\n  return function(state, dispatch) {\n    var ref = state.selection;\n    var $from = ref.$from;\n    var $to = ref.$to;\n    var range = $from.blockRange($to), wrapping = range && findWrapping(range, nodeType, attrs);\n    if (!wrapping) { return false }\n    if (dispatch) { dispatch(state.tr.wrap(range, wrapping).scrollIntoView()); }\n    return true\n  }\n}\n\n// :: (NodeType, ?Object) → (state: EditorState, dispatch: ?(tr: Transaction)) → bool\n// Returns a command that tries to set the selected textblocks to the\n// given node type with the given attributes.\nfunction setBlockType(nodeType, attrs) {\n  return function(state, dispatch) {\n    var ref = state.selection;\n    var from = ref.from;\n    var to = ref.to;\n    var applicable = false;\n    state.doc.nodesBetween(from, to, function (node, pos) {\n      if (applicable) { return false }\n      if (!node.isTextblock || node.hasMarkup(nodeType, attrs)) { return }\n      if (node.type == nodeType) {\n        applicable = true;\n      } else {\n        var $pos = state.doc.resolve(pos), index = $pos.index();\n        applicable = $pos.parent.canReplaceWith(index, index + 1, nodeType);\n      }\n    });\n    if (!applicable) { return false }\n    if (dispatch) { dispatch(state.tr.setBlockType(from, to, nodeType, attrs).scrollIntoView()); }\n    return true\n  }\n}\n\nfunction markApplies(doc, ranges, type) {\n  var loop = function ( i ) {\n    var ref = ranges[i];\n    var $from = ref.$from;\n    var $to = ref.$to;\n    var can = $from.depth == 0 ? doc.type.allowsMarkType(type) : false;\n    doc.nodesBetween($from.pos, $to.pos, function (node) {\n      if (can) { return false }\n      can = node.inlineContent && node.type.allowsMarkType(type);\n    });\n    if (can) { return { v: true } }\n  };\n\n  for (var i = 0; i < ranges.length; i++) {\n    var returned = loop( i );\n\n    if ( returned ) return returned.v;\n  }\n  return false\n}\n\n// :: (MarkType, ?Object) → (state: EditorState, dispatch: ?(tr: Transaction)) → bool\n// Create a command function that toggles the given mark with the\n// given attributes. Will return `false` when the current selection\n// doesn't support that mark. This will remove the mark if any marks\n// of that type exist in the selection, or add it otherwise. If the\n// selection is empty, this applies to the [stored\n// marks](#state.EditorState.storedMarks) instead of a range of the\n// document.\nfunction toggleMark(markType, attrs) {\n  return function(state, dispatch) {\n    var ref = state.selection;\n    var empty = ref.empty;\n    var $cursor = ref.$cursor;\n    var ranges = ref.ranges;\n    if ((empty && !$cursor) || !markApplies(state.doc, ranges, markType)) { return false }\n    if (dispatch) {\n      if ($cursor) {\n        if (markType.isInSet(state.storedMarks || $cursor.marks()))\n          { dispatch(state.tr.removeStoredMark(markType)); }\n        else\n          { dispatch(state.tr.addStoredMark(markType.create(attrs))); }\n      } else {\n        var has = false, tr = state.tr;\n        for (var i = 0; !has && i < ranges.length; i++) {\n          var ref$1 = ranges[i];\n          var $from = ref$1.$from;\n          var $to = ref$1.$to;\n          has = state.doc.rangeHasMark($from.pos, $to.pos, markType);\n        }\n        for (var i$1 = 0; i$1 < ranges.length; i$1++) {\n          var ref$2 = ranges[i$1];\n          var $from$1 = ref$2.$from;\n          var $to$1 = ref$2.$to;\n          if (has) {\n            tr.removeMark($from$1.pos, $to$1.pos, markType);\n          } else {\n            var from = $from$1.pos, to = $to$1.pos, start = $from$1.nodeAfter, end = $to$1.nodeBefore;\n            var spaceStart = start && start.isText ? /^\\s*/.exec(start.text)[0].length : 0;\n            var spaceEnd = end && end.isText ? /\\s*$/.exec(end.text)[0].length : 0;\n            if (from + spaceStart < to) { from += spaceStart; to -= spaceEnd; }\n            tr.addMark(from, to, markType.create(attrs));\n          }\n        }\n        dispatch(tr.scrollIntoView());\n      }\n    }\n    return true\n  }\n}\n\nfunction wrapDispatchForJoin(dispatch, isJoinable) {\n  return function (tr) {\n    if (!tr.isGeneric) { return dispatch(tr) }\n\n    var ranges = [];\n    for (var i = 0; i < tr.mapping.maps.length; i++) {\n      var map = tr.mapping.maps[i];\n      for (var j = 0; j < ranges.length; j++)\n        { ranges[j] = map.map(ranges[j]); }\n      map.forEach(function (_s, _e, from, to) { return ranges.push(from, to); });\n    }\n\n    // Figure out which joinable points exist inside those ranges,\n    // by checking all node boundaries in their parent nodes.\n    var joinable = [];\n    for (var i$1 = 0; i$1 < ranges.length; i$1 += 2) {\n      var from = ranges[i$1], to = ranges[i$1 + 1];\n      var $from = tr.doc.resolve(from), depth = $from.sharedDepth(to), parent = $from.node(depth);\n      for (var index = $from.indexAfter(depth), pos = $from.after(depth + 1); pos <= to; ++index) {\n        var after = parent.maybeChild(index);\n        if (!after) { break }\n        if (index && joinable.indexOf(pos) == -1) {\n          var before = parent.child(index - 1);\n          if (before.type == after.type && isJoinable(before, after))\n            { joinable.push(pos); }\n        }\n        pos += after.nodeSize;\n      }\n    }\n    // Join the joinable points\n    joinable.sort(function (a, b) { return a - b; });\n    for (var i$2 = joinable.length - 1; i$2 >= 0; i$2--) {\n      if (canJoin(tr.doc, joinable[i$2])) { tr.join(joinable[i$2]); }\n    }\n    dispatch(tr);\n  }\n}\n\n// :: ((state: EditorState, ?(tr: Transaction)) → bool, union<(before: Node, after: Node) → bool, [string]>) → (state: EditorState, ?(tr: Transaction)) → bool\n// Wrap a command so that, when it produces a transform that causes\n// two joinable nodes to end up next to each other, those are joined.\n// Nodes are considered joinable when they are of the same type and\n// when the `isJoinable` predicate returns true for them or, if an\n// array of strings was passed, if their node type name is in that\n// array.\nfunction autoJoin(command, isJoinable) {\n  if (Array.isArray(isJoinable)) {\n    var types = isJoinable;\n    isJoinable = function (node) { return types.indexOf(node.type.name) > -1; };\n  }\n  return function (state, dispatch, view) { return command(state, dispatch && wrapDispatchForJoin(dispatch, isJoinable), view); }\n}\n\n// :: (...[(EditorState, ?(tr: Transaction), ?EditorView) → bool]) → (EditorState, ?(tr: Transaction), ?EditorView) → bool\n// Combine a number of command functions into a single function (which\n// calls them one by one until one returns true).\nfunction chainCommands() {\n  var commands = [], len = arguments.length;\n  while ( len-- ) commands[ len ] = arguments[ len ];\n\n  return function(state, dispatch, view) {\n    for (var i = 0; i < commands.length; i++)\n      { if (commands[i](state, dispatch, view)) { return true } }\n    return false\n  }\n}\n\nvar backspace = chainCommands(deleteSelection, joinBackward, selectNodeBackward);\nvar del = chainCommands(deleteSelection, joinForward, selectNodeForward);\n\n// :: Object\n// A basic keymap containing bindings not specific to any schema.\n// Binds the following keys (when multiple commands are listed, they\n// are chained with [`chainCommands`](#commands.chainCommands)):\n//\n// * **Enter** to `newlineInCode`, `createParagraphNear`, `liftEmptyBlock`, `splitBlock`\n// * **Mod-Enter** to `exitCode`\n// * **Backspace** and **Mod-Backspace** to `deleteSelection`, `joinBackward`, `selectNodeBackward`\n// * **Delete** and **Mod-Delete** to `deleteSelection`, `joinForward`, `selectNodeForward`\n// * **Mod-Delete** to `deleteSelection`, `joinForward`, `selectNodeForward`\n// * **Mod-a** to `selectAll`\nvar pcBaseKeymap = {\n  \"Enter\": chainCommands(newlineInCode, createParagraphNear, liftEmptyBlock, splitBlock),\n  \"Mod-Enter\": exitCode,\n  \"Backspace\": backspace,\n  \"Mod-Backspace\": backspace,\n  \"Shift-Backspace\": backspace,\n  \"Delete\": del,\n  \"Mod-Delete\": del,\n  \"Mod-a\": selectAll\n};\n\n// :: Object\n// A copy of `pcBaseKeymap` that also binds **Ctrl-h** like Backspace,\n// **Ctrl-d** like Delete, **Alt-Backspace** like Ctrl-Backspace, and\n// **Ctrl-Alt-Backspace**, **Alt-Delete**, and **Alt-d** like\n// Ctrl-Delete.\nvar macBaseKeymap = {\n  \"Ctrl-h\": pcBaseKeymap[\"Backspace\"],\n  \"Alt-Backspace\": pcBaseKeymap[\"Mod-Backspace\"],\n  \"Ctrl-d\": pcBaseKeymap[\"Delete\"],\n  \"Ctrl-Alt-Backspace\": pcBaseKeymap[\"Mod-Delete\"],\n  \"Alt-Delete\": pcBaseKeymap[\"Mod-Delete\"],\n  \"Alt-d\": pcBaseKeymap[\"Mod-Delete\"]\n};\nfor (var key in pcBaseKeymap) { macBaseKeymap[key] = pcBaseKeymap[key]; }\n\n// declare global: os, navigator\nvar mac = typeof navigator != \"undefined\" ? /Mac/.test(navigator.platform)\n          : typeof os != \"undefined\" ? os.platform() == \"darwin\" : false;\n\n// :: Object\n// Depending on the detected platform, this will hold\n// [`pcBasekeymap`](#commands.pcBaseKeymap) or\n// [`macBaseKeymap`](#commands.macBaseKeymap).\nvar baseKeymap = mac ? macBaseKeymap : pcBaseKeymap;\n\nexport { autoJoin, baseKeymap, chainCommands, createParagraphNear, deleteSelection, exitCode, joinBackward, joinDown, joinForward, joinUp, lift, liftEmptyBlock, macBaseKeymap, newlineInCode, pcBaseKeymap, selectAll, selectNodeBackward, selectNodeForward, selectParentNode, setBlockType, splitBlock, splitBlockKeepMarks, toggleMark, wrapIn };\n//# sourceMappingURL=index.es.js.map\n","import { keydownHandler } from 'prosemirror-keymap';\nimport { NodeSelection, Selection, Plugin, TextSelection } from 'prosemirror-state';\nimport { DecorationSet, Decoration } from 'prosemirror-view';\nimport { Slice } from 'prosemirror-model';\n\n// ::- Gap cursor selections are represented using this class. Its\n// `$anchor` and `$head` properties both point at the cursor position.\nvar GapCursor = /*@__PURE__*/(function (Selection) {\n  function GapCursor($pos) {\n    Selection.call(this, $pos, $pos);\n  }\n\n  if ( Selection ) GapCursor.__proto__ = Selection;\n  GapCursor.prototype = Object.create( Selection && Selection.prototype );\n  GapCursor.prototype.constructor = GapCursor;\n\n  GapCursor.prototype.map = function map (doc, mapping) {\n    var $pos = doc.resolve(mapping.map(this.head));\n    return GapCursor.valid($pos) ? new GapCursor($pos) : Selection.near($pos)\n  };\n\n  GapCursor.prototype.content = function content () { return Slice.empty };\n\n  GapCursor.prototype.eq = function eq (other) {\n    return other instanceof GapCursor && other.head == this.head\n  };\n\n  GapCursor.prototype.toJSON = function toJSON () {\n    return {type: \"gapcursor\", pos: this.head}\n  };\n\n  GapCursor.fromJSON = function fromJSON (doc, json) {\n    if (typeof json.pos != \"number\") { throw new RangeError(\"Invalid input for GapCursor.fromJSON\") }\n    return new GapCursor(doc.resolve(json.pos))\n  };\n\n  GapCursor.prototype.getBookmark = function getBookmark () { return new GapBookmark(this.anchor) };\n\n  GapCursor.valid = function valid ($pos) {\n    var parent = $pos.parent;\n    if (parent.isTextblock || !closedBefore($pos) || !closedAfter($pos)) { return false }\n    var override = parent.type.spec.allowGapCursor;\n    if (override != null) { return override }\n    var deflt = parent.contentMatchAt($pos.index()).defaultType;\n    return deflt && deflt.isTextblock\n  };\n\n  GapCursor.findFrom = function findFrom ($pos, dir, mustMove) {\n    search: for (;;) {\n      if (!mustMove && GapCursor.valid($pos)) { return $pos }\n      var pos = $pos.pos, next = null;\n      // Scan up from this position\n      for (var d = $pos.depth;; d--) {\n        var parent = $pos.node(d);\n        if (dir > 0 ? $pos.indexAfter(d) < parent.childCount : $pos.index(d) > 0) {\n          next = parent.child(dir > 0 ? $pos.indexAfter(d) : $pos.index(d) - 1);\n          break\n        } else if (d == 0) {\n          return null\n        }\n        pos += dir;\n        var $cur = $pos.doc.resolve(pos);\n        if (GapCursor.valid($cur)) { return $cur }\n      }\n\n      // And then down into the next node\n      for (;;) {\n        var inside = dir > 0 ? next.firstChild : next.lastChild;\n        if (!inside) {\n          if (next.isAtom && !next.isText && !NodeSelection.isSelectable(next)) {\n            $pos = $pos.doc.resolve(pos + next.nodeSize * dir);\n            mustMove = false;\n            continue search\n          }\n          break\n        }\n        next = inside;\n        pos += dir;\n        var $cur$1 = $pos.doc.resolve(pos);\n        if (GapCursor.valid($cur$1)) { return $cur$1 }\n      }\n\n      return null\n    }\n  };\n\n  return GapCursor;\n}(Selection));\n\nGapCursor.prototype.visible = false;\n\nSelection.jsonID(\"gapcursor\", GapCursor);\n\nvar GapBookmark = function GapBookmark(pos) {\n  this.pos = pos;\n};\nGapBookmark.prototype.map = function map (mapping) {\n  return new GapBookmark(mapping.map(this.pos))\n};\nGapBookmark.prototype.resolve = function resolve (doc) {\n  var $pos = doc.resolve(this.pos);\n  return GapCursor.valid($pos) ? new GapCursor($pos) : Selection.near($pos)\n};\n\nfunction closedBefore($pos) {\n  for (var d = $pos.depth; d >= 0; d--) {\n    var index = $pos.index(d);\n    // At the start of this parent, look at next one\n    if (index == 0) { continue }\n    // See if the node before (or its first ancestor) is closed\n    for (var before = $pos.node(d).child(index - 1);; before = before.lastChild) {\n      if ((before.childCount == 0 && !before.inlineContent) || before.isAtom || before.type.spec.isolating) { return true }\n      if (before.inlineContent) { return false }\n    }\n  }\n  // Hit start of document\n  return true\n}\n\nfunction closedAfter($pos) {\n  for (var d = $pos.depth; d >= 0; d--) {\n    var index = $pos.indexAfter(d), parent = $pos.node(d);\n    if (index == parent.childCount) { continue }\n    for (var after = parent.child(index);; after = after.firstChild) {\n      if ((after.childCount == 0 && !after.inlineContent) || after.isAtom || after.type.spec.isolating) { return true }\n      if (after.inlineContent) { return false }\n    }\n  }\n  return true\n}\n\n// :: () → Plugin\n// Create a gap cursor plugin. When enabled, this will capture clicks\n// near and arrow-key-motion past places that don't have a normally\n// selectable position nearby, and create a gap cursor selection for\n// them. The cursor is drawn as an element with class\n// `ProseMirror-gapcursor`. You can either include\n// `style/gapcursor.css` from the package's directory or add your own\n// styles to make it visible.\nvar gapCursor = function() {\n  return new Plugin({\n    props: {\n      decorations: drawGapCursor,\n\n      createSelectionBetween: function createSelectionBetween(_view, $anchor, $head) {\n        if ($anchor.pos == $head.pos && GapCursor.valid($head)) { return new GapCursor($head) }\n      },\n\n      handleClick: handleClick,\n      handleKeyDown: handleKeyDown\n    }\n  })\n};\n\nvar handleKeyDown = keydownHandler({\n  \"ArrowLeft\": arrow(\"horiz\", -1),\n  \"ArrowRight\": arrow(\"horiz\", 1),\n  \"ArrowUp\": arrow(\"vert\", -1),\n  \"ArrowDown\": arrow(\"vert\", 1)\n});\n\nfunction arrow(axis, dir) {\n  var dirStr = axis == \"vert\" ? (dir > 0 ? \"down\" : \"up\") : (dir > 0 ? \"right\" : \"left\");\n  return function(state, dispatch, view) {\n    var sel = state.selection;\n    var $start = dir > 0 ? sel.$to : sel.$from, mustMove = sel.empty;\n    if (sel instanceof TextSelection) {\n      if (!view.endOfTextblock(dirStr) || $start.depth == 0) { return false }\n      mustMove = false;\n      $start = state.doc.resolve(dir > 0 ? $start.after() : $start.before());\n    }\n    var $found = GapCursor.findFrom($start, dir, mustMove);\n    if (!$found) { return false }\n    if (dispatch) { dispatch(state.tr.setSelection(new GapCursor($found))); }\n    return true\n  }\n}\n\nfunction handleClick(view, pos, event) {\n  if (!view.editable) { return false }\n  var $pos = view.state.doc.resolve(pos);\n  if (!GapCursor.valid($pos)) { return false }\n  var ref = view.posAtCoords({left: event.clientX, top: event.clientY});\n  var inside = ref.inside;\n  if (inside > -1 && NodeSelection.isSelectable(view.state.doc.nodeAt(inside))) { return false }\n  view.dispatch(view.state.tr.setSelection(new GapCursor($pos)));\n  return true\n}\n\nfunction drawGapCursor(state) {\n  if (!(state.selection instanceof GapCursor)) { return null }\n  var node = document.createElement(\"div\");\n  node.className = \"ProseMirror-gapcursor\";\n  return DecorationSet.create(state.doc, [Decoration.widget(state.selection.head, node, {key: \"gapcursor\"})])\n}\n\nexport { GapCursor, gapCursor };\n//# sourceMappingURL=index.es.js.map\n","import { Plugin } from 'prosemirror-state';\nimport { dropPoint } from 'prosemirror-transform';\n\n// :: (options: ?Object) → Plugin\n// Create a plugin that, when added to a ProseMirror instance,\n// causes a decoration to show up at the drop position when something\n// is dragged over the editor.\n//\n//   options::- These options are supported:\n//\n//     color:: ?string\n//     The color of the cursor. Defaults to `black`.\n//\n//     width:: ?number\n//     The precise width of the cursor in pixels. Defaults to 1.\n//\n//     class:: ?string\n//     A CSS class name to add to the cursor element.\nfunction dropCursor(options) {\n  if ( options === void 0 ) options = {};\n\n  return new Plugin({\n    view: function view(editorView) { return new DropCursorView(editorView, options) }\n  })\n}\n\nvar DropCursorView = function DropCursorView(editorView, options) {\n  var this$1 = this;\n\n  this.editorView = editorView;\n  this.width = options.width || 1;\n  this.color = options.color || \"black\";\n  this.class = options.class;\n  this.cursorPos = null;\n  this.element = null;\n  this.timeout = null;\n\n  this.handlers = [\"dragover\", \"dragend\", \"drop\", \"dragleave\"].map(function (name) {\n    var handler = function (e) { return this$1[name](e); };\n    editorView.dom.addEventListener(name, handler);\n    return {name: name, handler: handler}\n  });\n};\n\nDropCursorView.prototype.destroy = function destroy () {\n    var this$1 = this;\n\n  this.handlers.forEach(function (ref) {\n      var name = ref.name;\n      var handler = ref.handler;\n\n      return this$1.editorView.dom.removeEventListener(name, handler);\n    });\n};\n\nDropCursorView.prototype.update = function update (editorView, prevState) {\n  if (this.cursorPos != null && prevState.doc != editorView.state.doc) {\n    if (this.cursorPos > editorView.state.doc.content.size) { this.setCursor(null); }\n    else { this.updateOverlay(); }\n  }\n};\n\nDropCursorView.prototype.setCursor = function setCursor (pos) {\n  if (pos == this.cursorPos) { return }\n  this.cursorPos = pos;\n  if (pos == null) {\n    this.element.parentNode.removeChild(this.element);\n    this.element = null;\n  } else {\n    this.updateOverlay();\n  }\n};\n\nDropCursorView.prototype.updateOverlay = function updateOverlay () {\n  var $pos = this.editorView.state.doc.resolve(this.cursorPos), rect;\n  if (!$pos.parent.inlineContent) {\n    var before = $pos.nodeBefore, after = $pos.nodeAfter;\n    if (before || after) {\n      var nodeRect = this.editorView.nodeDOM(this.cursorPos - (before ?before.nodeSize : 0)).getBoundingClientRect();\n      var top = before ? nodeRect.bottom : nodeRect.top;\n      if (before && after)\n        { top = (top + this.editorView.nodeDOM(this.cursorPos).getBoundingClientRect().top) / 2; }\n      rect = {left: nodeRect.left, right: nodeRect.right, top: top - this.width / 2, bottom: top + this.width / 2};\n    }\n  }\n  if (!rect) {\n    var coords = this.editorView.coordsAtPos(this.cursorPos);\n    rect = {left: coords.left - this.width / 2, right: coords.left + this.width / 2, top: coords.top, bottom: coords.bottom};\n  }\n\n  var parent = this.editorView.dom.offsetParent;\n  if (!this.element) {\n    this.element = parent.appendChild(document.createElement(\"div\"));\n    if (this.class) { this.element.className = this.class; }\n    this.element.style.cssText = \"position: absolute; z-index: 50; pointer-events: none; background-color: \" + this.color;\n  }\n  var parentLeft, parentTop;\n  if (!parent || parent == document.body && getComputedStyle(parent).position == \"static\") {\n    parentLeft = -pageXOffset;\n    parentTop = -pageYOffset;\n  } else {\n    var rect$1 = parent.getBoundingClientRect();\n    parentLeft = rect$1.left - parent.scrollLeft;\n    parentTop = rect$1.top - parent.scrollTop;\n  }\n  this.element.style.left = (rect.left - parentLeft) + \"px\";\n  this.element.style.top = (rect.top - parentTop) + \"px\";\n  this.element.style.width = (rect.right - rect.left) + \"px\";\n  this.element.style.height = (rect.bottom - rect.top) + \"px\";\n};\n\nDropCursorView.prototype.scheduleRemoval = function scheduleRemoval (timeout) {\n    var this$1 = this;\n\n  clearTimeout(this.timeout);\n  this.timeout = setTimeout(function () { return this$1.setCursor(null); }, timeout);\n};\n\nDropCursorView.prototype.dragover = function dragover (event) {\n  if (!this.editorView.editable) { return }\n  var pos = this.editorView.posAtCoords({left: event.clientX, top: event.clientY});\n  if (pos) {\n    var target = pos.pos;\n    if (this.editorView.dragging && this.editorView.dragging.slice) {\n      target = dropPoint(this.editorView.state.doc, target, this.editorView.dragging.slice);\n      if (target == null) { return this.setCursor(null) }\n    }\n    this.setCursor(target);\n    this.scheduleRemoval(5000);\n  }\n};\n\nDropCursorView.prototype.dragend = function dragend () {\n  this.scheduleRemoval(20);\n};\n\nDropCursorView.prototype.drop = function drop () {\n  this.scheduleRemoval(20);\n};\n\nDropCursorView.prototype.dragleave = function dragleave (event) {\n  if (event.target == this.editorView.dom || !this.editorView.dom.contains(event.relatedTarget))\n    { this.setCursor(null); }\n};\n\nexport { dropCursor };\n//# sourceMappingURL=index.es.js.map\n","import { PluginKey, Plugin, TextSelection } from 'prosemirror-state';\n\nvar Rebaseable = function Rebaseable(step, inverted, origin) {\n  this.step = step;\n  this.inverted = inverted;\n  this.origin = origin;\n};\n\n// : ([Rebaseable], [Step], Transform) → [Rebaseable]\n// Undo a given set of steps, apply a set of other steps, and then\n// redo them.\nfunction rebaseSteps(steps, over, transform) {\n  for (var i = steps.length - 1; i >= 0; i--) { transform.step(steps[i].inverted); }\n  for (var i$1 = 0; i$1 < over.length; i$1++) { transform.step(over[i$1]); }\n  var result = [];\n  for (var i$2 = 0, mapFrom = steps.length; i$2 < steps.length; i$2++) {\n    var mapped = steps[i$2].step.map(transform.mapping.slice(mapFrom));\n    mapFrom--;\n    if (mapped && !transform.maybeStep(mapped).failed) {\n      transform.mapping.setMirror(mapFrom, transform.steps.length - 1);\n      result.push(new Rebaseable(mapped, mapped.invert(transform.docs[transform.docs.length - 1]), steps[i$2].origin));\n    }\n  }\n  return result\n}\n\n// This state field accumulates changes that have to be sent to the\n// central authority in the collaborating group and makes it possible\n// to integrate changes made by peers into our local document. It is\n// defined by the plugin, and will be available as the `collab` field\n// in the resulting editor state.\nvar CollabState = function CollabState(version, unconfirmed) {\n  // : number\n  // The version number of the last update received from the central\n  // authority. Starts at 0 or the value of the `version` property\n  // in the option object, for the editor's value when the option\n  // was enabled.\n  this.version = version;\n\n  // : [Rebaseable]\n  // The local steps that havent been successfully sent to the\n  // server yet.\n  this.unconfirmed = unconfirmed;\n};\n\nfunction unconfirmedFrom(transform) {\n  var result = [];\n  for (var i = 0; i < transform.steps.length; i++)\n    { result.push(new Rebaseable(transform.steps[i],\n                               transform.steps[i].invert(transform.docs[i]),\n                               transform)); }\n  return result\n}\n\nvar collabKey = new PluginKey(\"collab\");\n\n// :: (?Object) → Plugin\n//\n// Creates a plugin that enables the collaborative editing framework\n// for the editor.\n//\n//   config::- An optional set of options\n//\n//     version:: ?number\n//     The starting version number of the collaborative editing.\n//     Defaults to 0.\n//\n//     clientID:: ?union<number, string>\n//     This client's ID, used to distinguish its changes from those of\n//     other clients. Defaults to a random 32-bit number.\nfunction collab(config) {\n  if ( config === void 0 ) config = {};\n\n  config = {version: config.version || 0,\n            clientID: config.clientID == null ? Math.floor(Math.random() * 0xFFFFFFFF) : config.clientID};\n\n  return new Plugin({\n    key: collabKey,\n\n    state: {\n      init: function () { return new CollabState(config.version, []); },\n      apply: function apply(tr, collab) {\n        var newState = tr.getMeta(collabKey);\n        if (newState)\n          { return newState }\n        if (tr.docChanged)\n          { return new CollabState(collab.version, collab.unconfirmed.concat(unconfirmedFrom(tr))) }\n        return collab\n      }\n    },\n\n    config: config,\n    // This is used to notify the history plugin to not merge steps,\n    // so that the history can be rebased.\n    historyPreserveItems: true\n  })\n}\n\n// :: (state: EditorState, steps: [Step], clientIDs: [union<number, string>], options: ?Object) → Transaction\n// Create a transaction that represents a set of new steps received from\n// the authority. Applying this transaction moves the state forward to\n// adjust to the authority's view of the document.\n//\n//   options::- Additional options.\n//\n//     mapSelectionBackward:: ?boolean\n//     When enabled (the default is `false`), if the current selection\n//     is a [text selection](#state.TextSelection), its sides are\n//     mapped with a negative bias for this transaction, so that\n//     content inserted at the cursor ends up after the cursor. Users\n//     usually prefer this, but it isn't done by default for reasons\n//     of backwards compatibility.\nfunction receiveTransaction(state, steps, clientIDs, options) {\n  // Pushes a set of steps (received from the central authority) into\n  // the editor state (which should have the collab plugin enabled).\n  // Will recognize its own changes, and confirm unconfirmed steps as\n  // appropriate. Remaining unconfirmed steps will be rebased over\n  // remote steps.\n  var collabState = collabKey.getState(state);\n  var version = collabState.version + steps.length;\n  var ourID = collabKey.get(state).spec.config.clientID;\n\n  // Find out which prefix of the steps originated with us\n  var ours = 0;\n  while (ours < clientIDs.length && clientIDs[ours] == ourID) { ++ours; }\n  var unconfirmed = collabState.unconfirmed.slice(ours);\n  steps = ours ? steps.slice(ours) : steps;\n\n  // If all steps originated with us, we're done.\n  if (!steps.length)\n    { return state.tr.setMeta(collabKey, new CollabState(version, unconfirmed)) }\n\n  var nUnconfirmed = unconfirmed.length;\n  var tr = state.tr;\n  if (nUnconfirmed) {\n    unconfirmed = rebaseSteps(unconfirmed, steps, tr);\n  } else {\n    for (var i = 0; i < steps.length; i++) { tr.step(steps[i]); }\n    unconfirmed = [];\n  }\n\n  var newCollabState = new CollabState(version, unconfirmed);\n  if (options && options.mapSelectionBackward && state.selection instanceof TextSelection) {\n    tr.setSelection(TextSelection.between(tr.doc.resolve(tr.mapping.map(state.selection.anchor, -1)),\n                                          tr.doc.resolve(tr.mapping.map(state.selection.head, -1)), -1));\n    tr.updated &= ~1;\n  }\n  return tr.setMeta(\"rebased\", nUnconfirmed).setMeta(\"addToHistory\", false).setMeta(collabKey, newCollabState)\n}\n\n// :: (state: EditorState) → ?{version: number, steps: [Step], clientID: union<number, string>, origins: [Transaction]}\n// Provides data describing the editor's unconfirmed steps, which need\n// to be sent to the central authority. Returns null when there is\n// nothing to send.\n//\n// `origins` holds the _original_ transactions that produced each\n// steps. This can be useful for looking up time stamps and other\n// metadata for the steps, but note that the steps may have been\n// rebased, whereas the origin transactions are still the old,\n// unchanged objects.\nfunction sendableSteps(state) {\n  var collabState = collabKey.getState(state);\n  if (collabState.unconfirmed.length == 0) { return null }\n  return {\n    version: collabState.version,\n    steps: collabState.unconfirmed.map(function (s) { return s.step; }),\n    clientID: collabKey.get(state).spec.config.clientID,\n    get origins() { return this._origins || (this._origins = collabState.unconfirmed.map(function (s) { return s.origin; })) }\n  }\n}\n\n// :: (EditorState) → number\n// Get the version up to which the collab plugin has synced with the\n// central authority.\nfunction getVersion(state) {\n  return collabKey.getState(state).version\n}\n\nexport { collab, getVersion, rebaseSteps, receiveTransaction, sendableSteps };\n//# sourceMappingURL=index.es.js.map\n"],"sourceRoot":""}