@portabletext/editor 7.0.2 → 7.0.3

package/lib/index.js

@@ -1,18 +1,18 @@
 import { jsx, jsxs, Fragment } from "react/jsx-runtime";
 import { c } from "react/compiler-runtime";
 import { useSelector, useActorRef } from "@xstate/react";
-import React, { useRef, useEffect, useLayoutEffect, useState, createContext, useContext, useReducer, useCallback, memo, forwardRef, useMemo, Component, useSyncExternalStore, startTransition } from "react";
-import { isSpan, isTextBlock, compileSchema } from "@portabletext/schema";
-import { defineSchema } from "@portabletext/schema";
-import { isKeyedSegment, getNode, getChildren, getAncestor, isObjectNode, getAncestors, getNodeChildren } from "./_chunks-es/get-ancestor.js";
+import React, { createContext, useContext, useRef, useEffect, useLayoutEffect, useState, useReducer, useCallback, memo, forwardRef, useMemo, Component, useSyncExternalStore, startTransition } from "react";
+import { isKeyedSegment, getAncestor, isObjectNode, getNode, getChildren, getAncestors, getNodeChildren } from "./_chunks-es/get-node.js";
+import { isTextBlockNode, hasNode, getNodes, isAncestorPath, getSibling, isInline, parentPath, isSpanNode, isBlock, getEnclosingBlock, getPathSubSchema, getBlock, resolveContainerAt, getParent, getEnclosingContainer } from "./_chunks-es/get-path-sub-schema.js";
 import { getLeaf, getSpanNode, getText, getTextBlockNode, getUnionSchema, isLeaf, getFirstChild } from "./_chunks-es/get-first-child.js";
-import { isTextBlockNode, isBlock, hasNode, getEnclosingBlock, isAncestorPath, getNodes, getSibling, isInline, parentPath, isSpanNode, getPathSubSchema, getBlock, resolveContainerAt, getParent, getEnclosingContainer } from "./_chunks-es/get-path-sub-schema.js";
 import { rangeEdges, isEditableContainer, isBackwardRange, comparePoints, rangesOverlap, isAfterPoint, comparePaths, isSelectionCollapsed as isSelectionCollapsed$1, getFocusInlineObject, getFocusTextBlock, getFocusSpan, getFragment, isSelectionExpanded, getSelectionStartBlock, getSelectionEndBlock, isOverlappingSelection, getFocusBlock, getSelectedBlocks, isSelectingEntireBlocks, getSelectedValue, isActiveAnnotation, getActiveAnnotationsMarks, getActiveDecorators, getCaretWordSelection, getSelectionStartChild, getSelectionEndChild, getPreviousSpan, getNextSpan, getSelectionStartPoint, getSelectionEndPoint, getFocusBlockObject, getLastBlock, getFirstBlock, isAtTheEndOfBlock, isAtTheStartOfBlock, getMarkState, getFocusListBlock, getNextBlock, getPreviousBlock, getSelectedTextBlocks, getRootAcceptedTypes, isActiveDecorator, getFocusChild, getActiveAnnotations, isActiveListItem, isActiveStyle } from "./_chunks-es/selector.is-at-the-start-of-block.js";
