@portabletext/editor 1.11.3 → 1.12.1

package/lib/index.js

@@ -117,7 +117,13 @@ function getNextBlock(context) {
     return nextBlock;
 }
 function isEmptyTextBlock(block) {
-  return block.children.length === 1 && block.children[0].text === "";
+  if (!types.isPortableTextTextBlock(block))
+    return !1;
+  const onlyText = block.children.every(types.isPortableTextSpan), blockText = getTextBlockText(block);
+  return onlyText && blockText === "";
+}
+function getTextBlockText(block) {
+  return block.children.map((child) => child.text ?? "").join("");
 }
 const breakingBlockObject = {
   on: "insert break",
@@ -126,7 +132,7 @@ const breakingBlockObject = {
   }) => !!getFocusBlockObject(context),
   actions: [() => [{
     type: "insert text block",
-    decorators: []
+    placement: "after"
   }]]
 }, deletingEmptyTextBlockAfterBlockObject = {
   on: "delete backward",
@@ -143,17 +149,8 @@ const breakingBlockObject = {
     focusTextBlock,
     previousBlock
   }) => [{
-    type: "delete",
-    selection: {
-      anchor: {
-        path: focusTextBlock.path,
-        offset: 0
-      },
-      focus: {
-        path: focusTextBlock.path,
-        offset: 0
-      }
-    }
+    type: "delete block",
+    blockPath: focusTextBlock.path
   }, {
     type: "select",
     selection: {
@@ -182,17 +179,8 @@ const breakingBlockObject = {
     focusTextBlock,
     nextBlock
   }) => [{
-    type: "delete",
-    selection: {
-      anchor: {
-        path: focusTextBlock.path,
-        offset: 0
-      },
-      focus: {
-        path: focusTextBlock.path,
-        offset: 0
-      }
-    }
+    type: "delete block",
+    blockPath: focusTextBlock.path
   }, {
     type: "select",
     selection: {
@@ -355,20 +343,138 @@ function looksLikeUrl(text) {
   }
   return looksLikeUrl2;
 }
-function isPortableTextSpan(node) {
-  return node._type === "span" && "text" in node && typeof node.text == "string" && (typeof node.marks > "u" || Array.isArray(node.marks) && node.marks.every((mark) => typeof mark == "string"));
+function blockOffsetToSpanSelectionPoint({
+  value,
+  blockOffset
+}) {
+  let offsetLeft = blockOffset.offset, selectionPoint;
+  for (const block of value)
+    if (block._key === blockOffset.path[0]._key && types.isPortableTextTextBlock(block)) {
+      for (const child of block.children)
+        if (types.isPortableTextSpan(child)) {
+          if (offsetLeft === 0) {
+            selectionPoint = {
+              path: [...blockOffset.path, "children", {
+                _key: child._key
+              }],
+              offset: 0
+            };
+            break;
+          }
+          if (offsetLeft <= child.text.length) {
+            selectionPoint = {
+              path: [...blockOffset.path, "children", {
+                _key: child._key
+              }],
+              offset: offsetLeft
+            };
+            break;
+          }
+          offsetLeft -= child.text.length;
+        }
+    }
+  return selectionPoint;
 }
-function isPortableTextBlock(node) {
-  return (
-    // A block doesn't _have_ to be named 'block' - to differentiate between
-    // allowed child types and marks, one might name them differently
-    typeof node._type == "string" && // Toolkit-types like nested spans are @-prefixed
-    node._type[0] !== "@" && // `markDefs` isn't _required_ per say, but if it's there, it needs to be an array
-    (!("markDefs" in node) || !node.markDefs || Array.isArray(node.markDefs) && // Every mark definition needs to have an `_key` to be mappable in child spans
-    node.markDefs.every((def) => typeof def._key == "string")) && // `children` is required and needs to be an array
-    "children" in node && Array.isArray(node.children) && // All children are objects with `_type` (usually spans, but can contain other stuff)
-    node.children.every((child) => typeof child == "object" && "_type" in child)
-  );
+function spanSelectionPointToBlockOffset({
+  value,
+  selectionPoint
+}) {
+  let offset = 0;
+  for (const block of value)
+    if (block._key === selectionPoint.path[0]._key && types.isPortableTextTextBlock(block)) {
+      for (const child of block.children)
+        if (types.isPortableTextSpan(child)) {
+          if (child._key === selectionPoint.path[2]._key)
+            return {
+              path: [{
+                _key: block._key
+              }],
+              offset: offset + selectionPoint.offset
+            };
+          offset += child.text.length;
+        }
+    }
+}
+function isKeyedSegment$1(segment) {
+  return typeof segment == "object" && segment !== null && "_key" in segment;
+}
+function reverseSelection(selection) {
+  return selection && (selection.backward ? {
+    anchor: selection.focus,
+    focus: selection.anchor,
+    backward: !1
+  } : {
+    anchor: selection.focus,
+    focus: selection.anchor,
+    backward: !0
+  });
+}
+function getSelectionText({
+  value,
+  selection
+}) {
+  let text = "";
+  if (!value || !selection)
+    return text;
+  const forwardSelection = selection.backward ? reverseSelection(selection) : selection;
+  if (!forwardSelection)
+    return text;
+  for (const block of value)
+    if (!(isKeyedSegment$1(forwardSelection.anchor.path[0]) && block._key !== forwardSelection.anchor.path[0]._key) && types.isPortableTextTextBlock(block)) {
+      for (const child of block.children)
+        if (types.isPortableTextSpan(child)) {
+          if (isKeyedSegment$1(forwardSelection.anchor.path[2]) && child._key === forwardSelection.anchor.path[2]._key && isKeyedSegment$1(forwardSelection.focus.path[2]) && child._key === forwardSelection.focus.path[2]._key) {
+            text = text + child.text.slice(forwardSelection.anchor.offset, forwardSelection.focus.offset);
+            break;
+          }
+          if (isKeyedSegment$1(forwardSelection.anchor.path[2]) && child._key === forwardSelection.anchor.path[2]._key) {
+            text = text + child.text.slice(forwardSelection.anchor.offset);
+            continue;
+          }
+          if (isKeyedSegment$1(forwardSelection.focus.path[2]) && child._key === forwardSelection.focus.path[2]._key) {
+            text = text + child.text.slice(0, forwardSelection.focus.offset);
+            break;
+          }
+        }
+      if (isKeyedSegment$1(forwardSelection.focus.path[0]) && block._key === forwardSelection.focus.path[0]._key)
+        break;
+    }
+  return text;
+}
+function getStartPoint({
+  node,
+  path
+}) {
+  return types.isPortableTextTextBlock(node) ? {
+    path: [...path, "children", {
+      _key: node.children[0]._key
+    }],
+    offset: 0
+  } : {
+    path,
+    offset: 0
+  };
+}
+function getBlockTextBefore({
+  value,
+  point
+}) {
+  const key = isKeyedSegment$1(point.path[0]) ? point.path[0]._key : void 0, block = key ? value.find((block2) => block2._key === key) : void 0;
+  if (!block)
+    return "";
+  const startPoint = getStartPoint({
+    node: block,
+    path: [{
+      _key: block._key
+    }]
+  });
+  return getSelectionText({
+    value,
+    selection: {
+      anchor: startPoint,
+      focus: point
+    }
+  });
 }
 function createMarkdownBehaviors(config) {
   const automaticBlockquoteOnSpace = {
@@ -382,12 +488,24 @@ function createMarkdownBehaviors(config) {
       const selectionCollapsed = selectionIsCollapsed(context), focusTextBlock = getFocusTextBlock(context), focusSpan = getFocusSpan(context);
       if (!selectionCollapsed || !focusTextBlock || !focusSpan)
         return !1;
-      const caretAtTheEndOfQuote = context.selection.focus.offset === 1, looksLikeMarkdownQuote = /^>/.test(focusSpan.node.text), blockquoteStyle = config.blockquoteStyle?.({
+      const blockOffset = spanSelectionPointToBlockOffset({
+        value: context.value,
+        selectionPoint: {
+          path: [{
+            _key: focusTextBlock.node._key
+          }, "children", {
+            _key: focusSpan.node._key
+          }],
+          offset: context.selection.focus.offset
+        }
+      });
+      if (!blockOffset)
+        return !1;
+      const blockText = getTextBlockText(focusTextBlock.node), caretAtTheEndOfQuote = blockOffset.offset === 1, looksLikeMarkdownQuote = /^>/.test(blockText), blockquoteStyle = config.blockquoteStyle?.({
         schema: context.schema
       });
       return caretAtTheEndOfQuote && looksLikeMarkdownQuote && blockquoteStyle !== void 0 ? {
         focusTextBlock,
-        focusSpan,
         style: blockquoteStyle
       } : !1;
     },
@@ -396,7 +514,6 @@ function createMarkdownBehaviors(config) {
       text: " "
     }], (_, {
       focusTextBlock,
-      focusSpan,
       style
     }) => [{
       type: "unset block",
@@ -407,19 +524,17 @@ function createMarkdownBehaviors(config) {
       style,
       paths: [focusTextBlock.path]
     }, {
-      type: "delete",
-      selection: {
-        anchor: {
-          path: focusSpan.path,
-          offset: 0
-        },
-        focus: {
-          path: focusSpan.path,
-          offset: 2
-        }
+      type: "delete text",
+      anchor: {
+        path: focusTextBlock.path,
+        offset: 0
+      },
+      focus: {
+        path: focusTextBlock.path,
+        offset: 2
       }
     }]]
-  }, automaticBreak = {
+  }, automaticHr = {
     on: "insert text",
     guard: ({
       context,
@@ -428,16 +543,29 @@ function createMarkdownBehaviors(config) {
       const hrCharacter = event.text === "-" ? "-" : event.text === "*" ? "*" : event.text === "_" ? "_" : void 0;
       if (hrCharacter === void 0)
         return !1;
-      const breakObject = config.horizontalRuleObject?.({
+      const hrObject = config.horizontalRuleObject?.({
         schema: context.schema
       }), focusBlock = getFocusTextBlock(context), selectionCollapsed = selectionIsCollapsed(context);
-      if (!breakObject || !focusBlock || !selectionCollapsed)
+      if (!hrObject || !focusBlock || !selectionCollapsed)
         return !1;
-      const onlyText = focusBlock.node.children.every(isPortableTextSpan), blockText = focusBlock.node.children.map((child) => child.text ?? "").join("");
-      return onlyText && blockText === `${hrCharacter}${hrCharacter}` ? {
-        breakObject,
+      const textBefore = getBlockTextBefore({
+        value: context.value,
+        point: context.selection.focus
+      }), hrBlockOffsets = {
+        anchor: {
+          path: focusBlock.path,
+          offset: 0
+        },
+        focus: {
+          path: focusBlock.path,
+          offset: 3
+        }
+      };
+      return textBefore === `${hrCharacter}${hrCharacter}` ? {
+        hrObject,
         focusBlock,
-        hrCharacter
+        hrCharacter,
+        hrBlockOffsets
       } : !1;
     },
     actions: [(_, {
@@ -446,26 +574,56 @@ function createMarkdownBehaviors(config) {
       type: "insert text",
       text: hrCharacter
     }], (_, {
-      breakObject,
-      focusBlock
+      hrObject,
+      hrBlockOffsets
     }) => [{
       type: "insert block object",
-      ...breakObject
-    }, {
-      type: "delete",
-      selection: {
-        anchor: {
-          path: focusBlock.path,
-          offset: 0
-        },
-        focus: {
-          path: focusBlock.path,
-          offset: 0
-        }
-      }
+      placement: "before",
+      blockObject: hrObject
     }, {
+      type: "delete text",
+      ...hrBlockOffsets
+    }]]
+  }, automaticHrOnPaste = {
+    on: "paste",
+    guard: ({
+      context,
+      event
+    }) => {
+      const text = event.clipboardData.getData("text/plain"), hrRegExp = /^(---)$|(___)$|(\*\*\*)$/gm, hrCharacters = text.match(hrRegExp)?.[0], hrObject = config.horizontalRuleObject?.({
+        schema: context.schema
+      }), focusBlock = getFocusBlock(context);
+      return !hrCharacters || !hrObject || !focusBlock ? !1 : {
+        hrCharacters,
+        hrObject,
+        focusBlock
+      };
+    },
+    actions: [(_, {
+      hrCharacters
+    }) => [{
+      type: "insert text",
+      text: hrCharacters
+    }], (_, {
+      hrObject,
+      focusBlock
+    }) => types.isPortableTextTextBlock(focusBlock.node) ? [{
       type: "insert text block",
-      decorators: []
+      textBlock: {
+        children: focusBlock.node.children
+      },
+      placement: "after"
+    }, {
+      type: "insert block object",
+      blockObject: hrObject,
+      placement: "after"
+    }, {
+      type: "delete block",
+      blockPath: focusBlock.path
+    }] : [{
+      type: "insert block object",
+      blockObject: hrObject,
+      placement: "after"
     }]]
   }, automaticHeadingOnSpace = {
     on: "insert text",
@@ -478,8 +636,21 @@ function createMarkdownBehaviors(config) {
       const selectionCollapsed = selectionIsCollapsed(context), focusTextBlock = getFocusTextBlock(context), focusSpan = getFocusSpan(context);
       if (!selectionCollapsed || !focusTextBlock || !focusSpan)
         return !1;
-      const markdownHeadingSearch = /^#+/.exec(focusSpan.node.text), level = markdownHeadingSearch ? markdownHeadingSearch[0].length : void 0;
-      if (context.selection.focus.offset !== level)
+      const blockOffset = spanSelectionPointToBlockOffset({
+        value: context.value,
+        selectionPoint: {
+          path: [{
+            _key: focusTextBlock.node._key
+          }, "children", {
+            _key: focusSpan.node._key
+          }],
+          offset: context.selection.focus.offset
+        }
+      });
+      if (!blockOffset)
+        return !1;
+      const blockText = getTextBlockText(focusTextBlock.node), markdownHeadingSearch = /^#+/.exec(blockText), level = markdownHeadingSearch ? markdownHeadingSearch[0].length : void 0;
+      if (blockOffset.offset !== level)
         return !1;
       const style = level !== void 0 ? config.headingStyle?.({
         schema: context.schema,
@@ -487,7 +658,6 @@ function createMarkdownBehaviors(config) {
       }) : void 0;
       return level !== void 0 && style !== void 0 ? {
         focusTextBlock,
-        focusSpan,
         style,
         level
       } : !1;
@@ -497,7 +667,6 @@ function createMarkdownBehaviors(config) {
       text: " "
     }], (_, {
       focusTextBlock,
-      focusSpan,
       style,
       level
     }) => [{
@@ -509,16 +678,14 @@ function createMarkdownBehaviors(config) {
       style,
       paths: [focusTextBlock.path]
     }, {
-      type: "delete",
-      selection: {
-        anchor: {
-          path: focusSpan.path,
-          offset: 0
-        },
-        focus: {
-          path: focusSpan.path,
-          offset: level + 1
-        }
+      type: "delete text",
+      anchor: {
+        path: focusTextBlock.path,
+        offset: 0
+      },
+      focus: {
+        path: focusTextBlock.path,
+        offset: level + 1
       }
     }]]
   }, clearStyleOnBackspace = {
@@ -556,15 +723,27 @@ function createMarkdownBehaviors(config) {
       const selectionCollapsed = selectionIsCollapsed(context), focusTextBlock = getFocusTextBlock(context), focusSpan = getFocusSpan(context);
       if (!selectionCollapsed || !focusTextBlock || !focusSpan)
         return !1;
-      const defaultStyle = config.defaultStyle?.({
+      const blockOffset = spanSelectionPointToBlockOffset({
+        value: context.value,
+        selectionPoint: {
+          path: [{
+            _key: focusTextBlock.node._key
+          }, "children", {
+            _key: focusSpan.node._key
+          }],
+          offset: context.selection.focus.offset
+        }
+      });
+      if (!blockOffset)
+        return !1;
+      const blockText = getTextBlockText(focusTextBlock.node), defaultStyle = config.defaultStyle?.({
         schema: context.schema
-      }), looksLikeUnorderedList = /^(-|\*)/.test(focusSpan.node.text), unorderedListStyle = config.unorderedListStyle?.({
+      }), looksLikeUnorderedList = /^(-|\*)/.test(blockText), unorderedListStyle = config.unorderedListStyle?.({
         schema: context.schema
-      }), caretAtTheEndOfUnorderedList = context.selection.focus.offset === 1;
+      }), caretAtTheEndOfUnorderedList = blockOffset.offset === 1;
       if (defaultStyle && caretAtTheEndOfUnorderedList && looksLikeUnorderedList && unorderedListStyle !== void 0)
         return {
           focusTextBlock,
-          focusSpan,
           listItem: unorderedListStyle,
           listItemLength: 1,
           style: defaultStyle
@@ -574,7 +753,6 @@ function createMarkdownBehaviors(config) {
       }), caretAtTheEndOfOrderedList = context.selection.focus.offset === 2;
       return defaultStyle && caretAtTheEndOfOrderedList && looksLikeOrderedList && orderedListStyle !== void 0 ? {
         focusTextBlock,
-        focusSpan,
         listItem: orderedListStyle,
         listItemLength: 2,
         style: defaultStyle
@@ -585,7 +763,6 @@ function createMarkdownBehaviors(config) {
       text: " "
     }], (_, {
       focusTextBlock,
-      focusSpan,
       style,
       listItem,
       listItemLength
@@ -596,20 +773,18 @@ function createMarkdownBehaviors(config) {
       style,
       paths: [focusTextBlock.path]
     }, {
-      type: "delete",
-      selection: {
-        anchor: {
-          path: focusSpan.path,
-          offset: 0
-        },
-        focus: {
-          path: focusSpan.path,
-          offset: listItemLength + 1
-        }
+      type: "delete text",
+      anchor: {
+        path: focusTextBlock.path,
+        offset: 0
+      },
+      focus: {
+        path: focusTextBlock.path,
+        offset: listItemLength + 1
       }
     }]]
   };
-  return [automaticBlockquoteOnSpace, automaticBreak, automaticHeadingOnSpace, clearStyleOnBackspace, automaticListOnSpace];
+  return [automaticBlockquoteOnSpace, automaticHeadingOnSpace, automaticHr, automaticHrOnPaste, clearStyleOnBackspace, automaticListOnSpace];
 }
 function getPortableTextMemberSchemaTypes(portableTextType) {
   if (!portableTextType)
@@ -4007,6 +4182,21 @@ function createWithPortableTextLists(types2) {
     }, editor;
   };
 }
+function isPortableTextSpan(node) {
+  return node._type === "span" && "text" in node && typeof node.text == "string" && (typeof node.marks > "u" || Array.isArray(node.marks) && node.marks.every((mark) => typeof mark == "string"));
+}
+function isPortableTextBlock(node) {
+  return (
+    // A block doesn't _have_ to be named 'block' - to differentiate between
+    // allowed child types and marks, one might name them differently
+    typeof node._type == "string" && // Toolkit-types like nested spans are @-prefixed
+    node._type[0] !== "@" && // `markDefs` isn't _required_ per say, but if it's there, it needs to be an array
+    (!("markDefs" in node) || !node.markDefs || Array.isArray(node.markDefs) && // Every mark definition needs to have an `_key` to be mappable in child spans
+    node.markDefs.every((def) => typeof def._key == "string")) && // `children` is required and needs to be an array
+    "children" in node && Array.isArray(node.children) && // All children are objects with `_type` (usually spans, but can contain other stuff)
+    node.children.every((child) => typeof child == "object" && "_type" in child)
+  );
+}
 function getPreviousSpan({
   editor,
   blockPath,
@@ -4707,7 +4897,66 @@ function createSlateEditor(config) {
   };
   return slateEditors.set(config.editorActor, slateEditor), slateEditor;
 }
-const debug$5 = debugWithName("API:editable");
+function insertBlock({
+  block,
+  placement,
+  editor,
+  schema: schema2
+}) {
+  if (editor.selection) {
+    const [focusBlock, focusBlockPath] = Array.from(slate.Editor.nodes(editor, {
+      at: editor.selection.focus.path.slice(0, 1),
+      match: (n) => !slate.Editor.isEditor(n)
+    }))[0] ?? [void 0, void 0];
+    if (placement === "after") {
+      const nextPath = [focusBlockPath[0] + 1];
+      slate.Transforms.insertNodes(editor, block, {
+        at: nextPath
+      }), slate.Transforms.select(editor, {
+        anchor: {
+          path: [nextPath[0], 0],
+          offset: 0
+        },
+        focus: {
+          path: [nextPath[0], 0],
+          offset: 0
+        }
+      });
+    } else placement === "before" ? slate.Transforms.insertNodes(editor, block, {
+      at: focusBlockPath
+    }) : slate.Editor.insertNode(editor, block);
+    focusBlock && isEqualToEmptyEditor([focusBlock], schema2) && slate.Transforms.removeNodes(editor, {
+      at: focusBlockPath
+    });
+  } else {
+    const lastBlock = Array.from(slate.Editor.nodes(editor, {
+      match: (n) => !slate.Editor.isEditor(n),
+      at: [],
+      reverse: !0
+    }))[0];
+    slate.Editor.insertNode(editor, block), lastBlock && isEqualToEmptyEditor([lastBlock[0]], schema2) && slate.Transforms.removeNodes(editor, {
+      at: lastBlock[1]
+    });
+  }
+}
+const insertBlockObjectActionImplementation = ({
+  context,
+  action
+}) => {
+  const block = toSlateValue([{
+    _key: context.keyGenerator(),
+    _type: action.blockObject.name,
+    ...action.blockObject.value ? action.blockObject.value : {}
+  }], {
+    schemaTypes: context.schema
+  })[0];
+  insertBlock({
+    block,
+    placement: action.placement,
+    editor: action.editor,
+    schema: context.schema
+  });
+}, debug$5 = debugWithName("API:editable");
 function createEditableAPI(editor, editorActor) {
   const types2 = editorActor.getSnapshot().context.schema;
   return {
@@ -4796,18 +5045,21 @@ function createEditableAPI(editor, editorActor) {
         at: editor.selection
       }), editor.onChange(), toPortableTextRange(fromSlateValue(editor.children, types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types2)?.focus.path || [];
     },
-    insertBlock: (type, value) => insertBlockObjectActionImplementation({
+    insertBlock: (type, value) => (insertBlockObjectActionImplementation({
       context: {
         keyGenerator: editorActor.getSnapshot().context.keyGenerator,
         schema: types2
       },
       action: {
         type: "insert block object",
-        name: type.name,
-        value,
+        blockObject: {
+          name: type.name,
+          value
+        },
+        placement: "auto",
         editor
       }
-    }),
+    }), editor.onChange(), toPortableTextRange(fromSlateValue(editor.children, types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types2)?.focus.path ?? []),
     hasBlockStyle: (style) => {
       try {
         return editor.pteHasBlockStyle(style);
@@ -4977,35 +5229,6 @@ function createEditableAPI(editor, editorActor) {
     }
   };
 }
-const insertBlockObjectActionImplementation = ({
-  context,
-  action
-}) => {
-  const editor = action.editor, types2 = context.schema, block = toSlateValue([{
-    _key: context.keyGenerator(),
-    _type: action.name,
-    ...action.value ? action.value : {}
-  }], {
-    schemaTypes: context.schema
-  })[0];
-  if (!editor.selection) {
-    const lastBlock = Array.from(slate.Editor.nodes(editor, {
-      match: (n) => !slate.Editor.isEditor(n),
-      at: [],
-      reverse: !0
-    }))[0];
-    return slate.Editor.insertNode(editor, block), lastBlock && isEqualToEmptyEditor([lastBlock[0]], types2) && slate.Transforms.removeNodes(editor, {
-      at: lastBlock[1]
-    }), editor.onChange(), toPortableTextRange(fromSlateValue(editor.children, types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types2)?.focus.path ?? [];
-  }
-  const focusBlock = Array.from(slate.Editor.nodes(editor, {
-    at: editor.selection.focus.path.slice(0, 1),
-    match: (n) => n._type === types2.block.name
-  }))[0];
-  return slate.Editor.insertNode(editor, block), focusBlock && isEqualToEmptyEditor([focusBlock[0]], types2) && slate.Transforms.removeNodes(editor, {
-    at: focusBlock[1]
-  }), editor.onChange(), toPortableTextRange(fromSlateValue(editor.children, types2.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types2)?.focus.path || [];
-};
 function isAnnotationActive({
   editor,
   annotation
@@ -5401,18 +5624,52 @@ const addAnnotationActionImplementation = ({
   }) => {
     slate.deleteForward(action.editor, action.unit);
   },
-  delete: ({
+  "delete block": ({
+    action
+  }) => {
+    const range = toSlateRange({
+      anchor: {
+        path: action.blockPath,
+        offset: 0
+      },
+      focus: {
+        path: action.blockPath,
+        offset: 0
+      }
+    }, action.editor);
+    if (!range) {
+      console.error("Unable to find Slate range from selection points");
+      return;
+    }
+    slate.Transforms.removeNodes(action.editor, {
+      at: range
+    });
+  },
+  "delete text": ({
+    context,
     action
   }) => {
-    const location = toSlateRange(action.selection, action.editor);
-    if (!location) {
-      console.error(`Could not find Slate location from selection ${action.selection}`);
+    const value = fromSlateValue(action.editor.children, context.schema.block.name, KEY_TO_VALUE_ELEMENT.get(action.editor)), anchor = blockOffsetToSpanSelectionPoint({
+      value,
+      blockOffset: action.anchor
+    }), focus = blockOffsetToSpanSelectionPoint({
+      value,
+      blockOffset: action.focus
+    });
+    if (!anchor || !focus) {
+      console.error("Unable to find anchor or focus selection point");
       return;
     }
-    location.anchor.path.length === 1 && location.focus.path.length === 1 ? slate.Transforms.removeNodes(action.editor, {
-      at: location
-    }) : slate.Transforms.delete(action.editor, {
-      at: location
+    const range = toSlateRange({
+      anchor,
+      focus
+    }, action.editor);
+    if (!range) {
+      console.error("Unable to find Slate range from selection points");
+      return;
+    }
+    slate.Transforms.delete(action.editor, {
+      at: range
     });
   },
   "insert block object": insertBlockObjectActionImplementation,
@@ -5428,16 +5685,27 @@ const addAnnotationActionImplementation = ({
     context,
     action
   }) => {
-    slate.Editor.insertNode(action.editor, {
+    const block = toSlateValue([{
       _key: context.keyGenerator(),
       _type: context.schema.block.name,
       style: context.schema.styles[0].value ?? "normal",
       markDefs: [],
-      children: [{
+      children: action.textBlock?.children?.map((child) => ({
+        ...child,
+        _key: context.keyGenerator()
+      })) ?? [{
+        _type: context.schema.span.name,
         _key: context.keyGenerator(),
-        _type: "span",
         text: ""
       }]
+    }], {
+      schemaTypes: context.schema
+    })[0];
+    insertBlock({
+      block,
+      editor: action.editor,
+      schema: context.schema,
+      placement: action.placement
     });
   },
   effect: ({
@@ -5472,8 +5740,15 @@ function performAction({
   action
 }) {
   switch (action.type) {
-    case "delete": {
-      behaviorActionImplementations.delete({
+    case "delete block": {
+      behaviorActionImplementations["delete block"]({
+        context,
+        action
+      });
+      break;
+    }
+    case "delete text": {
+      behaviorActionImplementations["delete text"]({
         context,
         action
       });