{"version":3,"sources":["webpack:///./node_modules/@accrosoft-ltd/accropress-websites-components/node_modules/slate/dist/index.es.js"],"names":["_createForOfIteratorHelper","o","allowArrayLike","it","Symbol","iterator","Array","isArray","minLen","_arrayLikeToArray","n","Object","prototype","toString","call","slice","constructor","name","from","test","_unsupportedIterableToArray","length","i","F","s","done","value","e","_e","f","TypeError","err","normalCompletion","didErr","step","next","_e2","return","arr","len","arr2","_defineProperty","obj","key","defineProperty","enumerable","configurable","writable","DIRTY_PATHS","WeakMap","NORMALIZING","PATH_REFS","POINT_REFS","RANGE_REFS","_objectWithoutProperties","source","excluded","target","sourceKeys","keys","indexOf","_objectWithoutPropertiesLoose","getOwnPropertySymbols","sourceSymbolKeys","propertyIsEnumerable","SPACE","PUNCTUATION","CHAMELEON","getCharacterDistance","text","offset","prev","charCode","charCodeAt","isSurrogate","modifier","isModifier","isBMPEmoji","isVariationSelector","getWordDistance","char","started","charAt","l","rest","isWordCharacter","remaining","code","Element","isAncestor","Node","isNodeList","children","isElement","Editor","isEditor","isElementList","every","val","isElementProps","props","undefined","matches","element","ownKeys$1","object","enumerableOnly","symbols","filter","sym","getOwnPropertyDescriptor","push","apply","_objectSpread$1","arguments","forEach","getOwnPropertyDescriptors","defineProperties","IS_EDITOR_CACHE","above","editor","options","_options$voids","voids","_options$mode","mode","_options$at","at","selection","match","_step8","path","reverse","_iterator8","levels","_step8$value","p","Text","isText","Path","equals","addMark","after","_step9","anchor","point","edge","focus","end","range","_options$distance","distance","d","_iterator9","positions","before","_step10","start","_options$distance2","_iterator10","deleteBackward","_options$unit","unit","deleteForward","_options$unit2","deleteFragment","_options$direction","direction","edges","first","node","fragment","hasBlocks","some","isBlock","hasInlines","isInline","hasTexts","insertBreak","insertFragment","insertNode","insertText","cachedIsEditor","get","isVoid","normalizeNode","onChange","removeMark","marks","Range","isRange","Operation","isOperationList","operations","set","isEnd","Point","isEdge","isStart","isEmpty","isNormalizing","last","leaf","mark","_options$at2","_options$reverse","_options$voids2","_iterator11","_step11","_step11$value","_args","wrap","_context","abrupt","t0","finish","delegateYield","stop","isExpanded","_Editor$nodes","nodes","_Editor$leaf","previous","block","_prev2","prevNode","prevPath","blockPath","_options$mode2","_options$voids3","_options$at3","pointAfterLocation","_Editor$last","_Editor$last2","to","span","isPath","Error","_Editor$parent","parent","_Editor$parent2","includes","_Editor$nodes3","_Editor$nodes4","_options$at4","_options$mode3","_options$universal","universal","_options$reverse2","_options$voids4","nodeEntries","hit","_iterator12","_step12","_step12$value","isLower","emit","_args2","_context2","Span","isSpan","pass","_ref","compare","normalize","_options$force","force","getDirtyPaths","allPaths","_ref2","withoutNormalizing","_step13","_iterator13","dirtyPath","has","_Editor$node","_Editor$node2","Transforms","insertNodes","concat","max","m","_dirtyPath","pop","entry","parentPath","depth","_Node$first","_Node$first2","firstPath","_Node$last","_Node$last2","lastPath","common","isPoint","hasPath","pathRef","_options$affinity","affinity","ref","current","unref","pathRefs","delete","refs","add","Set","_options$edge","_Node$last3","_Node$last4","_Node$first3","_Node$first4","_Range$edges","_Range$edges2","pointRef","_options$affinity2","pointRefs","_options$at5","_options$unit3","_options$reverse3","reverse$1","_options$voids5","_Range$edges3","_Range$edges4","isNewBlock","blockText","leafTextRemaining","leafTextOffset","_iterator14","_step14","_step14$value","isFirst","calcDistance","_args3","_context3","string","_options$mode4","_options$voids6","_options$at6","pointBeforeLocation","_Editor$first","_Editor$first2","_Editor$parent3","_Editor$parent4","_Editor$nodes5","_Editor$nodes6","rangeRef","_options$affinity3","rangeRefs","_step15","_options$voids7","_Range$edges5","_Range$edges6","_iterator15","_step15$value","t","unhangRange","_options$voids8","_Range$edges7","_Range$edges8","isCollapsed","_step16","endBlock","skip","_iterator16","_step16$value","isBefore","void","fn","IS_NODE_LIST_CACHE","ancestor","root","ancestors","_iterator17","_step17","_args4","_context4","child","index","JSON","stringify","c","_options$reverse4","childPath","_args5","_context5","another","descendant","descendants","_iterator18","_step18","_step18$value","_args6","_context6","elements","_iterator19","_step19","_step19$value","_args7","_context7","extractProps","r","_step20","_Range$edges9","_Range$edges10","_iterator20","splice","_leaf","isNode","cachedResult","_iterator21","_step21","_args8","_context8","isTextProps","_options$reverse5","_options$from","visited","nextIndex","newPath","_newPath","_args9","_context9","isAfter","map","join","texts","_iterator22","_step22","_step22$value","_args10","_context10","ownKeys$2","_objectSpread$2","isNodeOperation","isOperation","type","endsWith","position","properties","newProperties","isSelectionOperation","isTextOperation","inverse","op","isSibling","inversePath","transform","inverseNewPath","_properties","_newProperties","_options$reverse6","paths","av","min","Math","endsAfter","as","bs","bv","endsAt","endsBefore","hasPrevious","isChild","isCommon","isDescendant","isParent","_options$reverse7","list","relative","operation","_options$affinity4","_op","_op2","_op3","_position","_op4","onp","copy","ownKeys$3","_objectSpread$3","result","_options$affinity5","ownKeys$4","_options$reverse8","isBackward","_Range$edges11","_Range$edges13","_Range$edges14","rs","re","_Range$edges15","_Range$edges16","ts","te","_Range$edges17","_Range$edges18","isAfterStart","isBeforeEnd","intersection","_Range$edges19","_Range$edges20","s1","e1","_Range$edges21","_Range$edges22","s2","e2","_objectSpread$4","isForward","points","_context11","_Range$edges23","affinityAnchor","affinityFocus","_options$affinity6","ownKeys$5","_objectSpread$5","_options$loose","loose","omitText","isTextList","hasOwnProperty","decorations","_decorations","_step23","leaves","_iterator23","_step24","dec","_Range$edges25","_Range$edges26","_iterator24","assign","middle","off","_off","ownKeys$6","_objectSpread$6","ownKeys$7","_objectSpread$7","NodeTransforms","_options$hanging","hanging","_options$voids9","_options$mode5","select","_nodes","_Range$edges27","_Editor$nodes7","_matchPath","isAtEnd","splitNodes","_step33","_iterator33","_node","_path","liftNodes","_options$at7","_options$mode6","_options$voids10","matchPath","_i","_pathRefs","parentNodeEntry","_parentNodeEntry","toPath","moveNodes","removeNodes","_toPath","splitPath","_toPath2","mergeNodes","_options$at8","_options$hanging2","_options$voids11","_options$mode7","_Editor$parent5","_Range$edges29","_Editor$nodes9","_current","_prev3","commonPath","isPreviousSibling","emptyAncestor","hasSingleChildNest","emptyRef","_options$at9","_options$mode8","_options$voids12","toRef","targets","_i2","_pathRefs2","_ref3","_options$hanging3","_options$voids13","_options$mode9","_options$at10","depths","_i3","_pathRefs3","_ref4","_Editor$node3","setNodes","_options$at11","_options$hanging4","_options$mode10","_options$split","split","_options$voids14","_Range$edges31","_Range$edges32","splitMode","endAtEndOfNode","always","startAtStartOfNode","_step34","_iterator34","_step34$value","k","_options$mode11","_options$voids15","_options$at12","_options$height","height","_options$always","deleteRange","_Editor$parent7","beforeRef","_Editor$nodes11","highest","voidMatch","_voidMatch","voidNode","voidPath","afterPath","_step35","afterRef","highestPath","lowestPath","_iterator35","_step35$value","_path2","_point","_point2","unsetNodes","_step36","_iterator36","unwrapNodes","_options$mode12","_options$split2","_options$voids16","_options$at13","_loop","_Editor$node5","_i4","_pathRefs4","_ref5","wrapNodes","_options$mode13","_options$split3","_options$voids17","_options$at14","_Range$edges33","_Range$edges34","_i5","_roots","rootPath","a","commonNodeEntry","commonNode","wrapperPath","wrapper","_Range$edges35","_Editor$node7","ownKeys$8","_objectSpread$8","SelectionTransforms","collapse","_options$edge2","_Range$edges37","_Range$edges38","_Range$edges39","_Range$edges40","deselect","move","_options$distance3","_options$unit4","_options$reverse9","_options$edge3","opts","setSelection","setPoint","_options$edge4","oldProps","newProps","TextTransforms","_options$reverse10","_options$unit5","_options$distance4","_options$voids18","_options$at15","_options$hanging5","furthestVoid","_Range$edges41","_end","endOfDoc","_Range$edges43","_Range$edges44","startBlock","isAcrossBlocks","isSingleText","startVoid","endVoid","_step37","_iterator37","_entry3","startRef","endRef","_Editor$leaf3","_i6","_pathRefs5","_Editor$leaf5","_node2","_path3","_offset","_text","_options$hanging6","_options$voids19","_options$at16","_Range$edges45","inlineElementMatch","_inlinePath","_step38","blockMatch","isBlockStart","isBlockEnd","mergeStart","mergeEnd","_Node$first5","_Node$last5","matcher","_ref16","_iterator38","starts","middles","ends","starting","_i7","_matches2","_Editor$nodes13","inlineMatch","inlinePath","isInlineStart","isInlineEnd","middleRef","_end2","_options$voids20","_options$at17","_at","ownKeys$9","_objectSpread$9","_step25","_iterator25","_step25$value","_step26","_iterator26","_step26$value","_parent","_index","_prev$children","_step27","_iterator27","_step27$value","_node3","_parent2","_index2","truePath","newParent","newIndex","_step28","_iterator28","_step28$value","_point3","_path4","_index3","_step29","_iterator29","_step29$value","_point4","_key4","_step30","_prev","_iterator30","_step30$value","_path5","_node4","_before","_after","_step31","_iterator31","_step31$value","_point5","_path6","_node5","_key6","_key7","_key8","_value","_path7","newNode","_node6","_parent4","_index4","_before2","_after2","_before3","_after3","_step32","_iterator32","_step32$value","_point6","applyToDraft"],"mappings":"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","file":"213f2b5c-c094a3357f374fe63a88.js","sourcesContent":["import _toConsumableArray from \"/opt/buildhome/repo/node_modules/@babel/runtime/helpers/esm/toConsumableArray\";\nimport _slicedToArray from \"/opt/buildhome/repo/node_modules/@babel/runtime/helpers/esm/slicedToArray\";\nimport _defineProperty2 from \"/opt/buildhome/repo/node_modules/@babel/runtime/helpers/esm/defineProperty\";\nimport _regeneratorRuntime from \"/opt/buildhome/repo/node_modules/@babel/runtime/regenerator\";\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nimport isPlainObject from 'is-plain-object';\nimport { reverse } from 'esrever';\nimport { produce, createDraft, finishDraft, isDraft } from 'immer';\nimport isEqual from 'fast-deep-equal';\n\nfunction _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n}\n\nvar DIRTY_PATHS = new WeakMap();\nvar FLUSHING = new WeakMap();\nvar NORMALIZING = new WeakMap();\nvar PATH_REFS = new WeakMap();\nvar POINT_REFS = new WeakMap();\nvar RANGE_REFS = new WeakMap();\n\nfunction ownKeys(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n/**\r\n * Create a new Slate `Editor` object.\r\n */\n\n\nvar createEditor = function createEditor() {\n  var editor = {\n    children: [],\n    operations: [],\n    selection: null,\n    marks: null,\n    isInline: function isInline() {\n      return false;\n    },\n    isVoid: function isVoid() {\n      return false;\n    },\n    onChange: function onChange() {},\n    apply: function apply(op) {\n      var _iterator = _createForOfIteratorHelper(Editor.pathRefs(editor)),\n          _step;\n\n      try {\n        for (_iterator.s(); !(_step = _iterator.n()).done;) {\n          var ref = _step.value;\n          PathRef.transform(ref, op);\n        }\n      } catch (err) {\n        _iterator.e(err);\n      } finally {\n        _iterator.f();\n      }\n\n      var _iterator2 = _createForOfIteratorHelper(Editor.pointRefs(editor)),\n          _step2;\n\n      try {\n        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n          var _ref = _step2.value;\n          PointRef.transform(_ref, op);\n        }\n      } catch (err) {\n        _iterator2.e(err);\n      } finally {\n        _iterator2.f();\n      }\n\n      var _iterator3 = _createForOfIteratorHelper(Editor.rangeRefs(editor)),\n          _step3;\n\n      try {\n        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n          var _ref2 = _step3.value;\n          RangeRef.transform(_ref2, op);\n        }\n      } catch (err) {\n        _iterator3.e(err);\n      } finally {\n        _iterator3.f();\n      }\n\n      var set = new Set();\n      var dirtyPaths = [];\n\n      var add = function add(path) {\n        if (path) {\n          var key = path.join(',');\n\n          if (!set.has(key)) {\n            set.add(key);\n            dirtyPaths.push(path);\n          }\n        }\n      };\n\n      var oldDirtyPaths = DIRTY_PATHS.get(editor) || [];\n      var newDirtyPaths = getDirtyPaths(op);\n\n      var _iterator4 = _createForOfIteratorHelper(oldDirtyPaths),\n          _step4;\n\n      try {\n        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {\n          var path = _step4.value;\n          var newPath = Path.transform(path, op);\n          add(newPath);\n        }\n      } catch (err) {\n        _iterator4.e(err);\n      } finally {\n        _iterator4.f();\n      }\n\n      var _iterator5 = _createForOfIteratorHelper(newDirtyPaths),\n          _step5;\n\n      try {\n        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {\n          var _path = _step5.value;\n          add(_path);\n        }\n      } catch (err) {\n        _iterator5.e(err);\n      } finally {\n        _iterator5.f();\n      }\n\n      DIRTY_PATHS.set(editor, dirtyPaths);\n      Transforms.transform(editor, op);\n      editor.operations.push(op);\n      Editor.normalize(editor); // Clear any formats applied to the cursor if the selection changes.\n\n      if (op.type === 'set_selection') {\n        editor.marks = null;\n      }\n\n      if (!FLUSHING.get(editor)) {\n        FLUSHING.set(editor, true);\n        Promise.resolve().then(function () {\n          FLUSHING.set(editor, false);\n          editor.onChange();\n          editor.operations = [];\n        });\n      }\n    },\n    addMark: function addMark(key, value) {\n      var selection = editor.selection;\n\n      if (selection) {\n        if (Range.isExpanded(selection)) {\n          Transforms.setNodes(editor, _defineProperty2({}, key, value), {\n            match: Text.isText,\n            split: true\n          });\n        } else {\n          var marks = _objectSpread(_objectSpread({}, Editor.marks(editor) || {}), {}, _defineProperty2({}, key, value));\n\n          editor.marks = marks;\n\n          if (!FLUSHING.get(editor)) {\n            editor.onChange();\n          }\n        }\n      }\n    },\n    deleteBackward: function deleteBackward(unit) {\n      var selection = editor.selection;\n\n      if (selection && Range.isCollapsed(selection)) {\n        Transforms.delete(editor, {\n          unit: unit,\n          reverse: true\n        });\n      }\n    },\n    deleteForward: function deleteForward(unit) {\n      var selection = editor.selection;\n\n      if (selection && Range.isCollapsed(selection)) {\n        Transforms.delete(editor, {\n          unit: unit\n        });\n      }\n    },\n    deleteFragment: function deleteFragment(direction) {\n      var selection = editor.selection;\n\n      if (selection && Range.isExpanded(selection)) {\n        Transforms.delete(editor, {\n          reverse: direction === 'backward'\n        });\n      }\n    },\n    getFragment: function getFragment() {\n      var selection = editor.selection;\n\n      if (selection) {\n        return Node.fragment(editor, selection);\n      }\n\n      return [];\n    },\n    insertBreak: function insertBreak() {\n      Transforms.splitNodes(editor, {\n        always: true\n      });\n    },\n    insertFragment: function insertFragment(fragment) {\n      Transforms.insertFragment(editor, fragment);\n    },\n    insertNode: function insertNode(node) {\n      Transforms.insertNodes(editor, node);\n    },\n    insertText: function insertText(text) {\n      var selection = editor.selection,\n          marks = editor.marks;\n\n      if (selection) {\n        // If the cursor is at the end of an inline, move it outside of\n        // the inline before inserting\n        if (Range.isCollapsed(selection)) {\n          var inline = Editor.above(editor, {\n            match: function match(n) {\n              return Editor.isInline(editor, n);\n            },\n            mode: 'highest'\n          });\n\n          if (inline) {\n            var _inline = _slicedToArray(inline, 2),\n                inlinePath = _inline[1];\n\n            if (Editor.isEnd(editor, selection.anchor, inlinePath)) {\n              var point = Editor.after(editor, inlinePath);\n              Transforms.setSelection(editor, {\n                anchor: point,\n                focus: point\n              });\n            }\n          }\n        }\n\n        if (marks) {\n          var node = _objectSpread({\n            text: text\n          }, marks);\n\n          Transforms.insertNodes(editor, node);\n        } else {\n          Transforms.insertText(editor, text);\n        }\n\n        editor.marks = null;\n      }\n    },\n    normalizeNode: function normalizeNode(entry) {\n      var _entry = _slicedToArray(entry, 2),\n          node = _entry[0],\n          path = _entry[1]; // There are no core normalizations for text nodes.\n\n\n      if (Text.isText(node)) {\n        return;\n      } // Ensure that block and inline nodes have at least one text child.\n\n\n      if (Element.isElement(node) && node.children.length === 0) {\n        var child = {\n          text: ''\n        };\n        Transforms.insertNodes(editor, child, {\n          at: path.concat(0),\n          voids: true\n        });\n        return;\n      } // Determine whether the node should have block or inline children.\n\n\n      var shouldHaveInlines = Editor.isEditor(node) ? false : Element.isElement(node) && (editor.isInline(node) || node.children.length === 0 || Text.isText(node.children[0]) || editor.isInline(node.children[0])); // Since we'll be applying operations while iterating, keep track of an\n      // index that accounts for any added/removed nodes.\n\n      var n = 0;\n\n      for (var i = 0; i < node.children.length; i++, n++) {\n        var currentNode = Node.get(editor, path);\n        if (Text.isText(currentNode)) continue;\n        var _child = node.children[i];\n        var prev = currentNode.children[n - 1];\n        var isLast = i === node.children.length - 1;\n        var isInlineOrText = Text.isText(_child) || Element.isElement(_child) && editor.isInline(_child); // Only allow block nodes in the top-level children and parent blocks\n        // that only contain block nodes. Similarly, only allow inline nodes in\n        // other inline nodes, or parent blocks that only contain inlines and\n        // text.\n\n        if (isInlineOrText !== shouldHaveInlines) {\n          Transforms.removeNodes(editor, {\n            at: path.concat(n),\n            voids: true\n          });\n          n--;\n        } else if (Element.isElement(_child)) {\n          // Ensure that inline nodes are surrounded by text nodes.\n          if (editor.isInline(_child)) {\n            if (prev == null || !Text.isText(prev)) {\n              var newChild = {\n                text: ''\n              };\n              Transforms.insertNodes(editor, newChild, {\n                at: path.concat(n),\n                voids: true\n              });\n              n++;\n            } else if (isLast) {\n              var _newChild = {\n                text: ''\n              };\n              Transforms.insertNodes(editor, _newChild, {\n                at: path.concat(n + 1),\n                voids: true\n              });\n              n++;\n            }\n          }\n        } else {\n          // Merge adjacent text nodes that are empty or match.\n          if (prev != null && Text.isText(prev)) {\n            if (Text.equals(_child, prev, {\n              loose: true\n            })) {\n              Transforms.mergeNodes(editor, {\n                at: path.concat(n),\n                voids: true\n              });\n              n--;\n            } else if (prev.text === '') {\n              Transforms.removeNodes(editor, {\n                at: path.concat(n - 1),\n                voids: true\n              });\n              n--;\n            } else if (isLast && _child.text === '') {\n              Transforms.removeNodes(editor, {\n                at: path.concat(n),\n                voids: true\n              });\n              n--;\n            }\n          }\n        }\n      }\n    },\n    removeMark: function removeMark(key) {\n      var selection = editor.selection;\n\n      if (selection) {\n        if (Range.isExpanded(selection)) {\n          Transforms.unsetNodes(editor, key, {\n            match: Text.isText,\n            split: true\n          });\n        } else {\n          var marks = _objectSpread({}, Editor.marks(editor) || {});\n\n          delete marks[key];\n          editor.marks = marks;\n\n          if (!FLUSHING.get(editor)) {\n            editor.onChange();\n          }\n        }\n      }\n    }\n  };\n  return editor;\n};\n/**\r\n * Get the \"dirty\" paths generated from an operation.\r\n */\n\n\nvar getDirtyPaths = function getDirtyPaths(op) {\n  switch (op.type) {\n    case 'insert_text':\n    case 'remove_text':\n    case 'set_node':\n      {\n        var path = op.path;\n        return Path.levels(path);\n      }\n\n    case 'insert_node':\n      {\n        var node = op.node,\n            _path2 = op.path;\n        var levels = Path.levels(_path2);\n        var descendants = Text.isText(node) ? [] : Array.from(Node.nodes(node), function (_ref3) {\n          var _ref6 = _slicedToArray(_ref3, 2),\n              p = _ref6[1];\n\n          return _path2.concat(p);\n        });\n        return [].concat(_toConsumableArray(levels), _toConsumableArray(descendants));\n      }\n\n    case 'merge_node':\n      {\n        var _path3 = op.path;\n        var ancestors = Path.ancestors(_path3);\n        var previousPath = Path.previous(_path3);\n        return [].concat(_toConsumableArray(ancestors), [previousPath]);\n      }\n\n    case 'move_node':\n      {\n        var _path4 = op.path,\n            newPath = op.newPath;\n\n        if (Path.equals(_path4, newPath)) {\n          return [];\n        }\n\n        var oldAncestors = [];\n        var newAncestors = [];\n\n        var _iterator6 = _createForOfIteratorHelper(Path.ancestors(_path4)),\n            _step6;\n\n        try {\n          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {\n            var ancestor = _step6.value;\n            var p = Path.transform(ancestor, op);\n            oldAncestors.push(p);\n          }\n        } catch (err) {\n          _iterator6.e(err);\n        } finally {\n          _iterator6.f();\n        }\n\n        var _iterator7 = _createForOfIteratorHelper(Path.ancestors(newPath)),\n            _step7;\n\n        try {\n          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {\n            var _ancestor = _step7.value;\n\n            var _p = Path.transform(_ancestor, op);\n\n            newAncestors.push(_p);\n          }\n        } catch (err) {\n          _iterator7.e(err);\n        } finally {\n          _iterator7.f();\n        }\n\n        var newParent = newAncestors[newAncestors.length - 1];\n        var newIndex = newPath[newPath.length - 1];\n        var resultPath = newParent.concat(newIndex);\n        return [].concat(oldAncestors, newAncestors, [resultPath]);\n      }\n\n    case 'remove_node':\n      {\n        var _path5 = op.path;\n\n        var _ancestors = Path.ancestors(_path5);\n\n        return _toConsumableArray(_ancestors);\n      }\n\n    case 'split_node':\n      {\n        var _path6 = op.path;\n\n        var _levels = Path.levels(_path6);\n\n        var nextPath = Path.next(_path6);\n        return [].concat(_toConsumableArray(_levels), [nextPath]);\n      }\n\n    default:\n      {\n        return [];\n      }\n  }\n};\n\nfunction _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n\n  return target;\n}\n\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n\n  var target = _objectWithoutPropertiesLoose(source, excluded);\n\n  var key, i;\n\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n\n  return target;\n}\n/**\r\n * Constants for string distance checking.\r\n */\n\n\nvar SPACE = /\\s/;\nvar PUNCTUATION = /[\\u0021-\\u0023\\u0025-\\u002A\\u002C-\\u002F\\u003A\\u003B\\u003F\\u0040\\u005B-\\u005D\\u005F\\u007B\\u007D\\u00A1\\u00A7\\u00AB\\u00B6\\u00B7\\u00BB\\u00BF\\u037E\\u0387\\u055A-\\u055F\\u0589\\u058A\\u05BE\\u05C0\\u05C3\\u05C6\\u05F3\\u05F4\\u0609\\u060A\\u060C\\u060D\\u061B\\u061E\\u061F\\u066A-\\u066D\\u06D4\\u0700-\\u070D\\u07F7-\\u07F9\\u0830-\\u083E\\u085E\\u0964\\u0965\\u0970\\u0AF0\\u0DF4\\u0E4F\\u0E5A\\u0E5B\\u0F04-\\u0F12\\u0F14\\u0F3A-\\u0F3D\\u0F85\\u0FD0-\\u0FD4\\u0FD9\\u0FDA\\u104A-\\u104F\\u10FB\\u1360-\\u1368\\u1400\\u166D\\u166E\\u169B\\u169C\\u16EB-\\u16ED\\u1735\\u1736\\u17D4-\\u17D6\\u17D8-\\u17DA\\u1800-\\u180A\\u1944\\u1945\\u1A1E\\u1A1F\\u1AA0-\\u1AA6\\u1AA8-\\u1AAD\\u1B5A-\\u1B60\\u1BFC-\\u1BFF\\u1C3B-\\u1C3F\\u1C7E\\u1C7F\\u1CC0-\\u1CC7\\u1CD3\\u2010-\\u2027\\u2030-\\u2043\\u2045-\\u2051\\u2053-\\u205E\\u207D\\u207E\\u208D\\u208E\\u2329\\u232A\\u2768-\\u2775\\u27C5\\u27C6\\u27E6-\\u27EF\\u2983-\\u2998\\u29D8-\\u29DB\\u29FC\\u29FD\\u2CF9-\\u2CFC\\u2CFE\\u2CFF\\u2D70\\u2E00-\\u2E2E\\u2E30-\\u2E3B\\u3001-\\u3003\\u3008-\\u3011\\u3014-\\u301F\\u3030\\u303D\\u30A0\\u30FB\\uA4FE\\uA4FF\\uA60D-\\uA60F\\uA673\\uA67E\\uA6F2-\\uA6F7\\uA874-\\uA877\\uA8CE\\uA8CF\\uA8F8-\\uA8FA\\uA92E\\uA92F\\uA95F\\uA9C1-\\uA9CD\\uA9DE\\uA9DF\\uAA5C-\\uAA5F\\uAADE\\uAADF\\uAAF0\\uAAF1\\uABEB\\uFD3E\\uFD3F\\uFE10-\\uFE19\\uFE30-\\uFE52\\uFE54-\\uFE61\\uFE63\\uFE68\\uFE6A\\uFE6B\\uFF01-\\uFF03\\uFF05-\\uFF0A\\uFF0C-\\uFF0F\\uFF1A\\uFF1B\\uFF1F\\uFF20\\uFF3B-\\uFF3D\\uFF3F\\uFF5B\\uFF5D\\uFF5F-\\uFF65]/;\nvar CHAMELEON = /['\\u2018\\u2019]/;\nvar SURROGATE_START = 0xd800;\nvar SURROGATE_END = 0xdfff;\nvar ZERO_WIDTH_JOINER = 0x200d;\n/**\r\n * Get the distance to the end of the first character in a string of text.\r\n */\n\nvar getCharacterDistance = function getCharacterDistance(text) {\n  var offset = 0; // prev types:\n  // SURR: surrogate pair\n  // MOD: modifier (technically also surrogate pair)\n  // ZWJ: zero width joiner\n  // VAR: variation selector\n  // BMP: sequenceable character from basic multilingual plane\n\n  var prev = null;\n  var charCode = text.charCodeAt(0);\n\n  while (charCode) {\n    if (isSurrogate(charCode)) {\n      var modifier = isModifier(charCode, text, offset); // Early returns are the heart of this function, where we decide if previous and current\n      // codepoints should form a single character (in terms of how many of them should selection\n      // jump over).\n\n      if (prev === 'SURR' || prev === 'BMP') {\n        break;\n      }\n\n      offset += 2;\n      prev = modifier ? 'MOD' : 'SURR';\n      charCode = text.charCodeAt(offset); // Absolutely fine to `continue` without any checks because if `charCode` is NaN (which\n      // is the case when out of `text` range), next `while` loop won\"t execute and we\"re done.\n\n      continue;\n    }\n\n    if (charCode === ZERO_WIDTH_JOINER) {\n      offset += 1;\n      prev = 'ZWJ';\n      charCode = text.charCodeAt(offset);\n      continue;\n    }\n\n    if (isBMPEmoji(charCode)) {\n      if (prev && prev !== 'ZWJ' && prev !== 'VAR') {\n        break;\n      }\n\n      offset += 1;\n      prev = 'BMP';\n      charCode = text.charCodeAt(offset);\n      continue;\n    }\n\n    if (isVariationSelector(charCode)) {\n      if (prev && prev !== 'ZWJ') {\n        break;\n      }\n\n      offset += 1;\n      prev = 'VAR';\n      charCode = text.charCodeAt(offset);\n      continue;\n    } // Modifier 'groups up' with what ever character is before that (even whitespace), need to\n    // look ahead.\n\n\n    if (prev === 'MOD') {\n      offset += 1;\n      break;\n    } // If while loop ever gets here, we're done (e.g latin chars).\n\n\n    break;\n  }\n\n  return offset || 1;\n};\n/**\r\n * Get the distance to the end of the first word in a string of text.\r\n */\n\n\nvar getWordDistance = function getWordDistance(text) {\n  var length = 0;\n  var i = 0;\n  var started = false;\n  var char;\n\n  while (char = text.charAt(i)) {\n    var l = getCharacterDistance(char);\n    char = text.slice(i, i + l);\n    var rest = text.slice(i + l);\n\n    if (isWordCharacter(char, rest)) {\n      started = true;\n      length += l;\n    } else if (!started) {\n      length += l;\n    } else {\n      break;\n    }\n\n    i += l;\n  }\n\n  return length;\n};\n/**\r\n * Check if a character is a word character. The `remaining` argument is used\r\n * because sometimes you must read subsequent characters to truly determine it.\r\n */\n\n\nvar isWordCharacter = function isWordCharacter(char, remaining) {\n  if (SPACE.test(char)) {\n    return false;\n  } // Chameleons count as word characters as long as they're in a word, so\n  // recurse to see if the next one is a word character or not.\n\n\n  if (CHAMELEON.test(char)) {\n    var next = remaining.charAt(0);\n    var length = getCharacterDistance(next);\n    next = remaining.slice(0, length);\n    var rest = remaining.slice(length);\n\n    if (isWordCharacter(next, rest)) {\n      return true;\n    }\n  }\n\n  if (PUNCTUATION.test(char)) {\n    return false;\n  }\n\n  return true;\n};\n/**\r\n * Determines if `code` is a surrogate\r\n */\n\n\nvar isSurrogate = function isSurrogate(code) {\n  return SURROGATE_START <= code && code <= SURROGATE_END;\n};\n/**\r\n * Does `code` form Modifier with next one.\r\n *\r\n * https://emojipedia.org/modifiers/\r\n */\n\n\nvar isModifier = function isModifier(code, text, offset) {\n  if (code === 0xd83c) {\n    var next = text.charCodeAt(offset + 1);\n    return next <= 0xdfff && next >= 0xdffb;\n  }\n\n  return false;\n};\n/**\r\n * Is `code` a Variation Selector.\r\n *\r\n * https://codepoints.net/variation_selectors\r\n */\n\n\nvar isVariationSelector = function isVariationSelector(code) {\n  return code <= 0xfe0f && code >= 0xfe00;\n};\n/**\r\n * Is `code` one of the BMP codes used in emoji sequences.\r\n *\r\n * https://emojipedia.org/emoji-zwj-sequences/\r\n */\n\n\nvar isBMPEmoji = function isBMPEmoji(code) {\n  // This requires tiny bit of maintanance, better ideas?\n  // Fortunately it only happens if new Unicode Standard\n  // is released. Fails gracefully if upkeep lags behind,\n  // same way Slate previously behaved with all emojis.\n  return code === 0x2764 || // heart (❤)\n  code === 0x2642 || // male (♂)\n  code === 0x2640 || // female (♀)\n  code === 0x2620 || // scull (☠)\n  code === 0x2695 || // medical (⚕)\n  code === 0x2708 || // plane (✈️)\n  code === 0x25ef // large circle (◯)\n  ;\n};\n\nvar Element = {\n  /**\r\n   * Check if a value implements the 'Ancestor' interface.\r\n   */\n  isAncestor: function isAncestor(value) {\n    return isPlainObject(value) && Node.isNodeList(value.children);\n  },\n\n  /**\r\n   * Check if a value implements the `Element` interface.\r\n   */\n  isElement: function isElement(value) {\n    return isPlainObject(value) && Node.isNodeList(value.children) && !Editor.isEditor(value);\n  },\n\n  /**\r\n   * Check if a value is an array of `Element` objects.\r\n   */\n  isElementList: function isElementList(value) {\n    return Array.isArray(value) && value.every(function (val) {\n      return Element.isElement(val);\n    });\n  },\n\n  /**\r\n   * Check if a set of props is a partial of Element.\r\n   */\n  isElementProps: function isElementProps(props) {\n    return props.children !== undefined;\n  },\n\n  /**\r\n   * Check if an element matches set of properties.\r\n   *\r\n   * Note: this checks custom properties, and it does not ensure that any\r\n   * children are equivalent.\r\n   */\n  matches: function matches(element, props) {\n    for (var key in props) {\n      if (key === 'children') {\n        continue;\n      }\n\n      if (element[key] !== props[key]) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n};\n\nfunction ownKeys$1(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread$1(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys$1(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys$1(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nvar IS_EDITOR_CACHE = new WeakMap();\nvar Editor = {\n  /**\r\n   * Get the ancestor above a location in the document.\r\n   */\n  above: function above(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var _options$voids = options.voids,\n        voids = _options$voids === void 0 ? false : _options$voids,\n        _options$mode = options.mode,\n        mode = _options$mode === void 0 ? 'lowest' : _options$mode,\n        _options$at = options.at,\n        at = _options$at === void 0 ? editor.selection : _options$at,\n        match = options.match;\n\n    if (!at) {\n      return;\n    }\n\n    var path = Editor.path(editor, at);\n    var reverse = mode === 'lowest';\n\n    var _iterator8 = _createForOfIteratorHelper(Editor.levels(editor, {\n      at: path,\n      voids: voids,\n      match: match,\n      reverse: reverse\n    })),\n        _step8;\n\n    try {\n      for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {\n        var _step8$value = _slicedToArray(_step8.value, 2),\n            n = _step8$value[0],\n            p = _step8$value[1];\n\n        if (!Text.isText(n) && !Path.equals(path, p)) {\n          return [n, p];\n        }\n      }\n    } catch (err) {\n      _iterator8.e(err);\n    } finally {\n      _iterator8.f();\n    }\n  },\n\n  /**\r\n   * Add a custom property to the leaf text nodes in the current selection.\r\n   *\r\n   * If the selection is currently collapsed, the marks will be added to the\r\n   * `editor.marks` property instead, and applied when text is inserted next.\r\n   */\n  addMark: function addMark(editor, key, value) {\n    editor.addMark(key, value);\n  },\n\n  /**\r\n   * Get the point after a location.\r\n   */\n  after: function after(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var anchor = Editor.point(editor, at, {\n      edge: 'end'\n    });\n    var focus = Editor.end(editor, []);\n    var range = {\n      anchor: anchor,\n      focus: focus\n    };\n    var _options$distance = options.distance,\n        distance = _options$distance === void 0 ? 1 : _options$distance;\n    var d = 0;\n    var target;\n\n    var _iterator9 = _createForOfIteratorHelper(Editor.positions(editor, _objectSpread$1(_objectSpread$1({}, options), {}, {\n      at: range\n    }))),\n        _step9;\n\n    try {\n      for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {\n        var p = _step9.value;\n\n        if (d > distance) {\n          break;\n        }\n\n        if (d !== 0) {\n          target = p;\n        }\n\n        d++;\n      }\n    } catch (err) {\n      _iterator9.e(err);\n    } finally {\n      _iterator9.f();\n    }\n\n    return target;\n  },\n\n  /**\r\n   * Get the point before a location.\r\n   */\n  before: function before(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var anchor = Editor.start(editor, []);\n    var focus = Editor.point(editor, at, {\n      edge: 'start'\n    });\n    var range = {\n      anchor: anchor,\n      focus: focus\n    };\n    var _options$distance2 = options.distance,\n        distance = _options$distance2 === void 0 ? 1 : _options$distance2;\n    var d = 0;\n    var target;\n\n    var _iterator10 = _createForOfIteratorHelper(Editor.positions(editor, _objectSpread$1(_objectSpread$1({}, options), {}, {\n      at: range,\n      reverse: true\n    }))),\n        _step10;\n\n    try {\n      for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {\n        var p = _step10.value;\n\n        if (d > distance) {\n          break;\n        }\n\n        if (d !== 0) {\n          target = p;\n        }\n\n        d++;\n      }\n    } catch (err) {\n      _iterator10.e(err);\n    } finally {\n      _iterator10.f();\n    }\n\n    return target;\n  },\n\n  /**\r\n   * Delete content in the editor backward from the current selection.\r\n   */\n  deleteBackward: function deleteBackward(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var _options$unit = options.unit,\n        unit = _options$unit === void 0 ? 'character' : _options$unit;\n    editor.deleteBackward(unit);\n  },\n\n  /**\r\n   * Delete content in the editor forward from the current selection.\r\n   */\n  deleteForward: function deleteForward(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var _options$unit2 = options.unit,\n        unit = _options$unit2 === void 0 ? 'character' : _options$unit2;\n    editor.deleteForward(unit);\n  },\n\n  /**\r\n   * Delete the content in the current selection.\r\n   */\n  deleteFragment: function deleteFragment(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var _options$direction = options.direction,\n        direction = _options$direction === void 0 ? 'forward' : _options$direction;\n    editor.deleteFragment(direction);\n  },\n\n  /**\r\n   * Get the start and end points of a location.\r\n   */\n  edges: function edges(editor, at) {\n    return [Editor.start(editor, at), Editor.end(editor, at)];\n  },\n\n  /**\r\n   * Get the end point of a location.\r\n   */\n  end: function end(editor, at) {\n    return Editor.point(editor, at, {\n      edge: 'end'\n    });\n  },\n\n  /**\r\n   * Get the first node at a location.\r\n   */\n  first: function first(editor, at) {\n    var path = Editor.path(editor, at, {\n      edge: 'start'\n    });\n    return Editor.node(editor, path);\n  },\n\n  /**\r\n   * Get the fragment at a location.\r\n   */\n  fragment: function fragment(editor, at) {\n    var range = Editor.range(editor, at);\n    var fragment = Node.fragment(editor, range);\n    return fragment;\n  },\n\n  /**\r\n   * Check if a node has block children.\r\n   */\n  hasBlocks: function hasBlocks(editor, element) {\n    return element.children.some(function (n) {\n      return Editor.isBlock(editor, n);\n    });\n  },\n\n  /**\r\n   * Check if a node has inline and text children.\r\n   */\n  hasInlines: function hasInlines(editor, element) {\n    return element.children.some(function (n) {\n      return Text.isText(n) || Editor.isInline(editor, n);\n    });\n  },\n\n  /**\r\n   * Check if a node has text children.\r\n   */\n  hasTexts: function hasTexts(editor, element) {\n    return element.children.every(function (n) {\n      return Text.isText(n);\n    });\n  },\n\n  /**\r\n   * Insert a block break at the current selection.\r\n   *\r\n   * If the selection is currently expanded, it will be deleted first.\r\n   */\n  insertBreak: function insertBreak(editor) {\n    editor.insertBreak();\n  },\n\n  /**\r\n   * Insert a fragment at the current selection.\r\n   *\r\n   * If the selection is currently expanded, it will be deleted first.\r\n   */\n  insertFragment: function insertFragment(editor, fragment) {\n    editor.insertFragment(fragment);\n  },\n\n  /**\r\n   * Insert a node at the current selection.\r\n   *\r\n   * If the selection is currently expanded, it will be deleted first.\r\n   */\n  insertNode: function insertNode(editor, node) {\n    editor.insertNode(node);\n  },\n\n  /**\r\n   * Insert text at the current selection.\r\n   *\r\n   * If the selection is currently expanded, it will be deleted first.\r\n   */\n  insertText: function insertText(editor, text) {\n    editor.insertText(text);\n  },\n\n  /**\r\n   * Check if a value is a block `Element` object.\r\n   */\n  isBlock: function isBlock(editor, value) {\n    return Element.isElement(value) && !editor.isInline(value);\n  },\n\n  /**\r\n   * Check if a value is an `Editor` object.\r\n   */\n  isEditor: function isEditor(value) {\n    if (!isPlainObject(value)) return false;\n    var cachedIsEditor = IS_EDITOR_CACHE.get(value);\n\n    if (cachedIsEditor !== undefined) {\n      return cachedIsEditor;\n    }\n\n    var isEditor = typeof value.addMark === 'function' && typeof value.apply === 'function' && typeof value.deleteBackward === 'function' && typeof value.deleteForward === 'function' && typeof value.deleteFragment === 'function' && typeof value.insertBreak === 'function' && typeof value.insertFragment === 'function' && typeof value.insertNode === 'function' && typeof value.insertText === 'function' && typeof value.isInline === 'function' && typeof value.isVoid === 'function' && typeof value.normalizeNode === 'function' && typeof value.onChange === 'function' && typeof value.removeMark === 'function' && (value.marks === null || isPlainObject(value.marks)) && (value.selection === null || Range.isRange(value.selection)) && Node.isNodeList(value.children) && Operation.isOperationList(value.operations);\n    IS_EDITOR_CACHE.set(value, isEditor);\n    return isEditor;\n  },\n\n  /**\r\n   * Check if a point is the end point of a location.\r\n   */\n  isEnd: function isEnd(editor, point, at) {\n    var end = Editor.end(editor, at);\n    return Point.equals(point, end);\n  },\n\n  /**\r\n   * Check if a point is an edge of a location.\r\n   */\n  isEdge: function isEdge(editor, point, at) {\n    return Editor.isStart(editor, point, at) || Editor.isEnd(editor, point, at);\n  },\n\n  /**\r\n   * Check if an element is empty, accounting for void nodes.\r\n   */\n  isEmpty: function isEmpty(editor, element) {\n    var children = element.children;\n\n    var _children = _slicedToArray(children, 1),\n        first = _children[0];\n\n    return children.length === 0 || children.length === 1 && Text.isText(first) && first.text === '' && !editor.isVoid(element);\n  },\n\n  /**\r\n   * Check if a value is an inline `Element` object.\r\n   */\n  isInline: function isInline(editor, value) {\n    return Element.isElement(value) && editor.isInline(value);\n  },\n\n  /**\r\n   * Check if the editor is currently normalizing after each operation.\r\n   */\n  isNormalizing: function isNormalizing(editor) {\n    var isNormalizing = NORMALIZING.get(editor);\n    return isNormalizing === undefined ? true : isNormalizing;\n  },\n\n  /**\r\n   * Check if a point is the start point of a location.\r\n   */\n  isStart: function isStart(editor, point, at) {\n    // PERF: If the offset isn't `0` we know it's not the start.\n    if (point.offset !== 0) {\n      return false;\n    }\n\n    var start = Editor.start(editor, at);\n    return Point.equals(point, start);\n  },\n\n  /**\r\n   * Check if a value is a void `Element` object.\r\n   */\n  isVoid: function isVoid(editor, value) {\n    return Element.isElement(value) && editor.isVoid(value);\n  },\n\n  /**\r\n   * Get the last node at a location.\r\n   */\n  last: function last(editor, at) {\n    var path = Editor.path(editor, at, {\n      edge: 'end'\n    });\n    return Editor.node(editor, path);\n  },\n\n  /**\r\n   * Get the leaf text node at a location.\r\n   */\n  leaf: function leaf(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var path = Editor.path(editor, at, options);\n    var node = Node.leaf(editor, path);\n    return [node, path];\n  },\n\n  /**\r\n   * Iterate through all of the levels at a location.\r\n   */\n  levels: /*#__PURE__*/_regeneratorRuntime.mark(function levels(editor) {\n    var options,\n        _options$at2,\n        at,\n        _options$reverse,\n        reverse,\n        _options$voids2,\n        voids,\n        match,\n        levels,\n        path,\n        _iterator11,\n        _step11,\n        _step11$value,\n        n,\n        p,\n        _args = arguments;\n\n    return _regeneratorRuntime.wrap(function levels$(_context) {\n      while (1) {\n        switch (_context.prev = _context.next) {\n          case 0:\n            options = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};\n            _options$at2 = options.at, at = _options$at2 === void 0 ? editor.selection : _options$at2, _options$reverse = options.reverse, reverse = _options$reverse === void 0 ? false : _options$reverse, _options$voids2 = options.voids, voids = _options$voids2 === void 0 ? false : _options$voids2;\n            match = options.match;\n\n            if (match == null) {\n              match = function match() {\n                return true;\n              };\n            }\n\n            if (at) {\n              _context.next = 6;\n              break;\n            }\n\n            return _context.abrupt(\"return\");\n\n          case 6:\n            levels = [];\n            path = Editor.path(editor, at);\n            _iterator11 = _createForOfIteratorHelper(Node.levels(editor, path));\n            _context.prev = 9;\n\n            _iterator11.s();\n\n          case 11:\n            if ((_step11 = _iterator11.n()).done) {\n              _context.next = 20;\n              break;\n            }\n\n            _step11$value = _slicedToArray(_step11.value, 2), n = _step11$value[0], p = _step11$value[1];\n\n            if (match(n, p)) {\n              _context.next = 15;\n              break;\n            }\n\n            return _context.abrupt(\"continue\", 18);\n\n          case 15:\n            levels.push([n, p]);\n\n            if (!(!voids && Editor.isVoid(editor, n))) {\n              _context.next = 18;\n              break;\n            }\n\n            return _context.abrupt(\"break\", 20);\n\n          case 18:\n            _context.next = 11;\n            break;\n\n          case 20:\n            _context.next = 25;\n            break;\n\n          case 22:\n            _context.prev = 22;\n            _context.t0 = _context[\"catch\"](9);\n\n            _iterator11.e(_context.t0);\n\n          case 25:\n            _context.prev = 25;\n\n            _iterator11.f();\n\n            return _context.finish(25);\n\n          case 28:\n            if (reverse) {\n              levels.reverse();\n            }\n\n            return _context.delegateYield(levels, \"t1\", 30);\n\n          case 30:\n          case \"end\":\n            return _context.stop();\n        }\n      }\n    }, levels, null, [[9, 22, 25, 28]]);\n  }),\n\n  /**\r\n   * Get the marks that would be added to text at the current selection.\r\n   */\n  marks: function marks(editor) {\n    var marks = editor.marks,\n        selection = editor.selection;\n\n    if (!selection) {\n      return null;\n    }\n\n    if (marks) {\n      return marks;\n    }\n\n    if (Range.isExpanded(selection)) {\n      var _Editor$nodes = Editor.nodes(editor, {\n        match: Text.isText\n      }),\n          _Editor$nodes2 = _slicedToArray(_Editor$nodes, 1),\n          match = _Editor$nodes2[0];\n\n      if (match) {\n        var _match = _slicedToArray(match, 1),\n            _node = _match[0];\n\n        var _rest = _objectWithoutProperties(_node, [\"text\"]);\n\n        return _rest;\n      } else {\n        return {};\n      }\n    }\n\n    var anchor = selection.anchor;\n    var path = anchor.path;\n\n    var _Editor$leaf = Editor.leaf(editor, path),\n        _Editor$leaf2 = _slicedToArray(_Editor$leaf, 1),\n        node = _Editor$leaf2[0];\n\n    if (anchor.offset === 0) {\n      var prev = Editor.previous(editor, {\n        at: path,\n        match: Text.isText\n      });\n      var block = Editor.above(editor, {\n        match: function match(n) {\n          return Editor.isBlock(editor, n);\n        }\n      });\n\n      if (prev && block) {\n        var _prev2 = _slicedToArray(prev, 2),\n            prevNode = _prev2[0],\n            prevPath = _prev2[1];\n\n        var _block = _slicedToArray(block, 2),\n            blockPath = _block[1];\n\n        if (Path.isAncestor(blockPath, prevPath)) {\n          node = prevNode;\n        }\n      }\n    }\n\n    var rest = _objectWithoutProperties(node, [\"text\"]);\n\n    return rest;\n  },\n\n  /**\r\n   * Get the matching node in the branch of the document after a location.\r\n   */\n  next: function next(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var _options$mode2 = options.mode,\n        mode = _options$mode2 === void 0 ? 'lowest' : _options$mode2,\n        _options$voids3 = options.voids,\n        voids = _options$voids3 === void 0 ? false : _options$voids3;\n    var match = options.match,\n        _options$at3 = options.at,\n        at = _options$at3 === void 0 ? editor.selection : _options$at3;\n\n    if (!at) {\n      return;\n    }\n\n    var pointAfterLocation = Editor.after(editor, at, {\n      voids: voids\n    });\n    if (!pointAfterLocation) return;\n\n    var _Editor$last = Editor.last(editor, []),\n        _Editor$last2 = _slicedToArray(_Editor$last, 2),\n        to = _Editor$last2[1];\n\n    var span = [pointAfterLocation.path, to];\n\n    if (Path.isPath(at) && at.length === 0) {\n      throw new Error(\"Cannot get the next node from the root node!\");\n    }\n\n    if (match == null) {\n      if (Path.isPath(at)) {\n        var _Editor$parent = Editor.parent(editor, at),\n            _Editor$parent2 = _slicedToArray(_Editor$parent, 1),\n            parent = _Editor$parent2[0];\n\n        match = function match(n) {\n          return parent.children.includes(n);\n        };\n      } else {\n        match = function match() {\n          return true;\n        };\n      }\n    }\n\n    var _Editor$nodes3 = Editor.nodes(editor, {\n      at: span,\n      match: match,\n      mode: mode,\n      voids: voids\n    }),\n        _Editor$nodes4 = _slicedToArray(_Editor$nodes3, 1),\n        next = _Editor$nodes4[0];\n\n    return next;\n  },\n\n  /**\r\n   * Get the node at a location.\r\n   */\n  node: function node(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var path = Editor.path(editor, at, options);\n    var node = Node.get(editor, path);\n    return [node, path];\n  },\n\n  /**\r\n   * Iterate through all of the nodes in the Editor.\r\n   */\n  nodes: /*#__PURE__*/_regeneratorRuntime.mark(function nodes(editor) {\n    var options,\n        _options$at4,\n        at,\n        _options$mode3,\n        mode,\n        _options$universal,\n        universal,\n        _options$reverse2,\n        reverse,\n        _options$voids4,\n        voids,\n        match,\n        from,\n        to,\n        first,\n        last,\n        nodeEntries,\n        matches,\n        hit,\n        _iterator12,\n        _step12,\n        _step12$value,\n        node,\n        path,\n        isLower,\n        emit,\n        _args2 = arguments;\n\n    return _regeneratorRuntime.wrap(function nodes$(_context2) {\n      while (1) {\n        switch (_context2.prev = _context2.next) {\n          case 0:\n            options = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};\n            _options$at4 = options.at, at = _options$at4 === void 0 ? editor.selection : _options$at4, _options$mode3 = options.mode, mode = _options$mode3 === void 0 ? 'all' : _options$mode3, _options$universal = options.universal, universal = _options$universal === void 0 ? false : _options$universal, _options$reverse2 = options.reverse, reverse = _options$reverse2 === void 0 ? false : _options$reverse2, _options$voids4 = options.voids, voids = _options$voids4 === void 0 ? false : _options$voids4;\n            match = options.match;\n\n            if (!match) {\n              match = function match() {\n                return true;\n              };\n            }\n\n            if (at) {\n              _context2.next = 6;\n              break;\n            }\n\n            return _context2.abrupt(\"return\");\n\n          case 6:\n            if (Span.isSpan(at)) {\n              from = at[0];\n              to = at[1];\n            } else {\n              first = Editor.path(editor, at, {\n                edge: 'start'\n              });\n              last = Editor.path(editor, at, {\n                edge: 'end'\n              });\n              from = reverse ? last : first;\n              to = reverse ? first : last;\n            }\n\n            nodeEntries = Node.nodes(editor, {\n              reverse: reverse,\n              from: from,\n              to: to,\n              pass: function pass(_ref) {\n                var _ref7 = _slicedToArray(_ref, 1),\n                    n = _ref7[0];\n\n                return voids ? false : Editor.isVoid(editor, n);\n              }\n            });\n            matches = [];\n            _iterator12 = _createForOfIteratorHelper(nodeEntries);\n            _context2.prev = 10;\n\n            _iterator12.s();\n\n          case 12:\n            if ((_step12 = _iterator12.n()).done) {\n              _context2.next = 37;\n              break;\n            }\n\n            _step12$value = _slicedToArray(_step12.value, 2), node = _step12$value[0], path = _step12$value[1];\n            isLower = hit && Path.compare(path, hit[1]) === 0; // In highest mode any node lower than the last hit is not a match.\n\n            if (!(mode === 'highest' && isLower)) {\n              _context2.next = 17;\n              break;\n            }\n\n            return _context2.abrupt(\"continue\", 35);\n\n          case 17:\n            if (match(node, path)) {\n              _context2.next = 23;\n              break;\n            }\n\n            if (!(universal && !isLower && Text.isText(node))) {\n              _context2.next = 22;\n              break;\n            }\n\n            return _context2.abrupt(\"return\");\n\n          case 22:\n            return _context2.abrupt(\"continue\", 35);\n\n          case 23:\n            if (!(mode === 'lowest' && isLower)) {\n              _context2.next = 26;\n              break;\n            }\n\n            hit = [node, path];\n            return _context2.abrupt(\"continue\", 35);\n\n          case 26:\n            // In lowest mode we emit the last hit, once it's guaranteed lowest.\n            emit = mode === 'lowest' ? hit : [node, path];\n\n            if (!emit) {\n              _context2.next = 34;\n              break;\n            }\n\n            if (!universal) {\n              _context2.next = 32;\n              break;\n            }\n\n            matches.push(emit);\n            _context2.next = 34;\n            break;\n\n          case 32:\n            _context2.next = 34;\n            return emit;\n\n          case 34:\n            hit = [node, path];\n\n          case 35:\n            _context2.next = 12;\n            break;\n\n          case 37:\n            _context2.next = 42;\n            break;\n\n          case 39:\n            _context2.prev = 39;\n            _context2.t0 = _context2[\"catch\"](10);\n\n            _iterator12.e(_context2.t0);\n\n          case 42:\n            _context2.prev = 42;\n\n            _iterator12.f();\n\n            return _context2.finish(42);\n\n          case 45:\n            if (!(mode === 'lowest' && hit)) {\n              _context2.next = 52;\n              break;\n            }\n\n            if (!universal) {\n              _context2.next = 50;\n              break;\n            }\n\n            matches.push(hit);\n            _context2.next = 52;\n            break;\n\n          case 50:\n            _context2.next = 52;\n            return hit;\n\n          case 52:\n            if (!universal) {\n              _context2.next = 54;\n              break;\n            }\n\n            return _context2.delegateYield(matches, \"t1\", 54);\n\n          case 54:\n          case \"end\":\n            return _context2.stop();\n        }\n      }\n    }, nodes, null, [[10, 39, 42, 45]]);\n  }),\n\n  /**\r\n   * Normalize any dirty objects in the editor.\r\n   */\n  normalize: function normalize(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var _options$force = options.force,\n        force = _options$force === void 0 ? false : _options$force;\n\n    var getDirtyPaths = function getDirtyPaths(editor) {\n      return DIRTY_PATHS.get(editor) || [];\n    };\n\n    if (!Editor.isNormalizing(editor)) {\n      return;\n    }\n\n    if (force) {\n      var allPaths = Array.from(Node.nodes(editor), function (_ref2) {\n        var _ref8 = _slicedToArray(_ref2, 2),\n            p = _ref8[1];\n\n        return p;\n      });\n      DIRTY_PATHS.set(editor, allPaths);\n    }\n\n    if (getDirtyPaths(editor).length === 0) {\n      return;\n    }\n\n    Editor.withoutNormalizing(editor, function () {\n      /*\r\n        Fix dirty elements with no children.\r\n        editor.normalizeNode() does fix this, but some normalization fixes also require it to work.\r\n        Running an initial pass avoids the catch-22 race condition.\r\n      */\n      var _iterator13 = _createForOfIteratorHelper(getDirtyPaths(editor)),\n          _step13;\n\n      try {\n        for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {\n          var dirtyPath = _step13.value;\n\n          if (Node.has(editor, dirtyPath)) {\n            var _Editor$node = Editor.node(editor, dirtyPath),\n                _Editor$node2 = _slicedToArray(_Editor$node, 2),\n                node = _Editor$node2[0],\n                _ = _Editor$node2[1]; // Add a text child to elements with no children.\n            // This is safe to do in any order, by definition it can't cause other paths to change.\n\n\n            if (Element.isElement(node) && node.children.length === 0) {\n              var child = {\n                text: ''\n              };\n              Transforms.insertNodes(editor, child, {\n                at: dirtyPath.concat(0),\n                voids: true\n              });\n            }\n          }\n        }\n      } catch (err) {\n        _iterator13.e(err);\n      } finally {\n        _iterator13.f();\n      }\n\n      var max = getDirtyPaths(editor).length * 42; // HACK: better way?\n\n      var m = 0;\n\n      while (getDirtyPaths(editor).length !== 0) {\n        if (m > max) {\n          throw new Error(\"\\n            Could not completely normalize the editor after \".concat(max, \" iterations! This is usually due to incorrect normalization logic that leaves a node in an invalid state.\\n          \"));\n        }\n\n        var _dirtyPath = getDirtyPaths(editor).pop(); // If the node doesn't exist in the tree, it does not need to be normalized.\n\n\n        if (Node.has(editor, _dirtyPath)) {\n          var entry = Editor.node(editor, _dirtyPath);\n          editor.normalizeNode(entry);\n        }\n\n        m++;\n      }\n    });\n  },\n\n  /**\r\n   * Get the parent node of a location.\r\n   */\n  parent: function parent(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var path = Editor.path(editor, at, options);\n    var parentPath = Path.parent(path);\n    var entry = Editor.node(editor, parentPath);\n    return entry;\n  },\n\n  /**\r\n   * Get the path of a location.\r\n   */\n  path: function path(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var depth = options.depth,\n        edge = options.edge;\n\n    if (Path.isPath(at)) {\n      if (edge === 'start') {\n        var _Node$first = Node.first(editor, at),\n            _Node$first2 = _slicedToArray(_Node$first, 2),\n            firstPath = _Node$first2[1];\n\n        at = firstPath;\n      } else if (edge === 'end') {\n        var _Node$last = Node.last(editor, at),\n            _Node$last2 = _slicedToArray(_Node$last, 2),\n            lastPath = _Node$last2[1];\n\n        at = lastPath;\n      }\n    }\n\n    if (Range.isRange(at)) {\n      if (edge === 'start') {\n        at = Range.start(at);\n      } else if (edge === 'end') {\n        at = Range.end(at);\n      } else {\n        at = Path.common(at.anchor.path, at.focus.path);\n      }\n    }\n\n    if (Point.isPoint(at)) {\n      at = at.path;\n    }\n\n    if (depth != null) {\n      at = at.slice(0, depth);\n    }\n\n    return at;\n  },\n  hasPath: function hasPath(editor, path) {\n    return Node.has(editor, path);\n  },\n\n  /**\r\n   * Create a mutable ref for a `Path` object, which will stay in sync as new\r\n   * operations are applied to the editor.\r\n   */\n  pathRef: function pathRef(editor, path) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var _options$affinity = options.affinity,\n        affinity = _options$affinity === void 0 ? 'forward' : _options$affinity;\n    var ref = {\n      current: path,\n      affinity: affinity,\n      unref: function unref() {\n        var current = ref.current;\n        var pathRefs = Editor.pathRefs(editor);\n        pathRefs.delete(ref);\n        ref.current = null;\n        return current;\n      }\n    };\n    var refs = Editor.pathRefs(editor);\n    refs.add(ref);\n    return ref;\n  },\n\n  /**\r\n   * Get the set of currently tracked path refs of the editor.\r\n   */\n  pathRefs: function pathRefs(editor) {\n    var refs = PATH_REFS.get(editor);\n\n    if (!refs) {\n      refs = new Set();\n      PATH_REFS.set(editor, refs);\n    }\n\n    return refs;\n  },\n\n  /**\r\n   * Get the start or end point of a location.\r\n   */\n  point: function point(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var _options$edge = options.edge,\n        edge = _options$edge === void 0 ? 'start' : _options$edge;\n\n    if (Path.isPath(at)) {\n      var path;\n\n      if (edge === 'end') {\n        var _Node$last3 = Node.last(editor, at),\n            _Node$last4 = _slicedToArray(_Node$last3, 2),\n            lastPath = _Node$last4[1];\n\n        path = lastPath;\n      } else {\n        var _Node$first3 = Node.first(editor, at),\n            _Node$first4 = _slicedToArray(_Node$first3, 2),\n            firstPath = _Node$first4[1];\n\n        path = firstPath;\n      }\n\n      var node = Node.get(editor, path);\n\n      if (!Text.isText(node)) {\n        throw new Error(\"Cannot get the \".concat(edge, \" point in the node at path [\").concat(at, \"] because it has no \").concat(edge, \" text node.\"));\n      }\n\n      return {\n        path: path,\n        offset: edge === 'end' ? node.text.length : 0\n      };\n    }\n\n    if (Range.isRange(at)) {\n      var _Range$edges = Range.edges(at),\n          _Range$edges2 = _slicedToArray(_Range$edges, 2),\n          start = _Range$edges2[0],\n          end = _Range$edges2[1];\n\n      return edge === 'start' ? start : end;\n    }\n\n    return at;\n  },\n\n  /**\r\n   * Create a mutable ref for a `Point` object, which will stay in sync as new\r\n   * operations are applied to the editor.\r\n   */\n  pointRef: function pointRef(editor, point) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var _options$affinity2 = options.affinity,\n        affinity = _options$affinity2 === void 0 ? 'forward' : _options$affinity2;\n    var ref = {\n      current: point,\n      affinity: affinity,\n      unref: function unref() {\n        var current = ref.current;\n        var pointRefs = Editor.pointRefs(editor);\n        pointRefs.delete(ref);\n        ref.current = null;\n        return current;\n      }\n    };\n    var refs = Editor.pointRefs(editor);\n    refs.add(ref);\n    return ref;\n  },\n\n  /**\r\n   * Get the set of currently tracked point refs of the editor.\r\n   */\n  pointRefs: function pointRefs(editor) {\n    var refs = POINT_REFS.get(editor);\n\n    if (!refs) {\n      refs = new Set();\n      POINT_REFS.set(editor, refs);\n    }\n\n    return refs;\n  },\n\n  /**\r\n   * Return all the positions in `at` range where a `Point` can be placed.\r\n   *\r\n   * By default, moves forward by individual offsets at a time, but\r\n   * the `unit` option can be used to to move by character, word, line, or block.\r\n   *\r\n   * The `reverse` option can be used to change iteration direction.\r\n   *\r\n   * Note: By default void nodes are treated as a single point and iteration\r\n   * will not happen inside their content unless you pass in true for the\r\n   * `voids` option, then iteration will occur.\r\n   */\n  positions: /*#__PURE__*/_regeneratorRuntime.mark(function positions(editor) {\n    var options,\n        _options$at5,\n        at,\n        _options$unit3,\n        unit,\n        _options$reverse3,\n        reverse$1,\n        _options$voids5,\n        voids,\n        range,\n        _Range$edges3,\n        _Range$edges4,\n        start,\n        end,\n        first,\n        isNewBlock,\n        blockText,\n        distance,\n        leafTextRemaining,\n        leafTextOffset,\n        _iterator14,\n        _step14,\n        _step14$value,\n        node,\n        path,\n        e,\n        s,\n        isFirst,\n        calcDistance,\n        _args3 = arguments;\n\n    return _regeneratorRuntime.wrap(function positions$(_context3) {\n      while (1) {\n        switch (_context3.prev = _context3.next) {\n          case 0:\n            calcDistance = function _calcDistance(text, unit) {\n              if (unit === 'character') {\n                return getCharacterDistance(text);\n              } else if (unit === 'word') {\n                return getWordDistance(text);\n              } else if (unit === 'line' || unit === 'block') {\n                return text.length;\n              }\n\n              return 1;\n            };\n\n            options = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : {};\n            _options$at5 = options.at, at = _options$at5 === void 0 ? editor.selection : _options$at5, _options$unit3 = options.unit, unit = _options$unit3 === void 0 ? 'offset' : _options$unit3, _options$reverse3 = options.reverse, reverse$1 = _options$reverse3 === void 0 ? false : _options$reverse3, _options$voids5 = options.voids, voids = _options$voids5 === void 0 ? false : _options$voids5;\n\n            if (at) {\n              _context3.next = 5;\n              break;\n            }\n\n            return _context3.abrupt(\"return\");\n\n          case 5:\n            /**\r\n             * Algorithm notes:\r\n             *\r\n             * Each step `distance` is dynamic depending on the underlying text\r\n             * and the `unit` specified.  Each step, e.g., a line or word, may\r\n             * span multiple text nodes, so we iterate through the text both on\r\n             * two levels in step-sync:\r\n             *\r\n             * `leafText` stores the text on a text leaf level, and is advanced\r\n             * through using the counters `leafTextOffset` and `leafTextRemaining`.\r\n             *\r\n             * `blockText` stores the text on a block level, and is shortened\r\n             * by `distance` every time it is advanced.\r\n             *\r\n             * We only maintain a window of one blockText and one leafText because\r\n             * a block node always appears before all of its leaf nodes.\r\n             */\n            range = Editor.range(editor, at);\n            _Range$edges3 = Range.edges(range), _Range$edges4 = _slicedToArray(_Range$edges3, 2), start = _Range$edges4[0], end = _Range$edges4[1];\n            first = reverse$1 ? end : start;\n            isNewBlock = false;\n            blockText = '';\n            distance = 0; // Distance for leafText to catch up to blockText.\n\n            leafTextRemaining = 0;\n            leafTextOffset = 0; // Iterate through all nodes in range, grabbing entire textual content\n            // of block nodes in blockText, and text nodes in leafText.\n            // Exploits the fact that nodes are sequenced in such a way that we first\n            // encounter the block node, then all of its text nodes, so when iterating\n            // through the blockText and leafText we just need to remember a window of\n            // one block node and leaf node, respectively.\n\n            _iterator14 = _createForOfIteratorHelper(Editor.nodes(editor, {\n              at: at,\n              reverse: reverse$1,\n              voids: voids\n            }));\n            _context3.prev = 14;\n\n            _iterator14.s();\n\n          case 16:\n            if ((_step14 = _iterator14.n()).done) {\n              _context3.next = 51;\n              break;\n            }\n\n            _step14$value = _slicedToArray(_step14.value, 2), node = _step14$value[0], path = _step14$value[1];\n\n            if (!Element.isElement(node)) {\n              _context3.next = 26;\n              break;\n            }\n\n            if (!(!voids && editor.isVoid(node))) {\n              _context3.next = 23;\n              break;\n            }\n\n            _context3.next = 22;\n            return Editor.start(editor, path);\n\n          case 22:\n            return _context3.abrupt(\"continue\", 49);\n\n          case 23:\n            if (!editor.isInline(node)) {\n              _context3.next = 25;\n              break;\n            }\n\n            return _context3.abrupt(\"continue\", 49);\n\n          case 25:\n            // Block element node - set `blockText` to its text content.\n            if (Editor.hasInlines(editor, node)) {\n              // We always exhaust block nodes before encountering a new one:\n              //   console.assert(blockText === '',\n              //     `blockText='${blockText}' - `+\n              //     `not exhausted before new block node`, path)\n              // Ensure range considered is capped to `range`, in the\n              // start/end edge cases where block extends beyond range.\n              // Equivalent to this, but presumably more performant:\n              //   blockRange = Editor.range(editor, ...Editor.edges(editor, path))\n              //   blockRange = Range.intersection(range, blockRange) // intersect\n              //   blockText = Editor.string(editor, blockRange, { voids })\n              e = Path.isAncestor(path, end.path) ? end : Editor.end(editor, path);\n              s = Path.isAncestor(path, start.path) ? start : Editor.start(editor, path);\n              blockText = Editor.string(editor, {\n                anchor: s,\n                focus: e\n              }, {\n                voids: voids\n              });\n              blockText = reverse$1 ? reverse(blockText) : blockText;\n              isNewBlock = true;\n            }\n\n          case 26:\n            if (!Text.isText(node)) {\n              _context3.next = 49;\n              break;\n            }\n\n            isFirst = Path.equals(path, first.path); // Proof that we always exhaust text nodes before encountering a new one:\n            //   console.assert(leafTextRemaining <= 0,\n            //     `leafTextRemaining=${leafTextRemaining} - `+\n            //     `not exhausted before new leaf text node`, path)\n            // Reset `leafText` counters for new text node.\n\n            if (isFirst) {\n              leafTextRemaining = reverse$1 ? first.offset : node.text.length - first.offset;\n              leafTextOffset = first.offset; // Works for reverse too.\n            } else {\n              leafTextRemaining = node.text.length;\n              leafTextOffset = reverse$1 ? leafTextRemaining : 0;\n            } // Yield position at the start of node (potentially).\n\n\n            if (!(isFirst || isNewBlock || unit === 'offset')) {\n              _context3.next = 33;\n              break;\n            }\n\n            _context3.next = 32;\n            return {\n              path: path,\n              offset: leafTextOffset\n            };\n\n          case 32:\n            isNewBlock = false;\n\n          case 33:\n            if (!true) {\n              _context3.next = 49;\n              break;\n            }\n\n            if (!(distance === 0)) {\n              _context3.next = 39;\n              break;\n            }\n\n            if (!(blockText === '')) {\n              _context3.next = 37;\n              break;\n            }\n\n            return _context3.abrupt(\"break\", 49);\n\n          case 37:\n            distance = calcDistance(blockText, unit);\n            blockText = blockText.slice(distance);\n\n          case 39:\n            // Advance `leafText` by the current `distance`.\n            leafTextOffset = reverse$1 ? leafTextOffset - distance : leafTextOffset + distance;\n            leafTextRemaining = leafTextRemaining - distance; // If `leafText` is exhausted, break to get a new leaf node\n            // and set distance to the overflow amount, so we'll (maybe)\n            // catch up to blockText in the next leaf text node.\n\n            if (!(leafTextRemaining < 0)) {\n              _context3.next = 44;\n              break;\n            }\n\n            distance = -leafTextRemaining;\n            return _context3.abrupt(\"break\", 49);\n\n          case 44:\n            // Successfully walked `distance` offsets through `leafText`\n            // to catch up with `blockText`, so we can reset `distance`\n            // and yield this position in this node.\n            distance = 0;\n            _context3.next = 47;\n            return {\n              path: path,\n              offset: leafTextOffset\n            };\n\n          case 47:\n            _context3.next = 33;\n            break;\n\n          case 49:\n            _context3.next = 16;\n            break;\n\n          case 51:\n            _context3.next = 56;\n            break;\n\n          case 53:\n            _context3.prev = 53;\n            _context3.t0 = _context3[\"catch\"](14);\n\n            _iterator14.e(_context3.t0);\n\n          case 56:\n            _context3.prev = 56;\n\n            _iterator14.f();\n\n            return _context3.finish(56);\n\n          case 59:\n          case \"end\":\n            return _context3.stop();\n        }\n      }\n    }, positions, null, [[14, 53, 56, 59]]);\n  }),\n\n  /**\r\n   * Get the matching node in the branch of the document before a location.\r\n   */\n  previous: function previous(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var _options$mode4 = options.mode,\n        mode = _options$mode4 === void 0 ? 'lowest' : _options$mode4,\n        _options$voids6 = options.voids,\n        voids = _options$voids6 === void 0 ? false : _options$voids6;\n    var match = options.match,\n        _options$at6 = options.at,\n        at = _options$at6 === void 0 ? editor.selection : _options$at6;\n\n    if (!at) {\n      return;\n    }\n\n    var pointBeforeLocation = Editor.before(editor, at, {\n      voids: voids\n    });\n\n    if (!pointBeforeLocation) {\n      return;\n    }\n\n    var _Editor$first = Editor.first(editor, []),\n        _Editor$first2 = _slicedToArray(_Editor$first, 2),\n        to = _Editor$first2[1]; // The search location is from the start of the document to the path of\n    // the point before the location passed in\n\n\n    var span = [pointBeforeLocation.path, to];\n\n    if (Path.isPath(at) && at.length === 0) {\n      throw new Error(\"Cannot get the previous node from the root node!\");\n    }\n\n    if (match == null) {\n      if (Path.isPath(at)) {\n        var _Editor$parent3 = Editor.parent(editor, at),\n            _Editor$parent4 = _slicedToArray(_Editor$parent3, 1),\n            parent = _Editor$parent4[0];\n\n        match = function match(n) {\n          return parent.children.includes(n);\n        };\n      } else {\n        match = function match() {\n          return true;\n        };\n      }\n    }\n\n    var _Editor$nodes5 = Editor.nodes(editor, {\n      reverse: true,\n      at: span,\n      match: match,\n      mode: mode,\n      voids: voids\n    }),\n        _Editor$nodes6 = _slicedToArray(_Editor$nodes5, 1),\n        previous = _Editor$nodes6[0];\n\n    return previous;\n  },\n\n  /**\r\n   * Get a range of a location.\r\n   */\n  range: function range(editor, at, to) {\n    if (Range.isRange(at) && !to) {\n      return at;\n    }\n\n    var start = Editor.start(editor, at);\n    var end = Editor.end(editor, to || at);\n    return {\n      anchor: start,\n      focus: end\n    };\n  },\n\n  /**\r\n   * Create a mutable ref for a `Range` object, which will stay in sync as new\r\n   * operations are applied to the editor.\r\n   */\n  rangeRef: function rangeRef(editor, range) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var _options$affinity3 = options.affinity,\n        affinity = _options$affinity3 === void 0 ? 'forward' : _options$affinity3;\n    var ref = {\n      current: range,\n      affinity: affinity,\n      unref: function unref() {\n        var current = ref.current;\n        var rangeRefs = Editor.rangeRefs(editor);\n        rangeRefs.delete(ref);\n        ref.current = null;\n        return current;\n      }\n    };\n    var refs = Editor.rangeRefs(editor);\n    refs.add(ref);\n    return ref;\n  },\n\n  /**\r\n   * Get the set of currently tracked range refs of the editor.\r\n   */\n  rangeRefs: function rangeRefs(editor) {\n    var refs = RANGE_REFS.get(editor);\n\n    if (!refs) {\n      refs = new Set();\n      RANGE_REFS.set(editor, refs);\n    }\n\n    return refs;\n  },\n\n  /**\r\n   * Remove a custom property from all of the leaf text nodes in the current\r\n   * selection.\r\n   *\r\n   * If the selection is currently collapsed, the removal will be stored on\r\n   * `editor.marks` and applied to the text inserted next.\r\n   */\n  removeMark: function removeMark(editor, key) {\n    editor.removeMark(key);\n  },\n\n  /**\r\n   * Get the start point of a location.\r\n   */\n  start: function start(editor, at) {\n    return Editor.point(editor, at, {\n      edge: 'start'\n    });\n  },\n\n  /**\r\n   * Get the text string content of a location.\r\n   *\r\n   * Note: by default the text of void nodes is considered to be an empty\r\n   * string, regardless of content, unless you pass in true for the voids option\r\n   */\n  string: function string(editor, at) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var _options$voids7 = options.voids,\n        voids = _options$voids7 === void 0 ? false : _options$voids7;\n    var range = Editor.range(editor, at);\n\n    var _Range$edges5 = Range.edges(range),\n        _Range$edges6 = _slicedToArray(_Range$edges5, 2),\n        start = _Range$edges6[0],\n        end = _Range$edges6[1];\n\n    var text = '';\n\n    var _iterator15 = _createForOfIteratorHelper(Editor.nodes(editor, {\n      at: range,\n      match: Text.isText,\n      voids: voids\n    })),\n        _step15;\n\n    try {\n      for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {\n        var _step15$value = _slicedToArray(_step15.value, 2),\n            node = _step15$value[0],\n            path = _step15$value[1];\n\n        var t = node.text;\n\n        if (Path.equals(path, end.path)) {\n          t = t.slice(0, end.offset);\n        }\n\n        if (Path.equals(path, start.path)) {\n          t = t.slice(start.offset);\n        }\n\n        text += t;\n      }\n    } catch (err) {\n      _iterator15.e(err);\n    } finally {\n      _iterator15.f();\n    }\n\n    return text;\n  },\n\n  /**\r\n   * Convert a range into a non-hanging one.\r\n   */\n  unhangRange: function unhangRange(editor, range) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var _options$voids8 = options.voids,\n        voids = _options$voids8 === void 0 ? false : _options$voids8;\n\n    var _Range$edges7 = Range.edges(range),\n        _Range$edges8 = _slicedToArray(_Range$edges7, 2),\n        start = _Range$edges8[0],\n        end = _Range$edges8[1]; // PERF: exit early if we can guarantee that the range isn't hanging.\n\n\n    if (start.offset !== 0 || end.offset !== 0 || Range.isCollapsed(range)) {\n      return range;\n    }\n\n    var endBlock = Editor.above(editor, {\n      at: end,\n      match: function match(n) {\n        return Editor.isBlock(editor, n);\n      }\n    });\n    var blockPath = endBlock ? endBlock[1] : [];\n    var first = Editor.start(editor, []);\n    var before = {\n      anchor: first,\n      focus: end\n    };\n    var skip = true;\n\n    var _iterator16 = _createForOfIteratorHelper(Editor.nodes(editor, {\n      at: before,\n      match: Text.isText,\n      reverse: true,\n      voids: voids\n    })),\n        _step16;\n\n    try {\n      for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {\n        var _step16$value = _slicedToArray(_step16.value, 2),\n            node = _step16$value[0],\n            path = _step16$value[1];\n\n        if (skip) {\n          skip = false;\n          continue;\n        }\n\n        if (node.text !== '' || Path.isBefore(path, blockPath)) {\n          end = {\n            path: path,\n            offset: node.text.length\n          };\n          break;\n        }\n      }\n    } catch (err) {\n      _iterator16.e(err);\n    } finally {\n      _iterator16.f();\n    }\n\n    return {\n      anchor: start,\n      focus: end\n    };\n  },\n\n  /**\r\n   * Match a void node in the current branch of the editor.\r\n   */\n  void: function _void(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    return Editor.above(editor, _objectSpread$1(_objectSpread$1({}, options), {}, {\n      match: function match(n) {\n        return Editor.isVoid(editor, n);\n      }\n    }));\n  },\n\n  /**\r\n   * Call a function, deferring normalization until after it completes.\r\n   */\n  withoutNormalizing: function withoutNormalizing(editor, fn) {\n    var value = Editor.isNormalizing(editor);\n    NORMALIZING.set(editor, false);\n\n    try {\n      fn();\n    } finally {\n      NORMALIZING.set(editor, value);\n    }\n\n    Editor.normalize(editor);\n  }\n};\nvar Location = {\n  /**\r\n   * Check if a value implements the `Location` interface.\r\n   */\n  isLocation: function isLocation(value) {\n    return Path.isPath(value) || Point.isPoint(value) || Range.isRange(value);\n  }\n};\nvar Span = {\n  /**\r\n   * Check if a value implements the `Span` interface.\r\n   */\n  isSpan: function isSpan(value) {\n    return Array.isArray(value) && value.length === 2 && value.every(Path.isPath);\n  }\n};\nvar IS_NODE_LIST_CACHE = new WeakMap();\nvar Node = {\n  /**\r\n   * Get the node at a specific path, asserting that it's an ancestor node.\r\n   */\n  ancestor: function ancestor(root, path) {\n    var node = Node.get(root, path);\n\n    if (Text.isText(node)) {\n      throw new Error(\"Cannot get the ancestor node at path [\".concat(path, \"] because it refers to a text node instead: \").concat(node));\n    }\n\n    return node;\n  },\n\n  /**\r\n   * Return a generator of all the ancestor nodes above a specific path.\r\n   *\r\n   * By default the order is bottom-up, from lowest to highest ancestor in\r\n   * the tree, but you can pass the `reverse: true` option to go top-down.\r\n   */\n  ancestors: /*#__PURE__*/_regeneratorRuntime.mark(function ancestors(root, path) {\n    var options,\n        _iterator17,\n        _step17,\n        p,\n        n,\n        entry,\n        _args4 = arguments;\n\n    return _regeneratorRuntime.wrap(function ancestors$(_context4) {\n      while (1) {\n        switch (_context4.prev = _context4.next) {\n          case 0:\n            options = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : {};\n            _iterator17 = _createForOfIteratorHelper(Path.ancestors(path, options));\n            _context4.prev = 2;\n\n            _iterator17.s();\n\n          case 4:\n            if ((_step17 = _iterator17.n()).done) {\n              _context4.next = 12;\n              break;\n            }\n\n            p = _step17.value;\n            n = Node.ancestor(root, p);\n            entry = [n, p];\n            _context4.next = 10;\n            return entry;\n\n          case 10:\n            _context4.next = 4;\n            break;\n\n          case 12:\n            _context4.next = 17;\n            break;\n\n          case 14:\n            _context4.prev = 14;\n            _context4.t0 = _context4[\"catch\"](2);\n\n            _iterator17.e(_context4.t0);\n\n          case 17:\n            _context4.prev = 17;\n\n            _iterator17.f();\n\n            return _context4.finish(17);\n\n          case 20:\n          case \"end\":\n            return _context4.stop();\n        }\n      }\n    }, ancestors, null, [[2, 14, 17, 20]]);\n  }),\n\n  /**\r\n   * Get the child of a node at a specific index.\r\n   */\n  child: function child(root, index) {\n    if (Text.isText(root)) {\n      throw new Error(\"Cannot get the child of a text node: \".concat(JSON.stringify(root)));\n    }\n\n    var c = root.children[index];\n\n    if (c == null) {\n      throw new Error(\"Cannot get child at index `\".concat(index, \"` in node: \").concat(JSON.stringify(root)));\n    }\n\n    return c;\n  },\n\n  /**\r\n   * Iterate over the children of a node at a specific path.\r\n   */\n  children: /*#__PURE__*/_regeneratorRuntime.mark(function children(root, path) {\n    var options,\n        _options$reverse4,\n        reverse,\n        ancestor,\n        children,\n        index,\n        child,\n        childPath,\n        _args5 = arguments;\n\n    return _regeneratorRuntime.wrap(function children$(_context5) {\n      while (1) {\n        switch (_context5.prev = _context5.next) {\n          case 0:\n            options = _args5.length > 2 && _args5[2] !== undefined ? _args5[2] : {};\n            _options$reverse4 = options.reverse, reverse = _options$reverse4 === void 0 ? false : _options$reverse4;\n            ancestor = Node.ancestor(root, path);\n            children = ancestor.children;\n            index = reverse ? children.length - 1 : 0;\n\n          case 5:\n            if (!(reverse ? index >= 0 : index < children.length)) {\n              _context5.next = 13;\n              break;\n            }\n\n            child = Node.child(ancestor, index);\n            childPath = path.concat(index);\n            _context5.next = 10;\n            return [child, childPath];\n\n          case 10:\n            index = reverse ? index - 1 : index + 1;\n            _context5.next = 5;\n            break;\n\n          case 13:\n          case \"end\":\n            return _context5.stop();\n        }\n      }\n    }, children);\n  }),\n\n  /**\r\n   * Get an entry for the common ancesetor node of two paths.\r\n   */\n  common: function common(root, path, another) {\n    var p = Path.common(path, another);\n    var n = Node.get(root, p);\n    return [n, p];\n  },\n\n  /**\r\n   * Get the node at a specific path, asserting that it's a descendant node.\r\n   */\n  descendant: function descendant(root, path) {\n    var node = Node.get(root, path);\n\n    if (Editor.isEditor(node)) {\n      throw new Error(\"Cannot get the descendant node at path [\".concat(path, \"] because it refers to the root editor node instead: \").concat(node));\n    }\n\n    return node;\n  },\n\n  /**\r\n   * Return a generator of all the descendant node entries inside a root node.\r\n   */\n  descendants: /*#__PURE__*/_regeneratorRuntime.mark(function descendants(root) {\n    var options,\n        _iterator18,\n        _step18,\n        _step18$value,\n        node,\n        path,\n        _args6 = arguments;\n\n    return _regeneratorRuntime.wrap(function descendants$(_context6) {\n      while (1) {\n        switch (_context6.prev = _context6.next) {\n          case 0:\n            options = _args6.length > 1 && _args6[1] !== undefined ? _args6[1] : {};\n            _iterator18 = _createForOfIteratorHelper(Node.nodes(root, options));\n            _context6.prev = 2;\n\n            _iterator18.s();\n\n          case 4:\n            if ((_step18 = _iterator18.n()).done) {\n              _context6.next = 11;\n              break;\n            }\n\n            _step18$value = _slicedToArray(_step18.value, 2), node = _step18$value[0], path = _step18$value[1];\n\n            if (!(path.length !== 0)) {\n              _context6.next = 9;\n              break;\n            }\n\n            _context6.next = 9;\n            return [node, path];\n\n          case 9:\n            _context6.next = 4;\n            break;\n\n          case 11:\n            _context6.next = 16;\n            break;\n\n          case 13:\n            _context6.prev = 13;\n            _context6.t0 = _context6[\"catch\"](2);\n\n            _iterator18.e(_context6.t0);\n\n          case 16:\n            _context6.prev = 16;\n\n            _iterator18.f();\n\n            return _context6.finish(16);\n\n          case 19:\n          case \"end\":\n            return _context6.stop();\n        }\n      }\n    }, descendants, null, [[2, 13, 16, 19]]);\n  }),\n\n  /**\r\n   * Return a generator of all the element nodes inside a root node. Each iteration\r\n   * will return an `ElementEntry` tuple consisting of `[Element, Path]`. If the\r\n   * root node is an element it will be included in the iteration as well.\r\n   */\n  elements: /*#__PURE__*/_regeneratorRuntime.mark(function elements(root) {\n    var options,\n        _iterator19,\n        _step19,\n        _step19$value,\n        node,\n        path,\n        _args7 = arguments;\n\n    return _regeneratorRuntime.wrap(function elements$(_context7) {\n      while (1) {\n        switch (_context7.prev = _context7.next) {\n          case 0:\n            options = _args7.length > 1 && _args7[1] !== undefined ? _args7[1] : {};\n            _iterator19 = _createForOfIteratorHelper(Node.nodes(root, options));\n            _context7.prev = 2;\n\n            _iterator19.s();\n\n          case 4:\n            if ((_step19 = _iterator19.n()).done) {\n              _context7.next = 11;\n              break;\n            }\n\n            _step19$value = _slicedToArray(_step19.value, 2), node = _step19$value[0], path = _step19$value[1];\n\n            if (!Element.isElement(node)) {\n              _context7.next = 9;\n              break;\n            }\n\n            _context7.next = 9;\n            return [node, path];\n\n          case 9:\n            _context7.next = 4;\n            break;\n\n          case 11:\n            _context7.next = 16;\n            break;\n\n          case 13:\n            _context7.prev = 13;\n            _context7.t0 = _context7[\"catch\"](2);\n\n            _iterator19.e(_context7.t0);\n\n          case 16:\n            _context7.prev = 16;\n\n            _iterator19.f();\n\n            return _context7.finish(16);\n\n          case 19:\n          case \"end\":\n            return _context7.stop();\n        }\n      }\n    }, elements, null, [[2, 13, 16, 19]]);\n  }),\n\n  /**\r\n   * Extract props from a Node.\r\n   */\n  extractProps: function extractProps(node) {\n    if (Element.isAncestor(node)) {\n      var properties = _objectWithoutProperties(node, [\"children\"]);\n\n      return properties;\n    } else {\n      var properties = _objectWithoutProperties(node, [\"text\"]);\n\n      return properties;\n    }\n  },\n\n  /**\r\n   * Get the first node entry in a root node from a path.\r\n   */\n  first: function first(root, path) {\n    var p = path.slice();\n    var n = Node.get(root, p);\n\n    while (n) {\n      if (Text.isText(n) || n.children.length === 0) {\n        break;\n      } else {\n        n = n.children[0];\n        p.push(0);\n      }\n    }\n\n    return [n, p];\n  },\n\n  /**\r\n   * Get the sliced fragment represented by a range inside a root node.\r\n   */\n  fragment: function fragment(root, range) {\n    if (Text.isText(root)) {\n      throw new Error(\"Cannot get a fragment starting from a root text node: \".concat(JSON.stringify(root)));\n    }\n\n    var newRoot = produce({\n      children: root.children\n    }, function (r) {\n      var _Range$edges9 = Range.edges(range),\n          _Range$edges10 = _slicedToArray(_Range$edges9, 2),\n          start = _Range$edges10[0],\n          end = _Range$edges10[1];\n\n      var nodeEntries = Node.nodes(r, {\n        reverse: true,\n        pass: function pass(_ref) {\n          var _ref9 = _slicedToArray(_ref, 2),\n              path = _ref9[1];\n\n          return !Range.includes(range, path);\n        }\n      });\n\n      var _iterator20 = _createForOfIteratorHelper(nodeEntries),\n          _step20;\n\n      try {\n        for (_iterator20.s(); !(_step20 = _iterator20.n()).done;) {\n          var _step20$value = _slicedToArray(_step20.value, 2),\n              path = _step20$value[1];\n\n          if (!Range.includes(range, path)) {\n            var parent = Node.parent(r, path);\n            var index = path[path.length - 1];\n            parent.children.splice(index, 1);\n          }\n\n          if (Path.equals(path, end.path)) {\n            var leaf = Node.leaf(r, path);\n            leaf.text = leaf.text.slice(0, end.offset);\n          }\n\n          if (Path.equals(path, start.path)) {\n            var _leaf = Node.leaf(r, path);\n\n            _leaf.text = _leaf.text.slice(start.offset);\n          }\n        }\n      } catch (err) {\n        _iterator20.e(err);\n      } finally {\n        _iterator20.f();\n      }\n\n      if (Editor.isEditor(r)) {\n        r.selection = null;\n      }\n    });\n    return newRoot.children;\n  },\n\n  /**\r\n   * Get the descendant node referred to by a specific path. If the path is an\r\n   * empty array, it refers to the root node itself.\r\n   */\n  get: function get(root, path) {\n    var node = root;\n\n    for (var i = 0; i < path.length; i++) {\n      var p = path[i];\n\n      if (Text.isText(node) || !node.children[p]) {\n        throw new Error(\"Cannot find a descendant at path [\".concat(path, \"] in node: \").concat(JSON.stringify(root)));\n      }\n\n      node = node.children[p];\n    }\n\n    return node;\n  },\n\n  /**\r\n   * Check if a descendant node exists at a specific path.\r\n   */\n  has: function has(root, path) {\n    var node = root;\n\n    for (var i = 0; i < path.length; i++) {\n      var p = path[i];\n\n      if (Text.isText(node) || !node.children[p]) {\n        return false;\n      }\n\n      node = node.children[p];\n    }\n\n    return true;\n  },\n\n  /**\r\n   * Check if a value implements the `Node` interface.\r\n   */\n  isNode: function isNode(value) {\n    return Text.isText(value) || Element.isElement(value) || Editor.isEditor(value);\n  },\n\n  /**\r\n   * Check if a value is a list of `Node` objects.\r\n   */\n  isNodeList: function isNodeList(value) {\n    if (!Array.isArray(value)) {\n      return false;\n    }\n\n    var cachedResult = IS_NODE_LIST_CACHE.get(value);\n\n    if (cachedResult !== undefined) {\n      return cachedResult;\n    }\n\n    var isNodeList = value.every(function (val) {\n      return Node.isNode(val);\n    });\n    IS_NODE_LIST_CACHE.set(value, isNodeList);\n    return isNodeList;\n  },\n\n  /**\r\n   * Get the last node entry in a root node from a path.\r\n   */\n  last: function last(root, path) {\n    var p = path.slice();\n    var n = Node.get(root, p);\n\n    while (n) {\n      if (Text.isText(n) || n.children.length === 0) {\n        break;\n      } else {\n        var i = n.children.length - 1;\n        n = n.children[i];\n        p.push(i);\n      }\n    }\n\n    return [n, p];\n  },\n\n  /**\r\n   * Get the node at a specific path, ensuring it's a leaf text node.\r\n   */\n  leaf: function leaf(root, path) {\n    var node = Node.get(root, path);\n\n    if (!Text.isText(node)) {\n      throw new Error(\"Cannot get the leaf node at path [\".concat(path, \"] because it refers to a non-leaf node: \").concat(node));\n    }\n\n    return node;\n  },\n\n  /**\r\n   * Return a generator of the in a branch of the tree, from a specific path.\r\n   *\r\n   * By default the order is top-down, from lowest to highest node in the tree,\r\n   * but you can pass the `reverse: true` option to go bottom-up.\r\n   */\n  levels: /*#__PURE__*/_regeneratorRuntime.mark(function levels(root, path) {\n    var options,\n        _iterator21,\n        _step21,\n        p,\n        n,\n        _args8 = arguments;\n\n    return _regeneratorRuntime.wrap(function levels$(_context8) {\n      while (1) {\n        switch (_context8.prev = _context8.next) {\n          case 0:\n            options = _args8.length > 2 && _args8[2] !== undefined ? _args8[2] : {};\n            _iterator21 = _createForOfIteratorHelper(Path.levels(path, options));\n            _context8.prev = 2;\n\n            _iterator21.s();\n\n          case 4:\n            if ((_step21 = _iterator21.n()).done) {\n              _context8.next = 11;\n              break;\n            }\n\n            p = _step21.value;\n            n = Node.get(root, p);\n            _context8.next = 9;\n            return [n, p];\n\n          case 9:\n            _context8.next = 4;\n            break;\n\n          case 11:\n            _context8.next = 16;\n            break;\n\n          case 13:\n            _context8.prev = 13;\n            _context8.t0 = _context8[\"catch\"](2);\n\n            _iterator21.e(_context8.t0);\n\n          case 16:\n            _context8.prev = 16;\n\n            _iterator21.f();\n\n            return _context8.finish(16);\n\n          case 19:\n          case \"end\":\n            return _context8.stop();\n        }\n      }\n    }, levels, null, [[2, 13, 16, 19]]);\n  }),\n\n  /**\r\n   * Check if a node matches a set of props.\r\n   */\n  matches: function matches(node, props) {\n    return Element.isElement(node) && Element.isElementProps(props) && Element.matches(node, props) || Text.isText(node) && Text.isTextProps(props) && Text.matches(node, props);\n  },\n\n  /**\r\n   * Return a generator of all the node entries of a root node. Each entry is\r\n   * returned as a `[Node, Path]` tuple, with the path referring to the node's\r\n   * position inside the root node.\r\n   */\n  nodes: /*#__PURE__*/_regeneratorRuntime.mark(function nodes(root) {\n    var options,\n        pass,\n        _options$reverse5,\n        reverse,\n        _options$from,\n        from,\n        to,\n        visited,\n        p,\n        n,\n        nextIndex,\n        newPath,\n        _newPath,\n        _args9 = arguments;\n\n    return _regeneratorRuntime.wrap(function nodes$(_context9) {\n      while (1) {\n        switch (_context9.prev = _context9.next) {\n          case 0:\n            options = _args9.length > 1 && _args9[1] !== undefined ? _args9[1] : {};\n            pass = options.pass, _options$reverse5 = options.reverse, reverse = _options$reverse5 === void 0 ? false : _options$reverse5;\n            _options$from = options.from, from = _options$from === void 0 ? [] : _options$from, to = options.to;\n            visited = new Set();\n            p = [];\n            n = root;\n\n          case 6:\n            if (!true) {\n              _context9.next = 37;\n              break;\n            }\n\n            if (!(to && (reverse ? Path.isBefore(p, to) : Path.isAfter(p, to)))) {\n              _context9.next = 9;\n              break;\n            }\n\n            return _context9.abrupt(\"break\", 37);\n\n          case 9:\n            if (visited.has(n)) {\n              _context9.next = 12;\n              break;\n            }\n\n            _context9.next = 12;\n            return [n, p];\n\n          case 12:\n            if (!(!visited.has(n) && !Text.isText(n) && n.children.length !== 0 && (pass == null || pass([n, p]) === false))) {\n              _context9.next = 19;\n              break;\n            }\n\n            visited.add(n);\n            nextIndex = reverse ? n.children.length - 1 : 0;\n\n            if (Path.isAncestor(p, from)) {\n              nextIndex = from[p.length];\n            }\n\n            p = p.concat(nextIndex);\n            n = Node.get(root, p);\n            return _context9.abrupt(\"continue\", 6);\n\n          case 19:\n            if (!(p.length === 0)) {\n              _context9.next = 21;\n              break;\n            }\n\n            return _context9.abrupt(\"break\", 37);\n\n          case 21:\n            if (reverse) {\n              _context9.next = 27;\n              break;\n            }\n\n            newPath = Path.next(p);\n\n            if (!Node.has(root, newPath)) {\n              _context9.next = 27;\n              break;\n            }\n\n            p = newPath;\n            n = Node.get(root, p);\n            return _context9.abrupt(\"continue\", 6);\n\n          case 27:\n            if (!(reverse && p[p.length - 1] !== 0)) {\n              _context9.next = 32;\n              break;\n            }\n\n            _newPath = Path.previous(p);\n            p = _newPath;\n            n = Node.get(root, p);\n            return _context9.abrupt(\"continue\", 6);\n\n          case 32:\n            // Otherwise we're going upward...\n            p = Path.parent(p);\n            n = Node.get(root, p);\n            visited.add(n);\n            _context9.next = 6;\n            break;\n\n          case 37:\n          case \"end\":\n            return _context9.stop();\n        }\n      }\n    }, nodes);\n  }),\n\n  /**\r\n   * Get the parent of a node at a specific path.\r\n   */\n  parent: function parent(root, path) {\n    var parentPath = Path.parent(path);\n    var p = Node.get(root, parentPath);\n\n    if (Text.isText(p)) {\n      throw new Error(\"Cannot get the parent of path [\".concat(path, \"] because it does not exist in the root.\"));\n    }\n\n    return p;\n  },\n\n  /**\r\n   * Get the concatenated text string of a node's content.\r\n   *\r\n   * Note that this will not include spaces or line breaks between block nodes.\r\n   * It is not a user-facing string, but a string for performing offset-related\r\n   * computations for a node.\r\n   */\n  string: function string(node) {\n    if (Text.isText(node)) {\n      return node.text;\n    } else {\n      return node.children.map(Node.string).join('');\n    }\n  },\n\n  /**\r\n   * Return a generator of all leaf text nodes in a root node.\r\n   */\n  texts: /*#__PURE__*/_regeneratorRuntime.mark(function texts(root) {\n    var options,\n        _iterator22,\n        _step22,\n        _step22$value,\n        node,\n        path,\n        _args10 = arguments;\n\n    return _regeneratorRuntime.wrap(function texts$(_context10) {\n      while (1) {\n        switch (_context10.prev = _context10.next) {\n          case 0:\n            options = _args10.length > 1 && _args10[1] !== undefined ? _args10[1] : {};\n            _iterator22 = _createForOfIteratorHelper(Node.nodes(root, options));\n            _context10.prev = 2;\n\n            _iterator22.s();\n\n          case 4:\n            if ((_step22 = _iterator22.n()).done) {\n              _context10.next = 11;\n              break;\n            }\n\n            _step22$value = _slicedToArray(_step22.value, 2), node = _step22$value[0], path = _step22$value[1];\n\n            if (!Text.isText(node)) {\n              _context10.next = 9;\n              break;\n            }\n\n            _context10.next = 9;\n            return [node, path];\n\n          case 9:\n            _context10.next = 4;\n            break;\n\n          case 11:\n            _context10.next = 16;\n            break;\n\n          case 13:\n            _context10.prev = 13;\n            _context10.t0 = _context10[\"catch\"](2);\n\n            _iterator22.e(_context10.t0);\n\n          case 16:\n            _context10.prev = 16;\n\n            _iterator22.f();\n\n            return _context10.finish(16);\n\n          case 19:\n          case \"end\":\n            return _context10.stop();\n        }\n      }\n    }, texts, null, [[2, 13, 16, 19]]);\n  })\n};\n\nfunction ownKeys$2(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread$2(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys$2(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys$2(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nvar Operation = {\n  /**\r\n   * Check of a value is a `NodeOperation` object.\r\n   */\n  isNodeOperation: function isNodeOperation(value) {\n    return Operation.isOperation(value) && value.type.endsWith('_node');\n  },\n\n  /**\r\n   * Check of a value is an `Operation` object.\r\n   */\n  isOperation: function isOperation(value) {\n    if (!isPlainObject(value)) {\n      return false;\n    }\n\n    switch (value.type) {\n      case 'insert_node':\n        return Path.isPath(value.path) && Node.isNode(value.node);\n\n      case 'insert_text':\n        return typeof value.offset === 'number' && typeof value.text === 'string' && Path.isPath(value.path);\n\n      case 'merge_node':\n        return typeof value.position === 'number' && Path.isPath(value.path) && isPlainObject(value.properties);\n\n      case 'move_node':\n        return Path.isPath(value.path) && Path.isPath(value.newPath);\n\n      case 'remove_node':\n        return Path.isPath(value.path) && Node.isNode(value.node);\n\n      case 'remove_text':\n        return typeof value.offset === 'number' && typeof value.text === 'string' && Path.isPath(value.path);\n\n      case 'set_node':\n        return Path.isPath(value.path) && isPlainObject(value.properties) && isPlainObject(value.newProperties);\n\n      case 'set_selection':\n        return value.properties === null && Range.isRange(value.newProperties) || value.newProperties === null && Range.isRange(value.properties) || isPlainObject(value.properties) && isPlainObject(value.newProperties);\n\n      case 'split_node':\n        return Path.isPath(value.path) && typeof value.position === 'number' && isPlainObject(value.properties);\n\n      default:\n        return false;\n    }\n  },\n\n  /**\r\n   * Check if a value is a list of `Operation` objects.\r\n   */\n  isOperationList: function isOperationList(value) {\n    return Array.isArray(value) && value.every(function (val) {\n      return Operation.isOperation(val);\n    });\n  },\n\n  /**\r\n   * Check of a value is a `SelectionOperation` object.\r\n   */\n  isSelectionOperation: function isSelectionOperation(value) {\n    return Operation.isOperation(value) && value.type.endsWith('_selection');\n  },\n\n  /**\r\n   * Check of a value is a `TextOperation` object.\r\n   */\n  isTextOperation: function isTextOperation(value) {\n    return Operation.isOperation(value) && value.type.endsWith('_text');\n  },\n\n  /**\r\n   * Invert an operation, returning a new operation that will exactly undo the\r\n   * original when applied.\r\n   */\n  inverse: function inverse(op) {\n    switch (op.type) {\n      case 'insert_node':\n        {\n          return _objectSpread$2(_objectSpread$2({}, op), {}, {\n            type: 'remove_node'\n          });\n        }\n\n      case 'insert_text':\n        {\n          return _objectSpread$2(_objectSpread$2({}, op), {}, {\n            type: 'remove_text'\n          });\n        }\n\n      case 'merge_node':\n        {\n          return _objectSpread$2(_objectSpread$2({}, op), {}, {\n            type: 'split_node',\n            path: Path.previous(op.path)\n          });\n        }\n\n      case 'move_node':\n        {\n          var newPath = op.newPath,\n              path = op.path; // PERF: in this case the move operation is a no-op anyways.\n\n          if (Path.equals(newPath, path)) {\n            return op;\n          } // If the move happens completely within a single parent the path and\n          // newPath are stable with respect to each other.\n\n\n          if (Path.isSibling(path, newPath)) {\n            return _objectSpread$2(_objectSpread$2({}, op), {}, {\n              path: newPath,\n              newPath: path\n            });\n          } // If the move does not happen within a single parent it is possible\n          // for the move to impact the true path to the location where the node\n          // was removed from and where it was inserted. We have to adjust for this\n          // and find the original path. We can accomplish this (only in non-sibling)\n          // moves by looking at the impact of the move operation on the node\n          // after the original move path.\n\n\n          var inversePath = Path.transform(path, op);\n          var inverseNewPath = Path.transform(Path.next(path), op);\n          return _objectSpread$2(_objectSpread$2({}, op), {}, {\n            path: inversePath,\n            newPath: inverseNewPath\n          });\n        }\n\n      case 'remove_node':\n        {\n          return _objectSpread$2(_objectSpread$2({}, op), {}, {\n            type: 'insert_node'\n          });\n        }\n\n      case 'remove_text':\n        {\n          return _objectSpread$2(_objectSpread$2({}, op), {}, {\n            type: 'insert_text'\n          });\n        }\n\n      case 'set_node':\n        {\n          var properties = op.properties,\n              newProperties = op.newProperties;\n          return _objectSpread$2(_objectSpread$2({}, op), {}, {\n            properties: newProperties,\n            newProperties: properties\n          });\n        }\n\n      case 'set_selection':\n        {\n          var _properties = op.properties,\n              _newProperties = op.newProperties;\n\n          if (_properties == null) {\n            return _objectSpread$2(_objectSpread$2({}, op), {}, {\n              properties: _newProperties,\n              newProperties: null\n            });\n          } else if (_newProperties == null) {\n            return _objectSpread$2(_objectSpread$2({}, op), {}, {\n              properties: null,\n              newProperties: _properties\n            });\n          } else {\n            return _objectSpread$2(_objectSpread$2({}, op), {}, {\n              properties: _newProperties,\n              newProperties: _properties\n            });\n          }\n        }\n\n      case 'split_node':\n        {\n          return _objectSpread$2(_objectSpread$2({}, op), {}, {\n            type: 'merge_node',\n            path: Path.next(op.path)\n          });\n        }\n    }\n  }\n};\nvar Path = {\n  /**\r\n   * Get a list of ancestor paths for a given path.\r\n   *\r\n   * The paths are sorted from deepest to shallowest ancestor. However, if the\r\n   * `reverse: true` option is passed, they are reversed.\r\n   */\n  ancestors: function ancestors(path) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var _options$reverse6 = options.reverse,\n        reverse = _options$reverse6 === void 0 ? false : _options$reverse6;\n    var paths = Path.levels(path, options);\n\n    if (reverse) {\n      paths = paths.slice(1);\n    } else {\n      paths = paths.slice(0, -1);\n    }\n\n    return paths;\n  },\n\n  /**\r\n   * Get the common ancestor path of two paths.\r\n   */\n  common: function common(path, another) {\n    var common = [];\n\n    for (var i = 0; i < path.length && i < another.length; i++) {\n      var av = path[i];\n      var bv = another[i];\n\n      if (av !== bv) {\n        break;\n      }\n\n      common.push(av);\n    }\n\n    return common;\n  },\n\n  /**\r\n   * Compare a path to another, returning an integer indicating whether the path\r\n   * was before, at, or after the other.\r\n   *\r\n   * Note: Two paths of unequal length can still receive a `0` result if one is\r\n   * directly above or below the other. If you want exact matching, use\r\n   * [[Path.equals]] instead.\r\n   */\n  compare: function compare(path, another) {\n    var min = Math.min(path.length, another.length);\n\n    for (var i = 0; i < min; i++) {\n      if (path[i] < another[i]) return -1;\n      if (path[i] > another[i]) return 1;\n    }\n\n    return 0;\n  },\n\n  /**\r\n   * Check if a path ends after one of the indexes in another.\r\n   */\n  endsAfter: function endsAfter(path, another) {\n    var i = path.length - 1;\n    var as = path.slice(0, i);\n    var bs = another.slice(0, i);\n    var av = path[i];\n    var bv = another[i];\n    return Path.equals(as, bs) && av > bv;\n  },\n\n  /**\r\n   * Check if a path ends at one of the indexes in another.\r\n   */\n  endsAt: function endsAt(path, another) {\n    var i = path.length;\n    var as = path.slice(0, i);\n    var bs = another.slice(0, i);\n    return Path.equals(as, bs);\n  },\n\n  /**\r\n   * Check if a path ends before one of the indexes in another.\r\n   */\n  endsBefore: function endsBefore(path, another) {\n    var i = path.length - 1;\n    var as = path.slice(0, i);\n    var bs = another.slice(0, i);\n    var av = path[i];\n    var bv = another[i];\n    return Path.equals(as, bs) && av < bv;\n  },\n\n  /**\r\n   * Check if a path is exactly equal to another.\r\n   */\n  equals: function equals(path, another) {\n    return path.length === another.length && path.every(function (n, i) {\n      return n === another[i];\n    });\n  },\n\n  /**\r\n   * Check if the path of previous sibling node exists\r\n   */\n  hasPrevious: function hasPrevious(path) {\n    return path[path.length - 1] > 0;\n  },\n\n  /**\r\n   * Check if a path is after another.\r\n   */\n  isAfter: function isAfter(path, another) {\n    return Path.compare(path, another) === 1;\n  },\n\n  /**\r\n   * Check if a path is an ancestor of another.\r\n   */\n  isAncestor: function isAncestor(path, another) {\n    return path.length < another.length && Path.compare(path, another) === 0;\n  },\n\n  /**\r\n   * Check if a path is before another.\r\n   */\n  isBefore: function isBefore(path, another) {\n    return Path.compare(path, another) === -1;\n  },\n\n  /**\r\n   * Check if a path is a child of another.\r\n   */\n  isChild: function isChild(path, another) {\n    return path.length === another.length + 1 && Path.compare(path, another) === 0;\n  },\n\n  /**\r\n   * Check if a path is equal to or an ancestor of another.\r\n   */\n  isCommon: function isCommon(path, another) {\n    return path.length <= another.length && Path.compare(path, another) === 0;\n  },\n\n  /**\r\n   * Check if a path is a descendant of another.\r\n   */\n  isDescendant: function isDescendant(path, another) {\n    return path.length > another.length && Path.compare(path, another) === 0;\n  },\n\n  /**\r\n   * Check if a path is the parent of another.\r\n   */\n  isParent: function isParent(path, another) {\n    return path.length + 1 === another.length && Path.compare(path, another) === 0;\n  },\n\n  /**\r\n   * Check is a value implements the `Path` interface.\r\n   */\n  isPath: function isPath(value) {\n    return Array.isArray(value) && (value.length === 0 || typeof value[0] === 'number');\n  },\n\n  /**\r\n   * Check if a path is a sibling of another.\r\n   */\n  isSibling: function isSibling(path, another) {\n    if (path.length !== another.length) {\n      return false;\n    }\n\n    var as = path.slice(0, -1);\n    var bs = another.slice(0, -1);\n    var al = path[path.length - 1];\n    var bl = another[another.length - 1];\n    return al !== bl && Path.equals(as, bs);\n  },\n\n  /**\r\n   * Get a list of paths at every level down to a path. Note: this is the same\r\n   * as `Path.ancestors`, but including the path itself.\r\n   *\r\n   * The paths are sorted from shallowest to deepest. However, if the `reverse:\r\n   * true` option is passed, they are reversed.\r\n   */\n  levels: function levels(path) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var _options$reverse7 = options.reverse,\n        reverse = _options$reverse7 === void 0 ? false : _options$reverse7;\n    var list = [];\n\n    for (var i = 0; i <= path.length; i++) {\n      list.push(path.slice(0, i));\n    }\n\n    if (reverse) {\n      list.reverse();\n    }\n\n    return list;\n  },\n\n  /**\r\n   * Given a path, get the path to the next sibling node.\r\n   */\n  next: function next(path) {\n    if (path.length === 0) {\n      throw new Error(\"Cannot get the next path of a root path [\".concat(path, \"], because it has no next index.\"));\n    }\n\n    var last = path[path.length - 1];\n    return path.slice(0, -1).concat(last + 1);\n  },\n\n  /**\r\n   * Given a path, return a new path referring to the parent node above it.\r\n   */\n  parent: function parent(path) {\n    if (path.length === 0) {\n      throw new Error(\"Cannot get the parent path of the root path [\".concat(path, \"].\"));\n    }\n\n    return path.slice(0, -1);\n  },\n\n  /**\r\n   * Given a path, get the path to the previous sibling node.\r\n   */\n  previous: function previous(path) {\n    if (path.length === 0) {\n      throw new Error(\"Cannot get the previous path of a root path [\".concat(path, \"], because it has no previous index.\"));\n    }\n\n    var last = path[path.length - 1];\n\n    if (last <= 0) {\n      throw new Error(\"Cannot get the previous path of a first child path [\".concat(path, \"] because it would result in a negative index.\"));\n    }\n\n    return path.slice(0, -1).concat(last - 1);\n  },\n\n  /**\r\n   * Get a path relative to an ancestor.\r\n   */\n  relative: function relative(path, ancestor) {\n    if (!Path.isAncestor(ancestor, path) && !Path.equals(path, ancestor)) {\n      throw new Error(\"Cannot get the relative path of [\".concat(path, \"] inside ancestor [\").concat(ancestor, \"], because it is not above or equal to the path.\"));\n    }\n\n    return path.slice(ancestor.length);\n  },\n\n  /**\r\n   * Transform a path by an operation.\r\n   */\n  transform: function transform(path, operation) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    return produce(path, function (p) {\n      var _options$affinity4 = options.affinity,\n          affinity = _options$affinity4 === void 0 ? 'forward' : _options$affinity4; // PERF: Exit early if the operation is guaranteed not to have an effect.\n\n      if (path.length === 0) {\n        return;\n      }\n\n      switch (operation.type) {\n        case 'insert_node':\n          {\n            var op = operation.path;\n\n            if (Path.equals(op, p) || Path.endsBefore(op, p) || Path.isAncestor(op, p)) {\n              p[op.length - 1] += 1;\n            }\n\n            break;\n          }\n\n        case 'remove_node':\n          {\n            var _op = operation.path;\n\n            if (Path.equals(_op, p) || Path.isAncestor(_op, p)) {\n              return null;\n            } else if (Path.endsBefore(_op, p)) {\n              p[_op.length - 1] -= 1;\n            }\n\n            break;\n          }\n\n        case 'merge_node':\n          {\n            var _op2 = operation.path,\n                position = operation.position;\n\n            if (Path.equals(_op2, p) || Path.endsBefore(_op2, p)) {\n              p[_op2.length - 1] -= 1;\n            } else if (Path.isAncestor(_op2, p)) {\n              p[_op2.length - 1] -= 1;\n              p[_op2.length] += position;\n            }\n\n            break;\n          }\n\n        case 'split_node':\n          {\n            var _op3 = operation.path,\n                _position = operation.position;\n\n            if (Path.equals(_op3, p)) {\n              if (affinity === 'forward') {\n                p[p.length - 1] += 1;\n              } else if (affinity === 'backward') ;else {\n                return null;\n              }\n            } else if (Path.endsBefore(_op3, p)) {\n              p[_op3.length - 1] += 1;\n            } else if (Path.isAncestor(_op3, p) && path[_op3.length] >= _position) {\n              p[_op3.length - 1] += 1;\n              p[_op3.length] -= _position;\n            }\n\n            break;\n          }\n\n        case 'move_node':\n          {\n            var _op4 = operation.path,\n                onp = operation.newPath; // If the old and new path are the same, it's a no-op.\n\n            if (Path.equals(_op4, onp)) {\n              return;\n            }\n\n            if (Path.isAncestor(_op4, p) || Path.equals(_op4, p)) {\n              var copy = onp.slice();\n\n              if (Path.endsBefore(_op4, onp) && _op4.length < onp.length) {\n                copy[_op4.length - 1] -= 1;\n              }\n\n              return copy.concat(p.slice(_op4.length));\n            } else if (Path.isSibling(_op4, onp) && (Path.isAncestor(onp, p) || Path.equals(onp, p))) {\n              if (Path.endsBefore(_op4, p)) {\n                p[_op4.length - 1] -= 1;\n              } else {\n                p[_op4.length - 1] += 1;\n              }\n            } else if (Path.endsBefore(onp, p) || Path.equals(onp, p) || Path.isAncestor(onp, p)) {\n              if (Path.endsBefore(_op4, p)) {\n                p[_op4.length - 1] -= 1;\n              }\n\n              p[onp.length - 1] += 1;\n            } else if (Path.endsBefore(_op4, p)) {\n              if (Path.equals(onp, p)) {\n                p[onp.length - 1] += 1;\n              }\n\n              p[_op4.length - 1] -= 1;\n            }\n\n            break;\n          }\n      }\n    });\n  }\n};\nvar PathRef = {\n  /**\r\n   * Transform the path ref's current value by an operation.\r\n   */\n  transform: function transform(ref, op) {\n    var current = ref.current,\n        affinity = ref.affinity;\n\n    if (current == null) {\n      return;\n    }\n\n    var path = Path.transform(current, op, {\n      affinity: affinity\n    });\n    ref.current = path;\n\n    if (path == null) {\n      ref.unref();\n    }\n  }\n};\n\nfunction ownKeys$3(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread$3(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys$3(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys$3(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nvar Point = {\n  /**\r\n   * Compare a point to another, returning an integer indicating whether the\r\n   * point was before, at, or after the other.\r\n   */\n  compare: function compare(point, another) {\n    var result = Path.compare(point.path, another.path);\n\n    if (result === 0) {\n      if (point.offset < another.offset) return -1;\n      if (point.offset > another.offset) return 1;\n      return 0;\n    }\n\n    return result;\n  },\n\n  /**\r\n   * Check if a point is after another.\r\n   */\n  isAfter: function isAfter(point, another) {\n    return Point.compare(point, another) === 1;\n  },\n\n  /**\r\n   * Check if a point is before another.\r\n   */\n  isBefore: function isBefore(point, another) {\n    return Point.compare(point, another) === -1;\n  },\n\n  /**\r\n   * Check if a point is exactly equal to another.\r\n   */\n  equals: function equals(point, another) {\n    // PERF: ensure the offsets are equal first since they are cheaper to check.\n    return point.offset === another.offset && Path.equals(point.path, another.path);\n  },\n\n  /**\r\n   * Check if a value implements the `Point` interface.\r\n   */\n  isPoint: function isPoint(value) {\n    return isPlainObject(value) && typeof value.offset === 'number' && Path.isPath(value.path);\n  },\n\n  /**\r\n   * Transform a point by an operation.\r\n   */\n  transform: function transform(point, op) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    return produce(point, function (p) {\n      var _options$affinity5 = options.affinity,\n          affinity = _options$affinity5 === void 0 ? 'forward' : _options$affinity5;\n      var path = p.path,\n          offset = p.offset;\n\n      switch (op.type) {\n        case 'insert_node':\n        case 'move_node':\n          {\n            p.path = Path.transform(path, op, options);\n            break;\n          }\n\n        case 'insert_text':\n          {\n            if (Path.equals(op.path, path) && op.offset <= offset) {\n              p.offset += op.text.length;\n            }\n\n            break;\n          }\n\n        case 'merge_node':\n          {\n            if (Path.equals(op.path, path)) {\n              p.offset += op.position;\n            }\n\n            p.path = Path.transform(path, op, options);\n            break;\n          }\n\n        case 'remove_text':\n          {\n            if (Path.equals(op.path, path) && op.offset <= offset) {\n              p.offset -= Math.min(offset - op.offset, op.text.length);\n            }\n\n            break;\n          }\n\n        case 'remove_node':\n          {\n            if (Path.equals(op.path, path) || Path.isAncestor(op.path, path)) {\n              return null;\n            }\n\n            p.path = Path.transform(path, op, options);\n            break;\n          }\n\n        case 'split_node':\n          {\n            if (Path.equals(op.path, path)) {\n              if (op.position === offset && affinity == null) {\n                return null;\n              } else if (op.position < offset || op.position === offset && affinity === 'forward') {\n                p.offset -= op.position;\n                p.path = Path.transform(path, op, _objectSpread$3(_objectSpread$3({}, options), {}, {\n                  affinity: 'forward'\n                }));\n              }\n            } else {\n              p.path = Path.transform(path, op, options);\n            }\n\n            break;\n          }\n      }\n    });\n  }\n};\nvar PointRef = {\n  /**\r\n   * Transform the point ref's current value by an operation.\r\n   */\n  transform: function transform(ref, op) {\n    var current = ref.current,\n        affinity = ref.affinity;\n\n    if (current == null) {\n      return;\n    }\n\n    var point = Point.transform(current, op, {\n      affinity: affinity\n    });\n    ref.current = point;\n\n    if (point == null) {\n      ref.unref();\n    }\n  }\n};\n\nfunction ownKeys$4(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread$4(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys$4(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys$4(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nvar Range = {\n  /**\r\n   * Get the start and end points of a range, in the order in which they appear\r\n   * in the document.\r\n   */\n  edges: function edges(range) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var _options$reverse8 = options.reverse,\n        reverse = _options$reverse8 === void 0 ? false : _options$reverse8;\n    var anchor = range.anchor,\n        focus = range.focus;\n    return Range.isBackward(range) === reverse ? [anchor, focus] : [focus, anchor];\n  },\n\n  /**\r\n   * Get the end point of a range.\r\n   */\n  end: function end(range) {\n    var _Range$edges11 = Range.edges(range),\n        _Range$edges12 = _slicedToArray(_Range$edges11, 2),\n        end = _Range$edges12[1];\n\n    return end;\n  },\n\n  /**\r\n   * Check if a range is exactly equal to another.\r\n   */\n  equals: function equals(range, another) {\n    return Point.equals(range.anchor, another.anchor) && Point.equals(range.focus, another.focus);\n  },\n\n  /**\r\n   * Check if a range includes a path, a point or part of another range.\r\n   */\n  includes: function includes(range, target) {\n    if (Range.isRange(target)) {\n      if (Range.includes(range, target.anchor) || Range.includes(range, target.focus)) {\n        return true;\n      }\n\n      var _Range$edges13 = Range.edges(range),\n          _Range$edges14 = _slicedToArray(_Range$edges13, 2),\n          rs = _Range$edges14[0],\n          re = _Range$edges14[1];\n\n      var _Range$edges15 = Range.edges(target),\n          _Range$edges16 = _slicedToArray(_Range$edges15, 2),\n          ts = _Range$edges16[0],\n          te = _Range$edges16[1];\n\n      return Point.isBefore(rs, ts) && Point.isAfter(re, te);\n    }\n\n    var _Range$edges17 = Range.edges(range),\n        _Range$edges18 = _slicedToArray(_Range$edges17, 2),\n        start = _Range$edges18[0],\n        end = _Range$edges18[1];\n\n    var isAfterStart = false;\n    var isBeforeEnd = false;\n\n    if (Point.isPoint(target)) {\n      isAfterStart = Point.compare(target, start) >= 0;\n      isBeforeEnd = Point.compare(target, end) <= 0;\n    } else {\n      isAfterStart = Path.compare(target, start.path) >= 0;\n      isBeforeEnd = Path.compare(target, end.path) <= 0;\n    }\n\n    return isAfterStart && isBeforeEnd;\n  },\n\n  /**\r\n   * Get the intersection of a range with another.\r\n   */\n  intersection: function intersection(range, another) {\n    var rest = _objectWithoutProperties(range, [\"anchor\", \"focus\"]);\n\n    var _Range$edges19 = Range.edges(range),\n        _Range$edges20 = _slicedToArray(_Range$edges19, 2),\n        s1 = _Range$edges20[0],\n        e1 = _Range$edges20[1];\n\n    var _Range$edges21 = Range.edges(another),\n        _Range$edges22 = _slicedToArray(_Range$edges21, 2),\n        s2 = _Range$edges22[0],\n        e2 = _Range$edges22[1];\n\n    var start = Point.isBefore(s1, s2) ? s2 : s1;\n    var end = Point.isBefore(e1, e2) ? e1 : e2;\n\n    if (Point.isBefore(end, start)) {\n      return null;\n    } else {\n      return _objectSpread$4({\n        anchor: start,\n        focus: end\n      }, rest);\n    }\n  },\n\n  /**\r\n   * Check if a range is backward, meaning that its anchor point appears in the\r\n   * document _after_ its focus point.\r\n   */\n  isBackward: function isBackward(range) {\n    var anchor = range.anchor,\n        focus = range.focus;\n    return Point.isAfter(anchor, focus);\n  },\n\n  /**\r\n   * Check if a range is collapsed, meaning that both its anchor and focus\r\n   * points refer to the exact same position in the document.\r\n   */\n  isCollapsed: function isCollapsed(range) {\n    var anchor = range.anchor,\n        focus = range.focus;\n    return Point.equals(anchor, focus);\n  },\n\n  /**\r\n   * Check if a range is expanded.\r\n   *\r\n   * This is the opposite of [[Range.isCollapsed]] and is provided for legibility.\r\n   */\n  isExpanded: function isExpanded(range) {\n    return !Range.isCollapsed(range);\n  },\n\n  /**\r\n   * Check if a range is forward.\r\n   *\r\n   * This is the opposite of [[Range.isBackward]] and is provided for legibility.\r\n   */\n  isForward: function isForward(range) {\n    return !Range.isBackward(range);\n  },\n\n  /**\r\n   * Check if a value implements the [[Range]] interface.\r\n   */\n  isRange: function isRange(value) {\n    return isPlainObject(value) && Point.isPoint(value.anchor) && Point.isPoint(value.focus);\n  },\n\n  /**\r\n   * Iterate through all of the point entries in a range.\r\n   */\n  points: /*#__PURE__*/_regeneratorRuntime.mark(function points(range) {\n    return _regeneratorRuntime.wrap(function points$(_context11) {\n      while (1) {\n        switch (_context11.prev = _context11.next) {\n          case 0:\n            _context11.next = 2;\n            return [range.anchor, 'anchor'];\n\n          case 2:\n            _context11.next = 4;\n            return [range.focus, 'focus'];\n\n          case 4:\n          case \"end\":\n            return _context11.stop();\n        }\n      }\n    }, points);\n  }),\n\n  /**\r\n   * Get the start point of a range.\r\n   */\n  start: function start(range) {\n    var _Range$edges23 = Range.edges(range),\n        _Range$edges24 = _slicedToArray(_Range$edges23, 1),\n        start = _Range$edges24[0];\n\n    return start;\n  },\n\n  /**\r\n   * Transform a range by an operation.\r\n   */\n  transform: function transform(range, op) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var _options$affinity6 = options.affinity,\n        affinity = _options$affinity6 === void 0 ? 'inward' : _options$affinity6;\n    var affinityAnchor;\n    var affinityFocus;\n\n    if (affinity === 'inward') {\n      if (Range.isForward(range)) {\n        affinityAnchor = 'forward';\n        affinityFocus = 'backward';\n      } else {\n        affinityAnchor = 'backward';\n        affinityFocus = 'forward';\n      }\n    } else if (affinity === 'outward') {\n      if (Range.isForward(range)) {\n        affinityAnchor = 'backward';\n        affinityFocus = 'forward';\n      } else {\n        affinityAnchor = 'forward';\n        affinityFocus = 'backward';\n      }\n    } else {\n      affinityAnchor = affinity;\n      affinityFocus = affinity;\n    }\n\n    return produce(range, function (r) {\n      var anchor = Point.transform(r.anchor, op, {\n        affinity: affinityAnchor\n      });\n      var focus = Point.transform(r.focus, op, {\n        affinity: affinityFocus\n      });\n\n      if (!anchor || !focus) {\n        return null;\n      }\n\n      r.anchor = anchor;\n      r.focus = focus;\n    });\n  }\n};\nvar RangeRef = {\n  /**\r\n   * Transform the range ref's current value by an operation.\r\n   */\n  transform: function transform(ref, op) {\n    var current = ref.current,\n        affinity = ref.affinity;\n\n    if (current == null) {\n      return;\n    }\n\n    var path = Range.transform(current, op, {\n      affinity: affinity\n    });\n    ref.current = path;\n\n    if (path == null) {\n      ref.unref();\n    }\n  }\n};\n\nfunction ownKeys$5(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread$5(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys$5(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys$5(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nvar Text = {\n  /**\r\n   * Check if two text nodes are equal.\r\n   */\n  equals: function equals(text, another) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var _options$loose = options.loose,\n        loose = _options$loose === void 0 ? false : _options$loose;\n\n    function omitText(obj) {\n      var rest = _objectWithoutProperties(obj, [\"text\"]);\n\n      return rest;\n    }\n\n    return isEqual(loose ? omitText(text) : text, loose ? omitText(another) : another);\n  },\n\n  /**\r\n   * Check if a value implements the `Text` interface.\r\n   */\n  isText: function isText(value) {\n    return isPlainObject(value) && typeof value.text === 'string';\n  },\n\n  /**\r\n   * Check if a value is a list of `Text` objects.\r\n   */\n  isTextList: function isTextList(value) {\n    return Array.isArray(value) && value.every(function (val) {\n      return Text.isText(val);\n    });\n  },\n\n  /**\r\n   * Check if some props are a partial of Text.\r\n   */\n  isTextProps: function isTextProps(props) {\n    return props.text !== undefined;\n  },\n\n  /**\r\n   * Check if an text matches set of properties.\r\n   *\r\n   * Note: this is for matching custom properties, and it does not ensure that\r\n   * the `text` property are two nodes equal.\r\n   */\n  matches: function matches(text, props) {\n    for (var key in props) {\n      if (key === 'text') {\n        continue;\n      }\n\n      if (!text.hasOwnProperty(key) || text[key] !== props[key]) {\n        return false;\n      }\n    }\n\n    return true;\n  },\n\n  /**\r\n   * Get the leaves for a text node given decorations.\r\n   */\n  decorations: function decorations(node, _decorations) {\n    var leaves = [_objectSpread$5({}, node)];\n\n    var _iterator23 = _createForOfIteratorHelper(_decorations),\n        _step23;\n\n    try {\n      for (_iterator23.s(); !(_step23 = _iterator23.n()).done;) {\n        var dec = _step23.value;\n\n        var rest = _objectWithoutProperties(dec, [\"anchor\", \"focus\"]);\n\n        var _Range$edges25 = Range.edges(dec),\n            _Range$edges26 = _slicedToArray(_Range$edges25, 2),\n            start = _Range$edges26[0],\n            end = _Range$edges26[1];\n\n        var next = [];\n        var o = 0;\n\n        var _iterator24 = _createForOfIteratorHelper(leaves),\n            _step24;\n\n        try {\n          for (_iterator24.s(); !(_step24 = _iterator24.n()).done;) {\n            var leaf = _step24.value;\n            var length = leaf.text.length;\n            var offset = o;\n            o += length; // If the range encompases the entire leaf, add the range.\n\n            if (start.offset <= offset && end.offset >= o) {\n              Object.assign(leaf, rest);\n              next.push(leaf);\n              continue;\n            } // If the range expanded and match the leaf, or starts after, or ends before it, continue.\n\n\n            if (start.offset !== end.offset && (start.offset === o || end.offset === offset) || start.offset > o || end.offset < offset || end.offset === offset && offset !== 0) {\n              next.push(leaf);\n              continue;\n            } // Otherwise we need to split the leaf, at the start, end, or both,\n            // and add the range to the middle intersecting section. Do the end\n            // split first since we don't need to update the offset that way.\n\n\n            var middle = leaf;\n            var before = void 0;\n            var after = void 0;\n\n            if (end.offset < o) {\n              var off = end.offset - offset;\n              after = _objectSpread$5(_objectSpread$5({}, middle), {}, {\n                text: middle.text.slice(off)\n              });\n              middle = _objectSpread$5(_objectSpread$5({}, middle), {}, {\n                text: middle.text.slice(0, off)\n              });\n            }\n\n            if (start.offset > offset) {\n              var _off = start.offset - offset;\n\n              before = _objectSpread$5(_objectSpread$5({}, middle), {}, {\n                text: middle.text.slice(0, _off)\n              });\n              middle = _objectSpread$5(_objectSpread$5({}, middle), {}, {\n                text: middle.text.slice(_off)\n              });\n            }\n\n            Object.assign(middle, rest);\n\n            if (before) {\n              next.push(before);\n            }\n\n            next.push(middle);\n\n            if (after) {\n              next.push(after);\n            }\n          }\n        } catch (err) {\n          _iterator24.e(err);\n        } finally {\n          _iterator24.f();\n        }\n\n        leaves = next;\n      }\n    } catch (err) {\n      _iterator23.e(err);\n    } finally {\n      _iterator23.f();\n    }\n\n    return leaves;\n  }\n};\n\nfunction ownKeys$6(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread$6(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys$6(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys$6(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nvar applyToDraft = function applyToDraft(editor, selection, op) {\n  switch (op.type) {\n    case 'insert_node':\n      {\n        var path = op.path,\n            node = op.node;\n        var parent = Node.parent(editor, path);\n        var index = path[path.length - 1];\n\n        if (index > parent.children.length) {\n          throw new Error(\"Cannot apply an \\\"insert_node\\\" operation at path [\".concat(path, \"] because the destination is past the end of the node.\"));\n        }\n\n        parent.children.splice(index, 0, node);\n\n        if (selection) {\n          var _iterator25 = _createForOfIteratorHelper(Range.points(selection)),\n              _step25;\n\n          try {\n            for (_iterator25.s(); !(_step25 = _iterator25.n()).done;) {\n              var _step25$value = _slicedToArray(_step25.value, 2),\n                  point = _step25$value[0],\n                  key = _step25$value[1];\n\n              selection[key] = Point.transform(point, op);\n            }\n          } catch (err) {\n            _iterator25.e(err);\n          } finally {\n            _iterator25.f();\n          }\n        }\n\n        break;\n      }\n\n    case 'insert_text':\n      {\n        var _path = op.path,\n            offset = op.offset,\n            text = op.text;\n        if (text.length === 0) break;\n\n        var _node = Node.leaf(editor, _path);\n\n        var before = _node.text.slice(0, offset);\n\n        var after = _node.text.slice(offset);\n\n        _node.text = before + text + after;\n\n        if (selection) {\n          var _iterator26 = _createForOfIteratorHelper(Range.points(selection)),\n              _step26;\n\n          try {\n            for (_iterator26.s(); !(_step26 = _iterator26.n()).done;) {\n              var _step26$value = _slicedToArray(_step26.value, 2),\n                  _point = _step26$value[0],\n                  _key = _step26$value[1];\n\n              selection[_key] = Point.transform(_point, op);\n            }\n          } catch (err) {\n            _iterator26.e(err);\n          } finally {\n            _iterator26.f();\n          }\n        }\n\n        break;\n      }\n\n    case 'merge_node':\n      {\n        var _path2 = op.path;\n\n        var _node2 = Node.get(editor, _path2);\n\n        var prevPath = Path.previous(_path2);\n        var prev = Node.get(editor, prevPath);\n\n        var _parent = Node.parent(editor, _path2);\n\n        var _index = _path2[_path2.length - 1];\n\n        if (Text.isText(_node2) && Text.isText(prev)) {\n          prev.text += _node2.text;\n        } else if (!Text.isText(_node2) && !Text.isText(prev)) {\n          var _prev$children;\n\n          (_prev$children = prev.children).push.apply(_prev$children, _toConsumableArray(_node2.children));\n        } else {\n          throw new Error(\"Cannot apply a \\\"merge_node\\\" operation at path [\".concat(_path2, \"] to nodes of different interfaces: \").concat(_node2, \" \").concat(prev));\n        }\n\n        _parent.children.splice(_index, 1);\n\n        if (selection) {\n          var _iterator27 = _createForOfIteratorHelper(Range.points(selection)),\n              _step27;\n\n          try {\n            for (_iterator27.s(); !(_step27 = _iterator27.n()).done;) {\n              var _step27$value = _slicedToArray(_step27.value, 2),\n                  _point2 = _step27$value[0],\n                  _key2 = _step27$value[1];\n\n              selection[_key2] = Point.transform(_point2, op);\n            }\n          } catch (err) {\n            _iterator27.e(err);\n          } finally {\n            _iterator27.f();\n          }\n        }\n\n        break;\n      }\n\n    case 'move_node':\n      {\n        var _path3 = op.path,\n            newPath = op.newPath;\n\n        if (Path.isAncestor(_path3, newPath)) {\n          throw new Error(\"Cannot move a path [\".concat(_path3, \"] to new path [\").concat(newPath, \"] because the destination is inside itself.\"));\n        }\n\n        var _node3 = Node.get(editor, _path3);\n\n        var _parent2 = Node.parent(editor, _path3);\n\n        var _index2 = _path3[_path3.length - 1]; // This is tricky, but since the `path` and `newPath` both refer to\n        // the same snapshot in time, there's a mismatch. After either\n        // removing the original position, the second step's path can be out\n        // of date. So instead of using the `op.newPath` directly, we\n        // transform `op.path` to ascertain what the `newPath` would be after\n        // the operation was applied.\n\n        _parent2.children.splice(_index2, 1);\n\n        var truePath = Path.transform(_path3, op);\n        var newParent = Node.get(editor, Path.parent(truePath));\n        var newIndex = truePath[truePath.length - 1];\n        newParent.children.splice(newIndex, 0, _node3);\n\n        if (selection) {\n          var _iterator28 = _createForOfIteratorHelper(Range.points(selection)),\n              _step28;\n\n          try {\n            for (_iterator28.s(); !(_step28 = _iterator28.n()).done;) {\n              var _step28$value = _slicedToArray(_step28.value, 2),\n                  _point3 = _step28$value[0],\n                  _key3 = _step28$value[1];\n\n              selection[_key3] = Point.transform(_point3, op);\n            }\n          } catch (err) {\n            _iterator28.e(err);\n          } finally {\n            _iterator28.f();\n          }\n        }\n\n        break;\n      }\n\n    case 'remove_node':\n      {\n        var _path4 = op.path;\n        var _index3 = _path4[_path4.length - 1];\n\n        var _parent3 = Node.parent(editor, _path4);\n\n        _parent3.children.splice(_index3, 1); // Transform all of the points in the value, but if the point was in the\n        // node that was removed we need to update the range or remove it.\n\n\n        if (selection) {\n          var _iterator29 = _createForOfIteratorHelper(Range.points(selection)),\n              _step29;\n\n          try {\n            for (_iterator29.s(); !(_step29 = _iterator29.n()).done;) {\n              var _step29$value = _slicedToArray(_step29.value, 2),\n                  _point4 = _step29$value[0],\n                  _key4 = _step29$value[1];\n\n              var result = Point.transform(_point4, op);\n\n              if (selection != null && result != null) {\n                selection[_key4] = result;\n              } else {\n                var _prev = void 0;\n\n                var next = void 0;\n\n                var _iterator30 = _createForOfIteratorHelper(Node.texts(editor)),\n                    _step30;\n\n                try {\n                  for (_iterator30.s(); !(_step30 = _iterator30.n()).done;) {\n                    var _step30$value = _slicedToArray(_step30.value, 2),\n                        n = _step30$value[0],\n                        p = _step30$value[1];\n\n                    if (Path.compare(p, _path4) === -1) {\n                      _prev = [n, p];\n                    } else {\n                      next = [n, p];\n                      break;\n                    }\n                  }\n                } catch (err) {\n                  _iterator30.e(err);\n                } finally {\n                  _iterator30.f();\n                }\n\n                if (_prev) {\n                  _point4.path = _prev[1];\n                  _point4.offset = _prev[0].text.length;\n                } else if (next) {\n                  _point4.path = next[1];\n                  _point4.offset = 0;\n                } else {\n                  selection = null;\n                }\n              }\n            }\n          } catch (err) {\n            _iterator29.e(err);\n          } finally {\n            _iterator29.f();\n          }\n        }\n\n        break;\n      }\n\n    case 'remove_text':\n      {\n        var _path5 = op.path,\n            _offset = op.offset,\n            _text = op.text;\n        if (_text.length === 0) break;\n\n        var _node4 = Node.leaf(editor, _path5);\n\n        var _before = _node4.text.slice(0, _offset);\n\n        var _after = _node4.text.slice(_offset + _text.length);\n\n        _node4.text = _before + _after;\n\n        if (selection) {\n          var _iterator31 = _createForOfIteratorHelper(Range.points(selection)),\n              _step31;\n\n          try {\n            for (_iterator31.s(); !(_step31 = _iterator31.n()).done;) {\n              var _step31$value = _slicedToArray(_step31.value, 2),\n                  _point5 = _step31$value[0],\n                  _key5 = _step31$value[1];\n\n              selection[_key5] = Point.transform(_point5, op);\n            }\n          } catch (err) {\n            _iterator31.e(err);\n          } finally {\n            _iterator31.f();\n          }\n        }\n\n        break;\n      }\n\n    case 'set_node':\n      {\n        var _path6 = op.path,\n            properties = op.properties,\n            newProperties = op.newProperties;\n\n        if (_path6.length === 0) {\n          throw new Error(\"Cannot set properties on the root node!\");\n        }\n\n        var _node5 = Node.get(editor, _path6);\n\n        for (var _key6 in newProperties) {\n          if (_key6 === 'children' || _key6 === 'text') {\n            throw new Error(\"Cannot set the \\\"\".concat(_key6, \"\\\" property of nodes!\"));\n          }\n\n          var value = newProperties[_key6];\n\n          if (value == null) {\n            delete _node5[_key6];\n          } else {\n            _node5[_key6] = value;\n          }\n        } // properties that were previously defined, but are now missing, must be deleted\n\n\n        for (var _key7 in properties) {\n          if (!newProperties.hasOwnProperty(_key7)) {\n            delete _node5[_key7];\n          }\n        }\n\n        break;\n      }\n\n    case 'set_selection':\n      {\n        var _newProperties = op.newProperties;\n\n        if (_newProperties == null) {\n          selection = _newProperties;\n        } else {\n          if (selection == null) {\n            if (!Range.isRange(_newProperties)) {\n              throw new Error(\"Cannot apply an incomplete \\\"set_selection\\\" operation properties \".concat(JSON.stringify(_newProperties), \" when there is no current selection.\"));\n            }\n\n            selection = _objectSpread$6({}, _newProperties);\n          }\n\n          for (var _key8 in _newProperties) {\n            var _value = _newProperties[_key8];\n\n            if (_value == null) {\n              if (_key8 === 'anchor' || _key8 === 'focus') {\n                throw new Error(\"Cannot remove the \\\"\".concat(_key8, \"\\\" selection property\"));\n              }\n\n              delete selection[_key8];\n            } else {\n              selection[_key8] = _value;\n            }\n          }\n        }\n\n        break;\n      }\n\n    case 'split_node':\n      {\n        var _path7 = op.path,\n            position = op.position,\n            _properties = op.properties;\n\n        if (_path7.length === 0) {\n          throw new Error(\"Cannot apply a \\\"split_node\\\" operation at path [\".concat(_path7, \"] because the root node cannot be split.\"));\n        }\n\n        var _node6 = Node.get(editor, _path7);\n\n        var _parent4 = Node.parent(editor, _path7);\n\n        var _index4 = _path7[_path7.length - 1];\n        var newNode;\n\n        if (Text.isText(_node6)) {\n          var _before2 = _node6.text.slice(0, position);\n\n          var _after2 = _node6.text.slice(position);\n\n          _node6.text = _before2;\n          newNode = _objectSpread$6(_objectSpread$6({}, _properties), {}, {\n            text: _after2\n          });\n        } else {\n          var _before3 = _node6.children.slice(0, position);\n\n          var _after3 = _node6.children.slice(position);\n\n          _node6.children = _before3;\n          newNode = _objectSpread$6(_objectSpread$6({}, _properties), {}, {\n            children: _after3\n          });\n        }\n\n        _parent4.children.splice(_index4 + 1, 0, newNode);\n\n        if (selection) {\n          var _iterator32 = _createForOfIteratorHelper(Range.points(selection)),\n              _step32;\n\n          try {\n            for (_iterator32.s(); !(_step32 = _iterator32.n()).done;) {\n              var _step32$value = _slicedToArray(_step32.value, 2),\n                  _point6 = _step32$value[0],\n                  _key9 = _step32$value[1];\n\n              selection[_key9] = Point.transform(_point6, op);\n            }\n          } catch (err) {\n            _iterator32.e(err);\n          } finally {\n            _iterator32.f();\n          }\n        }\n\n        break;\n      }\n  }\n\n  return selection;\n};\n\nvar GeneralTransforms = {\n  /**\r\n   * Transform the editor by an operation.\r\n   */\n  transform: function transform(editor, op) {\n    editor.children = createDraft(editor.children);\n    var selection = editor.selection && createDraft(editor.selection);\n\n    try {\n      selection = applyToDraft(editor, selection, op);\n    } finally {\n      editor.children = finishDraft(editor.children);\n\n      if (selection) {\n        editor.selection = isDraft(selection) ? finishDraft(selection) : selection;\n      } else {\n        editor.selection = null;\n      }\n    }\n  }\n};\n\nfunction ownKeys$7(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread$7(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys$7(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys$7(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nvar NodeTransforms = {\n  /**\r\n   * Insert nodes at a specific location in the Editor.\r\n   */\n  insertNodes: function insertNodes(editor, nodes) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    Editor.withoutNormalizing(editor, function () {\n      var _options$hanging = options.hanging,\n          hanging = _options$hanging === void 0 ? false : _options$hanging,\n          _options$voids9 = options.voids,\n          voids = _options$voids9 === void 0 ? false : _options$voids9,\n          _options$mode5 = options.mode,\n          mode = _options$mode5 === void 0 ? 'lowest' : _options$mode5;\n      var at = options.at,\n          match = options.match,\n          select = options.select;\n\n      if (Node.isNode(nodes)) {\n        nodes = [nodes];\n      }\n\n      if (nodes.length === 0) {\n        return;\n      }\n\n      var _nodes = nodes,\n          _nodes2 = _slicedToArray(_nodes, 1),\n          node = _nodes2[0]; // By default, use the selection as the target location. But if there is\n      // no selection, insert at the end of the document since that is such a\n      // common use case when inserting from a non-selected state.\n\n\n      if (!at) {\n        if (editor.selection) {\n          at = editor.selection;\n        } else if (editor.children.length > 0) {\n          at = Editor.end(editor, []);\n        } else {\n          at = [0];\n        }\n\n        select = true;\n      }\n\n      if (select == null) {\n        select = false;\n      }\n\n      if (Range.isRange(at)) {\n        if (!hanging) {\n          at = Editor.unhangRange(editor, at);\n        }\n\n        if (Range.isCollapsed(at)) {\n          at = at.anchor;\n        } else {\n          var _Range$edges27 = Range.edges(at),\n              _Range$edges28 = _slicedToArray(_Range$edges27, 2),\n              end = _Range$edges28[1];\n\n          var pointRef = Editor.pointRef(editor, end);\n          Transforms.delete(editor, {\n            at: at\n          });\n          at = pointRef.unref();\n        }\n      }\n\n      if (Point.isPoint(at)) {\n        if (match == null) {\n          if (Text.isText(node)) {\n            match = function match(n) {\n              return Text.isText(n);\n            };\n          } else if (editor.isInline(node)) {\n            match = function match(n) {\n              return Text.isText(n) || Editor.isInline(editor, n);\n            };\n          } else {\n            match = function match(n) {\n              return Editor.isBlock(editor, n);\n            };\n          }\n        }\n\n        var _Editor$nodes7 = Editor.nodes(editor, {\n          at: at.path,\n          match: match,\n          mode: mode,\n          voids: voids\n        }),\n            _Editor$nodes8 = _slicedToArray(_Editor$nodes7, 1),\n            entry = _Editor$nodes8[0];\n\n        if (entry) {\n          var _entry2 = _slicedToArray(entry, 2),\n              _matchPath = _entry2[1];\n\n          var pathRef = Editor.pathRef(editor, _matchPath);\n          var isAtEnd = Editor.isEnd(editor, at, _matchPath);\n          Transforms.splitNodes(editor, {\n            at: at,\n            match: match,\n            mode: mode,\n            voids: voids\n          });\n          var path = pathRef.unref();\n          at = isAtEnd ? Path.next(path) : path;\n        } else {\n          return;\n        }\n      }\n\n      var parentPath = Path.parent(at);\n      var index = at[at.length - 1];\n\n      if (!voids && Editor.void(editor, {\n        at: parentPath\n      })) {\n        return;\n      }\n\n      var _iterator33 = _createForOfIteratorHelper(nodes),\n          _step33;\n\n      try {\n        for (_iterator33.s(); !(_step33 = _iterator33.n()).done;) {\n          var _node = _step33.value;\n\n          var _path = parentPath.concat(index);\n\n          index++;\n          editor.apply({\n            type: 'insert_node',\n            path: _path,\n            node: _node\n          });\n        }\n      } catch (err) {\n        _iterator33.e(err);\n      } finally {\n        _iterator33.f();\n      }\n\n      if (select) {\n        var point = Editor.end(editor, at);\n\n        if (point) {\n          Transforms.select(editor, point);\n        }\n      }\n    });\n  },\n\n  /**\r\n   * Lift nodes at a specific location upwards in the document tree, splitting\r\n   * their parent in two if necessary.\r\n   */\n  liftNodes: function liftNodes(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    Editor.withoutNormalizing(editor, function () {\n      var _options$at7 = options.at,\n          at = _options$at7 === void 0 ? editor.selection : _options$at7,\n          _options$mode6 = options.mode,\n          mode = _options$mode6 === void 0 ? 'lowest' : _options$mode6,\n          _options$voids10 = options.voids,\n          voids = _options$voids10 === void 0 ? false : _options$voids10;\n      var match = options.match;\n\n      if (match == null) {\n        match = Path.isPath(at) ? matchPath(editor, at) : function (n) {\n          return Editor.isBlock(editor, n);\n        };\n      }\n\n      if (!at) {\n        return;\n      }\n\n      var matches = Editor.nodes(editor, {\n        at: at,\n        match: match,\n        mode: mode,\n        voids: voids\n      });\n      var pathRefs = Array.from(matches, function (_ref) {\n        var _ref10 = _slicedToArray(_ref, 2),\n            p = _ref10[1];\n\n        return Editor.pathRef(editor, p);\n      });\n\n      for (var _i = 0, _pathRefs = pathRefs; _i < _pathRefs.length; _i++) {\n        var pathRef = _pathRefs[_i];\n        var path = pathRef.unref();\n\n        if (path.length < 2) {\n          throw new Error(\"Cannot lift node at a path [\".concat(path, \"] because it has a depth of less than `2`.\"));\n        }\n\n        var parentNodeEntry = Editor.node(editor, Path.parent(path));\n\n        var _parentNodeEntry = _slicedToArray(parentNodeEntry, 2),\n            parent = _parentNodeEntry[0],\n            parentPath = _parentNodeEntry[1];\n\n        var index = path[path.length - 1];\n        var length = parent.children.length;\n\n        if (length === 1) {\n          var toPath = Path.next(parentPath);\n          Transforms.moveNodes(editor, {\n            at: path,\n            to: toPath,\n            voids: voids\n          });\n          Transforms.removeNodes(editor, {\n            at: parentPath,\n            voids: voids\n          });\n        } else if (index === 0) {\n          Transforms.moveNodes(editor, {\n            at: path,\n            to: parentPath,\n            voids: voids\n          });\n        } else if (index === length - 1) {\n          var _toPath = Path.next(parentPath);\n\n          Transforms.moveNodes(editor, {\n            at: path,\n            to: _toPath,\n            voids: voids\n          });\n        } else {\n          var splitPath = Path.next(path);\n\n          var _toPath2 = Path.next(parentPath);\n\n          Transforms.splitNodes(editor, {\n            at: splitPath,\n            voids: voids\n          });\n          Transforms.moveNodes(editor, {\n            at: path,\n            to: _toPath2,\n            voids: voids\n          });\n        }\n      }\n    });\n  },\n\n  /**\r\n   * Merge a node at a location with the previous node of the same depth,\r\n   * removing any empty containing nodes after the merge if necessary.\r\n   */\n  mergeNodes: function mergeNodes(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    Editor.withoutNormalizing(editor, function () {\n      var match = options.match,\n          _options$at8 = options.at,\n          at = _options$at8 === void 0 ? editor.selection : _options$at8;\n      var _options$hanging2 = options.hanging,\n          hanging = _options$hanging2 === void 0 ? false : _options$hanging2,\n          _options$voids11 = options.voids,\n          voids = _options$voids11 === void 0 ? false : _options$voids11,\n          _options$mode7 = options.mode,\n          mode = _options$mode7 === void 0 ? 'lowest' : _options$mode7;\n\n      if (!at) {\n        return;\n      }\n\n      if (match == null) {\n        if (Path.isPath(at)) {\n          var _Editor$parent5 = Editor.parent(editor, at),\n              _Editor$parent6 = _slicedToArray(_Editor$parent5, 1),\n              parent = _Editor$parent6[0];\n\n          match = function match(n) {\n            return parent.children.includes(n);\n          };\n        } else {\n          match = function match(n) {\n            return Editor.isBlock(editor, n);\n          };\n        }\n      }\n\n      if (!hanging && Range.isRange(at)) {\n        at = Editor.unhangRange(editor, at);\n      }\n\n      if (Range.isRange(at)) {\n        if (Range.isCollapsed(at)) {\n          at = at.anchor;\n        } else {\n          var _Range$edges29 = Range.edges(at),\n              _Range$edges30 = _slicedToArray(_Range$edges29, 2),\n              end = _Range$edges30[1];\n\n          var pointRef = Editor.pointRef(editor, end);\n          Transforms.delete(editor, {\n            at: at\n          });\n          at = pointRef.unref();\n\n          if (options.at == null) {\n            Transforms.select(editor, at);\n          }\n        }\n      }\n\n      var _Editor$nodes9 = Editor.nodes(editor, {\n        at: at,\n        match: match,\n        voids: voids,\n        mode: mode\n      }),\n          _Editor$nodes10 = _slicedToArray(_Editor$nodes9, 1),\n          current = _Editor$nodes10[0];\n\n      var prev = Editor.previous(editor, {\n        at: at,\n        match: match,\n        voids: voids,\n        mode: mode\n      });\n\n      if (!current || !prev) {\n        return;\n      }\n\n      var _current = _slicedToArray(current, 2),\n          node = _current[0],\n          path = _current[1];\n\n      var _prev3 = _slicedToArray(prev, 2),\n          prevNode = _prev3[0],\n          prevPath = _prev3[1];\n\n      if (path.length === 0 || prevPath.length === 0) {\n        return;\n      }\n\n      var newPath = Path.next(prevPath);\n      var commonPath = Path.common(path, prevPath);\n      var isPreviousSibling = Path.isSibling(path, prevPath);\n      var levels = Array.from(Editor.levels(editor, {\n        at: path\n      }), function (_ref2) {\n        var _ref11 = _slicedToArray(_ref2, 1),\n            n = _ref11[0];\n\n        return n;\n      }).slice(commonPath.length).slice(0, -1); // Determine if the merge will leave an ancestor of the path empty as a\n      // result, in which case we'll want to remove it after merging.\n\n      var emptyAncestor = Editor.above(editor, {\n        at: path,\n        mode: 'highest',\n        match: function match(n) {\n          return levels.includes(n) && hasSingleChildNest(editor, n);\n        }\n      });\n      var emptyRef = emptyAncestor && Editor.pathRef(editor, emptyAncestor[1]);\n      var properties;\n      var position; // Ensure that the nodes are equivalent, and figure out what the position\n      // and extra properties of the merge will be.\n\n      if (Text.isText(node) && Text.isText(prevNode)) {\n        var rest = _objectWithoutProperties(node, [\"text\"]);\n\n        position = prevNode.text.length;\n        properties = rest;\n      } else if (Element.isElement(node) && Element.isElement(prevNode)) {\n        var rest = _objectWithoutProperties(node, [\"children\"]);\n\n        position = prevNode.children.length;\n        properties = rest;\n      } else {\n        throw new Error(\"Cannot merge the node at path [\".concat(path, \"] with the previous sibling because it is not the same kind: \").concat(JSON.stringify(node), \" \").concat(JSON.stringify(prevNode)));\n      } // If the node isn't already the next sibling of the previous node, move\n      // it so that it is before merging.\n\n\n      if (!isPreviousSibling) {\n        Transforms.moveNodes(editor, {\n          at: path,\n          to: newPath,\n          voids: voids\n        });\n      } // If there was going to be an empty ancestor of the node that was merged,\n      // we remove it from the tree.\n\n\n      if (emptyRef) {\n        Transforms.removeNodes(editor, {\n          at: emptyRef.current,\n          voids: voids\n        });\n      } // If the target node that we're merging with is empty, remove it instead\n      // of merging the two. This is a common rich text editor behavior to\n      // prevent losing formatting when deleting entire nodes when you have a\n      // hanging selection.\n\n\n      if (Element.isElement(prevNode) && Editor.isEmpty(editor, prevNode) || Text.isText(prevNode) && prevNode.text === '') {\n        Transforms.removeNodes(editor, {\n          at: prevPath,\n          voids: voids\n        });\n      } else {\n        editor.apply({\n          type: 'merge_node',\n          path: newPath,\n          position: position,\n          properties: properties\n        });\n      }\n\n      if (emptyRef) {\n        emptyRef.unref();\n      }\n    });\n  },\n\n  /**\r\n   * Move the nodes at a location to a new location.\r\n   */\n  moveNodes: function moveNodes(editor, options) {\n    Editor.withoutNormalizing(editor, function () {\n      var to = options.to,\n          _options$at9 = options.at,\n          at = _options$at9 === void 0 ? editor.selection : _options$at9,\n          _options$mode8 = options.mode,\n          mode = _options$mode8 === void 0 ? 'lowest' : _options$mode8,\n          _options$voids12 = options.voids,\n          voids = _options$voids12 === void 0 ? false : _options$voids12;\n      var match = options.match;\n\n      if (!at) {\n        return;\n      }\n\n      if (match == null) {\n        match = Path.isPath(at) ? matchPath(editor, at) : function (n) {\n          return Editor.isBlock(editor, n);\n        };\n      }\n\n      var toRef = Editor.pathRef(editor, to);\n      var targets = Editor.nodes(editor, {\n        at: at,\n        match: match,\n        mode: mode,\n        voids: voids\n      });\n      var pathRefs = Array.from(targets, function (_ref3) {\n        var _ref12 = _slicedToArray(_ref3, 2),\n            p = _ref12[1];\n\n        return Editor.pathRef(editor, p);\n      });\n\n      for (var _i2 = 0, _pathRefs2 = pathRefs; _i2 < _pathRefs2.length; _i2++) {\n        var pathRef = _pathRefs2[_i2];\n        var path = pathRef.unref();\n        var newPath = toRef.current;\n\n        if (path.length !== 0) {\n          editor.apply({\n            type: 'move_node',\n            path: path,\n            newPath: newPath\n          });\n        }\n\n        if (toRef.current && Path.isSibling(newPath, path) && Path.isAfter(newPath, path)) {\n          // When performing a sibling move to a later index, the path at the destination is shifted\n          // to before the insertion point instead of after. To ensure our group of nodes are inserted\n          // in the correct order we increment toRef to account for that\n          toRef.current = Path.next(toRef.current);\n        }\n      }\n\n      toRef.unref();\n    });\n  },\n\n  /**\r\n   * Remove the nodes at a specific location in the document.\r\n   */\n  removeNodes: function removeNodes(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    Editor.withoutNormalizing(editor, function () {\n      var _options$hanging3 = options.hanging,\n          hanging = _options$hanging3 === void 0 ? false : _options$hanging3,\n          _options$voids13 = options.voids,\n          voids = _options$voids13 === void 0 ? false : _options$voids13,\n          _options$mode9 = options.mode,\n          mode = _options$mode9 === void 0 ? 'lowest' : _options$mode9;\n      var _options$at10 = options.at,\n          at = _options$at10 === void 0 ? editor.selection : _options$at10,\n          match = options.match;\n\n      if (!at) {\n        return;\n      }\n\n      if (match == null) {\n        match = Path.isPath(at) ? matchPath(editor, at) : function (n) {\n          return Editor.isBlock(editor, n);\n        };\n      }\n\n      if (!hanging && Range.isRange(at)) {\n        at = Editor.unhangRange(editor, at);\n      }\n\n      var depths = Editor.nodes(editor, {\n        at: at,\n        match: match,\n        mode: mode,\n        voids: voids\n      });\n      var pathRefs = Array.from(depths, function (_ref4) {\n        var _ref13 = _slicedToArray(_ref4, 2),\n            p = _ref13[1];\n\n        return Editor.pathRef(editor, p);\n      });\n\n      for (var _i3 = 0, _pathRefs3 = pathRefs; _i3 < _pathRefs3.length; _i3++) {\n        var pathRef = _pathRefs3[_i3];\n        var path = pathRef.unref();\n\n        if (path) {\n          var _Editor$node3 = Editor.node(editor, path),\n              _Editor$node4 = _slicedToArray(_Editor$node3, 1),\n              node = _Editor$node4[0];\n\n          editor.apply({\n            type: 'remove_node',\n            path: path,\n            node: node\n          });\n        }\n      }\n    });\n  },\n\n  /**\r\n   * Set new properties on the nodes at a location.\r\n   */\n  setNodes: function setNodes(editor, props) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    Editor.withoutNormalizing(editor, function () {\n      var match = options.match,\n          _options$at11 = options.at,\n          at = _options$at11 === void 0 ? editor.selection : _options$at11;\n      var _options$hanging4 = options.hanging,\n          hanging = _options$hanging4 === void 0 ? false : _options$hanging4,\n          _options$mode10 = options.mode,\n          mode = _options$mode10 === void 0 ? 'lowest' : _options$mode10,\n          _options$split = options.split,\n          split = _options$split === void 0 ? false : _options$split,\n          _options$voids14 = options.voids,\n          voids = _options$voids14 === void 0 ? false : _options$voids14;\n\n      if (!at) {\n        return;\n      }\n\n      if (match == null) {\n        match = Path.isPath(at) ? matchPath(editor, at) : function (n) {\n          return Editor.isBlock(editor, n);\n        };\n      }\n\n      if (!hanging && Range.isRange(at)) {\n        at = Editor.unhangRange(editor, at);\n      }\n\n      if (split && Range.isRange(at)) {\n        var rangeRef = Editor.rangeRef(editor, at, {\n          affinity: 'inward'\n        });\n\n        var _Range$edges31 = Range.edges(at),\n            _Range$edges32 = _slicedToArray(_Range$edges31, 2),\n            start = _Range$edges32[0],\n            end = _Range$edges32[1];\n\n        var splitMode = mode === 'lowest' ? 'lowest' : 'highest';\n        var endAtEndOfNode = Editor.isEnd(editor, end, end.path);\n        Transforms.splitNodes(editor, {\n          at: end,\n          match: match,\n          mode: splitMode,\n          voids: voids,\n          always: !endAtEndOfNode\n        });\n        var startAtStartOfNode = Editor.isStart(editor, start, start.path);\n        Transforms.splitNodes(editor, {\n          at: start,\n          match: match,\n          mode: splitMode,\n          voids: voids,\n          always: !startAtStartOfNode\n        });\n        at = rangeRef.unref();\n\n        if (options.at == null) {\n          Transforms.select(editor, at);\n        }\n      }\n\n      var _iterator34 = _createForOfIteratorHelper(Editor.nodes(editor, {\n        at: at,\n        match: match,\n        mode: mode,\n        voids: voids\n      })),\n          _step34;\n\n      try {\n        for (_iterator34.s(); !(_step34 = _iterator34.n()).done;) {\n          var _step34$value = _slicedToArray(_step34.value, 2),\n              node = _step34$value[0],\n              path = _step34$value[1];\n\n          var properties = {};\n          var newProperties = {}; // You can't set properties on the editor node.\n\n          if (path.length === 0) {\n            continue;\n          }\n\n          for (var k in props) {\n            if (k === 'children' || k === 'text') {\n              continue;\n            }\n\n            if (props[k] !== node[k]) {\n              // Omit new properties from the old property list rather than set them to undefined\n              if (node.hasOwnProperty(k)) properties[k] = node[k];\n              newProperties[k] = props[k];\n            }\n          }\n\n          if (Object.keys(newProperties).length !== 0) {\n            editor.apply({\n              type: 'set_node',\n              path: path,\n              properties: properties,\n              newProperties: newProperties\n            });\n          }\n        }\n      } catch (err) {\n        _iterator34.e(err);\n      } finally {\n        _iterator34.f();\n      }\n    });\n  },\n\n  /**\r\n   * Split the nodes at a specific location.\r\n   */\n  splitNodes: function splitNodes(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    Editor.withoutNormalizing(editor, function () {\n      var _options$mode11 = options.mode,\n          mode = _options$mode11 === void 0 ? 'lowest' : _options$mode11,\n          _options$voids15 = options.voids,\n          voids = _options$voids15 === void 0 ? false : _options$voids15;\n      var match = options.match,\n          _options$at12 = options.at,\n          at = _options$at12 === void 0 ? editor.selection : _options$at12,\n          _options$height = options.height,\n          height = _options$height === void 0 ? 0 : _options$height,\n          _options$always = options.always,\n          always = _options$always === void 0 ? false : _options$always;\n\n      if (match == null) {\n        match = function match(n) {\n          return Editor.isBlock(editor, n);\n        };\n      }\n\n      if (Range.isRange(at)) {\n        at = deleteRange(editor, at);\n      } // If the target is a path, the default height-skipping and position\n      // counters need to account for us potentially splitting at a non-leaf.\n\n\n      if (Path.isPath(at)) {\n        var path = at;\n        var point = Editor.point(editor, path);\n\n        var _Editor$parent7 = Editor.parent(editor, path),\n            _Editor$parent8 = _slicedToArray(_Editor$parent7, 1),\n            parent = _Editor$parent8[0];\n\n        match = function match(n) {\n          return n === parent;\n        };\n\n        height = point.path.length - path.length + 1;\n        at = point;\n        always = true;\n      }\n\n      if (!at) {\n        return;\n      }\n\n      var beforeRef = Editor.pointRef(editor, at, {\n        affinity: 'backward'\n      });\n\n      var _Editor$nodes11 = Editor.nodes(editor, {\n        at: at,\n        match: match,\n        mode: mode,\n        voids: voids\n      }),\n          _Editor$nodes12 = _slicedToArray(_Editor$nodes11, 1),\n          highest = _Editor$nodes12[0];\n\n      if (!highest) {\n        return;\n      }\n\n      var voidMatch = Editor.void(editor, {\n        at: at,\n        mode: 'highest'\n      });\n      var nudge = 0;\n\n      if (!voids && voidMatch) {\n        var _voidMatch = _slicedToArray(voidMatch, 2),\n            voidNode = _voidMatch[0],\n            voidPath = _voidMatch[1];\n\n        if (Element.isElement(voidNode) && editor.isInline(voidNode)) {\n          var after = Editor.after(editor, voidPath);\n\n          if (!after) {\n            var text = {\n              text: ''\n            };\n            var afterPath = Path.next(voidPath);\n            Transforms.insertNodes(editor, text, {\n              at: afterPath,\n              voids: voids\n            });\n            after = Editor.point(editor, afterPath);\n          }\n\n          at = after;\n          always = true;\n        }\n\n        var siblingHeight = at.path.length - voidPath.length;\n        height = siblingHeight + 1;\n        always = true;\n      }\n\n      var afterRef = Editor.pointRef(editor, at);\n      var depth = at.path.length - height;\n\n      var _highest = _slicedToArray(highest, 2),\n          highestPath = _highest[1];\n\n      var lowestPath = at.path.slice(0, depth);\n      var position = height === 0 ? at.offset : at.path[depth] + nudge;\n\n      var _iterator35 = _createForOfIteratorHelper(Editor.levels(editor, {\n        at: lowestPath,\n        reverse: true,\n        voids: voids\n      })),\n          _step35;\n\n      try {\n        for (_iterator35.s(); !(_step35 = _iterator35.n()).done;) {\n          var _step35$value = _slicedToArray(_step35.value, 2),\n              node = _step35$value[0],\n              _path2 = _step35$value[1];\n\n          var split = false;\n\n          if (_path2.length < highestPath.length || _path2.length === 0 || !voids && Editor.isVoid(editor, node)) {\n            break;\n          }\n\n          var _point = beforeRef.current;\n          var isEnd = Editor.isEnd(editor, _point, _path2);\n\n          if (always || !beforeRef || !Editor.isEdge(editor, _point, _path2)) {\n            split = true;\n            var properties = Node.extractProps(node);\n            editor.apply({\n              type: 'split_node',\n              path: _path2,\n              position: position,\n              properties: properties\n            });\n          }\n\n          position = _path2[_path2.length - 1] + (split || isEnd ? 1 : 0);\n        }\n      } catch (err) {\n        _iterator35.e(err);\n      } finally {\n        _iterator35.f();\n      }\n\n      if (options.at == null) {\n        var _point2 = afterRef.current || Editor.end(editor, []);\n\n        Transforms.select(editor, _point2);\n      }\n\n      beforeRef.unref();\n      afterRef.unref();\n    });\n  },\n\n  /**\r\n   * Unset properties on the nodes at a location.\r\n   */\n  unsetNodes: function unsetNodes(editor, props) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n    if (!Array.isArray(props)) {\n      props = [props];\n    }\n\n    var obj = {};\n\n    var _iterator36 = _createForOfIteratorHelper(props),\n        _step36;\n\n    try {\n      for (_iterator36.s(); !(_step36 = _iterator36.n()).done;) {\n        var key = _step36.value;\n        obj[key] = null;\n      }\n    } catch (err) {\n      _iterator36.e(err);\n    } finally {\n      _iterator36.f();\n    }\n\n    Transforms.setNodes(editor, obj, options);\n  },\n\n  /**\r\n   * Unwrap the nodes at a location from a parent node, splitting the parent if\r\n   * necessary to ensure that only the content in the range is unwrapped.\r\n   */\n  unwrapNodes: function unwrapNodes(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    Editor.withoutNormalizing(editor, function () {\n      var _options$mode12 = options.mode,\n          mode = _options$mode12 === void 0 ? 'lowest' : _options$mode12,\n          _options$split2 = options.split,\n          split = _options$split2 === void 0 ? false : _options$split2,\n          _options$voids16 = options.voids,\n          voids = _options$voids16 === void 0 ? false : _options$voids16;\n      var _options$at13 = options.at,\n          at = _options$at13 === void 0 ? editor.selection : _options$at13,\n          match = options.match;\n\n      if (!at) {\n        return;\n      }\n\n      if (match == null) {\n        match = Path.isPath(at) ? matchPath(editor, at) : function (n) {\n          return Editor.isBlock(editor, n);\n        };\n      }\n\n      if (Path.isPath(at)) {\n        at = Editor.range(editor, at);\n      }\n\n      var rangeRef = Range.isRange(at) ? Editor.rangeRef(editor, at) : null;\n      var matches = Editor.nodes(editor, {\n        at: at,\n        match: match,\n        mode: mode,\n        voids: voids\n      });\n      var pathRefs = Array.from(matches, function (_ref5) {\n        var _ref14 = _slicedToArray(_ref5, 2),\n            p = _ref14[1];\n\n        return Editor.pathRef(editor, p);\n      });\n\n      var _loop = function _loop(pathRef) {\n        var path = pathRef.unref();\n\n        var _Editor$node5 = Editor.node(editor, path),\n            _Editor$node6 = _slicedToArray(_Editor$node5, 1),\n            node = _Editor$node6[0];\n\n        var range = Editor.range(editor, path);\n\n        if (split && rangeRef) {\n          range = Range.intersection(rangeRef.current, range);\n        }\n\n        Transforms.liftNodes(editor, {\n          at: range,\n          match: function match(n) {\n            return Element.isAncestor(node) && node.children.includes(n);\n          },\n          voids: voids\n        });\n      };\n\n      for (var _i4 = 0, _pathRefs4 = pathRefs; _i4 < _pathRefs4.length; _i4++) {\n        var pathRef = _pathRefs4[_i4];\n\n        _loop(pathRef);\n      }\n\n      if (rangeRef) {\n        rangeRef.unref();\n      }\n    });\n  },\n\n  /**\r\n   * Wrap the nodes at a location in a new container node, splitting the edges\r\n   * of the range first to ensure that only the content in the range is wrapped.\r\n   */\n  wrapNodes: function wrapNodes(editor, element) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    Editor.withoutNormalizing(editor, function () {\n      var _options$mode13 = options.mode,\n          mode = _options$mode13 === void 0 ? 'lowest' : _options$mode13,\n          _options$split3 = options.split,\n          split = _options$split3 === void 0 ? false : _options$split3,\n          _options$voids17 = options.voids,\n          voids = _options$voids17 === void 0 ? false : _options$voids17;\n      var match = options.match,\n          _options$at14 = options.at,\n          at = _options$at14 === void 0 ? editor.selection : _options$at14;\n\n      if (!at) {\n        return;\n      }\n\n      if (match == null) {\n        if (Path.isPath(at)) {\n          match = matchPath(editor, at);\n        } else if (editor.isInline(element)) {\n          match = function match(n) {\n            return Editor.isInline(editor, n) || Text.isText(n);\n          };\n        } else {\n          match = function match(n) {\n            return Editor.isBlock(editor, n);\n          };\n        }\n      }\n\n      if (split && Range.isRange(at)) {\n        var _Range$edges33 = Range.edges(at),\n            _Range$edges34 = _slicedToArray(_Range$edges33, 2),\n            start = _Range$edges34[0],\n            end = _Range$edges34[1];\n\n        var rangeRef = Editor.rangeRef(editor, at, {\n          affinity: 'inward'\n        });\n        Transforms.splitNodes(editor, {\n          at: end,\n          match: match,\n          voids: voids\n        });\n        Transforms.splitNodes(editor, {\n          at: start,\n          match: match,\n          voids: voids\n        });\n        at = rangeRef.unref();\n\n        if (options.at == null) {\n          Transforms.select(editor, at);\n        }\n      }\n\n      var roots = Array.from(Editor.nodes(editor, {\n        at: at,\n        match: editor.isInline(element) ? function (n) {\n          return Editor.isBlock(editor, n);\n        } : function (n) {\n          return Editor.isEditor(n);\n        },\n        mode: 'lowest',\n        voids: voids\n      }));\n\n      for (var _i5 = 0, _roots = roots; _i5 < _roots.length; _i5++) {\n        var _roots$_i = _slicedToArray(_roots[_i5], 2),\n            rootPath = _roots$_i[1];\n\n        var a = Range.isRange(at) ? Range.intersection(at, Editor.range(editor, rootPath)) : at;\n\n        if (!a) {\n          continue;\n        }\n\n        var matches = Array.from(Editor.nodes(editor, {\n          at: a,\n          match: match,\n          mode: mode,\n          voids: voids\n        }));\n\n        if (matches.length > 0) {\n          (function () {\n            var _matches = _slicedToArray(matches, 1),\n                first = _matches[0];\n\n            var last = matches[matches.length - 1];\n\n            var _first = _slicedToArray(first, 2),\n                firstPath = _first[1];\n\n            var _last = _slicedToArray(last, 2),\n                lastPath = _last[1];\n\n            var commonPath = Path.equals(firstPath, lastPath) ? Path.parent(firstPath) : Path.common(firstPath, lastPath);\n            var range = Editor.range(editor, firstPath, lastPath);\n            var commonNodeEntry = Editor.node(editor, commonPath);\n\n            var _commonNodeEntry = _slicedToArray(commonNodeEntry, 1),\n                commonNode = _commonNodeEntry[0];\n\n            var depth = commonPath.length + 1;\n            var wrapperPath = Path.next(lastPath.slice(0, depth));\n\n            var wrapper = _objectSpread$7(_objectSpread$7({}, element), {}, {\n              children: []\n            });\n\n            Transforms.insertNodes(editor, wrapper, {\n              at: wrapperPath,\n              voids: voids\n            });\n            Transforms.moveNodes(editor, {\n              at: range,\n              match: function match(n) {\n                return Element.isAncestor(commonNode) && commonNode.children.includes(n);\n              },\n              to: wrapperPath.concat(0),\n              voids: voids\n            });\n          })();\n        }\n      }\n    });\n  }\n};\n\nvar hasSingleChildNest = function hasSingleChildNest(editor, node) {\n  if (Element.isElement(node)) {\n    var element = node;\n\n    if (Editor.isVoid(editor, node)) {\n      return true;\n    } else if (element.children.length === 1) {\n      return hasSingleChildNest(editor, element.children[0]);\n    } else {\n      return false;\n    }\n  } else if (Editor.isEditor(node)) {\n    return false;\n  } else {\n    return true;\n  }\n};\n/**\r\n * Convert a range into a point by deleting it's content.\r\n */\n\n\nvar deleteRange = function deleteRange(editor, range) {\n  if (Range.isCollapsed(range)) {\n    return range.anchor;\n  } else {\n    var _Range$edges35 = Range.edges(range),\n        _Range$edges36 = _slicedToArray(_Range$edges35, 2),\n        end = _Range$edges36[1];\n\n    var pointRef = Editor.pointRef(editor, end);\n    Transforms.delete(editor, {\n      at: range\n    });\n    return pointRef.unref();\n  }\n};\n\nvar matchPath = function matchPath(editor, path) {\n  var _Editor$node7 = Editor.node(editor, path),\n      _Editor$node8 = _slicedToArray(_Editor$node7, 1),\n      node = _Editor$node8[0];\n\n  return function (n) {\n    return n === node;\n  };\n};\n\nfunction ownKeys$8(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread$8(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys$8(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys$8(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nvar SelectionTransforms = {\n  /**\r\n   * Collapse the selection.\r\n   */\n  collapse: function collapse(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var _options$edge2 = options.edge,\n        edge = _options$edge2 === void 0 ? 'anchor' : _options$edge2;\n    var selection = editor.selection;\n\n    if (!selection) {\n      return;\n    } else if (edge === 'anchor') {\n      Transforms.select(editor, selection.anchor);\n    } else if (edge === 'focus') {\n      Transforms.select(editor, selection.focus);\n    } else if (edge === 'start') {\n      var _Range$edges37 = Range.edges(selection),\n          _Range$edges38 = _slicedToArray(_Range$edges37, 1),\n          start = _Range$edges38[0];\n\n      Transforms.select(editor, start);\n    } else if (edge === 'end') {\n      var _Range$edges39 = Range.edges(selection),\n          _Range$edges40 = _slicedToArray(_Range$edges39, 2),\n          end = _Range$edges40[1];\n\n      Transforms.select(editor, end);\n    }\n  },\n\n  /**\r\n   * Unset the selection.\r\n   */\n  deselect: function deselect(editor) {\n    var selection = editor.selection;\n\n    if (selection) {\n      editor.apply({\n        type: 'set_selection',\n        properties: selection,\n        newProperties: null\n      });\n    }\n  },\n\n  /**\r\n   * Move the selection's point forward or backward.\r\n   */\n  move: function move(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var selection = editor.selection;\n    var _options$distance3 = options.distance,\n        distance = _options$distance3 === void 0 ? 1 : _options$distance3,\n        _options$unit4 = options.unit,\n        unit = _options$unit4 === void 0 ? 'character' : _options$unit4,\n        _options$reverse9 = options.reverse,\n        reverse = _options$reverse9 === void 0 ? false : _options$reverse9;\n    var _options$edge3 = options.edge,\n        edge = _options$edge3 === void 0 ? null : _options$edge3;\n\n    if (!selection) {\n      return;\n    }\n\n    if (edge === 'start') {\n      edge = Range.isBackward(selection) ? 'focus' : 'anchor';\n    }\n\n    if (edge === 'end') {\n      edge = Range.isBackward(selection) ? 'anchor' : 'focus';\n    }\n\n    var anchor = selection.anchor,\n        focus = selection.focus;\n    var opts = {\n      distance: distance,\n      unit: unit\n    };\n    var props = {};\n\n    if (edge == null || edge === 'anchor') {\n      var point = reverse ? Editor.before(editor, anchor, opts) : Editor.after(editor, anchor, opts);\n\n      if (point) {\n        props.anchor = point;\n      }\n    }\n\n    if (edge == null || edge === 'focus') {\n      var _point = reverse ? Editor.before(editor, focus, opts) : Editor.after(editor, focus, opts);\n\n      if (_point) {\n        props.focus = _point;\n      }\n    }\n\n    Transforms.setSelection(editor, props);\n  },\n\n  /**\r\n   * Set the selection to a new value.\r\n   */\n  select: function select(editor, target) {\n    var selection = editor.selection;\n    target = Editor.range(editor, target);\n\n    if (selection) {\n      Transforms.setSelection(editor, target);\n      return;\n    }\n\n    if (!Range.isRange(target)) {\n      throw new Error(\"When setting the selection and the current selection is `null` you must provide at least an `anchor` and `focus`, but you passed: \".concat(JSON.stringify(target)));\n    }\n\n    editor.apply({\n      type: 'set_selection',\n      properties: selection,\n      newProperties: target\n    });\n  },\n\n  /**\r\n   * Set new properties on one of the selection's points.\r\n   */\n  setPoint: function setPoint(editor, props) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    var selection = editor.selection;\n    var _options$edge4 = options.edge,\n        edge = _options$edge4 === void 0 ? 'both' : _options$edge4;\n\n    if (!selection) {\n      return;\n    }\n\n    if (edge === 'start') {\n      edge = Range.isBackward(selection) ? 'focus' : 'anchor';\n    }\n\n    if (edge === 'end') {\n      edge = Range.isBackward(selection) ? 'anchor' : 'focus';\n    }\n\n    var anchor = selection.anchor,\n        focus = selection.focus;\n    var point = edge === 'anchor' ? anchor : focus;\n    Transforms.setSelection(editor, _defineProperty2({}, edge === 'anchor' ? 'anchor' : 'focus', _objectSpread$8(_objectSpread$8({}, point), props)));\n  },\n\n  /**\r\n   * Set new properties on the selection.\r\n   */\n  setSelection: function setSelection(editor, props) {\n    var selection = editor.selection;\n    var oldProps = {};\n    var newProps = {};\n\n    if (!selection) {\n      return;\n    }\n\n    for (var k in props) {\n      if (k === 'anchor' && props.anchor != null && !Point.equals(props.anchor, selection.anchor) || k === 'focus' && props.focus != null && !Point.equals(props.focus, selection.focus) || k !== 'anchor' && k !== 'focus' && props[k] !== selection[k]) {\n        oldProps[k] = selection[k];\n        newProps[k] = props[k];\n      }\n    }\n\n    if (Object.keys(oldProps).length > 0) {\n      editor.apply({\n        type: 'set_selection',\n        properties: oldProps,\n        newProperties: newProps\n      });\n    }\n  }\n};\nvar TextTransforms = {\n  /**\r\n   * Delete content in the editor.\r\n   */\n  delete: function _delete(editor) {\n    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    Editor.withoutNormalizing(editor, function () {\n      var _options$reverse10 = options.reverse,\n          reverse = _options$reverse10 === void 0 ? false : _options$reverse10,\n          _options$unit5 = options.unit,\n          unit = _options$unit5 === void 0 ? 'character' : _options$unit5,\n          _options$distance4 = options.distance,\n          distance = _options$distance4 === void 0 ? 1 : _options$distance4,\n          _options$voids18 = options.voids,\n          voids = _options$voids18 === void 0 ? false : _options$voids18;\n      var _options$at15 = options.at,\n          at = _options$at15 === void 0 ? editor.selection : _options$at15,\n          _options$hanging5 = options.hanging,\n          hanging = _options$hanging5 === void 0 ? false : _options$hanging5;\n\n      if (!at) {\n        return;\n      }\n\n      if (Range.isRange(at) && Range.isCollapsed(at)) {\n        at = at.anchor;\n      }\n\n      if (Point.isPoint(at)) {\n        var furthestVoid = Editor.void(editor, {\n          at: at,\n          mode: 'highest'\n        });\n\n        if (!voids && furthestVoid) {\n          var _furthestVoid = _slicedToArray(furthestVoid, 2),\n              voidPath = _furthestVoid[1];\n\n          at = voidPath;\n        } else {\n          var opts = {\n            unit: unit,\n            distance: distance\n          };\n          var target = reverse ? Editor.before(editor, at, opts) || Editor.start(editor, []) : Editor.after(editor, at, opts) || Editor.end(editor, []);\n          at = {\n            anchor: at,\n            focus: target\n          };\n          hanging = true;\n        }\n      }\n\n      if (Path.isPath(at)) {\n        Transforms.removeNodes(editor, {\n          at: at,\n          voids: voids\n        });\n        return;\n      }\n\n      if (Range.isCollapsed(at)) {\n        return;\n      }\n\n      if (!hanging) {\n        var _Range$edges41 = Range.edges(at),\n            _Range$edges42 = _slicedToArray(_Range$edges41, 2),\n            _end = _Range$edges42[1];\n\n        var endOfDoc = Editor.end(editor, []);\n\n        if (!Point.equals(_end, endOfDoc)) {\n          at = Editor.unhangRange(editor, at, {\n            voids: voids\n          });\n        }\n      }\n\n      var _Range$edges43 = Range.edges(at),\n          _Range$edges44 = _slicedToArray(_Range$edges43, 2),\n          start = _Range$edges44[0],\n          end = _Range$edges44[1];\n\n      var startBlock = Editor.above(editor, {\n        match: function match(n) {\n          return Editor.isBlock(editor, n);\n        },\n        at: start,\n        voids: voids\n      });\n      var endBlock = Editor.above(editor, {\n        match: function match(n) {\n          return Editor.isBlock(editor, n);\n        },\n        at: end,\n        voids: voids\n      });\n      var isAcrossBlocks = startBlock && endBlock && !Path.equals(startBlock[1], endBlock[1]);\n      var isSingleText = Path.equals(start.path, end.path);\n      var startVoid = voids ? null : Editor.void(editor, {\n        at: start,\n        mode: 'highest'\n      });\n      var endVoid = voids ? null : Editor.void(editor, {\n        at: end,\n        mode: 'highest'\n      }); // If the start or end points are inside an inline void, nudge them out.\n\n      if (startVoid) {\n        var before = Editor.before(editor, start);\n\n        if (before && startBlock && Path.isAncestor(startBlock[1], before.path)) {\n          start = before;\n        }\n      }\n\n      if (endVoid) {\n        var after = Editor.after(editor, end);\n\n        if (after && endBlock && Path.isAncestor(endBlock[1], after.path)) {\n          end = after;\n        }\n      } // Get the highest nodes that are completely inside the range, as well as\n      // the start and end nodes.\n\n\n      var matches = [];\n      var lastPath;\n\n      var _iterator37 = _createForOfIteratorHelper(Editor.nodes(editor, {\n        at: at,\n        voids: voids\n      })),\n          _step37;\n\n      try {\n        for (_iterator37.s(); !(_step37 = _iterator37.n()).done;) {\n          var entry = _step37.value;\n\n          var _entry3 = _slicedToArray(entry, 2),\n              node = _entry3[0],\n              path = _entry3[1];\n\n          if (lastPath && Path.compare(path, lastPath) === 0) {\n            continue;\n          }\n\n          if (!voids && Editor.isVoid(editor, node) || !Path.isCommon(path, start.path) && !Path.isCommon(path, end.path)) {\n            matches.push(entry);\n            lastPath = path;\n          }\n        }\n      } catch (err) {\n        _iterator37.e(err);\n      } finally {\n        _iterator37.f();\n      }\n\n      var pathRefs = Array.from(matches, function (_ref) {\n        var _ref15 = _slicedToArray(_ref, 2),\n            p = _ref15[1];\n\n        return Editor.pathRef(editor, p);\n      });\n      var startRef = Editor.pointRef(editor, start);\n      var endRef = Editor.pointRef(editor, end);\n\n      if (!isSingleText && !startVoid) {\n        var _point = startRef.current;\n\n        var _Editor$leaf3 = Editor.leaf(editor, _point),\n            _Editor$leaf4 = _slicedToArray(_Editor$leaf3, 1),\n            _node = _Editor$leaf4[0];\n\n        var _path = _point.path;\n        var _start = start,\n            offset = _start.offset;\n\n        var text = _node.text.slice(offset);\n\n        if (text.length > 0) editor.apply({\n          type: 'remove_text',\n          path: _path,\n          offset: offset,\n          text: text\n        });\n      }\n\n      for (var _i6 = 0, _pathRefs5 = pathRefs; _i6 < _pathRefs5.length; _i6++) {\n        var pathRef = _pathRefs5[_i6];\n\n        var _path2 = pathRef.unref();\n\n        Transforms.removeNodes(editor, {\n          at: _path2,\n          voids: voids\n        });\n      }\n\n      if (!endVoid) {\n        var _point2 = endRef.current;\n\n        var _Editor$leaf5 = Editor.leaf(editor, _point2),\n            _Editor$leaf6 = _slicedToArray(_Editor$leaf5, 1),\n            _node2 = _Editor$leaf6[0];\n\n        var _path3 = _point2.path;\n\n        var _offset = isSingleText ? start.offset : 0;\n\n        var _text = _node2.text.slice(_offset, end.offset);\n\n        if (_text.length > 0) editor.apply({\n          type: 'remove_text',\n          path: _path3,\n          offset: _offset,\n          text: _text\n        });\n      }\n\n      if (!isSingleText && isAcrossBlocks && endRef.current && startRef.current) {\n        Transforms.mergeNodes(editor, {\n          at: endRef.current,\n          hanging: true,\n          voids: voids\n        });\n      }\n\n      var point = reverse ? startRef.unref() || endRef.unref() : endRef.unref() || startRef.unref();\n\n      if (options.at == null && point) {\n        Transforms.select(editor, point);\n      }\n    });\n  },\n\n  /**\r\n   * Insert a fragment at a specific location in the editor.\r\n   */\n  insertFragment: function insertFragment(editor, fragment) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    Editor.withoutNormalizing(editor, function () {\n      var _options$hanging6 = options.hanging,\n          hanging = _options$hanging6 === void 0 ? false : _options$hanging6,\n          _options$voids19 = options.voids,\n          voids = _options$voids19 === void 0 ? false : _options$voids19;\n      var _options$at16 = options.at,\n          at = _options$at16 === void 0 ? editor.selection : _options$at16;\n\n      if (!fragment.length) {\n        return;\n      }\n\n      if (!at) {\n        return;\n      } else if (Range.isRange(at)) {\n        if (!hanging) {\n          at = Editor.unhangRange(editor, at);\n        }\n\n        if (Range.isCollapsed(at)) {\n          at = at.anchor;\n        } else {\n          var _Range$edges45 = Range.edges(at),\n              _Range$edges46 = _slicedToArray(_Range$edges45, 2),\n              end = _Range$edges46[1];\n\n          if (!voids && Editor.void(editor, {\n            at: end\n          })) {\n            return;\n          }\n\n          var pointRef = Editor.pointRef(editor, end);\n          Transforms.delete(editor, {\n            at: at\n          });\n          at = pointRef.unref();\n        }\n      } else if (Path.isPath(at)) {\n        at = Editor.start(editor, at);\n      }\n\n      if (!voids && Editor.void(editor, {\n        at: at\n      })) {\n        return;\n      } // If the insert point is at the edge of an inline node, move it outside\n      // instead since it will need to be split otherwise.\n\n\n      var inlineElementMatch = Editor.above(editor, {\n        at: at,\n        match: function match(n) {\n          return Editor.isInline(editor, n);\n        },\n        mode: 'highest',\n        voids: voids\n      });\n\n      if (inlineElementMatch) {\n        var _inlineElementMatch = _slicedToArray(inlineElementMatch, 2),\n            _inlinePath = _inlineElementMatch[1];\n\n        if (Editor.isEnd(editor, at, _inlinePath)) {\n          var after = Editor.after(editor, _inlinePath);\n          at = after;\n        } else if (Editor.isStart(editor, at, _inlinePath)) {\n          var before = Editor.before(editor, _inlinePath);\n          at = before;\n        }\n      }\n\n      var blockMatch = Editor.above(editor, {\n        match: function match(n) {\n          return Editor.isBlock(editor, n);\n        },\n        at: at,\n        voids: voids\n      });\n\n      var _blockMatch = _slicedToArray(blockMatch, 2),\n          blockPath = _blockMatch[1];\n\n      var isBlockStart = Editor.isStart(editor, at, blockPath);\n      var isBlockEnd = Editor.isEnd(editor, at, blockPath);\n      var mergeStart = !isBlockStart || isBlockStart && isBlockEnd;\n      var mergeEnd = !isBlockEnd;\n\n      var _Node$first5 = Node.first({\n        children: fragment\n      }, []),\n          _Node$first6 = _slicedToArray(_Node$first5, 2),\n          firstPath = _Node$first6[1];\n\n      var _Node$last5 = Node.last({\n        children: fragment\n      }, []),\n          _Node$last6 = _slicedToArray(_Node$last5, 2),\n          lastPath = _Node$last6[1];\n\n      var matches = [];\n\n      var matcher = function matcher(_ref2) {\n        var _ref16 = _slicedToArray(_ref2, 2),\n            n = _ref16[0],\n            p = _ref16[1];\n\n        if (mergeStart && Path.isAncestor(p, firstPath) && Element.isElement(n) && !editor.isVoid(n) && !editor.isInline(n)) {\n          return false;\n        }\n\n        if (mergeEnd && Path.isAncestor(p, lastPath) && Element.isElement(n) && !editor.isVoid(n) && !editor.isInline(n)) {\n          return false;\n        }\n\n        return true;\n      };\n\n      var _iterator38 = _createForOfIteratorHelper(Node.nodes({\n        children: fragment\n      }, {\n        pass: matcher\n      })),\n          _step38;\n\n      try {\n        for (_iterator38.s(); !(_step38 = _iterator38.n()).done;) {\n          var entry = _step38.value;\n\n          if (entry[1].length > 0 && matcher(entry)) {\n            matches.push(entry);\n          }\n        }\n      } catch (err) {\n        _iterator38.e(err);\n      } finally {\n        _iterator38.f();\n      }\n\n      var starts = [];\n      var middles = [];\n      var ends = [];\n      var starting = true;\n      var hasBlocks = false;\n\n      for (var _i7 = 0, _matches2 = matches; _i7 < _matches2.length; _i7++) {\n        var _matches2$_i = _slicedToArray(_matches2[_i7], 1),\n            node = _matches2$_i[0];\n\n        if (Element.isElement(node) && !editor.isInline(node)) {\n          starting = false;\n          hasBlocks = true;\n          middles.push(node);\n        } else if (starting) {\n          starts.push(node);\n        } else {\n          ends.push(node);\n        }\n      }\n\n      var _Editor$nodes13 = Editor.nodes(editor, {\n        at: at,\n        match: function match(n) {\n          return Text.isText(n) || Editor.isInline(editor, n);\n        },\n        mode: 'highest',\n        voids: voids\n      }),\n          _Editor$nodes14 = _slicedToArray(_Editor$nodes13, 1),\n          inlineMatch = _Editor$nodes14[0];\n\n      var _inlineMatch = _slicedToArray(inlineMatch, 2),\n          inlinePath = _inlineMatch[1];\n\n      var isInlineStart = Editor.isStart(editor, at, inlinePath);\n      var isInlineEnd = Editor.isEnd(editor, at, inlinePath);\n      var middleRef = Editor.pathRef(editor, isBlockEnd ? Path.next(blockPath) : blockPath);\n      var endRef = Editor.pathRef(editor, isInlineEnd ? Path.next(inlinePath) : inlinePath);\n      Transforms.splitNodes(editor, {\n        at: at,\n        match: function match(n) {\n          return hasBlocks ? Editor.isBlock(editor, n) : Text.isText(n) || Editor.isInline(editor, n);\n        },\n        mode: hasBlocks ? 'lowest' : 'highest',\n        voids: voids\n      });\n      var startRef = Editor.pathRef(editor, !isInlineStart || isInlineStart && isInlineEnd ? Path.next(inlinePath) : inlinePath);\n      Transforms.insertNodes(editor, starts, {\n        at: startRef.current,\n        match: function match(n) {\n          return Text.isText(n) || Editor.isInline(editor, n);\n        },\n        mode: 'highest',\n        voids: voids\n      });\n      Transforms.insertNodes(editor, middles, {\n        at: middleRef.current,\n        match: function match(n) {\n          return Editor.isBlock(editor, n);\n        },\n        mode: 'lowest',\n        voids: voids\n      });\n      Transforms.insertNodes(editor, ends, {\n        at: endRef.current,\n        match: function match(n) {\n          return Text.isText(n) || Editor.isInline(editor, n);\n        },\n        mode: 'highest',\n        voids: voids\n      });\n\n      if (!options.at) {\n        var path;\n\n        if (ends.length > 0) {\n          path = Path.previous(endRef.current);\n        } else if (middles.length > 0) {\n          path = Path.previous(middleRef.current);\n        } else {\n          path = Path.previous(startRef.current);\n        }\n\n        var _end2 = Editor.end(editor, path);\n\n        Transforms.select(editor, _end2);\n      }\n\n      startRef.unref();\n      middleRef.unref();\n      endRef.unref();\n    });\n  },\n\n  /**\r\n   * Insert a string of text in the Editor.\r\n   */\n  insertText: function insertText(editor, text) {\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    Editor.withoutNormalizing(editor, function () {\n      var _options$voids20 = options.voids,\n          voids = _options$voids20 === void 0 ? false : _options$voids20;\n      var _options$at17 = options.at,\n          at = _options$at17 === void 0 ? editor.selection : _options$at17;\n\n      if (!at) {\n        return;\n      }\n\n      if (Path.isPath(at)) {\n        at = Editor.range(editor, at);\n      }\n\n      if (Range.isRange(at)) {\n        if (Range.isCollapsed(at)) {\n          at = at.anchor;\n        } else {\n          var end = Range.end(at);\n\n          if (!voids && Editor.void(editor, {\n            at: end\n          })) {\n            return;\n          }\n\n          var pointRef = Editor.pointRef(editor, end);\n          Transforms.delete(editor, {\n            at: at,\n            voids: voids\n          });\n          at = pointRef.unref();\n          Transforms.setSelection(editor, {\n            anchor: at,\n            focus: at\n          });\n        }\n      }\n\n      if (!voids && Editor.void(editor, {\n        at: at\n      })) {\n        return;\n      }\n\n      var _at = at,\n          path = _at.path,\n          offset = _at.offset;\n      if (text.length > 0) editor.apply({\n        type: 'insert_text',\n        path: path,\n        offset: offset,\n        text: text\n      });\n    });\n  }\n};\n\nfunction ownKeys$9(object, enumerableOnly) {\n  var keys = Object.keys(object);\n\n  if (Object.getOwnPropertySymbols) {\n    var symbols = Object.getOwnPropertySymbols(object);\n    if (enumerableOnly) symbols = symbols.filter(function (sym) {\n      return Object.getOwnPropertyDescriptor(object, sym).enumerable;\n    });\n    keys.push.apply(keys, symbols);\n  }\n\n  return keys;\n}\n\nfunction _objectSpread$9(target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i] != null ? arguments[i] : {};\n\n    if (i % 2) {\n      ownKeys$9(Object(source), true).forEach(function (key) {\n        _defineProperty(target, key, source[key]);\n      });\n    } else if (Object.getOwnPropertyDescriptors) {\n      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));\n    } else {\n      ownKeys$9(Object(source)).forEach(function (key) {\n        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));\n      });\n    }\n  }\n\n  return target;\n}\n\nvar Transforms = _objectSpread$9(_objectSpread$9(_objectSpread$9(_objectSpread$9({}, GeneralTransforms), NodeTransforms), SelectionTransforms), TextTransforms);\n\nexport { Editor, Element, Location, Node, Operation, Path, PathRef, Point, PointRef, Range, RangeRef, Span, Text, Transforms, createEditor };"],"sourceRoot":""}