-import { isEqualSelectionPoints, blockOffsetToSpanSelectionPoint, getBlockKeyFromSelectionPoint, getBlockEndPoint, getBlockStartPoint, isSelectionCollapsed, getAncestorTextBlock, 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 rawDebug from "debug";
+import { isSpan, isTextBlock, compileSchema } from "@portabletext/schema";
+import { defineSchema } from "@portabletext/schema";
 import scrollIntoView from "scroll-into-view-if-needed";
+import { getAncestorTextBlock, isEqualSelectionPoints, blockOffsetToSpanSelectionPoint, getBlockKeyFromSelectionPoint, getBlockEndPoint, getBlockStartPoint, isSelectionCollapsed, 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 { createKeyboardShortcut, undo, redo, code, underline, italic as italic$1, bold as bold$1 } from "@portabletext/keyboard-shortcuts";
-import { isEmptyTextBlock, getTextBlockText } from "./_chunks-es/util.is-empty-text-block.js";
+import rawDebug from "debug";
+import { isEmptyTextBlock, getTextBlockText, isEqualSelections } from "./_chunks-es/util.is-equal-selections.js";
 import { setup, fromCallback, assign, and, assertEvent, enqueueActions, emit, not, raise as raise$1, createActor } from "xstate";
 import { defineBehavior, forward, raise, effect } from "./behaviors/index.js";
 import { htmlToPortableText } from "@portabletext/html";
@@ -21,6 +21,211 @@ import { markdownToPortableText, portableTextToMarkdown } from "@portabletext/ma
 import { insert, setIfMissing, diffMatchPatch as diffMatchPatch$1, unset, set, applyAll } from "@portabletext/patches";
 import { EditorContext as EditorContext$1 } from "./_chunks-es/use-editor.js";
 import { useEditor } from "./_chunks-es/use-editor.js";
+function serializePath(path2) {
+  return path2.reduce((result, segment, index) => isKeyedSegment(segment) ? `${result}[_key=="${segment._key}"]` : `${result}${index === 0 ? "" : "."}${segment}`, "");
+}
+function getDomNode(editor, path2) {
+  const editorElement = editor.domElement;
+  if (!editorElement)
+    return;
+  if (path2.length === 0)
+    return editorElement;
+  const serializedPath = serializePath(path2), selector = `[data-pt-path="${CSS.escape(serializedPath)}"]`, blockSegment = path2[0];
+  if (isKeyedSegment(blockSegment)) {
+    const blockIndex = editor.blockIndexMap.get(blockSegment._key);
+    if (blockIndex !== void 0) {
+      const blockNode = editorElement.children[blockIndex];
+      if (blockNode instanceof HTMLElement) {
+        if (blockNode.matches(selector))
+          return blockNode.closest("[data-pt-editor]") !== editorElement ? void 0 : blockNode;
+        const domNode2 = blockNode.querySelector(selector);
+        if (domNode2 instanceof HTMLElement)
+          return domNode2.closest("[data-pt-editor]") !== editorElement ? void 0 : domNode2;
+      }
+    }
+  }
+  const domNode = editorElement.querySelector(selector);
+  if (!(!(domNode instanceof HTMLElement) || domNode.closest("[data-pt-editor]") !== editorElement))
+    return domNode;
+}
+const getDefaultView = (value) => value && value.ownerDocument && value.ownerDocument.defaultView || null, isDOMComment = (value) => isDOMNode(value) && value.nodeType === 8, isDOMElement = (value) => isDOMNode(value) && value.nodeType === 1, isDOMNode = (value) => {
+  const window2 = getDefaultView(value);
+  return !!window2 && value instanceof window2.Node;
+}, isDOMSelection = (value) => {
+  const window2 = value && value.anchorNode && getDefaultView(value.anchorNode);
+  return !!window2 && value instanceof window2.Selection;
+}, isPlainTextOnlyPaste = (event) => event.clipboardData && event.clipboardData.getData("text/plain") !== "" && event.clipboardData.types.length === 1, normalizeDOMPoint = (domPoint) => {
+  let [node, offset] = domPoint;
+  if (isDOMElement(node) && node.childNodes.length) {
+    let isLast = offset === node.childNodes.length, index = isLast ? offset - 1 : offset;
+    for ([node, index] = getEditableChildAndIndex(node, index, isLast ? "backward" : "forward"), isLast = index < offset; isDOMElement(node) && node.childNodes.length; ) {
+      const i = isLast ? node.childNodes.length - 1 : 0;
+      node = getEditableChild(node, i, isLast ? "backward" : "forward");
+    }
+    offset = isLast && node.textContent != null ? node.textContent.length : 0;
+  }
+  return [node, offset];
+}, hasShadowRoot = (node) => {
+  let parent = node && node.parentNode;
+  for (; parent; ) {
+    if (parent.toString() === "[object ShadowRoot]")
+      return !0;
+    parent = parent.parentNode;
+  }
+  return !1;
+}, getEditableChildAndIndex = (parent, index, direction) => {
+  const {
+    childNodes
+  } = parent;
+  let child = childNodes[index], i = index, triedForward = !1, triedBackward = !1;
+  for (; (isDOMComment(child) || isDOMElement(child) && child.childNodes.length === 0 || isDOMElement(child) && child.getAttribute("contenteditable") === "false") && !(triedForward && triedBackward); ) {
+    if (i >= childNodes.length) {
+      triedForward = !0, i = index - 1, direction = "backward";
+      continue;
+    }
+    if (i < 0) {
+      triedBackward = !0, i = index + 1, direction = "forward";
+      continue;
+    }
+    child = childNodes[i], index = i, i += direction === "forward" ? 1 : -1;
+  }
+  return [child, index];
+}, getEditableChild = (parent, index, direction) => {
+  const [child] = getEditableChildAndIndex(parent, index, direction);
+  return child;
+}, getSelection = (root) => "getSelection" in root && typeof root.getSelection == "function" ? root.getSelection() : document.getSelection(), isTrackedMutation = (editor, mutation, batch) => {
+  const {
+    target
+  } = mutation;
+  if (isDOMElement(target) && target.matches('[contentEditable="false"]'))
+    return !1;
+  const {
+    document: document2
+  } = DOMEditor.getWindow(editor);
+  if (containsShadowAware(document2, target))
+    return DOMEditor.hasDOMNode(editor, target, {
+      editable: !0
+    });
+  const parentMutation = batch.find(({
+    addedNodes,
+    removedNodes
+  }) => {
+    for (const node of addedNodes)
+      if (node === target || containsShadowAware(node, target))
+        return !0;
+    for (const node of removedNodes)
+      if (node === target || containsShadowAware(node, target))
+        return !0;
+    return !1;
+  });
+  return !parentMutation || parentMutation === mutation ? !1 : isTrackedMutation(editor, parentMutation, batch);
+}, getActiveElement = () => {
+  let activeElement = document.activeElement;
+  for (; activeElement?.shadowRoot && activeElement.shadowRoot?.activeElement; )
+    activeElement = activeElement?.shadowRoot?.activeElement;
+  return activeElement;
+}, isBefore = (node, otherNode) => !!(node.compareDocumentPosition(otherNode) & Node.DOCUMENT_POSITION_PRECEDING), isAfter = (node, otherNode) => !!(node.compareDocumentPosition(otherNode) & Node.DOCUMENT_POSITION_FOLLOWING), closestShadowAware = (element, selector) => {
+  if (!element)
+    return null;
+  let current = element;
+  for (; current; ) {
+    if (current.matches && current.matches(selector))
+      return current;
+    if (current.parentElement)
+      current = current.parentElement;
+    else if (current.parentNode && "host" in current.parentNode)
+      current = current.parentNode.host;
+    else
+      return null;
+  }
+  return null;
+}, containsShadowAware = (parent, child) => {
+  if (!parent || !child)
+    return !1;
+  if (parent.contains(child))
+    return !0;
+  let current = child;
+  for (; current; ) {
+    if (current === parent)
+      return !0;
+    if (current.parentNode)
+      "host" in current.parentNode ? current = current.parentNode.host : current = current.parentNode;
+    else
+      return !1;
+  }
+  return !1;
+}, KEYED_SEGMENT_PATTERN = /\[_key=="(.+?)"\]/;
+function deserializePath(serializedPath) {
+  const path2 = [];
+  let remaining = serializedPath;
+  for (; remaining.length > 0; ) {
+    remaining.startsWith(".") && (remaining = remaining.slice(1));
+    const keyMatch = remaining.match(KEYED_SEGMENT_PATTERN);
+    if (keyMatch?.[1] && remaining.startsWith("[")) {
+      path2.push({
+        _key: keyMatch[1]
+      }), remaining = remaining.slice(keyMatch[0].length);
+      continue;
+    }
+    const nextBracket = remaining.indexOf("["), nextDot = remaining.indexOf(".");
+    let end2;
+    nextBracket === -1 && nextDot === -1 ? end2 = remaining.length : nextBracket === -1 ? end2 = nextDot : nextDot === -1 ? end2 = nextBracket : end2 = Math.min(nextBracket, nextDot);
+    const fieldName = remaining.slice(0, end2);
+    fieldName && path2.push(fieldName), remaining = remaining.slice(end2);
+  }
+  return path2;
+}
+function getDomNodePath(domNode) {
+  let element = isDOMElement(domNode) ? domNode : domNode.parentElement;
+  if (element && !element.hasAttribute("data-pt-path") && (element = element.closest("[data-pt-path]")), !element)
+    return;
+  const dataPath = element.getAttribute("data-pt-path");
+  if (dataPath !== null)
+    return dataPath === "" ? [] : deserializePath(dataPath);
+}
+function safeStringify(value, space) {
+  try {
+    return JSON.stringify(value, null, space);
+  } catch (error) {
+    return console.error(error), "JSON.stringify failed";
+  }
+}
+function safeParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch (error) {
+    return console.error(error), "JSON.parse failed";
+  }
+}
+function getAncestorObjectNode(snapshot, path2) {
+  const result = getAncestor(snapshot, path2, (node) => isObjectNode({
+    schema: snapshot.context.schema
+  }, node));
+  if (result && isObjectNode({
+    schema: snapshot.context.schema
+  }, result.node))
+    return {
+      node: result.node,
+      path: result.path
+    };
+}
+function commonPath(path2, another) {
+  const common = [];
+  for (let i = 0; i < path2.length && i < another.length; i++) {
+    const segment = path2.at(i), otherSegment = another.at(i);
+    if (segment === void 0 || otherSegment === void 0)
+      break;
+    if (isKeyedSegment(segment) && isKeyedSegment(otherSegment)) {
+      if (segment._key !== otherSegment._key)
+        break;
+      common.push(segment);
+    } else if (segment === otherSegment)
+      common.push(segment);
+    else
+      break;
+  }
+  return common;
+}
 function isPath(value) {
   return Array.isArray(value) && (value.length === 0 || typeof value[0] == "number" || typeof value[0] == "string" || isKeyedSegment(value[0]));
 }
@@ -31,7 +236,37 @@ function isPoint(value) {
 function isRange(value) {
   return isObject(value) && isPoint(value.anchor) && isPoint(value.focus);
 }
-const EDITOR_BRAND = /* @__PURE__ */ Symbol.for("slate-editor");
+function rangeEnd(range2, root) {
+  const [, end2] = rangeEdges(range2, root);
+  return end2;
+}
+function rangeStart(range2, root) {
+  const [start2] = rangeEdges(range2, root);
+  return start2;
+}
+function path(editor, at, options = {}) {
+  const {
+    depth,
+    edge
+  } = options;
+  if (isPath(at) && (edge === "start" || edge === "end")) {
+    const leaf = getLeaf(editor, at, {
+      edge
+    });
+    leaf && (at = leaf.path);
+  }
+  return isRange(at) && (edge === "start" ? at = rangeStart(at, editor) : edge === "end" ? at = rangeEnd(at, editor) : at = commonPath(at.anchor.path, at.focus.path)), isPoint(at) && (at = at.path), depth != null && (at = sliceToNodeDepth(at, depth)), at;
+}
+function sliceToNodeDepth(nodePath, depth) {
+  let nodeCount = 0;
+  for (let i = 0; i < nodePath.length; i++) {
+    const segment = nodePath[i];
+    if ((isKeyedSegment(segment) || typeof segment == "number") && (nodeCount++, nodeCount === depth))
+      return nodePath.slice(0, i + 1);
+  }
+  return nodePath;
+}
+const EDITOR_BRAND = /* @__PURE__ */ Symbol.for("editor-engine");
 function isEditor(value) {
   return isObject(value) && value[EDITOR_BRAND] === !0;
 }
@@ -74,16 +309,16 @@ function point(editor, at, options = {}) {
   }
   return at;
 }
-function end(editor, at) {
-  return point(editor, at, {
-    edge: "end"
-  });
-}
 function start(editor, at) {
   return point(editor, at, {
     edge: "start"
   });
 }
+function isVoidNode(snapshot, node, path2) {
+  return isObjectNode({
+    schema: snapshot.context.schema
+  }, node) && !isEditableContainer(snapshot, node, path2);
+}
 function pathEquals(path2, another) {
   if (path2.length !== another.length)
     return !1;
@@ -100,269 +335,6 @@ function pathEquals(path2, another) {
 function pointEquals(point2, another) {
   return point2.offset === another.offset && pathEquals(point2.path, another.path);
 }
-function resolveSelection(editor, selection) {
-  if (!selection)
-    return null;
-  if (isEqualSelectionPoints(selection.anchor, selection.focus)) {
-    const anchorPoint2 = resolveSelectionPoint(editor, selection.anchor, selection.backward ? "backward" : "forward");
-    return anchorPoint2 ? {
-      anchor: anchorPoint2,
-      focus: anchorPoint2
-    } : null;
-  }
-  const anchorPoint = resolveSelectionPoint(editor, selection.anchor, selection.backward ? "forward" : "backward"), focusPoint = resolveSelectionPoint(editor, selection.focus, selection.backward ? "backward" : "forward");
-  return !anchorPoint || !focusPoint ? null : {
-    anchor: anchorPoint,
-    focus: focusPoint
-  };
-}
-function resolveSelectionPoint(editor, selectionPoint, direction) {
-  const snapshot = {
-    context: {
-      schema: editor.schema,
-      containers: editor.publicContainers,
-      value: editor.children
-    },
-    blockIndexMap: editor.blockIndexMap
-  }, entry = getNode(snapshot, selectionPoint.path);
-  if (entry) {
-    if (getChildren(snapshot, entry.path).length === 0)
-      return {
-        path: entry.path,
-        offset: isSpan({
-          schema: editor.schema
-        }, entry.node) ? Math.min(entry.node.text.length, selectionPoint.offset) : 0
-      };
-    const isBlockLevelPath = isBlock(snapshot, selectionPoint.path);
-    if (isTextBlock({
-      schema: editor.schema
-    }, entry.node) && isBlockLevelPath) {
-      const spanPoint = blockOffsetToSpanSelectionPoint({
-        snapshot,
-        blockOffset: {
-          path: entry.path,
-          offset: selectionPoint.offset
-        },
-        direction
-      });
-      if (spanPoint)
-        return spanPoint;
-    }
-    const leaf2 = getLeaf(snapshot, entry.path, {
-      edge: direction === "forward" ? "start" : "end"
-    });
-    return leaf2 ? {
-      path: leaf2.path,
-      offset: 0
-    } : {
-      path: entry.path,
-      offset: 0
-    };
-  }
-  const blockKey = getBlockKeyFromSelectionPoint(selectionPoint);
-  if (!blockKey)
-    return;
-  const blockEntry = getNode(snapshot, [{
-    _key: blockKey
-  }]);
-  if (!blockEntry)
-    return;
-  const leaf = getLeaf(snapshot, blockEntry.path, {
-    edge: "start"
-  });
-  return leaf ? {
-    path: leaf.path,
-    offset: 0
-  } : {
-    path: blockEntry.path,
-    offset: 0
-  };
-}
-function applySelect(editor, target) {
-  const range2 = toRange(editor, target), {
-    selection
-  } = editor;
-  if (selection) {
-    const oldProps = {}, newProps = {};
-    range2.anchor != null && !pointEquals(range2.anchor, selection.anchor) && (oldProps.anchor = selection.anchor, newProps.anchor = range2.anchor), range2.focus != null && !pointEquals(range2.focus, selection.focus) && (oldProps.focus = selection.focus, newProps.focus = range2.focus), Object.keys(oldProps).length > 0 && editor.apply({
-      type: "set_selection",
-      properties: oldProps,
-      newProperties: newProps
-    });
-  } else
-    editor.apply({
-      type: "set_selection",
-      properties: null,
-      newProperties: range2
-    });
-}
-function applyDeselect(editor) {
-  const {
-    selection
-  } = editor;
-  selection && editor.apply({
-    type: "set_selection",
-    properties: selection,
-    newProperties: null
-  });
-}
-function toRange(editor, target) {
-  if (isRange(target))
-    return target;
-  if (isPoint(target))
-    return {
-      anchor: target,
-      focus: target
-    };
-  const start$1 = start(editor, target), end$1 = end(editor, target);
-  return {
-    anchor: start$1,
-    focus: end$1
-  };
-}
-const rootName = "pte:";
-function createDebugger(name) {
-  const namespace = `${rootName}${name}`;
-  return rawDebug && rawDebug.enabled(namespace) ? rawDebug(namespace) : rawDebug(rootName);
-}
-const debug = {
-  behaviors: createDebugger("behaviors"),
-  history: createDebugger("history"),
-  mutation: createDebugger("mutation"),
-  normalization: createDebugger("normalization"),
-  operation: createDebugger("operation"),
-  selection: createDebugger("selection"),
-  setup: createDebugger("setup"),
-  state: createDebugger("state"),
-  syncValue: createDebugger("sync:value"),
-  syncPatch: createDebugger("sync:patch")
-};
-function serializePath(path2) {
-  return path2.reduce((result, segment, index) => isKeyedSegment(segment) ? `${result}[_key=="${segment._key}"]` : `${result}${index === 0 ? "" : "."}${segment}`, "");
-}
-function getDomNode(editor, path2) {
-  const editorElement = editor.domElement;
-  if (!editorElement)
-    return;
-  if (path2.length === 0)
-    return editorElement;
-  const serializedPath = serializePath(path2), selector = `[data-pt-path="${CSS.escape(serializedPath)}"]`, blockSegment = path2[0];
-  if (isKeyedSegment(blockSegment)) {
-    const blockIndex = editor.blockIndexMap.get(blockSegment._key);
-    if (blockIndex !== void 0) {
-      const blockNode = editorElement.children[blockIndex];
-      if (blockNode instanceof HTMLElement) {
-        if (blockNode.matches(selector))
-          return blockNode.closest("[data-pt-editor]") !== editorElement ? void 0 : blockNode;
-        const domNode2 = blockNode.querySelector(selector);
-        if (domNode2 instanceof HTMLElement)
-          return domNode2.closest("[data-pt-editor]") !== editorElement ? void 0 : domNode2;
-      }
-    }
-  }
-  const domNode = editorElement.querySelector(selector);
-  if (!(!(domNode instanceof HTMLElement) || domNode.closest("[data-pt-editor]") !== editorElement))
-    return domNode;
-}
-const KEYED_SEGMENT_PATTERN = /\[_key=="(.+?)"\]/;
-function deserializePath(serializedPath) {
-  const path2 = [];
-  let remaining = serializedPath;
-  for (; remaining.length > 0; ) {
-    remaining.startsWith(".") && (remaining = remaining.slice(1));
-    const keyMatch = remaining.match(KEYED_SEGMENT_PATTERN);
-    if (keyMatch?.[1] && remaining.startsWith("[")) {
-      path2.push({
-        _key: keyMatch[1]
-      }), remaining = remaining.slice(keyMatch[0].length);
-      continue;
-    }
-    const nextBracket = remaining.indexOf("["), nextDot = remaining.indexOf(".");
-    let end2;
-    nextBracket === -1 && nextDot === -1 ? end2 = remaining.length : nextBracket === -1 ? end2 = nextDot : nextDot === -1 ? end2 = nextBracket : end2 = Math.min(nextBracket, nextDot);
-    const fieldName = remaining.slice(0, end2);
-    fieldName && path2.push(fieldName), remaining = remaining.slice(end2);
-  }
-  return path2;
-}
-function safeStringify(value, space) {
-  try {
-    return JSON.stringify(value, null, space);
-  } catch (error) {
-    return console.error(error), "JSON.stringify failed";
-  }
-}
-function safeParse(text) {
-  try {
-    return JSON.parse(text);
-  } catch (error) {
-    return console.error(error), "JSON.parse failed";
-  }
-}
-function getAncestorObjectNode(snapshot, path2) {
-  const result = getAncestor(snapshot, path2, (node) => isObjectNode({
-    schema: snapshot.context.schema
-  }, node));
-  if (result && isObjectNode({
-    schema: snapshot.context.schema
-  }, result.node))
-    return {
-      node: result.node,
-      path: result.path
-    };
-}
-function commonPath(path2, another) {
-  const common = [];
-  for (let i = 0; i < path2.length && i < another.length; i++) {
-    const segment = path2.at(i), otherSegment = another.at(i);
-    if (segment === void 0 || otherSegment === void 0)
-      break;
-    if (isKeyedSegment(segment) && isKeyedSegment(otherSegment)) {
-      if (segment._key !== otherSegment._key)
-        break;
-      common.push(segment);
-    } else if (segment === otherSegment)
-      common.push(segment);
-    else
-      break;
-  }
-  return common;
-}
-function rangeEnd(range2, root) {
-  const [, end2] = rangeEdges(range2, root);
-  return end2;
-}
-function rangeStart(range2, root) {
-  const [start2] = rangeEdges(range2, root);
-  return start2;
-}
-function path(editor, at, options = {}) {
-  const {
-    depth,
-    edge
-  } = options;
-  if (isPath(at) && (edge === "start" || edge === "end")) {
-    const leaf = getLeaf(editor, at, {
-      edge
-    });
-    leaf && (at = leaf.path);
-  }
-  return isRange(at) && (edge === "start" ? at = rangeStart(at, editor) : edge === "end" ? at = rangeEnd(at, editor) : at = commonPath(at.anchor.path, at.focus.path)), isPoint(at) && (at = at.path), depth != null && (at = sliceToNodeDepth(at, depth)), at;
-}
-function sliceToNodeDepth(nodePath, depth) {
-  let nodeCount = 0;
-  for (let i = 0; i < nodePath.length; i++) {
-    const segment = nodePath[i];
-    if ((isKeyedSegment(segment) || typeof segment == "number") && (nodeCount++, nodeCount === depth))
-      return nodePath.slice(0, i + 1);
-  }
-  return nodePath;
-}
-function isVoidNode(snapshot, node, path2) {
-  return isObjectNode({
-    schema: snapshot.context.schema
-  }, node) && !isEditableContainer(snapshot, node, path2);
-}
 function isCollapsedRange(range2) {
   const {
     anchor,
@@ -455,7 +427,7 @@ typeof globalThis < "u" && globalThis.InputEvent && typeof globalThis.InputEvent
   toDOMPoint: (editor, point2) => {
     const nodeEntry = getNode(editor, point2.path), el = getDomNode(editor, point2.path);
     if (!el)
-      throw new Error(`Cannot resolve a DOM node from path: ${point2.path}`);
+      throw new Error(`Cannot find a DOM node for editor path: ${point2.path}`);
     let domPoint;
     if (nodeEntry && isVoidNode(editor, nodeEntry.node, point2.path)) {
       const spacer = el.querySelector("[data-pt-zero-width]");
@@ -494,7 +466,7 @@ typeof globalThis < "u" && globalThis.InputEvent && typeof globalThis.InputEvent
       start2 = end2;
     }
     if (!domPoint)
-      throw new Error(`Cannot resolve a DOM point from Slate point: ${safeStringify(point2)}`);
+      throw new Error(`Cannot find a DOM position for editor location: ${safeStringify(point2)}`);
     return domPoint;
   },
   toDOMRange: (editor, range2) => {
@@ -504,7 +476,7 @@ typeof globalThis < "u" && globalThis.InputEvent && typeof globalThis.InputEvent
     } = range2, isBackward = isBackwardRange(range2, editor), domAnchor = DOMEditor.toDOMPoint(editor, anchor), domFocus = isCollapsedRange(range2) ? domAnchor : DOMEditor.toDOMPoint(editor, focus), domRange = DOMEditor.getWindow(editor).document.createRange(), [startNode, startOffset] = isBackward ? domFocus : domAnchor, [endNode, endOffset] = isBackward ? domAnchor : domFocus, isStartAtZeroWidth = !!(isDOMElement(startNode) ? startNode : startNode.parentElement).getAttribute("data-pt-zero-width"), isEndAtZeroWidth = !!(isDOMElement(endNode) ? endNode : endNode.parentElement).getAttribute("data-pt-zero-width");
     return domRange.setStart(startNode, isStartAtZeroWidth ? 1 : startOffset), domRange.setEnd(endNode, isEndAtZeroWidth ? 1 : endOffset), domRange;
   },
-  toSlatePoint: (editor, domPoint, options) => {
+  toSelectionPoint: (editor, domPoint, options) => {
     const {
       exactMatch,
       suppressThrow,
@@ -553,7 +525,7 @@ typeof globalThis < "u" && globalThis.InputEvent && typeof globalThis.InputEvent
       }
       domNode && offset === domNode.textContent.length && // COMPAT: Android IMEs might remove the zero width space while composing,
       // and we don't add it for line-breaks.
-      IS_ANDROID && domNode.hasAttribute("data-pt-zero-width") && !domNode.hasAttribute("data-pt-line-break") && domNode.textContent?.startsWith("\uFEFF") && // COMPAT: If the parent node is a Slate zero-width space, editor is
+      IS_ANDROID && domNode.hasAttribute("data-pt-zero-width") && !domNode.hasAttribute("data-pt-line-break") && domNode.textContent?.startsWith("\uFEFF") && // COMPAT: If the parent node is a zero-width space, editor is
       // because the text node should have no characters. However, during IME
       // composition the ASCII characters will be prepended to the zero-width
       // space, so subtract 1 from the offset to account for the zero-width
@@ -574,7 +546,7 @@ typeof globalThis < "u" && globalThis.InputEvent && typeof globalThis.InputEvent
         if (!nodePath) {
           if (suppressThrow)
             return null;
-          throw new Error(`Cannot resolve a Slate point from DOM point: ${domPoint}`);
+          throw new Error(`Cannot map DOM position to an editor location: ${domPoint}`);
         }
         let {
           path: path22,
@@ -617,13 +589,13 @@ typeof globalThis < "u" && globalThis.InputEvent && typeof globalThis.InputEvent
     if (!textNode) {
       if (suppressThrow)
         return null;
-      throw new Error(`Cannot resolve a Slate point from DOM point: ${domPoint}`);
+      throw new Error(`Cannot map DOM position to an editor location: ${domPoint}`);
     }
     const path2 = getDomNodePath(textNode);
     if (!path2) {
       if (suppressThrow)
         return null;
-      throw new Error(`Cannot resolve a Slate point from DOM point: ${domPoint}`);
+      throw new Error(`Cannot map DOM position to an editor location: ${domPoint}`);
     }
     if (path2.length > 1) {
       const parentPath2 = path2.slice(0, -1), parentEntry = getNode(editor, parentPath2);
@@ -638,7 +610,7 @@ typeof globalThis < "u" && globalThis.InputEvent && typeof globalThis.InputEvent
       offset
     };
   },
-  toSlateRange: (editor, domRange, options) => {
+  toEditorSelection: (editor, domRange, options) => {
     const {
       exactMatch,
       suppressThrow
@@ -664,308 +636,29 @@ typeof globalThis < "u" && globalThis.InputEvent && typeof globalThis.InputEvent
         anchorNode = domRange.startContainer, anchorOffset = domRange.startOffset, focusNode = domRange.endContainer, focusOffset = domRange.endOffset, isCollapsed = domRange.collapsed;
     if (anchorNode == null || focusNode == null || anchorOffset == null || focusOffset == null) {
       if (suppressThrow)
-        return null;
-      throw new Error(`Cannot resolve a Slate range from DOM range: ${domRange}`);
-    }
-    IS_FIREFOX && focusNode.textContent?.endsWith(`
-
-`) && focusOffset === focusNode.textContent.length && focusOffset--;
-    const anchor = DOMEditor.toSlatePoint(editor, [anchorNode, anchorOffset], {
-      exactMatch,
-      suppressThrow
-    });
-    if (!anchor)
-      return null;
-    const focusBeforeAnchor = isBefore(anchorNode, focusNode) || anchorNode === focusNode && focusOffset < anchorOffset, focus = isCollapsed ? anchor : DOMEditor.toSlatePoint(editor, [focusNode, focusOffset], {
-      exactMatch,
-      suppressThrow,
-      searchDirection: focusBeforeAnchor ? "forward" : "backward"
-    });
-    return focus ? {
-      anchor,
-      focus
-    } : null;
-  }
-}, getDefaultView = (value) => value && value.ownerDocument && value.ownerDocument.defaultView || null, isDOMComment = (value) => isDOMNode(value) && value.nodeType === 8, isDOMElement = (value) => isDOMNode(value) && value.nodeType === 1, isDOMNode = (value) => {
-  const window2 = getDefaultView(value);
-  return !!window2 && value instanceof window2.Node;
-}, isDOMSelection = (value) => {
-  const window2 = value && value.anchorNode && getDefaultView(value.anchorNode);
-  return !!window2 && value instanceof window2.Selection;
-}, isPlainTextOnlyPaste = (event) => event.clipboardData && event.clipboardData.getData("text/plain") !== "" && event.clipboardData.types.length === 1, normalizeDOMPoint = (domPoint) => {
-  let [node, offset] = domPoint;
-  if (isDOMElement(node) && node.childNodes.length) {
-    let isLast = offset === node.childNodes.length, index = isLast ? offset - 1 : offset;
-    for ([node, index] = getEditableChildAndIndex(node, index, isLast ? "backward" : "forward"), isLast = index < offset; isDOMElement(node) && node.childNodes.length; ) {
-      const i = isLast ? node.childNodes.length - 1 : 0;
-      node = getEditableChild(node, i, isLast ? "backward" : "forward");
-    }
-    offset = isLast && node.textContent != null ? node.textContent.length : 0;
-  }
-  return [node, offset];
-}, hasShadowRoot = (node) => {
-  let parent = node && node.parentNode;
-  for (; parent; ) {
-    if (parent.toString() === "[object ShadowRoot]")
-      return !0;
-    parent = parent.parentNode;
-  }
-  return !1;
-}, getEditableChildAndIndex = (parent, index, direction) => {
-  const {
-    childNodes
-  } = parent;
-  let child = childNodes[index], i = index, triedForward = !1, triedBackward = !1;
-  for (; (isDOMComment(child) || isDOMElement(child) && child.childNodes.length === 0 || isDOMElement(child) && child.getAttribute("contenteditable") === "false") && !(triedForward && triedBackward); ) {
-    if (i >= childNodes.length) {
-      triedForward = !0, i = index - 1, direction = "backward";
-      continue;
-    }
-    if (i < 0) {
-      triedBackward = !0, i = index + 1, direction = "forward";
-      continue;
-    }
-    child = childNodes[i], index = i, i += direction === "forward" ? 1 : -1;
-  }
-  return [child, index];
-}, getEditableChild = (parent, index, direction) => {
-  const [child] = getEditableChildAndIndex(parent, index, direction);
-  return child;
-}, getSelection = (root) => "getSelection" in root && typeof root.getSelection == "function" ? root.getSelection() : document.getSelection(), isTrackedMutation = (editor, mutation, batch) => {
-  const {
-    target
-  } = mutation;
-  if (isDOMElement(target) && target.matches('[contentEditable="false"]'))
-    return !1;
-  const {
-    document: document2
-  } = DOMEditor.getWindow(editor);
-  if (containsShadowAware(document2, target))
-    return DOMEditor.hasDOMNode(editor, target, {
-      editable: !0
-    });
-  const parentMutation = batch.find(({
-    addedNodes,
-    removedNodes
-  }) => {
-    for (const node of addedNodes)
-      if (node === target || containsShadowAware(node, target))
-        return !0;
-    for (const node of removedNodes)
-      if (node === target || containsShadowAware(node, target))
-        return !0;
-    return !1;
-  });
-  return !parentMutation || parentMutation === mutation ? !1 : isTrackedMutation(editor, parentMutation, batch);
-}, getActiveElement = () => {
-  let activeElement = document.activeElement;
-  for (; activeElement?.shadowRoot && activeElement.shadowRoot?.activeElement; )
-    activeElement = activeElement?.shadowRoot?.activeElement;
-  return activeElement;
-}, isBefore = (node, otherNode) => !!(node.compareDocumentPosition(otherNode) & Node.DOCUMENT_POSITION_PRECEDING), isAfter = (node, otherNode) => !!(node.compareDocumentPosition(otherNode) & Node.DOCUMENT_POSITION_FOLLOWING), closestShadowAware = (element, selector) => {
-  if (!element)
-    return null;
-  let current = element;
-  for (; current; ) {
-    if (current.matches && current.matches(selector))
-      return current;
-    if (current.parentElement)
-      current = current.parentElement;
-    else if (current.parentNode && "host" in current.parentNode)
-      current = current.parentNode.host;
-    else
-      return null;
-  }
-  return null;
-}, containsShadowAware = (parent, child) => {
-  if (!parent || !child)
-    return !1;
-  if (parent.contains(child))
-    return !0;
-  let current = child;
-  for (; current; ) {
-    if (current === parent)
-      return !0;
-    if (current.parentNode)
-      "host" in current.parentNode ? current = current.parentNode.host : current = current.parentNode;
-    else
-      return !1;
-  }
-  return !1;
-};
-function getDomNodePath(domNode) {
-  let element = isDOMElement(domNode) ? domNode : domNode.parentElement;
-  if (element && !element.hasAttribute("data-pt-path") && (element = element.closest("[data-pt-path]")), !element)
-    return;
-  const dataPath = element.getAttribute("data-pt-path");
-  if (dataPath !== null)
-    return dataPath === "" ? [] : deserializePath(dataPath);
-}
-function getEventPosition({
-  editorActor,
-  slateEditor,
-  event
-}) {
-  if (editorActor.getSnapshot().matches({
-    setup: "setting up"
-  }))
-    return;
-  const eventResult = getEventNode({
-    slateEditor,
-    event
-  });
-  if (!eventResult)
-    return;
-  const {
-    node: eventNode,
-    path: eventPath
-  } = eventResult, eventBlockEntry = getEnclosingBlock(slateEditor, eventPath), eventBlock = eventBlockEntry?.node, eventBlockPath = eventBlockEntry?.path, eventPositionBlock = getEventPositionBlock({
-    nodePath: eventPath,
-    slateEditor,
-    event
-  }), eventSelection = getSelectionFromEvent(slateEditor, event) ?? null;
-  if (eventBlock && eventBlockPath && eventPositionBlock && !eventSelection && !isEventContainer(slateEditor, eventNode, eventPath))
-    return {
-      block: eventPositionBlock,
-      isEditor: !1,
-      isContainer: !1,
-      selection: {
-        anchor: getBlockStartPoint({
-          context: slateEditor,
-          block: {
-            node: eventBlock,
-            path: eventBlockPath
-          }
-        }),
-        focus: getBlockEndPoint({
-          context: slateEditor,
-          block: {
-            node: eventBlock,
-            path: eventBlockPath
-          }
-        })
-      }
-    };
-  if (!eventPositionBlock || !eventSelection)
-    return;
-  const eventSelectionFocusBlock = getEnclosingBlock(slateEditor, eventSelection.focus.path);
-  if (eventSelectionFocusBlock)
-    return isSelectionCollapsed(eventSelection) && eventBlock && eventBlockPath && eventSelectionFocusBlock.node._key !== eventBlock._key && !isAncestorPath(eventBlockPath, eventSelectionFocusBlock.path) ? {
-      block: eventPositionBlock,
-      isEditor: !1,
-      isContainer: !1,
-      selection: {
-        anchor: getBlockStartPoint({
-          context: slateEditor,
-          block: {
-            node: eventBlock,
-            path: eventBlockPath
-          }
-        }),
-        focus: getBlockEndPoint({
-          context: slateEditor,
-          block: {
-            node: eventBlock,
-            path: eventBlockPath
-          }
-        })
-      }
-    } : {
-      block: eventPositionBlock,
-      isEditor: isEditor(eventNode),
-      isContainer: isEditor(eventNode) ? !1 : isEditableContainer(slateEditor, eventNode, eventPath),
-      selection: eventSelection
-    };
-}
-function getEventNode({
-  slateEditor,
-  event
-}) {
-  if (DOMEditor.hasTarget(slateEditor, event.target))
-    try {
-      const path2 = getDomNodePath(event.target);
-      if (path2) {
-        if (path2.length === 0)
-          return {
-            node: slateEditor,
-            path: path2
-          };
-        {
-          const nodeEntry = getNode(slateEditor, path2);
-          if (nodeEntry)
-            return {
-              node: nodeEntry.node,
-              path: path2
-            };
-        }
-      }
-    } catch (error) {
-      console.error(error);
-    }
-}
-function getEventPositionBlock({
-  nodePath,
-  slateEditor,
-  event
-}) {
-  const firstBlockEntry = getNode(slateEditor, [0]);
-  if (!firstBlockEntry)
-    return;
-  const firstBlockElement = getDomNode(slateEditor, firstBlockEntry.path);
-  if (!firstBlockElement)
-    return;
-  const firstBlockRect = firstBlockElement.getBoundingClientRect();
-  if (event.pageY < firstBlockRect.top)
-    return "start";
-  const lastBlock = slateEditor.children.at(-1), lastBlockEntry = lastBlock ? getNode(slateEditor, [{
-    _key: lastBlock._key
-  }]) : void 0;
-  if (!lastBlockEntry)
-    return;
-  const lastBlockElement = getDomNode(slateEditor, lastBlockEntry.path);
-  if (!lastBlockElement)
-    return;
-  const lastBlockRef = lastBlockElement.getBoundingClientRect();
-  if (event.pageY > lastBlockRef.bottom)
-    return "end";
-  const element = getDomNode(slateEditor, nodePath);
-  if (!element)
-    return;
-  const elementRect = element.getBoundingClientRect(), top = elementRect.top, height = elementRect.height;
-  return Math.abs(top - event.pageY) < height / 2 ? "start" : "end";
-}
-function getSelectionFromEvent(editor, event) {
-  if (!event.target || !isDOMNode(event.target))
-    return;
-  const window2 = DOMEditor.getWindow(editor);
-  let domRange;
-  if (window2.document.caretPositionFromPoint !== void 0) {
-    const position = window2.document.caretPositionFromPoint(event.clientX, event.clientY);
-    if (position)
-      try {
-        domRange = window2.document.createRange(), domRange.setStart(position.offsetNode, position.offset), domRange.setEnd(position.offsetNode, position.offset);
-      } catch {
-      }
-  } else if (window2.document.caretRangeFromPoint !== void 0)
-    domRange = window2.document.caretRangeFromPoint(event.clientX, event.clientY) ?? void 0;
-  else {
-    console.warn("Neither caretPositionFromPoint nor caretRangeFromPoint is supported");
-    return;
-  }
-  if (domRange)
-    try {
-      return DOMEditor.toSlateRange(editor, domRange, {
-        exactMatch: !1,
-        // It can still throw even with this option set to true
-        suppressThrow: !1
-      });
-    } catch {
-      return;
+        return null;
+      throw new Error(`Cannot map DOM range to an editor selection: ${domRange}`);
     }
-}
-function isEventContainer(slateEditor, eventNode, eventPath) {
-  return isEditor(eventNode) ? !0 : isEditableContainer(slateEditor, eventNode, eventPath);
-}
+    IS_FIREFOX && focusNode.textContent?.endsWith(`
+
+`) && focusOffset === focusNode.textContent.length && focusOffset--;
+    const anchor = DOMEditor.toSelectionPoint(editor, [anchorNode, anchorOffset], {
+      exactMatch,
+      suppressThrow
+    });
+    if (!anchor)
+      return null;
+    const focusBeforeAnchor = isBefore(anchorNode, focusNode) || anchorNode === focusNode && focusOffset < anchorOffset, focus = isCollapsed ? anchor : DOMEditor.toSelectionPoint(editor, [focusNode, focusOffset], {
+      exactMatch,
+      suppressThrow,
+      searchDirection: focusBeforeAnchor ? "forward" : "backward"
+    });
+    return focus ? {
+      anchor,
+      focus
+    } : null;
+  }
+};
 function getVoidAncestor(snapshot, path2) {
   return getAncestor(snapshot, path2, (node, ancestorPath) => isVoidNode(snapshot, node, ancestorPath));
 }
@@ -999,6 +692,11 @@ function deselect(editor) {
     newProperties: null
   });
 }
+function end(editor, at) {
+  return point(editor, at, {
+    edge: "end"
+  });
+}
 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;
@@ -1620,6 +1318,12 @@ function isExpandedRange(range2) {
 function rangeEquals(range2, another) {
   return pointEquals(range2.anchor, another.anchor) && pointEquals(range2.focus, another.focus);
 }
+const EditorContext = createContext(null), useEngineStatic = () => {
+  const editor = useContext(EditorContext);
+  if (!editor)
+    throw new Error("The `useEngineStatic` hook must be used inside the <Engine> component's context.");
+  return editor;
+};
 function useIsMounted() {
   const isMountedRef = useRef(!1);
   return useEffect(() => (isMountedRef.current = !0, () => {
@@ -1637,12 +1341,6 @@ function useMutationObserver(node, callback, options) {
     return mutationObserver.observe(node.current, options), () => mutationObserver.disconnect();
   }, [mutationObserver, node, options]);
 }
-const EditorContext = createContext(null), useSlateStatic = () => {
-  const editor = useContext(EditorContext);
-  if (!editor)
-    throw new Error("The `useSlateStatic` hook must be used inside the <Slate> component's context.");
-  return editor;
-};
 function isDescendantPath(path2, another) {
   return isAncestorPath(another, path2);
 }
@@ -2052,12 +1750,12 @@ function createAndroidInputManager({
     const data = event.dataTransfer || event.data || void 0;
     insertPositionHint !== !1 && type !== "insertText" && type !== "insertCompositionText" && (insertPositionHint = !1);
     let [nativeTargetRange] = event.getTargetRanges();
-    nativeTargetRange && (targetRange2 = DOMEditor.toSlateRange(editor, nativeTargetRange, {
+    nativeTargetRange && (targetRange2 = DOMEditor.toEditorSelection(editor, nativeTargetRange, {
       exactMatch: !1,
       suppressThrow: !0
     }));
     const domSelection = DOMEditor.getWindow(editor).getSelection();
-    if (!targetRange2 && domSelection && (nativeTargetRange = domSelection, targetRange2 = DOMEditor.toSlateRange(editor, domSelection, {
+    if (!targetRange2 && domSelection && (nativeTargetRange = domSelection, targetRange2 = DOMEditor.toEditorSelection(editor, domSelection, {
       exactMatch: !1,
       suppressThrow: !0
     })), targetRange2 = targetRange2 ?? editor.selection, !targetRange2)
@@ -2442,7 +2140,7 @@ const MUTATION_OBSERVER_CONFIG$1 = {
 }) => {
   if (!IS_ANDROID)
     return null;
-  const editor = useSlateStatic(), isMounted = useIsMounted(), [inputManager] = useState(() => createAndroidInputManager({
+  const editor = useEngineStatic(), isMounted = useIsMounted(), [inputManager] = useState(() => createAndroidInputManager({
     editor,
     editorActor,
     ...options
@@ -2586,7 +2284,7 @@ function isError(error) {
   return error instanceof Error;
 }
 const DecorateContext = createContext({}), useDecorations = (node, path2, parentDecorations) => {
-  const $ = c(11), editor = useSlateStatic(), {
+  const $ = c(11), editor = useEngineStatic(), {
     decorate,
     addEventListener
   } = useContext(DecorateContext);
@@ -2641,7 +2339,7 @@ const Element$1 = (props) => {
     renderElement,
     renderLeaf,
     renderText
-  } = props, dataPath = serializePath(props.path), editor = useSlateStatic(), isInline$1 = isInline(editor, props.path), isInNewPipeline = useContext(NewPipelineContext), decorations = useDecorations(element, props.path, parentDecorations);
+  } = props, dataPath = serializePath(props.path), editor = useEngineStatic(), isInline$1 = isInline(editor, props.path), isInNewPipeline = useContext(NewPipelineContext), decorations = useDecorations(element, props.path, parentDecorations);
   let t0;
   $[0] !== decorations || $[1] !== element || $[2] !== props.path || $[3] !== renderElement || $[4] !== renderLeaf || $[5] !== renderText ? (t0 = {
     decorations,
@@ -2957,14 +2655,14 @@ function getTextContent(editor, path2) {
   }
   return text;
 }
-const SlateString = (props) => {
+const EngineString = (props) => {
   const $ = c(6), {
     isLast,
     leaf,
     parent,
     path: path2,
     text
-  } = props, editor = useSlateStatic(), parentPath$1 = parentPath(path2), leafText = leaf.text ?? "";
+  } = props, editor = useEngineStatic(), parentPath$1 = parentPath(path2), leafText = leaf.text ?? "";
   if (leafText === "" && isTextBlock({
     schema: editor.schema
   }, parent) && parent.children[parent.children.length - 1] === text && getTextContent(editor, parentPath$1) === "") {
@@ -3009,20 +2707,20 @@ const SlateString = (props) => {
 })), ZeroWidthString = (props) => {
   const $ = c(10), {
     isLineBreak: t0
-  } = props, isLineBreak = t0 === void 0 ? !1 : t0, isInNewPipeline = useContext(NewPipelineContext), slateValue = isLineBreak ? "n" : "z";
+  } = props, isLineBreak = t0 === void 0 ? !1 : t0, isInNewPipeline = useContext(NewPipelineContext), engineValue = isLineBreak ? "n" : "z";
   let t1;
-  $[0] !== isInNewPipeline || $[1] !== isLineBreak || $[2] !== slateValue ? (t1 = isInNewPipeline ? {
+  $[0] !== engineValue || $[1] !== isInNewPipeline || $[2] !== isLineBreak ? (t1 = isInNewPipeline ? {
     "data-pt-zero-width": !0,
     ...isLineBreak ? {
       "data-pt-line-break": !0
     } : {}
   } : {
-    "data-slate-zero-width": slateValue,
+    "data-slate-zero-width": engineValue,
     "data-pt-zero-width": !0,
     ...isLineBreak ? {
       "data-pt-line-break": !0
     } : {}
-  }, $[0] = isInNewPipeline, $[1] = isLineBreak, $[2] = slateValue, $[3] = t1) : t1 = $[3];
+  }, $[0] = engineValue, $[1] = isInNewPipeline, $[2] = isLineBreak, $[3] = t1) : t1 = $[3];
   const attributes = t1, t2 = !IS_ANDROID || !isLineBreak ? "\uFEFF" : null;
   let t3;
   $[4] !== isLineBreak ? (t3 = isLineBreak ? /* @__PURE__ */ jsx("br", {}) : null, $[4] = isLineBreak, $[5] = t3) : t3 = $[5];
@@ -3042,7 +2740,7 @@ const SlateString = (props) => {
     leafPosition
   } = props, renderLeaf = t0 === void 0 ? defaultRenderLeaf : t0, isInNewPipeline = useContext(NewPipelineContext);
   let t1;
-  $[0] !== isLast || $[1] !== leaf || $[2] !== parent || $[3] !== path2 || $[4] !== text ? (t1 = /* @__PURE__ */ jsx(SlateString, { isLast, leaf, parent, path: path2, text }), $[0] = isLast, $[1] = leaf, $[2] = parent, $[3] = path2, $[4] = text, $[5] = t1) : t1 = $[5];
+  $[0] !== isLast || $[1] !== leaf || $[2] !== parent || $[3] !== path2 || $[4] !== text ? (t1 = /* @__PURE__ */ jsx(EngineString, { isLast, leaf, parent, path: path2, text }), $[0] = isLast, $[1] = leaf, $[2] = parent, $[3] = path2, $[4] = text, $[5] = t1) : t1 = $[5];
   const children = t1;
   let t2;
   return $[6] !== children || $[7] !== isInNewPipeline || $[8] !== leaf || $[9] !== leafPosition || $[10] !== path2 || $[11] !== renderLeaf || $[12] !== text ? (t2 = renderLeaf({
@@ -3139,7 +2837,7 @@ const useChildren = (props) => {
     renderElement,
     renderText,
     renderLeaf
-  } = props, editor = useSlateStatic();
+  } = props, editor = useEngineStatic();
   editor.isNodeMapDirty = !1;
   const parentContainer = useParentContainer(), parentIsInNewPipeline = useContext(NewPipelineContext), decorationsByChild = useDecorationsByChild(editor, node, parentPath2, decorations);
   let children = [], arrayFieldName = "children", childContainer = parentContainer;
@@ -3237,14 +2935,14 @@ const useChildren = (props) => {
     throw new Error("Unexpected node type");
   });
   return childContainer && childContainer !== parentContainer ? /* @__PURE__ */ jsx(ParentContainerContext, { value: childContainer, children: /* @__PURE__ */ jsx(NewPipelineContext.Provider, { value: !0, children: elements }) }) : /* @__PURE__ */ jsx(Fragment, { children: elements });
-}, SlateSelectorContext = createContext({}), refEquality = (a, b) => a === b;
-function useSlateSelector(selector, equalityFn = refEquality) {
-  const context = useContext(SlateSelectorContext);
+}, EngineSelectorContext = createContext({}), refEquality = (a, b) => a === b;
+function useEngineSelector(selector, equalityFn = refEquality) {
+  const context = useContext(EngineSelectorContext);
   if (!context)
-    throw new Error("The `useSlateSelector` hook must be used inside the <Slate> component's context.");
+    throw new Error("The `useEngineSelector` hook must be used inside the <Engine> component's context.");
   const {
     addEventListener
-  } = context, editor = useSlateStatic(), genericSelector = useCallback(() => selector(editor), [editor, selector]), [selectedState, update] = useGenericSelector(genericSelector, equalityFn);
+  } = context, editor = useEngineStatic(), genericSelector = useCallback(() => selector(editor), [editor, selector]), [selectedState, update] = useGenericSelector(genericSelector, equalityFn);
   return useIsomorphicLayoutEffect(() => {
     const unsubscribe = addEventListener(update);
     return update(), unsubscribe;
@@ -3273,19 +2971,19 @@ function useSelectorContext() {
 function useFlushDeferredSelectorsOnRender() {
   const {
     flushDeferred
-  } = useContext(SlateSelectorContext);
+  } = useContext(EngineSelectorContext);
   useIsomorphicLayoutEffect(flushDeferred);
 }
-const useSlate = () => {
+const useEngine = () => {
   const {
     addEventListener
-  } = useContext(SlateSelectorContext), [, forceRender] = useReducer((s) => s + 1, 0);
+  } = useContext(EngineSelectorContext), [, forceRender] = useReducer((s) => s + 1, 0);
   if (!addEventListener)
-    throw new Error("The `useSlate` hook must be used inside the <Slate> component's context.");
-  return useIsomorphicLayoutEffect(() => addEventListener(forceRender), [addEventListener]), useSlateStatic();
+    throw new Error("The `useEngine` hook must be used inside the <Engine> component's context.");
+  return useIsomorphicLayoutEffect(() => addEventListener(forceRender), [addEventListener]), useEngineStatic();
 };
 function useTrackUserInput() {
-  const editor = useSlateStatic(), receivedUserInput = useRef(!1), animationFrameIdRef = useRef(0), onUserInput = useCallback(() => {
+  const editor = useEngineStatic(), receivedUserInput = useRef(!1), animationFrameIdRef = useRef(0), onUserInput = useCallback(() => {
     if (receivedUserInput.current)
       return;
     receivedUserInput.current = !0;
@@ -3423,7 +3121,7 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
     scrollSelectionIntoView = defaultScrollSelectionIntoView,
     style: userStyle = {},
     ...attributes
-  } = props, editor = useSlate(), ref = useRef(null), deferredOperations = useRef([]), processing = useRef(!1), {
+  } = props, editor = useEngine(), ref = useRef(null), deferredOperations = useRef([]), processing = useRef(!1), {
     onUserInput,
     receivedUserInput
   } = useTrackUserInput(), [, forceRender] = useReducer((s) => s + 1, 0);
@@ -3469,7 +3167,7 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
         focusNode
       } = domSelection, anchorNodeSelectable = DOMEditor.hasEditableTarget(editor, anchorNode) || DOMEditor.isTargetInsideNonReadonlyVoid(editor, anchorNode), focusNodeInEditor = DOMEditor.hasTarget(editor, focusNode);
       if (anchorNodeSelectable && focusNodeInEditor) {
-        const range2 = DOMEditor.toSlateRange(editor, domSelection, {
+        const range2 = DOMEditor.toEditorSelection(editor, domSelection, {
           exactMatch: !1,
           suppressThrow: !0
         });
@@ -3505,17 +3203,17 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
       const editorElement = editor.domElement;
       let hasDomSelectionInEditor = !1;
       if (containsShadowAware(editorElement, anchorNode) && containsShadowAware(editorElement, focusNode) && (hasDomSelectionInEditor = !0), hasDomSelection && hasDomSelectionInEditor && selection && !forceChange) {
-        const slateRange = DOMEditor.toSlateRange(editor, domSelection, {
+        const editorSelection = DOMEditor.toEditorSelection(editor, domSelection, {
           exactMatch: !0,
-          // domSelection is not necessarily a valid Slate range
+          // domSelection is not necessarily a valid range
           // (e.g. when clicking on contentEditable:false element)
           suppressThrow: !0
         });
-        if (slateRange && rangeEquals(slateRange, selection))
+        if (editorSelection && rangeEquals(editorSelection, selection))
           return;
       }
       if (selection && !DOMEditor.hasRange(editor, selection)) {
-        const fallbackRange = DOMEditor.toSlateRange(editor, domSelection, {
+        const fallbackRange = DOMEditor.toEditorSelection(editor, domSelection, {
           exactMatch: !1,
           suppressThrow: !0
         });
@@ -3571,11 +3269,11 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
     if (processing?.current && IS_WEBKIT && root instanceof ShadowRoot) {
       const range2 = event.getTargetRanges()[0], newRange = new window.Range();
       newRange.setStart(range2.startContainer, range2.startOffset), newRange.setEnd(range2.endContainer, range2.endOffset);
-      const slateRange = DOMEditor.toSlateRange(editor, newRange, {
+      const editorSelection = DOMEditor.toEditorSelection(editor, newRange, {
         exactMatch: !1,
         suppressThrow: !1
       });
-      editor.select(slateRange), event.preventDefault(), event.stopImmediatePropagation();
+      editor.select(editorSelection), event.preventDefault(), event.stopImmediatePropagation();
       return;
     }
     if (onUserInput(), !readOnly && DOMEditor.hasEditableTarget(editor, event.target) && !isDOMEventHandled(event, propsOnDOMBeforeInput)) {
@@ -3612,7 +3310,7 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
       if ((!type.startsWith("delete") || type.startsWith("deleteBy")) && !editor.isNodeMapDirty) {
         const [targetRange2] = event.getTargetRanges();
         if (targetRange2) {
-          const range2 = DOMEditor.toSlateRange(editor, targetRange2, {
+          const range2 = DOMEditor.toEditorSelection(editor, targetRange2, {
             exactMatch: !1,
             suppressThrow: !1
           });
@@ -4212,57 +3910,360 @@ const RestoreDOM = IS_ANDROID ? RestoreDOMComponent : ({
             }
           }
         }
-      }, [readOnly, editor, editorActor, attributes.onKeyDown]),
-      onPaste: useCallback((event) => {
-        !readOnly && DOMEditor.hasEditableTarget(editor, event.target) && !isEventHandled(event, attributes.onPaste) && (!HAS_BEFORE_INPUT_SUPPORT || isPlainTextOnlyPaste(event.nativeEvent) || IS_WEBKIT) && (event.preventDefault(), editorActor.send({
-          type: "behavior event",
-          behaviorEvent: {
-            type: "input.*",
-            originEvent: {
-              dataTransfer: event.clipboardData
-            }
-          },
-          editor
-        }));
-      }, [readOnly, editor, editorActor, attributes.onPaste]),
-      children: /* @__PURE__ */ jsx(Children, { decorations, node: editor, path: [], renderElement, renderLeaf, renderText })
-    }
-  ) }) }) });
-}), defaultDecorate = () => [], defaultScrollSelectionIntoView = (editor, domRange) => {
-  const isBackward = !!editor.selection && isBackwardRange(editor.selection, editor), domFocusPoint = domRange.cloneRange();
-  if (domFocusPoint.collapse(isBackward), domFocusPoint.getBoundingClientRect) {
-    const leafEl = domFocusPoint.startContainer.parentElement, domRect = domFocusPoint.getBoundingClientRect();
-    if (domRect.width === 0 && domRect.height === 0 && domRect.x === 0 && domRect.y === 0) {
-      const leafRect = leafEl.getBoundingClientRect();
-      if (leafRect.width > 0 || leafRect.height > 0)
-        return;
+      }, [readOnly, editor, editorActor, attributes.onKeyDown]),
+      onPaste: useCallback((event) => {
+        !readOnly && DOMEditor.hasEditableTarget(editor, event.target) && !isEventHandled(event, attributes.onPaste) && (!HAS_BEFORE_INPUT_SUPPORT || isPlainTextOnlyPaste(event.nativeEvent) || IS_WEBKIT) && (event.preventDefault(), editorActor.send({
+          type: "behavior event",
+          behaviorEvent: {
+            type: "input.*",
+            originEvent: {
+              dataTransfer: event.clipboardData
+            }
+          },
+          editor
+        }));
+      }, [readOnly, editor, editorActor, attributes.onPaste]),
+      children: /* @__PURE__ */ jsx(Children, { decorations, node: editor, path: [], renderElement, renderLeaf, renderText })
+    }
+  ) }) }) });
+}), defaultDecorate = () => [], defaultScrollSelectionIntoView = (editor, domRange) => {
+  const isBackward = !!editor.selection && isBackwardRange(editor.selection, editor), domFocusPoint = domRange.cloneRange();
+  if (domFocusPoint.collapse(isBackward), domFocusPoint.getBoundingClientRect) {
+    const leafEl = domFocusPoint.startContainer.parentElement, domRect = domFocusPoint.getBoundingClientRect();
+    if (domRect.width === 0 && domRect.height === 0 && domRect.x === 0 && domRect.y === 0) {
+      const leafRect = leafEl.getBoundingClientRect();
+      if (leafRect.width > 0 || leafRect.height > 0)
+        return;
+    }
+    leafEl.getBoundingClientRect = domFocusPoint.getBoundingClientRect.bind(domFocusPoint), scrollIntoView(leafEl, {
+      scrollMode: "if-needed"
+    }), delete leafEl.getBoundingClientRect;
+  }
+}, isEventHandled = (event, handler) => handler ? handler(event) ?? (event.isDefaultPrevented() || event.isPropagationStopped()) : !1, isDOMEventTargetInput = (event) => isDOMNode(event.target) && (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement), isDOMEventHandled = (event, handler) => handler ? handler(event) ?? event.defaultPrevented : !1, handleNativeHistoryEvents = (editor, editorActor, event) => {
+  if (event.inputType === "historyUndo") {
+    editorActor.send({
+      type: "behavior event",
+      behaviorEvent: {
+        type: "history.undo"
+      },
+      editor
+    });
+    return;
+  }
+  if (event.inputType === "historyRedo") {
+    editorActor.send({
+      type: "behavior event",
+      behaviorEvent: {
+        type: "history.redo"
+      },
+      editor
+    });
+    return;
+  }
+};
+function resolveSelection(editor, selection) {
+  if (!selection)
+    return null;
+  if (isEqualSelectionPoints(selection.anchor, selection.focus)) {
+    const anchorPoint2 = resolveSelectionPoint(editor, selection.anchor, selection.backward ? "backward" : "forward");
+    return anchorPoint2 ? {
+      anchor: anchorPoint2,
+      focus: anchorPoint2
+    } : null;
+  }
+  const anchorPoint = resolveSelectionPoint(editor, selection.anchor, selection.backward ? "forward" : "backward"), focusPoint = resolveSelectionPoint(editor, selection.focus, selection.backward ? "backward" : "forward");
+  return !anchorPoint || !focusPoint ? null : {
+    anchor: anchorPoint,
+    focus: focusPoint
+  };
+}
+function resolveSelectionPoint(editor, selectionPoint, direction) {
+  const snapshot = {
+    context: {
+      schema: editor.schema,
+      containers: editor.publicContainers,
+      value: editor.children
+    },
+    blockIndexMap: editor.blockIndexMap
+  }, entry = getNode(snapshot, selectionPoint.path);
+  if (entry) {
+    if (getChildren(snapshot, entry.path).length === 0)
+      return {
+        path: entry.path,
+        offset: isSpan({
+          schema: editor.schema
+        }, entry.node) ? Math.min(entry.node.text.length, selectionPoint.offset) : 0
+      };
+    const isBlockLevelPath = isBlock(snapshot, selectionPoint.path);
+    if (isTextBlock({
+      schema: editor.schema
+    }, entry.node) && isBlockLevelPath) {
+      const spanPoint = blockOffsetToSpanSelectionPoint({
+        snapshot,
+        blockOffset: {
+          path: entry.path,
+          offset: selectionPoint.offset
+        },
+        direction
+      });
+      if (spanPoint)
+        return spanPoint;
+    }
+    const leaf2 = getLeaf(snapshot, entry.path, {
+      edge: direction === "forward" ? "start" : "end"
+    });
+    return leaf2 ? {
+      path: leaf2.path,
+      offset: 0
+    } : {
+      path: entry.path,
+      offset: 0
+    };
+  }
+  const blockKey = getBlockKeyFromSelectionPoint(selectionPoint);
+  if (!blockKey)
+    return;
+  const blockEntry = getNode(snapshot, [{
+    _key: blockKey
+  }]);
+  if (!blockEntry)
+    return;
+  const leaf = getLeaf(snapshot, blockEntry.path, {
+    edge: "start"
+  });
+  return leaf ? {
+    path: leaf.path,
+    offset: 0
+  } : {
+    path: blockEntry.path,
+    offset: 0
+  };
+}
+function applySelect(editor, target) {
+  const range2 = toRange(editor, target), {
+    selection
+  } = editor;
+  if (selection) {
+    const oldProps = {}, newProps = {};
+    range2.anchor != null && !pointEquals(range2.anchor, selection.anchor) && (oldProps.anchor = selection.anchor, newProps.anchor = range2.anchor), range2.focus != null && !pointEquals(range2.focus, selection.focus) && (oldProps.focus = selection.focus, newProps.focus = range2.focus), Object.keys(oldProps).length > 0 && editor.apply({
+      type: "set_selection",
+      properties: oldProps,
+      newProperties: newProps
+    });
+  } else
+    editor.apply({
+      type: "set_selection",
+      properties: null,
+      newProperties: range2
+    });
+}
+function applyDeselect(editor) {
+  const {
+    selection
+  } = editor;
+  selection && editor.apply({
+    type: "set_selection",
+    properties: selection,
+    newProperties: null
+  });
+}
+function toRange(editor, target) {
+  if (isRange(target))
+    return target;
+  if (isPoint(target))
+    return {
+      anchor: target,
+      focus: target
+    };
+  const start$1 = start(editor, target), end$1 = end(editor, target);
+  return {
+    anchor: start$1,
+    focus: end$1
+  };
+}
+const rootName = "pte:";
+function createDebugger(name) {
+  const namespace = `${rootName}${name}`;
+  return rawDebug && rawDebug.enabled(namespace) ? rawDebug(namespace) : rawDebug(rootName);
+}
+const debug = {
+  behaviors: createDebugger("behaviors"),
+  history: createDebugger("history"),
+  mutation: createDebugger("mutation"),
+  normalization: createDebugger("normalization"),
+  operation: createDebugger("operation"),
+  selection: createDebugger("selection"),
+  setup: createDebugger("setup"),
+  state: createDebugger("state"),
+  syncValue: createDebugger("sync:value"),
+  syncPatch: createDebugger("sync:patch")
+};
+function getEventPosition({
+  editorActor,
+  editorEngine,
+  event
+}) {
+  if (editorActor.getSnapshot().matches({
+    setup: "setting up"
+  }))
+    return;
+  const eventResult = getEventNode({
+    editorEngine,
+    event
+  });
+  if (!eventResult)
+    return;
+  const {
+    node: eventNode,
+    path: eventPath
+  } = eventResult, eventBlockEntry = getEnclosingBlock(editorEngine, eventPath), eventBlock = eventBlockEntry?.node, eventBlockPath = eventBlockEntry?.path, eventPositionBlock = getEventPositionBlock({
+    nodePath: eventPath,
+    editorEngine,
+    event
+  }), eventSelection = getSelectionFromEvent(editorEngine, event) ?? null;
+  if (eventBlock && eventBlockPath && eventPositionBlock && !eventSelection && !isEventContainer(editorEngine, eventNode, eventPath))
+    return {
+      block: eventPositionBlock,
+      isEditor: !1,
+      isContainer: !1,
+      selection: {
+        anchor: getBlockStartPoint({
+          context: editorEngine,
+          block: {
+            node: eventBlock,
+            path: eventBlockPath
+          }
+        }),
+        focus: getBlockEndPoint({
+          context: editorEngine,
+          block: {
+            node: eventBlock,
+            path: eventBlockPath
+          }
+        })
+      }
+    };
+  if (!eventPositionBlock || !eventSelection)
+    return;
+  const eventSelectionFocusBlock = getEnclosingBlock(editorEngine, eventSelection.focus.path);
+  if (eventSelectionFocusBlock)
+    return isSelectionCollapsed(eventSelection) && eventBlock && eventBlockPath && eventSelectionFocusBlock.node._key !== eventBlock._key && !isAncestorPath(eventBlockPath, eventSelectionFocusBlock.path) ? {
+      block: eventPositionBlock,
+      isEditor: !1,
+      isContainer: !1,
+      selection: {
+        anchor: getBlockStartPoint({
+          context: editorEngine,
+          block: {
+            node: eventBlock,
+            path: eventBlockPath
+          }
+        }),
+        focus: getBlockEndPoint({
+          context: editorEngine,
+          block: {
+            node: eventBlock,
+            path: eventBlockPath
+          }
+        })
+      }
+    } : {
+      block: eventPositionBlock,
+      isEditor: isEditor(eventNode),
+      isContainer: isEditor(eventNode) ? !1 : isEditableContainer(editorEngine, eventNode, eventPath),
+      selection: eventSelection
+    };
+}
+function getEventNode({
+  editorEngine,
+  event
+}) {
+  if (DOMEditor.hasTarget(editorEngine, event.target))
+    try {
+      const path2 = getDomNodePath(event.target);
+      if (path2) {
+        if (path2.length === 0)
+          return {
+            node: editorEngine,
+            path: path2
+          };
+        {
+          const nodeEntry = getNode(editorEngine, path2);
+          if (nodeEntry)
+            return {
+              node: nodeEntry.node,
+              path: path2
+            };
+        }
+      }
+    } catch (error) {
+      console.error(error);
     }
-    leafEl.getBoundingClientRect = domFocusPoint.getBoundingClientRect.bind(domFocusPoint), scrollIntoView(leafEl, {
-      scrollMode: "if-needed"
-    }), delete leafEl.getBoundingClientRect;
-  }
-}, isEventHandled = (event, handler) => handler ? handler(event) ?? (event.isDefaultPrevented() || event.isPropagationStopped()) : !1, isDOMEventTargetInput = (event) => isDOMNode(event.target) && (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement), isDOMEventHandled = (event, handler) => handler ? handler(event) ?? event.defaultPrevented : !1, handleNativeHistoryEvents = (editor, editorActor, event) => {
-  if (event.inputType === "historyUndo") {
-    editorActor.send({
-      type: "behavior event",
-      behaviorEvent: {
-        type: "history.undo"
-      },
-      editor
-    });
+}
+function getEventPositionBlock({
+  nodePath,
+  editorEngine,
+  event
+}) {
+  const firstBlockEntry = getNode(editorEngine, [0]);
+  if (!firstBlockEntry)
     return;
-  }
-  if (event.inputType === "historyRedo") {
-    editorActor.send({
-      type: "behavior event",
-      behaviorEvent: {
-        type: "history.redo"
-      },
-      editor
-    });
+  const firstBlockElement = getDomNode(editorEngine, firstBlockEntry.path);
+  if (!firstBlockElement)
+    return;
+  const firstBlockRect = firstBlockElement.getBoundingClientRect();
+  if (event.pageY < firstBlockRect.top)
+    return "start";
+  const lastBlock = editorEngine.children.at(-1), lastBlockEntry = lastBlock ? getNode(editorEngine, [{
+    _key: lastBlock._key
+  }]) : void 0;
+  if (!lastBlockEntry)
+    return;
+  const lastBlockElement = getDomNode(editorEngine, lastBlockEntry.path);
+  if (!lastBlockElement)
+    return;
+  const lastBlockRef = lastBlockElement.getBoundingClientRect();
+  if (event.pageY > lastBlockRef.bottom)
+    return "end";
+  const element = getDomNode(editorEngine, nodePath);
+  if (!element)
+    return;
+  const elementRect = element.getBoundingClientRect(), top = elementRect.top, height = elementRect.height;
+  return Math.abs(top - event.pageY) < height / 2 ? "start" : "end";
+}
+function getSelectionFromEvent(editor, event) {
+  if (!event.target || !isDOMNode(event.target))
+    return;
+  const window2 = DOMEditor.getWindow(editor);
+  let domRange;
+  if (window2.document.caretPositionFromPoint !== void 0) {
+    const position = window2.document.caretPositionFromPoint(event.clientX, event.clientY);
+    if (position)
+      try {
+        domRange = window2.document.createRange(), domRange.setStart(position.offsetNode, position.offset), domRange.setEnd(position.offsetNode, position.offset);
+      } catch {
+      }
+  } else if (window2.document.caretRangeFromPoint !== void 0)
+    domRange = window2.document.caretRangeFromPoint(event.clientX, event.clientY) ?? void 0;
+  else {
+    console.warn("Neither caretPositionFromPoint nor caretRangeFromPoint is supported");
     return;
   }
-}, EditorActorContext = createContext({}), IS_MAC = typeof window < "u" && /Mac|iPod|iPhone|iPad/.test(window.navigator.userAgent), modifiers = {
+  if (domRange)
+    try {
+      return DOMEditor.toEditorSelection(editor, domRange, {
+        exactMatch: !1,
+        // It can still throw even with this option set to true
+        suppressThrow: !1
+      });
+    } catch {
+      return;
+    }
+}
+function isEventContainer(editorEngine, eventNode, eventPath) {
+  return isEditor(eventNode) ? !0 : isEditableContainer(editorEngine, eventNode, eventPath);
+}
+const EditorActorContext = createContext({}), IS_MAC = typeof window < "u" && /Mac|iPod|iPhone|iPad/.test(window.navigator.userAgent), modifiers = {
   alt: "altKey",
   control: "ctrlKey",
   meta: "metaKey",
@@ -4419,13 +4420,6 @@ function performHotkey({
       }
   });
 }
-function moveRangeByOperation(range2, operation) {
-  const anchor = transformPoint$1(range2.anchor, operation), focus = transformPoint$1(range2.focus, operation);
-  return anchor === null || focus === null ? null : pointEquals(anchor, range2.anchor) && pointEquals(focus, range2.focus) ? range2 : {
-    anchor,
-    focus
-  };
-}
 function rangeIncludes(range2, target, root) {
   if (isRange(target)) {
     if (rangeIncludes(range2, target.anchor, root) || rangeIncludes(range2, target.focus, root))
@@ -4437,18 +4431,25 @@ function rangeIncludes(range2, target, root) {
   let isAfterStart = !1, isBeforeEnd = !1;
   return isPoint(target) ? (isAfterStart = comparePoints(target, start2, root) >= 0, isBeforeEnd = comparePoints(target, end2, root) <= 0) : (isAfterStart = comparePaths(target, start2.path, root) >= 0, isBeforeEnd = comparePaths(target, end2.path, root) <= 0), isAfterStart && isBeforeEnd;
 }
-const slateOperationCallback = ({
+function moveRangeByOperation(range2, operation) {
+  const anchor = transformPoint$1(range2.anchor, operation), focus = transformPoint$1(range2.focus, operation);
+  return anchor === null || focus === null ? null : pointEquals(anchor, range2.anchor) && pointEquals(focus, range2.focus) ? range2 : {
+    anchor,
+    focus
+  };
+}
+const engineOperationCallback = ({
   input,
   sendBack
 }) => {
-  const originalApply = input.slateEditor.apply;
-  return input.slateEditor.apply = (op) => {
+  const originalApply = input.editorEngine.apply;
+  return input.editorEngine.apply = (op) => {
     op.type !== "set_selection" && sendBack({
-      type: "slate operation",
+      type: "engine operation",
       operation: op
     }), originalApply(op);
   }, () => {
-    input.slateEditor.apply = originalApply;
+    input.editorEngine.apply = originalApply;
   };
 }, rangeDecorationsMachine = setup({
   types: {
@@ -4481,7 +4482,7 @@ const slateOperationCallback = ({
           ...rangeDecoration.selection
         });
       }
-      context.slateEditor.decoratedRanges = rangeDecorationState;
+      context.editorEngine.decoratedRanges = rangeDecorationState;
     },
     "update range decorations": ({
       context,
@@ -4504,16 +4505,16 @@ const slateOperationCallback = ({
           ...rangeDecoration.selection
         });
       }
-      context.slateEditor.decoratedRanges = rangeDecorationState;
+      context.editorEngine.decoratedRanges = rangeDecorationState;
     },
     "move range decorations": ({
       context,
       event
     }) => {
-      if (event.type !== "slate operation")
+      if (event.type !== "engine operation")
         return;
       const rangeDecorationState = [];
-      for (const decoratedRange of context.slateEditor.decoratedRanges) {
+      for (const decoratedRange of context.editorEngine.decoratedRanges) {
         const currentSelection = decoratedRange.rangeDecoration.selection;
         if (!currentSelection) {
           decoratedRange.rangeDecoration.onMoved?.({
@@ -4536,7 +4537,7 @@ const slateOperationCallback = ({
           }
         });
       }
-      context.slateEditor.decoratedRanges = rangeDecorationState;
+      context.editorEngine.decoratedRanges = rangeDecorationState;
     },
     "assign readOnly": assign({
       readOnly: ({
@@ -4548,12 +4549,12 @@ const slateOperationCallback = ({
       decorate: ({
         context
       }) => ({
-        fn: createDecorate(context.schema, context.slateEditor)
+        fn: createDecorate(context.schema, context.editorEngine)
       })
     })
   },
   actors: {
-    "slate operation listener": fromCallback(slateOperationCallback)
+    "engine operation listener": fromCallback(engineOperationCallback)
   },
   guards: {
     "has pending range decorations": ({
@@ -4561,14 +4562,14 @@ const slateOperationCallback = ({
     }) => context.pendingRangeDecorations.length > 0,
     "has range decorations": ({
       context
-    }) => context.slateEditor.decoratedRanges.length > 0,
+    }) => context.editorEngine.decoratedRanges.length > 0,
     "has different decorations": ({
       context,
       event
     }) => {
       if (event.type !== "range decorations updated")
         return !1;
-      const existingRangeDecorations = context.slateEditor.decoratedRanges.map((decoratedRange) => ({
+      const existingRangeDecorations = context.editorEngine.decoratedRanges.map((decoratedRange) => ({
         anchor: decoratedRange.rangeDecoration.selection?.anchor,
         focus: decoratedRange.rangeDecoration.selection?.focus,
         payload: decoratedRange.rangeDecoration.payload
@@ -4596,17 +4597,17 @@ const slateOperationCallback = ({
     decoratedRanges: [],
     skipSetup: input.skipSetup,
     schema: input.schema,
-    slateEditor: input.slateEditor,
+    editorEngine: input.editorEngine,
     decorate: {
-      fn: createDecorate(input.schema, input.slateEditor)
+      fn: createDecorate(input.schema, input.editorEngine)
     }
   }),
   invoke: {
-    src: "slate operation listener",
+    src: "engine operation listener",
     input: ({
       context
     }) => ({
-      slateEditor: context.slateEditor
+      editorEngine: context.editorEngine
     })
   },
   on: {
@@ -4650,7 +4651,7 @@ const slateOperationCallback = ({
       states: {
         idle: {
           on: {
-            "slate operation": {
+            "engine operation": {
               target: "moving range decorations",
               guard: and(["has range decorations", "not read only"])
             }
@@ -4666,10 +4667,10 @@ const slateOperationCallback = ({
     }
   }
 });
-function createDecorate(schema, slateEditor) {
+function createDecorate(schema, editorEngine) {
   return function([node, path2]) {
-    const defaultStyle = schema.styles.at(0)?.name, firstBlock = slateEditor.children[0];
-    return slateEditor.children.length === 1 && firstBlock && isEmptyTextBlock({
+    const defaultStyle = schema.styles.at(0)?.name, firstBlock = editorEngine.children[0];
+    return editorEngine.children.length === 1 && firstBlock && isEmptyTextBlock({
       schema
     }, firstBlock) && (!firstBlock.style || firstBlock.style === defaultStyle) && !firstBlock.listItem ? [{
       anchor: {
@@ -4682,10 +4683,10 @@ function createDecorate(schema, slateEditor) {
       },
       placeholder: !0
     }] : path2.length === 0 ? [] : !isTextBlock({
-      schema: slateEditor.schema
-    }, node) || node.children.length === 0 ? [] : slateEditor.decoratedRanges.filter((decoratedRange) => {
+      schema: editorEngine.schema
+    }, node) || node.children.length === 0 ? [] : editorEngine.decoratedRanges.filter((decoratedRange) => {
       if (isCollapsedRange(decoratedRange)) {
-        const anchorBlock = getEnclosingBlock(slateEditor, decoratedRange.anchor.path), anchorChildSegment = decoratedRange.anchor.path.at(-1);
+        const anchorBlock = getEnclosingBlock(editorEngine, decoratedRange.anchor.path), anchorChildSegment = decoratedRange.anchor.path.at(-1);
         return !anchorBlock || !isKeyedSegment(anchorChildSegment) ? !1 : anchorBlock.node._key === node._key && node.children.some((child) => child._key === anchorChildSegment._key);
       }
       return rangeIntersection(decoratedRange, {
@@ -4697,7 +4698,7 @@ function createDecorate(schema, slateEditor) {
           path: path2,
           offset: 0
         }
-      }, slateEditor) || rangeIncludes(decoratedRange, path2, slateEditor);
+      }, editorEngine) || rangeIncludes(decoratedRange, path2, editorEngine);
     });
   };
 }
@@ -4797,22 +4798,22 @@ function useEditorSelector(editor, selector, t0) {
 }
 function getEditorSnapshot({
   editorActorSnapshot,
-  slateEditorInstance
+  editorEngineInstance
 }) {
   return {
-    blockIndexMap: slateEditorInstance.blockIndexMap,
+    blockIndexMap: editorEngineInstance.blockIndexMap,
     context: {
-      containers: slateEditorInstance.publicContainers,
+      containers: editorEngineInstance.publicContainers,
       converters: editorActorSnapshot.context.converters,
       keyGenerator: editorActorSnapshot.context.keyGenerator,
       readOnly: editorActorSnapshot.matches({
         "edit mode": "read only"
       }),
       schema: editorActorSnapshot.context.schema,
-      selection: slateEditorInstance.selection,
-      value: slateEditorInstance.children
+      selection: editorEngineInstance.selection,
+      value: editorEngineInstance.children
     },
-    decoratorState: slateEditorInstance.decoratorState
+    decoratorState: editorEngineInstance.decoratorState
   };
 }
 const emptySet$1 = /* @__PURE__ */ new Set(), emptyState = {
@@ -4891,12 +4892,12 @@ const defaultStore = {
 function SelectionStateProvider(t0) {
   const $ = c(10), {
     children
-  } = t0, editorActor = useContext(EditorActorContext), slateEditor = useSlateStatic();
+  } = t0, editorActor = useContext(EditorActorContext), editorEngine = useEngineStatic();
   let t1;
-  $[0] !== editorActor || $[1] !== slateEditor ? (t1 = () => {
+  $[0] !== editorActor || $[1] !== editorEngine ? (t1 = () => {
     const actorSnapshot = editorActor.getSnapshot(), snapshot = getEditorSnapshot({
       editorActorSnapshot: actorSnapshot,
-      slateEditorInstance: slateEditor
+      editorEngineInstance: editorEngine
     }), selection = snapshot.context.selection ? {
       anchorPath: snapshot.context.selection.anchor.path,
       focusPath: snapshot.context.selection.focus.path,
@@ -4906,12 +4907,12 @@ function SelectionStateProvider(t0) {
     return getSelectionState({
       context: {
         schema: snapshot.context.schema,
-        containers: slateEditor.publicContainers,
+        containers: editorEngine.publicContainers,
         value: snapshot.context.value
       },
-      blockIndexMap: slateEditor.blockIndexMap
+      blockIndexMap: editorEngine.blockIndexMap
     }, selection);
-  }, $[0] = editorActor, $[1] = slateEditor, $[2] = t1) : t1 = $[2];
+  }, $[0] = editorActor, $[1] = editorEngine, $[2] = t1) : t1 = $[2];
   const computeCurrent = t1, [seed] = useState(computeCurrent), stateRef = useRef(seed), [initialSubscribers] = useState(_temp$2), subscribersRef = useRef(initialSubscribers);
   let t2, t3;
   $[3] !== computeCurrent || $[4] !== editorActor ? (t2 = () => {
@@ -5095,7 +5096,7 @@ function RenderContainer(props) {
   return t2;
 }
 function useBlockSubSchema(path2) {
-  const $ = c(3), editor = useSlateStatic();
+  const $ = c(3), editor = useEngineStatic();
   let t0;
   return $[0] !== editor || $[1] !== path2 ? (t0 = getPathSubSchema(editor, path2), $[0] = editor, $[1] = path2, $[2] = t0) : t0 = $[2], t0;
 }
@@ -5206,7 +5207,7 @@ function RenderTextBlock(props) {
   const serializedPath = t2, selected = useIsSelectedContainer(serializedPath), focused = useIsFocusedContainer(serializedPath);
   let t3;
   $[7] !== props.textBlock._key ? (t3 = (editor) => editor.listIndexMap.get(props.textBlock._key), $[7] = props.textBlock._key, $[8] = t3) : t3 = $[8];
-  const listIndex = useSlateSelector(t3), subSchema = useBlockSubSchema(props.path);
+  const listIndex = useEngineSelector(t3), subSchema = useBlockSubSchema(props.path);
   let children = props.children;
   if (props.legacy.renderStyle && props.textBlock.style) {
     let t42;
@@ -5367,7 +5368,7 @@ function tupleRefEqual(previous, next) {
   return !0;
 }
 function RenderElement(props) {
-  const $ = c(84), editorActor = useContext(EditorActorContext), parentContainer = useContext(ParentContainerContext), parentTextBlock = useContext(ParentTextBlockContext), isInNewPipeline = useContext(NewPipelineContext), slateStatic = useSlateStatic(), schema = props.schema, type = props.element._type;
+  const $ = c(84), editorActor = useContext(EditorActorContext), parentContainer = useContext(ParentContainerContext), parentTextBlock = useContext(ParentTextBlockContext), isInNewPipeline = useContext(NewPipelineContext), engineStatic = useEngineStatic(), schema = props.schema, type = props.element._type;
   let t0;
   $[0] !== parentContainer || $[1] !== type ? (t0 = findBlockPositionalOverride(parentContainer, type), $[0] = parentContainer, $[1] = type, $[2] = t0) : t0 = $[2];
   const blockPositionalOverride = t0;
@@ -5490,7 +5491,7 @@ function RenderElement(props) {
     }
     return rendered;
   }
-  if (isInline(slateStatic, props.path)) {
+  if (isInline(engineStatic, props.path)) {
     if (isInNewPipeline && !inlineObjectConfig) {
       let rest_0;
       if ($[44] !== props.attributes) {
@@ -5960,19 +5961,19 @@ const PortableTextEditorContext = createContext(null), usePortableTextEditor = (
   guards: {
     "pending operations": ({
       context
-    }) => context.slateEditor.operations.length > 0
+    }) => context.editorEngine.operations.length > 0
   }
 }), validateSelectionAction = validateSelectionSetup.createAction(({
   context,
   event
 }) => {
-  validateSelection(context.slateEditor, event.editorElement);
+  validateSelection(context.editorEngine, event.editorElement);
 }), validateSelectionMachine = validateSelectionSetup.createMachine({
   id: "validate selection",
   context: ({
     input
   }) => ({
-    slateEditor: input.slateEditor
+    editorEngine: input.editorEngine
   }),
   initial: "idle",
   states: {
@@ -6007,25 +6008,25 @@ const PortableTextEditorContext = createContext(null), usePortableTextEditor = (
     }
   }
 });
-function validateSelection(slateEditor, editorElement) {
-  if (!slateEditor.selection)
+function validateSelection(editorEngine, editorElement) {
+  if (!editorEngine.selection)
     return;
   let root;
   try {
-    root = DOMEditor.findDocumentOrShadowRoot(slateEditor);
+    root = DOMEditor.findDocumentOrShadowRoot(editorEngine);
   } catch {
   }
   if (!root || editorElement !== root.activeElement)
     return;
-  const domSelection = DOMEditor.getWindow(slateEditor).getSelection();
+  const domSelection = DOMEditor.getWindow(editorEngine).getSelection();
   if (!domSelection || domSelection.rangeCount === 0)
     return;
   const existingDOMRange = domSelection.getRangeAt(0);
   try {
-    const newDOMRange = DOMEditor.toDOMRange(slateEditor, slateEditor.selection);
+    const newDOMRange = DOMEditor.toDOMRange(editorEngine, editorEngine.selection);
     (newDOMRange.startOffset !== existingDOMRange.startOffset || newDOMRange.endOffset !== existingDOMRange.endOffset) && (debug.selection("DOM range out of sync, validating selection"), domSelection?.removeAllRanges(), domSelection.addRange(newDOMRange));
   } catch {
-    debug.selection("Could not resolve selection, selecting top document"), applyDeselect(slateEditor), slateEditor.children.length > 0 && applySelect(slateEditor, start(slateEditor, [])), slateEditor.onChange();
+    debug.selection("Could not resolve selection, selecting top document"), applyDeselect(editorEngine), editorEngine.children.length > 0 && applySelect(editorEngine, start(editorEngine, [])), editorEngine.onChange();
   }
 }
 const PortableTextEditable = forwardRef(function(props, forwardedRef) {
@@ -6062,13 +6063,13 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
   const portableTextEditor = usePortableTextEditor(), [hasInvalidValue, setHasInvalidValue] = useState(!1), editorActor = useContext(EditorActorContext), relayActor = useContext(RelayActorContext);
   let t0;
   $[27] !== editorActor ? (t0 = editorActor.getSnapshot(), $[27] = editorActor, $[28] = t0) : t0 = $[28];
-  const schema = t0.context.schema, readOnly = useSelector(editorActor, _temp), slateEditor = useSlate();
+  const schema = t0.context.schema, readOnly = useSelector(editorActor, _temp), editorEngine = useEngine();
   let t1;
-  $[29] !== slateEditor ? (t1 = {
+  $[29] !== editorEngine ? (t1 = {
     input: {
-      slateEditor
+      editorEngine
     }
-  }, $[29] = slateEditor, $[30] = t1) : t1 = $[30];
+  }, $[29] = editorEngine, $[30] = t1) : t1 = $[30];
   const validateSelectionActor = useActorRef(validateSelectionMachine, t1);
   let t2;
   $[31] !== rangeDecorations ? (t2 = rangeDecorations ?? [], $[31] = rangeDecorations, $[32] = t2) : t2 = $[32];
@@ -6078,15 +6079,15 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
   }), $[33] = editorActor, $[34] = t3) : t3 = $[34];
   const t4 = !t3;
   let t5;
-  $[35] !== readOnly || $[36] !== schema || $[37] !== slateEditor || $[38] !== t2 || $[39] !== t4 ? (t5 = {
+  $[35] !== editorEngine || $[36] !== readOnly || $[37] !== schema || $[38] !== t2 || $[39] !== t4 ? (t5 = {
     input: {
       rangeDecorations: t2,
       readOnly,
       schema,
-      slateEditor,
+      editorEngine,
       skipSetup: t4
     }
-  }, $[35] = readOnly, $[36] = schema, $[37] = slateEditor, $[38] = t2, $[39] = t4, $[40] = t5) : t5 = $[40];
+  }, $[35] = editorEngine, $[36] = readOnly, $[37] = schema, $[38] = t2, $[39] = t4, $[40] = t5) : t5 = $[40];
   const rangeDecorationsActor = useActorRef(rangeDecorationsMachine, t5), decorate = useSelector(rangeDecorationsActor, _temp2), dropPosition = useDropPosition();
   let t6, t7;
   $[41] !== rangeDecorationsActor || $[42] !== readOnly ? (t6 = () => {
@@ -6117,16 +6118,16 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
   $[59] !== readOnly || $[60] !== renderAnnotation || $[61] !== renderChild || $[62] !== renderDecorator || $[63] !== renderPlaceholder || $[64] !== schema ? (t12 = (leafProps) => /* @__PURE__ */ jsx(RenderLeaf, { ...leafProps, readOnly, renderAnnotation, renderChild, renderDecorator, renderPlaceholder, schema }), $[59] = readOnly, $[60] = renderAnnotation, $[61] = renderChild, $[62] = renderDecorator, $[63] = renderPlaceholder, $[64] = schema, $[65] = t12) : t12 = $[65];
   const renderLeaf = t12, renderText = _temp3;
   let t13;
-  $[66] !== editorActor || $[67] !== propsSelection || $[68] !== slateEditor ? (t13 = () => {
+  $[66] !== editorActor || $[67] !== editorEngine || $[68] !== propsSelection ? (t13 = () => {
     if (propsSelection) {
       debug.selection.enabled && debug.selection(`Selection from props ${safeStringify(propsSelection)}`);
-      const resolvedSelection = resolveSelection(slateEditor, propsSelection);
-      resolvedSelection && (debug.selection.enabled && debug.selection(`Resolved selection from props ${safeStringify(resolvedSelection)}`), slateEditor.select(resolvedSelection), slateEditor.operations.some(_temp4) || editorActor.send({
+      const resolvedSelection = resolveSelection(editorEngine, propsSelection);
+      resolvedSelection && (debug.selection.enabled && debug.selection(`Resolved selection from props ${safeStringify(resolvedSelection)}`), editorEngine.select(resolvedSelection), editorEngine.operations.some(_temp4) || editorActor.send({
         type: "update selection",
         selection: resolvedSelection
-      }), slateEditor.onChange());
+      }), editorEngine.onChange());
     }
-  }, $[66] = editorActor, $[67] = propsSelection, $[68] = slateEditor, $[69] = t13) : t13 = $[69];
+  }, $[66] = editorActor, $[67] = editorEngine, $[68] = propsSelection, $[69] = t13) : t13 = $[69];
   const restoreSelectionFromProps = t13;
   let t14, t15;
   $[70] !== editorActor || $[71] !== rangeDecorationsActor || $[72] !== restoreSelectionFromProps ? (t14 = () => {
@@ -6148,13 +6149,13 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
     propsSelection && !hasInvalidValue && restoreSelectionFromProps();
   }, t17 = [hasInvalidValue, propsSelection, restoreSelectionFromProps], $[75] = hasInvalidValue, $[76] = propsSelection, $[77] = restoreSelectionFromProps, $[78] = t16, $[79] = t17) : (t16 = $[78], t17 = $[79]), useEffect(t16, t17);
   let t18;
-  $[80] !== editorActor || $[81] !== onCopy || $[82] !== slateEditor ? (t18 = (event) => {
-    if (DOMEditor.hasSelectableTarget(slateEditor, event.target)) {
+  $[80] !== editorActor || $[81] !== editorEngine || $[82] !== onCopy ? (t18 = (event) => {
+    if (DOMEditor.hasSelectableTarget(editorEngine, event.target)) {
       if (onCopy)
         onCopy(event) !== void 0 && event.preventDefault();
       else if (event.nativeEvent.clipboardData) {
         event.stopPropagation(), event.preventDefault();
-        const selection = slateEditor.selection ?? void 0, position = selection ? {
+        const selection = editorEngine.selection ?? void 0, position = selection ? {
           selection
         } : void 0;
         if (!position) {
@@ -6170,16 +6171,16 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
             },
             position
           },
-          editor: slateEditor,
+          editor: editorEngine,
           nativeEvent: event
         });
       }
     }
-  }, $[80] = editorActor, $[81] = onCopy, $[82] = slateEditor, $[83] = t18) : t18 = $[83];
+  }, $[80] = editorActor, $[81] = editorEngine, $[82] = onCopy, $[83] = t18) : t18 = $[83];
   const handleCopy = t18;
   let t19;
-  $[84] !== editorActor || $[85] !== onCut || $[86] !== slateEditor ? (t19 = (event_0) => {
-    if (DOMEditor.hasSelectableTarget(slateEditor, event_0.target)) {
+  $[84] !== editorActor || $[85] !== editorEngine || $[86] !== onCut ? (t19 = (event_0) => {
+    if (DOMEditor.hasSelectableTarget(editorEngine, event_0.target)) {
       if (onCut)
         onCut(event_0) !== void 0 && event_0.preventDefault();
       else if (event_0.nativeEvent.clipboardData) {
@@ -6200,22 +6201,22 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
             },
             position: position_0
           },
-          editor: slateEditor,
+          editor: editorEngine,
           nativeEvent: event_0
         });
       }
     }
-  }, $[84] = editorActor, $[85] = onCut, $[86] = slateEditor, $[87] = t19) : t19 = $[87];
+  }, $[84] = editorActor, $[85] = editorEngine, $[86] = onCut, $[87] = t19) : t19 = $[87];
   const handleCut = t19;
   let t20;
-  $[88] !== editorActor || $[89] !== onPaste || $[90] !== portableTextEditor || $[91] !== relayActor || $[92] !== slateEditor ? (t20 = (event_1) => {
-    const value = slateEditor.children, path2 = slateEditor.selection?.focus.path || [], onPasteResult = onPaste?.({
+  $[88] !== editorActor || $[89] !== editorEngine || $[90] !== onPaste || $[91] !== portableTextEditor || $[92] !== relayActor ? (t20 = (event_1) => {
+    const value = editorEngine.children, path2 = editorEngine.selection?.focus.path || [], onPasteResult = onPaste?.({
       event: event_1,
       value,
       path: path2,
       schemaTypes: portableTextEditor.schemaTypes
     });
-    if (onPasteResult || !slateEditor.selection)
+    if (onPasteResult || !editorEngine.selection)
       event_1.preventDefault(), relayActor.send({
         type: "loading"
       }), Promise.resolve(onPasteResult).then((result_1) => {
@@ -6237,7 +6238,7 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
               },
               position: position_1
             },
-            editor: slateEditor,
+            editor: editorEngine,
             nativeEvent: event_1
           });
         } else
@@ -6257,7 +6258,7 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
               }),
               placement: "auto"
             },
-            editor: slateEditor
+            editor: editorEngine
           }) : console.warn("Your onPaste function returned something unexpected:", result_1);
       }).catch(_temp5).finally(() => {
         relayActor.send({
@@ -6282,28 +6283,28 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
           },
           position: position_2
         },
-        editor: slateEditor,
+        editor: editorEngine,
         nativeEvent: event_1
       });
     }
     debug.behaviors("No result from custom paste handler, pasting normally");
-  }, $[88] = editorActor, $[89] = onPaste, $[90] = portableTextEditor, $[91] = relayActor, $[92] = slateEditor, $[93] = t20) : t20 = $[93];
+  }, $[88] = editorActor, $[89] = editorEngine, $[90] = onPaste, $[91] = portableTextEditor, $[92] = relayActor, $[93] = t20) : t20 = $[93];
   const handlePaste = t20;
   let t21;
-  $[94] !== editorActor || $[95] !== onFocus || $[96] !== relayActor || $[97] !== slateEditor ? (t21 = (event_2) => {
+  $[94] !== editorActor || $[95] !== editorEngine || $[96] !== onFocus || $[97] !== relayActor ? (t21 = (event_2) => {
     onFocus && onFocus(event_2), event_2.isDefaultPrevented() || (relayActor.send({
       type: "focused",
       event: event_2
-    }), !slateEditor.selection && slateEditor.children.length === 1 && isEmptyTextBlock(editorActor.getSnapshot().context, slateEditor.children.at(0)) && (slateEditor.select(start(slateEditor, [])), slateEditor.onChange()));
-  }, $[94] = editorActor, $[95] = onFocus, $[96] = relayActor, $[97] = slateEditor, $[98] = t21) : t21 = $[98];
+    }), !editorEngine.selection && editorEngine.children.length === 1 && isEmptyTextBlock(editorActor.getSnapshot().context, editorEngine.children.at(0)) && (editorEngine.select(start(editorEngine, [])), editorEngine.onChange()));
+  }, $[94] = editorActor, $[95] = editorEngine, $[96] = onFocus, $[97] = relayActor, $[98] = t21) : t21 = $[98];
   const handleOnFocus = t21;
   let t22;
-  $[99] !== editorActor || $[100] !== onClick || $[101] !== slateEditor ? (t22 = (event_3) => {
+  $[99] !== editorActor || $[100] !== editorEngine || $[101] !== onClick ? (t22 = (event_3) => {
     if (onClick && onClick(event_3), event_3.isDefaultPrevented() || event_3.isPropagationStopped())
       return;
     const position_3 = getEventPosition({
       editorActor,
-      slateEditor,
+      editorEngine,
       event: event_3.nativeEvent
     });
     position_3 && editorActor.send({
@@ -6312,10 +6313,10 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
         type: "mouse.click",
         position: position_3
       },
-      editor: slateEditor,
+      editor: editorEngine,
       nativeEvent: event_3
     });
-  }, $[99] = editorActor, $[100] = onClick, $[101] = slateEditor, $[102] = t22) : t22 = $[102];
+  }, $[99] = editorActor, $[100] = editorEngine, $[101] = onClick, $[102] = t22) : t22 = $[102];
   const handleClick = t22;
   let t23;
   $[103] !== onBlur || $[104] !== relayActor ? (t23 = (event_4) => {
@@ -6331,10 +6332,10 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
   }, $[106] = onBeforeInput, $[107] = t24) : t24 = $[107];
   const handleOnBeforeInput = t24;
   let t25;
-  $[108] !== editorActor || $[109] !== hotkeys || $[110] !== portableTextEditor || $[111] !== props || $[112] !== slateEditor ? (t25 = (event_6) => {
+  $[108] !== editorActor || $[109] !== editorEngine || $[110] !== hotkeys || $[111] !== portableTextEditor || $[112] !== props ? (t25 = (event_6) => {
     props.onKeyDown && props.onKeyDown(event_6), event_6.isDefaultPrevented() || performHotkey({
       editorActor,
-      editor: slateEditor,
+      editor: editorEngine,
       portableTextEditor,
       hotkeys: hotkeys ?? {},
       event: event_6
@@ -6351,13 +6352,13 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
           shiftKey: event_6.shiftKey
         }
       },
-      editor: slateEditor,
+      editor: editorEngine,
       nativeEvent: event_6
     });
-  }, $[108] = editorActor, $[109] = hotkeys, $[110] = portableTextEditor, $[111] = props, $[112] = slateEditor, $[113] = t25) : t25 = $[113];
+  }, $[108] = editorActor, $[109] = editorEngine, $[110] = hotkeys, $[111] = portableTextEditor, $[112] = props, $[113] = t25) : t25 = $[113];
   const handleKeyDown = t25;
   let t26;
-  $[114] !== editorActor || $[115] !== props || $[116] !== slateEditor ? (t26 = (event_7) => {
+  $[114] !== editorActor || $[115] !== editorEngine || $[116] !== props ? (t26 = (event_7) => {
     props.onKeyUp && props.onKeyUp(event_7), event_7.isDefaultPrevented() || editorActor.send({
       type: "behavior event",
       behaviorEvent: {
@@ -6371,10 +6372,10 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
           shiftKey: event_7.shiftKey
         }
       },
-      editor: slateEditor,
+      editor: editorEngine,
       nativeEvent: event_7
     });
-  }, $[114] = editorActor, $[115] = props, $[116] = slateEditor, $[117] = t26) : t26 = $[117];
+  }, $[114] = editorActor, $[115] = editorEngine, $[116] = props, $[117] = t26) : t26 = $[117];
   const handleKeyUp = t26;
   let t27;
   bb0: {
@@ -6391,10 +6392,10 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
       scrollSelectionIntoView(portableTextEditor, domRange);
     }, $[118] = portableTextEditor, $[119] = scrollSelectionIntoView, $[120] = t282) : t282 = $[120], t27 = t282;
   }
-  const scrollSelectionIntoViewToSlate = t27;
+  const scrollSelectionIntoViewToEngine = t27;
   let t28, t29;
-  $[121] !== editorActor || $[122] !== slateEditor ? (t28 = () => {
-    const window2 = DOMEditor.getWindow(slateEditor), onDragEnd_0 = () => {
+  $[121] !== editorActor || $[122] !== editorEngine ? (t28 = () => {
+    const window2 = DOMEditor.getWindow(editorEngine), onDragEnd_0 = () => {
       editorActor.send({
         type: "dragend"
       });
@@ -6406,14 +6407,14 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
     return window2.document.addEventListener("dragend", onDragEnd_0), window2.document.addEventListener("drop", onDrop_0), () => {
       window2.document.removeEventListener("dragend", onDragEnd_0), window2.document.removeEventListener("drop", onDrop_0);
     };
-  }, t29 = [slateEditor, editorActor], $[121] = editorActor, $[122] = slateEditor, $[123] = t28, $[124] = t29) : (t28 = $[123], t29 = $[124]), useEffect(t28, t29);
+  }, t29 = [editorEngine, editorActor], $[121] = editorActor, $[122] = editorEngine, $[123] = t28, $[124] = t29) : (t28 = $[123], t29 = $[124]), useEffect(t28, t29);
   let t30;
-  $[125] !== editorActor || $[126] !== onDragStart || $[127] !== readOnly || $[128] !== slateEditor ? (t30 = (event_8) => {
-    if (readOnly || !DOMEditor.hasTarget(slateEditor, event_8.target) || (onDragStart?.(event_8), event_8.isDefaultPrevented() || event_8.isPropagationStopped()))
+  $[125] !== editorActor || $[126] !== editorEngine || $[127] !== onDragStart || $[128] !== readOnly ? (t30 = (event_8) => {
+    if (readOnly || !DOMEditor.hasTarget(editorEngine, event_8.target) || (onDragStart?.(event_8), event_8.isDefaultPrevented() || event_8.isPropagationStopped()))
       return;
     const position_4 = getEventPosition({
       editorActor,
-      slateEditor,
+      editorEngine,
       event: event_8.nativeEvent
     });
     if (!position_4) {
@@ -6434,15 +6435,15 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
         },
         position: position_4
       },
-      editor: slateEditor
+      editor: editorEngine
     }), !0;
-  }, $[125] = editorActor, $[126] = onDragStart, $[127] = readOnly, $[128] = slateEditor, $[129] = t30) : t30 = $[129];
+  }, $[125] = editorActor, $[126] = editorEngine, $[127] = onDragStart, $[128] = readOnly, $[129] = t30) : t30 = $[129];
   const handleDragStart = t30;
   let t31;
-  $[130] !== editorActor || $[131] !== onDrag || $[132] !== slateEditor ? (t31 = (event_9) => {
+  $[130] !== editorActor || $[131] !== editorEngine || $[132] !== onDrag ? (t31 = (event_9) => {
     if (onDrag?.(event_9), !(event_9.isDefaultPrevented() || event_9.isPropagationStopped() || !getEventPosition({
       editorActor,
-      slateEditor,
+      editorEngine,
       event: event_9.nativeEvent
     })))
       return editorActor.send({
@@ -6453,12 +6454,12 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
             dataTransfer: event_9.dataTransfer
           }
         },
-        editor: slateEditor
+        editor: editorEngine
       }), !0;
-  }, $[130] = editorActor, $[131] = onDrag, $[132] = slateEditor, $[133] = t31) : t31 = $[133];
+  }, $[130] = editorActor, $[131] = editorEngine, $[132] = onDrag, $[133] = t31) : t31 = $[133];
   const handleDrag = t31;
   let t32;
-  $[134] !== editorActor || $[135] !== onDragEnd || $[136] !== slateEditor ? (t32 = (event_10) => {
+  $[134] !== editorActor || $[135] !== editorEngine || $[136] !== onDragEnd ? (t32 = (event_10) => {
     if (onDragEnd?.(event_10), !(event_10.isDefaultPrevented() || event_10.isPropagationStopped()))
       return editorActor.send({
         type: "behavior event",
@@ -6468,17 +6469,17 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
             dataTransfer: event_10.dataTransfer
           }
         },
-        editor: slateEditor
+        editor: editorEngine
       }), !0;
-  }, $[134] = editorActor, $[135] = onDragEnd, $[136] = slateEditor, $[137] = t32) : t32 = $[137];
+  }, $[134] = editorActor, $[135] = editorEngine, $[136] = onDragEnd, $[137] = t32) : t32 = $[137];
   const handleDragEnd = t32;
   let t33;
-  $[138] !== editorActor || $[139] !== onDragEnter || $[140] !== slateEditor ? (t33 = (event_11) => {
+  $[138] !== editorActor || $[139] !== editorEngine || $[140] !== onDragEnter ? (t33 = (event_11) => {
     if (onDragEnter?.(event_11), event_11.isDefaultPrevented() || event_11.isPropagationStopped())
       return;
     const position_6 = getEventPosition({
       editorActor,
-      slateEditor,
+      editorEngine,
       event: event_11.nativeEvent
     });
     if (position_6)
@@ -6491,17 +6492,17 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
           },
           position: position_6
         },
-        editor: slateEditor
+        editor: editorEngine
       }), !0;
-  }, $[138] = editorActor, $[139] = onDragEnter, $[140] = slateEditor, $[141] = t33) : t33 = $[141];
+  }, $[138] = editorActor, $[139] = editorEngine, $[140] = onDragEnter, $[141] = t33) : t33 = $[141];
   const handleDragEnter = t33;
   let t34;
-  $[142] !== editorActor || $[143] !== onDragOver || $[144] !== slateEditor ? (t34 = (event_12) => {
+  $[142] !== editorActor || $[143] !== editorEngine || $[144] !== onDragOver ? (t34 = (event_12) => {
     if (onDragOver?.(event_12), event_12.isDefaultPrevented() || event_12.isPropagationStopped())
       return;
     const position_7 = getEventPosition({
       editorActor,
-      slateEditor,
+      editorEngine,
       event: event_12.nativeEvent
     });
     if (position_7)
@@ -6515,18 +6516,18 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
           dragOrigin: editorActor.getSnapshot().context.internalDrag?.origin,
           position: position_7
         },
-        editor: slateEditor,
+        editor: editorEngine,
         nativeEvent: event_12
       }), !0;
-  }, $[142] = editorActor, $[143] = onDragOver, $[144] = slateEditor, $[145] = t34) : t34 = $[145];
+  }, $[142] = editorActor, $[143] = editorEngine, $[144] = onDragOver, $[145] = t34) : t34 = $[145];
   const handleDragOver = t34;
   let t35;
-  $[146] !== editorActor || $[147] !== onDrop || $[148] !== slateEditor ? (t35 = (event_13) => {
+  $[146] !== editorActor || $[147] !== editorEngine || $[148] !== onDrop ? (t35 = (event_13) => {
     if (onDrop?.(event_13), event_13.isDefaultPrevented() || event_13.isPropagationStopped())
       return;
     const position_8 = getEventPosition({
       editorActor,
-      slateEditor,
+      editorEngine,
       event: event_13.nativeEvent
     });
     if (!position_8) {
@@ -6543,16 +6544,16 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
         dragOrigin: editorActor.getSnapshot().context.internalDrag?.origin,
         position: position_8
       },
-      editor: slateEditor,
+      editor: editorEngine,
       nativeEvent: event_13
     }), !0;
-  }, $[146] = editorActor, $[147] = onDrop, $[148] = slateEditor, $[149] = t35) : t35 = $[149];
+  }, $[146] = editorActor, $[147] = editorEngine, $[148] = onDrop, $[149] = t35) : t35 = $[149];
   const handleDrop = t35;
   let t36;
-  $[150] !== editorActor || $[151] !== onDragLeave || $[152] !== slateEditor ? (t36 = (event_14) => {
+  $[150] !== editorActor || $[151] !== editorEngine || $[152] !== onDragLeave ? (t36 = (event_14) => {
     if (onDragLeave?.(event_14), !(event_14.isDefaultPrevented() || event_14.isPropagationStopped() || !getEventPosition({
       editorActor,
-      slateEditor,
+      editorEngine,
       event: event_14.nativeEvent
     })))
       return editorActor.send({
@@ -6563,9 +6564,9 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
             dataTransfer: event_14.dataTransfer
           }
         },
-        editor: slateEditor
+        editor: editorEngine
       }), !0;
-  }, $[150] = editorActor, $[151] = onDragLeave, $[152] = slateEditor, $[153] = t36) : t36 = $[153];
+  }, $[150] = editorActor, $[151] = editorEngine, $[152] = onDragLeave, $[153] = t36) : t36 = $[153];
   const handleDragLeave = t36;
   let t37;
   $[154] !== forwardedRef || $[155] !== validateSelectionActor ? (t37 = (editorElement) => {
@@ -6591,7 +6592,7 @@ const PortableTextEditable = forwardRef(function(props, forwardedRef) {
   if (!portableTextEditor)
     return null;
   let t38;
-  return $[157] !== callbackRef || $[158] !== decorate || $[159] !== editorActor || $[160] !== handleClick || $[161] !== handleCopy || $[162] !== handleCut || $[163] !== handleDrag || $[164] !== handleDragEnd || $[165] !== handleDragEnter || $[166] !== handleDragLeave || $[167] !== handleDragOver || $[168] !== handleDragStart || $[169] !== handleDrop || $[170] !== handleKeyDown || $[171] !== handleKeyUp || $[172] !== handleOnBeforeInput || $[173] !== handleOnBlur || $[174] !== handleOnFocus || $[175] !== handlePaste || $[176] !== hasInvalidValue || $[177] !== readOnly || $[178] !== renderElement || $[179] !== renderLeaf || $[180] !== restProps || $[181] !== scrollSelectionIntoViewToSlate ? (t38 = hasInvalidValue ? null : /* @__PURE__ */ jsx(SelectionStateProvider, { children: /* @__PURE__ */ jsx(Editable, { ...restProps, ref: callbackRef, editorActor, "data-read-only": readOnly, autoFocus: !1, className: restProps.className || "pt-editable", decorate, onBlur: handleOnBlur, onCopy: handleCopy, onCut: handleCut, onClick: handleClick, onDOMBeforeInput: handleOnBeforeInput, onDragStart: handleDragStart, onDrag: handleDrag, onDragEnd: handleDragEnd, onDragEnter: handleDragEnter, onDragOver: handleDragOver, onDrop: handleDrop, onDragLeave: handleDragLeave, onFocus: handleOnFocus, onKeyDown: handleKeyDown, onKeyUp: handleKeyUp, onPaste: handlePaste, readOnly, renderElement, renderLeaf, renderText, scrollSelectionIntoView: scrollSelectionIntoViewToSlate }) }), $[157] = callbackRef, $[158] = decorate, $[159] = editorActor, $[160] = handleClick, $[161] = handleCopy, $[162] = handleCut, $[163] = handleDrag, $[164] = handleDragEnd, $[165] = handleDragEnter, $[166] = handleDragLeave, $[167] = handleDragOver, $[168] = handleDragStart, $[169] = handleDrop, $[170] = handleKeyDown, $[171] = handleKeyUp, $[172] = handleOnBeforeInput, $[173] = handleOnBlur, $[174] = handleOnFocus, $[175] = handlePaste, $[176] = hasInvalidValue, $[177] = readOnly, $[178] = renderElement, $[179] = renderLeaf, $[180] = restProps, $[181] = scrollSelectionIntoViewToSlate, $[182] = t38) : t38 = $[182], t38;
+  return $[157] !== callbackRef || $[158] !== decorate || $[159] !== editorActor || $[160] !== handleClick || $[161] !== handleCopy || $[162] !== handleCut || $[163] !== handleDrag || $[164] !== handleDragEnd || $[165] !== handleDragEnter || $[166] !== handleDragLeave || $[167] !== handleDragOver || $[168] !== handleDragStart || $[169] !== handleDrop || $[170] !== handleKeyDown || $[171] !== handleKeyUp || $[172] !== handleOnBeforeInput || $[173] !== handleOnBlur || $[174] !== handleOnFocus || $[175] !== handlePaste || $[176] !== hasInvalidValue || $[177] !== readOnly || $[178] !== renderElement || $[179] !== renderLeaf || $[180] !== restProps || $[181] !== scrollSelectionIntoViewToEngine ? (t38 = hasInvalidValue ? null : /* @__PURE__ */ jsx(SelectionStateProvider, { children: /* @__PURE__ */ jsx(Editable, { ...restProps, ref: callbackRef, editorActor, "data-read-only": readOnly, autoFocus: !1, className: restProps.className || "pt-editable", decorate, onBlur: handleOnBlur, onCopy: handleCopy, onCut: handleCut, onClick: handleClick, onDOMBeforeInput: handleOnBeforeInput, onDragStart: handleDragStart, onDrag: handleDrag, onDragEnd: handleDragEnd, onDragEnter: handleDragEnter, onDragOver: handleDragOver, onDrop: handleDrop, onDragLeave: handleDragLeave, onFocus: handleOnFocus, onKeyDown: handleKeyDown, onKeyUp: handleKeyUp, onPaste: handlePaste, readOnly, renderElement, renderLeaf, renderText, scrollSelectionIntoView: scrollSelectionIntoViewToEngine }) }), $[157] = callbackRef, $[158] = decorate, $[159] = editorActor, $[160] = handleClick, $[161] = handleCopy, $[162] = handleCut, $[163] = handleDrag, $[164] = handleDragEnd, $[165] = handleDragEnter, $[166] = handleDragLeave, $[167] = handleDragOver, $[168] = handleDragStart, $[169] = handleDrop, $[170] = handleKeyDown, $[171] = handleKeyUp, $[172] = handleOnBeforeInput, $[173] = handleOnBlur, $[174] = handleOnFocus, $[175] = handlePaste, $[176] = hasInvalidValue, $[177] = readOnly, $[178] = renderElement, $[179] = renderLeaf, $[180] = restProps, $[181] = scrollSelectionIntoViewToEngine, $[182] = t38) : t38 = $[182], t38;
 });
 PortableTextEditable.displayName = "ForwardRef(PortableTextEditable)";
 function noop() {
@@ -6613,7 +6614,21 @@ function _temp4(o) {
 function _temp5(error) {
   return console.warn(error), error;
 }
-const forEachActor = (actorRef, callback) => {
+const Engine = (props) => {
+  const {
+    editor,
+    children
+  } = props, {
+    selectorContext,
+    onChange: handleSelectorChange
+  } = useSelectorContext(), onContextChange = useCallback(() => {
+    handleSelectorChange();
+  }, [editor, handleSelectorChange]);
+  return useEffect(() => (editor.onContextChange = onContextChange, () => {
+    editor.onContextChange = () => {
+    };
+  }), [editor, onContextChange]), /* @__PURE__ */ jsx(EngineSelectorContext.Provider, { value: selectorContext, children: /* @__PURE__ */ jsx(EditorContext.Provider, { value: editor, children }) });
+}, forEachActor = (actorRef, callback) => {
   callback(actorRef);
   const children = actorRef.getSnapshot().children;
   children && Object.values(children).forEach((child) => {
@@ -6630,21 +6645,6 @@ function stopActor(actorRef) {
     ref._processingStatus = 0, ref._snapshot = snapshot;
   });
 }
-const Slate = (props) => {
-  const {
-    editor,
-    children
-  } = props, {
-    selectorContext,
-    onChange: handleSelectorChange
-  } = useSelectorContext(), onContextChange = useCallback(() => {
-    handleSelectorChange();
-  }, [editor, handleSelectorChange]);
-  return useEffect(() => (editor.onContextChange = onContextChange, () => {
-    editor.onContextChange = () => {
-    };
-  }), [editor, onContextChange]), /* @__PURE__ */ jsx(SlateSelectorContext.Provider, { value: selectorContext, children: /* @__PURE__ */ jsx(EditorContext.Provider, { value: editor, children }) });
-};
 const converterJson = {
   mimeType: "application/json",
   serialize: ({
@@ -7000,14 +7000,14 @@ function createEditableAPI(editor, editorActor) {
     isMarkActive: (mark) => {
       const snapshot = getEditorSnapshot({
         editorActorSnapshot: editorActor.getSnapshot(),
-        slateEditorInstance: editor
+        editorEngineInstance: editor
       });
       return getActiveDecorators(snapshot).includes(mark);
     },
     marks: () => {
       const snapshot = getEditorSnapshot({
         editorActorSnapshot: editorActor.getSnapshot(),
-        slateEditorInstance: editor
+        editorEngineInstance: editor
       }), activeAnnotations = getActiveAnnotationsMarks(snapshot), activeDecorators = getActiveDecorators(snapshot);
       return [...activeAnnotations, ...activeDecorators];
     },
@@ -7149,14 +7149,14 @@ function createEditableAPI(editor, editorActor) {
     isAnnotationActive: (annotationType) => {
       const snapshot = getEditorSnapshot({
         editorActorSnapshot: editorActor.getSnapshot(),
-        slateEditorInstance: editor
+        editorEngineInstance: editor
       });
       return isActiveAnnotation(annotationType)(snapshot);
     },
     addAnnotation: (type, value) => {
       const snapshotBefore = getEditorSnapshot({
         editorActorSnapshot: editorActor.getSnapshot(),
-        slateEditorInstance: editor
+        editorEngineInstance: editor
       }), selectedValueBefore = getSelectedValue(snapshotBefore), focusSpanBefore = getFocusSpan(snapshotBefore), markDefsBefore = selectedValueBefore.flatMap((block) => isTextBlock(snapshotBefore.context, block) ? block.markDefs ?? [] : []);
       editorActor.send({
         type: "behavior event",
@@ -7171,7 +7171,7 @@ function createEditableAPI(editor, editorActor) {
       });
       const snapshotAfter = getEditorSnapshot({
         editorActorSnapshot: editorActor.getSnapshot(),
-        slateEditorInstance: editor
+        editorEngineInstance: editor
       }), selectedValueAfter = getSelectedValue(snapshotAfter), focusBlockAfter = getFocusBlock(snapshotAfter), focusSpanAfter = getFocusSpan(snapshotAfter), focusSpanDecorators = focusSpanAfter ? getPathSubSchema(snapshotAfter, focusSpanAfter.path).decorators.map((decorator) => decorator.name) : snapshotAfter.context.schema.decorators.map((decorator) => decorator.name), newMarkDefKeysOnFocusSpan = focusSpanAfter?.node.marks?.filter((mark) => !focusSpanBefore?.node.marks?.includes(mark) && !focusSpanDecorators.includes(mark)), markDefs = selectedValueAfter.flatMap((block) => isTextBlock(snapshotAfter.context, block) ? block.markDefs?.map((markDef2) => ({
         markDef: markDef2,
         path: [{
@@ -7206,142 +7206,33 @@ function createEditableAPI(editor, editorActor) {
           annotation: {
             name: type.name
           }
-        },
-        editor
-      });
-    },
-    getSelection: () => editor.selection,
-    getValue: () => editor.children,
-    isCollapsedSelection: () => !!editor.selection && isCollapsedRange(editor.selection),
-    isExpandedSelection: () => !!editor.selection && isExpandedRange(editor.selection),
-    insertBreak: () => {
-      editorActor.send({
-        type: "behavior event",
-        behaviorEvent: {
-          type: "insert.break"
-        },
-        editor
-      });
-    },
-    getFragment: () => {
-      const snapshot = getEditorSnapshot({
-        editorActorSnapshot: editorActor.getSnapshot(),
-        slateEditorInstance: editor
-      });
-      return getFragment(snapshot).map((entry) => entry.node);
-    },
-    isSelectionsOverlapping: (selectionA, selectionB) => !selectionA || !selectionB ? !1 : rangeIncludes(selectionA, selectionB, editor)
-  };
-}
-const levelIndexMaps = /* @__PURE__ */ new Map();
-function buildIndexMaps(context, {
-  blockIndexMap,
-  listIndexMap
-}) {
-  blockIndexMap.clear(), listIndexMap.clear(), levelIndexMaps.clear();
-  let previousListItem;
-  for (let blockIndex = 0; blockIndex < context.value.length; blockIndex++) {
-    const block = context.value.at(blockIndex);
-    if (block === void 0)
-      continue;
-    if (blockIndexMap.set(block._key, blockIndex), !isTextBlockNode(context, block)) {
-      levelIndexMaps.clear(), previousListItem = void 0;
-      continue;
-    }
-    if (block.listItem === void 0 || block.level === void 0) {
-      levelIndexMaps.clear(), previousListItem = void 0;
-      continue;
-    }
-    if (!previousListItem) {
-      const levelIndexMap2 = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map();
-      levelIndexMap2.set(block.level, 1), levelIndexMaps.set(block.listItem, levelIndexMap2), listIndexMap.set(block._key, 1), previousListItem = {
-        listItem: block.listItem,
-        level: block.level
-      };
-      continue;
-    }
-    if (previousListItem.listItem === block.listItem && previousListItem.level < block.level) {
-      const levelIndexMap2 = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map();
-      levelIndexMap2.set(block.level, 1), levelIndexMaps.set(block.listItem, levelIndexMap2), listIndexMap.set(block._key, 1), previousListItem = {
-        listItem: block.listItem,
-        level: block.level
-      };
-      continue;
-    }
-    levelIndexMaps.forEach((levelIndexMap2, listItem) => {
-      if (listItem === block.listItem)
-        return;
-      const levelsToDelete = [];
-      levelIndexMap2.forEach((_, level) => {
-        level >= block.level && levelsToDelete.push(level);
-      }), levelsToDelete.forEach((level) => {
-        levelIndexMap2.delete(level);
+        },
+        editor
       });
-    });
-    const levelIndexMap = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map(), levelCounter = levelIndexMap.get(block.level) ?? 0;
-    levelIndexMap.set(block.level, levelCounter + 1), levelIndexMaps.set(block.listItem, levelIndexMap), listIndexMap.set(block._key, levelCounter + 1), previousListItem = {
-      listItem: block.listItem,
-      level: block.level
-    };
-  }
-}
-function createPlaceholderBlock(snapshot, path2) {
-  const style = resolveDefaultStyle(snapshot, path2);
-  return {
-    _type: snapshot.context.schema.block.name,
-    _key: snapshot.context.keyGenerator(),
-    style,
-    markDefs: [],
-    children: [{
-      _type: snapshot.context.schema.span.name,
-      _key: snapshot.context.keyGenerator(),
-      text: "",
-      marks: []
-    }]
-  };
-}
-function resolveDefaultStyle(snapshot, path2) {
-  const rootFallback = snapshot.context.schema.styles[0]?.name ?? "normal";
-  return path2 ? getPathSubSchema(snapshot, path2).styles[0]?.name ?? rootFallback : rootFallback;
-}
-function buildPublicContainers(resolved) {
-  const projected = /* @__PURE__ */ new Map();
-  for (const [type, config] of resolved)
-    projected.set(type, toRegisteredContainer(config));
-  return projected;
-}
-function toRegisteredContainer(config) {
-  return {
-    kind: "container",
-    type: config.container.type,
-    field: config.field,
-    ...config.of ? {
-      of: config.of.map(toRegisteredOfEntry).filter(isDefined)
-    } : {}
+    },
+    getSelection: () => editor.selection,
+    getValue: () => editor.children,
+    isCollapsedSelection: () => !!editor.selection && isCollapsedRange(editor.selection),
+    isExpandedSelection: () => !!editor.selection && isExpandedRange(editor.selection),
+    insertBreak: () => {
+      editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "insert.break"
+        },
+        editor
+      });
+    },
+    getFragment: () => {
+      const snapshot = getEditorSnapshot({
+        editorActorSnapshot: editorActor.getSnapshot(),
+        editorEngineInstance: editor
+      });
+      return getFragment(snapshot).map((entry) => entry.node);
+    },
+    isSelectionsOverlapping: (selectionA, selectionB) => !selectionA || !selectionB ? !1 : rangeIncludes(selectionA, selectionB, editor)
   };
 }
-function toRegisteredOfEntry(entry) {
-  if ("container" in entry)
-    return toRegisteredContainer(entry);
-  if ("span" in entry)
-    return {
-      kind: "span",
-      type: entry.span.type
-    };
-  if ("blockObject" in entry)
-    return {
-      kind: "blockObject",
-      type: entry.blockObject.type
-    };
-  if ("inlineObject" in entry)
-    return {
-      kind: "inlineObject",
-      type: entry.inlineObject.type
-    };
-}
-function isDefined(value) {
-  return value !== void 0;
-}
 function createBehaviorApiPlugin(editorActor) {
   return function(editor) {
     const {
@@ -7522,6 +7413,75 @@ function createHistoryPlugin({
     }, editor;
   };
 }
+function isNormalizing(editor) {
+  return editor.normalizing;
+}
+function setNormalizing(editor, isNormalizing2) {
+  editor.normalizing = isNormalizing2;
+}
+function withoutNormalizing(editor, fn) {
+  const value = isNormalizing(editor);
+  setNormalizing(editor, !1);
+  try {
+    fn();
+  } finally {
+    setNormalizing(editor, value);
+  }
+  normalize(editor);
+}
+function normalize(editor, options = {}) {
+  const {
+    force = !1,
+    operation
+  } = options, getDirtyPaths2 = (editor2) => editor2.dirtyPaths, getDirtyPathKeys = (editor2) => editor2.dirtyPathKeys, popDirtyPath = (editor2) => {
+    const path2 = getDirtyPaths2(editor2).pop(), key = serializePath(path2);
+    return getDirtyPathKeys(editor2).delete(key), path2;
+  };
+  if (isNormalizing(editor)) {
+    if (force) {
+      const allPaths = Array.from(getNodes(editor), (entry) => entry.path), allPathKeys = new Set(allPaths.map((p) => serializePath(p)));
+      editor.dirtyPaths = allPaths, editor.dirtyPathKeys = allPathKeys;
+    }
+    getDirtyPaths2(editor).length !== 0 && withoutNormalizing(editor, () => {
+      for (const dirtyPath of getDirtyPaths2(editor))
+        if (dirtyPath.length !== 0 && hasNode(editor, dirtyPath)) {
+          const entry = getNode(editor, dirtyPath);
+          if (!entry)
+            continue;
+          const entryNode = entry.node;
+          isTextBlock({
+            schema: editor.schema
+          }, entryNode) && entryNode.children.length === 0 && (editor.isNormalizingNode = !0, editor.normalizeNode([entry.node, entry.path], {
+            operation
+          }), editor.isNormalizingNode = !1);
+        }
+      let dirtyPaths = getDirtyPaths2(editor);
+      const initialDirtyPathsLength = dirtyPaths.length;
+      let iteration = 0;
+      for (; dirtyPaths.length !== 0; ) {
+        if (!editor.shouldNormalize({
+          dirtyPaths,
+          iteration,
+          initialDirtyPathsLength,
+          operation
+        }))
+          return;
+        const dirtyPath = popDirtyPath(editor);
+        if (dirtyPath.length === 0)
+          editor.isNormalizingNode = !0, editor.normalizeNode([editor, dirtyPath], {
+            operation
+          }), editor.isNormalizingNode = !1;
+        else if (hasNode(editor, dirtyPath)) {
+          const entry = getNode(editor, dirtyPath);
+          entry && (editor.isNormalizingNode = !0, editor.normalizeNode([entry.node, entry.path], {
+            operation
+          }), editor.isNormalizingNode = !1);
+        }
+        iteration++, dirtyPaths = getDirtyPaths2(editor);
+      }
+    });
+  }
+}
 function cloneDiff(diff2) {
   const [type, patch] = diff2;
   return [type, patch];
@@ -8179,7 +8139,7 @@ function getValue(root, path2) {
   }
   return current;
 }
-function toSlateBlock(block, {
+function toEngineBlock(block, {
   schemaTypes
 }) {
   const {
@@ -8371,75 +8331,6 @@ function insertNodePatch(operation) {
   const arrayFieldPath = operation.path.slice(0, -1);
   return arrayFieldPath.length === 0 ? [insert([operation.node], operation.position, operation.path)] : [setIfMissing([], arrayFieldPath), insert([operation.node], operation.position, operation.path)];
 }
-function isNormalizing(editor) {
-  return editor.normalizing;
-}
-function setNormalizing(editor, isNormalizing2) {
-  editor.normalizing = isNormalizing2;
-}
-function withoutNormalizing(editor, fn) {
-  const value = isNormalizing(editor);
-  setNormalizing(editor, !1);
-  try {
-    fn();
-  } finally {
-    setNormalizing(editor, value);
-  }
-  normalize(editor);
-}
-function normalize(editor, options = {}) {
-  const {
-    force = !1,
-    operation
-  } = options, getDirtyPaths2 = (editor2) => editor2.dirtyPaths, getDirtyPathKeys = (editor2) => editor2.dirtyPathKeys, popDirtyPath = (editor2) => {
-    const path2 = getDirtyPaths2(editor2).pop(), key = serializePath(path2);
-    return getDirtyPathKeys(editor2).delete(key), path2;
-  };
-  if (isNormalizing(editor)) {
-    if (force) {
-      const allPaths = Array.from(getNodes(editor), (entry) => entry.path), allPathKeys = new Set(allPaths.map((p) => serializePath(p)));
-      editor.dirtyPaths = allPaths, editor.dirtyPathKeys = allPathKeys;
-    }
-    getDirtyPaths2(editor).length !== 0 && withoutNormalizing(editor, () => {
-      for (const dirtyPath of getDirtyPaths2(editor))
-        if (dirtyPath.length !== 0 && hasNode(editor, dirtyPath)) {
-          const entry = getNode(editor, dirtyPath);
-          if (!entry)
-            continue;
-          const entryNode = entry.node;
-          isTextBlock({
-            schema: editor.schema
-          }, entryNode) && entryNode.children.length === 0 && (editor.isNormalizingNode = !0, editor.normalizeNode([entry.node, entry.path], {
-            operation
-          }), editor.isNormalizingNode = !1);
-        }
-      let dirtyPaths = getDirtyPaths2(editor);
-      const initialDirtyPathsLength = dirtyPaths.length;
-      let iteration = 0;
-      for (; dirtyPaths.length !== 0; ) {
-        if (!editor.shouldNormalize({
-          dirtyPaths,
-          iteration,
-          initialDirtyPathsLength,
-          operation
-        }))
-          return;
-        const dirtyPath = popDirtyPath(editor);
-        if (dirtyPath.length === 0)
-          editor.isNormalizingNode = !0, editor.normalizeNode([editor, dirtyPath], {
-            operation
-          }), editor.isNormalizingNode = !1;
-        else if (hasNode(editor, dirtyPath)) {
-          const entry = getNode(editor, dirtyPath);
-          entry && (editor.isNormalizingNode = !0, editor.normalizeNode([entry.node, entry.path], {
-            operation
-          }), editor.isNormalizingNode = !1);
-        }
-        iteration++, dirtyPaths = getDirtyPaths2(editor);
-      }
-    });
-  }
-}
 function withRemoteChanges(editor, fn) {
   const prev = editor.isProcessingRemoteChanges;
   editor.isProcessingRemoteChanges = !0, fn(), editor.isProcessingRemoteChanges = prev;
@@ -8552,21 +8443,73 @@ function updateSelectionPlugin({
       type: "update selection",
       selection: editor.selection
     });
-  }, {
-    onChange
-  } = editor;
-  return editor.onChange = () => {
-    onChange(), editorActor.getSnapshot().matches({
-      setup: "setting up"
-    }) || updateSelection();
-  }, editor;
+  }, {
+    onChange
+  } = editor;
+  return editor.onChange = () => {
+    onChange(), editorActor.getSnapshot().matches({
+      setup: "setting up"
+    }) || updateSelection();
+  }, editor;
+}
+const levelIndexMaps = /* @__PURE__ */ new Map();
+function buildIndexMaps(context, {
+  blockIndexMap,
+  listIndexMap
+}) {
+  blockIndexMap.clear(), listIndexMap.clear(), levelIndexMaps.clear();
+  let previousListItem;
+  for (let blockIndex = 0; blockIndex < context.value.length; blockIndex++) {
+    const block = context.value.at(blockIndex);
+    if (block === void 0)
+      continue;
+    if (blockIndexMap.set(block._key, blockIndex), !isTextBlockNode(context, block)) {
+      levelIndexMaps.clear(), previousListItem = void 0;
+      continue;
+    }
+    if (block.listItem === void 0 || block.level === void 0) {
+      levelIndexMaps.clear(), previousListItem = void 0;
+      continue;
+    }
+    if (!previousListItem) {
+      const levelIndexMap2 = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map();
+      levelIndexMap2.set(block.level, 1), levelIndexMaps.set(block.listItem, levelIndexMap2), listIndexMap.set(block._key, 1), previousListItem = {
+        listItem: block.listItem,
+        level: block.level
+      };
+      continue;
+    }
+    if (previousListItem.listItem === block.listItem && previousListItem.level < block.level) {
+      const levelIndexMap2 = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map();
+      levelIndexMap2.set(block.level, 1), levelIndexMaps.set(block.listItem, levelIndexMap2), listIndexMap.set(block._key, 1), previousListItem = {
+        listItem: block.listItem,
+        level: block.level
+      };
+      continue;
+    }
+    levelIndexMaps.forEach((levelIndexMap2, listItem) => {
+      if (listItem === block.listItem)
+        return;
+      const levelsToDelete = [];
+      levelIndexMap2.forEach((_, level) => {
+        level >= block.level && levelsToDelete.push(level);
+      }), levelsToDelete.forEach((level) => {
+        levelIndexMap2.delete(level);
+      });
+    });
+    const levelIndexMap = levelIndexMaps.get(block.listItem) ?? /* @__PURE__ */ new Map(), levelCounter = levelIndexMap.get(block.level) ?? 0;
+    levelIndexMap.set(block.level, levelCounter + 1), levelIndexMaps.set(block.listItem, levelIndexMap), listIndexMap.set(block._key, levelCounter + 1), previousListItem = {
+      listItem: block.listItem,
+      level: block.level
+    };
+  }
 }
 function updateValuePlugin(context, editor) {
   const {
     apply: apply2
   } = editor;
   return editor.apply = (operation) => {
-    if (editor.isNormalizingNode && debug.normalization.enabled && debug.normalization(`(slate operation)
+    if (editor.isNormalizingNode && debug.normalization.enabled && debug.normalization(`((engine operation))
 ${safeStringify(operation, 2)}`), operation.type === "set_selection") {
       apply2(operation);
       return;
@@ -9766,6 +9709,25 @@ function transformPointForMerge(point2, mergePath, prevKey, position) {
     offset
   };
 }
+function createPlaceholderBlock(snapshot, path2) {
+  const style = resolveDefaultStyle(snapshot, path2);
+  return {
+    _type: snapshot.context.schema.block.name,
+    _key: snapshot.context.keyGenerator(),
+    style,
+    markDefs: [],
+    children: [{
+      _type: snapshot.context.schema.span.name,
+      _key: snapshot.context.keyGenerator(),
+      text: "",
+      marks: []
+    }]
+  };
+}
+function resolveDefaultStyle(snapshot, path2) {
+  const rootFallback = snapshot.context.schema.styles[0]?.name ?? "normal";
+  return path2 ? getPathSubSchema(snapshot, path2).styles[0]?.name ?? rootFallback : rootFallback;
+}
 function setNodeProperties(editor, props, path2) {
   const nodeEntry = getNode(editor, path2);
   if (!nodeEntry)
@@ -10427,8 +10389,46 @@ const shouldNormalize = (_editor, {
     onContextChange && onContextChange(options), onChange(options);
   }, e;
 };
-function createSlateEditor(config) {
-  debug.setup("creating new slate editor instance");
+function buildPublicContainers(resolved) {
+  const projected = /* @__PURE__ */ new Map();
+  for (const [type, config] of resolved)
+    projected.set(type, toRegisteredContainer(config));
+  return projected;
+}
+function toRegisteredContainer(config) {
+  return {
+    kind: "container",
+    type: config.container.type,
+    field: config.field,
+    ...config.of ? {
+      of: config.of.map(toRegisteredOfEntry).filter(isDefined)
+    } : {}
+  };
+}
+function toRegisteredOfEntry(entry) {
+  if ("container" in entry)
+    return toRegisteredContainer(entry);
+  if ("span" in entry)
+    return {
+      kind: "span",
+      type: entry.span.type
+    };
+  if ("blockObject" in entry)
+    return {
+      kind: "blockObject",
+      type: entry.blockObject.type
+    };
+  if ("inlineObject" in entry)
+    return {
+      kind: "inlineObject",
+      type: entry.inlineObject.type
+    };
+}
+function isDefined(value) {
+  return value !== void 0;
+}
+function createEditorEngine(config) {
+  debug.setup("creating new editor engine instance");
   const context = config.editorActor.getSnapshot().context, placeholderBlock = createPlaceholderBlock({
     context: {
       schema: context.schema,
@@ -10442,27 +10442,27 @@ function createSlateEditor(config) {
     undos: [],
     redos: []
   }, 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 slateEditor = plugins(withDOM(editor), {
+  const editorEngine = plugins(withDOM(editor), {
     editorActor: config.editorActor,
     relayActor: config.relayActor,
     subscriptions: config.subscriptions
   });
   return buildIndexMaps({
     schema: context.schema,
-    value: slateEditor.children
+    value: editorEngine.children
   }, {
-    blockIndexMap: slateEditor.blockIndexMap,
-    listIndexMap: slateEditor.listIndexMap
-  }), slateEditor;
+    blockIndexMap: editorEngine.blockIndexMap,
+    listIndexMap: editorEngine.listIndexMap
+  }), editorEngine;
 }
-function createEditorDom(sendBack, slateEditor) {
+function createEditorDom(sendBack, editorEngine) {
   return {
-    getBlockNodes: (snapshot) => getBlockNodes(slateEditor, snapshot),
-    getChildNodes: (snapshot) => getChildNodes(slateEditor, snapshot),
-    getEditorElement: () => getEditorElement(slateEditor),
+    getBlockNodes: (snapshot) => getBlockNodes(editorEngine, snapshot),
+    getChildNodes: (snapshot) => getChildNodes(editorEngine, snapshot),
+    getEditorElement: () => getEditorElement(editorEngine),
     getSelectionRect: (snapshot) => getSelectionRect(snapshot),
-    getStartBlockElement: (snapshot) => getStartBlockElement(slateEditor, snapshot),
-    getEndBlockElement: (snapshot) => getEndBlockElement(slateEditor, snapshot),
+    getStartBlockElement: (snapshot) => getStartBlockElement(editorEngine, snapshot),
+    getEndBlockElement: (snapshot) => getEndBlockElement(editorEngine, snapshot),
     setDragGhost: ({
       event,
       ghost
@@ -10473,25 +10473,25 @@ function createEditorDom(sendBack, slateEditor) {
     })
   };
 }
-function getBlockNodes(slateEditor, snapshot) {
+function getBlockNodes(editorEngine, snapshot) {
   if (!snapshot.context.selection)
     return [];
   try {
     return getFragment(snapshot).flatMap((entry) => {
-      const domNode = getDomNode(slateEditor, entry.path);
+      const domNode = getDomNode(editorEngine, entry.path);
       return domNode ? [domNode] : [];
     });
   } catch {
     return [];
   }
 }
-function getChildNodes(slateEditor, snapshot) {
+function getChildNodes(editorEngine, snapshot) {
   if (!snapshot.context.selection)
     return [];
   try {
-    const [start2, end2] = rangeEdges(snapshot.context.selection, slateEditor), childEntries = [];
+    const [start2, end2] = rangeEdges(snapshot.context.selection, editorEngine), childEntries = [];
     let buffered;
-    for (const entry of getNodes(slateEditor, {
+    for (const entry of getNodes(editorEngine, {
       from: start2.path,
       to: end2.path
     })) {
@@ -10505,13 +10505,13 @@ function getChildNodes(slateEditor, snapshot) {
       }
       buffered = entry;
     }
-    return buffered && childEntries.push(buffered), childEntries.flatMap((childEntry) => getDomNode(slateEditor, childEntry.path) || []);
+    return buffered && childEntries.push(buffered), childEntries.flatMap((childEntry) => getDomNode(editorEngine, childEntry.path) || []);
   } catch {
     return [];
   }
 }
-function getEditorElement(slateEditor) {
-  return getDomNode(slateEditor, []);
+function getEditorElement(editorEngine) {
+  return getDomNode(editorEngine, []);
 }
 function getSelectionRect(snapshot) {
   if (!snapshot.context.selection)
@@ -10523,18 +10523,18 @@ function getSelectionRect(snapshot) {
     return null;
   }
 }
-function getStartBlockElement(slateEditor, snapshot) {
+function getStartBlockElement(editorEngine, snapshot) {
   const startBlock = getSelectionStartBlock(snapshot);
   if (!startBlock)
     return null;
-  const startBlockNode = getDomNode(slateEditor, startBlock.path);
+  const startBlockNode = getDomNode(editorEngine, startBlock.path);
   return startBlockNode instanceof Element ? startBlockNode : null;
 }
-function getEndBlockElement(slateEditor, snapshot) {
+function getEndBlockElement(editorEngine, snapshot) {
   const endBlock = getSelectionEndBlock(snapshot);
   if (!endBlock)
     return null;
-  const endBlockNode = getDomNode(slateEditor, endBlock.path);
+  const endBlockNode = getDomNode(editorEngine, endBlock.path);
   return endBlockNode instanceof Element ? endBlockNode : null;
 }
 function setDragGhost({
@@ -12061,6 +12061,13 @@ function createEditorSnapshot({
     decoratorState: editor.decoratorState
   };
 }
+function withPerformingBehaviorOperation(editor, fn) {
+  const prev = editor.isPerformingBehaviorOperation;
+  editor.isPerformingBehaviorOperation = !0, fn(), editor.isPerformingBehaviorOperation = prev;
+}
+function withoutNormalizingConditional(editor, predicate, fn) {
+  predicate() ? withoutNormalizing(editor, fn) : fn();
+}
 const addAnnotationOperationImplementation = ({
   snapshot,
   operation
@@ -12282,8 +12289,8 @@ const blockSetOperationImplementation = ({
   } = snapshot, blockEntry = getNode(operation.editor, operation.at);
   if (!blockEntry)
     throw new Error(`Unable to find block at ${safeStringify(operation.at)}`);
-  const slateBlock = blockEntry.node;
-  if (isTextBlockNode(context, slateBlock)) {
+  const engineBlock = blockEntry.node;
+  if (isTextBlockNode(context, engineBlock)) {
     const subSchema = getPathSubSchema(snapshot, blockEntry.path), filteredProps = {};
     for (const key of Object.keys(operation.props))
       if (key !== "_type") {
@@ -12321,7 +12328,7 @@ const blockSetOperationImplementation = ({
       }
     setNodeProperties(operation.editor, filteredProps, blockEntry.path);
   } else {
-    const schemaDefinition = getBlockObjectSchema(snapshot, slateBlock, blockEntry.path), filteredProps = {};
+    const schemaDefinition = getBlockObjectSchema(snapshot, engineBlock, blockEntry.path), filteredProps = {};
     for (const key of Object.keys(operation.props))
       if (key !== "_type") {
         if (key === "_key") {
@@ -12330,8 +12337,8 @@ const blockSetOperationImplementation = ({
         }
         schemaDefinition?.fields?.some((field) => field.name === key) && (filteredProps[key] = operation.props[key]);
       }
-    const patches = Object.entries(filteredProps).map(([key, value]) => set(value, [key])), updatedSlateBlock = applyAll(slateBlock, patches);
-    setNodeProperties(operation.editor, updatedSlateBlock, blockEntry.path);
+    const patches = Object.entries(filteredProps).map(([key, value]) => set(value, [key])), updatedEngineBlock = applyAll(engineBlock, patches);
+    setNodeProperties(operation.editor, updatedEngineBlock, blockEntry.path);
   }
 }, blockUnsetOperationImplementation = ({
   snapshot,
@@ -12342,8 +12349,8 @@ const blockSetOperationImplementation = ({
   } = snapshot, blockEntry = getNode(operation.editor, operation.at);
   if (!blockEntry)
     throw new Error(`Unable to find block at ${safeStringify(operation.at)}`);
-  const slateBlock = blockEntry.node;
-  if (isTextBlockNode(context, slateBlock)) {
+  const engineBlock = blockEntry.node;
+  if (isTextBlockNode(context, engineBlock)) {
     const propsToRemove = operation.props.filter((prop) => prop !== "_type" && prop !== "_key"), unsetProps2 = {};
     for (const prop of propsToRemove)
       unsetProps2[prop] = null;
@@ -12630,6 +12637,58 @@ const childSetOperationImplementation = ({
     }
   }
 };
+function unhangRange(snapshot, range2) {
+  const {
+    context
+  } = snapshot;
+  let [start2, end2] = rangeEdges(range2, {
+    children: context.value
+  });
+  if (start2.offset !== 0 || end2.offset !== 0 || isCollapsedRange(range2) || getSibling(snapshot, end2.path, "previous") !== void 0)
+    return range2;
+  const endBlock = getAncestorTextBlock(snapshot, end2.path), blockPath = endBlock ? endBlock.path : [];
+  for (const {
+    path: path2
+  } of getNodes(snapshot, {
+    from: start2.path,
+    to: end2.path,
+    match: (candidate, candidatePath) => isVoidNode(snapshot, candidate, candidatePath) || isEditableContainer(snapshot, candidate, candidatePath)
+  }))
+    if (!isAncestorPath(path2, start2.path) && !isAncestorPath(path2, end2.path))
+      return range2;
+  let skip = !0;
+  for (const {
+    node,
+    path: nodePath
+  } of getNodes(snapshot, {
+    from: start2.path,
+    to: end2.path,
+    match: (n) => isSpan({
+      schema: context.schema
+    }, n),
+    reverse: !0
+  })) {
+    if (skip) {
+      skip = !1;
+      continue;
+    }
+    if (isSpan({
+      schema: context.schema
+    }, node) && (node.text !== "" || isBeforePath(nodePath, blockPath, {
+      children: context.value
+    }))) {
+      end2 = {
+        path: nodePath,
+        offset: node.text.length
+      };
+      break;
+    }
+  }
+  return {
+    anchor: start2,
+    focus: end2
+  };
+}
 function getHighestObjectNode(snapshot, path2) {
   const ancestors = getAncestors(snapshot, path2);
   for (let i = ancestors.length - 1; i >= 0; i--) {
@@ -13125,58 +13184,6 @@ function isEmptyContainer(snapshot, path2) {
   const children = getChildren(snapshot, path2);
   return children.length === 1 && isEmptyTextBlock(snapshot.context, children[0].node);
 }
-function unhangRange(snapshot, range2) {
-  const {
-    context
-  } = snapshot;
-  let [start2, end2] = rangeEdges(range2, {
-    children: context.value
-  });
-  if (start2.offset !== 0 || end2.offset !== 0 || isCollapsedRange(range2) || getSibling(snapshot, end2.path, "previous") !== void 0)
-    return range2;
-  const endBlock = getAncestorTextBlock(snapshot, end2.path), blockPath = endBlock ? endBlock.path : [];
-  for (const {
-    path: path2
-  } of getNodes(snapshot, {
-    from: start2.path,
-    to: end2.path,
-    match: (candidate, candidatePath) => isVoidNode(snapshot, candidate, candidatePath) || isEditableContainer(snapshot, candidate, candidatePath)
-  }))
-    if (!isAncestorPath(path2, start2.path) && !isAncestorPath(path2, end2.path))
-      return range2;
-  let skip = !0;
-  for (const {
-    node,
-    path: nodePath
-  } of getNodes(snapshot, {
-    from: start2.path,
-    to: end2.path,
-    match: (n) => isSpan({
-      schema: context.schema
-    }, n),
-    reverse: !0
-  })) {
-    if (skip) {
-      skip = !1;
-      continue;
-    }
-    if (isSpan({
-      schema: context.schema
-    }, node) && (node.text !== "" || isBeforePath(nodePath, blockPath, {
-      children: context.value
-    }))) {
-      end2 = {
-        path: nodePath,
-        offset: node.text.length
-      };
-      break;
-    }
-  }
-  return {
-    anchor: start2,
-    focus: end2
-  };
-}
 const deleteOperationImplementation = ({
   operation
 }) => {
@@ -13239,6 +13246,10 @@ const deleteOperationImplementation = ({
     removeEmptyStartBlock: !0
   });
 };
+function pluginRedoing(editor, fn) {
+  const prev = editor.isRedoing;
+  editor.isRedoing = !0, fn(), editor.isRedoing = prev;
+}
 function transformOperation(editor, patch, operation) {
   const snapshot = editor, transformedOperation = {
     ...operation
@@ -13292,10 +13303,6 @@ function findOperationTargetBlock(snapshot, editor, operation) {
 function pathStartsWith(path2, prefix) {
   return pathEquals(path2, prefix) || isAncestorPath(prefix, path2);
 }
-function pluginRedoing(editor, fn) {
-  const prev = editor.isRedoing;
-  editor.isRedoing = !0, fn(), editor.isRedoing = prev;
-}
 const historyRedoOperationImplementation = ({
   operation
 }) => {
@@ -13478,7 +13485,7 @@ const historyUndoOperationImplementation = ({
   });
   if (!parsedBlock)
     return;
-  const block = toSlateBlock(parsedBlock, {
+  const block = toEngineBlock(parsedBlock, {
     schemaTypes: context.schema
   }), target = resolveTarget({
     editor,
@@ -14060,27 +14067,6 @@ const moveBackwardOperationImplementation = ({
     distance: operation.distance,
     reverse: !0
   });
-}, moveBlockOperationImplementation = ({
-  operation
-}) => {
-  const editor = operation.editor, originEntry = getNode(editor, operation.at);
-  if (!originEntry)
-    throw new Error(`Failed to resolve origin block at ${safeStringify(operation.at)}`);
-  const destinationEntry = getNode(editor, operation.to);
-  if (!destinationEntry)
-    throw new Error(`Failed to resolve destination block at ${safeStringify(operation.to)}`);
-  const siblings = getChildren(editor, parentPath(originEntry.path)), originIndex = siblings.findIndex((sibling) => sibling.node._key === originEntry.node._key), destinationIndex = siblings.findIndex((sibling) => sibling.node._key === destinationEntry.node._key), movingDown = originIndex !== -1 && destinationIndex !== -1 && originIndex < destinationIndex, node = originEntry.node, savedSelection = editor.selection;
-  withoutNormalizing(editor, () => {
-    editor.apply({
-      type: "unset",
-      path: originEntry.path
-    }), editor.apply({
-      type: "insert",
-      path: destinationEntry.path,
-      node,
-      position: movingDown ? "after" : "before"
-    });
-  }), savedSelection && (editor.selection = savedSelection);
 }, moveForwardOperationImplementation = ({
   operation
 }) => {
@@ -14134,7 +14120,6 @@ const moveBackwardOperationImplementation = ({
   "insert.child": insertChildOperationImplementation,
   "insert.text": insertTextOperationImplementation,
   "move.backward": moveBackwardOperationImplementation,
-  "move.block": moveBlockOperationImplementation,
   "move.forward": moveForwardOperationImplementation,
   "remove.text": removeTextOperationImplementation,
   select: selectOperationImplementation,
@@ -14158,13 +14143,6 @@ function performOperation({
   };
   isNormalizing(operation.editor) ? withoutNormalizing(operation.editor, perform) : perform();
 }
-function withPerformingBehaviorOperation(editor, fn) {
-  const prev = editor.isPerformingBehaviorOperation;
-  editor.isPerformingBehaviorOperation = !0, fn(), editor.isPerformingBehaviorOperation = prev;
-}
-function withoutNormalizingConditional(editor, predicate, fn) {
-  predicate() ? withoutNormalizing(editor, fn) : fn();
-}
 const abstractAnnotationBehaviors = [defineBehavior({
   on: "annotation.set",
   guard: ({
@@ -15306,7 +15284,7 @@ const abstractInsertBehaviors = [
   }]
 }), abstractKeyboardBehaviors = [
   /**
-   * When Backspace is pressed on an inline object, Slate will raise a
+   * When Backspace is pressed on an inline object, the engine raises a
    * `delete.backward` event with `unit: 'block'`. This is wrong and this
    * Behavior adjusts that.
    */
@@ -15322,7 +15300,7 @@ const abstractInsertBehaviors = [
     })]]
   }),
   /**
-   * When Delete is pressed on an inline object, Slate will raise a
+   * When Delete is pressed on an inline object, the engine raises a
    * `delete.forward` event with `unit: 'block'`. This is wrong and this
    * Behavior adjusts that.
    */
@@ -15525,6 +15503,35 @@ const abstractInsertBehaviors = [
     listItem: event.listItem
   })]]
 })], abstractMoveBehaviors = [defineBehavior({
+  on: "move.block",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    const originEntry = getNode(snapshot, event.at), destinationEntry = getNode(snapshot, event.to);
+    if (!originEntry || !destinationEntry || pathEquals(originEntry.path, destinationEntry.path))
+      return !1;
+    const siblings = getChildren(snapshot, parentPath(originEntry.path)), originIndex = siblings.findIndex((sibling) => sibling.node._key === originEntry.node._key), destinationIndex = siblings.findIndex((sibling) => sibling.node._key === destinationEntry.node._key), movingDown = originIndex !== -1 && destinationIndex !== -1 && originIndex < destinationIndex;
+    return {
+      originEntry,
+      destinationEntry,
+      movingDown
+    };
+  },
+  actions: [(_, {
+    originEntry,
+    destinationEntry,
+    movingDown
+  }) => [raise({
+    type: "unset",
+    at: originEntry.path
+  }), raise({
+    type: "insert",
+    at: destinationEntry.path,
+    value: originEntry.node,
+    position: movingDown ? "after" : "before"
+  })]]
+}), defineBehavior({
   on: "move.block up",
   guard: ({
     snapshot,
@@ -15532,18 +15539,26 @@ const abstractInsertBehaviors = [
   }) => {
     const previousSibling = getSibling(snapshot, event.at, "previous");
     return previousSibling ? {
-      previousSibling
+      previousSibling,
+      savedSelection: snapshot.context.selection
     } : !1;
   },
   actions: [({
     event
   }, {
-    previousSibling
-  }) => [raise({
-    type: "move.block",
-    at: event.at,
-    to: previousSibling.path
-  })]]
+    previousSibling,
+    savedSelection
+  }) => {
+    const actions = [raise({
+      type: "move.block",
+      at: event.at,
+      to: previousSibling.path
+    })];
+    return savedSelection && actions.push(raise({
+      type: "select",
+      at: savedSelection
+    })), actions;
+  }]
 }), defineBehavior({
   on: "move.block down",
   guard: ({
@@ -15552,18 +15567,26 @@ const abstractInsertBehaviors = [
   }) => {
     const nextSibling = getSibling(snapshot, event.at, "next");
     return nextSibling ? {
-      nextSibling
+      nextSibling,
+      savedSelection: snapshot.context.selection
     } : !1;
   },
   actions: [({
     event
   }, {
-    nextSibling
-  }) => [raise({
-    type: "move.block",
-    at: event.at,
-    to: nextSibling.path
-  })]]
+    nextSibling,
+    savedSelection
+  }) => {
+    const actions = [raise({
+      type: "move.block",
+      at: event.at,
+      to: nextSibling.path
+    })];
+    return savedSelection && actions.push(raise({
+      type: "select",
+      at: savedSelection
+    })), actions;
+  }]
 })], abstractSelectBehaviors = [defineBehavior({
   on: "select.block",
   guard: ({
@@ -15955,7 +15978,7 @@ const abstractInsertBehaviors = [
 function isSyntheticBehaviorEvent(event) {
   return !isCustomBehaviorEvent(event) && !isNativeBehaviorEvent(event) && !isAbstractBehaviorEvent(event);
 }
-const abstractBehaviorEventTypes = ["annotation.set", "annotation.toggle", "decorator.toggle", "delete.backward", "delete.block", "delete.child", "delete.forward", "delete.text", "deserialize", "deserialize.data", "deserialization.success", "deserialization.failure", "insert.blocks", "insert.break", "insert.inline object", "insert.soft break", "insert.span", "list item.add", "list item.remove", "list item.toggle", "move.block down", "move.block up", "select.block", "select.previous block", "select.next block", "serialize", "serialize.data", "serialization.success", "serialization.failure", "split", "style.add", "style.remove", "style.toggle"];
+const abstractBehaviorEventTypes = ["annotation.set", "annotation.toggle", "decorator.toggle", "delete.backward", "delete.block", "delete.child", "delete.forward", "delete.text", "deserialize", "deserialize.data", "deserialization.success", "deserialization.failure", "insert.blocks", "insert.break", "insert.inline object", "insert.soft break", "insert.span", "list item.add", "list item.remove", "list item.toggle", "move.block", "move.block down", "move.block up", "select.block", "select.previous block", "select.next block", "serialize", "serialize.data", "serialization.success", "serialization.failure", "split", "style.add", "style.remove", "style.toggle"];
 function isAbstractBehaviorEvent(event) {
   return abstractBehaviorEventTypes.includes(event.type);
 }
@@ -16310,18 +16333,18 @@ function isTypeAlreadyRegistered(maps, attempting, type) {
 }
 function rerouteExternalBehaviorEvent({
   event,
-  slateEditor
+  editorEngine
 }) {
   switch (event.type) {
     case "blur":
       return {
         type: "blur",
-        editor: slateEditor
+        editor: editorEngine
       };
     case "focus":
       return {
         type: "focus",
-        editor: slateEditor
+        editor: editorEngine
       };
     case "insert.block object":
       return {
@@ -16334,13 +16357,13 @@ function rerouteExternalBehaviorEvent({
           },
           placement: event.placement
         },
-        editor: slateEditor
+        editor: editorEngine
       };
     default:
       return {
         type: "behavior event",
         behaviorEvent: event,
-        editor: slateEditor
+        editor: editorEngine
       };
   }
 }
@@ -16366,11 +16389,11 @@ const editorMachine = setup({
         event
       }) => (assertEvent(event, "remove behavior"), context.behaviors.delete(event.behaviorConfig), /* @__PURE__ */ new Set([...context.behaviors]))
     }),
-    "add slate editor to context": assign({
-      slateEditor: ({
+    "add editor engine to context": assign({
+      editorEngine: ({
         context,
         event
-      }) => event.type === "add slate editor" ? event.editor : context.slateEditor
+      }) => event.type === "add editor engine" ? event.editor : context.editorEngine
     }),
     register: assign(({
       context,
@@ -16385,9 +16408,9 @@ const editorMachine = setup({
         if (!containerConfig)
           return {};
         const containers = new Map(context.containers);
-        return containers.set(node.type, containerConfig), context.slateEditor && (context.slateEditor.containers = containers, context.slateEditor.publicContainers = buildPublicContainers(containers), normalize(context.slateEditor, {
+        return containers.set(node.type, containerConfig), context.editorEngine && (context.editorEngine.containers = containers, context.editorEngine.publicContainers = buildPublicContainers(containers), normalize(context.editorEngine, {
           force: !0
-        }), context.slateEditor.onChange()), {
+        }), context.editorEngine.onChange()), {
           containers
         };
       }
@@ -16395,7 +16418,7 @@ const editorMachine = setup({
         if (isTypeAlreadyRegistered(context, "textBlock", node.type))
           return {};
         const textBlocks = new Map(context.textBlocks);
-        return textBlocks.set(node.type, resolveTextBlockConfig(node)), context.slateEditor && (context.slateEditor.textBlocks = textBlocks, context.slateEditor.onChange()), {
+        return textBlocks.set(node.type, resolveTextBlockConfig(node)), context.editorEngine && (context.editorEngine.textBlocks = textBlocks, context.editorEngine.onChange()), {
           textBlocks
         };
       }
@@ -16405,7 +16428,7 @@ const editorMachine = setup({
         const spans = new Map(context.spans);
         return spans.set(node.type, {
           span: node
-        }), context.slateEditor && (context.slateEditor.spans = spans, context.slateEditor.onChange()), {
+        }), context.editorEngine && (context.editorEngine.spans = spans, context.editorEngine.onChange()), {
           spans
         };
       }
@@ -16415,7 +16438,7 @@ const editorMachine = setup({
         const blockObjects = new Map(context.blockObjects);
         return blockObjects.set(node.type, {
           blockObject: node
-        }), context.slateEditor && (context.slateEditor.blockObjects = blockObjects, context.slateEditor.onChange()), {
+        }), context.editorEngine && (context.editorEngine.blockObjects = blockObjects, context.editorEngine.onChange()), {
           blockObjects
         };
       }
@@ -16424,7 +16447,7 @@ const editorMachine = setup({
       const inlineObjects = new Map(context.inlineObjects);
       return inlineObjects.set(node.type, {
         inlineObject: node
-      }), context.slateEditor && (context.slateEditor.inlineObjects = inlineObjects, context.slateEditor.onChange()), {
+      }), context.editorEngine && (context.editorEngine.inlineObjects = inlineObjects, context.editorEngine.onChange()), {
         inlineObjects
       };
     }),
@@ -16436,41 +16459,41 @@ const editorMachine = setup({
       const node = event.node;
       if (node.kind === "container") {
         const containers = new Map(context.containers);
-        return containers.delete(node.type), context.slateEditor && (context.slateEditor.containers = containers, context.slateEditor.publicContainers = buildPublicContainers(containers), normalize(context.slateEditor, {
+        return containers.delete(node.type), context.editorEngine && (context.editorEngine.containers = containers, context.editorEngine.publicContainers = buildPublicContainers(containers), normalize(context.editorEngine, {
           force: !0
-        }), context.slateEditor.onChange()), {
+        }), context.editorEngine.onChange()), {
           containers
         };
       }
       if (node.kind === "textBlock") {
         const textBlocks = new Map(context.textBlocks);
-        return textBlocks.delete(node.type), context.slateEditor && (context.slateEditor.textBlocks = textBlocks, context.slateEditor.onChange()), {
+        return textBlocks.delete(node.type), context.editorEngine && (context.editorEngine.textBlocks = textBlocks, context.editorEngine.onChange()), {
           textBlocks
         };
       }
       if (node.kind === "span") {
         const spans = new Map(context.spans);
-        return spans.delete(node.type), context.slateEditor && (context.slateEditor.spans = spans, context.slateEditor.onChange()), {
+        return spans.delete(node.type), context.editorEngine && (context.editorEngine.spans = spans, context.editorEngine.onChange()), {
           spans
         };
       }
       if (node.kind === "blockObject") {
         const blockObjects = new Map(context.blockObjects);
-        return blockObjects.delete(node.type), context.slateEditor && (context.slateEditor.blockObjects = blockObjects, context.slateEditor.onChange()), {
+        return blockObjects.delete(node.type), context.editorEngine && (context.editorEngine.blockObjects = blockObjects, context.editorEngine.onChange()), {
           blockObjects
         };
       }
       const inlineObjects = new Map(context.inlineObjects);
-      return inlineObjects.delete(node.type), context.slateEditor && (context.slateEditor.inlineObjects = inlineObjects, context.slateEditor.onChange()), {
+      return inlineObjects.delete(node.type), context.editorEngine && (context.editorEngine.inlineObjects = inlineObjects, context.editorEngine.onChange()), {
         inlineObjects
       };
     }),
-    "attach maps to slate editor": ({
+    "attach maps to editor engine": ({
       context
     }) => {
-      context.slateEditor && (context.slateEditor.containers = context.containers, context.slateEditor.publicContainers = buildPublicContainers(context.containers), context.slateEditor.blockObjects = context.blockObjects, context.slateEditor.inlineObjects = context.inlineObjects, context.slateEditor.spans = context.spans, context.slateEditor.textBlocks = context.textBlocks, normalize(context.slateEditor, {
+      context.editorEngine && (context.editorEngine.containers = context.containers, context.editorEngine.publicContainers = buildPublicContainers(context.containers), context.editorEngine.blockObjects = context.blockObjects, context.editorEngine.inlineObjects = context.inlineObjects, context.editorEngine.spans = context.spans, context.editorEngine.textBlocks = context.textBlocks, normalize(context.editorEngine, {
         force: !0
-      }), context.slateEditor.onChange());
+      }), context.editorEngine.onChange());
     },
     "emit patch event": emit(({
       event
@@ -16546,14 +16569,14 @@ const editorMachine = setup({
     "handle focus": ({
       context
     }) => {
-      const slateEditor = context.slateEditor;
-      if (!slateEditor) {
-        console.error("No Slate editor found to focus");
+      const editorEngine = context.editorEngine;
+      if (!editorEngine) {
+        console.error("No editor engine found to focus");
         return;
       }
       try {
-        const currentSelection = slateEditor.selection;
-        DOMEditor.focus(slateEditor), currentSelection && (slateEditor.select(currentSelection), slateEditor.pendingSelection = slateEditor.selection, slateEditor.onChange());
+        const currentSelection = editorEngine.selection;
+        DOMEditor.focus(editorEngine), currentSelection && (editorEngine.select(currentSelection), editorEngine.pendingSelection = editorEngine.selection, editorEngine.onChange());
       } catch (error) {
         console.error(new Error(`Failed to focus editor: ${error instanceof Error ? error.message : error}`));
       }
@@ -16586,7 +16609,7 @@ const editorMachine = setup({
             }
             self.send(rerouteExternalBehaviorEvent({
               event: eventSentBack,
-              slateEditor: event.editor
+              editorEngine: event.editor
             }));
           }
         });
@@ -16602,12 +16625,12 @@ const editorMachine = setup({
     })
   },
   guards: {
-    "slate is busy": ({
+    "engine is busy": ({
       context
-    }) => context.slateEditor ? context.slateEditor.operations.length > 0 : !1,
-    "slate is normalizing node": ({
+    }) => context.editorEngine ? context.editorEngine.operations.length > 0 : !1,
+    "engine is normalizing node": ({
       context
-    }) => context.slateEditor ? context.slateEditor.isNormalizingNode : !1
+    }) => context.editorEngine ? context.editorEngine.isNormalizingNode : !1
   }
 }).createMachine({
   id: "editor",
@@ -16637,8 +16660,8 @@ const editorMachine = setup({
     "remove behavior": {
       actions: "remove behavior from context"
     },
-    "add slate editor": {
-      actions: ["add slate editor to context", "attach maps to slate editor"]
+    "add editor engine": {
+      actions: ["add editor engine to context", "attach maps to editor engine"]
     },
     register: {
       actions: ["register"]
@@ -16737,7 +16760,7 @@ const editorMachine = setup({
             focus: {
               target: ".focusing",
               actions: [assign({
-                slateEditor: ({
+                editorEngine: ({
                   event
                 }) => event.editor
               })]
@@ -16776,7 +16799,7 @@ const editorMachine = setup({
                     debug.state("exit: edit mode->editable->focusing->checking if busy");
                   }],
                   always: [{
-                    guard: "slate is busy",
+                    guard: "engine is busy",
                     target: "busy"
                   }, {
                     target: "#editor.edit mode.editable.idle",
@@ -16923,14 +16946,14 @@ const editorMachine = setup({
                       }],
                       on: {
                         "internal.patch": [{
-                          guard: "slate is normalizing node",
+                          guard: "engine is normalizing node",
                           actions: "defer event"
                         }, {
                           actions: "defer event",
                           target: "#editor.setup.set up.writing.dirty"
                         }],
                         mutation: [{
-                          guard: "slate is normalizing node",
+                          guard: "engine is normalizing node",
                           actions: "defer event"
                         }, {
                           actions: "defer event",
@@ -16992,7 +17015,7 @@ const editorMachine = setup({
     "set is deferring mutations": ({
       context
     }) => {
-      context.slateEditor.isDeferringMutations = !0;
+      context.editorEngine.isDeferringMutations = !0;
     },
     "emit mutations": enqueueActions(({
       context,
@@ -17004,7 +17027,7 @@ const editorMachine = setup({
           patches: bulk.patches,
           snapshot: bulk.value
         });
-      context.slateEditor.isDeferringMutations = !1;
+      context.editorEngine.isDeferringMutations = !1;
     }),
     "clear pending mutations": assign({
       pendingMutations: []
@@ -17054,15 +17077,15 @@ const editorMachine = setup({
       input,
       sendBack
     }) => {
-      const originalApply = input.slateEditor.apply;
-      return input.slateEditor.apply = (op) => {
+      const originalApply = input.editorEngine.apply;
+      return input.editorEngine.apply = (op) => {
         op.type === "insert_text" || op.type === "remove_text" ? sendBack({
           type: "typing"
         }) : sendBack({
           type: "not typing"
         }), originalApply(op);
       }, () => {
-        input.slateEditor.apply = originalApply;
+        input.editorEngine.apply = originalApply;
       };
     }),
     "mutation interval": fromCallback(({
@@ -17086,9 +17109,9 @@ const editorMachine = setup({
     "is read-only": ({
       context
     }) => context.readOnly,
-    "slate is normalizing": ({
+    "engine is normalizing": ({
       context
-    }) => isNormalizing(context.slateEditor)
+    }) => isNormalizing(context.editorEngine)
   },
   delays: {
     "type debounce": 250
@@ -17102,7 +17125,7 @@ const editorMachine = setup({
     pendingPatchEvents: [],
     readOnly: input.readOnly,
     schema: input.schema,
-    slateEditor: input.slateEditor
+    editorEngine: input.editorEngine
   }),
   on: {
     "update readOnly": {
@@ -17118,7 +17141,7 @@ const editorMachine = setup({
         input: ({
           context
         }) => ({
-          slateEditor: context.slateEditor
+          editorEngine: context.editorEngine
         })
       },
       states: {
@@ -17194,7 +17217,7 @@ const editorMachine = setup({
           },
           on: {
             "emit changes": {
-              guard: and([not("is read-only"), "slate is normalizing"]),
+              guard: and([not("is read-only"), "engine is normalizing"]),
               target: "idle",
               actions: ["emit pending patch events", "clear pending patch events", "emit mutations", "clear pending mutations"]
             },
@@ -17246,7 +17269,7 @@ const editorMachine = setup({
       guard: ({
         context,
         event
-      }) => context.prevSelection !== event.selection,
+      }) => !isEqualSelections(context.prevSelection, event.selection),
       actions: [assign({
         prevSelection: ({
           event
@@ -17606,7 +17629,7 @@ const syncValueCallback = ({
   updateValue({
     context: input.context,
     sendBack,
-    slateEditor: input.slateEditor,
+    editorEngine: input.editorEngine,
     value: input.value,
     streamBlocks: input.streamBlocks
   });
@@ -17653,11 +17676,11 @@ const syncValueCallback = ({
     "is busy": ({
       context
     }) => {
-      const isBusy = context.slateEditor.isDeferringMutations || context.slateEditor.isProcessingRemoteChanges;
+      const isBusy = context.editorEngine.isDeferringMutations || context.editorEngine.isProcessingRemoteChanges;
       return debug.syncValue(safeStringify({
         isBusy,
-        isDeferringMutations: context.slateEditor.isDeferringMutations,
-        isProcessingRemoteChanges: context.slateEditor.isProcessingRemoteChanges
+        isDeferringMutations: context.editorEngine.isDeferringMutations,
+        isProcessingRemoteChanges: context.editorEngine.isProcessingRemoteChanges
       })), isBusy;
     },
     "is empty value": ({
@@ -17697,7 +17720,7 @@ const syncValueCallback = ({
     keyGenerator: input.keyGenerator,
     schema: input.schema,
     readOnly: input.readOnly,
-    slateEditor: input.slateEditor,
+    editorEngine: input.editorEngine,
     pendingValue: void 0,
     previousValue: void 0
   }),
@@ -17796,7 +17819,7 @@ const syncValueCallback = ({
             readOnly: context.readOnly,
             schema: context.schema
           },
-          slateEditor: context.slateEditor,
+          editorEngine: context.editorEngine,
           streamBlocks: !context.initialValueSynced,
           value: context.pendingValue
         })
@@ -17837,14 +17860,14 @@ const syncValueCallback = ({
 async function updateValue({
   context,
   sendBack,
-  slateEditor,
+  editorEngine,
   streamBlocks,
   value
 }) {
   let doneSyncing = !1, isChanged = !1, isValid = !0;
-  const hadSelection = !!slateEditor.selection;
+  const hadSelection = !!editorEngine.selection;
   if ((!value || value.length === 0) && (clearEditor({
-    slateEditor,
+    editorEngine,
     doneSyncing
   }), isChanged = !0), value && value.length > 0)
     if (streamBlocks)
@@ -17854,7 +17877,7 @@ async function updateValue({
           return;
         }
         isChanged = removeExtraBlocks({
-          slateEditor,
+          editorEngine,
           value
         }), (async () => {
           for await (const [currentBlock, currentBlockIndex] of getStreamedBlocks({
@@ -17868,7 +17891,7 @@ async function updateValue({
               sendBack,
               block: currentBlock,
               index: currentBlockIndex,
-              slateEditor,
+              editorEngine,
               value
             });
             if (isChanged = blockChanged || isChanged, isValid = isValid && blockValid, !isValid)
@@ -17881,7 +17904,7 @@ async function updateValue({
       if (doneSyncing)
         return;
       isChanged = removeExtraBlocks({
-        slateEditor,
+        editorEngine,
         value
       });
       let index = 0;
@@ -17894,7 +17917,7 @@ async function updateValue({
           sendBack,
           block,
           index,
-          slateEditor,
+          editorEngine,
           value
         });
         if (isChanged = blockChanged || isChanged, isValid = isValid && blockValid, !blockValid)
@@ -17912,7 +17935,7 @@ async function updateValue({
   if (isChanged) {
     debug.syncValue("remote value changed, syncing local value");
     try {
-      slateEditor.onChange();
+      editorEngine.onChange();
     } catch (err) {
       console.error(err), sendBack({
         type: "invalid value",
@@ -17924,7 +17947,7 @@ async function updateValue({
       });
       return;
     }
-    hadSelection && !slateEditor.selection && slateEditor.children.length > 0 && (applySelect(slateEditor, start(slateEditor, [])), slateEditor.onChange()), sendBack({
+    hadSelection && !editorEngine.selection && editorEngine.children.length > 0 && (applySelect(editorEngine, start(editorEngine, [])), editorEngine.onChange()), sendBack({
       type: "value changed",
       value
     });
@@ -17943,19 +17966,19 @@ async function* getStreamedBlocks({
     index % 10 === 0 && await new Promise((resolve) => setTimeout(resolve, 0)), yield [block, index], index++;
 }
 function clearEditor({
-  slateEditor,
+  editorEngine,
   doneSyncing
 }) {
-  withoutNormalizing(slateEditor, () => {
-    pluginWithoutHistory(slateEditor, () => {
-      withRemoteChanges(slateEditor, () => {
-        withoutPatching(slateEditor, () => {
+  withoutNormalizing(editorEngine, () => {
+    pluginWithoutHistory(editorEngine, () => {
+      withRemoteChanges(editorEngine, () => {
+        withoutPatching(editorEngine, () => {
           if (doneSyncing)
             return;
-          const childrenLength = slateEditor.children.length;
-          slateEditor.children.forEach((_, index) => {
-            const removeNode = slateEditor.children[childrenLength - 1 - index];
-            removeNode && slateEditor.apply({
+          const childrenLength = editorEngine.children.length;
+          editorEngine.children.forEach((_, index) => {
+            const removeNode = editorEngine.children[childrenLength - 1 - index];
+            removeNode && editorEngine.apply({
               type: "unset",
               path: [{
                 _key: removeNode._key
@@ -17968,18 +17991,18 @@ function clearEditor({
   });
 }
 function removeExtraBlocks({
-  slateEditor,
+  editorEngine,
   value
 }) {
   let isChanged = !1;
-  return withoutNormalizing(slateEditor, () => {
-    withRemoteChanges(slateEditor, () => {
-      withoutPatching(slateEditor, () => {
-        const childrenLength = slateEditor.children.length;
+  return withoutNormalizing(editorEngine, () => {
+    withRemoteChanges(editorEngine, () => {
+      withoutPatching(editorEngine, () => {
+        const childrenLength = editorEngine.children.length;
         if (value.length < childrenLength) {
           for (let i = childrenLength - 1; i > value.length - 1; i--) {
-            const removeNode = slateEditor.children[i];
-            removeNode && slateEditor.apply({
+            const removeNode = editorEngine.children[i];
+            removeNode && editorEngine.apply({
               type: "unset",
               path: [{
                 _key: removeNode._key
@@ -17997,23 +18020,23 @@ function syncBlock({
   sendBack,
   block,
   index,
-  slateEditor,
+  editorEngine,
   value
 }) {
-  const oldSlateBlock = slateEditor.children.at(index), oldBlock = slateEditor.children.at(index);
-  if (!oldSlateBlock || !oldBlock) {
+  const oldEngineBlock = editorEngine.children.at(index), oldBlock = editorEngine.children.at(index);
+  if (!oldEngineBlock || !oldBlock) {
     const validation2 = validateValue([block], context.schema, context.keyGenerator);
     if (debug.syncValue("Validating and inserting new block in the end of the value", block), validation2.valid || validation2.resolution?.autoResolve) {
-      const slateBlock = toSlateBlock(block, {
+      const engineBlock = toEngineBlock(block, {
         schemaTypes: context.schema
       });
-      return withoutNormalizing(slateEditor, () => {
-        withRemoteChanges(slateEditor, () => {
-          withoutPatching(slateEditor, () => {
-            slateEditor.apply({
+      return withoutNormalizing(editorEngine, () => {
+        withRemoteChanges(editorEngine, () => {
+          withoutPatching(editorEngine, () => {
+            editorEngine.apply({
               type: "insert",
-              path: [slateEditor.children.length],
-              node: slateBlock,
+              path: [editorEngine.children.length],
+              node: engineBlock,
               position: "before"
             });
           });
@@ -18049,24 +18072,24 @@ function syncBlock({
       type: "patch",
       patch
     });
-  })), validation.valid || validation.resolution?.autoResolve ? (oldBlock._key === block._key && oldBlock._type === block._type ? (debug.syncValue("Updating block", oldBlock, block), withoutNormalizing(slateEditor, () => {
-    withRemoteChanges(slateEditor, () => {
-      withoutPatching(slateEditor, () => {
+  })), validation.valid || validation.resolution?.autoResolve ? (oldBlock._key === block._key && oldBlock._type === block._type ? (debug.syncValue("Updating block", oldBlock, block), withoutNormalizing(editorEngine, () => {
+    withRemoteChanges(editorEngine, () => {
+      withoutPatching(editorEngine, () => {
         updateBlock({
           context,
-          slateEditor,
-          oldSlateBlock,
+          editorEngine,
+          oldEngineBlock,
           block,
           index
         });
       });
     });
-  })) : (debug.syncValue("Replacing block", oldBlock, block), withoutNormalizing(slateEditor, () => {
-    withRemoteChanges(slateEditor, () => {
-      withoutPatching(slateEditor, () => {
+  })) : (debug.syncValue("Replacing block", oldBlock, block), withoutNormalizing(editorEngine, () => {
+    withRemoteChanges(editorEngine, () => {
+      withoutPatching(editorEngine, () => {
         replaceBlock({
           context,
-          slateEditor,
+          editorEngine,
           block,
           index
         });
@@ -18086,84 +18109,84 @@ function syncBlock({
 }
 function replaceBlock({
   context,
-  slateEditor,
+  editorEngine,
   block,
   index
 }) {
-  const slateBlock = toSlateBlock(block, {
+  const engineBlock = toEngineBlock(block, {
     schemaTypes: context.schema
-  }), currentSelection = slateEditor.selection, focusBlockSegment = currentSelection?.focus.path[0], blockAtIndex = slateEditor.children[index], selectionFocusOnBlock = currentSelection && isKeyedSegment(focusBlockSegment) && blockAtIndex && focusBlockSegment._key === blockAtIndex._key;
-  selectionFocusOnBlock && applyDeselect(slateEditor);
-  const oldNode = slateEditor.children[index];
-  oldNode && (slateEditor.apply({
+  }), currentSelection = editorEngine.selection, focusBlockSegment = currentSelection?.focus.path[0], blockAtIndex = editorEngine.children[index], selectionFocusOnBlock = currentSelection && isKeyedSegment(focusBlockSegment) && blockAtIndex && focusBlockSegment._key === blockAtIndex._key;
+  selectionFocusOnBlock && applyDeselect(editorEngine);
+  const oldNode = editorEngine.children[index];
+  oldNode && (editorEngine.apply({
     type: "unset",
     path: [{
       _key: oldNode._key
     }]
-  }), slateEditor.apply({
+  }), editorEngine.apply({
     type: "insert",
     path: [index],
-    node: slateBlock,
+    node: engineBlock,
     position: "before"
-  }), slateEditor.onChange(), selectionFocusOnBlock && hasNode(slateEditor, currentSelection.anchor.path) && hasNode(slateEditor, currentSelection.focus.path) && applySelect(slateEditor, currentSelection));
+  }), editorEngine.onChange(), selectionFocusOnBlock && hasNode(editorEngine, currentSelection.anchor.path) && hasNode(editorEngine, currentSelection.focus.path) && applySelect(editorEngine, currentSelection));
 }
 function updateBlock({
   context,
-  slateEditor,
-  oldSlateBlock,
+  editorEngine,
+  oldEngineBlock,
   block,
   index: _index
 }) {
-  const slateBlock = toSlateBlock(block, {
+  const engineBlock = toEngineBlock(block, {
     schemaTypes: context.schema
   }), {
     children: _children,
     ...blockProps
-  } = slateBlock;
-  setNodeProperties(slateEditor, blockProps, [{
-    _key: oldSlateBlock._key
+  } = engineBlock;
+  setNodeProperties(editorEngine, blockProps, [{
+    _key: oldEngineBlock._key
   }]);
-  const oldRecord = oldSlateBlock, newRecord = slateBlock, removedProperties = {};
+  const oldRecord = oldEngineBlock, newRecord = engineBlock, removedProperties = {};
   for (const key of Object.keys(oldRecord))
     key === "children" || key === "text" || newRecord.hasOwnProperty(key) || (removedProperties[key] = null);
-  if (Object.keys(removedProperties).length > 0 && setNodeProperties(slateEditor, removedProperties, [{
-    _key: oldSlateBlock._key
+  if (Object.keys(removedProperties).length > 0 && setNodeProperties(editorEngine, removedProperties, [{
+    _key: oldEngineBlock._key
   }]), isTextBlock({
-    schema: slateEditor.schema
-  }, slateBlock) && isTextBlock({
-    schema: slateEditor.schema
-  }, oldSlateBlock)) {
-    const oldKeys = oldSlateBlock.children.map((c2) => c2._key), newKeys = slateBlock.children.map((c2) => c2._key), oldKeySet = new Set(oldKeys), hasSharedKeys = newKeys.some((key) => oldKeySet.has(key));
+    schema: editorEngine.schema
+  }, engineBlock) && isTextBlock({
+    schema: editorEngine.schema
+  }, oldEngineBlock)) {
+    const oldKeys = oldEngineBlock.children.map((c2) => c2._key), newKeys = engineBlock.children.map((c2) => c2._key), oldKeySet = new Set(oldKeys), hasSharedKeys = newKeys.some((key) => oldKeySet.has(key));
     if (oldKeys.length === newKeys.length && oldKeys.length > 0 && oldKeySet.size === oldKeys.length && oldKeys.some((key, i) => key !== newKeys[i]) && newKeys.every((key) => oldKeySet.has(key)) || newKeys.length > 0 && !hasSharedKeys) {
-      debug.syncValue("Replacing children via set"), setNodeProperties(slateEditor, {
-        children: slateBlock.children
+      debug.syncValue("Replacing children via set"), setNodeProperties(editorEngine, {
+        children: engineBlock.children
       }, [{
-        _key: oldSlateBlock._key
-      }]), slateEditor.onChange();
+        _key: oldEngineBlock._key
+      }]), editorEngine.onChange();
       return;
     }
-    const oldBlockChildrenLength = oldSlateBlock.children.length;
-    slateBlock.children.length < oldBlockChildrenLength && Array.from(Array(oldBlockChildrenLength - slateBlock.children.length)).forEach((_, i) => {
+    const oldBlockChildrenLength = oldEngineBlock.children.length;
+    engineBlock.children.length < oldBlockChildrenLength && Array.from(Array(oldBlockChildrenLength - engineBlock.children.length)).forEach((_, i) => {
       const childIndex = oldBlockChildrenLength - 1 - i;
       if (childIndex > 0) {
         debug.syncValue("Removing child");
-        const childNode = oldSlateBlock.children[childIndex];
+        const childNode = oldEngineBlock.children[childIndex];
         if (!childNode)
           return;
-        slateEditor.apply({
+        editorEngine.apply({
           type: "unset",
           path: [{
-            _key: oldSlateBlock._key
+            _key: oldEngineBlock._key
           }, "children", {
             _key: childNode._key
           }]
         });
       }
-    }), slateBlock.children.forEach((currentBlockChild, currentBlockChildIndex) => {
-      const oldBlockChild = oldSlateBlock.children.at(currentBlockChildIndex), isChildChanged = !oldBlockChild || !isEqualChild(currentBlockChild, oldBlockChild, slateEditor.schema.span.name), isTextChanged = oldBlockChild && isSpan({
-        schema: slateEditor.schema
+    }), engineBlock.children.forEach((currentBlockChild, currentBlockChildIndex) => {
+      const oldBlockChild = oldEngineBlock.children.at(currentBlockChildIndex), isChildChanged = !oldBlockChild || !isEqualChild(currentBlockChild, oldBlockChild, editorEngine.schema.span.name), isTextChanged = oldBlockChild && isSpan({
+        schema: editorEngine.schema
       }, oldBlockChild) && currentBlockChild.text !== oldBlockChild.text, path2 = [{
-        _key: oldSlateBlock._key
+        _key: oldEngineBlock._key
       }, "children", {
         _key: currentBlockChild._key
       }];
@@ -18174,13 +18197,13 @@ function updateBlock({
             text: _text,
             ...childProps
           } = currentBlockChild;
-          setNodeProperties(slateEditor, childProps, path2);
+          setNodeProperties(editorEngine, childProps, path2);
           const isSpanNode2 = isSpan({
             schema: context.schema
           }, currentBlockChild) && isSpan({
             schema: context.schema
           }, oldBlockChild);
-          isSpanNode2 && isTextChanged ? (oldBlockChild.text.length > 0 && deleteRange(slateEditor, {
+          isSpanNode2 && isTextChanged ? (oldBlockChild.text.length > 0 && deleteRange(editorEngine, {
             focus: {
               path: path2,
               offset: 0
@@ -18192,63 +18215,63 @@ function updateBlock({
           }, {
             selection: "preserve",
             removeEmptyStartBlock: !0
-          }), slateEditor.apply({
+          }), editorEngine.apply({
             type: "insert_text",
             path: path2,
             offset: 0,
             text: currentBlockChild.text
-          }), slateEditor.onChange()) : isSpanNode2 || debug.syncValue("Updating changed inline object child", currentBlockChild);
+          }), editorEngine.onChange()) : isSpanNode2 || debug.syncValue("Updating changed inline object child", currentBlockChild);
         } else if (oldBlockChild) {
           debug.syncValue("Replacing child", currentBlockChild);
-          const oldChild = oldSlateBlock.children[currentBlockChildIndex];
+          const oldChild = oldEngineBlock.children[currentBlockChildIndex];
           if (!oldChild)
             return;
-          slateEditor.apply({
+          editorEngine.apply({
             type: "unset",
             path: [{
-              _key: oldSlateBlock._key
+              _key: oldEngineBlock._key
             }, "children", {
               _key: oldChild._key
             }]
           });
-          const prevSibling = currentBlockChildIndex > 0 ? oldSlateBlock.children[currentBlockChildIndex - 1] : void 0;
-          prevSibling ? slateEditor.apply({
+          const prevSibling = currentBlockChildIndex > 0 ? oldEngineBlock.children[currentBlockChildIndex - 1] : void 0;
+          prevSibling ? editorEngine.apply({
             type: "insert",
             path: [{
-              _key: oldSlateBlock._key
+              _key: oldEngineBlock._key
             }, "children", {
               _key: prevSibling._key
             }],
             node: currentBlockChild,
             position: "after"
-          }) : slateEditor.apply({
+          }) : editorEngine.apply({
             type: "insert",
             path: [{
-              _key: oldSlateBlock._key
+              _key: oldEngineBlock._key
             }, "children", 0],
             node: currentBlockChild,
             position: "before"
-          }), slateEditor.onChange();
+          }), editorEngine.onChange();
         } else if (!oldBlockChild) {
           debug.syncValue("Inserting new child", currentBlockChild);
-          const prevChild = currentBlockChildIndex > 0 ? slateBlock.children[currentBlockChildIndex - 1] : void 0;
-          prevChild ? slateEditor.apply({
+          const prevChild = currentBlockChildIndex > 0 ? engineBlock.children[currentBlockChildIndex - 1] : void 0;
+          prevChild ? editorEngine.apply({
             type: "insert",
             path: [{
-              _key: oldSlateBlock._key
+              _key: oldEngineBlock._key
             }, "children", {
               _key: prevChild._key
             }],
             node: currentBlockChild,
             position: "after"
-          }) : slateEditor.apply({
+          }) : editorEngine.apply({
             type: "insert",
             path: [{
-              _key: oldSlateBlock._key
+              _key: oldEngineBlock._key
             }, "children", 0],
             node: currentBlockChild,
             position: "before"
-          }), slateEditor.onChange();
+          }), editorEngine.onChange();
         }
       }
     });
@@ -18258,23 +18281,23 @@ function createInternalEditor(config) {
   debug.setup("creating new editor instance");
   const subscriptions = [], editorActor = createActor(editorMachine, {
     input: editorConfigToMachineInput(config)
-  }), relayActor = createActor(relayMachine), slateEditor = createSlateEditor({
+  }), relayActor = createActor(relayMachine), editorEngine = createEditorEngine({
     editorActor,
     relayActor,
     subscriptions
-  }), editable = createEditableAPI(slateEditor, editorActor), {
+  }), editable = createEditableAPI(editorEngine, editorActor), {
     mutationActor,
     syncActor
   } = createActors({
     editorActor,
     relayActor,
-    slateEditor,
+    editorEngine,
     subscriptions
   }), editor = {
-    dom: createEditorDom((event) => editorActor.send(event), slateEditor),
+    dom: createEditorDom((event) => editorActor.send(event), editorEngine),
     getSnapshot: () => getEditorSnapshot({
       editorActorSnapshot: editorActor.getSnapshot(),
-      slateEditorInstance: slateEditor
+      editorEngineInstance: editorEngine
     }),
     registerBehavior: (behaviorConfig) => {
       const priority = createEditorPriority({
@@ -18318,7 +18341,7 @@ function createInternalEditor(config) {
         default:
           editorActor.send(rerouteExternalBehaviorEvent({
             event,
-            slateEditor
+            editorEngine
           }));
       }
     },
@@ -18360,7 +18383,7 @@ function createInternalEditor(config) {
     },
     editor,
     editable,
-    slateEditor,
+    editorEngine,
     subscriptions
   };
 }
@@ -18382,7 +18405,7 @@ function createActors(config) {
         "edit mode": "read only"
       }),
       schema: config.editorActor.getSnapshot().context.schema,
-      slateEditor: config.slateEditor
+      editorEngine: config.editorEngine
     }
   }), syncActor = createActor(syncMachine, {
     input: {
@@ -18392,7 +18415,7 @@ function createActors(config) {
         "edit mode": "read only"
       }),
       schema: config.editorActor.getSnapshot().context.schema,
-      slateEditor: config.slateEditor
+      editorEngine: config.editorEngine
     }
   });
   return config.subscriptions.push(() => {
@@ -18421,7 +18444,7 @@ function createActors(config) {
           config.editorActor.send({
             ...event,
             type: "internal.patch",
-            value: config.slateEditor.children
+            value: config.editorEngine.children
           });
           break;
         default:
@@ -18483,7 +18506,7 @@ class PortableTextEditor {
    * A lookup table for all the relevant schema types for this portable text type.
    */
   /*
-   * The editor API (currently implemented with Slate).
+   * The editor API (the engine).
    */
   constructor(config) {
     this.schemaTypes = config.editorActor.getSnapshot().context.schema, this.editable = config.editable;
@@ -18875,25 +18898,25 @@ 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.slateEditor || $[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.editorEngine || $[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.slateEditor
+      type: "add editor engine",
+      editor: internalEditor_0.editorEngine
     }), 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.slateEditor, $[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.editorEngine, $[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.slateEditor || $[15] !== t4 ? (t5 = /* @__PURE__ */ jsx(Slate, { editor: internalEditor_0.slateEditor, children: t4 }), $[14] = internalEditor_0.slateEditor, $[15] = t4, $[16] = t5) : t5 = $[16];
+  $[14] !== internalEditor_0.editorEngine || $[15] !== t4 ? (t5 = /* @__PURE__ */ jsx(Engine, { editor: internalEditor_0.editorEngine, children: t4 }), $[14] = internalEditor_0.editorEngine, $[15] = t4, $[16] = t5) : t5 = $[16];
   let t6;
   $[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;