@portabletext/editor 6.4.0 → 6.5.0

package/lib/index.js

@@ -3,9 +3,9 @@ import { c } from "react/compiler-runtime";
 import { useSelector, useActorRef } from "@xstate/react";
 import React, { useRef, useEffect, useLayoutEffect, useState, createContext, useContext, useReducer, useCallback, useMemo, memo, forwardRef, Component, startTransition } from "react";
 import rawDebug from "debug";
-import { getBlockEndPoint, getBlockStartPoint, getBlockKeyFromSelectionPoint, isSelectionCollapsed, isKeyedSegment, isEqualSelectionPoints, getChildKeyFromSelectionPoint, blockOffsetToSpanSelectionPoint, defaultKeyGenerator, parseBlocks, parseBlock, isListBlock, getSelectionStartPoint as getSelectionStartPoint$1, getSelectionEndPoint as getSelectionEndPoint$1, parseAnnotation, parseMarkDefs, parseSpan, parseInlineObject, isEqualPathSegments } from "./_chunks-es/util.slice-blocks.js";
-import { isTextBlock, isSpan, compileSchema } from "@portabletext/schema";
+import { isSpan, isTextBlock, compileSchema } from "@portabletext/schema";
 import { defineSchema } from "@portabletext/schema";
+import { isTypedObject, isListBlock, getBlockEndPoint, getBlockStartPoint, getBlockKeyFromSelectionPoint, isSelectionCollapsed, isKeyedSegment, isEqualSelectionPoints, getChildKeyFromSelectionPoint, blockOffsetToSpanSelectionPoint, defaultKeyGenerator, parseBlocks, parseBlock, getSelectionStartPoint as getSelectionStartPoint$1, getSelectionEndPoint as getSelectionEndPoint$1, parseAnnotation, parseMarkDefs, parseSpan, parseInlineObject, isEqualPathSegments } from "./_chunks-es/util.slice-blocks.js";
 import scrollIntoView from "scroll-into-view-if-needed";
 import { createKeyboardShortcut, code, underline, italic as italic$1, bold as bold$1, undo as undo$1, redo as redo$1 } from "@portabletext/keyboard-shortcuts";
 import { ResizeObserver } from "@juggle/resize-observer";
@@ -50,20 +50,19 @@ function safeParse(text) {
     return console.error(error), "JSON.parse failed";
   }
 }
