slate 0.82.1 → 0.84.0

package/dist/index.es.js

@@ -2847,6 +2847,7 @@ var Operation = {
 
 };
 
+// eslint-disable-next-line no-redeclare
 var Path = {
   /**
    * Get a list of ancestor paths for a given path.
@@ -3130,131 +3131,130 @@ var Path = {
    */
   transform(path, operation) {
     var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    return produce(path, p => {
-      var {
-        affinity = 'forward'
-      } = options; // PERF: Exit early if the operation is guaranteed not to have an effect.
-
-      if (!path || (path === null || path === void 0 ? void 0 : path.length) === 0) {
-        return;
-      }
+    if (!path) return null; // PERF: use destructing instead of immer
 
-      if (p === null) {
-        return null;
-      }
+    var p = [...path];
+    var {
+      affinity = 'forward'
+    } = options; // PERF: Exit early if the operation is guaranteed not to have an effect.
 
-      switch (operation.type) {
-        case 'insert_node':
-          {
-            var {
-              path: op
-            } = operation;
+    if (path.length === 0) {
+      return p;
+    }
 
-            if (Path.equals(op, p) || Path.endsBefore(op, p) || Path.isAncestor(op, p)) {
-              p[op.length - 1] += 1;
-            }
+    switch (operation.type) {
+      case 'insert_node':
+        {
+          var {
+            path: op
+          } = operation;
 
-            break;
+          if (Path.equals(op, p) || Path.endsBefore(op, p) || Path.isAncestor(op, p)) {
+            p[op.length - 1] += 1;
           }
 
-        case 'remove_node':
-          {
-            var {
-              path: _op
-            } = operation;
+          break;
+        }
 
-            if (Path.equals(_op, p) || Path.isAncestor(_op, p)) {
-              return null;
-            } else if (Path.endsBefore(_op, p)) {
-              p[_op.length - 1] -= 1;
-            }
+      case 'remove_node':
+        {
+          var {
+            path: _op
+          } = operation;
 
-            break;
+          if (Path.equals(_op, p) || Path.isAncestor(_op, p)) {
+            return null;
+          } else if (Path.endsBefore(_op, p)) {
+            p[_op.length - 1] -= 1;
           }
 
-        case 'merge_node':
-          {
-            var {
-              path: _op2,
-              position
-            } = operation;
-
-            if (Path.equals(_op2, p) || Path.endsBefore(_op2, p)) {
-              p[_op2.length - 1] -= 1;
-            } else if (Path.isAncestor(_op2, p)) {
-              p[_op2.length - 1] -= 1;
-              p[_op2.length] += position;
-            }
+          break;
+        }
 
-            break;
+      case 'merge_node':
+        {
+          var {
+            path: _op2,
+            position
+          } = operation;
+
+          if (Path.equals(_op2, p) || Path.endsBefore(_op2, p)) {
+            p[_op2.length - 1] -= 1;
+          } else if (Path.isAncestor(_op2, p)) {
+            p[_op2.length - 1] -= 1;
+            p[_op2.length] += position;
           }
 
-        case 'split_node':
-          {
-            var {
-              path: _op3,
-              position: _position
-            } = operation;
-
-            if (Path.equals(_op3, p)) {
-              if (affinity === 'forward') {
-                p[p.length - 1] += 1;
-              } else if (affinity === 'backward') ; else {
-                return null;
-              }
-            } else if (Path.endsBefore(_op3, p)) {
-              p[_op3.length - 1] += 1;
-            } else if (Path.isAncestor(_op3, p) && path[_op3.length] >= _position) {
-              p[_op3.length - 1] += 1;
-              p[_op3.length] -= _position;
-            }
+          break;
+        }
 
-            break;
+      case 'split_node':
+        {
+          var {
+            path: _op3,
+            position: _position
+          } = operation;
+
+          if (Path.equals(_op3, p)) {
+            if (affinity === 'forward') {
+              p[p.length - 1] += 1;
+            } else if (affinity === 'backward') ; else {
+              return null;
+            }
+          } else if (Path.endsBefore(_op3, p)) {
+            p[_op3.length - 1] += 1;
+          } else if (Path.isAncestor(_op3, p) && path[_op3.length] >= _position) {
+            p[_op3.length - 1] += 1;
+            p[_op3.length] -= _position;
           }
 
-        case 'move_node':
-          {
-            var {
-              path: _op4,
-              newPath: onp
-            } = operation; // If the old and new path are the same, it's a no-op.
-
-            if (Path.equals(_op4, onp)) {
-              return;
-            }
+          break;
+        }
 
-            if (Path.isAncestor(_op4, p) || Path.equals(_op4, p)) {
-              var copy = onp.slice();
+      case 'move_node':
+        {
+          var {
+            path: _op4,
+            newPath: onp
+          } = operation; // If the old and new path are the same, it's a no-op.
 
-              if (Path.endsBefore(_op4, onp) && _op4.length < onp.length) {
-                copy[_op4.length - 1] -= 1;
-              }
+          if (Path.equals(_op4, onp)) {
+            return p;
+          }
 
-              return copy.concat(p.slice(_op4.length));
-            } else if (Path.isSibling(_op4, onp) && (Path.isAncestor(onp, p) || Path.equals(onp, p))) {
-              if (Path.endsBefore(_op4, p)) {
-                p[_op4.length - 1] -= 1;
-              } else {
-                p[_op4.length - 1] += 1;
-              }
-            } else if (Path.endsBefore(onp, p) || Path.equals(onp, p) || Path.isAncestor(onp, p)) {
-              if (Path.endsBefore(_op4, p)) {
-                p[_op4.length - 1] -= 1;
-              }
+          if (Path.isAncestor(_op4, p) || Path.equals(_op4, p)) {
+            var copy = onp.slice();
 
-              p[onp.length - 1] += 1;
-            } else if (Path.endsBefore(_op4, p)) {
-              if (Path.equals(onp, p)) {
-                p[onp.length - 1] += 1;
-              }
+            if (Path.endsBefore(_op4, onp) && _op4.length < onp.length) {
+              copy[_op4.length - 1] -= 1;
+            }
 
+            return copy.concat(p.slice(_op4.length));
+          } else if (Path.isSibling(_op4, onp) && (Path.isAncestor(onp, p) || Path.equals(onp, p))) {
+            if (Path.endsBefore(_op4, p)) {
+              p[_op4.length - 1] -= 1;
+            } else {
+              p[_op4.length - 1] += 1;
+            }
+          } else if (Path.endsBefore(onp, p) || Path.equals(onp, p) || Path.isAncestor(onp, p)) {
+            if (Path.endsBefore(_op4, p)) {
               p[_op4.length - 1] -= 1;
             }
 
-            break;
+            p[onp.length - 1] += 1;
+          } else if (Path.endsBefore(_op4, p)) {
+            if (Path.equals(onp, p)) {
+              p[onp.length - 1] += 1;
+            }
+
+            p[_op4.length - 1] -= 1;
           }
-      }
-    });
+
+          break;
+        }
+    }
+
+    return p;
   }
 
 };
@@ -5641,20 +5641,16 @@ var TextTransforms = {
         }
       }
 
-      for (var pathRef of pathRefs) {
-        var _path2 = pathRef.unref();
-
-        Transforms.removeNodes(editor, {
-          at: _path2,
-          voids
-        });
-      }
+      pathRefs.reverse().map(r => r.unref()).filter(r => r !== null).forEach(p => Transforms.removeNodes(editor, {
+        at: p,
+        voids
+      }));
 
       if (!endVoid) {
         var _point2 = endRef.current;
         var [_node2] = Editor.leaf(editor, _point2);
         var {
-          path: _path3
+          path: _path2
         } = _point2;
 
         var _offset = isSingleText ? start.offset : 0;
@@ -5664,7 +5660,7 @@ var TextTransforms = {
         if (_text.length > 0) {
           editor.apply({
             type: 'remove_text',
-            path: _path3,
+            path: _path2,
             offset: _offset,
             text: _text
           });