slate 0.115.1 → 0.116.0

package/dist/index.es.js

@@ -1,4 +1,4 @@
-import { createDraft, finishDraft, isDraft, produce } from 'immer';
+import { produce } from 'immer';
 
 // eslint-disable-next-line no-redeclare
 var PathRef = {
@@ -372,280 +372,337 @@ function _defineProperty(obj, key, value) {
 
 function ownKeys$e(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread$e(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$e(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$e(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-var applyToDraft = (editor, selection, op) => {
-  switch (op.type) {
-    case 'insert_node':
-      {
-        var {
-          path,
-          node
-        } = op;
-        var parent = Node.parent(editor, path);
-        var index = path[path.length - 1];
-        if (index > parent.children.length) {
-          throw new Error("Cannot apply an \"insert_node\" operation at path [".concat(path, "] because the destination is past the end of the node."));
-        }
-        parent.children.splice(index, 0, node);
-        if (selection) {
-          for (var [point, key] of Range.points(selection)) {
-            selection[key] = Point.transform(point, op);
-          }
-        }
-        break;
-      }
-    case 'insert_text':
-      {
-        var {
-          path: _path,
-          offset,
-          text
-        } = op;
-        if (text.length === 0) break;
-        var _node = Node.leaf(editor, _path);
-        var before = _node.text.slice(0, offset);
-        var after = _node.text.slice(offset);
-        _node.text = before + text + after;
-        if (selection) {
-          for (var [_point, _key] of Range.points(selection)) {
-            selection[_key] = Point.transform(_point, op);
-          }
-        }
-        break;
+var insertChildren = function insertChildren(xs, index) {
+  for (var _len = arguments.length, newValues = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    newValues[_key - 2] = arguments[_key];
+  }
+  return [...xs.slice(0, index), ...newValues, ...xs.slice(index)];
+};
+var replaceChildren = function replaceChildren(xs, index, removeCount) {
+  for (var _len2 = arguments.length, newValues = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
+    newValues[_key2 - 3] = arguments[_key2];
+  }
+  return [...xs.slice(0, index), ...newValues, ...xs.slice(index + removeCount)];
+};
+var removeChildren = replaceChildren;
+/**
+ * Replace a descendant with a new node, replacing all ancestors
+ */
+var modifyDescendant = (editor, path, f) => {
+  if (path.length === 0) {
+    throw new Error('Cannot modify the editor');
+  }
+  var node = Node.get(editor, path);
+  var slicedPath = path.slice();
+  var modifiedNode = f(node);
+  while (slicedPath.length > 1) {
+    var _index = slicedPath.pop();
+    var ancestorNode = Node.get(editor, slicedPath);
+    modifiedNode = _objectSpread$e(_objectSpread$e({}, ancestorNode), {}, {
+      children: replaceChildren(ancestorNode.children, _index, 1, modifiedNode)
+    });
+  }
+  var index = slicedPath.pop();
+  editor.children = replaceChildren(editor.children, index, 1, modifiedNode);
+};
+/**
+ * Replace the children of a node, replacing all ancestors
+ */
+var modifyChildren = (editor, path, f) => {
+  if (path.length === 0) {
+    editor.children = f(editor.children);
+  } else {
+    modifyDescendant(editor, path, node => {
+      if (Text.isText(node)) {
+        throw new Error("Cannot get the element at path [".concat(path, "] because it refers to a leaf node: ").concat(Scrubber.stringify(node)));
       }
-    case 'merge_node':
-      {
-        var {
-          path: _path2
-        } = op;
-        var _node2 = Node.get(editor, _path2);
-        var prevPath = Path.previous(_path2);
-        var prev = Node.get(editor, prevPath);
-        var _parent = Node.parent(editor, _path2);
-        var _index = _path2[_path2.length - 1];
-        if (Text.isText(_node2) && Text.isText(prev)) {
-          prev.text += _node2.text;
-        } else if (!Text.isText(_node2) && !Text.isText(prev)) {
-          prev.children.push(..._node2.children);
-        } else {
-          throw new Error("Cannot apply a \"merge_node\" operation at path [".concat(_path2, "] to nodes of different interfaces: ").concat(Scrubber.stringify(_node2), " ").concat(Scrubber.stringify(prev)));
+      return _objectSpread$e(_objectSpread$e({}, node), {}, {
+        children: f(node.children)
+      });
+    });
+  }
+};
+/**
+ * Replace a leaf, replacing all ancestors
+ */
+var modifyLeaf = (editor, path, f) => modifyDescendant(editor, path, node => {
+  if (!Text.isText(node)) {
+    throw new Error("Cannot get the leaf node at path [".concat(path, "] because it refers to a non-leaf node: ").concat(Scrubber.stringify(node)));
+  }
+  return f(node);
+});
+// eslint-disable-next-line no-redeclare
+var GeneralTransforms = {
+  transform(editor, op) {
+    var transformSelection = false;
+    switch (op.type) {
+      case 'insert_node':
+        {
+          var {
+            path,
+            node
+          } = op;
+          modifyChildren(editor, Path.parent(path), children => {
+            var index = path[path.length - 1];
+            if (index > children.length) {
+              throw new Error("Cannot apply an \"insert_node\" operation at path [".concat(path, "] because the destination is past the end of the node."));
+            }
+            return insertChildren(children, index, node);
+          });
+          transformSelection = true;
+          break;
         }
-        _parent.children.splice(_index, 1);
-        if (selection) {
-          for (var [_point2, _key2] of Range.points(selection)) {
-            selection[_key2] = Point.transform(_point2, op);
-          }
+      case 'insert_text':
+        {
+          var {
+            path: _path,
+            offset,
+            text
+          } = op;
+          if (text.length === 0) break;
+          modifyLeaf(editor, _path, node => {
+            var before = node.text.slice(0, offset);
+            var after = node.text.slice(offset);
+            return _objectSpread$e(_objectSpread$e({}, node), {}, {
+              text: before + text + after
+            });
+          });
+          transformSelection = true;
+          break;
         }
-        break;
-      }
-    case 'move_node':
-      {
-        var {
-          path: _path3,
-          newPath
-        } = op;
-        if (Path.isAncestor(_path3, newPath)) {
-          throw new Error("Cannot move a path [".concat(_path3, "] to new path [").concat(newPath, "] because the destination is inside itself."));
+      case 'merge_node':
+        {
+          var {
+            path: _path2
+          } = op;
+          var index = _path2[_path2.length - 1];
+          var prevPath = Path.previous(_path2);
+          var prevIndex = prevPath[prevPath.length - 1];
+          modifyChildren(editor, Path.parent(_path2), children => {
+            var node = children[index];
+            var prev = children[prevIndex];
+            var newNode;
+            if (Text.isText(node) && Text.isText(prev)) {
+              newNode = _objectSpread$e(_objectSpread$e({}, prev), {}, {
+                text: prev.text + node.text
+              });
+            } else if (!Text.isText(node) && !Text.isText(prev)) {
+              newNode = _objectSpread$e(_objectSpread$e({}, prev), {}, {
+                children: prev.children.concat(node.children)
+              });
+            } else {
+              throw new Error("Cannot apply a \"merge_node\" operation at path [".concat(_path2, "] to nodes of different interfaces: ").concat(Scrubber.stringify(node), " ").concat(Scrubber.stringify(prev)));
+            }
+            return replaceChildren(children, prevIndex, 2, newNode);
+          });
+          transformSelection = true;
+          break;
         }
-        var _node3 = Node.get(editor, _path3);
-        var _parent2 = Node.parent(editor, _path3);
-        var _index2 = _path3[_path3.length - 1];
-        // This is tricky, but since the `path` and `newPath` both refer to
-        // the same snapshot in time, there's a mismatch. After either
-        // removing the original position, the second step's path can be out
-        // of date. So instead of using the `op.newPath` directly, we
-        // transform `op.path` to ascertain what the `newPath` would be after
-        // the operation was applied.
-        _parent2.children.splice(_index2, 1);
-        var truePath = Path.transform(_path3, op);
-        var newParent = Node.get(editor, Path.parent(truePath));
-        var newIndex = truePath[truePath.length - 1];
-        newParent.children.splice(newIndex, 0, _node3);
-        if (selection) {
-          for (var [_point3, _key3] of Range.points(selection)) {
-            selection[_key3] = Point.transform(_point3, op);
+      case 'move_node':
+        {
+          var {
+            path: _path3,
+            newPath
+          } = op;
+          var _index2 = _path3[_path3.length - 1];
+          if (Path.isAncestor(_path3, newPath)) {
+            throw new Error("Cannot move a path [".concat(_path3, "] to new path [").concat(newPath, "] because the destination is inside itself."));
           }
+          var _node = Node.get(editor, _path3);
+          modifyChildren(editor, Path.parent(_path3), children => removeChildren(children, _index2, 1));
+          // This is tricky, but since the `path` and `newPath` both refer to
+          // the same snapshot in time, there's a mismatch. After either
+          // removing the original position, the second step's path can be out
+          // of date. So instead of using the `op.newPath` directly, we
+          // transform `op.path` to ascertain what the `newPath` would be after
+          // the operation was applied.
+          var truePath = Path.transform(_path3, op);
+          var newIndex = truePath[truePath.length - 1];
+          modifyChildren(editor, Path.parent(truePath), children => insertChildren(children, newIndex, _node));
+          transformSelection = true;
+          break;
         }
-        break;
-      }
-    case 'remove_node':
-      {
-        var {
-          path: _path4
-        } = op;
-        var _index3 = _path4[_path4.length - 1];
-        var _parent3 = Node.parent(editor, _path4);
-        _parent3.children.splice(_index3, 1);
-        // Transform all the points in the value, but if the point was in the
-        // node that was removed we need to update the range or remove it.
-        if (selection) {
-          for (var [_point4, _key4] of Range.points(selection)) {
-            var result = Point.transform(_point4, op);
-            if (selection != null && result != null) {
-              selection[_key4] = result;
-            } else {
-              var _prev = void 0;
-              var next = void 0;
-              for (var [n, p] of Node.texts(editor)) {
-                if (Path.compare(p, _path4) === -1) {
-                  _prev = [n, p];
-                } else {
-                  next = [n, p];
-                  break;
+      case 'remove_node':
+        {
+          var {
+            path: _path4
+          } = op;
+          var _index3 = _path4[_path4.length - 1];
+          modifyChildren(editor, Path.parent(_path4), children => removeChildren(children, _index3, 1));
+          // Transform all the points in the value, but if the point was in the
+          // node that was removed we need to update the range or remove it.
+          if (editor.selection) {
+            var selection = _objectSpread$e({}, editor.selection);
+            for (var [point, key] of Range.points(selection)) {
+              var result = Point.transform(point, op);
+              if (selection != null && result != null) {
+                selection[key] = result;
+              } else {
+                var prev = void 0;
+                var next = void 0;
+                for (var [n, p] of Node.texts(editor)) {
+                  if (Path.compare(p, _path4) === -1) {
+                    prev = [n, p];
+                  } else {
+                    next = [n, p];
+                    break;
+                  }
                 }
-              }
-              var preferNext = false;
-              if (_prev && next) {
-                if (Path.equals(next[1], _path4)) {
-                  preferNext = !Path.hasPrevious(next[1]);
+                var preferNext = false;
+                if (prev && next) {
+                  if (Path.equals(next[1], _path4)) {
+                    preferNext = !Path.hasPrevious(next[1]);
+                  } else {
+                    preferNext = Path.common(prev[1], _path4).length < Path.common(next[1], _path4).length;
+                  }
+                }
+                if (prev && !preferNext) {
+                  selection[key] = {
+                    path: prev[1],
+                    offset: prev[0].text.length
+                  };
+                } else if (next) {
+                  selection[key] = {
+                    path: next[1],
+                    offset: 0
+                  };
                 } else {
-                  preferNext = Path.common(_prev[1], _path4).length < Path.common(next[1], _path4).length;
+                  selection = null;
                 }
               }
-              if (_prev && !preferNext) {
-                _point4.path = _prev[1];
-                _point4.offset = _prev[0].text.length;
-              } else if (next) {
-                _point4.path = next[1];
-                _point4.offset = 0;
-              } else {
-                selection = null;
-              }
             }
+            editor.selection = selection;
           }
+          break;
         }
-        break;
-      }
-    case 'remove_text':
-      {
-        var {
-          path: _path5,
-          offset: _offset,
-          text: _text
-        } = op;
-        if (_text.length === 0) break;
-        var _node4 = Node.leaf(editor, _path5);
-        var _before = _node4.text.slice(0, _offset);
-        var _after = _node4.text.slice(_offset + _text.length);
-        _node4.text = _before + _after;
-        if (selection) {
-          for (var [_point5, _key5] of Range.points(selection)) {
-            selection[_key5] = Point.transform(_point5, op);
-          }
-        }
-        break;
-      }
-    case 'set_node':
-      {
-        var {
-          path: _path6,
-          properties,
-          newProperties
-        } = op;
-        if (_path6.length === 0) {
-          throw new Error("Cannot set properties on the root node!");
+      case 'remove_text':
+        {
+          var {
+            path: _path5,
+            offset: _offset,
+            text: _text
+          } = op;
+          if (_text.length === 0) break;
+          modifyLeaf(editor, _path5, node => {
+            var before = node.text.slice(0, _offset);
+            var after = node.text.slice(_offset + _text.length);
+            return _objectSpread$e(_objectSpread$e({}, node), {}, {
+              text: before + after
+            });
+          });
+          transformSelection = true;
+          break;
         }
-        var _node5 = Node.get(editor, _path6);
-        for (var _key6 in newProperties) {
-          if (_key6 === 'children' || _key6 === 'text') {
-            throw new Error("Cannot set the \"".concat(_key6, "\" property of nodes!"));
-          }
-          var value = newProperties[_key6];
-          if (value == null) {
-            delete _node5[_key6];
-          } else {
-            _node5[_key6] = value;
+      case 'set_node':
+        {
+          var {
+            path: _path6,
+            properties,
+            newProperties
+          } = op;
+          if (_path6.length === 0) {
+            throw new Error("Cannot set properties on the root node!");
           }
+          modifyDescendant(editor, _path6, node => {
+            var newNode = _objectSpread$e({}, node);
+            for (var _key3 in newProperties) {
+              if (_key3 === 'children' || _key3 === 'text') {
+                throw new Error("Cannot set the \"".concat(_key3, "\" property of nodes!"));
+              }
+              var value = newProperties[_key3];
+              if (value == null) {
+                delete newNode[_key3];
+              } else {
+                newNode[_key3] = value;
+              }
+            }
+            // properties that were previously defined, but are now missing, must be deleted
+            for (var _key4 in properties) {
+              if (!newProperties.hasOwnProperty(_key4)) {
+                delete newNode[_key4];
+              }
+            }
+            return newNode;
+          });
+          break;
         }
-        // properties that were previously defined, but are now missing, must be deleted
-        for (var _key7 in properties) {
-          if (!newProperties.hasOwnProperty(_key7)) {
-            delete _node5[_key7];
+      case 'set_selection':
+        {
+          var {
+            newProperties: _newProperties
+          } = op;
+          if (_newProperties == null) {
+            editor.selection = null;
+            break;
           }
-        }
-        break;
-      }
-    case 'set_selection':
-      {
-        var {
-          newProperties: _newProperties
-        } = op;
-        if (_newProperties == null) {
-          selection = _newProperties;
-        } else {
-          if (selection == null) {
+          if (editor.selection == null) {
             if (!Range.isRange(_newProperties)) {
               throw new Error("Cannot apply an incomplete \"set_selection\" operation properties ".concat(Scrubber.stringify(_newProperties), " when there is no current selection."));
             }
-            selection = _objectSpread$e({}, _newProperties);
+            editor.selection = _objectSpread$e({}, _newProperties);
+            break;
           }
-          for (var _key8 in _newProperties) {
-            var _value = _newProperties[_key8];
-            if (_value == null) {
-              if (_key8 === 'anchor' || _key8 === 'focus') {
-                throw new Error("Cannot remove the \"".concat(_key8, "\" selection property"));
+          var _selection = _objectSpread$e({}, editor.selection);
+          for (var _key5 in _newProperties) {
+            var value = _newProperties[_key5];
+            if (value == null) {
+              if (_key5 === 'anchor' || _key5 === 'focus') {
+                throw new Error("Cannot remove the \"".concat(_key5, "\" selection property"));
               }
-              delete selection[_key8];
+              delete _selection[_key5];
             } else {
-              selection[_key8] = _value;
+              _selection[_key5] = value;
             }
           }
+          editor.selection = _selection;
+          break;
         }
-        break;
-      }
-    case 'split_node':
-      {
-        var {
-          path: _path7,
-          position,
-          properties: _properties
-        } = op;
-        if (_path7.length === 0) {
-          throw new Error("Cannot apply a \"split_node\" operation at path [".concat(_path7, "] because the root node cannot be split."));
-        }
-        var _node6 = Node.get(editor, _path7);
-        var _parent4 = Node.parent(editor, _path7);
-        var _index4 = _path7[_path7.length - 1];
-        var newNode;
-        if (Text.isText(_node6)) {
-          var _before2 = _node6.text.slice(0, position);
-          var _after2 = _node6.text.slice(position);
-          _node6.text = _before2;
-          newNode = _objectSpread$e(_objectSpread$e({}, _properties), {}, {
-            text: _after2
-          });
-        } else {
-          var _before3 = _node6.children.slice(0, position);
-          var _after3 = _node6.children.slice(position);
-          _node6.children = _before3;
-          newNode = _objectSpread$e(_objectSpread$e({}, _properties), {}, {
-            children: _after3
-          });
-        }
-        _parent4.children.splice(_index4 + 1, 0, newNode);
-        if (selection) {
-          for (var [_point6, _key9] of Range.points(selection)) {
-            selection[_key9] = Point.transform(_point6, op);
+      case 'split_node':
+        {
+          var {
+            path: _path7,
+            position,
+            properties: _properties
+          } = op;
+          var _index4 = _path7[_path7.length - 1];
+          if (_path7.length === 0) {
+            throw new Error("Cannot apply a \"split_node\" operation at path [".concat(_path7, "] because the root node cannot be split."));
           }
+          modifyChildren(editor, Path.parent(_path7), children => {
+            var node = children[_index4];
+            var newNode;
+            var nextNode;
+            if (Text.isText(node)) {
+              var before = node.text.slice(0, position);
+              var after = node.text.slice(position);
+              newNode = _objectSpread$e(_objectSpread$e({}, node), {}, {
+                text: before
+              });
+              nextNode = _objectSpread$e(_objectSpread$e({}, _properties), {}, {
+                text: after
+              });
+            } else {
+              var _before = node.children.slice(0, position);
+              var _after = node.children.slice(position);
+              newNode = _objectSpread$e(_objectSpread$e({}, node), {}, {
+                children: _before
+              });
+              nextNode = _objectSpread$e(_objectSpread$e({}, _properties), {}, {
+                children: _after
+              });
+            }
+            return replaceChildren(children, _index4, 1, newNode, nextNode);
+          });
+          transformSelection = true;
+          break;
         }
-        break;
-      }
-  }
-  return selection;
-};
-// eslint-disable-next-line no-redeclare
-var GeneralTransforms = {
-  transform(editor, op) {
-    editor.children = createDraft(editor.children);
-    var selection = editor.selection && createDraft(editor.selection);
-    try {
-      selection = applyToDraft(editor, selection, op);
-    } finally {
-      editor.children = finishDraft(editor.children);
-      if (selection) {
-        editor.selection = isDraft(selection) ? finishDraft(selection) : selection;
-      } else {
-        editor.selection = null;
+    }
+    if (transformSelection && editor.selection) {
+      var _selection2 = _objectSpread$e({}, editor.selection);
+      for (var [_point, _key6] of Range.points(_selection2)) {
+        _selection2[_key6] = Point.transform(_point, op);
       }
+      editor.selection = _selection2;
     }
   }
 };
@@ -874,51 +931,51 @@ var Range = {
   },
   transform(range, op) {
     var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    return produce(range, r => {
-      if (r === null) {
-        return null;
-      }
-      var {
-        affinity = 'inward'
-      } = options;
-      var affinityAnchor;
-      var affinityFocus;
-      if (affinity === 'inward') {
-        // If the range is collapsed, make sure to use the same affinity to
-        // avoid the two points passing each other and expanding in the opposite
-        // direction
-        var isCollapsed = Range.isCollapsed(r);
-        if (Range.isForward(r)) {
-          affinityAnchor = 'forward';
-          affinityFocus = isCollapsed ? affinityAnchor : 'backward';
-        } else {
-          affinityAnchor = 'backward';
-          affinityFocus = isCollapsed ? affinityAnchor : 'forward';
-        }
-      } else if (affinity === 'outward') {
-        if (Range.isForward(r)) {
-          affinityAnchor = 'backward';
-          affinityFocus = 'forward';
-        } else {
-          affinityAnchor = 'forward';
-          affinityFocus = 'backward';
-        }
+    if (range === null) {
+      return null;
+    }
+    var {
+      affinity = 'inward'
+    } = options;
+    var affinityAnchor;
+    var affinityFocus;
+    if (affinity === 'inward') {
+      // If the range is collapsed, make sure to use the same affinity to
+      // avoid the two points passing each other and expanding in the opposite
+      // direction
+      var isCollapsed = Range.isCollapsed(range);
+      if (Range.isForward(range)) {
+        affinityAnchor = 'forward';
+        affinityFocus = isCollapsed ? affinityAnchor : 'backward';
       } else {
-        affinityAnchor = affinity;
-        affinityFocus = affinity;
+        affinityAnchor = 'backward';
+        affinityFocus = isCollapsed ? affinityAnchor : 'forward';
       }
-      var anchor = Point.transform(r.anchor, op, {
-        affinity: affinityAnchor
-      });
-      var focus = Point.transform(r.focus, op, {
-        affinity: affinityFocus
-      });
-      if (!anchor || !focus) {
-        return null;
+    } else if (affinity === 'outward') {
+      if (Range.isForward(range)) {
+        affinityAnchor = 'backward';
+        affinityFocus = 'forward';
+      } else {
+        affinityAnchor = 'forward';
+        affinityFocus = 'backward';
       }
-      r.anchor = anchor;
-      r.focus = focus;
+    } else {
+      affinityAnchor = affinity;
+      affinityFocus = affinity;
+    }
+    var anchor = Point.transform(range.anchor, op, {
+      affinity: affinityAnchor
+    });
+    var focus = Point.transform(range.focus, op, {
+      affinity: affinityFocus
     });
+    if (!anchor || !focus) {
+      return null;
+    }
+    return {
+      anchor,
+      focus
+    };
   }
 };
 
@@ -1680,72 +1737,76 @@ var Point = {
   },
   transform(point, op) {
     var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    return produce(point, p => {
-      if (p === null) {
-        return null;
-      }
-      var {
-        affinity = 'forward'
-      } = options;
-      var {
-        path,
-        offset
-      } = p;
-      switch (op.type) {
-        case 'insert_node':
-        case 'move_node':
-          {
-            p.path = Path.transform(path, op, options);
-            break;
+    if (point === null) {
+      return null;
+    }
+    var {
+      affinity = 'forward'
+    } = options;
+    var {
+      path,
+      offset
+    } = point;
+    switch (op.type) {
+      case 'insert_node':
+      case 'move_node':
+        {
+          path = Path.transform(path, op, options);
+          break;
+        }
+      case 'insert_text':
+        {
+          if (Path.equals(op.path, path) && (op.offset < offset || op.offset === offset && affinity === 'forward')) {
+            offset += op.text.length;
           }
-        case 'insert_text':
-          {
-            if (Path.equals(op.path, path) && (op.offset < offset || op.offset === offset && affinity === 'forward')) {
-              p.offset += op.text.length;
-            }
-            break;
+          break;
+        }
+      case 'merge_node':
+        {
+          if (Path.equals(op.path, path)) {
+            offset += op.position;
           }
-        case 'merge_node':
-          {
-            if (Path.equals(op.path, path)) {
-              p.offset += op.position;
-            }
-            p.path = Path.transform(path, op, options);
-            break;
+          path = Path.transform(path, op, options);
+          break;
+        }
+      case 'remove_text':
+        {
+          if (Path.equals(op.path, path) && op.offset <= offset) {
+            offset -= Math.min(offset - op.offset, op.text.length);
           }
-        case 'remove_text':
-          {
-            if (Path.equals(op.path, path) && op.offset <= offset) {
-              p.offset -= Math.min(offset - op.offset, op.text.length);
-            }
-            break;
+          break;
+        }
+      case 'remove_node':
+        {
+          if (Path.equals(op.path, path) || Path.isAncestor(op.path, path)) {
+            return null;
           }
-        case 'remove_node':
-          {
-            if (Path.equals(op.path, path) || Path.isAncestor(op.path, path)) {
+          path = Path.transform(path, op, options);
+          break;
+        }
+      case 'split_node':
+        {
+          if (Path.equals(op.path, path)) {
+            if (op.position === offset && affinity == null) {
               return null;
+            } else if (op.position < offset || op.position === offset && affinity === 'forward') {
+              offset -= op.position;
+              path = Path.transform(path, op, _objectSpread$b(_objectSpread$b({}, options), {}, {
+                affinity: 'forward'
+              }));
             }
-            p.path = Path.transform(path, op, options);
-            break;
-          }
-        case 'split_node':
-          {
-            if (Path.equals(op.path, path)) {
-              if (op.position === offset && affinity == null) {
-                return null;
-              } else if (op.position < offset || op.position === offset && affinity === 'forward') {
-                p.offset -= op.position;
-                p.path = Path.transform(path, op, _objectSpread$b(_objectSpread$b({}, options), {}, {
-                  affinity: 'forward'
-                }));
-              }
-            } else {
-              p.path = Path.transform(path, op, options);
-            }
-            break;
+          } else {
+            path = Path.transform(path, op, options);
           }
-      }
-    });
+          break;
+        }
+      default:
+        return point;
+    }
+    return {
+      path,
+      offset
+    };
   }
 };