-const isObject = (value) => typeof value == "object" && value !== null;
-function isElement(value, schema) {
-  return isObject(value) && value._type === schema.block.name;
-}
-function isText(value, schema) {
-  return isObject(value) && value._type === schema.span.name;
+function isObjectNode(context, node2) {
+  return isTypedObject(node2) && node2._type !== context.schema.block.name && node2._type !== context.schema.span.name;
 }
-function isObjectNode(value, schema) {
-  return isObject(value) && typeof value._type == "string" && typeof value._key == "string" && value._type !== schema.block.name && value._type !== schema.span.name;
-}
-function isLeaf(value, schema) {
-  return isText(value, schema) || isObjectNode(value, schema);
+function isLeaf(node2, schema) {
+  return isSpan({
+    schema
+  }, node2) || isObjectNode({
+    schema
+  }, node2);
 }
 function getNodeIf(root, path2, schema) {
+  if (path2.length === 0)
+    return;
   let node2 = root;
   for (let i = 0; i < path2.length; i++) {
     const p = path2[i];
@@ -84,30 +83,44 @@ function getNode(root, path2, schema) {
 }
 function getFirst(root, path2, schema) {
   const p = path2.slice();
-  let n2 = getNode(root, p, schema);
+  let n2;
+  if (path2.length === 0) {
+    if (isLeaf(root, schema) || root.children.length === 0)
+      throw new Error("Cannot get the first descendant of a leaf or empty root");
+    n2 = root.children[0], p.push(0);
+  } else
+    n2 = getNode(root, p, schema);
   for (; n2 && !isLeaf(n2, schema); ) {
-    const ancestor = n2;
-    if (ancestor.children.length === 0)
+    const ancestorChildren = n2.children;
+    if (ancestorChildren.length === 0)
       break;
-    n2 = ancestor.children[0], p.push(0);
+    n2 = ancestorChildren[0], p.push(0);
   }
   return [n2, p];
 }
 function getLast(root, path2, schema) {
   const p = path2.slice();
-  let n2 = getNode(root, p, schema);
+  let n2;
+  if (path2.length === 0) {
+    if (isLeaf(root, schema) || root.children.length === 0)
+      throw new Error("Cannot get the last descendant of a leaf or empty root");
+    const i = root.children.length - 1;
+    n2 = root.children[i], p.push(i);
+  } else
+    n2 = getNode(root, p, schema);
   for (; n2 && !isLeaf(n2, schema); ) {
-    const ancestor = n2;
-    if (ancestor.children.length === 0)
+    const ancestorChildren = n2.children;
+    if (ancestorChildren.length === 0)
       break;
-    const i = ancestor.children.length - 1;
-    n2 = ancestor.children[i], p.push(i);
+    const i = ancestorChildren.length - 1;
+    n2 = ancestorChildren[i], p.push(i);
   }
   return [n2, p];
 }
 function isPath(value) {
   return Array.isArray(value) && (value.length === 0 || typeof value[0] == "number");
 }
+const isObject = (value) => typeof value == "object" && value !== null;
 function isPoint(value) {
   return isObject(value) && typeof value.offset == "number" && isPath(value.path);
 }
@@ -165,12 +178,18 @@ function point(editor, at, options = {}) {
       path2 = firstPath;
     }
     const node2 = getNode(editor, path2, editor.schema);
-    if (!isText(node2, editor.schema) && !isElement(node2, editor.schema) && !isEditor(node2))
+    if (!isSpan({
+      schema: editor.schema
+    }, node2) && !isTextBlock({
+      schema: editor.schema
+    }, node2) && !isEditor(node2))
       return {
         path: path2,
         offset: 0
       };
-    if (!isText(node2, editor.schema))
+    if (!isSpan({
+      schema: editor.schema
+    }, node2))
       throw new Error(`Cannot get the ${edge} point in the node at path [${at}] because it has no ${edge} text node.`);
     return {
       path: path2,
@@ -191,26 +210,9 @@ function end(editor, at) {
 function isAncestorPath(path2, another) {
   return path2.length < another.length && comparePaths(path2, another) === 0;
 }
-function nextPath(path2) {
-  if (path2.length === 0)
-    throw new Error(`Cannot get the next path of a root path [${path2}], because it has no next index.`);
-  const last = path2[path2.length - 1];
-  return path2.slice(0, -1).concat(last + 1);
-}
 function pathEquals(path2, another) {
   return path2.length === another.length && path2.every((n2, i) => n2 === another[i]);
 }
-function pathHasPrevious(path2) {
-  return path2[path2.length - 1] > 0;
-}
-function previousPath(path2) {
-  if (path2.length === 0)
-    throw new Error(`Cannot get the previous path of a root path [${path2}], because it has no previous index.`);
-  const last = path2[path2.length - 1];
-  if (last <= 0)
-    throw new Error(`Cannot get the previous path of a first child path [${path2}] because it would result in a negative index.`);
-  return path2.slice(0, -1).concat(last - 1);
-}
 const getCharacterDistance = (str, isRTL = !1) => {
   const isLTR = !isRTL, codepoints = isRTL ? codepointsIteratorRTL(str) : str;
   let left = CodepointType.None, right = CodepointType.None, distance = 0, gb11 = null, gb12Or13 = null;
@@ -312,23 +314,9 @@ const endingEmojiZWJ = new RegExp("\\p{ExtPict}[\\p{Gr_Ext}\\p{EMod}]*\\u200D$",
   return match2 === null ? !1 : match2[0].length / 2 % 2 === 1;
 };
 function hasInlines(editor, element) {
-  return element.children.some((n2) => isText(n2, editor.schema) || editor.isInline(n2));
-}
-function hasNode(root, path2, schema) {
-  let node2 = root;
-  for (let i = 0; i < path2.length; i++) {
-    const p = path2[i];
-    if (isLeaf(node2, schema))
-      return !1;
-    const children = node2.children;
-    if (!children[p])
-      return !1;
-    node2 = children[p];
-  }
-  return !0;
-}
-function hasPath(editor, path2) {
-  return hasNode(editor, path2, editor.schema);
+  return element.children.some((n2) => isSpan({
+    schema: editor.schema
+  }, n2) ? !0 : editor.isInline(n2));
 }
 const Span = {
   isSpan(value) {
@@ -341,11 +329,38 @@ function isAfterPath(path2, another) {
 function isBeforePath(path2, another) {
   return comparePaths(path2, another) === -1;
 }
+function nextPath(path2) {
+  if (path2.length === 0)
+    throw new Error(`Cannot get the next path of a root path [${path2}], because it has no next index.`);
+  const last = path2[path2.length - 1];
+  return path2.slice(0, -1).concat(last + 1);
+}
 function parentPath(path2) {
   if (path2.length === 0)
     throw new Error(`Cannot get the parent path of the root path [${path2}].`);
   return path2.slice(0, -1);
 }
+function previousPath(path2) {
+  if (path2.length === 0)
+    throw new Error(`Cannot get the previous path of a root path [${path2}], because it has no previous index.`);
+  const last = path2[path2.length - 1];
+  if (last <= 0)
+    throw new Error(`Cannot get the previous path of a first child path [${path2}] because it would result in a negative index.`);
+  return path2.slice(0, -1).concat(last - 1);
+}
+function hasNode(root, path2, schema) {
+  let node2 = root;
+  for (let i = 0; i < path2.length; i++) {
+    const p = path2[i];
+    if (isLeaf(node2, schema))
+      return !1;
+    const children = node2.children;
+    if (!children[p])
+      return !1;
+    node2 = children[p];
+  }
+  return !0;
+}
 function* getNodes(root, schema, options = {}) {
   const {
     pass,
@@ -376,7 +391,7 @@ function* getNodes(root, schema, options = {}) {
       p = previousPath(p), n2 = getNode(root, p, schema);
       continue;
     }
-    p = parentPath(p), n2 = getNode(root, p, schema), visited.add(n2);
+    p = parentPath(p), n2 = p.length === 0 ? root : getNode(root, p, schema), visited.add(n2);
   }
 }
 function commonPath(path2, another) {
@@ -416,11 +431,9 @@ function path(editor, at, options = {}) {
 function* nodes(editor, options = {}) {
   const {
     at = editor.selection,
-    mode = "all",
-    universal = !1,
+    mode,
     reverse = !1,
-    voids = !1,
-    pass
+    includeObjectNodes = !1
   } = options;
   let {
     match: match2
@@ -442,16 +455,17 @@ function* nodes(editor, options = {}) {
     reverse,
     from,
     to,
-    pass: ([node2, path2]) => pass && pass([node2, path2]) ? !0 : isElement(node2, editor.schema) ? !!(!voids && editor.isElementReadOnly(node2)) : !1
-  }), matches = [];
+    pass: ([node2]) => isTextBlock({
+      schema: editor.schema
+    }, node2) ? !!(!includeObjectNodes && editor.isElementReadOnly(node2)) : !1
+  });
   let hit;
   for (const [node2, path2] of nodeEntries) {
     const isLower = hit && comparePaths(path2, hit[1]) === 0;
-    if (mode === "highest" && isLower)
+    if (mode === "highest" && isLower || !match2(node2, path2))
       continue;
-    if (!match2(node2, path2)) {
-      if (universal && !isLower && isText(node2, editor.schema))
-        return;
+    if (!mode) {
+      yield [node2, path2], hit = [node2, path2];
       continue;
     }
     if (mode === "lowest" && isLower) {
@@ -459,9 +473,9 @@ function* nodes(editor, options = {}) {
       continue;
     }
     const emit2 = mode === "lowest" ? hit : [node2, path2];
-    emit2 && (universal ? matches.push(emit2) : yield emit2), hit = [node2, path2];
+    emit2 && (yield emit2), hit = [node2, path2];
   }
-  mode === "lowest" && hit && (universal ? matches.push(hit) : yield hit), universal && (yield* matches);
+  mode === "lowest" && hit && (yield hit);
 }
 function start(editor, at) {
   return point(editor, at, {
@@ -479,13 +493,15 @@ function range(editor, at, to) {
 }
 function string(editor, at, options = {}) {
   const {
-    voids = !1
+    includeObjectNodes = !1
   } = options, editorRange = range(editor, at), [start2, end2] = rangeEdges(editorRange);
   let text = "";
   for (const [node2, path2] of nodes(editor, {
     at: editorRange,
-    match: (n2) => isText(n2, editor.schema),
-    voids
+    match: (n2) => isSpan({
+      schema: editor.schema
+    }, n2),
+    includeObjectNodes
   })) {
     let t = node2.text;
     pathEquals(path2, end2.path) && (t = t.slice(0, end2.offset)), pathEquals(path2, start2.path) && (t = t.slice(start2.offset)), text += t;
@@ -497,34 +513,22 @@ function* positions(editor, options = {}) {
     at = editor.selection,
     unit = "offset",
     reverse = !1,
-    voids = !1
+    includeObjectNodes = !1
   } = options;
   if (!at)
     return;
   const editorRange = range(editor, at), [start$1, end$1] = rangeEdges(editorRange), first = reverse ? end$1 : start$1;
   let isNewBlock = !1, blockText = "", distance = 0, leafTextRemaining = 0, leafTextOffset = 0;
-  const skippedPaths = [];
   for (const [node2, nodePath] of nodes(editor, {
     at,
     reverse,
-    voids
+    includeObjectNodes
   })) {
-    const hasSkippedAncestor = skippedPaths.some((p) => isAncestorPath(p, nodePath));
-    function* maybeYield(point2) {
-      hasSkippedAncestor || (yield point2);
-    }
-    if (isElement(node2, editor.schema)) {
-      if (!editor.isSelectable(node2))
-        if (skippedPaths.push(nodePath), reverse) {
-          pathHasPrevious(nodePath) && (yield* maybeYield(end(editor, previousPath(nodePath))));
-          continue;
-        } else {
-          const next2 = nextPath(nodePath);
-          hasPath(editor, next2) && (yield* maybeYield(start(editor, next2)));
-          continue;
-        }
-      if (!voids && editor.isElementReadOnly(node2)) {
-        yield* maybeYield(start(editor, nodePath));
+    if (isTextBlock({
+      schema: editor.schema
+    }, node2)) {
+      if (!includeObjectNodes && editor.isElementReadOnly(node2)) {
+        yield start(editor, nodePath);
         continue;
       }
       if (editor.isInline(node2))
@@ -535,30 +539,38 @@ function* positions(editor, options = {}) {
           anchor: s,
           focus: e
         }, {
-          voids
+          includeObjectNodes
         }), isNewBlock = !0;
       }
     }
-    if (editor.isObjectNode(node2)) {
-      yield* maybeYield({
+    if (isObjectNode({
+      schema: editor.schema
+    }, node2)) {
+      yield {
         path: nodePath,
         offset: 0
-      });
+      };
       continue;
     }
-    if (!isEditor(node2) && !isElement(node2, editor.schema) && !isText(node2, editor.schema)) {
-      yield* maybeYield({
+    if (!isEditor(node2) && !isTextBlock({
+      schema: editor.schema
+    }, node2) && !isSpan({
+      schema: editor.schema
+    }, node2)) {
+      yield {
         path: nodePath,
         offset: 0
-      });
+      };
       continue;
     }
-    if (isText(node2, editor.schema)) {
+    if (isSpan({
+      schema: editor.schema
+    }, node2)) {
       const isFirst = pathEquals(nodePath, first.path);
-      for (isFirst ? (leafTextRemaining = reverse ? first.offset : node2.text.length - first.offset, leafTextOffset = first.offset) : (leafTextRemaining = node2.text.length, leafTextOffset = reverse ? leafTextRemaining : 0), (isFirst || isNewBlock || unit === "offset") && (yield* maybeYield({
+      for (isFirst ? (leafTextRemaining = reverse ? first.offset : node2.text.length - first.offset, leafTextOffset = first.offset) : (leafTextRemaining = node2.text.length, leafTextOffset = reverse ? leafTextRemaining : 0), (isFirst || isNewBlock || unit === "offset") && (yield {
         path: nodePath,
         offset: leafTextOffset
-      }), isNewBlock = !1); ; ) {
+      }, isNewBlock = !1); ; ) {
         if (distance === 0) {
           if (blockText === "")
             break;
@@ -568,10 +580,10 @@ function* positions(editor, options = {}) {
           distance = -leafTextRemaining;
           break;
         }
-        distance = 0, yield* maybeYield({
+        distance = 0, yield {
           path: nodePath,
           offset: leafTextOffset
-        });
+        };
       }
     }
   }
@@ -629,8 +641,13 @@ function pathLevels(path2, options = {}) {
   return reverse && list.reverse(), list;
 }
 function* getLevels(root, path2, schema, options = {}) {
-  for (const p of pathLevels(path2, options))
+  for (const p of pathLevels(path2, options)) {
+    if (p.length === 0) {
+      yield [root, p];
+      continue;
+    }
     yield [getNode(root, p, schema), p];
+  }
 }
 function* levels(editor, options = {}) {
   const {
@@ -647,7 +664,7 @@ function* levels(editor, options = {}) {
     match2(n2, p) && levels2.push([n2, p]);
   reverse && levels2.reverse(), yield* levels2;
 }
-function above(editor, options = {}) {
+function above(editor, options) {
   const {
     mode = "lowest",
     at = editor.selection,
@@ -668,22 +685,32 @@ function above(editor, options = {}) {
   });
   return firstMatch;
 }
-function getVoid(editor, options = {}) {
+function getObjectNode(editor, options = {}) {
   const {
     at = editor.selection
   } = options;
   if (!at)
     return;
   const nodePath = path(editor, at), node2 = getNode(editor, nodePath, editor.schema);
-  return editor.isObjectNode(node2) ? [node2, nodePath] : above(editor, {
+  return isObjectNode({
+    schema: editor.schema
+  }, node2) ? [node2, nodePath] : above(editor, {
     ...options,
-    match: (n2) => editor.isObjectNode(n2)
+    match: (n2) => isObjectNode({
+      schema: editor.schema
+    }, n2)
   });
 }
+function hasPath(editor, path2) {
+  return hasNode(editor, path2, editor.schema);
+}
 function node(editor, at, options = {}) {
   const nodePath = path(editor, at, options);
   return [getNode(editor, nodePath, editor.schema), nodePath];
 }
+function pathHasPrevious(path2) {
+  return path2[path2.length - 1] > 0;
+}
 function pointEquals(point2, another) {
   return point2.offset === another.offset && pathEquals(point2.path, another.path);
 }
@@ -694,19 +721,18 @@ function isCollapsedRange(range2) {
   } = range2;
   return pointEquals(anchor, focus);
 }
-function isBlock(editor, value) {
-  return !editor.isInline(value);
-}
 function unhangRange(editor, range2, options = {}) {
   const {
-    voids = !1
+    includeObjectNodes = !1
   } = options;
   let [start$1, end2] = rangeEdges(range2);
   if (start$1.offset !== 0 || end2.offset !== 0 || isCollapsedRange(range2) || pathHasPrevious(end2.path))
     return range2;
   const endBlock = above(editor, {
     at: end2,
-    match: (n2) => isElement(n2, editor.schema) && isBlock(editor, n2)
+    match: (n2) => isTextBlock({
+      schema: editor.schema
+    }, n2)
   }), blockPath = endBlock ? endBlock[1] : [], before2 = {
     anchor: start(editor, start$1),
     focus: end2
@@ -714,9 +740,11 @@ function unhangRange(editor, range2, options = {}) {
   let skip = !0;
   for (const [node2, path2] of nodes(editor, {
     at: before2,
-    match: (n2) => isText(n2, editor.schema),
+    match: (n2) => isSpan({
+      schema: editor.schema
+    }, n2),
     reverse: !0,
-    voids
+    includeObjectNodes
   })) {
     if (skip) {
       skip = !1;
@@ -875,7 +903,9 @@ const DOMEditor = {
     if (x == null || y == null)
       throw new Error(`Cannot resolve a Slate range from a DOM event: ${event}`);
     const node2 = DOMEditor.toSlateNode(editor, event.target), path2 = DOMEditor.findPath(editor, node2);
-    if (editor.isObjectNode(node2)) {
+    if (isObjectNode({
+      schema: editor.schema
+    }, node2)) {
       const rect = target.getBoundingClientRect(), isPrev = path2.length > 1 ? x - rect.left < rect.left + rect.width - x : y - rect.top < rect.top + rect.height - y, edge = point(editor, path2, {
         edge: isPrev ? "start" : "end"
       }), point$1 = isPrev ? before(editor, edge) : after(editor, edge);
@@ -985,7 +1015,9 @@ const DOMEditor = {
     if (editor.readOnly)
       return !1;
     const slateNode = DOMEditor.hasTarget(editor, target) && DOMEditor.toSlateNode(editor, target);
-    return !!slateNode && editor.isObjectNode(slateNode);
+    return !!slateNode && isObjectNode({
+      schema: editor.schema
+    }, slateNode);
   },
   toDOMNode: (editor, node2) => {
     const domNode = isEditor(node2) ? editor.domElement : editor.keyToElement?.get(DOMEditor.findKey(editor, node2));
@@ -996,7 +1028,9 @@ const DOMEditor = {
   toDOMPoint: (editor, point2) => {
     const [node$1] = node(editor, point2.path), el = DOMEditor.toDOMNode(editor, node$1);
     let domPoint;
-    if (editor.isObjectNode(node$1)) {
+    if (isObjectNode({
+      schema: editor.schema
+    }, node$1)) {
       const spacer = el.querySelector("[data-slate-zero-width]");
       if (spacer) {
         const domText = spacer.childNodes[0];
@@ -1011,7 +1045,7 @@ const DOMEditor = {
       }
       return [el, 0];
     }
-    getVoid(editor, {
+    getObjectNode(editor, {
       at: point2
     }) && (point2 = {
       path: point2.path,
@@ -1152,7 +1186,9 @@ const DOMEditor = {
         const childEl = nearestNode.childNodes[nearestOffset];
         if (childEl instanceof HTMLElement && DOMEditor.hasDOMNode(editor, childEl)) {
           const slateNode2 = DOMEditor.toSlateNode(editor, childEl);
-          if (editor.isObjectNode(slateNode2))
+          if (isObjectNode({
+            schema: editor.schema
+          }, slateNode2))
             try {
               return {
                 path: DOMEditor.findPath(editor, slateNode2),
@@ -1165,7 +1201,9 @@ const DOMEditor = {
       const elementNode = parentNode.closest('[data-slate-node="element"]') ?? (parentNode.hasAttribute("data-slate-node") ? parentNode : null);
       if (elementNode && DOMEditor.hasDOMNode(editor, elementNode)) {
         const slateNode2 = DOMEditor.toSlateNode(editor, elementNode);
-        if (editor.isObjectNode(slateNode2))
+        if (isObjectNode({
+          schema: editor.schema
+        }, slateNode2))
           try {
             return {
               path: DOMEditor.findPath(editor, slateNode2),
@@ -1193,7 +1231,9 @@ const DOMEditor = {
       const parentPath2 = path2.slice(0, -1);
       try {
         const parentSlateNode = getNode(editor, parentPath2, editor.schema);
-        if (editor.isObjectNode(parentSlateNode))
+        if (isObjectNode({
+          schema: editor.schema
+        }, parentSlateNode))
           return {
             path: parentPath2,
             offset: 0
@@ -1255,21 +1295,20 @@ const DOMEditor = {
       anchor,
       focus
     };
-    return isExpandedRange(range2) && isForwardRange(range2) && isDOMElement(focusNode) && getVoid(editor, {
+    return isExpandedRange(range2) && isForwardRange(range2) && isDOMElement(focusNode) && getObjectNode(editor, {
       at: range2.focus,
       mode: "highest"
     }) && (range2 = unhangRange(editor, range2, {
-      voids: !0
+      includeObjectNodes: !0
     })), range2;
   }
 };
 function getChild(root, index, schema) {
-  if (isText(root, schema) || isObjectNode(root, schema))
-    throw new Error(`Cannot get the child of a leaf node: ${safeStringify(root)}`);
-  const c2 = root.children[index];
-  if (c2 == null)
-    throw new Error(`Cannot get child at index \`${index}\` in node: ${safeStringify(root)}`);
-  return c2;
+  if (isEditor(root) || isTextBlock({
+    schema
+  }, root))
+    return root.children[index];
+  throw new Error(`Cannot get the child of a leaf node: ${safeStringify(root)}`);
 }
 function getFocusBlock({
   editor
@@ -1293,10 +1332,14 @@ function getFocusSpan({
     });
     if (!focusBlock)
       return [void 0, void 0];
-    if (!editor.isTextBlock(focusBlock))
+    if (!isTextBlock({
+      schema: editor.schema
+    }, focusBlock))
       return [void 0, void 0];
     const [node$1, path2] = node(editor, editor.selection.focus.path.slice(0, 2));
-    if (editor.isTextSpan(node$1))
+    if (isSpan({
+      schema: editor.schema
+    }, node$1))
       return [node$1, path2];
   } catch {
     return [void 0, void 0];
@@ -1378,7 +1421,6 @@ function getNodeBlock({
   if (isEditor(node2))
     return;
   if (isBlockElement({
-    editor,
     schema
   }, node2))
     return elementToBlock({
@@ -1388,11 +1430,12 @@ function getNodeBlock({
     mode: "highest",
     at: [],
     match: (n2) => isBlockElement({
-      editor,
       schema
     }, n2) && n2.children.some((child) => child._key === node2._key)
   })).at(0)?.at(0);
-  return isElement(parent2, editor.schema) ? elementToBlock({
+  return isTextBlock({
+    schema: editor.schema
+  }, parent2) ? elementToBlock({
     element: parent2
   }) : void 0;
 }
@@ -1402,10 +1445,11 @@ function elementToBlock({
   return element;
 }
 function isBlockElement({
-  editor,
   schema
 }, node2) {
-  return isElement(node2, editor.schema) && !editor.isInline(node2) && (schema.block.name === node2._type || schema.blockObjects.some((blockObject) => blockObject.name === node2._type));
+  return isTextBlock({
+    schema
+  }, node2);
 }
 function isListItemActive({
   editor,
@@ -1415,9 +1459,13 @@ function isListItemActive({
     return !1;
   const selectedBlocks = [...nodes(editor, {
     at: editor.selection,
-    match: (node2) => editor.isTextBlock(node2)
+    match: (node2) => isTextBlock({
+      schema: editor.schema
+    }, node2)
   })];
-  return selectedBlocks.length > 0 ? selectedBlocks.every(([node2]) => editor.isListBlock(node2) && node2.listItem === listItem) : !1;
+  return selectedBlocks.length > 0 ? selectedBlocks.every(([node2]) => isListBlock({
+    schema: editor.schema
+  }, node2) && node2.listItem === listItem) : !1;
 }
 function isStyleActive({
   editor,
@@ -1427,7 +1475,9 @@ function isStyleActive({
     return !1;
   const selectedBlocks = [...nodes(editor, {
     at: editor.selection,
-    match: (node2) => editor.isTextBlock(node2)
+    match: (node2) => isTextBlock({
+      schema: editor.schema
+    }, node2)
   })];
   return selectedBlocks.length > 0 ? selectedBlocks.every(([node2]) => node2.style === style) : !1;
 }
@@ -2246,16 +2296,26 @@ function rangeRef(editor, range2, options = {}) {
 }
 function getLeaf(root, path2, schema) {
   const node2 = getNode(root, path2, schema);
-  if (!isText(node2, schema) && !isObjectNode(node2, schema))
-    throw new Error(`Cannot get the leaf node at path [${path2}] because it refers to a non-leaf node: ${safeStringify(node2)}`);
-  return node2;
+  if (isSpan({
+    schema
+  }, node2) || isObjectNode({
+    schema
+  }, node2))
+    return node2;
+  throw new Error(`Cannot get the leaf node at path [${path2}] because it refers to a non-leaf node: ${safeStringify(node2)}`);
 }
 function getString(node2, schema) {
-  return isObjectNode(node2, schema) ? "" : isText(node2, schema) ? node2.text : node2.children.map((child) => getString(child, schema)).join("");
+  return isEditor(node2) || isObjectNode({
+    schema
+  }, node2) ? "" : isSpan({
+    schema
+  }, node2) ? node2.text : node2.children.map((child) => getString(child, schema)).join("");
 }
 function* getTexts(root, schema, options = {}) {
   for (const [node2, path2] of getNodes(root, schema, options))
-    isText(node2, schema) && (yield [node2, path2]);
+    isSpan({
+      schema
+    }, node2) && (yield [node2, path2]);
 }
 function rangeEquals(range2, another) {
   return pointEquals(range2.anchor, another.anchor) && pointEquals(range2.focus, another.focus);
@@ -2316,23 +2376,18 @@ const EditorContext = createContext(null), useSlateStatic = () => {
     throw new Error("The `useSlateStatic` hook must be used inside the <Slate> component's context.");
   return editor;
 };
-function parent(editor, at, options = {}) {
-  const nodePath = path(editor, at, options), parentPath_ = parentPath(nodePath);
-  return node(editor, parentPath_);
-}
-function next(editor, options = {}) {
+function next(editor, options) {
   const {
     mode = "lowest",
-    voids = !1
-  } = options;
-  let {
+    includeObjectNodes = !1
+  } = options, {
     match: match2,
     at = editor.selection
   } = options;
   if (!at)
     return;
   const pointAfterLocation = after(editor, at, {
-    voids
+    includeObjectNodes
   });
   if (!pointAfterLocation)
     return;
@@ -2341,17 +2396,11 @@ function next(editor, options = {}) {
   })), span = [pointAfterLocation.path, to];
   if (isPath(at) && at.length === 0)
     throw new Error("Cannot get the next node from the root node!");
-  if (match2 == null)
-    if (isPath(at)) {
-      const [parentNode] = parent(editor, at);
-      match2 = (n2) => parentNode.children.includes(n2);
-    } else
-      match2 = () => !0;
   const [nextEntry] = nodes(editor, {
     at: span,
     match: match2,
     mode,
-    voids
+    includeObjectNodes
   });
   return nextEntry;
 }
@@ -2433,7 +2482,9 @@ function verifyDiffState(editor, textDiff) {
   if (!hasPath(editor, path2))
     return !1;
   const node2 = getNode(editor, path2, editor.schema);
-  if (!isText(node2, editor.schema))
+  if (!isSpan({
+    schema: editor.schema
+  }, node2))
     return !1;
   if (diff2.start !== node2.text.length || diff2.text.length === 0)
     return node2.text.slice(diff2.start, diff2.start + diff2.text.length) === diff2.text;
@@ -2441,7 +2492,9 @@ function verifyDiffState(editor, textDiff) {
   if (!hasPath(editor, nextPath$1))
     return !1;
   const nextNode = getNode(editor, nextPath$1, editor.schema);
-  return isText(nextNode, editor.schema) && nextNode.text.startsWith(diff2.text);
+  return isSpan({
+    schema: editor.schema
+  }, nextNode) && nextNode.text.startsWith(diff2.text);
 }
 function applyStringDiff(text, ...diffs) {
   return diffs.reduce((text2, diff2) => text2.slice(0, diff2.start) + diff2.text + text2.slice(diff2.end), text);
@@ -2504,10 +2557,14 @@ function normalizePoint(editor, point2) {
   if (!hasPath(editor, path2))
     return null;
   let leaf2 = getNode(editor, path2, editor.schema);
-  if (!isText(leaf2, editor.schema))
+  if (!isSpan({
+    schema: editor.schema
+  }, leaf2))
     return null;
   const parentBlock = above(editor, {
-    match: (n2) => isElement(n2, editor.schema) && isBlock(editor, n2),
+    match: (n2) => isTextBlock({
+      schema: editor.schema
+    }, n2),
     at: path2
   });
   if (!parentBlock)
@@ -2515,7 +2572,9 @@ function normalizePoint(editor, point2) {
   for (; offset > leaf2.text.length; ) {
     const entry = next(editor, {
       at: path2,
-      match: (n2) => isText(n2, editor.schema)
+      match: (n2) => isSpan({
+        schema: editor.schema
+      }, n2)
     });
     if (!entry || !isDescendantPath(entry[1], parentBlock[1]))
       return null;
@@ -2732,7 +2791,9 @@ function createAndroidInputManager({
     }
   }, storeDiff = (path2, diff2) => {
     const pendingDiffs = editor.pendingDiffs, target = getLeaf(editor, path2, editor.schema);
-    if (!isText(target, editor.schema))
+    if (!isSpan({
+      schema: editor.schema
+    }, target))
       return;
     const idx = pendingDiffs.findIndex((change) => pathEquals(change.path, path2));
     if (idx < 0) {
@@ -2783,7 +2844,9 @@ function createAndroidInputManager({
     if (type.startsWith("delete")) {
       const direction = type.endsWith("Backward") ? "backward" : "forward";
       let [start2, end2] = rangeEdges(targetRange2), [leaf$1, path2] = leaf(editor, start2.path);
-      if (!isText(leaf$1, editor.schema))
+      if (!isSpan({
+        schema: editor.schema
+      }, leaf$1))
         return scheduleAction(() => editorActor.send({
           type: "behavior event",
           behaviorEvent: {
@@ -2797,7 +2860,9 @@ function createAndroidInputManager({
       if (isExpandedRange(targetRange2) && leaf$1.text.length === start2.offset && end2.offset === 0) {
         const next$1 = next(editor, {
           at: start2.path,
-          match: (n2) => isText(n2, editor.schema)
+          match: (n2) => isSpan({
+            schema: editor.schema
+          }, n2)
         });
         next$1 && pathEquals(next$1[1], end2.path) && (direction === "backward" ? (targetRange2 = {
           anchor: end2,
@@ -2857,7 +2922,9 @@ function createAndroidInputManager({
         } = targetRange2;
         if (canStoreDiff && isCollapsedRange(targetRange2)) {
           const targetNode = getLeaf(editor, anchor.path, editor.schema);
-          if (isText(targetNode, editor.schema) && anchor.offset < targetNode.text.length)
+          if (isSpan({
+            schema: editor.schema
+          }, targetNode) && anchor.offset < targetNode.text.length)
             return storeDiff(anchor.path, {
               text: "",
               start: anchor.offset,
@@ -3191,10 +3258,12 @@ const shallowCompare = (obj1, obj2) => Object.keys(obj1).length === Object.keys(
   }
   return !0;
 }, splitDecorationsByChild = (editor, node2, decorations) => {
-  const decorationsByChild = Array.from(node2.children, () => []);
+  const children = isEditor(node2) || isTextBlock({
+    schema: editor.schema
+  }, node2) ? node2.children : [], decorationsByChild = Array.from(children, () => []);
   if (decorations.length === 0)
     return decorationsByChild;
-  const path2 = DOMEditor.findPath(editor, node2), level = path2.length, ancestorRange = range(editor, path2), cachedChildRanges = new Array(node2.children.length), getChildRange = (index) => {
+  const path2 = DOMEditor.findPath(editor, node2), level = path2.length, ancestorRange = range(editor, path2), cachedChildRanges = new Array(children.length), getChildRange = (index) => {
     const cachedRange = cachedChildRanges[index];
     if (cachedRange)
       return cachedRange;
@@ -3259,7 +3328,9 @@ const DecorateContext = createContext({}), useDecorations = (node2, parentDecora
   } = useContext(DecorateContext), selector = () => {
     const path2 = ReactEditor.findPath(editor, node2);
     return decorate([node2, path2]);
-  }, equalityFn = isText(node2, editor.schema) ? isTextDecorationsEqual : isElementDecorationsEqual, [decorations, update] = useGenericSelector(selector, equalityFn);
+  }, equalityFn = isSpan({
+    schema: editor.schema
+  }, node2) ? isTextDecorationsEqual : isElementDecorationsEqual, [decorations, update] = useGenericSelector(selector, equalityFn);
   return useIsomorphicLayoutEffect(() => {
     const unsubscribe = addEventListener(update);
     return update(), unsubscribe;
@@ -3292,7 +3363,7 @@ const defaultRenderElement$1 = (props) => /* @__PURE__ */ jsx(DefaultElement, {
     renderLeaf,
     renderText
   } = props, editor = useSlateStatic(), isInline = editor.isInline(element), decorations = useDecorations(element, parentDecorations), key = ReactEditor.findKey(editor, element), ref = useCallback((ref2) => {
-    ref2 ? (editor.keyToElement?.set(key, ref2), editor.nodeToElement.set(element, ref2), editor.elementToNode.set(ref2, element)) : (editor.keyToElement?.delete(key), editor.nodeToElement.delete(element));
+    ref2 ? (editor.keyToElement?.set(key, ref2), editor.elementToNode.set(ref2, element)) : editor.keyToElement?.delete(key);
   }, [editor, key, element]), children = useChildren({
     decorations,
     node: element,
@@ -3304,7 +3375,9 @@ const defaultRenderElement$1 = (props) => /* @__PURE__ */ jsx(DefaultElement, {
     "data-slate-node": "element",
     ref
   };
-  if (isInline && (attributes["data-slate-inline"] = !0), !isInline && hasInlines(editor, element)) {
+  if (isInline && (attributes["data-slate-inline"] = !0), !isInline && isTextBlock({
+    schema: editor.schema
+  }, element) && hasInlines(editor, element)) {
     const text = getString(element, editor.schema), dir = getDirection(text);
     dir === "rtl" && (attributes.dir = dir);
   }
@@ -3336,12 +3409,12 @@ const defaultRenderElement$1 = (props) => /* @__PURE__ */ jsx(DefaultElement, {
     isInline,
     renderElement = defaultRenderElement
   } = props, editor = useSlateStatic(), readOnly = useReadOnly(), key = ReactEditor.findKey(editor, objectNode), ref = useCallback((ref2) => {
-    ref2 ? (editor.keyToElement?.set(key, ref2), editor.nodeToElement.set(objectNode, ref2), editor.elementToNode.set(ref2, objectNode)) : (editor.keyToElement?.delete(key), editor.nodeToElement.delete(objectNode));
+    ref2 ? (editor.keyToElement?.set(key, ref2), editor.elementToNode.set(ref2, objectNode)) : editor.keyToElement?.delete(key);
   }, [editor, key, objectNode]), syntheticText = useMemo(() => ({
     text: "",
     marks: []
   }), []), spacerTextRef = useCallback((span) => {
-    span ? (editor.keyToElement?.set(ReactEditor.findKey(editor, syntheticText), span), editor.nodeToElement.set(syntheticText, span), editor.elementToNode.set(span, syntheticText)) : editor.nodeToElement.delete(syntheticText);
+    span && (editor.keyToElement?.set(ReactEditor.findKey(editor, syntheticText), span), editor.elementToNode.set(span, syntheticText));
   }, [editor, syntheticText]);
   React.useEffect(() => (editor.nodeToIndex.set(syntheticText, 0), editor.nodeToParent.set(syntheticText, objectNode), () => {
     editor.nodeToIndex.delete(syntheticText), editor.nodeToParent.delete(syntheticText);
@@ -3445,7 +3518,9 @@ const SlateString = (props) => {
     parent: parent2,
     text
   } = props, editor = useSlateStatic(), path2 = ReactEditor.findPath(editor, text), parentPath_ = parentPath(path2), isMarkPlaceholder = !!leaf2[MARK_PLACEHOLDER_SYMBOL];
-  return leaf2.text === "" && parent2.children[parent2.children.length - 1] === text && !editor.isInline(parent2) && string(editor, parentPath_) === "" ? /* @__PURE__ */ jsx(ZeroWidthString, { isLineBreak: !0, isMarkPlaceholder }) : leaf2.text === "" ? /* @__PURE__ */ jsx(ZeroWidthString, { isMarkPlaceholder }) : isLast && leaf2.text.slice(-1) === `
+  return leaf2.text === "" && isTextBlock({
+    schema: editor.schema
+  }, parent2) && parent2.children[parent2.children.length - 1] === text && !editor.isInline(parent2) && string(editor, parentPath_) === "" ? /* @__PURE__ */ jsx(ZeroWidthString, { isLineBreak: !0, isMarkPlaceholder }) : leaf2.text === "" ? /* @__PURE__ */ jsx(ZeroWidthString, { isMarkPlaceholder }) : isLast && leaf2.text.slice(-1) === `
 ` ? /* @__PURE__ */ jsx(TextString, { isTrailing: !0, text: leaf2.text }) : /* @__PURE__ */ jsx(TextString, { text: leaf2.text });
 }, TextString = (props) => {
   const {
@@ -3565,7 +3640,7 @@ const defaultRenderLeaf = (props) => /* @__PURE__ */ jsx(DefaultLeaf, { ...props
   const attributes = {
     "data-slate-node": "text",
     ref: useCallback((span) => {
-      span ? (editor.keyToElement?.set(key, span), editor.nodeToElement.set(text, span), editor.elementToNode.set(span, text)) : (editor.keyToElement?.delete(key), editor.nodeToElement.delete(text), ref.current && editor.elementToNode.delete(ref.current)), ref.current = span;
+      span ? (editor.keyToElement?.set(key, span), editor.elementToNode.set(span, text)) : (editor.keyToElement?.delete(key), ref.current && editor.elementToNode.delete(ref.current)), ref.current = span;
     }, [ref, editor, key, text])
   };
   return renderText({
@@ -3589,21 +3664,41 @@ const defaultRenderLeaf = (props) => /* @__PURE__ */ jsx(DefaultLeaf, { ...props
     renderLeaf
   } = props, editor = useSlateStatic();
   editor.isNodeMapDirty = !1;
-  const isEditorNode = isEditor(node2), decorationsByChild = useDecorationsByChild(editor, node2, decorations);
-  node2.children.forEach((n2, i) => {
+  const isEditorNode = isEditor(node2), decorationsByChild = useDecorationsByChild(editor, node2, decorations), children = isEditor(node2) || isTextBlock({
+    schema: editor.schema
+  }, node2) ? node2.children : [];
+  children.forEach((n2, i) => {
     editor.nodeToIndex.set(n2, i), editor.nodeToParent.set(n2, node2);
   });
   const renderElementComponent = useCallback((n2, i, cachedKey) => {
     const key = cachedKey ?? ReactEditor.findKey(editor, n2);
     return /* @__PURE__ */ jsx(ElementContext.Provider, { value: n2, children: /* @__PURE__ */ jsx(MemoizedElement, { decorations: decorationsByChild[i] ?? [], element: n2, renderElement, renderPlaceholder, renderLeaf, renderText }, key.id) }, `provider-${key.id}`);
-  }, [editor, decorationsByChild, renderElement, renderPlaceholder, renderLeaf, renderText]), renderTextComponent = (n2, i) => {
+  }, [editor, decorationsByChild, renderElement, renderPlaceholder, renderLeaf, renderText]), textBlockParent = isTextBlock({
+    schema: editor.schema
+  }, node2) ? node2 : void 0, renderTextComponent = (n2, i) => {
+    if (!textBlockParent)
+      throw new Error("Cannot render text component without a text block parent");
     const key = ReactEditor.findKey(editor, n2);
-    return /* @__PURE__ */ jsx(MemoizedText, { decorations: decorationsByChild[i] ?? [], isLast: i === node2.children.length - 1, parent: node2, renderPlaceholder, renderLeaf, renderText, text: n2 }, key.id);
+    return /* @__PURE__ */ jsx(MemoizedText, { decorations: decorationsByChild[i] ?? [], isLast: i === children.length - 1, parent: textBlockParent, renderPlaceholder, renderLeaf, renderText, text: n2 }, key.id);
   }, renderObjectNodeComponent = (n2, i) => {
     const key = ReactEditor.findKey(editor, n2);
     return /* @__PURE__ */ jsx(MemoizedObjectNode, { decorations: decorationsByChild[i] ?? [], isInline: !isEditorNode, objectNode: n2, renderElement }, key.id);
   };
-  return node2.children.map((n2, i) => isElement(n2, editor.schema) ? renderElementComponent(n2, i) : isObjectNode(n2, editor.schema) ? renderObjectNodeComponent(n2, i) : renderTextComponent(n2, i));
+  return children.map((n2, i) => {
+    if (isTextBlock({
+      schema: editor.schema
+    }, n2))
+      return renderElementComponent(n2, i);
+    if (isObjectNode({
+      schema: editor.schema
+    }, n2))
+      return renderObjectNodeComponent(n2, i);
+    if (isSpan({
+      schema: editor.schema
+    }, n2))
+      return renderTextComponent(n2, i);
+    throw new Error("Unexpected node type");
+  });
 }, useDecorationsByChild = (editor, node2, decorations) => {
   const decorationsByChild = splitDecorationsByChild(editor, node2, decorations), mutableDecorationsByChild = useRef(decorationsByChild).current;
   mutableDecorationsByChild.length = decorationsByChild.length;
@@ -3613,9 +3708,7 @@ const defaultRenderLeaf = (props) => /* @__PURE__ */ jsx(DefaultLeaf, { ...props
   }
   return mutableDecorationsByChild;
 }, ComposingContext = createContext(!1), SlateSelectorContext = createContext({}), refEquality = (a, b) => a === b;
-function useSlateSelector(selector, equalityFn = refEquality, {
-  deferred
-} = {}) {
+function useSlateSelector(selector, equalityFn = refEquality) {
   const context = useContext(SlateSelectorContext);
   if (!context)
     throw new Error("The `useSlateSelector` hook must be used inside the <Slate> component's context.");
@@ -3623,11 +3716,9 @@ function useSlateSelector(selector, equalityFn = refEquality, {
     addEventListener
   } = context, editor = useSlateStatic(), genericSelector = useCallback(() => selector(editor), [editor, selector]), [selectedState, update] = useGenericSelector(genericSelector, equalityFn);
   return useIsomorphicLayoutEffect(() => {
-    const unsubscribe = addEventListener(update, {
-      deferred
-    });
+    const unsubscribe = addEventListener(update);
     return update(), unsubscribe;
-  }, [addEventListener, update, deferred]), selectedState;
+  }, [addEventListener, update]), selectedState;
 }
 function useSelectorContext() {
   const eventListeners = useRef(/* @__PURE__ */ new Set()), deferredEventListeners = useRef(/* @__PURE__ */ new Set()), onChange = useCallback(() => {
@@ -3638,14 +3729,9 @@ function useSelectorContext() {
     deferredEventListeners.current.forEach((listener) => {
       listener();
     }), deferredEventListeners.current.clear();
-  }, []), addEventListener = useCallback((callbackProp, {
-    deferred = !1
-  } = {}) => {
-    const callback = deferred ? () => deferredEventListeners.current.add(callbackProp) : callbackProp;
-    return eventListeners.current.add(callback), () => {
-      eventListeners.current.delete(callback);
-    };
-  }, []);
+  }, []), addEventListener = useCallback((callbackProp) => (eventListeners.current.add(callbackProp), () => {
+    eventListeners.current.delete(callbackProp);
+  }), []);
   return {
     selectorContext: useMemo(() => ({
       addEventListener,
@@ -3859,7 +3945,7 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
     scheduleOnDOMSelectionChange
   }), useIsomorphicLayoutEffect(() => {
     let window2 = null;
-    ref.current && (window2 = getDefaultView(ref.current)) ? (editor.domWindow = window2, editor.domElement = ref.current, editor.nodeToElement.set(editor, ref.current), editor.elementToNode.set(ref.current, editor)) : editor.nodeToElement.delete(editor);
+    ref.current && (window2 = getDefaultView(ref.current)) && (editor.domWindow = window2, editor.domElement = ref.current, editor.elementToNode.set(ref.current, editor));
     const {
       selection
     } = editor, root = ReactEditor.findDocumentOrShadowRoot(editor), domSelection = getSelection(root);
@@ -3971,7 +4057,9 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
         if (native && node2.parentElement && window2?.getComputedStyle(node2.parentElement)?.whiteSpace === "pre") {
           const block = above(editor, {
             at: anchor.path,
-            match: (n2) => isElement(n2, editor.schema) && isBlock(editor, n2)
+            match: (n2) => isTextBlock({
+              schema: editor.schema
+            }, n2)
           });
           block && getString(block[0], editor.schema).includes("	") && (native = !1);
         }
@@ -4181,7 +4269,7 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
       editor.userSelection = null, toRestore && (!editor.selection || !rangeEquals(editor.selection, toRestore)) && editor.select(toRestore);
     }
   }, [editor, editorActor, onDOMSelectionChange, onUserInput, propsOnDOMBeforeInput, readOnly, scheduleOnDOMSelectionChange]), callbackRef = useCallback((node2) => {
-    node2 == null ? (onDOMSelectionChange.cancel(), scheduleOnDOMSelectionChange.cancel(), editor.domElement = null, editor.nodeToElement.delete(editor), ref.current && HAS_BEFORE_INPUT_SUPPORT && ref.current.removeEventListener("beforeinput", onDOMBeforeInput)) : HAS_BEFORE_INPUT_SUPPORT && node2.addEventListener("beforeinput", onDOMBeforeInput), ref.current = node2, typeof forwardedRef == "function" ? forwardedRef(node2) : forwardedRef && (forwardedRef.current = node2);
+    node2 == null ? (onDOMSelectionChange.cancel(), scheduleOnDOMSelectionChange.cancel(), editor.domElement = null, ref.current && HAS_BEFORE_INPUT_SUPPORT && ref.current.removeEventListener("beforeinput", onDOMBeforeInput)) : HAS_BEFORE_INPUT_SUPPORT && node2.addEventListener("beforeinput", onDOMBeforeInput), ref.current = node2, typeof forwardedRef == "function" ? forwardedRef(node2) : forwardedRef && (forwardedRef.current = node2);
   }, [onDOMSelectionChange, scheduleOnDOMSelectionChange, editor, onDOMBeforeInput, forwardedRef]);
   useIsomorphicLayoutEffect(() => {
     const window2 = ReactEditor.getWindow(editor), onSelectionChange = ({
@@ -4214,7 +4302,9 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
     const {
       anchor
     } = editor.selection, leaf2 = getLeaf(editor, anchor.path, editor.schema);
-    if (isText(leaf2, editor.schema)) {
+    if (isSpan({
+      schema: editor.schema
+    }, leaf2)) {
       const {
         text: _text,
         ...rest
@@ -4243,7 +4333,9 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
         const {
           anchor
         } = selection, text = getLeaf(editor, anchor.path, editor.schema);
-        if (!isText(text, editor.schema))
+        if (!isSpan({
+          schema: editor.schema
+        }, text))
           return;
         if (marks && !textEquals(text, marks, {
           loose: !0
@@ -4322,7 +4414,11 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
         if (relatedTarget !== el && !(isDOMElement(relatedTarget) && relatedTarget.hasAttribute("data-slate-spacer"))) {
           if (relatedTarget != null && isDOMNode(relatedTarget) && ReactEditor.hasDOMNode(editor, relatedTarget)) {
             const node2 = ReactEditor.toSlateNode(editor, relatedTarget);
-            if (isElement(node2, editor.schema) || editor.isObjectNode(node2))
+            if (isTextBlock({
+              schema: editor.schema
+            }, node2) || isObjectNode({
+              schema: editor.schema
+            }, node2))
               return;
           }
           IS_WEBKIT && getSelection(root)?.removeAllRanges(), editor.focused = !1;
@@ -4331,12 +4427,16 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
       onClick: useCallback((event) => {
         if (ReactEditor.hasTarget(editor, event.target) && !isEventHandled(event, attributes.onClick) && isDOMNode(event.target)) {
           const node2 = ReactEditor.toSlateNode(editor, event.target), path2 = ReactEditor.findPath(editor, node2);
-          if (!hasPath(editor, path2) || getNode(editor, path2, editor.schema) !== node2)
+          if (getNodeIf(editor, path2, editor.schema) !== node2)
             return;
           if (event.detail === TRIPLE_CLICK && path2.length >= 1) {
             let blockPath = path2;
-            isElement(node2, editor.schema) && isBlock(editor, node2) || (blockPath = above(editor, {
-              match: (n2) => isElement(n2, editor.schema) && isBlock(editor, n2),
+            isTextBlock({
+              schema: editor.schema
+            }, node2) && !editor.isInline(node2) || (blockPath = above(editor, {
+              match: (n2) => isTextBlock({
+                schema: editor.schema
+              }, n2),
               at: path2
             })?.[1] ?? path2.slice(0, 1));
             const range$1 = range(editor, blockPath);
@@ -4345,12 +4445,12 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
           }
           if (readOnly)
             return;
-          const start$1 = start(editor, path2), end$1 = end(editor, path2), startVoid = getVoid(editor, {
+          const start$1 = start(editor, path2), end$1 = end(editor, path2), startObjectNode = getObjectNode(editor, {
             at: start$1
-          }), endVoid = getVoid(editor, {
+          }), endObjectNode = getObjectNode(editor, {
             at: end$1
           });
-          if (startVoid && endVoid && pathEquals(startVoid[1], endVoid[1])) {
+          if (startObjectNode && endObjectNode && pathEquals(startObjectNode[1], endObjectNode[1])) {
             const range$1 = range(editor, start$1);
             editor.select(range$1);
           }
@@ -4493,7 +4593,9 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
           if (HAS_BEFORE_INPUT_SUPPORT) {
             if ((IS_CHROME || IS_WEBKIT) && selection && (Hotkeys.isDeleteBackward(nativeEvent) || Hotkeys.isDeleteForward(nativeEvent)) && isCollapsedRange(selection)) {
               const currentNode = getNode(editor, selection.anchor.path, editor.schema);
-              if (editor.isObjectNode(currentNode)) {
+              if (isObjectNode({
+                schema: editor.schema
+              }, currentNode)) {
                 event.preventDefault(), editorActor.send({
                   type: "behavior event",
                   behaviorEvent: {
@@ -5292,7 +5394,9 @@ function createDecorate(schema, slateEditor) {
       }];
     if (path2.length === 0)
       return [];
-    if (!isElement(node2, slateEditor.schema) || node2.children.length === 0)
+    if (!isTextBlock({
+      schema: slateEditor.schema
+    }, node2) || node2.children.length === 0)
       return [];
     const blockIndex = path2.at(0);
     return blockIndex === void 0 ? [] : slateEditor.decoratedRanges.filter((decoratedRange) => isCollapsedRange(decoratedRange) ? node2.children.some((_, childIndex) => pathEquals(decoratedRange.anchor.path, [blockIndex, childIndex]) && pathEquals(decoratedRange.focus.path, [blockIndex, childIndex])) : rangeIntersection(decoratedRange, {
@@ -5361,7 +5465,7 @@ function useEditorSelector(editor, selector, t0) {
   return $[0] !== editor || $[1] !== selector ? (t1 = (editorActorSnapshot) => {
     const snapshot = getEditorSnapshot({
       editorActorSnapshot,
-      slateEditorInstance: editor._internal.slateEditor.instance
+      slateEditorInstance: editor._internal.slateEditor
     });
     return selector(snapshot);
   }, $[0] = editor, $[1] = selector, $[2] = t1) : t1 = $[2], useSelector(editor._internal.editorActor, t1, compare);
@@ -5752,27 +5856,21 @@ function RenderStyle({
   });
 }
 function RenderElement(props) {
-  const $ = c(34), editorActor = useContext(EditorActorContext), schema = useSelector(editorActor, _temp$3), slateStatic = useSlateStatic();
+  const $ = c(26), editorActor = useContext(EditorActorContext), schema = useSelector(editorActor, _temp$3), slateStatic = useSlateStatic();
+  if (isTextBlock({
+    schema
+  }, props.element)) {
+    const t02 = props.dropPosition?.blockKey === props.element._key ? props.dropPosition.positionBlock : void 0;
+    let t12;
+    return $[0] !== props.attributes || $[1] !== props.children || $[2] !== props.element || $[3] !== props.readOnly || $[4] !== props.renderBlock || $[5] !== props.renderListItem || $[6] !== props.renderStyle || $[7] !== props.spellCheck || $[8] !== schema || $[9] !== t02 ? (t12 = /* @__PURE__ */ jsx(RenderTextBlock, { attributes: props.attributes, dropPosition: t02, element: props.element, readOnly: props.readOnly, renderBlock: props.renderBlock, renderListItem: props.renderListItem, renderStyle: props.renderStyle, schema, spellCheck: props.spellCheck, textBlock: props.element, children: props.children }), $[0] = props.attributes, $[1] = props.children, $[2] = props.element, $[3] = props.readOnly, $[4] = props.renderBlock, $[5] = props.renderListItem, $[6] = props.renderStyle, $[7] = props.spellCheck, $[8] = schema, $[9] = t02, $[10] = t12) : t12 = $[10], t12;
+  }
   if (slateStatic.isInline(props.element)) {
     let t02;
-    return $[0] !== props.attributes || $[1] !== props.children || $[2] !== props.element || $[3] !== props.readOnly || $[4] !== props.renderChild || $[5] !== schema ? (t02 = /* @__PURE__ */ jsx(RenderInlineObject, { attributes: props.attributes, element: props.element, readOnly: props.readOnly, renderChild: props.renderChild, schema, children: props.children }), $[0] = props.attributes, $[1] = props.children, $[2] = props.element, $[3] = props.readOnly, $[4] = props.renderChild, $[5] = schema, $[6] = t02) : t02 = $[6], t02;
-  }
-  let block, t0;
-  if ($[7] !== props.element._key || $[8] !== schema || $[9] !== slateStatic.blockIndexMap || $[10] !== slateStatic.children) {
-    const blockIndex = slateStatic.blockIndexMap.get(props.element._key);
-    block = blockIndex !== void 0 ? slateStatic.children.at(blockIndex) : void 0, t0 = isTextBlock({
-      schema
-    }, block), $[7] = props.element._key, $[8] = schema, $[9] = slateStatic.blockIndexMap, $[10] = slateStatic.children, $[11] = block, $[12] = t0;
-  } else
-    block = $[11], t0 = $[12];
-  if (t0) {
-    const t12 = props.dropPosition?.blockKey === props.element._key ? props.dropPosition.positionBlock : void 0;
-    let t22;
-    return $[13] !== block || $[14] !== props.attributes || $[15] !== props.children || $[16] !== props.element || $[17] !== props.readOnly || $[18] !== props.renderBlock || $[19] !== props.renderListItem || $[20] !== props.renderStyle || $[21] !== props.spellCheck || $[22] !== schema || $[23] !== t12 ? (t22 = /* @__PURE__ */ jsx(RenderTextBlock, { attributes: props.attributes, dropPosition: t12, element: props.element, readOnly: props.readOnly, renderBlock: props.renderBlock, renderListItem: props.renderListItem, renderStyle: props.renderStyle, schema, spellCheck: props.spellCheck, textBlock: block, children: props.children }), $[13] = block, $[14] = props.attributes, $[15] = props.children, $[16] = props.element, $[17] = props.readOnly, $[18] = props.renderBlock, $[19] = props.renderListItem, $[20] = props.renderStyle, $[21] = props.spellCheck, $[22] = schema, $[23] = t12, $[24] = t22) : t22 = $[24], t22;
+    return $[11] !== props.attributes || $[12] !== props.children || $[13] !== props.element || $[14] !== props.readOnly || $[15] !== props.renderChild || $[16] !== schema ? (t02 = /* @__PURE__ */ jsx(RenderInlineObject, { attributes: props.attributes, element: props.element, readOnly: props.readOnly, renderChild: props.renderChild, schema, children: props.children }), $[11] = props.attributes, $[12] = props.children, $[13] = props.element, $[14] = props.readOnly, $[15] = props.renderChild, $[16] = schema, $[17] = t02) : t02 = $[17], t02;
   }
-  const t1 = props.dropPosition?.blockKey === props.element._key ? props.dropPosition.positionBlock : void 0;
-  let t2;
-  return $[25] !== block || $[26] !== props.attributes || $[27] !== props.children || $[28] !== props.element || $[29] !== props.readOnly || $[30] !== props.renderBlock || $[31] !== schema || $[32] !== t1 ? (t2 = /* @__PURE__ */ jsx(RenderBlockObject, { attributes: props.attributes, blockObject: block, dropPosition: t1, element: props.element, readOnly: props.readOnly, renderBlock: props.renderBlock, schema, children: props.children }), $[25] = block, $[26] = props.attributes, $[27] = props.children, $[28] = props.element, $[29] = props.readOnly, $[30] = props.renderBlock, $[31] = schema, $[32] = t1, $[33] = t2) : t2 = $[33], t2;
+  const t0 = props.dropPosition?.blockKey === props.element._key ? props.dropPosition.positionBlock : void 0;
+  let t1;
+  return $[18] !== props.attributes || $[19] !== props.children || $[20] !== props.element || $[21] !== props.readOnly || $[22] !== props.renderBlock || $[23] !== schema || $[24] !== t0 ? (t1 = /* @__PURE__ */ jsx(RenderBlockObject, { attributes: props.attributes, blockObject: props.element, dropPosition: t0, element: props.element, readOnly: props.readOnly, renderBlock: props.renderBlock, schema, children: props.children }), $[18] = props.attributes, $[19] = props.children, $[20] = props.element, $[21] = props.readOnly, $[22] = props.renderBlock, $[23] = schema, $[24] = t0, $[25] = t1) : t1 = $[25], t1;
 }
 function _temp$3(s) {
   return s.context.schema;
@@ -5786,7 +5884,9 @@ function RenderSpan(props) {
     name: schema.span.name,
     fields: t0
   }, $[1] = schema.span.name, $[2] = t1) : t1 = $[2];
-  const schemaType = t1, parent2 = props.children.props.parent, block = parent2 && slateEditor.isTextBlock(parent2) ? parent2 : void 0;
+  const schemaType = t1, parent2 = props.children.props.parent, block = parent2 && isTextBlock({
+    schema: slateEditor.schema
+  }, parent2) ? parent2 : void 0;
   let t2;
   $[3] !== block || $[4] !== props.leaf._key ? (t2 = block ? [{
     _key: block._key
@@ -6875,50 +6975,20 @@ function stopActor(actorRef) {
     ref._processingStatus = 0, ref._snapshot = snapshot;
   });
 }
-function isNode(value, schema) {
-  return isText(value, schema) || isElement(value, schema) || isEditor(value) || isObjectNode(value, schema);
-}
-function isNodeList(value, schema) {
-  return Array.isArray(value) && value.every((val) => isNode(val, schema));
-}
-const FocusedContext = createContext(!1), REACT_MAJOR_VERSION = parseInt(React.version.split(".")[0], 10), Slate = (props) => {
+const Slate = (props) => {
   const {
     editor,
-    children,
-    onChange,
-    onSelectionChange,
-    onValueChange,
-    initialValue,
-    ...rest
-  } = props;
-  React.useState(() => {
-    if (!isNodeList(initialValue, editor.schema))
-      throw new Error(`[Slate] initialValue is invalid! Expected a list of elements but got: ${safeStringify(initialValue)}`);
-    if (!isEditor(editor))
-      throw new Error(`[Slate] editor is invalid! You passed: ${safeStringify(editor)}`);
-    editor.children = initialValue, Object.assign(editor, rest);
-  });
-  const {
+    children
+  } = props, {
     selectorContext,
     onChange: handleSelectorChange
   } = useSelectorContext(), onContextChange = useCallback(() => {
-    onChange && onChange(editor.children), onSelectionChange && editor.operations.find((op) => op.type === "set_selection") && onSelectionChange(editor.selection), onValueChange && editor.operations.find((op) => op.type !== "set_selection") && onValueChange(editor.children), handleSelectorChange();
-  }, [editor, handleSelectorChange, onChange, onSelectionChange, onValueChange]);
-  useEffect(() => (editor.onContextChange = onContextChange, () => {
+    handleSelectorChange();
+  }, [editor, handleSelectorChange]);
+  return useEffect(() => (editor.onContextChange = onContextChange, () => {
     editor.onContextChange = () => {
     };
-  }), [editor, onContextChange]);
-  const [isFocused, setIsFocused] = useState(ReactEditor.isFocused(editor));
-  return useEffect(() => {
-    setIsFocused(ReactEditor.isFocused(editor));
-  }, [editor]), useIsomorphicLayoutEffect(() => {
-    const fn = () => setIsFocused(ReactEditor.isFocused(editor));
-    return REACT_MAJOR_VERSION >= 17 ? (document.addEventListener("focusin", fn), document.addEventListener("focusout", fn), () => {
-      document.removeEventListener("focusin", fn), document.removeEventListener("focusout", fn);
-    }) : (document.addEventListener("focus", fn, !0), document.addEventListener("blur", fn, !0), () => {
-      document.removeEventListener("focus", fn, !0), document.removeEventListener("blur", fn, !0);
-    });
-  }, [editor]), /* @__PURE__ */ jsx(SlateSelectorContext.Provider, { value: selectorContext, children: /* @__PURE__ */ jsx(EditorContext.Provider, { value: editor, children: /* @__PURE__ */ jsx(FocusedContext.Provider, { value: isFocused, children }) }) });
+  }), [editor, onContextChange]), /* @__PURE__ */ jsx(SlateSelectorContext.Provider, { value: selectorContext, children: /* @__PURE__ */ jsx(EditorContext.Provider, { value: editor, children }) });
 };
 const converterJson = {
   mimeType: "application/json",
@@ -7393,14 +7463,20 @@ function createEditableAPI(editor, editorActor) {
       try {
         const activeAnnotations = [], spans = nodes(editor, {
           at: editor.selection,
-          match: (node2) => isText(node2, editor.schema) && node2.marks !== void 0 && Array.isArray(node2.marks) && node2.marks.length > 0
+          match: (node2) => isSpan({
+            schema: editor.schema
+          }, node2) && node2.marks !== void 0 && Array.isArray(node2.marks) && node2.marks.length > 0
         });
         for (const [span, path2] of spans) {
           const [block] = node(editor, path2, {
             depth: 1
           });
-          editor.isTextBlock(block) && block.markDefs?.forEach((def) => {
-            isText(span, editor.schema) && span.marks && Array.isArray(span.marks) && span.marks.includes(def._key) && activeAnnotations.push(def);
+          isTextBlock({
+            schema: editor.schema
+          }, block) && block.markDefs?.forEach((def) => {
+            isSpan({
+              schema: editor.schema
+            }, span) && span.marks && Array.isArray(span.marks) && span.marks.includes(def._key) && activeAnnotations.push(def);
           });
         }
         return activeAnnotations;
@@ -7827,9 +7903,11 @@ function normalize(editor, options = {}) {
     }
     getDirtyPaths2(editor).length !== 0 && withoutNormalizing(editor, () => {
       for (const dirtyPath of getDirtyPaths2(editor))
-        if (hasNode(editor, dirtyPath, editor.schema)) {
+        if (dirtyPath.length !== 0 && hasNode(editor, dirtyPath, editor.schema)) {
           const entry = node(editor, dirtyPath), [entryNode, _] = entry;
-          isElement(entryNode, editor.schema) && entryNode.children.length === 0 && editor.normalizeNode(entry, {
+          isTextBlock({
+            schema: editor.schema
+          }, entryNode) && entryNode.children.length === 0 && editor.normalizeNode(entry, {
             operation
           });
         }
@@ -7845,7 +7923,11 @@ function normalize(editor, options = {}) {
         }))
           return;
         const dirtyPath = popDirtyPath(editor);
-        if (hasNode(editor, dirtyPath, editor.schema)) {
+        if (dirtyPath.length === 0)
+          editor.normalizeNode([editor, dirtyPath], {
+            operation
+          });
+        else if (hasNode(editor, dirtyPath, editor.schema)) {
           const entry = node(editor, dirtyPath);
           editor.normalizeNode(entry, {
             operation
@@ -7869,17 +7951,18 @@ function withoutNormalizing(editor, fn) {
   }
   normalize(editor);
 }
-function isAncestorElement(value, schema) {
-  return isObject(value) && value._type === schema.block.name;
-}
 function extractProps(node2, schema) {
-  if (isAncestorElement(node2, schema)) {
+  if (isTextBlock({
+    schema
+  }, node2)) {
     const {
       children: _children,
       ...properties
     } = node2;
     return properties;
-  } else if (isText(node2, schema)) {
+  } else if (isSpan({
+    schema
+  }, node2)) {
     const {
       text: _text,
       ...properties
@@ -7934,7 +8017,9 @@ function applySplitNode(editor, path2, position, properties) {
   const savedSelection = editor.selection;
   try {
     withoutNormalizing(editor, () => {
-      if (isText(node2, editor.schema)) {
+      if (isSpan({
+        schema: editor.schema
+      }, node2)) {
         const afterText = node2.text.slice(position), newNode = {
           ...properties,
           text: afterText
@@ -7949,16 +8034,18 @@ function applySplitNode(editor, path2, position, properties) {
           path: nextPath(path2),
           node: newNode
         });
-      } else if (isElement(node2, editor.schema)) {
-        const afterChildren = node2.children.slice(position), newNode = {
+      } else if (isTextBlock({
+        schema: editor.schema
+      }, node2)) {
+        const children = node2.children, afterChildren = children.slice(position), newNode = {
           ...properties,
           children: afterChildren
         };
-        for (let i = node2.children.length - 1; i >= position; i--)
+        for (let i = children.length - 1; i >= position; i--)
           editor.apply({
             type: "remove_node",
             path: [...path2, i],
-            node: node2.children[i]
+            node: children[i]
           });
         editor.apply({
           type: "insert_node",
@@ -8002,11 +8089,19 @@ function applyInsertNodeAtPath(editor, node2, path2) {
 }
 function applyInsertNodeAtPoint(editor, node2, at) {
   withoutNormalizing(editor, () => {
-    const match2 = isText(node2, editor.schema) ? (n2) => isText(n2, editor.schema) : (n2) => isText(n2, editor.schema) || editor.isObjectNode(n2), [entry] = nodes(editor, {
+    const match2 = isSpan({
+      schema: editor.schema
+    }, node2) ? (n2) => isSpan({
+      schema: editor.schema
+    }, n2) : (n2) => isSpan({
+      schema: editor.schema
+    }, n2) || isObjectNode({
+      schema: editor.schema
+    }, n2), [entry] = nodes(editor, {
       at: at.path,
       match: match2,
       mode: "lowest",
-      voids: !1
+      includeObjectNodes: !1
     });
     if (!entry)
       return;
@@ -8085,7 +8180,9 @@ function applyMergeNode(editor, path2, position) {
   editorAny.pendingDiffs = [], editorAny.pendingSelection = null, editorAny.pendingAction = null;
   try {
     withoutNormalizing(editor, () => {
-      if (isText(node2, editor.schema))
+      if (isSpan({
+        schema: editor.schema
+      }, node2))
         node2.text.length > 0 && editor.apply({
           type: "insert_text",
           path: prevPath,
@@ -8096,13 +8193,14 @@ function applyMergeNode(editor, path2, position) {
           path: path2,
           node: node2
         });
-      else if (isElement(node2, editor.schema)) {
-        const children = node2.children;
-        for (let i = 0; i < children.length; i++)
+      else if (isTextBlock({
+        schema: editor.schema
+      }, node2)) {
+        for (let i = 0; i < node2.children.length; i++)
           editor.apply({
             type: "insert_node",
             path: [...prevPath, position + i],
-            node: children[i]
+            node: node2.children[i]
           });
         editor.apply({
           type: "remove_node",
@@ -8163,7 +8261,11 @@ function transformPointForMerge(point2, mergePath, position) {
 function applySetNode(editor, props, path2) {
   const node2 = getNode(editor, path2, editor.schema), propsRecord = props, properties = {}, newProperties = {};
   for (const key of Object.keys(propsRecord))
-    key !== "children" && (key === "text" && !isElement(node2, editor.schema) && !editor.isObjectNode(node2) || propsRecord[key] !== node2[key] && (node2.hasOwnProperty(key) && (properties[key] = node2[key]), propsRecord[key] != null && (newProperties[key] = propsRecord[key])));
+    key !== "children" && (key === "text" && !isTextBlock({
+      schema: editor.schema
+    }, node2) && !isObjectNode({
+      schema: editor.schema
+    }, node2) || propsRecord[key] !== node2[key] && (node2.hasOwnProperty(key) && (properties[key] = node2[key]), propsRecord[key] != null && (newProperties[key] = propsRecord[key])));
   (Object.keys(newProperties).length > 0 || Object.keys(properties).length > 0) && editor.apply({
     type: "set_node",
     path: path2,
@@ -8171,18 +8273,15 @@ function applySetNode(editor, props, path2) {
     newProperties
   });
 }
-function getAncestor(root, path2, schema) {
-  const node2 = getNode(root, path2, schema);
-  if (isText(node2, schema) || isObjectNode(node2, schema))
-    throw new Error(`Cannot get the ancestor node at path [${path2}] because it refers to a leaf node instead: ${safeStringify(node2)}`);
-  return node2;
-}
 function* getChildren(root, path2, schema, options = {}) {
   const {
     reverse = !1
-  } = options, ancestor = getAncestor(root, path2, schema), {
-    children
-  } = ancestor;
+  } = options, ancestor = path2.length === 0 ? root : getNode(root, path2, schema);
+  if (!isTextBlock({
+    schema
+  }, ancestor))
+    return;
+  const children = ancestor.children;
   let index = reverse ? children.length - 1 : 0;
   for (; reverse ? index >= 0 : index < children.length; ) {
     const child = getChild(ancestor, index, schema), childPath = path2.concat(index);
@@ -8209,11 +8308,17 @@ function createNormalizationPlugin(editorActor) {
         withNormalizeNode(editor, () => {
           applyInsertNodeAtPath(editor, createPlaceholderBlock(editorActor.getSnapshot().context), [0]);
         });
-      }), editor.isTextBlock(node$1)) {
+      }), isTextBlock({
+        schema: editor.schema
+      }, node$1)) {
         const children = getChildren(editor, path2, editor.schema);
         for (const [child, childPath] of children) {
           const nextNode = node$1.children[childPath[1] + 1];
-          if (editor.isTextSpan(child) && editor.isTextSpan(nextNode) && child.marks?.every((mark) => nextNode.marks?.includes(mark)) && nextNode.marks?.every((mark) => child.marks?.includes(mark))) {
+          if (isSpan({
+            schema: editor.schema
+          }, child) && isSpan({
+            schema: editor.schema
+          }, nextNode) && child.marks?.every((mark) => nextNode.marks?.includes(mark)) && nextNode.marks?.every((mark) => child.marks?.includes(mark))) {
             debug$1.normalization("merging spans with same marks"), withNormalizeNode(editor, () => {
               const mergePath = [childPath[0], childPath[1] + 1];
               applyMergeNode(editor, mergePath, child.text.length);
@@ -8222,7 +8327,9 @@ function createNormalizationPlugin(editorActor) {
           }
         }
       }
-      if (editor.isTextBlock(node$1) && !Array.isArray(node$1.markDefs)) {
+      if (isTextBlock({
+        schema: editor.schema
+      }, node$1) && !Array.isArray(node$1.markDefs)) {
         debug$1.normalization("adding .markDefs to block node"), withNormalizeNode(editor, () => {
           applySetNode(editor, {
             markDefs: []
@@ -8230,7 +8337,9 @@ function createNormalizationPlugin(editorActor) {
         });
         return;
       }
-      if (defaultStyle && editor.isTextBlock(node$1) && typeof node$1.style > "u") {
+      if (defaultStyle && isTextBlock({
+        schema: editor.schema
+      }, node$1) && typeof node$1.style > "u") {
         debug$1.normalization("adding .style to block node"), withNormalizeNode(editor, () => {
           applySetNode(editor, {
             style: defaultStyle
@@ -8238,7 +8347,9 @@ function createNormalizationPlugin(editorActor) {
         });
         return;
       }
-      if (editor.isTextSpan(node$1) && !Array.isArray(node$1.marks)) {
+      if (isSpan({
+        schema: editor.schema
+      }, node$1) && !Array.isArray(node$1.marks)) {
         debug$1.normalization("Adding .marks to span node"), withNormalizeNode(editor, () => {
           applySetNode(editor, {
             marks: []
@@ -8246,9 +8357,13 @@ function createNormalizationPlugin(editorActor) {
         });
         return;
       }
-      if (editor.isTextSpan(node$1)) {
+      if (isSpan({
+        schema: editor.schema
+      }, node$1)) {
         const blockPath = parentPath(path2), [block] = node(editor, blockPath), decorators = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), annotations = node$1.marks?.filter((mark) => !decorators.includes(mark));
-        if (editor.isTextBlock(block) && node$1.text === "" && annotations && annotations.length > 0) {
+        if (isTextBlock({
+          schema: editor.schema
+        }, block) && node$1.text === "" && annotations && annotations.length > 0) {
           debug$1.normalization("removing annotations from empty span node"), withNormalizeNode(editor, () => {
             applySetNode(editor, {
               marks: node$1.marks?.filter((mark) => decorators.includes(mark))
@@ -8257,10 +8372,14 @@ function createNormalizationPlugin(editorActor) {
           return;
         }
       }
-      if (editor.isTextBlock(node$1)) {
+      if (isTextBlock({
+        schema: editor.schema
+      }, node$1)) {
         const decorators = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name);
         for (const [child, childPath] of getChildren(editor, path2, editor.schema))
-          if (editor.isTextSpan(child)) {
+          if (isSpan({
+            schema: editor.schema
+          }, child)) {
             const marks = child.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators.includes(mark) && !node$1.markDefs?.find((def) => def._key === mark));
             if (orphanedAnnotations.length > 0) {
               debug$1.normalization("removing orphaned annotations from span node"), withNormalizeNode(editor, () => {
@@ -8272,9 +8391,13 @@ function createNormalizationPlugin(editorActor) {
             }
           }
       }
-      if (editor.isTextSpan(node$1)) {
+      if (isSpan({
+        schema: editor.schema
+      }, node$1)) {
         const blockPath = parentPath(path2), [block] = node(editor, blockPath);
-        if (editor.isTextBlock(block)) {
+        if (isTextBlock({
+          schema: editor.schema
+        }, block)) {
           const decorators = editorActor.getSnapshot().context.schema.decorators.map((decorator) => decorator.name), marks = node$1.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
           if (orphanedAnnotations.length > 0) {
             debug$1.normalization("removing orphaned annotations from span node"), withNormalizeNode(editor, () => {
@@ -8286,7 +8409,9 @@ function createNormalizationPlugin(editorActor) {
           }
         }
       }
-      if (editor.isTextBlock(node$1)) {
+      if (isTextBlock({
+        schema: editor.schema
+      }, node$1)) {
         const markDefs = node$1.markDefs ?? [], markDefKeys = /* @__PURE__ */ new Set(), newMarkDefs = [];
         for (const markDef of markDefs)
           markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
@@ -8299,8 +8424,12 @@ function createNormalizationPlugin(editorActor) {
           return;
         }
       }
-      if (editor.isTextBlock(node$1)) {
-        const newMarkDefs = (node$1.markDefs || []).filter((def) => node$1.children.find((child) => isText(child, editor.schema) && Array.isArray(child.marks) && child.marks.includes(def._key)));
+      if (isTextBlock({
+        schema: editor.schema
+      }, node$1)) {
+        const newMarkDefs = (node$1.markDefs || []).filter((def) => node$1.children.find((child) => isSpan({
+          schema: editor.schema
+        }, child) && Array.isArray(child.marks) && child.marks.includes(def._key)));
         if (node$1.markDefs && !isEqualMarkDefs(newMarkDefs, node$1.markDefs)) {
           debug$1.normalization("removing markDef not in use"), withNormalizeNode(editor, () => {
             applySetNode(editor, {
@@ -8335,13 +8464,17 @@ function createNormalizationPlugin(editorActor) {
             const focusSpan = Array.from(nodes(editor, {
               mode: "lowest",
               at: op.properties.focus,
-              match: (n2) => editor.isTextSpan(n2),
-              voids: !1
+              match: (n2) => isSpan({
+                schema: editor.schema
+              }, n2),
+              includeObjectNodes: !1
             }))[0]?.[0], newFocusSpan = Array.from(nodes(editor, {
               mode: "lowest",
               at: op.newProperties.focus,
-              match: (n2) => editor.isTextSpan(n2),
-              voids: !1
+              match: (n2) => isSpan({
+                schema: editor.schema
+              }, n2),
+              includeObjectNodes: !1
             }))[0]?.[0], movedToNextSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] + 1 && focusSpan.text.length === op.properties.focus.offset && op.newProperties.focus.offset === 0, movedToPreviousSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] - 1 && op.properties.focus.offset === 0 && newFocusSpan.text.length === op.newProperties.focus.offset;
             !movedToNextSpan && !movedToPreviousSpan && (editor.decoratorState = {});
           }
@@ -9014,7 +9147,9 @@ function toSlateBlock(block, {
         ...childProps
       }) : child;
     });
-    return !hasMissingMarkDefs && !hasMissingChildren && !hasInlines2 && isElement(block, schemaTypes) ? block : {
+    return !hasMissingMarkDefs && !hasMissingChildren && !hasInlines2 && isTextBlock({
+      schema: schemaTypes
+    }, block) ? block : {
       _type,
       _key,
       ...rest,
@@ -9037,10 +9172,14 @@ function isEqualToEmptyEditor(initialValue, blocks, schemaTypes) {
   const firstBlock = blocks.at(0);
   if (!firstBlock)
     return !0;
-  if (!isElement(firstBlock, schemaTypes) || firstBlock._type !== schemaTypes.block.name || "listItem" in firstBlock || !("style" in firstBlock) || firstBlock.style !== schemaTypes.styles.at(0)?.name || !Array.isArray(firstBlock.children) || firstBlock.children.length !== 1)
+  if (!isTextBlock({
+    schema: schemaTypes
+  }, firstBlock) || firstBlock._type !== schemaTypes.block.name || "listItem" in firstBlock || !("style" in firstBlock) || firstBlock.style !== schemaTypes.styles.at(0)?.name || !Array.isArray(firstBlock.children) || firstBlock.children.length !== 1)
     return !1;
   const firstChild = firstBlock.children.at(0);
-  return !(!firstChild || !isText(firstChild, schemaTypes) || !("_type" in firstChild) || firstChild._type !== schemaTypes.span.name || firstChild.text !== "" || firstChild.marks?.join("") || "markDefs" in firstBlock && Array.isArray(firstBlock.markDefs) && firstBlock.markDefs.length > 0 || Object.keys(firstBlock).some((key) => key !== "_type" && key !== "_key" && key !== "children" && key !== "markDefs" && key !== "style") || isEqualValues({
+  return !(!firstChild || !isSpan({
+    schema: schemaTypes
+  }, firstChild) || !("_type" in firstChild) || firstChild._type !== schemaTypes.span.name || firstChild.text !== "" || firstChild.marks?.join("") || "markDefs" in firstBlock && Array.isArray(firstBlock.markDefs) && firstBlock.markDefs.length > 0 || Object.keys(firstBlock).some((key) => key !== "_type" && key !== "_key" && key !== "children" && key !== "markDefs" && key !== "style") || isEqualValues({
     schema: schemaTypes
   }, initialValue, [firstBlock]));
 }
@@ -9076,7 +9215,11 @@ function diffMatchPatch(editor, patch) {
   if (!block)
     return !1;
   const child = findBlockChild(block, patch.path, editor.schema);
-  if (!child || !(block && editor.isTextBlock(block.node) && patch.path.length === 4 && patch.path[1] === "children" && patch.path[3] === "text") || !isText(child.node, editor.schema))
+  if (!child || !(block && isTextBlock({
+    schema: editor.schema
+  }, block.node) && patch.path.length === 4 && patch.path[1] === "children" && patch.path[3] === "text") || !isSpan({
+    schema: editor.schema
+  }, child.node))
     return !1;
   const patches = parse(patch.value), [newValue] = apply$1(patches, child.node.text, {
     allowExceedingIndices: !0
@@ -9145,7 +9288,9 @@ function insertPatch(context, editor, patch) {
   }, {
     schemaTypes: context.schema
   }), normalizedIdx = position === "after" ? targetChild.index + 1 : targetChild.index, childInsertPath = [block.index, normalizedIdx];
-  return childrenToInsert && isElement(childrenToInsert, editor.schema) && childrenToInsert.children.forEach((node2, i) => {
+  return childrenToInsert && isTextBlock({
+    schema: editor.schema
+  }, childrenToInsert) && childrenToInsert.children.forEach((node2, i) => {
     editor.apply({
       type: "insert_node",
       path: [childInsertPath[0], childInsertPath[1] + i],
@@ -9159,13 +9304,19 @@ function setPatch(editor, patch) {
   const block = findBlock(editor.children, patch.path);
   if (!block)
     return !1;
-  const isTextBlock2 = editor.isTextBlock(block.node);
+  const blockIsTextBlock = isTextBlock({
+    schema: editor.schema
+  }, block.node);
   if (patch.path.length === 1) {
     const updatedBlock = applyAll(block.node, [{
       ...patch,
       path: patch.path.slice(1)
     }]);
-    if (editor.isTextBlock(block.node) && isElement(updatedBlock, editor.schema)) {
+    if (isTextBlock({
+      schema: editor.schema
+    }, block.node) && isTextBlock({
+      schema: editor.schema
+    }, updatedBlock)) {
       applySetNode(editor, updatedBlock, [block.index]);
       const previousSelection = editor.selection, childPaths = Array.from(nodes(editor, {
         at: [block.index],
@@ -9193,7 +9344,7 @@ function setPatch(editor, patch) {
     } else
       return applySetNode(editor, updatedBlock, [block.index]), !0;
   }
-  if (isTextBlock2 && patch.path[1] !== "children") {
+  if (blockIsTextBlock && patch.path[1] !== "children") {
     const updatedBlock = applyAll(block.node, [{
       ...patch,
       path: patch.path.slice(1)
@@ -9201,8 +9352,10 @@ function setPatch(editor, patch) {
     return applySetNode(editor, updatedBlock, [block.index]), !0;
   }
   const child = findBlockChild(block, patch.path, editor.schema);
-  if (isTextBlock2 && child) {
-    if (isText(child.node, editor.schema))
+  if (blockIsTextBlock && child) {
+    if (isSpan({
+      schema: editor.schema
+    }, child.node))
       if (value !== null && typeof value == "object" && "text" in value && typeof value.text == "string") {
         if (patch.type === "setIfMissing")
           return !1;
@@ -9239,7 +9392,7 @@ function setPatch(editor, patch) {
       applySetNode(editor, newNode, [block.index, child.index]);
     }
     return !0;
-  } else if (block && !isTextBlock2)
+  } else if (block && !blockIsTextBlock)
     if (patch.path.length > 1 && patch.path[1] !== "children") {
       const newVal = applyAll(block.node, [{
         ...patch,
@@ -9276,7 +9429,9 @@ function unsetPatch(editor, patch) {
     }), !0;
   }
   const child = findBlockChild(block, patch.path, editor.schema);
-  if (editor.isTextBlock(block.node) && child && patch.path[1] === "children" && patch.path.length === 3) {
+  if (isTextBlock({
+    schema: editor.schema
+  }, block.node) && child && patch.path[1] === "children" && patch.path.length === 3) {
     const [childNode] = node(editor, [block.index, child.index]);
     return editor.apply({
       type: "remove_node",
@@ -9284,7 +9439,11 @@ function unsetPatch(editor, patch) {
       node: childNode
     }), !0;
   }
-  if (child && (isElement(child.node, editor.schema) || editor.isObjectNode(child.node))) {
+  if (child && (isTextBlock({
+    schema: editor.schema
+  }, child.node) || isObjectNode({
+    schema: editor.schema
+  }, child.node))) {
     const propEntry = patch.path.slice(3).at(0);
     if (propEntry === void 0 || typeof propEntry == "string" && ["_key", "_type", "children"].includes(propEntry))
       return !1;
@@ -9301,7 +9460,9 @@ function unsetPatch(editor, patch) {
       applySetNode(editor, newNode, [block.index, child.index]);
     return !0;
   }
-  if (child && isText(child.node, editor.schema)) {
+  if (child && isSpan({
+    schema: editor.schema
+  }, child.node)) {
     const propPath = patch.path.slice(3), propEntry = propPath.at(0);
     if (propEntry === void 0 || typeof propEntry == "string" && ["_key", "_type"].includes(propEntry))
       return !1;
@@ -9321,7 +9482,9 @@ function unsetPatch(editor, patch) {
     return applySetNode(editor, unsetProps, [block.index, child.index]), !0;
   }
   if (!child) {
-    if (!editor.isTextBlock(block.node)) {
+    if (!isTextBlock({
+      schema: editor.schema
+    }, block.node)) {
       const newVal = applyAll(block.node, [{
         ...patch,
         path: patch.path.slice(1)
@@ -9335,7 +9498,9 @@ function unsetPatch(editor, patch) {
         applySetNode(editor, newVal, [block.index]);
       return !0;
     }
-    if (editor.isTextBlock(block.node)) {
+    if (isTextBlock({
+      schema: editor.schema
+    }, block.node)) {
       const propPath = patch.path.slice(1), propEntry = propPath.at(0);
       if (propEntry === void 0 || typeof propEntry != "string" || ["_key", "_type", "children"].includes(propEntry))
         return !1;
@@ -9372,7 +9537,9 @@ function findBlock(children, path2) {
 }
 function findBlockChild(block, path2, schema) {
   const blockNode = block.node;
-  if (!isElement(blockNode, schema) || path2[1] !== "children")
+  if (!isTextBlock({
+    schema
+  }, blockNode) || path2[1] !== "children")
     return;
   let childIndex = -1;
   const child = blockNode.children.find((node2, index) => {
@@ -9473,7 +9640,9 @@ function setNodePatch(schema, children, operation) {
       const child = block.children[operation.path[1]];
       if (child) {
         const blockKey = block._key, childKey = child._key, patches = [];
-        if (isElement(child, schema)) {
+        if (isTextBlock({
+          schema
+        }, child)) {
           const _key = operation.newProperties._key;
           _key !== void 0 && patches.push(set(_key, [{
             _key: blockKey
@@ -9533,7 +9702,9 @@ function insertNodePatch(schema, children, operation, beforeValue) {
     }], setIfMissingPatch = setIfMissing([], [{
       _key: block._key
     }, "children"]);
-    return isText(operation.node, schema) ? [setIfMissingPatch, insert([operation.node], position, path2)] : [setIfMissingPatch, insert([operation.node], position, path2)];
+    return isSpan({
+      schema
+    }, operation.node) ? [setIfMissingPatch, insert([operation.node], position, path2)] : [setIfMissingPatch, insert([operation.node], position, path2)];
   }
   return [];
 }
@@ -9657,12 +9828,7 @@ function createSchemaPlugin({
   editorActor
 }) {
   return function(editor) {
-    editor.isTextBlock = (value) => isEditor(value) ? !1 : isTextBlock(editorActor.getSnapshot().context, value), editor.isTextSpan = (value) => isEditor(value) ? !1 : isSpan(editorActor.getSnapshot().context, value), editor.isListBlock = (value) => isEditor(value) ? !1 : isListBlock(editorActor.getSnapshot().context, value), editor.schema = editorActor.getSnapshot().context.schema, editor.isObjectNode = (value) => {
-      if (!isObject(value) || isEditor(value))
-        return !1;
-      const obj = value;
-      return typeof obj._type == "string" && obj._type !== editor.schema.block.name && obj._type !== editor.schema.span.name;
-    }, editor.isInline = (element) => {
+    editor.schema = editorActor.getSnapshot().context.schema, editor.isInline = (element) => {
       if (isEditor(element))
         return !1;
       const snapshot = editorActor.getSnapshot();
@@ -9680,6 +9846,10 @@ function createSchemaPlugin({
     } = editor;
     return editor.normalizeNode = (entry) => {
       const [node2, path2] = entry;
+      if (isEditor(node2)) {
+        normalizeNode2(entry);
+        return;
+      }
       if (node2._type === void 0 && path2.length === 2) {
         debug$1.normalization("Setting span type on text node without a type");
         const span = node2, key = span._key || editorActor.getSnapshot().context.keyGenerator();
@@ -9708,6 +9878,10 @@ function createSchemaPlugin({
     }, editor;
   };
 }
+function parent(editor, at, options = {}) {
+  const nodePath = path(editor, at, options), parentPath_ = parentPath(nodePath);
+  return parentPath_.length === 0 ? [editor, parentPath_] : node(editor, parentPath_);
+}
 function createUniqueKeysPlugin(editorActor) {
   const context = editorActor.getSnapshot().context;
   return function(editor) {
@@ -9744,7 +9918,11 @@ function createUniqueKeysPlugin(editorActor) {
       apply2(operation);
     }, editor.normalizeNode = (entry) => {
       const [node2, path2] = entry;
-      if (isElement(node2, editor.schema) || editor.isObjectNode(node2)) {
+      if (isTextBlock({
+        schema: editor.schema
+      }, node2) || isObjectNode({
+        schema: editor.schema
+      }, node2)) {
         const [parentNode] = parent(editor, path2);
         if (parentNode && isEditor(parentNode)) {
           const blockKeys = /* @__PURE__ */ new Set();
@@ -9771,7 +9949,9 @@ function createUniqueKeysPlugin(editorActor) {
           }
         }
       }
-      if (isElement(node2, editor.schema) && node2._type === editorActor.getSnapshot().context.schema.block.name) {
+      if (isTextBlock({
+        schema: editor.schema
+      }, node2)) {
         if (!node2._key) {
           withNormalizeNode(editor, () => {
             applySetNode(editor, {
@@ -9978,22 +10158,36 @@ const insertChildren = (xs, index, ...newValues) => [...xs.slice(0, index), ...n
     const index2 = slicedPath.pop(), ancestorNode = getNode(root, slicedPath, schema);
     modifiedNode = {
       ...ancestorNode,
-      children: replaceChildren(ancestorNode.children, index2, 1, modifiedNode)
+      children: replaceChildren(isTextBlock({
+        schema
+      }, ancestorNode) ? ancestorNode.children : [], index2, 1, modifiedNode)
     };
   }
-  const index = slicedPath.pop();
-  root.children = replaceChildren(root.children, index, 1, modifiedNode);
+  const index = slicedPath.pop(), newRootChildren = replaceChildren(isEditor(root) || isTextBlock({
+    schema
+  }, root) ? root.children : [], index, 1, modifiedNode);
+  root.children = newRootChildren;
 }, modifyChildren = (root, path2, schema, f) => {
-  path2.length === 0 ? root.children = f(root.children) : modifyDescendant(root, path2, schema, (node2) => {
-    if (isText(node2, schema) || isObjectNode(node2, schema))
+  path2.length === 0 ? root.children = f(isEditor(root) || isTextBlock({
+    schema
+  }, root) ? root.children : []) : modifyDescendant(root, path2, schema, (node2) => {
+    if (isSpan({
+      schema
+    }, node2) || isObjectNode({
+      schema
+    }, node2))
       throw new Error(`Cannot get the element at path [${path2}] because it refers to a leaf node: ${safeStringify(node2)}`);
     return {
       ...node2,
-      children: f(node2.children)
+      children: f(isTextBlock({
+        schema
+      }, node2) ? node2.children : [])
     };
   });
 }, modifyLeaf = (root, path2, schema, f) => modifyDescendant(root, path2, schema, (node2) => {
-  if (!isText(node2, schema))
+  if (!isSpan({
+    schema
+  }, node2))
     throw new Error(`Cannot get the leaf node at path [${path2}] because it refers to a non-leaf node: ${safeStringify(node2)}`);
   return f(node2);
 });
@@ -10093,11 +10287,11 @@ function applyOperation(editor, op) {
       modifyDescendant(editor, path2, editor.schema, (node2) => {
         const newNode = {
           ...node2
-        }, isElement2 = "children" in node2 && Array.isArray(node2.children);
+        }, isElement = "children" in node2 && Array.isArray(node2.children);
         for (const key in newProperties) {
           if (key === "children")
             throw new Error(`Cannot set the "${key}" property of nodes!`);
-          if (key === "text" && !isElement2 && Array.isArray(node2.marks))
+          if (key === "text" && !isElement && Array.isArray(node2.marks))
             throw new Error(`Cannot set the "${key}" property of nodes!`);
           const value = newProperties[key];
           value == null ? delete newNode[key] : newNode[key] = value;
@@ -10219,7 +10413,9 @@ const getDirtyPaths = (_editor, op) => {
       const {
         node: node2,
         path: path2
-      } = op, levels2 = pathLevels(path2), descendants = isText(node2, _editor.schema) ? [] : Array.from(getNodes(node2, _editor.schema), ([, p]) => path2.concat(p));
+      } = op, levels2 = pathLevels(path2), descendants = isSpan({
+        schema: _editor.schema
+      }, node2) ? [] : Array.from(getNodes(node2, _editor.schema), ([, p]) => path2.concat(p));
       return [...levels2, ...descendants];
     }
     case "remove_node": {
@@ -10232,6 +10428,14 @@ const getDirtyPaths = (_editor, op) => {
       return [];
   }
 };
+function getTextBlockNode(root, path2, schema) {
+  const node2 = getNode(root, path2, schema);
+  if (isTextBlock({
+    schema
+  }, node2))
+    return node2;
+  throw new Error(`Cannot get the text block at path [${path2}] because it refers to a non-text-block node: ${safeStringify(node2)}`);
+}
 function pointRef(editor, point2, options = {}) {
   const {
     affinity = "forward"
@@ -10251,22 +10455,23 @@ const getDefaultInsertLocation = (editor) => editor.selection ? editor.selection
 function elementReadOnly(editor, options = {}) {
   return above(editor, {
     ...options,
-    match: (n2) => isElement(n2, editor.schema) && editor.isElementReadOnly(n2)
+    match: (n2) => isTextBlock({
+      schema: editor.schema
+    }, n2) && editor.isElementReadOnly(n2)
   });
 }
-function previous(editor, options = {}) {
+function previous(editor, options) {
   const {
     mode = "lowest",
-    voids = !1
-  } = options;
-  let {
+    includeObjectNodes = !1
+  } = options, {
     match: match2,
     at = editor.selection
   } = options;
   if (!at)
     return;
   const pointBeforeLocation = before(editor, at, {
-    voids
+    includeObjectNodes
   });
   if (!pointBeforeLocation)
     return;
@@ -10275,23 +10480,28 @@ function previous(editor, options = {}) {
   })), span = [pointBeforeLocation.path, to];
   if (isPath(at) && at.length === 0)
     throw new Error("Cannot get the previous node from the root node!");
-  if (match2 == null)
-    if (isPath(at)) {
-      const [parentNode] = parent(editor, at);
-      match2 = (n2) => parentNode.children.includes(n2);
-    } else
-      match2 = () => !0;
   const [previousEntry] = nodes(editor, {
     reverse: !0,
     at: span,
     match: match2,
     mode,
-    voids
+    includeObjectNodes
   });
   return previousEntry;
 }
 function shouldMergeNodesRemovePrevNode(_editor, [prevNode, prevPath], [_curNode, _curNodePath]) {
-  return isElement(prevNode, _editor.schema) && (prevNode.children.length === 0 || prevNode.children.length === 1 && isText(prevNode.children[0], _editor.schema) && prevNode.children[0].text === "") || isText(prevNode, _editor.schema) && prevNode.text === "" && prevPath[prevPath.length - 1] !== 0;
+  let isEmptyElement = !1;
+  if (isTextBlock({
+    schema: _editor.schema
+  }, prevNode)) {
+    const prevChildren = prevNode.children;
+    isEmptyElement = prevChildren.length === 0 || prevChildren.length === 1 && isSpan({
+      schema: _editor.schema
+    }, prevChildren[0]) && prevChildren[0].text === "";
+  }
+  return isEmptyElement || isSpan({
+    schema: _editor.schema
+  }, prevNode) && prevNode.text === "" && prevPath[prevPath.length - 1] !== 0;
 }
 function isCommonPath(path2, another) {
   return path2.length <= another.length && comparePaths(path2, another) === 0;
@@ -10299,7 +10509,7 @@ function isCommonPath(path2, another) {
 function insertText(editor, text, options = {}) {
   withoutNormalizing(editor, () => {
     const {
-      voids = !1
+      includeObjectNodes = !1
     } = options;
     let {
       at = getDefaultInsertLocation(editor)
@@ -10309,14 +10519,14 @@ function insertText(editor, text, options = {}) {
         at = at.anchor;
       else {
         const end2 = rangeEnd(at);
-        if (!voids && getVoid(editor, {
+        if (!includeObjectNodes && getObjectNode(editor, {
           at: end2
         }))
           return;
         const start2 = rangeStart(at), startRef = pointRef(editor, start2), endRef = pointRef(editor, end2);
         deleteText(editor, {
           at,
-          voids
+          includeObjectNodes
         });
         const startPoint = startRef.unref(), endPoint = endRef.unref();
         at = startPoint || endPoint, editor.setSelection({
@@ -10324,7 +10534,7 @@ function insertText(editor, text, options = {}) {
           focus: at
         });
       }
-    if (!voids && getVoid(editor, {
+    if (!includeObjectNodes && getObjectNode(editor, {
       at
     }) || elementReadOnly(editor, {
       at
@@ -10350,7 +10560,7 @@ function removeNodes(editor, options = {}) {
   withoutNormalizing(editor, () => {
     const {
       hanging = !1,
-      voids = !1,
+      includeObjectNodes = !1,
       mode = "lowest"
     } = options;
     let {
@@ -10359,14 +10569,16 @@ function removeNodes(editor, options = {}) {
     } = options;
     if (!at)
       return;
-    match2 == null && (match2 = isPath(at) ? matchPath(editor, at) : (n2) => isElement(n2, editor.schema) && isBlock(editor, n2)), !hanging && isRange(at) && (at = unhangRange(editor, at, {
-      voids
+    match2 == null && (match2 = isPath(at) ? matchPath(editor, at) : (n2) => isTextBlock({
+      schema: editor.schema
+    }, n2)), !hanging && isRange(at) && (at = unhangRange(editor, at, {
+      includeObjectNodes
     }));
     const depths = nodes(editor, {
       at,
       match: match2,
       mode,
-      voids
+      includeObjectNodes
     }), pathRefs = Array.from(depths, ([, p]) => pathRef(editor, p));
     for (const ref of pathRefs) {
       const path2 = ref.unref();
@@ -10387,7 +10599,7 @@ function deleteText(editor, options = {}) {
       reverse = !1,
       unit = "character",
       distance = 1,
-      voids = !1
+      includeObjectNodes = !1
     } = options;
     let {
       at = editor.selection,
@@ -10397,12 +10609,12 @@ function deleteText(editor, options = {}) {
       return;
     let isCollapsed = !1;
     if (isRange(at) && isCollapsedRange(at) && (isCollapsed = !0, at = at.anchor), isPoint(at)) {
-      const furthestVoid = getVoid(editor, {
+      const furthestObjectNode = getObjectNode(editor, {
         at,
         mode: "highest"
       });
-      if (!voids && furthestVoid) {
-        const [, voidPath] = furthestVoid;
+      if (!includeObjectNodes && furthestObjectNode) {
+        const [, voidPath] = furthestObjectNode;
         at = voidPath;
       } else {
         const opts = {
@@ -10418,7 +10630,7 @@ function deleteText(editor, options = {}) {
     if (isPath(at)) {
       removeNodes(editor, {
         at,
-        voids
+        includeObjectNodes
       });
       return;
     }
@@ -10427,25 +10639,29 @@ function deleteText(editor, options = {}) {
     if (!hanging) {
       const [, end2] = rangeEdges(at), endOfDoc = end(editor, []);
       pointEquals(end2, endOfDoc) || (at = unhangRange(editor, at, {
-        voids
+        includeObjectNodes
       }));
     }
     let [start$1, end$1] = rangeEdges(at);
     const startBlock = above(editor, {
-      match: (n2) => isElement(n2, editor.schema) && isBlock(editor, n2),
+      match: (n2) => isTextBlock({
+        schema: editor.schema
+      }, n2),
       at: start$1,
-      voids
+      includeObjectNodes
     }), endBlock = above(editor, {
-      match: (n2) => isElement(n2, editor.schema) && isBlock(editor, n2),
+      match: (n2) => isTextBlock({
+        schema: editor.schema
+      }, n2),
       at: end$1,
-      voids
-    }), isAcrossBlocks = startBlock && endBlock && !pathEquals(startBlock[1], endBlock[1]), isSingleText = pathEquals(start$1.path, end$1.path), startNonEditable = voids ? null : getVoid(editor, {
+      includeObjectNodes
+    }), isAcrossBlocks = startBlock && endBlock && !pathEquals(startBlock[1], endBlock[1]), isSingleText = pathEquals(start$1.path, end$1.path), startNonEditable = includeObjectNodes ? null : getObjectNode(editor, {
       at: start$1,
       mode: "highest"
     }) ?? elementReadOnly(editor, {
       at: start$1,
       mode: "highest"
-    }), endNonEditable = voids ? null : getVoid(editor, {
+    }), endNonEditable = includeObjectNodes ? null : getObjectNode(editor, {
       at: end$1,
       mode: "highest"
     }) ?? elementReadOnly(editor, {
@@ -10464,16 +10680,22 @@ function deleteText(editor, options = {}) {
     let lastPath;
     for (const entry of nodes(editor, {
       at,
-      voids
+      includeObjectNodes
     })) {
       const [node2, path2] = entry;
-      lastPath && comparePaths(path2, lastPath) === 0 || (!voids && (editor.isObjectNode(node2) || isElement(node2, editor.schema) && editor.isElementReadOnly(node2)) || !isCommonPath(path2, start$1.path) && !isCommonPath(path2, end$1.path)) && (matches.push(entry), lastPath = path2);
+      lastPath && comparePaths(path2, lastPath) === 0 || (!includeObjectNodes && (isObjectNode({
+        schema: editor.schema
+      }, node2) || isTextBlock({
+        schema: editor.schema
+      }, node2) && editor.isElementReadOnly(node2)) || !isCommonPath(path2, start$1.path) && !isCommonPath(path2, end$1.path)) && (matches.push(entry), lastPath = path2);
     }
     const pathRefs = Array.from(matches, ([, p]) => pathRef(editor, p)), startRef = pointRef(editor, start$1), endRef = pointRef(editor, end$1);
     let removedText = "";
     if (!isSingleText && !startNonEditable) {
       const point22 = startRef.current, node2 = getNode(editor, point22.path, editor.schema);
-      if (isText(node2, editor.schema)) {
+      if (isSpan({
+        schema: editor.schema
+      }, node2)) {
         const {
           path: path2
         } = point22, {
@@ -10490,11 +10712,13 @@ function deleteText(editor, options = {}) {
     if (pathRefs.reverse().map((r) => r.unref()).filter((r) => r !== null).forEach((p) => {
       removeNodes(editor, {
         at: p,
-        voids
+        includeObjectNodes
       });
     }), !endNonEditable) {
       const point22 = endRef.current, node2 = getNode(editor, point22.path, editor.schema);
-      if (isText(node2, editor.schema)) {
+      if (isSpan({
+        schema: editor.schema
+      }, node2)) {
         const {
           path: path2
         } = point22, offset = isSingleText ? start$1.offset : 0, text = node2.text.slice(offset, end$1.offset);
@@ -10507,15 +10731,17 @@ function deleteText(editor, options = {}) {
       }
     }
     if (!isSingleText && isAcrossBlocks && endRef.current && startRef.current) {
-      const mergeAt = endRef.current, mergeMatch = (n2) => isElement(n2, editor.schema) && isBlock(editor, n2), [current] = nodes(editor, {
+      const mergeAt = endRef.current, mergeMatch = (n2) => isTextBlock({
+        schema: editor.schema
+      }, n2), [current] = nodes(editor, {
         at: mergeAt,
         match: mergeMatch,
-        voids,
+        includeObjectNodes,
         mode: "lowest"
       }), prev = previous(editor, {
         at: mergeAt,
         match: mergeMatch,
-        voids,
+        includeObjectNodes,
         mode: "lowest"
       });
       if (current && prev) {
@@ -10524,9 +10750,11 @@ function deleteText(editor, options = {}) {
           const newPath = nextPath(prevPath), common = commonPath(mergePath, prevPath), isPreviousSibling = isSiblingPath(mergePath, prevPath), editorLevels = Array.from(levels(editor, {
             at: mergePath
           }), ([n2]) => n2).slice(common.length).slice(0, -1), hasSingleChildNest = (node2) => {
-            if (isElement(node2, editor.schema)) {
-              const element = node2;
-              return element.children.length === 1 ? hasSingleChildNest(element.children[0]) : !1;
+            if (isTextBlock({
+              schema: editor.schema
+            }, node2)) {
+              const elementChildren = node2.children;
+              return elementChildren.length === 1 ? hasSingleChildNest(elementChildren[0]) : !1;
             } else return !isEditor(node2);
           }, emptyAncestor = above(editor, {
             at: mergePath,
@@ -10534,9 +10762,17 @@ function deleteText(editor, options = {}) {
             match: (n2) => editorLevels.includes(n2) && hasSingleChildNest(n2)
           }), emptyRef = emptyAncestor && pathRef(editor, emptyAncestor[1]);
           let position;
-          if (isText(mergeNode, editor.schema) && isText(prevNode, editor.schema))
+          if (isSpan({
+            schema: editor.schema
+          }, mergeNode) && isSpan({
+            schema: editor.schema
+          }, prevNode))
             position = prevNode.text.length;
-          else if (isElement(mergeNode, editor.schema) && isElement(prevNode, editor.schema))
+          else if (isTextBlock({
+            schema: editor.schema
+          }, mergeNode) && isTextBlock({
+            schema: editor.schema
+          }, prevNode))
             position = prevNode.children.length;
           else
             throw new Error(`Cannot merge the node at path [${mergePath}] with the previous sibling because it is not the same kind: ${safeStringify(mergeNode)} ${safeStringify(prevNode)}`);
@@ -10554,15 +10790,19 @@ function deleteText(editor, options = {}) {
           }
           if (emptyRef && removeNodes(editor, {
             at: emptyRef.current,
-            voids
+            includeObjectNodes
           }), shouldMergeNodesRemovePrevNode(editor, prev, current))
             removeNodes(editor, {
               at: prevPath,
-              voids
+              includeObjectNodes
             });
           else {
             const pteEditor = editor;
-            if (pteEditor.isTextBlock(mergeNode) && pteEditor.isTextBlock(prevNode) && Array.isArray(mergeNode.markDefs) && mergeNode.markDefs.length > 0) {
+            if (isTextBlock({
+              schema: editor.schema
+            }, mergeNode) && isTextBlock({
+              schema: editor.schema
+            }, prevNode) && Array.isArray(mergeNode.markDefs) && mergeNode.markDefs.length > 0) {
               const targetPath = isPreviousSibling ? prevPath : previousPath(newPath), oldDefs = Array.isArray(prevNode.markDefs) && prevNode.markDefs || [], newMarkDefs = [...new Map([...oldDefs, ...mergeNode.markDefs].map((def) => [def._key, def])).values()];
               applySetNode(pteEditor, {
                 markDefs: newMarkDefs
@@ -10583,7 +10823,7 @@ function insertNodes(editor, nodes$1, options = {}) {
   withoutNormalizing(editor, () => {
     const {
       hanging = !1,
-      voids = !1,
+      includeObjectNodes = !1,
       mode = "lowest",
       batchDirty = !0
     } = options;
@@ -10592,12 +10832,12 @@ function insertNodes(editor, nodes$1, options = {}) {
       match: match2,
       select: select2
     } = options;
-    if (isNode(nodes$1, editor.schema) && (nodes$1 = [nodes$1]), nodes$1.length === 0)
+    if (nodes$1.length === 0)
       return;
     const node2 = nodes$1[0];
     if (at || (at = getDefaultInsertLocation(editor), select2 !== !1 && (select2 = !0)), select2 == null && (select2 = !1), isRange(at))
       if (hanging || (at = unhangRange(editor, at, {
-        voids
+        includeObjectNodes
       })), isCollapsedRange(at))
         at = at.anchor;
       else {
@@ -10607,12 +10847,20 @@ function insertNodes(editor, nodes$1, options = {}) {
         }), at = endPointRef.unref();
       }
     if (isPoint(at)) {
-      match2 == null && (isText(node2, editor.schema) ? match2 = (n2) => isText(n2, editor.schema) : editor.isInline(node2) ? match2 = (n2) => isText(n2, editor.schema) || editor.isInline(n2) : match2 = (n2) => isElement(n2, editor.schema) && isBlock(editor, n2));
+      match2 == null && (isSpan({
+        schema: editor.schema
+      }, node2) ? match2 = (n2) => isSpan({
+        schema: editor.schema
+      }, n2) : editor.isInline(node2) ? match2 = (n2) => isSpan({
+        schema: editor.schema
+      }, n2) || editor.isInline(n2) : match2 = (n2) => isTextBlock({
+        schema: editor.schema
+      }, n2));
       const [entry] = nodes(editor, {
         at: at.path,
         match: match2,
         mode,
-        voids
+        includeObjectNodes
       });
       if (entry) {
         const [, matchPath2] = entry, matchPathRef = pathRef(editor, matchPath2), isAtEnd = isEnd(editor, at, matchPath2);
@@ -10626,7 +10874,7 @@ function insertNodes(editor, nodes$1, options = {}) {
               at: splitAt,
               match: match2,
               mode,
-              voids
+              includeObjectNodes
             });
             if (highest) {
               afterRef = pointRef(editor, splitAt);
@@ -10635,7 +10883,7 @@ function insertNodes(editor, nodes$1, options = {}) {
               for (const [node22, nodePath] of levels(editor, {
                 at: lowestPath,
                 reverse: !0,
-                voids
+                includeObjectNodes
               })) {
                 let split = !1;
                 if (nodePath.length < highestPath.length || nodePath.length === 0)
@@ -10660,7 +10908,7 @@ function insertNodes(editor, nodes$1, options = {}) {
     }
     const parentPath_ = parentPath(at);
     let index = at[at.length - 1];
-    if (!(!voids && getVoid(editor, {
+    if (!(!includeObjectNodes && getObjectNode(editor, {
       at: parentPath_
     }))) {
       if (batchDirty) {
@@ -10674,7 +10922,9 @@ function insertNodes(editor, nodes$1, options = {}) {
               path: path2,
               node: node22
             };
-            editor.apply(op), at = nextPath(at), batchedOps.push(op), isText(node22, editor.schema) ? newDirtyPaths.push(path2) : newDirtyPaths.push(...Array.from(getNodes(node22, editor.schema), ([, p]) => path2.concat(p)));
+            editor.apply(op), at = nextPath(at), batchedOps.push(op), isSpan({
+              schema: editor.schema
+            }, node22) ? newDirtyPaths.push(path2) : newDirtyPaths.push(...Array.from(getNodes(node22, editor.schema), ([, p]) => path2.concat(p)));
           }
         }, () => {
           updateDirtyPaths(editor, newDirtyPaths, (p) => {
@@ -10703,85 +10953,111 @@ function insertNodes(editor, nodes$1, options = {}) {
 }
 const normalizeNode = (editor, entry) => {
   const [node2, path2] = entry;
-  if (isText(node2, editor.schema) || editor.isObjectNode(node2))
+  if (isSpan({
+    schema: editor.schema
+  }, node2) || isObjectNode({
+    schema: editor.schema
+  }, node2))
     return;
-  "children" in node2 || (node2.children = []);
+  node2.children ??= [];
   let element = node2;
   if (element !== editor && element.children.length === 0) {
     const child = editor.createSpan();
-    insertNodes(editor, child, {
+    insertNodes(editor, [child], {
       at: path2.concat(0),
-      voids: !0
-    }), element = getNode(editor, path2, editor.schema);
+      includeObjectNodes: !0
+    }), element = getTextBlockNode(editor, path2, editor.schema);
   }
   const firstChild = element.children[0];
-  if (element !== editor && (editor.isInline(element) || isText(firstChild, editor.schema) || editor.isObjectNode(firstChild) || isElement(firstChild, editor.schema) && editor.isInline(firstChild)))
+  if (!isEditor(element) && (editor.isInline(element) || isSpan({
+    schema: editor.schema
+  }, firstChild) || isObjectNode({
+    schema: editor.schema
+  }, firstChild) || isTextBlock({
+    schema: editor.schema
+  }, firstChild) && editor.isInline(firstChild)))
     for (let n2 = 0; n2 < element.children.length; n2++) {
       const child = element.children[n2], prev = element.children[n2 - 1];
-      if (isText(child, editor.schema)) {
-        if (prev != null && isText(prev, editor.schema)) {
+      if (isSpan({
+        schema: editor.schema
+      }, child)) {
+        if (prev != null && isSpan({
+          schema: editor.schema
+        }, prev)) {
           if (child.text === "")
             removeNodes(editor, {
               at: path2.concat(n2),
-              voids: !0
-            }), element = getNode(editor, path2, editor.schema), n2--;
+              includeObjectNodes: !0
+            }), element = getTextBlockNode(editor, path2, editor.schema), n2--;
           else if (prev.text === "")
             removeNodes(editor, {
               at: path2.concat(n2 - 1),
-              voids: !0
-            }), element = getNode(editor, path2, editor.schema), n2--;
+              includeObjectNodes: !0
+            }), element = getTextBlockNode(editor, path2, editor.schema), n2--;
           else if (textEquals(child, prev, {
             loose: !0
           })) {
             const mergePath = path2.concat(n2);
-            applyMergeNode(editor, mergePath, prev.text.length), element = getNode(editor, path2, editor.schema), n2--;
+            applyMergeNode(editor, mergePath, prev.text.length), element = getTextBlockNode(editor, path2, editor.schema), n2--;
           }
         }
-      } else if (isElement(child, editor.schema))
+      } else if (isTextBlock({
+        schema: editor.schema
+      }, child))
         if (editor.isInline(child)) {
-          if (prev == null || !isText(prev, editor.schema)) {
+          if (prev == null || !isSpan({
+            schema: editor.schema
+          }, prev)) {
             const newChild = editor.createSpan();
-            insertNodes(editor, newChild, {
+            insertNodes(editor, [newChild], {
               at: path2.concat(n2),
-              voids: !0
-            }), element = getNode(editor, path2, editor.schema), n2++;
+              includeObjectNodes: !0
+            }), element = getTextBlockNode(editor, path2, editor.schema), n2++;
           }
           if (n2 === element.children.length - 1) {
             const newChild = editor.createSpan();
-            insertNodes(editor, newChild, {
+            insertNodes(editor, [newChild], {
               at: path2.concat(n2 + 1),
-              voids: !0
-            }), element = getNode(editor, path2, editor.schema), n2++;
+              includeObjectNodes: !0
+            }), element = getTextBlockNode(editor, path2, editor.schema), n2++;
           }
         } else
           removeNodes(editor, {
             at: path2.concat(n2),
-            voids: !0
-          }), element = getNode(editor, path2, editor.schema), n2--;
-      else if (editor.isObjectNode(child)) {
-        if (prev == null || !isText(prev, editor.schema)) {
+            includeObjectNodes: !0
+          }), element = getTextBlockNode(editor, path2, editor.schema), n2--;
+      else if (isObjectNode({
+        schema: editor.schema
+      }, child)) {
+        if (prev == null || !isSpan({
+          schema: editor.schema
+        }, prev)) {
           const newChild = editor.createSpan();
-          insertNodes(editor, newChild, {
+          insertNodes(editor, [newChild], {
             at: path2.concat(n2),
-            voids: !0
-          }), element = getNode(editor, path2, editor.schema), n2++;
+            includeObjectNodes: !0
+          }), element = getTextBlockNode(editor, path2, editor.schema), n2++;
         }
         if (n2 === element.children.length - 1) {
           const newChild = editor.createSpan();
-          insertNodes(editor, newChild, {
+          insertNodes(editor, [newChild], {
             at: path2.concat(n2 + 1),
-            voids: !0
-          }), element = getNode(editor, path2, editor.schema), n2++;
+            includeObjectNodes: !0
+          }), element = getTextBlockNode(editor, path2, editor.schema), n2++;
         }
       }
     }
   else
     for (let n2 = 0; n2 < element.children.length; n2++) {
       const child = element.children[n2];
-      (isText(child, editor.schema) || isElement(child, editor.schema) && editor.isInline(child)) && (removeNodes(editor, {
+      (isSpan({
+        schema: editor.schema
+      }, child) || isTextBlock({
+        schema: editor.schema
+      }, child) && editor.isInline(child)) && (removeNodes(editor, {
         at: path2.concat(n2),
-        voids: !0
-      }), element = getNode(editor, path2, editor.schema), n2--);
+        includeObjectNodes: !0
+      }), element = path2.length === 0 ? editor : getTextBlockNode(editor, path2, editor.schema), n2--);
     }
 };
 function select(editor, target) {
@@ -10845,7 +11121,6 @@ const shouldNormalize = (_editor, {
     }),
     isElementReadOnly: () => !1,
     isInline: () => !1,
-    isSelectable: () => !0,
     onChange: () => {
     },
     // Core
@@ -11170,7 +11445,7 @@ const withDOM = (editor) => {
     apply: apply2,
     onChange
   } = e;
-  return e.isNodeMapDirty = !1, e.domWindow = null, e.domElement = null, e.domPlaceholder = "", e.domPlaceholderElement = null, e.keyToElement = /* @__PURE__ */ new WeakMap(), e.nodeToIndex = /* @__PURE__ */ new WeakMap(), e.nodeToParent = /* @__PURE__ */ new WeakMap(), e.elementToNode = /* @__PURE__ */ new WeakMap(), e.nodeToElement = /* @__PURE__ */ new WeakMap(), e.nodeToKey = /* @__PURE__ */ new WeakMap(), e.readOnly = !1, e.focused = !1, e.composing = !1, e.userSelection = null, e.onContextChange = null, e.scheduleFlush = null, e.pendingInsertionMarks = null, e.userMarks = null, e.pendingDiffs = [], e.pendingAction = null, e.pendingSelection = null, e.forceRender = null, e.apply = (op) => {
+  return e.isNodeMapDirty = !1, e.domWindow = null, e.domElement = null, e.domPlaceholder = "", e.domPlaceholderElement = null, e.keyToElement = /* @__PURE__ */ new WeakMap(), e.nodeToIndex = /* @__PURE__ */ new WeakMap(), e.nodeToParent = /* @__PURE__ */ new WeakMap(), e.elementToNode = /* @__PURE__ */ new WeakMap(), e.nodeToKey = /* @__PURE__ */ new WeakMap(), e.readOnly = !1, e.focused = !1, e.composing = !1, e.userSelection = null, e.onContextChange = null, e.scheduleFlush = null, e.pendingInsertionMarks = null, e.userMarks = null, e.pendingDiffs = [], e.pendingAction = null, e.pendingSelection = null, e.forceRender = null, e.apply = (op) => {
     const matches = [], pendingDiffs = e.pendingDiffs;
     if (pendingDiffs?.length) {
       const transformed = pendingDiffs.map((textDiff) => transformTextDiff(textDiff, op)).filter(Boolean);
@@ -11212,6 +11487,8 @@ const withDOM = (editor) => {
         e.isNodeMapDirty = !0;
     }
     for (const [path2, key] of matches) {
+      if (path2.length === 0)
+        continue;
       const [node$1] = node(e, path2);
       e.nodeToKey.set(node$1, key);
     }
@@ -11228,7 +11505,7 @@ const withDOM = (editor) => {
     matches.push([p, key]);
   }
   return matches;
-}, withReact = (editor) => {
+}, REACT_MAJOR_VERSION = parseInt(React.version.split(".")[0], 10), withReact = (editor) => {
   let e = editor;
   e = withDOM(e);
   const {
@@ -11253,21 +11530,18 @@ function createSlateEditor(config) {
     undos: [],
     redos: []
   }, editor.lastSelection = null, editor.lastSlateSelection = null, editor.listIndexMap = /* @__PURE__ */ new Map(), editor.remotePatches = [], editor.undoStepId = void 0, editor.children = [placeholderBlock], editor.isDeferringMutations = !1, editor.isNormalizingNode = !1, editor.isPatching = !0, editor.isPerformingBehaviorOperation = !1, editor.isProcessingRemoteChanges = !1, editor.isRedoing = !1, editor.isUndoing = !1, editor.withHistory = !0;
-  const instance = plugins(withReact(editor), {
+  const slateEditor = plugins(withReact(editor), {
     editorActor: config.editorActor,
     relayActor: config.relayActor,
     subscriptions: config.subscriptions
   });
   return buildIndexMaps({
     schema: context.schema,
-    value: instance.children
+    value: slateEditor.children
   }, {
-    blockIndexMap: instance.blockIndexMap,
-    listIndexMap: instance.listIndexMap
-  }), {
-    instance,
-    initialValue: [placeholderBlock]
-  };
+    blockIndexMap: slateEditor.blockIndexMap,
+    listIndexMap: slateEditor.listIndexMap
+  }), slateEditor;
 }
 function createEditorDom(sendBack, slateEditor) {
   return {
@@ -12779,7 +13053,9 @@ const addAnnotationOperationImplementation = ({
     affinity: "inward"
   }) : null, selectedBlocks = nodes(editor, {
     at: effectiveSelection,
-    match: (node2) => editor.isTextBlock(node2),
+    match: (node2) => isTextBlock({
+      schema: editor.schema
+    }, node2),
     reverse: isBackwardRange(effectiveSelection)
   });
   let blockIndex = 0;
@@ -12796,7 +13072,9 @@ const addAnnotationOperationImplementation = ({
     const splitRange = at ?? editor.selection;
     if (splitRange && isRange(splitRange)) {
       const [splitLeaf] = leaf(editor, splitRange.anchor);
-      if (!(isCollapsedRange(splitRange) && isText(splitLeaf, editor.schema) && splitLeaf.text.length > 0)) {
+      if (!(isCollapsedRange(splitRange) && isSpan({
+        schema: editor.schema
+      }, splitLeaf) && splitLeaf.text.length > 0)) {
         const splitRangeRef = rangeRef(editor, splitRange, {
           affinity: "inward"
         }), [splitStart, splitEnd] = rangeEdges(splitRange);
@@ -12814,7 +13092,9 @@ const addAnnotationOperationImplementation = ({
     }
     const children = getChildren(editor, blockPath, editor.schema), selectionRange = ref?.current ?? editor.selection;
     for (const [span, path2] of children) {
-      if (!editor.isTextSpan(span) || !selectionRange || !rangeIncludes(selectionRange, path2))
+      if (!isSpan({
+        schema: editor.schema
+      }, span) || !selectionRange || !rangeIncludes(selectionRange, path2))
         continue;
       const marks = span.marks ?? [];
       applySetNode(editor, {
@@ -12841,12 +13121,16 @@ const addAnnotationOperationImplementation = ({
       const [block, blockPath] = node(editor, effectiveSelection, {
         depth: 1
       });
-      if (!editor.isTextBlock(block))
+      if (!isTextBlock({
+        schema: editor.schema
+      }, block))
         return;
       const potentialAnnotations = (block.markDefs ?? []).filter((markDef) => markDef._type === operation.annotation.name), [selectedChild, selectedChildPath] = node(editor, effectiveSelection, {
         depth: 2
       });
-      if (!editor.isTextSpan(selectedChild))
+      if (!isSpan({
+        schema: editor.schema
+      }, selectedChild))
         return;
       const annotationToRemove = selectedChild.marks?.find((mark) => potentialAnnotations.some((markDef) => markDef._key === mark));
       if (!annotationToRemove)
@@ -12855,14 +13139,18 @@ const addAnnotationOperationImplementation = ({
       for (const [child, childPath] of getChildren(editor, blockPath, editor.schema, {
         reverse: !0
       }))
-        if (editor.isTextSpan(child) && isBeforePath(childPath, selectedChildPath))
+        if (isSpan({
+          schema: editor.schema
+        }, child) && isBeforePath(childPath, selectedChildPath))
           if (child.marks?.includes(annotationToRemove))
             previousSpansWithSameAnnotation.push([child, childPath]);
           else
             break;
       const nextSpansWithSameAnnotation = [];
       for (const [child, childPath] of getChildren(editor, blockPath, editor.schema))
-        if (editor.isTextSpan(child) && isAfterPath(childPath, selectedChildPath))
+        if (isSpan({
+          schema: editor.schema
+        }, child) && isAfterPath(childPath, selectedChildPath))
           if (child.marks?.includes(annotationToRemove))
             nextSpansWithSameAnnotation.push([child, childPath]);
           else
@@ -12877,7 +13165,9 @@ const addAnnotationOperationImplementation = ({
       }) : null, splitRange = at ?? editor.selection;
       if (splitRange && isRange(splitRange)) {
         const [splitLeaf] = leaf(editor, splitRange.anchor);
-        if (!(isCollapsedRange(splitRange) && isText(splitLeaf, editor.schema) && splitLeaf.text.length > 0)) {
+        if (!(isCollapsedRange(splitRange) && isSpan({
+          schema: editor.schema
+        }, splitLeaf) && splitLeaf.text.length > 0)) {
           const splitRangeRef = rangeRef(editor, splitRange, {
             affinity: "inward"
           }), [splitStart, splitEnd] = rangeEdges(splitRange);
@@ -12895,12 +13185,16 @@ const addAnnotationOperationImplementation = ({
       }
       const blocks = nodes(editor, {
         at: effectiveSelection,
-        match: (node2) => editor.isTextBlock(node2)
+        match: (node2) => isTextBlock({
+          schema: editor.schema
+        }, node2)
       }), selectionRange = ref?.current ?? editor.selection;
       for (const [block, blockPath] of blocks) {
         const children = getChildren(editor, blockPath, editor.schema);
         for (const [child, childPath] of children) {
-          if (!editor.isTextSpan(child) || !selectionRange || !rangeIncludes(selectionRange, childPath))
+          if (!isSpan({
+            schema: editor.schema
+          }, child) || !selectionRange || !rangeIncludes(selectionRange, childPath))
             continue;
           const markDefs = block.markDefs ?? [], marks = child.marks ?? [], marksWithoutAnnotation = marks.filter((mark) => markDefs.find((markDef2) => markDef2._key === mark)?._type !== operation.annotation.name);
           marksWithoutAnnotation.length !== marks.length && applySetNode(editor, {
@@ -13016,7 +13310,9 @@ const addAnnotationOperationImplementation = ({
   }), child = childEntry?.[0], childPath = childEntry?.[1];
   if (!child || !childPath)
     throw new Error(`Unable to find child at ${safeStringify(operation.at)}`);
-  if (operation.editor.isTextSpan(child)) {
+  if (isSpan({
+    schema: operation.editor.schema
+  }, child)) {
     const {
       _type,
       text,
@@ -13038,7 +13334,9 @@ const addAnnotationOperationImplementation = ({
     }));
     return;
   }
-  if (operation.editor.isObjectNode(child)) {
+  if (isObjectNode({
+    schema: operation.editor.schema
+  }, child)) {
     const definition = context.schema.inlineObjects.find((definition2) => definition2.name === child._type);
     if (!definition)
       throw new Error(`Unable to find schema definition for Inline Object type ${child._type}`);
@@ -13080,7 +13378,9 @@ const addAnnotationOperationImplementation = ({
   }), child = childEntry?.[0], childPath = childEntry?.[1];
   if (!child || !childPath)
     throw new Error(`Unable to find child at ${safeStringify(operation.at)}`);
-  if (operation.editor.isTextSpan(child)) {
+  if (isSpan({
+    schema: operation.editor.schema
+  }, child)) {
     const newNode = {};
     for (const prop of operation.props)
       if (prop !== "text" && prop !== "_type") {
@@ -13098,7 +13398,9 @@ const addAnnotationOperationImplementation = ({
     });
     return;
   }
-  if (operation.editor.isObjectNode(child)) {
+  if (isObjectNode({
+    schema: operation.editor.schema
+  }, child)) {
     const unsetProps = {};
     for (const prop of operation.props)
       prop !== "_type" && (prop === "_key" ? unsetProps._key = context.keyGenerator() : unsetProps[prop] = null);
@@ -13137,7 +13439,9 @@ const addAnnotationOperationImplementation = ({
       operation.at || applySelect(editor, at);
       const splitTextNodes = nodes(editor, {
         at,
-        match: (n2) => isText(n2, editor.schema)
+        match: (n2) => isSpan({
+          schema: editor.schema
+        }, n2)
       });
       for (const [node2, path2] of splitTextNodes) {
         const marks = [...(Array.isArray(node2.marks) ? node2.marks : []).filter((eMark) => eMark !== mark), mark];
@@ -13148,17 +13452,25 @@ const addAnnotationOperationImplementation = ({
     } else {
       if (!Array.from(nodes(editor, {
         at,
-        match: (node2) => editor.isTextSpan(node2)
+        match: (node2) => isSpan({
+          schema: editor.schema
+        }, node2)
       }))?.at(0))
         return;
       const [block, blockPath] = node(editor, at, {
         depth: 1
-      }), lonelyEmptySpan = editor.isTextBlock(block) && block.children.length === 1 && editor.isTextSpan(block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
+      }), lonelyEmptySpan = isTextBlock({
+        schema: editor.schema
+      }, block) && block.children.length === 1 && isSpan({
+        schema: editor.schema
+      }, block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
       if (lonelyEmptySpan) {
         const existingMarks = lonelyEmptySpan.marks ?? [], existingMarksWithoutDecorator = existingMarks.filter((existingMark) => existingMark !== mark), newMarks = existingMarks.length === existingMarksWithoutDecorator.length ? [...existingMarks, mark] : existingMarksWithoutDecorator;
         for (const [, spanPath] of nodes(editor, {
           at: blockPath,
-          match: (node2) => editor.isTextSpan(node2)
+          match: (node2) => isSpan({
+            schema: editor.schema
+          }, node2)
         }))
           applySetNode(editor, {
             marks: newMarks
@@ -13190,7 +13502,9 @@ const addAnnotationOperationImplementation = ({
       const ref = rangeRef(editor, at, {
         affinity: "inward"
       }), [decoratorLeaf] = leaf(editor, at.anchor);
-      if (!(isCollapsedRange(at) && isText(decoratorLeaf, editor.schema) && decoratorLeaf.text.length > 0)) {
+      if (!(isCollapsedRange(at) && isSpan({
+        schema: editor.schema
+      }, decoratorLeaf) && decoratorLeaf.text.length > 0)) {
         const [start2, end2] = rangeEdges(at);
         if (!isEnd(editor, end2, end2.path) || !isEdge(editor, end2, end2.path)) {
           const [endNode] = node(editor, end2.path);
@@ -13204,10 +13518,14 @@ const addAnnotationOperationImplementation = ({
       const updatedAt = ref.unref();
       updatedAt && [...nodes(editor, {
         at: updatedAt,
-        match: (n2) => isText(n2, editor.schema)
+        match: (n2) => isSpan({
+          schema: editor.schema
+        }, n2)
       })].forEach(([node2, path2]) => {
         const block = editor.children[path2[0]];
-        isElement(block, editor.schema) && block.children.includes(node2) && applySetNode(editor, {
+        isTextBlock({
+          schema: editor.schema
+        }, block) && block.children.includes(node2) && applySetNode(editor, {
           marks: (Array.isArray(node2.marks) ? node2.marks : []).filter((eMark) => eMark !== mark),
           _type: context.schema.span.name
         }, path2);
@@ -13215,12 +13533,18 @@ const addAnnotationOperationImplementation = ({
     } else {
       const [block, blockPath] = node(editor, at, {
         depth: 1
-      }), lonelyEmptySpan = editor.isTextBlock(block) && block.children.length === 1 && editor.isTextSpan(block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
+      }), lonelyEmptySpan = isTextBlock({
+        schema: editor.schema
+      }, block) && block.children.length === 1 && isSpan({
+        schema: editor.schema
+      }, block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
       if (lonelyEmptySpan) {
         const existingMarksWithoutDecorator = (lonelyEmptySpan.marks ?? []).filter((existingMark) => existingMark !== mark);
         for (const [, spanPath] of nodes(editor, {
           at: blockPath,
-          match: (node2) => editor.isTextSpan(node2)
+          match: (node2) => isSpan({
+            schema: editor.schema
+          }, node2)
         }))
           applySetNode(editor, {
             marks: existingMarksWithoutDecorator
@@ -13265,7 +13589,11 @@ const addAnnotationOperationImplementation = ({
       }
     }, blockMatches = nodes(operation.editor, {
       at: removeRange,
-      match: (n2) => isElement(n2, operation.editor.schema) && isBlock(operation.editor, n2) || operation.editor.isObjectNode(n2),
+      match: (n2) => isTextBlock({
+        schema: operation.editor.schema
+      }, n2) || isObjectNode({
+        schema: operation.editor.schema
+      }, n2) && !operation.editor.isInline(n2),
       mode: "highest"
     }), blockPathRefs = Array.from(blockMatches, ([, p]) => pathRef(operation.editor, p));
     for (const pathRef2 of blockPathRefs) {
@@ -13284,8 +13612,12 @@ const addAnnotationOperationImplementation = ({
   if (operation.unit === "child") {
     const childMatches = nodes(operation.editor, {
       at,
-      match: (node2, path2) => isSpan(context, node2) || isElement(node2, operation.editor.schema) && operation.editor.isInline(node2) || // TODO: Update depth check when containers land (path.length > 1 assumes flat structure)
-      operation.editor.isObjectNode(node2) && path2.length > 1
+      match: (node2, path2) => isSpan(context, node2) || isTextBlock({
+        schema: operation.editor.schema
+      }, node2) && operation.editor.isInline(node2) || // TODO: Update depth check when containers land (path.length > 1 assumes flat structure)
+      isObjectNode({
+        schema: operation.editor.schema
+      }, node2) && path2.length > 1
     }), childPathRefs = Array.from(childMatches, ([, p]) => pathRef(operation.editor, p));
     for (const pathRef2 of childPathRefs) {
       const path2 = pathRef2.unref();
@@ -13302,7 +13634,9 @@ const addAnnotationOperationImplementation = ({
   }
   if (operation.direction === "backward" && operation.unit === "line") {
     const parentBlockEntry = above(operation.editor, {
-      match: (n2) => isElement(n2, operation.editor.schema) && isBlock(operation.editor, n2),
+      match: (n2) => isTextBlock({
+        schema: operation.editor.schema
+      }, n2),
       at
     });
     if (parentBlockEntry) {
@@ -13326,7 +13660,9 @@ const addAnnotationOperationImplementation = ({
   if (isCollapsedRange(at) && start$1.path.length >= 2)
     try {
       const node2 = getNode(operation.editor, start$1.path, operation.editor.schema);
-      if (operation.editor.isObjectNode(node2)) {
+      if (isObjectNode({
+        schema: operation.editor.schema
+      }, node2)) {
         operation.editor.apply({
           type: "remove_node",
           path: start$1.path,
@@ -13340,29 +13676,45 @@ const addAnnotationOperationImplementation = ({
     const blockIndex = start$1.path.at(0);
     if (blockIndex !== void 0) {
       const node2 = getNode(operation.editor, [blockIndex], operation.editor.schema);
-      if (operation.editor.isObjectNode(node2))
+      if (isObjectNode({
+        schema: operation.editor.schema
+      }, node2))
         return [node2, [blockIndex]];
     }
   })(), endNodeEntry = (() => {
     const blockIndex = end$1.path.at(0);
     if (blockIndex !== void 0) {
       const node2 = getNode(operation.editor, [blockIndex], operation.editor.schema);
-      if (operation.editor.isObjectNode(node2))
+      if (isObjectNode({
+        schema: operation.editor.schema
+      }, node2))
         return [node2, [blockIndex]];
     }
   })(), startBlock = startNodeEntry ?? above(operation.editor, {
-    match: (n2) => isElement(n2, operation.editor.schema) && isBlock(operation.editor, n2) || operation.editor.isObjectNode(n2),
+    match: (n2) => isTextBlock({
+      schema: operation.editor.schema
+    }, n2) || isObjectNode({
+      schema: operation.editor.schema
+    }, n2) && !operation.editor.isInline(n2),
     at: start$1
   }), endBlock = endNodeEntry ?? above(operation.editor, {
-    match: (n2) => isElement(n2, operation.editor.schema) && isBlock(operation.editor, n2) || operation.editor.isObjectNode(n2),
+    match: (n2) => isTextBlock({
+      schema: operation.editor.schema
+    }, n2) || isObjectNode({
+      schema: operation.editor.schema
+    }, n2) && !operation.editor.isInline(n2),
     at: end$1
-  }), isAcrossBlocks = startBlock && endBlock && !pathEquals(startBlock[1], endBlock[1]), startObjectNode = startBlock && operation.editor.isObjectNode(startBlock[0]) ? startBlock : void 0, endObjectNode = endBlock && operation.editor.isObjectNode(endBlock[0]) ? endBlock : void 0, startNonEditable = startObjectNode ?? getVoid(operation.editor, {
+  }), isAcrossBlocks = startBlock && endBlock && !pathEquals(startBlock[1], endBlock[1]), startObjectNode = startBlock && isObjectNode({
+    schema: operation.editor.schema
+  }, startBlock[0]) ? startBlock : void 0, endObjectNode = endBlock && isObjectNode({
+    schema: operation.editor.schema
+  }, endBlock[0]) ? endBlock : void 0, startNonEditable = startObjectNode ?? getObjectNode(operation.editor, {
     at: start$1,
     mode: "highest"
   }) ?? elementReadOnly(operation.editor, {
     at: start$1,
     mode: "highest"
-  }), endNonEditable = endObjectNode ?? getVoid(operation.editor, {
+  }), endNonEditable = endObjectNode ?? getObjectNode(operation.editor, {
     at: end$1,
     mode: "highest"
   }) ?? elementReadOnly(operation.editor, {
@@ -13372,16 +13724,22 @@ const addAnnotationOperationImplementation = ({
   let lastPath;
   for (const entry of nodes(operation.editor, {
     at,
-    voids: !1
+    includeObjectNodes: !1
   })) {
     const [node2, path2] = entry;
-    lastPath && comparePaths(path2, lastPath) === 0 || (operation.editor.isObjectNode(node2) || isElement(node2, operation.editor.schema) && operation.editor.isElementReadOnly(node2) || !isCommonPath(path2, start$1.path) && !isCommonPath(path2, end$1.path)) && (matches.push(entry), lastPath = path2);
+    lastPath && comparePaths(path2, lastPath) === 0 || (isObjectNode({
+      schema: operation.editor.schema
+    }, node2) || isTextBlock({
+      schema: operation.editor.schema
+    }, node2) && operation.editor.isElementReadOnly(node2) || !isCommonPath(path2, start$1.path) && !isCommonPath(path2, end$1.path)) && (matches.push(entry), lastPath = path2);
   }
   const pathRefs = Array.from(matches, ([, path2]) => pathRef(operation.editor, path2)), startRef = pointRef(operation.editor, start$1), endRef = pointRef(operation.editor, end$1);
   if (startBlock && endBlock && pointEquals(start$1, start(operation.editor, startBlock[1])) && pointEquals(end$1, end(operation.editor, endBlock[1])) && isAcrossBlocks) {
     if (!startNonEditable) {
       const point2 = startRef.current, node2 = getNode(operation.editor, point2.path, operation.editor.schema);
-      isText(node2, operation.editor.schema) && node2.text.length > 0 && operation.editor.apply({
+      isSpan({
+        schema: operation.editor.schema
+      }, node2) && node2.text.length > 0 && operation.editor.apply({
         type: "remove_text",
         path: point2.path,
         offset: 0,
@@ -13401,7 +13759,9 @@ const addAnnotationOperationImplementation = ({
     }
     if (!endNonEditable) {
       const point2 = endRef.current, node2 = getNode(operation.editor, point2.path, operation.editor.schema);
-      if (isText(node2, operation.editor.schema)) {
+      if (isSpan({
+        schema: operation.editor.schema
+      }, node2)) {
         const {
           path: path2
         } = point2, offset = 0, text = node2.text.slice(offset, end$1.offset);
@@ -13416,7 +13776,11 @@ const addAnnotationOperationImplementation = ({
     if (endRef.current && startRef.current) {
       const endBlockMatches = nodes(operation.editor, {
         at: endRef.current,
-        match: (n2) => isElement(n2, operation.editor.schema) && isBlock(operation.editor, n2) || operation.editor.isObjectNode(n2)
+        match: (n2) => isTextBlock({
+          schema: operation.editor.schema
+        }, n2) || isObjectNode({
+          schema: operation.editor.schema
+        }, n2) && !operation.editor.isInline(n2)
       }), endBlockPathRefs = Array.from(endBlockMatches, ([, p]) => pathRef(operation.editor, p));
       for (const pathRef2 of endBlockPathRefs) {
         const endPath = pathRef2.unref();
@@ -13440,7 +13804,9 @@ const addAnnotationOperationImplementation = ({
     });
     return;
   }
-  if (startNonEditable && startBlock && endBlock && pathEquals(startBlock[1], endBlock[1]) && operation.editor.isObjectNode(startBlock[0])) {
+  if (startNonEditable && startBlock && endBlock && pathEquals(startBlock[1], endBlock[1]) && isObjectNode({
+    schema: operation.editor.schema
+  }, startBlock[0])) {
     const path2 = startBlock[1];
     operation.editor.apply({
       type: "remove_node",
@@ -13454,7 +13820,9 @@ const addAnnotationOperationImplementation = ({
     const currentPath = pathRef2.current;
     if (currentPath) {
       const [nodeAtPath] = node(operation.editor, currentPath);
-      if (operation.editor.isObjectNode(nodeAtPath)) {
+      if (isObjectNode({
+        schema: operation.editor.schema
+      }, nodeAtPath)) {
         const path2 = pathRef2.unref();
         path2 && (endObjectNode && pathEquals(path2, endObjectNode[1]) && (removedEndObjectNode = !0), operation.editor.apply({
           type: "remove_node",
@@ -13733,7 +14101,16 @@ const historyUndoOperationImplementation = ({
       editor.history.redos.push(step), editor.history.undos.pop();
     }
   }
-}, insertBlockOperationImplementation = ({
+};
+function getSpanNode(root, path2, schema) {
+  const node2 = getNode(root, path2, schema);
+  if (isSpan({
+    schema
+  }, node2))
+    return node2;
+  throw new Error(`Cannot get the span at path [${path2}] because it refers to a non-span node: ${safeStringify(node2)}`);
+}
+const insertBlockOperationImplementation = ({
   context,
   operation
 }) => {
@@ -13782,12 +14159,20 @@ function insertBlock(options) {
   const start$1 = at ? rangeStart(at) : start(editor, []), end$1 = at ? rangeEnd(at) : end(editor, []), [startBlock, startBlockPath] = Array.from(nodes(editor, {
     at: start$1,
     mode: "lowest",
-    match: (node2, path2) => (isElement(node2, editor.schema) || editor.isObjectNode(node2)) && path2.length <= start$1.path.length
+    match: (node2, path2) => (isTextBlock({
+      schema: editor.schema
+    }, node2) || isObjectNode({
+      schema: editor.schema
+    }, node2)) && path2.length <= start$1.path.length
   })).at(0) ?? [void 0, void 0];
   let [endBlock, endBlockPath] = Array.from(nodes(editor, {
     at: end$1,
     mode: "lowest",
-    match: (node2, path2) => (isElement(node2, editor.schema) || editor.isObjectNode(node2)) && path2.length <= end$1.path.length
+    match: (node2, path2) => (isTextBlock({
+      schema: editor.schema
+    }, node2) || isObjectNode({
+      schema: editor.schema
+    }, node2)) && path2.length <= end$1.path.length
   })).at(0) ?? [void 0, void 0];
   if (!startBlock || !startBlockPath || !endBlock || !endBlockPath)
     throw new Error("Unable to insert block without a start and end block");
@@ -13804,19 +14189,27 @@ function insertBlock(options) {
       replaceEmptyTextBlock(editor, endBlockPath, block, select2);
       return;
     }
-    if (editor.isTextBlock(block) && editor.isTextBlock(endBlock)) {
+    if (isTextBlock({
+      schema: editor.schema
+    }, block) && isTextBlock({
+      schema: editor.schema
+    }, endBlock)) {
       const selectionBefore = end(editor, endBlockPath);
-      insertTextBlockFragment(editor, block, selectionBefore), select2 === "start" ? setSelectionToPoint(editor, selectionBefore) : select2 === "none" && clearSelection(editor);
+      insertTextBlockFragment(context, editor, block, selectionBefore), select2 === "start" ? setSelectionToPoint(editor, selectionBefore) : select2 === "none" && clearSelection(editor);
       return;
     }
     insertNodeAt(editor, nextPath(endBlockPath), block, select2);
     return;
   }
-  if (isExpandedRange(at) && !editor.isTextBlock(block)) {
+  if (isExpandedRange(at) && !isTextBlock({
+    schema: editor.schema
+  }, block)) {
     const atBeforeDelete = rangeRef(editor, at, {
       affinity: "inward"
-    }), start2 = rangeStart(at), startBlock2 = getNode(editor, [start2.path[0]], editor.schema), startOfBlock = start(editor, [start2.path[0]]), isAtStartOfBlock = isElement(startBlock2, editor.schema) && pointEquals(start2, startOfBlock);
-    deleteExpandedRange(editor, at);
+    }), start2 = rangeStart(at), startBlock2 = getNode(editor, [start2.path[0]], editor.schema), startOfBlock = start(editor, [start2.path[0]]), isAtStartOfBlock = isTextBlock({
+      schema: editor.schema
+    }, startBlock2) && pointEquals(start2, startOfBlock);
+    deleteExpandedRange(context, editor, at);
     const atAfterDelete = atBeforeDelete.unref() ?? editor.selection, atBeforeInsert = atAfterDelete ? rangeRef(editor, atAfterDelete, {
       affinity: "inward"
     }) : void 0;
@@ -13843,11 +14236,15 @@ function insertBlock(options) {
       type: "set_selection",
       properties: editor.selection,
       newProperties: atAfterInsert
-    }), !editor.isTextBlock(block) && atAfterDelete) {
+    }), !isTextBlock({
+      schema: editor.schema
+    }, block) && atAfterDelete) {
       const emptyBlockPath = isAtStartOfBlock ? [atAfterDelete.anchor.path[0] + 1] : [atAfterDelete.anchor.path[0]];
       try {
         const potentiallyEmptyBlock = getNode(editor, emptyBlockPath, editor.schema);
-        isElement(potentiallyEmptyBlock, editor.schema) && isEmptyTextBlock(context, potentiallyEmptyBlock) && editor.apply({
+        isTextBlock({
+          schema: editor.schema
+        }, potentiallyEmptyBlock) && isEmptyTextBlock(context, potentiallyEmptyBlock) && editor.apply({
           type: "remove_node",
           path: emptyBlockPath,
           node: potentiallyEmptyBlock
@@ -13857,12 +14254,16 @@ function insertBlock(options) {
     }
     return;
   }
-  if (!editor.isTextBlock(block) && editor.isTextBlock(endBlock) && !isExpandedRange(at)) {
+  if (!isTextBlock({
+    schema: editor.schema
+  }, block) && isTextBlock({
+    schema: editor.schema
+  }, endBlock) && !isExpandedRange(at)) {
     const selectionPoint = rangeStart(at), blockPath = [selectionPoint.path[0]], blockStartPoint = start(editor, blockPath), blockEndPoint = end(editor, blockPath), isAtBlockStart = pointEquals(selectionPoint, blockStartPoint), isAtBlockEnd = pointEquals(selectionPoint, blockEndPoint);
     if (!isAtBlockStart && !isAtBlockEnd) {
-      const currentBlock = getNode(editor, blockPath, editor.schema), childIndex = selectionPoint.path[1], childOffset = selectionPoint.offset;
+      const currentBlock = getTextBlockNode(editor, blockPath, editor.schema), childIndex = selectionPoint.path[1], childOffset = selectionPoint.offset;
       if (childOffset > 0) {
-        const textNode = getNode(editor, selectionPoint.path, editor.schema);
+        const textNode = getSpanNode(editor, selectionPoint.path, editor.schema);
         if (childOffset < textNode.text.length) {
           const {
             text: _2,
@@ -13915,14 +14316,20 @@ function insertBlock(options) {
       return;
     }
   }
-  if (editor.isTextBlock(endBlock) && editor.isTextBlock(block)) {
+  if (isTextBlock({
+    schema: editor.schema
+  }, endBlock) && isTextBlock({
+    schema: editor.schema
+  }, block)) {
     let selectionStartPoint = rangeStart(at), wasCrossBlockDeletion = !1;
     if (isExpandedRange(at)) {
       const [start2, end2] = rangeEdges(at), isCrossBlock = start2.path[0] !== end2.path[0];
-      if (deleteExpandedRange(editor, at), isCrossBlock) {
+      if (deleteExpandedRange(context, editor, at), isCrossBlock) {
         wasCrossBlockDeletion = !0;
         const startBlockPath2 = [start2.path[0]], mergedBlock = getNode(editor, startBlockPath2, editor.schema);
-        if (editor.isTextBlock(mergedBlock)) {
+        if (isTextBlock({
+          schema: editor.schema
+        }, mergedBlock)) {
           const mergePoint = {
             path: [...startBlockPath2, start2.path[1]],
             offset: start2.offset
@@ -13933,11 +14340,21 @@ function insertBlock(options) {
       const [newEndBlock, newEndBlockPath] = Array.from(nodes(editor, {
         at: end(editor, []),
         mode: "lowest",
-        match: (node2, path2) => (isElement(node2, editor.schema) || editor.isObjectNode(node2)) && path2.length === 1
+        match: (node2, path2) => (isTextBlock({
+          schema: editor.schema
+        }, node2) || isObjectNode({
+          schema: editor.schema
+        }, node2)) && path2.length === 1
       })).at(-1) ?? [void 0, void 0];
-      newEndBlock && newEndBlockPath && (isElement(newEndBlock, editor.schema) || editor.isObjectNode(newEndBlock)) && (endBlock = newEndBlock, endBlockPath = newEndBlockPath);
-    }
-    if (!editor.isTextBlock(endBlock))
+      newEndBlock && newEndBlockPath && (isTextBlock({
+        schema: editor.schema
+      }, newEndBlock) || isObjectNode({
+        schema: editor.schema
+      }, newEndBlock)) && (endBlock = newEndBlock, endBlockPath = newEndBlockPath);
+    }
+    if (!isTextBlock({
+      schema: editor.schema
+    }, endBlock))
       return;
     if (isEmptyTextBlock(context, endBlock)) {
       replaceEmptyTextBlock(editor, endBlockPath, block, select2);
@@ -13967,7 +14384,9 @@ function insertBlock(options) {
         _key: context.keyGenerator()
       } : child;
     }), endBlockNode = getNode(editor, endBlockPath, editor.schema);
-    if (isElement(endBlockNode, editor.schema) && editor.isTextBlock(endBlockNode)) {
+    if (isTextBlock({
+      schema: editor.schema
+    }, endBlockNode)) {
       const properties = {
         markDefs: endBlockNode.markDefs
       }, newProperties = {
@@ -13986,10 +14405,10 @@ function insertBlock(options) {
     };
     if (select2 === "end") {
       const insertAt = editor.selection ? rangeEnd(editor.selection) : end(editor, endBlockPath);
-      insertTextBlockFragment(editor, adjustedBlock, insertAt);
+      insertTextBlockFragment(context, editor, adjustedBlock, insertAt);
       return;
     }
-    if (insertTextBlockFragment(editor, adjustedBlock, selectionStartPoint), select2 === "start")
+    if (insertTextBlockFragment(context, editor, adjustedBlock, selectionStartPoint), select2 === "start")
       setSelectionToPoint(editor, selectionStartPoint);
     else if (select2 === "none")
       if (wasCrossBlockDeletion)
@@ -13999,7 +14418,9 @@ function insertBlock(options) {
         pointEquals(selectionStartPoint, endBlockStartPoint) || setSelectionToPoint(editor, selectionStartPoint);
       }
   } else {
-    if (!editor.isTextBlock(endBlock)) {
+    if (!isTextBlock({
+      schema: editor.schema
+    }, endBlock)) {
       insertNodeAt(editor, [endBlockPath[0] + 1], block, select2);
       return;
     }
@@ -14030,7 +14451,7 @@ function insertBlock(options) {
       return;
     }
     if (isExpandedRange(at) && pointEquals(selectionStartPoint, endBlockStartPoint)) {
-      const [, end2] = rangeEdges(at), endNode = getNode(editor, end2.path, editor.schema);
+      const [, end2] = rangeEdges(at), endNode = getSpanNode(editor, end2.path, editor.schema);
       end2.offset > 0 && editor.apply({
         type: "remove_text",
         path: end2.path,
@@ -14039,43 +14460,47 @@ function insertBlock(options) {
       });
       for (let i = end2.path[1] - 1; i >= 0; i--)
         removeNodeAt(editor, [...endBlockPath, i]);
-      insertTextBlockFragment(editor, block, start(editor, endBlockPath)), select2 !== "none" && setSelection(editor, endBlockPath, select2);
+      insertTextBlockFragment(context, editor, block, start(editor, endBlockPath)), select2 !== "none" && setSelection(editor, endBlockPath, select2);
       return;
     }
     if (isExpandedRange(at) && pointEquals(selectionEndPoint, endBlockEndPoint)) {
-      const [start2] = rangeEdges(at), blockNode = getNode(editor, endBlockPath, editor.schema);
+      const [start2] = rangeEdges(at), blockNode = getTextBlockNode(editor, endBlockPath, editor.schema);
       for (let i = blockNode.children.length - 1; i > start2.path[1]; i--)
         removeNodeAt(editor, [...endBlockPath, i]);
-      const startNode = getNode(editor, start2.path, editor.schema);
+      const startNode = getSpanNode(editor, start2.path, editor.schema);
       start2.offset < startNode.text.length && editor.apply({
         type: "remove_text",
         path: start2.path,
         offset: start2.offset,
         text: startNode.text.slice(start2.offset)
-      }), insertTextBlockFragment(editor, block, start2), select2 !== "none" && setSelection(editor, nextPath(endBlockPath), select2);
+      }), insertTextBlockFragment(context, editor, block, start2), select2 !== "none" && setSelection(editor, nextPath(endBlockPath), select2);
       return;
     }
     const [focusChild] = getFocusChild({
       editor
     });
-    if (focusChild && editor.isTextSpan(focusChild)) {
+    if (focusChild && isSpan({
+      schema: editor.schema
+    }, focusChild)) {
       const startPoint = rangeStart(at);
-      if (editor.isTextBlock(block)) {
+      if (isTextBlock({
+        schema: editor.schema
+      }, block)) {
         const nodeToSplit = getNode(editor, startPoint.path, editor.schema);
-        if (isText(nodeToSplit, editor.schema)) {
+        if (isSpan(context, nodeToSplit)) {
           const {
             text: _,
             ...properties
           } = nodeToSplit;
           applySplitNode(editor, startPoint.path, startPoint.offset, properties);
         }
-        insertTextBlockFragment(editor, block, startPoint), select2 === "none" ? setSelectionToRange(editor, at) : setSelection(editor, [endBlockPath[0] + 1], "start");
+        insertTextBlockFragment(context, editor, block, startPoint), select2 === "none" ? setSelectionToRange(editor, at) : setSelection(editor, [endBlockPath[0] + 1], "start");
       } else {
         let currentPath = startPoint.path, currentOffset = startPoint.offset;
         const cursorPositionRef = pointRef(editor, startPoint, {
           affinity: "backward"
         }), blockPath = [currentPath[0]], firstBlockPathRef = pathRef(editor, blockPath), textNode = getNode(editor, currentPath, editor.schema);
-        if (isText(textNode, editor.schema) && currentOffset > 0 && currentOffset < textNode.text.length) {
+        if (isSpan(context, textNode) && currentOffset > 0 && currentOffset < textNode.text.length) {
           const {
             text: _,
             ...properties
@@ -14083,7 +14508,9 @@ function insertBlock(options) {
           applySplitNode(editor, currentPath, currentOffset, properties), currentPath = nextPath(currentPath), currentOffset = 0;
         }
         const splitAtIndex = currentOffset > 0 ? currentPath[1] + 1 : currentPath[1], blockToSplit = getNode(editor, blockPath, editor.schema);
-        if (splitAtIndex < blockToSplit.children.length && isElement(blockToSplit, editor.schema)) {
+        if (isTextBlock({
+          schema: editor.schema
+        }, blockToSplit) && splitAtIndex < blockToSplit.children.length) {
           const {
             children: _,
             ...blockProperties
@@ -14195,10 +14622,10 @@ function replaceEmptyTextBlock(editor, blockPath, newBlock, select2) {
     }
   });
 }
-function deleteSameBlockRange(editor, start2, end2) {
+function deleteSameBlockRange(context, editor, start2, end2) {
   const blockPath = [start2.path[0]];
   if (pathEquals(start2.path, end2.path)) {
-    const textToRemove = getNode(editor, start2.path, editor.schema).text.slice(start2.offset, end2.offset);
+    const textToRemove = getSpanNode(editor, start2.path, editor.schema).text.slice(start2.offset, end2.offset);
     editor.apply({
       type: "remove_text",
       path: start2.path,
@@ -14207,7 +14634,7 @@ function deleteSameBlockRange(editor, start2, end2) {
     });
     return;
   }
-  const startNode = getNode(editor, start2.path, editor.schema);
+  const startNode = getSpanNode(editor, start2.path, editor.schema);
   if (start2.offset < startNode.text.length) {
     const textToRemove = startNode.text.slice(start2.offset);
     editor.apply({
@@ -14219,7 +14646,7 @@ function deleteSameBlockRange(editor, start2, end2) {
   }
   for (let i = end2.path[1] - 1; i > start2.path[1]; i--)
     removeNodeAt(editor, [...blockPath, i]);
-  const newEndPath = [...blockPath, start2.path[1] + 1], endNode = getNode(editor, newEndPath, editor.schema);
+  const newEndPath = [...blockPath, start2.path[1] + 1], endNode = getSpanNode(editor, newEndPath, editor.schema);
   if (end2.offset > 0) {
     const textToRemove = endNode.text.slice(0, end2.offset);
     editor.apply({
@@ -14230,12 +14657,12 @@ function deleteSameBlockRange(editor, start2, end2) {
     });
   }
   const startNodeAfter = getNode(editor, start2.path, editor.schema), endNodeAfter = getNode(editor, newEndPath, editor.schema);
-  isText(startNodeAfter, editor.schema) && isText(endNodeAfter, editor.schema) && applyMergeNode(editor, newEndPath, startNodeAfter.text.length);
+  isSpan(context, startNodeAfter) && isSpan(context, endNodeAfter) && applyMergeNode(editor, newEndPath, startNodeAfter.text.length);
 }
 function deleteCrossBlockRange(editor, start2, end2) {
   const startBlockPath = [start2.path[0]];
   if (start2.path.length > 1) {
-    const startNode = getNode(editor, start2.path, editor.schema);
+    const startNode = getSpanNode(editor, start2.path, editor.schema);
     if (start2.offset < startNode.text.length) {
       const textToRemove = startNode.text.slice(start2.offset);
       editor.apply({
@@ -14245,7 +14672,7 @@ function deleteCrossBlockRange(editor, start2, end2) {
         text: textToRemove
       });
     }
-    const startBlock2 = getNode(editor, startBlockPath, editor.schema);
+    const startBlock2 = getTextBlockNode(editor, startBlockPath, editor.schema);
     for (let i = startBlock2.children.length - 1; i > start2.path[1]; i--)
       removeNodeAt(editor, [...startBlockPath, i]);
   }
@@ -14255,7 +14682,7 @@ function deleteCrossBlockRange(editor, start2, end2) {
   if (end2.path.length > 1) {
     for (let i = 0; i < end2.path[1]; i++)
       removeNodeAt(editor, [...adjustedEndBlockPath, 0]);
-    const endNodePath = [...adjustedEndBlockPath, 0], endNode = getNode(editor, endNodePath, editor.schema);
+    const endNodePath = [...adjustedEndBlockPath, 0], endNode = getSpanNode(editor, endNodePath, editor.schema);
     if (end2.offset > 0) {
       const textToRemove = endNode.text.slice(0, end2.offset);
       editor.apply({
@@ -14267,7 +14694,11 @@ function deleteCrossBlockRange(editor, start2, end2) {
     }
   }
   const startBlock = getNode(editor, startBlockPath, editor.schema), endBlock = getNode(editor, adjustedEndBlockPath, editor.schema);
-  editor.isTextBlock(startBlock) && editor.isTextBlock(endBlock) && withoutNormalizing(editor, () => {
+  isTextBlock({
+    schema: editor.schema
+  }, startBlock) && isTextBlock({
+    schema: editor.schema
+  }, endBlock) && withoutNormalizing(editor, () => {
     if (Array.isArray(endBlock.markDefs) && endBlock.markDefs.length > 0) {
       const oldDefs = Array.isArray(startBlock.markDefs) && startBlock.markDefs || [], newMarkDefs = [...new Map([...oldDefs, ...endBlock.markDefs].map((def) => [def._key, def])).values()];
       applySetNode(editor, {
@@ -14277,16 +14708,18 @@ function deleteCrossBlockRange(editor, start2, end2) {
     applyMergeNode(editor, adjustedEndBlockPath, startBlock.children.length);
   });
 }
-function deleteExpandedRange(editor, range2) {
+function deleteExpandedRange(context, editor, range2) {
   const [start2, end2] = rangeEdges(range2);
-  start2.path[0] === end2.path[0] ? deleteSameBlockRange(editor, start2, end2) : deleteCrossBlockRange(editor, start2, end2);
+  start2.path[0] === end2.path[0] ? deleteSameBlockRange(context, editor, start2, end2) : deleteCrossBlockRange(editor, start2, end2);
 }
-function insertTextBlockFragment(editor, block, at) {
-  if (!isElement(block, editor.schema) || !editor.isTextBlock(block))
+function insertTextBlockFragment(context, editor, block, at) {
+  if (!isTextBlock({
+    schema: editor.schema
+  }, block))
     return;
   if (at.offset > 0) {
     const textNode = getNode(editor, at.path, editor.schema);
-    if (isText(textNode, editor.schema)) {
+    if (isSpan(context, textNode)) {
       const {
         text: _,
         ...properties
@@ -14375,11 +14808,15 @@ const insertChildOperationImplementation = ({
     offset
   } = selection.anchor;
   const node2 = getNode(editor, path2, editor.schema);
-  if (editor.isObjectNode(node2)) {
+  if (isObjectNode({
+    schema: editor.schema
+  }, node2)) {
     const next2 = nextPath(path2);
     if (hasPath(editor, next2)) {
       const nextNode = getNode(editor, next2, editor.schema);
-      if (isText(nextNode, editor.schema))
+      if (isSpan({
+        schema: editor.schema
+      }, nextNode))
         path2 = next2, offset = 0, applySelect(editor, {
           path: path2,
           offset
@@ -14388,7 +14825,7 @@ const insertChildOperationImplementation = ({
         return;
     } else
       return;
-  } else if (getVoid(editor, {
+  } else if (getObjectNode(editor, {
     at: selection
   }) || elementReadOnly(editor, {
     at: selection
@@ -18277,7 +18714,11 @@ function updateBlock({
     path: [index],
     properties: removedProperties,
     newProperties: {}
-  }), slateEditor.isTextBlock(slateBlock) && slateEditor.isTextBlock(oldSlateBlock)) {
+  }), isTextBlock({
+    schema: slateEditor.schema
+  }, slateBlock) && isTextBlock({
+    schema: slateEditor.schema
+  }, oldSlateBlock)) {
     const oldBlockChildrenLength = oldSlateBlock.children.length;
     slateBlock.children.length < oldBlockChildrenLength && Array.from(Array(oldBlockChildrenLength - slateBlock.children.length)).forEach((_, i) => {
       const childIndex = oldBlockChildrenLength - 1 - i;
@@ -18291,7 +18732,9 @@ function updateBlock({
         });
       }
     }), slateBlock.children.forEach((currentBlockChild, currentBlockChildIndex) => {
-      const oldBlockChild = oldSlateBlock.children.at(currentBlockChildIndex), isChildChanged = !oldBlockChild || !isEqualChild(currentBlockChild, oldBlockChild, slateEditor.schema.span.name), isTextChanged = oldBlockChild && isText(oldBlockChild, slateEditor.schema) && currentBlockChild.text !== oldBlockChild.text, path2 = [index, currentBlockChildIndex];
+      const oldBlockChild = oldSlateBlock.children.at(currentBlockChildIndex), isChildChanged = !oldBlockChild || !isEqualChild(currentBlockChild, oldBlockChild, slateEditor.schema.span.name), isTextChanged = oldBlockChild && isSpan({
+        schema: slateEditor.schema
+      }, oldBlockChild) && currentBlockChild.text !== oldBlockChild.text, path2 = [index, currentBlockChildIndex];
       if (isChildChanged)
         if (currentBlockChild._key === oldBlockChild?._key && currentBlockChild._type === oldBlockChild?._type) {
           debug$1.syncValue("Updating changed child", currentBlockChild, oldBlockChild), applySetNode(slateEditor, currentBlockChild, path2);
@@ -18345,19 +18788,19 @@ function createInternalEditor(config) {
     editorActor,
     relayActor,
     subscriptions
-  }), editable = createEditableAPI(slateEditor.instance, editorActor), {
+  }), editable = createEditableAPI(slateEditor, editorActor), {
     mutationActor,
     syncActor
   } = createActors({
     editorActor,
     relayActor,
-    slateEditor: slateEditor.instance,
+    slateEditor,
     subscriptions
   }), editor = {
-    dom: createEditorDom((event) => editorActor.send(event), slateEditor.instance),
+    dom: createEditorDom((event) => editorActor.send(event), slateEditor),
     getSnapshot: () => getEditorSnapshot({
       editorActorSnapshot: editorActor.getSnapshot(),
-      slateEditorInstance: slateEditor.instance
+      slateEditorInstance: slateEditor
     }),
     registerBehavior: (behaviorConfig) => {
       const priority = createEditorPriority({
@@ -18392,7 +18835,7 @@ function createInternalEditor(config) {
         default:
           editorActor.send(rerouteExternalBehaviorEvent({
             event,
-            slateEditor: slateEditor.instance
+            slateEditor
           }));
       }
     },
@@ -18928,7 +19371,7 @@ class PortableTextEditor {
   static isSelectionsOverlapping = (editor, selectionA, selectionB) => editor.editable?.isSelectionsOverlapping(selectionA, selectionB);
 }
 function EditorProvider(props) {
-  const $ = c(27);
+  const $ = c(26);
   let t0;
   $[0] !== props.initialConfig ? (t0 = () => {
     const internalEditor = createInternalEditor(props.initialConfig), portableTextEditor = new PortableTextEditor({
@@ -18944,31 +19387,31 @@ function EditorProvider(props) {
     portableTextEditor: portableTextEditor_0
   } = t1;
   let t2;
-  $[2] !== internalEditor_0.actors.editorActor || $[3] !== internalEditor_0.actors.mutationActor || $[4] !== internalEditor_0.actors.relayActor || $[5] !== internalEditor_0.actors.syncActor || $[6] !== internalEditor_0.editor._internal.slateEditor.instance || $[7] !== internalEditor_0.subscriptions ? (t2 = () => {
+  $[2] !== internalEditor_0.actors.editorActor || $[3] !== internalEditor_0.actors.mutationActor || $[4] !== internalEditor_0.actors.relayActor || $[5] !== internalEditor_0.actors.syncActor || $[6] !== internalEditor_0.editor._internal.slateEditor || $[7] !== internalEditor_0.subscriptions ? (t2 = () => {
     const unsubscribers = [];
     for (const subscription of internalEditor_0.subscriptions)
       unsubscribers.push(subscription());
     return internalEditor_0.actors.editorActor.start(), internalEditor_0.actors.editorActor.send({
       type: "add slate editor",
-      editor: internalEditor_0.editor._internal.slateEditor.instance
+      editor: internalEditor_0.editor._internal.slateEditor
     }), internalEditor_0.actors.mutationActor.start(), internalEditor_0.actors.relayActor.start(), internalEditor_0.actors.syncActor.start(), () => {
       for (const unsubscribe of unsubscribers)
         unsubscribe();
       stopActor(internalEditor_0.actors.editorActor), stopActor(internalEditor_0.actors.mutationActor), stopActor(internalEditor_0.actors.relayActor), stopActor(internalEditor_0.actors.syncActor);
     };
-  }, $[2] = internalEditor_0.actors.editorActor, $[3] = internalEditor_0.actors.mutationActor, $[4] = internalEditor_0.actors.relayActor, $[5] = internalEditor_0.actors.syncActor, $[6] = internalEditor_0.editor._internal.slateEditor.instance, $[7] = internalEditor_0.subscriptions, $[8] = t2) : t2 = $[8];
+  }, $[2] = internalEditor_0.actors.editorActor, $[3] = internalEditor_0.actors.mutationActor, $[4] = internalEditor_0.actors.relayActor, $[5] = internalEditor_0.actors.syncActor, $[6] = internalEditor_0.editor._internal.slateEditor, $[7] = internalEditor_0.subscriptions, $[8] = t2) : t2 = $[8];
   let t3;
   $[9] !== internalEditor_0 ? (t3 = [internalEditor_0], $[9] = internalEditor_0, $[10] = t3) : t3 = $[10], useEffect(t2, t3);
   let t4;
   $[11] !== portableTextEditor_0 || $[12] !== props.children ? (t4 = /* @__PURE__ */ jsx(PortableTextEditorContext.Provider, { value: portableTextEditor_0, children: props.children }), $[11] = portableTextEditor_0, $[12] = props.children, $[13] = t4) : t4 = $[13];
   let t5;
-  $[14] !== internalEditor_0.editor._internal.slateEditor.initialValue || $[15] !== internalEditor_0.editor._internal.slateEditor.instance || $[16] !== t4 ? (t5 = /* @__PURE__ */ jsx(Slate, { editor: internalEditor_0.editor._internal.slateEditor.instance, initialValue: internalEditor_0.editor._internal.slateEditor.initialValue, children: t4 }), $[14] = internalEditor_0.editor._internal.slateEditor.initialValue, $[15] = internalEditor_0.editor._internal.slateEditor.instance, $[16] = t4, $[17] = t5) : t5 = $[17];
+  $[14] !== internalEditor_0.editor._internal.slateEditor || $[15] !== t4 ? (t5 = /* @__PURE__ */ jsx(Slate, { editor: internalEditor_0.editor._internal.slateEditor, children: t4 }), $[14] = internalEditor_0.editor._internal.slateEditor, $[15] = t4, $[16] = t5) : t5 = $[16];
   let t6;
-  $[18] !== internalEditor_0.actors.relayActor || $[19] !== t5 ? (t6 = /* @__PURE__ */ jsx(RelayActorContext.Provider, { value: internalEditor_0.actors.relayActor, children: t5 }), $[18] = internalEditor_0.actors.relayActor, $[19] = t5, $[20] = t6) : t6 = $[20];
+  $[17] !== internalEditor_0.actors.relayActor || $[18] !== t5 ? (t6 = /* @__PURE__ */ jsx(RelayActorContext.Provider, { value: internalEditor_0.actors.relayActor, children: t5 }), $[17] = internalEditor_0.actors.relayActor, $[18] = t5, $[19] = t6) : t6 = $[19];
   let t7;
-  $[21] !== internalEditor_0.actors.editorActor || $[22] !== t6 ? (t7 = /* @__PURE__ */ jsx(EditorActorContext.Provider, { value: internalEditor_0.actors.editorActor, children: t6 }), $[21] = internalEditor_0.actors.editorActor, $[22] = t6, $[23] = t7) : t7 = $[23];
+  $[20] !== internalEditor_0.actors.editorActor || $[21] !== t6 ? (t7 = /* @__PURE__ */ jsx(EditorActorContext.Provider, { value: internalEditor_0.actors.editorActor, children: t6 }), $[20] = internalEditor_0.actors.editorActor, $[21] = t6, $[22] = t7) : t7 = $[22];
   let t8;
-  return $[24] !== internalEditor_0.editor || $[25] !== t7 ? (t8 = /* @__PURE__ */ jsx(EditorContext$1.Provider, { value: internalEditor_0.editor, children: t7 }), $[24] = internalEditor_0.editor, $[25] = t7, $[26] = t8) : t8 = $[26], t8;
+  return $[23] !== internalEditor_0.editor || $[24] !== t7 ? (t8 = /* @__PURE__ */ jsx(EditorContext$1.Provider, { value: internalEditor_0.editor, children: t7 }), $[23] = internalEditor_0.editor, $[24] = t7, $[25] = t8) : t8 = $[25], t8;
 }
 const usePortableTextEditorSelection = () => {
   const $ = c(5), editorActor = useContext(EditorActorContext);