@portabletext/editor 1.0.18 → 1.1.0

package/lib/index.js

@@ -38,7 +38,9 @@ function createArrayedPath(point, editor) {
     return [];
   if (editor.isVoid(block))
     return [blockPath[0], 0];
-  const childPath = [point.path[2]], childIndex = block.children.findIndex((child) => isEqual__default.default([{ _key: child._key }], childPath));
+  const childPath = [point.path[2]], childIndex = block.children.findIndex(
+    (child) => isEqual__default.default([{ _key: child._key }], childPath)
+  );
   if (childIndex >= 0 && block.children[childIndex]) {
     const child = block.children[childIndex];
     return slate.Element.isElement(child) && editor.isVoid(child) ? blockPath.concat(childIndex).concat(0) : blockPath.concat(childIndex);
@@ -83,7 +85,9 @@ function normalizePoint(point, value) {
     return null;
   const newPath = [];
   let newOffset = point.offset || 0;
-  const blockKey = typeof point.path[0] == "object" && "_key" in point.path[0] && point.path[0]._key, childKey = typeof point.path[2] == "object" && "_key" in point.path[2] && point.path[2]._key, block = value.find((blk) => blk._key === blockKey);
+  const blockKey = typeof point.path[0] == "object" && "_key" in point.path[0] && point.path[0]._key, childKey = typeof point.path[2] == "object" && "_key" in point.path[2] && point.path[2]._key, block = value.find(
+    (blk) => blk._key === blockKey
+  );
   if (block)
     newPath.push({ _key: block._key });
   else
@@ -106,14 +110,16 @@ function normalizeSelection(selection, value) {
   const { anchor, focus } = selection;
   return anchor && value.find((blk) => isEqual__default.default({ _key: blk._key }, anchor.path[0])) && (newAnchor = normalizePoint(anchor, value)), focus && value.find((blk) => isEqual__default.default({ _key: blk._key }, focus.path[0])) && (newFocus = normalizePoint(focus, value)), newAnchor && newFocus ? { anchor: newAnchor, focus: newFocus, backward: selection.backward } : null;
 }
-const EMPTY_MARKDEFS = [], EMPTY_MARKS$1 = [], VOID_CHILD_KEY = "void-child";
+const EMPTY_MARKDEFS = [], VOID_CHILD_KEY = "void-child";
 function keepObjectEquality(object, keyMap) {
   const value = keyMap[object._key];
   return value && isEqual__default.default(object, value) ? value : (keyMap[object._key] = object, object);
 }
 function toSlateValue(value, { schemaTypes }, keyMap = {}) {
   return value && Array.isArray(value) ? value.map((block) => {
-    const { _type, _key, ...rest } = block, voidChildren = [{ _key: VOID_CHILD_KEY, _type: "span", text: "", marks: [] }];
+    const { _type, _key, ...rest } = block, voidChildren = [
+      { _key: VOID_CHILD_KEY, _type: "span", text: "", marks: [] }
+    ];
     if (block && block._type === schemaTypes.block.name) {
       const textBlock = block;
       let hasInlines = !1;
@@ -154,12 +160,25 @@ function fromSlateValue(value, textBlockType, keyMap = {}) {
         const { _type: _cType } = child;
         if ("value" in child && _cType !== "span") {
           hasInlines = !0;
-          const { value: v, _key: k, _type: t, __inline: _i, children: _c, ...rest } = child;
-          return keepObjectEquality({ ...rest, ...v, _key: k, _type: t }, keyMap);
+          const {
+            value: v,
+            _key: k,
+            _type: t,
+            __inline: _i,
+            children: _c,
+            ...rest
+          } = child;
+          return keepObjectEquality(
+            { ...rest, ...v, _key: k, _type: t },
+            keyMap
+          );
         }
         return child;
       });
-      return hasInlines ? keepObjectEquality({ ...block, children, _key, _type }, keyMap) : block;
+      return hasInlines ? keepObjectEquality(
+        { ...block, children, _key, _type },
+        keyMap
+      ) : block;
     }
     const blockValue = "value" in block && block.value;
     return keepObjectEquality(
@@ -331,10 +350,23 @@ function getCounterContentForListLevel(level) {
       return "counter(listItemNumberNextNextNext) '. '";
   }
 }
-const debug$l = debugWithName("components:DraggableBlock"), DraggableBlock = ({ children, element, readOnly, blockRef }) => {
-  const editor = slateReact.useSlateStatic(), dragGhostRef = react.useRef(), [isDragOver, setIsDragOver] = react.useState(!1), isVoid = react.useMemo(() => slate.Editor.isVoid(editor, element), [editor, element]), isInline = react.useMemo(() => slate.Editor.isInline(editor, element), [editor, element]), [blockElement, setBlockElement] = react.useState(null);
+const debug$l = debugWithName("components:DraggableBlock"), DraggableBlock = ({
+  children,
+  element,
+  readOnly,
+  blockRef
+}) => {
+  const editor = slateReact.useSlateStatic(), dragGhostRef = react.useRef(), [isDragOver, setIsDragOver] = react.useState(!1), isVoid = react.useMemo(
+    () => slate.Editor.isVoid(editor, element),
+    [editor, element]
+  ), isInline = react.useMemo(
+    () => slate.Editor.isInline(editor, element),
+    [editor, element]
+  ), [blockElement, setBlockElement] = react.useState(null);
   react.useEffect(
-    () => setBlockElement(blockRef ? blockRef.current : slateReact.ReactEditor.toDOMNode(editor, element)),
+    () => setBlockElement(
+      blockRef ? blockRef.current : slateReact.ReactEditor.toDOMNode(editor, element)
+    ),
     [editor, element, blockRef]
   );
   const handleDragOver = react.useCallback(
@@ -421,7 +453,9 @@ const debug$l = debugWithName("components:DraggableBlock"), DraggableBlock = ({
       }
       if (debug$l("Drag start"), IS_DRAGGING.set(editor, !0), event.dataTransfer && (event.dataTransfer.setData("application/portable-text", "something"), event.dataTransfer.effectAllowed = "move"), blockElement && blockElement instanceof HTMLElement) {
         let dragGhost = blockElement.cloneNode(!0);
-        const customGhost = dragGhost.querySelector("[data-pt-drag-ghost-element]");
+        const customGhost = dragGhost.querySelector(
+          "[data-pt-drag-ghost-element]"
+        );
         if (customGhost && (dragGhost = customGhost), dragGhost.setAttribute("data-dragged", ""), document.body) {
           dragGhostRef.current = dragGhost, dragGhost.style.position = "absolute", dragGhost.style.left = "-99999px", dragGhost.style.boxSizing = "border-box", document.body.appendChild(dragGhost);
           const rect = blockElement.getBoundingClientRect(), x = event.clientX - rect.left, y = event.clientY - rect.top;
@@ -479,7 +513,11 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = { display: "inline-block" }, El
   spellCheck
 }) => {
   const editor = slateReact.useSlateStatic(), selected = slateReact.useSelected(), blockRef = react.useRef(null), inlineBlockObjectRef = react.useRef(null), focused = selected && editor.selection && slate.Range.isCollapsed(editor.selection) || !1, value = react.useMemo(
-    () => fromSlateValue([element], schemaTypes.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0],
+    () => fromSlateValue(
+      [element],
+      schemaTypes.block.name,
+      KEY_TO_VALUE_ELEMENT.get(editor)
+    )[0],
     [editor, element, schemaTypes.block.name]
   );
   let renderedBlock = children, className;
@@ -489,11 +527,17 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = { display: "inline-block" }, El
   if (typeof element._key != "string")
     throw new Error("Expected element to have a _key property");
   if (editor.isInline(element)) {
-    const path = slateReact.ReactEditor.findPath(editor, element), [block2] = slate.Editor.node(editor, path, { depth: 1 }), schemaType2 = schemaTypes.inlineObjects.find((_type) => _type.name === element._type);
+    const path = slateReact.ReactEditor.findPath(editor, element), [block2] = slate.Editor.node(editor, path, { depth: 1 }), schemaType2 = schemaTypes.inlineObjects.find(
+      (_type) => _type.name === element._type
+    );
     if (!schemaType2)
       throw new Error("Could not find type for inline block element");
     if (slate.Element.isElement(block2)) {
-      const elmPath = [{ _key: block2._key }, "children", { _key: element._key }];
+      const elmPath = [
+        { _key: block2._key },
+        "children",
+        { _key: element._key }
+      ];
       return /* @__PURE__ */ jsxRuntime.jsxs("span", { ...attributes, children: [
         children,
         /* @__PURE__ */ jsxRuntime.jsxs(
@@ -531,7 +575,9 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = { display: "inline-block" }, El
     className = "pt-block pt-text-block";
     const isListItem = "listItem" in element, style = "style" in element && element.style || "normal";
     className = `pt-block pt-text-block pt-text-block-style-${style}`;
-    const blockStyleType = schemaTypes.styles.find((item) => item.value === style);
+    const blockStyleType = schemaTypes.styles.find(
+      (item) => item.value === style
+    );
     renderStyle && blockStyleType && (renderedBlock = renderStyle({
       block: element,
       children,
@@ -544,7 +590,9 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = { display: "inline-block" }, El
     }));
     let level;
     if (isListItem && (typeof element.level == "number" && (level = element.level), className += ` pt-list-item pt-list-item-${element.listItem} pt-list-item-level-${level || 1}`), editor.isListBlock(value) && isListItem && element.listItem) {
-      const listType = schemaTypes.lists.find((item) => item.value === element.listItem);
+      const listType = schemaTypes.lists.find(
+        (item) => item.value === element.listItem
+      );
       renderListItem && listType ? renderedBlock = renderListItem({
         block: value,
         children: renderedBlock,
@@ -581,15 +629,38 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = { display: "inline-block" }, El
       {
         enumerable: !1,
         get() {
-          return console.warn("Property 'type' is deprecated, use 'schemaType' instead."), schemaTypes.block;
+          return console.warn(
+            "Property 'type' is deprecated, use 'schemaType' instead."
+          ), schemaTypes.block;
         }
       }
     ), propsOrDefaultRendered = renderBlock ? renderBlock(renderProps) : children;
-    return /* @__PURE__ */ jsxRuntime.jsx("div", { ...attributes, className, spellCheck, children: /* @__PURE__ */ jsxRuntime.jsx(DraggableBlock, { element, readOnly, blockRef, children: /* @__PURE__ */ jsxRuntime.jsx("div", { ref: blockRef, children: propsOrDefaultRendered }) }) }, element._key);
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        ...attributes,
+        className,
+        spellCheck,
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          DraggableBlock,
+          {
+            element,
+            readOnly,
+            blockRef,
+            children: /* @__PURE__ */ jsxRuntime.jsx("div", { ref: blockRef, children: propsOrDefaultRendered })
+          }
+        )
+      },
+      element._key
+    );
   }
-  const schemaType = schemaTypes.blockObjects.find((_type) => _type.name === element._type);
+  const schemaType = schemaTypes.blockObjects.find(
+    (_type) => _type.name === element._type
+  );
   if (!schemaType)
-    throw new Error(`Could not find schema type for block element of _type ${element._type}`);
+    throw new Error(
+      `Could not find schema type for block element of _type ${element._type}`
+    );
   className = "pt-block pt-object-block";
   const block = fromSlateValue(
     [element],
@@ -612,7 +683,9 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = { display: "inline-block" }, El
       {
         enumerable: !1,
         get() {
-          return console.warn("Property 'type' is deprecated, use 'schemaType' instead."), schemaType;
+          return console.warn(
+            "Property 'type' is deprecated, use 'schemaType' instead."
+          ), schemaType;
         }
       }
     );
@@ -634,7 +707,11 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = { display: "inline-block" }, El
   return editor;
 };
 function DefaultAnnotation(props) {
-  const handleClick = react.useCallback(() => alert(JSON.stringify(props.annotation)), [props.annotation]);
+  const handleClick = react.useCallback(
+    // eslint-disable-next-line no-alert
+    () => alert(JSON.stringify(props.annotation)),
+    [props.annotation]
+  );
   return /* @__PURE__ */ jsxRuntime.jsx("span", { style: { color: "blue" }, onClick: handleClick, children: props.children });
 }
 function getPortableTextMemberSchemaTypes(portableTextType) {
@@ -643,16 +720,24 @@ function getPortableTextMemberSchemaTypes(portableTextType) {
   const blockType = portableTextType.of?.find(findBlockType);
   if (!blockType)
     throw new Error("Block type is not defined in this schema (required)");
-  const childrenField = blockType.fields?.find((field) => field.name === "children");
+  const childrenField = blockType.fields?.find(
+    (field) => field.name === "children"
+  );
   if (!childrenField)
     throw new Error("Children field for block type found in schema (required)");
   const ofType = childrenField.type.of;
   if (!ofType)
-    throw new Error("Valid types for block children not found in schema (required)");
+    throw new Error(
+      "Valid types for block children not found in schema (required)"
+    );
   const spanType = ofType.find((memberType) => memberType.name === "span");
   if (!spanType)
     throw new Error("Span type not found in schema (required)");
-  const inlineObjectTypes = ofType.filter((memberType) => memberType.name !== "span") || [], blockObjectTypes = portableTextType.of?.filter((field) => field.name !== blockType.name) || [];
+  const inlineObjectTypes = ofType.filter(
+    (memberType) => memberType.name !== "span"
+  ) || [], blockObjectTypes = portableTextType.of?.filter(
+    (field) => field.name !== blockType.name
+  ) || [];
   return {
     styles: resolveEnabledStyles(blockType),
     decorators: resolveEnabledDecorators(spanType),
@@ -666,10 +751,16 @@ function getPortableTextMemberSchemaTypes(portableTextType) {
   };
 }
 function resolveEnabledStyles(blockType) {
-  const styleField = blockType.fields?.find((btField) => btField.name === "style");
+  const styleField = blockType.fields?.find(
+    (btField) => btField.name === "style"
+  );
   if (!styleField)
-    throw new Error("A field with name 'style' is not defined in the block type (required).");
-  const textStyles = styleField.type.options?.list && styleField.type.options.list?.filter((style) => style.value);
+    throw new Error(
+      "A field with name 'style' is not defined in the block type (required)."
+    );
+  const textStyles = styleField.type.options?.list && styleField.type.options.list?.filter(
+    (style) => style.value
+  );
   if (!textStyles || textStyles.length === 0)
     throw new Error(
       "The style fields need at least one style defined. I.e: {title: 'Normal', value: 'normal'}."
@@ -680,9 +771,13 @@ function resolveEnabledDecorators(spanType) {
   return spanType.decorators;
 }
 function resolveEnabledListItems(blockType) {
-  const listField = blockType.fields?.find((btField) => btField.name === "listItem");
+  const listField = blockType.fields?.find(
+    (btField) => btField.name === "listItem"
+  );
   if (!listField)
-    throw new Error("A field with name 'listItem' is not defined in the block type (required).");
+    throw new Error(
+      "A field with name 'listItem' is not defined in the block type (required)."
+    );
   const listItems = listField.type.options?.list && listField.type.options.list.filter((list) => list.value);
   if (!listItems)
     throw new Error("The list field need at least to be an empty array");
@@ -708,7 +803,12 @@ function createOperationToPatches(types2) {
     const textChild = editor.isTextBlock(block) && editor.isTextSpan(block.children[operation.path[1]]) && block.children[operation.path[1]];
     if (!textChild)
       throw new Error("Could not find child");
-    const path = [{ _key: block._key }, "children", { _key: textChild._key }, "text"], prevBlock = beforeValue[operation.path[0]], prevChild = editor.isTextBlock(prevBlock) && prevBlock.children[operation.path[1]], prevText = editor.isTextSpan(prevChild) ? prevChild.text : "", patch = patches.diffMatchPatch(prevText, textChild.text, path);
+    const path = [
+      { _key: block._key },
+      "children",
+      { _key: textChild._key },
+      "text"
+    ], prevBlock = beforeValue[operation.path[0]], prevChild = editor.isTextBlock(prevBlock) && prevBlock.children[operation.path[1]], prevText = editor.isTextSpan(prevChild) ? prevChild.text : "", patch = patches.diffMatchPatch(prevText, textChild.text, path);
     return patch.value.length ? [patch] : [];
   }
   function removeTextPatch(editor, operation, beforeValue) {
@@ -720,7 +820,12 @@ function createOperationToPatches(types2) {
       throw new Error("Expected span");
     if (!textChild)
       throw new Error("Could not find child");
-    const path = [{ _key: block._key }, "children", { _key: textChild._key }, "text"], beforeBlock = beforeValue[operation.path[0]], prevTextChild = editor.isTextBlock(beforeBlock) && beforeBlock.children[operation.path[1]], prevText = editor.isTextSpan(prevTextChild) && prevTextChild.text, patch = patches.diffMatchPatch(prevText || "", textChild.text, path);
+    const path = [
+      { _key: block._key },
+      "children",
+      { _key: textChild._key },
+      "text"
+    ], beforeBlock = beforeValue[operation.path[0]], prevTextChild = editor.isTextBlock(beforeBlock) && beforeBlock.children[operation.path[1]], prevText = editor.isTextSpan(prevTextChild) && prevTextChild.text, patch = patches.diffMatchPatch(prevText || "", textChild.text, path);
     return patch.value ? [patch] : [];
   }
   function setNodePatch(editor, operation) {
@@ -732,7 +837,9 @@ function createOperationToPatches(types2) {
         { ...editor.children[operation.path[0]], ...operation.newProperties },
         isUndefined__default.default
       );
-      return [patches.set(fromSlateValue([setNode], textBlockName)[0], [{ _key: block._key }])];
+      return [
+        patches.set(fromSlateValue([setNode], textBlockName)[0], [{ _key: block._key }])
+      ];
     } else if (operation.path.length === 2) {
       const block = editor.children[operation.path[0]];
       if (editor.isTextBlock(block)) {
@@ -743,11 +850,23 @@ function createOperationToPatches(types2) {
             if (keys.length === 1 && keyName === "_key") {
               const val = get__default.default(operation.newProperties, keyName);
               patches$1.push(
-                patches.set(val, [{ _key: blockKey }, "children", block.children.indexOf(child), keyName])
+                patches.set(val, [
+                  { _key: blockKey },
+                  "children",
+                  block.children.indexOf(child),
+                  keyName
+                ])
               );
             } else {
               const val = get__default.default(operation.newProperties, keyName);
-              patches$1.push(patches.set(val, [{ _key: blockKey }, "children", { _key: childKey }, keyName]));
+              patches$1.push(
+                patches.set(val, [
+                  { _key: blockKey },
+                  "children",
+                  { _key: childKey },
+                  keyName
+                ])
+              );
             }
           }), patches$1;
         }
@@ -755,21 +874,27 @@ function createOperationToPatches(types2) {
       }
       throw new Error("Could not find a valid block");
     } else
-      throw new Error(`Unexpected path encountered: ${JSON.stringify(operation.path)}`);
+      throw new Error(
+        `Unexpected path encountered: ${JSON.stringify(operation.path)}`
+      );
   }
   function insertNodePatch(editor, operation, beforeValue) {
     const block = beforeValue[operation.path[0]], isTextBlock = editor.isTextBlock(block);
     if (operation.path.length === 1) {
       const position = operation.path[0] === 0 ? "before" : "after", beforeBlock = beforeValue[operation.path[0] - 1], targetKey = operation.path[0] === 0 ? block?._key : beforeBlock?._key;
       return targetKey ? [
-        patches.insert([fromSlateValue([operation.node], textBlockName)[0]], position, [
-          { _key: targetKey }
-        ])
+        patches.insert(
+          [fromSlateValue([operation.node], textBlockName)[0]],
+          position,
+          [{ _key: targetKey }]
+        )
       ] : [
         patches.setIfMissing(beforeValue, []),
-        patches.insert([fromSlateValue([operation.node], textBlockName)[0]], "before", [
-          operation.path[0]
-        ])
+        patches.insert(
+          [fromSlateValue([operation.node], textBlockName)[0]],
+          "before",
+          [operation.path[0]]
+        )
       ];
     } else if (isTextBlock && operation.path.length === 2 && editor.children[operation.path[0]]) {
       const position = block.children.length === 0 || !block.children[operation.path[1] - 1] ? "before" : "after", node = { ...operation.node };
@@ -792,7 +917,9 @@ function createOperationToPatches(types2) {
         ])
       ];
     }
-    return debug$k("Something was inserted into a void block. Not producing editor patches."), [];
+    return debug$k(
+      "Something was inserted into a void block. Not producing editor patches."
+    ), [];
   }
   function splitNodePatch(editor, operation, beforeValue) {
     const patches$1 = [], splitBlock = editor.children[operation.path[0]];
@@ -809,7 +936,9 @@ function createOperationToPatches(types2) {
           [editor.children[operation.path[0] + 1]],
           textBlockName
         )[0];
-        targetValue && (patches$1.push(patches.insert([targetValue], "after", [{ _key: splitBlock._key }])), oldBlock.children.slice(operation.position).forEach((span) => {
+        targetValue && (patches$1.push(
+          patches.insert([targetValue], "after", [{ _key: splitBlock._key }])
+        ), oldBlock.children.slice(operation.position).forEach((span) => {
           const path = [{ _key: oldBlock._key }, "children", { _key: span._key }];
           patches$1.push(patches.unset(path));
         }));
@@ -823,7 +952,10 @@ function createOperationToPatches(types2) {
           [
             {
               ...splitBlock,
-              children: splitBlock.children.slice(operation.path[1] + 1, operation.path[1] + 2)
+              children: splitBlock.children.slice(
+                operation.path[1] + 1,
+                operation.path[1] + 2
+              )
             }
           ],
           textBlockName
@@ -855,10 +987,14 @@ function createOperationToPatches(types2) {
       throw new Error("Block not found");
     } else if (editor.isTextBlock(block) && operation.path.length === 2) {
       const spanToRemove = block.children[operation.path[1]];
-      return spanToRemove ? block.children.filter((span) => span._key === operation.node._key).length > 1 ? (console.warn(
+      return spanToRemove ? block.children.filter(
+        (span) => span._key === operation.node._key
+      ).length > 1 ? (console.warn(
         `Multiple spans have \`_key\` ${operation.node._key}. It's ambiguous which one to remove.`,
         JSON.stringify(block, null, 2)
-      ), []) : [patches.unset([{ _key: block._key }, "children", { _key: spanToRemove._key }])] : (debug$k("Span not found in editor trying to remove node"), []);
+      ), []) : [
+        patches.unset([{ _key: block._key }, "children", { _key: spanToRemove._key }])
+      ] : (debug$k("Span not found in editor trying to remove node"), []);
     } else
       return debug$k("Not creating patch inside object block"), [];
   }
@@ -866,13 +1002,18 @@ function createOperationToPatches(types2) {
     const patches$1 = [], block = beforeValue[operation.path[0]], updatedBlock = editor.children[operation.path[0]];
     if (operation.path.length === 1)
       if (block?._key) {
-        const newBlock = fromSlateValue([editor.children[operation.path[0] - 1]], textBlockName)[0];
+        const newBlock = fromSlateValue(
+          [editor.children[operation.path[0] - 1]],
+          textBlockName
+        )[0];
         patches$1.push(patches.set(newBlock, [{ _key: newBlock._key }])), patches$1.push(patches.unset([{ _key: block._key }]));
       } else
         throw new Error("Target key not found!");
     else if (editor.isTextBlock(block) && editor.isTextBlock(updatedBlock) && operation.path.length === 2) {
       const updatedSpan = updatedBlock.children[operation.path[1] - 1] && editor.isTextSpan(updatedBlock.children[operation.path[1] - 1]) ? updatedBlock.children[operation.path[1] - 1] : void 0, removedSpan = block.children[operation.path[1]] && editor.isTextSpan(block.children[operation.path[1]]) ? block.children[operation.path[1]] : void 0;
-      updatedSpan && (block.children.filter((span) => span._key === updatedSpan._key).length === 1 ? patches$1.push(
+      updatedSpan && (block.children.filter(
+        (span) => span._key === updatedSpan._key
+      ).length === 1 ? patches$1.push(
         patches.set(updatedSpan.text, [
           { _key: block._key },
           "children",
@@ -882,7 +1023,11 @@ function createOperationToPatches(types2) {
       ) : console.warn(
         `Multiple spans have \`_key\` ${updatedSpan._key}. It's ambiguous which one to update.`,
         JSON.stringify(block, null, 2)
-      )), removedSpan && (block.children.filter((span) => span._key === removedSpan._key).length === 1 ? patches$1.push(patches.unset([{ _key: block._key }, "children", { _key: removedSpan._key }])) : console.warn(
+      )), removedSpan && (block.children.filter(
+        (span) => span._key === removedSpan._key
+      ).length === 1 ? patches$1.push(
+        patches.unset([{ _key: block._key }, "children", { _key: removedSpan._key }])
+      ) : console.warn(
         `Multiple spans have \`_key\` ${removedSpan._key}. It's ambiguous which one to remove.`,
         JSON.stringify(block, null, 2)
       ));
@@ -895,7 +1040,9 @@ function createOperationToPatches(types2) {
     if (operation.path.length === 1) {
       const position = operation.path[0] > operation.newPath[0] ? "before" : "after";
       patches$1.push(patches.unset([{ _key: block._key }])), patches$1.push(
-        patches.insert([fromSlateValue([block], textBlockName)[0]], position, [{ _key: targetBlock._key }])
+        patches.insert([fromSlateValue([block], textBlockName)[0]], position, [
+          { _key: targetBlock._key }
+        ])
       );
     } else if (operation.path.length === 2 && editor.isTextBlock(block) && editor.isTextBlock(targetBlock)) {
       const child = block.children[operation.path[1]], targetChild = targetBlock.children[operation.newPath[1]], position = operation.newPath[1] === targetBlock.children.length ? "after" : "before", childToInsert = fromSlateValue([block], textBlockName)[0].children[operation.path[1]];
@@ -957,14 +1104,24 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
       },
       focusBlock: () => {
         if (editor.selection) {
-          const block = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
+          const block = slate.Node.descendant(
+            editor,
+            editor.selection.focus.path.slice(0, 1)
+          );
           if (block)
-            return fromSlateValue([block], types$1.block.name, KEY_TO_VALUE_ELEMENT.get(editor))[0];
+            return fromSlateValue(
+              [block],
+              types$1.block.name,
+              KEY_TO_VALUE_ELEMENT.get(editor)
+            )[0];
         }
       },
       focusChild: () => {
         if (editor.selection) {
-          const block = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
+          const block = slate.Node.descendant(
+            editor,
+            editor.selection.focus.path.slice(0, 1)
+          );
           if (block && editor.isTextBlock(block))
             return fromSlateValue(
               [block],
@@ -985,7 +1142,9 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
         if (!focusBlock)
           throw new Error("No focused text block");
         if (type.name !== types$1.span.name && !types$1.inlineObjects.some((t) => t.name === type.name))
-          throw new Error("This type cannot be inserted as a child to a text block");
+          throw new Error(
+            "This type cannot be inserted as a child to a text block"
+          );
         const child = toSlateValue(
           [
             {
@@ -1002,11 +1161,17 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
           ],
           portableTextEditor
         )[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode = child._type === types$1.span.name, focusNode = slate.Node.get(editor, focusChildPath);
-        return isSpanNode && focusNode._type !== types$1.span.name && (debug$j("Inserting span child next to inline object child, moving selection + 1"), editor.move({ distance: 1, unit: "character" })), slate.Transforms.insertNodes(editor, child, {
+        return isSpanNode && focusNode._type !== types$1.span.name && (debug$j(
+          "Inserting span child next to inline object child, moving selection + 1"
+        ), editor.move({ distance: 1, unit: "character" })), slate.Transforms.insertNodes(editor, child, {
           select: !0,
           at: editor.selection
         }), editor.onChange(), toPortableTextRange(
-          fromSlateValue(editor.children, types$1.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
+          fromSlateValue(
+            editor.children,
+            types$1.block.name,
+            KEY_TO_VALUE_ELEMENT.get(editor)
+          ),
           editor.selection,
           types$1
         )?.focus.path || [];
@@ -1031,7 +1196,11 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
             })
           )[0];
           return slate.Editor.insertNode(editor, block), lastBlock && isEqualToEmptyEditor([lastBlock[0]], types$1) && slate.Transforms.removeNodes(editor, { at: lastBlock[1] }), editor.onChange(), toPortableTextRange(
-            fromSlateValue(editor.children, types$1.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
+            fromSlateValue(
+              editor.children,
+              types$1.block.name,
+              KEY_TO_VALUE_ELEMENT.get(editor)
+            ),
             editor.selection,
             types$1
           )?.focus.path ?? [];
@@ -1043,7 +1212,11 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
           })
         )[0];
         return slate.Editor.insertNode(editor, block), focusBlock && isEqualToEmptyEditor([focusBlock[0]], types$1) && slate.Transforms.removeNodes(editor, { at: focusBlock[1] }), editor.onChange(), toPortableTextRange(
-          fromSlateValue(editor.children, types$1.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
+          fromSlateValue(
+            editor.children,
+            types$1.block.name,
+            KEY_TO_VALUE_ELEMENT.get(editor)
+          ),
           editor.selection,
           types$1
         )?.focus.path || [];
@@ -1069,10 +1242,16 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
           editor
         );
         if (slatePath) {
-          const [block, blockPath] = slate.Editor.node(editor, slatePath.focus.path.slice(0, 1));
+          const [block, blockPath] = slate.Editor.node(
+            editor,
+            slatePath.focus.path.slice(0, 1)
+          );
           if (block && blockPath && typeof block._key == "string") {
             if (path.length === 1 && slatePath.focus.path.length === 1)
-              return [fromSlateValue([block], types$1.block.name)[0], [{ _key: block._key }]];
+              return [
+                fromSlateValue([block], types$1.block.name)[0],
+                [{ _key: block._key }]
+              ];
             const ptBlock = fromSlateValue(
               [block],
               types$1.block.name,
@@ -1081,7 +1260,10 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
             if (editor.isTextBlock(ptBlock)) {
               const ptChild = ptBlock.children[slatePath.focus.path[1]];
               if (ptChild)
-                return [ptChild, [{ _key: block._key }, "children", { _key: ptChild._key }]];
+                return [
+                  ptChild,
+                  [{ _key: block._key }, "children", { _key: ptChild._key }]
+                ];
             }
           }
         }
@@ -1148,43 +1330,74 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
       addAnnotation: (type, value) => {
         const { selection: originalSelection } = editor;
         let returnValue;
-        if (originalSelection) {
-          const [block] = slate.Editor.node(editor, originalSelection.focus, { depth: 1 });
-          if (!editor.isTextBlock(block))
-            return;
-          slate.Range.isCollapsed(originalSelection) && (editor.pteExpandToWord(), editor.onChange());
-          const [textNode] = slate.Editor.node(editor, originalSelection.focus, { depth: 2 });
-          editor.selection && (slate.Editor.withoutNormalizing(editor, () => {
-            const annotationKey = keyGenerator();
-            slate.Transforms.setNodes(
-              editor,
-              {
-                markDefs: [
-                  ...block.markDefs || [],
-                  { _type: type.name, _key: annotationKey, ...value }
-                ]
-              },
-              { at: originalSelection.focus }
-            ), editor.onChange(), slate.Transforms.setNodes(editor, {}, { match: slate.Text.isText, split: !0 }), editor.onChange(), editor.selection && slate.Text.isText(textNode) && slate.Transforms.setNodes(
-              editor,
-              {
-                marks: [...textNode.marks || [], annotationKey]
-              },
-              {
-                at: editor.selection,
-                match: (n) => n._type === types$1.span.name
+        if (originalSelection && (slate.Range.isCollapsed(originalSelection) && (editor.pteExpandToWord(), editor.onChange()), editor.selection)) {
+          let spanPath, markDefPath;
+          const markDefPaths = [];
+          slate.Editor.withoutNormalizing(editor, () => {
+            if (!editor.selection)
+              return;
+            const selectedBlocks = slate.Editor.nodes(editor, {
+              at: editor.selection,
+              match: (node) => editor.isTextBlock(node),
+              reverse: slate.Range.isBackward(editor.selection)
+            });
+            for (const [block, blockPath] of selectedBlocks) {
+              if (block.children.length === 0 || block.children.length === 1 && block.children[0].text === "")
+                continue;
+              const annotationKey = keyGenerator(), markDefs = block.markDefs ?? [];
+              markDefs.find(
+                (markDef) => markDef._type === type.name && markDef._key === annotationKey
+              ) === void 0 && (slate.Transforms.setNodes(
+                editor,
+                {
+                  markDefs: [
+                    ...markDefs,
+                    {
+                      _type: type.name,
+                      _key: annotationKey,
+                      ...value
+                    }
+                  ]
+                },
+                { at: blockPath }
+              ), markDefPath = [
+                { _key: block._key },
+                "markDefs",
+                { _key: annotationKey }
+              ], slate.Range.isBackward(editor.selection) ? markDefPaths.unshift(markDefPath) : markDefPaths.push(markDefPath)), slate.Transforms.setNodes(
+                editor,
+                {},
+                { match: slate.Text.isText, split: !0 }
+              );
+              const children = slate.Node.children(editor, blockPath);
+              for (const [span, path] of children) {
+                if (!editor.isTextSpan(span) || !slate.Range.includes(editor.selection, path))
+                  continue;
+                const marks = span.marks ?? [], existingSameTypeAnnotations = marks.filter(
+                  (mark) => markDefs.some(
+                    (markDef) => markDef._key === mark && markDef._type === type.name
+                  )
+                );
+                slate.Transforms.setNodes(
+                  editor,
+                  {
+                    marks: [
+                      ...marks.filter(
+                        (mark) => !existingSameTypeAnnotations.includes(mark)
+                      ),
+                      annotationKey
+                    ]
+                  },
+                  { at: path }
+                ), spanPath = [{ _key: block._key }, "children", { _key: span._key }];
               }
-            ), editor.onChange();
-            const newPortableTextEditorSelection = toPortableTextRange(
-              fromSlateValue(editor.children, types$1.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
-              editor.selection,
-              types$1
-            );
-            newPortableTextEditorSelection && (returnValue = {
-              spanPath: newPortableTextEditorSelection.focus.path,
-              markDefPath: [{ _key: block._key }, "markDefs", { _key: annotationKey }]
+            }
+            markDefPath && spanPath && (returnValue = {
+              markDefPath,
+              markDefPaths,
+              spanPath
             });
-          }), slate.Editor.normalize(editor), editor.onChange());
+          }), editor.onChange();
         }
         return returnValue;
       },
@@ -1211,34 +1424,98 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
               voids: !0,
               match: (node) => node._type === types$1.span.name || // Text children
               !editor.isTextBlock(node) && slate.Element.isElement(node)
-            })), editor.children.length === 0 && (editor.children = [editor.pteCreateEmptyBlock()]), editor.onChange();
+            })), editor.children.length === 0 && (editor.children = [editor.pteCreateTextBlock({ decorators: [] })]), editor.onChange();
           }
         }
       },
       removeAnnotation: (type) => {
-        let { selection } = editor;
-        if (debug$j("Removing annotation", type), selection) {
-          if (slate.Range.isCollapsed(selection)) {
-            const [node, nodePath] = slate.Editor.node(editor, selection, { depth: 2 });
-            slate.Text.isText(node) && node.marks && typeof node.text == "string" && (slate.Transforms.select(editor, nodePath), selection = editor.selection);
-          }
-          slate.Editor.withoutNormalizing(editor, () => {
-            if (selection && slate.Range.isExpanded(selection)) {
-              if (selection = editor.selection, !selection)
+        debug$j("Removing annotation", type), slate.Editor.withoutNormalizing(editor, () => {
+          if (editor.selection)
+            if (slate.Range.isCollapsed(editor.selection)) {
+              const [block, blockPath] = slate.Editor.node(editor, editor.selection, {
+                depth: 1
+              });
+              if (!editor.isTextBlock(block))
                 return;
-              [
-                ...slate.Editor.nodes(editor, {
-                  at: selection,
-                  match: (node) => editor.isTextBlock(node) && Array.isArray(node.markDefs) && node.markDefs.some((def) => def._type === type.name)
-                })
-              ].forEach(([block]) => {
-                editor.isTextBlock(block) && Array.isArray(block.markDefs) && block.markDefs.filter((def) => def._type === type.name).forEach((def) => {
-                  slate.Editor.removeMark(editor, def._key);
-                });
+              const potentialAnnotations = (block.markDefs ?? []).filter(
+                (markDef) => markDef._type === type.name
+              ), [selectedChild, selectedChildPath] = slate.Editor.node(
+                editor,
+                editor.selection,
+                {
+                  depth: 2
+                }
+              );
+              if (!editor.isTextSpan(selectedChild))
+                return;
+              const annotationToRemove = selectedChild.marks?.find(
+                (mark) => potentialAnnotations.some((markDef) => markDef._key === mark)
+              );
+              if (!annotationToRemove)
+                return;
+              const previousSpansWithSameAnnotation = [];
+              for (const [child, childPath] of slate.Node.children(editor, blockPath, {
+                reverse: !0
+              }))
+                if (editor.isTextSpan(child) && slate.Path.isBefore(childPath, selectedChildPath))
+                  if (child.marks?.includes(annotationToRemove))
+                    previousSpansWithSameAnnotation.push([child, childPath]);
+                  else
+                    break;
+              const nextSpansWithSameAnnotation = [];
+              for (const [child, childPath] of slate.Node.children(editor, blockPath))
+                if (editor.isTextSpan(child) && slate.Path.isAfter(childPath, selectedChildPath))
+                  if (child.marks?.includes(annotationToRemove))
+                    nextSpansWithSameAnnotation.push([child, childPath]);
+                  else
+                    break;
+              for (const [child, childPath] of [
+                ...previousSpansWithSameAnnotation,
+                [selectedChild, selectedChildPath],
+                ...nextSpansWithSameAnnotation
+              ])
+                slate.Transforms.setNodes(
+                  editor,
+                  {
+                    marks: child.marks?.filter(
+                      (mark) => mark !== annotationToRemove
+                    )
+                  },
+                  { at: childPath }
+                );
+            } else {
+              slate.Transforms.setNodes(
+                editor,
+                {},
+                {
+                  match: (node) => editor.isTextSpan(node),
+                  split: !0,
+                  hanging: !0
+                }
+              );
+              const blocks = slate.Editor.nodes(editor, {
+                at: editor.selection,
+                match: (node) => editor.isTextBlock(node)
               });
+              for (const [block, blockPath] of blocks) {
+                const children = slate.Node.children(editor, blockPath);
+                for (const [child, childPath] of children) {
+                  if (!editor.isTextSpan(child) || !slate.Range.includes(editor.selection, childPath))
+                    continue;
+                  const markDefs = block.markDefs ?? [], marks = child.marks ?? [], marksWithoutAnnotation = marks.filter((mark) => markDefs.find(
+                    (markDef2) => markDef2._key === mark
+                  )?._type !== type.name);
+                  marksWithoutAnnotation.length !== marks.length && slate.Transforms.setNodes(
+                    editor,
+                    {
+                      marks: marksWithoutAnnotation
+                    },
+                    { at: childPath }
+                  );
+                }
+              }
             }
-          }), slate.Editor.normalize(editor), editor.onChange();
-        }
+        }), editor.onChange();
       },
       getSelection: () => {
         let ptRange = null;
@@ -1247,14 +1524,22 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
           if (existing)
             return existing;
           ptRange = toPortableTextRange(
-            fromSlateValue(editor.children, types$1.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
+            fromSlateValue(
+              editor.children,
+              types$1.block.name,
+              KEY_TO_VALUE_ELEMENT.get(editor)
+            ),
             editor.selection,
             types$1
           ), SLATE_TO_PORTABLE_TEXT_RANGE.set(editor.selection, ptRange);
         }
         return ptRange;
       },
-      getValue: () => fromSlateValue(editor.children, types$1.block.name, KEY_TO_VALUE_ELEMENT.get(editor)),
+      getValue: () => fromSlateValue(
+        editor.children,
+        types$1.block.name,
+        KEY_TO_VALUE_ELEMENT.get(editor)
+      ),
       isCollapsedSelection: () => !!editor.selection && slate.Range.isCollapsed(editor.selection),
       isExpandedSelection: () => !!editor.selection && slate.Range.isExpanded(editor.selection),
       insertBreak: () => {
@@ -1268,23 +1553,94 @@ function createWithEditableAPI(portableTextEditor, types$1, keyGenerator) {
     }), editor;
   };
 }
-function createWithInsertBreak(types2) {
+function createWithInsertBreak(types2, keyGenerator) {
   return function(editor) {
     const { insertBreak } = editor;
     return editor.insertBreak = () => {
-      if (editor.selection) {
-        const focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
-        if (editor.isTextBlock(focusBlock)) {
-          const [, end] = slate.Range.edges(editor.selection), isEndAtStartOfNode = slate.Editor.isStart(editor, end, end.path), isEmptyTextBlock = focusBlock && isEqualToEmptyEditor([focusBlock], types2);
-          if (isEndAtStartOfNode && !isEmptyTextBlock) {
-            slate.Editor.insertNode(editor, editor.pteCreateEmptyBlock());
-            const [nextBlockPath] = slate.Path.next(focusBlockPath);
-            slate.Transforms.select(editor, {
-              anchor: { path: [nextBlockPath, 0], offset: 0 },
-              focus: { path: [nextBlockPath, 0], offset: 0 }
-            }), editor.onChange();
-            return;
-          }
+      if (!editor.selection) {
+        insertBreak();
+        return;
+      }
+      const focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath);
+      if (editor.isTextBlock(focusBlock)) {
+        const [start, end] = slate.Range.edges(editor.selection), isEndAtStartOfBlock = isEqual__default.default(end, {
+          path: [...focusBlockPath, 0],
+          offset: 0
+        });
+        if (isEndAtStartOfBlock && slate.Range.isCollapsed(editor.selection)) {
+          const focusDecorators = editor.isTextSpan(focusBlock.children[0]) ? (focusBlock.children[0].marks ?? []).filter(
+            (mark) => types2.decorators.some((decorator) => decorator.value === mark)
+          ) : [];
+          slate.Editor.insertNode(
+            editor,
+            editor.pteCreateTextBlock({ decorators: focusDecorators })
+          );
+          const [nextBlockPath] = slate.Path.next(focusBlockPath);
+          slate.Transforms.select(editor, {
+            anchor: { path: [nextBlockPath, 0], offset: 0 },
+            focus: { path: [nextBlockPath, 0], offset: 0 }
+          }), editor.onChange();
+          return;
+        }
+        const lastFocusBlockChild = focusBlock.children[focusBlock.children.length - 1], isStartAtEndOfBlock = isEqual__default.default(start, {
+          path: [...focusBlockPath, focusBlock.children.length - 1],
+          offset: editor.isTextSpan(lastFocusBlockChild) ? lastFocusBlockChild.text.length : 0
+        });
+        if (!isEndAtStartOfBlock && !isStartAtEndOfBlock) {
+          slate.Editor.withoutNormalizing(editor, () => {
+            if (!editor.selection)
+              return;
+            slate.Transforms.splitNodes(editor, {
+              at: editor.selection
+            });
+            const [nextNode, nextNodePath] = slate.Editor.node(
+              editor,
+              slate.Path.next(focusBlockPath),
+              { depth: 1 }
+            );
+            if (slate.Transforms.setSelection(editor, {
+              anchor: { path: [...nextNodePath, 0], offset: 0 },
+              focus: { path: [...nextNodePath, 0], offset: 0 }
+            }), editor.isTextBlock(nextNode) && nextNode.markDefs && nextNode.markDefs.length > 0) {
+              const newMarkDefKeys = /* @__PURE__ */ new Map(), prevNodeSpans = Array.from(
+                slate.Node.children(editor, focusBlockPath)
+              ).map((entry) => entry[0]).filter((node) => editor.isTextSpan(node)), children = slate.Node.children(editor, nextNodePath);
+              for (const [child, childPath] of children) {
+                if (!editor.isTextSpan(child))
+                  continue;
+                const marks = child.marks ?? [];
+                for (const mark of marks)
+                  types2.decorators.some(
+                    (decorator) => decorator.value === mark
+                  ) || prevNodeSpans.some(
+                    (prevNodeSpan) => prevNodeSpan.marks?.includes(mark)
+                  ) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(mark, keyGenerator());
+                const newMarks = marks.map(
+                  (mark) => newMarkDefKeys.get(mark) ?? mark
+                );
+                isEqual__default.default(marks, newMarks) || slate.Transforms.setNodes(
+                  editor,
+                  { marks: newMarks },
+                  {
+                    at: childPath
+                  }
+                );
+              }
+              const newMarkDefs = nextNode.markDefs.map((markDef) => ({
+                ...markDef,
+                _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
+              }));
+              isEqual__default.default(nextNode.markDefs, newMarkDefs) || slate.Transforms.setNodes(
+                editor,
+                { markDefs: newMarkDefs },
+                {
+                  at: nextNodePath,
+                  match: (node) => editor.isTextBlock(node)
+                }
+              );
+            }
+          }), editor.onChange();
+          return;
         }
       }
       insertBreak();
@@ -2086,9 +2442,11 @@ function createApplyPatch(schemaTypes) {
   let previousPatch;
   return function(editor, patch) {
     let changed = !1;
-    debugVerbose$4 && (debug$i(`
+    debugVerbose$4 && (debug$i(
+      `
 
-NEW PATCH =============================================================`), debug$i(JSON.stringify(patch, null, 2)));
+NEW PATCH =============================================================`
+    ), debug$i(JSON.stringify(patch, null, 2)));
     try {
       switch (patch.type) {
         case "insert":
@@ -2113,14 +2471,19 @@ NEW PATCH =============================================================`), debug
   };
 }
 function diffMatchPatch(editor, patch) {
-  const { block, child, childPath } = findBlockAndChildFromPath(editor, patch.path);
+  const { block, child, childPath } = findBlockAndChildFromPath(
+    editor,
+    patch.path
+  );
   if (!block)
     return debug$i("Block not found"), !1;
   if (!child || !childPath)
     return debug$i("Child not found"), !1;
   if (!(block && editor.isTextBlock(block) && patch.path.length === 4 && patch.path[1] === "children" && patch.path[3] === "text") || !slate.Text.isText(child))
     return !1;
-  const patches2 = parse(patch.value), [newValue] = apply(patches2, child.text, { allowExceedingIndices: !0 }), diff$1 = cleanupEfficiency(diff(child.text, newValue), 5);
+  const patches2 = parse(patch.value), [newValue] = apply(patches2, child.text, {
+    allowExceedingIndices: !0
+  }), diff$1 = cleanupEfficiency(diff(child.text, newValue), 5);
   debugState(editor, "before");
   let offset = 0;
   for (const [op, text] of diff$1)
@@ -2154,12 +2517,17 @@ function insertPatch(editor, patch, schemaTypes) {
     { schemaTypes },
     KEY_TO_SLATE_ELEMENT.get(editor)
   ), targetChildIndex = targetChildPath[1], normalizedIdx = position === "after" ? targetChildIndex + 1 : targetChildIndex, childInsertPath = [targetChildPath[0], normalizedIdx];
-  return debug$i(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && slate.Element.isElement(childrenToInsert[0]) && slate.Transforms.insertNodes(editor, childrenToInsert[0].children, { at: childInsertPath }), debugState(editor, "after"), !0;
+  return debug$i(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && slate.Element.isElement(childrenToInsert[0]) && slate.Transforms.insertNodes(editor, childrenToInsert[0].children, {
+    at: childInsertPath
+  }), debugState(editor, "after"), !0;
 }
 function setPatch(editor, patch) {
   let value = patch.value;
   typeof patch.path[3] == "string" && (value = {}, value[patch.path[3]] = patch.value);
-  const { block, blockPath, child, childPath } = findBlockAndChildFromPath(editor, patch.path);
+  const { block, blockPath, child, childPath } = findBlockAndChildFromPath(
+    editor,
+    patch.path
+  );
   if (!block)
     return debug$i("Block not found"), !1;
   const isTextBlock = editor.isTextBlock(block);
@@ -2220,12 +2588,15 @@ function unsetPatch(editor, patch, previousPatch) {
     const previousSelection = editor.selection;
     return slate.Transforms.deselect(editor), editor.children.forEach((c, i) => {
       slate.Transforms.removeNodes(editor, { at: [i] });
-    }), slate.Transforms.insertNodes(editor, editor.pteCreateEmptyBlock()), previousSelection && slate.Transforms.select(editor, {
+    }), slate.Transforms.insertNodes(editor, editor.pteCreateTextBlock({ decorators: [] })), previousSelection && slate.Transforms.select(editor, {
       anchor: { path: [0, 0], offset: 0 },
       focus: { path: [0, 0], offset: 0 }
     }), editor.onChange(), debugState(editor, "after"), !0;
   }
-  const { block, blockPath, child, childPath } = findBlockAndChildFromPath(editor, patch.path);
+  const { block, blockPath, child, childPath } = findBlockAndChildFromPath(
+    editor,
+    patch.path
+  );
   if (patch.path.length === 1) {
     if (!block || !blockPath)
       return debug$i("Block not found"), !1;
@@ -2257,7 +2628,12 @@ function findBlockAndChildFromPath(editor, path) {
     const isMatch = isKeyedSegment(path[2]) ? node._key === path[2]._key : index === path[2];
     return isMatch && (childIndex = index), isMatch;
   });
-  return child ? { block, child, blockPath, childPath: blockPath?.concat(childIndex) } : { block, blockPath, child: void 0, childPath: void 0 };
+  return child ? {
+    block,
+    child,
+    blockPath,
+    childPath: blockPath?.concat(childIndex)
+  } : { block, blockPath, child: void 0, childPath: void 0 };
 }
 const PATCHING = /* @__PURE__ */ new WeakMap();
 function withoutPatching(editor, fn) {
@@ -2286,10 +2662,17 @@ function createWithUndoRedo(options) {
         patches2.forEach((patch) => {
           if (!reset && patch.origin !== "local" && remotePatches) {
             if (patch.type === "unset" && patch.path.length === 0) {
-              debug$h("Someone else cleared the content, resetting undo/redo history"), editor.history = { undos: [], redos: [] }, remotePatches.splice(0, remotePatches.length), SAVING.set(editor, !0), reset = !0;
+              debug$h(
+                "Someone else cleared the content, resetting undo/redo history"
+              ), editor.history = { undos: [], redos: [] }, remotePatches.splice(0, remotePatches.length), SAVING.set(editor, !0), reset = !0;
               return;
             }
-            remotePatches.push({ patch, time: /* @__PURE__ */ new Date(), snapshot, previousSnapshot });
+            remotePatches.push({
+              patch,
+              time: /* @__PURE__ */ new Date(),
+              snapshot,
+              previousSnapshot
+            });
           }
         }), previousSnapshot = snapshot;
       });
@@ -2310,7 +2693,10 @@ function createWithUndoRedo(options) {
           step.operations.push(op);
         else {
           const newStep = {
-            operations: [...editor.selection === null ? [] : [createSelectOperation(editor)], op],
+            operations: [
+              ...editor.selection === null ? [] : [createSelectOperation(editor)],
+              op
+            ],
             timestamp: /* @__PURE__ */ new Date()
           };
           undos.push(newStep), debug$h("Created new undo step", step);
@@ -2327,12 +2713,20 @@ function createWithUndoRedo(options) {
       if (undos.length > 0) {
         const step = undos[undos.length - 1];
         if (debug$h("Undoing", step), step.operations.length > 0) {
-          const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
+          const otherPatches = remotePatches.filter(
+            (item) => item.time >= step.timestamp
+          );
           let transformedOperations = step.operations;
           otherPatches.forEach((item) => {
             transformedOperations = flatten__default.default(
               transformedOperations.map(
-                (op) => transformOperation(editor, item.patch, op, item.snapshot, item.previousSnapshot)
+                (op) => transformOperation(
+                  editor,
+                  item.patch,
+                  op,
+                  item.snapshot,
+                  item.previousSnapshot
+                )
               )
             );
           });
@@ -2361,12 +2755,20 @@ function createWithUndoRedo(options) {
       if (redos.length > 0) {
         const step = redos[redos.length - 1];
         if (debug$h("Redoing", step), step.operations.length > 0) {
-          const otherPatches = remotePatches.filter((item) => item.time >= step.timestamp);
+          const otherPatches = remotePatches.filter(
+            (item) => item.time >= step.timestamp
+          );
           let transformedOperations = step.operations;
           otherPatches.forEach((item) => {
             transformedOperations = flatten__default.default(
               transformedOperations.map(
-                (op) => transformOperation(editor, item.patch, op, item.snapshot, item.previousSnapshot)
+                (op) => transformOperation(
+                  editor,
+                  item.patch,
+                  op,
+                  item.snapshot,
+                  item.previousSnapshot
+                )
               )
             );
           });
@@ -2391,7 +2793,9 @@ function createWithUndoRedo(options) {
   };
 }
 function transformOperation(editor, patch, operation, snapshot, previousSnapshot) {
-  debugVerbose$3 && (debug$h(`Adjusting '${operation.type}' operation paths for '${patch.type}' patch`), debug$h(`Operation ${JSON.stringify(operation)}`), debug$h(`Patch ${JSON.stringify(patch)}`));
+  debugVerbose$3 && (debug$h(
+    `Adjusting '${operation.type}' operation paths for '${patch.type}' patch`
+  ), debug$h(`Operation ${JSON.stringify(operation)}`), debug$h(`Patch ${JSON.stringify(patch)}`));
   const transformedOperation = { ...operation };
   if (patch.type === "insert" && patch.path.length === 1) {
     const insertBlockIndex = (snapshot || []).findIndex(
@@ -2399,7 +2803,13 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
     );
     return debug$h(
       `Adjusting block path (+${patch.items.length}) for '${transformedOperation.type}' operation and patch '${patch.type}'`
-    ), [adjustBlockPath(transformedOperation, patch.items.length, insertBlockIndex)];
+    ), [
+      adjustBlockPath(
+        transformedOperation,
+        patch.items.length,
+        insertBlockIndex
+      )
+    ];
   }
   if (patch.type === "unset" && patch.path.length === 1) {
     const unsetBlockIndex = (previousSnapshot || []).findIndex(
@@ -2410,9 +2820,14 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
     )), [adjustBlockPath(transformedOperation, -1, unsetBlockIndex)]);
   }
   if (patch.type === "unset" && patch.path.length === 0)
-    return debug$h(`Adjusting selection for unset everything patch and ${operation.type} operation`), [];
+    return debug$h(
+      `Adjusting selection for unset everything patch and ${operation.type} operation`
+    ), [];
   if (patch.type === "diffMatchPatch") {
-    const operationTargetBlock = findOperationTargetBlock(editor, transformedOperation);
+    const operationTargetBlock = findOperationTargetBlock(
+      editor,
+      transformedOperation
+    );
     return !operationTargetBlock || !isEqual__default.default({ _key: operationTargetBlock._key }, patch.path[0]) ? [transformedOperation] : (parse(patch.value).forEach((diffPatch) => {
       let adjustOffsetBy = 0, changedOffset = diffPatch.utf8Start1;
       const { diffs } = diffPatch;
@@ -2438,7 +2853,10 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
 function adjustBlockPath(operation, level, blockIndex) {
   const transformedOperation = { ...operation };
   if (blockIndex >= 0 && transformedOperation.type !== "set_selection" && Array.isArray(transformedOperation.path) && transformedOperation.path[0] >= blockIndex + level && transformedOperation.path[0] + level > -1) {
-    const newPath = [transformedOperation.path[0] + level, ...transformedOperation.path.slice(1)];
+    const newPath = [
+      transformedOperation.path[0] + level,
+      ...transformedOperation.path.slice(1)
+    ];
     transformedOperation.path = newPath;
   }
   if (transformedOperation.type === "set_selection") {
@@ -2526,31 +2944,51 @@ function createWithPatches({
         case "insert_text":
           patches$1 = [
             ...patches$1,
-            ...patchFunctions.insertTextPatch(editor, operation, previousChildren)
+            ...patchFunctions.insertTextPatch(
+              editor,
+              operation,
+              previousChildren
+            )
           ];
           break;
         case "remove_text":
           patches$1 = [
             ...patches$1,
-            ...patchFunctions.removeTextPatch(editor, operation, previousChildren)
+            ...patchFunctions.removeTextPatch(
+              editor,
+              operation,
+              previousChildren
+            )
           ];
           break;
         case "remove_node":
           patches$1 = [
             ...patches$1,
-            ...patchFunctions.removeNodePatch(editor, operation, previousChildren)
+            ...patchFunctions.removeNodePatch(
+              editor,
+              operation,
+              previousChildren
+            )
           ];
           break;
         case "split_node":
           patches$1 = [
             ...patches$1,
-            ...patchFunctions.splitNodePatch(editor, operation, previousChildren)
+            ...patchFunctions.splitNodePatch(
+              editor,
+              operation,
+              previousChildren
+            )
           ];
           break;
         case "insert_node":
           patches$1 = [
             ...patches$1,
-            ...patchFunctions.insertNodePatch(editor, operation, previousChildren)
+            ...patchFunctions.insertNodePatch(
+              editor,
+              operation,
+              previousChildren
+            )
           ];
           break;
         case "set_node":
@@ -2562,17 +3000,27 @@ function createWithPatches({
         case "merge_node":
           patches$1 = [
             ...patches$1,
-            ...patchFunctions.mergeNodePatch(editor, operation, previousChildren)
+            ...patchFunctions.mergeNodePatch(
+              editor,
+              operation,
+              previousChildren
+            )
           ];
           break;
         case "move_node":
           patches$1 = [
             ...patches$1,
-            ...patchFunctions.moveNodePatch(editor, operation, previousChildren)
+            ...patchFunctions.moveNodePatch(
+              editor,
+              operation,
+              previousChildren
+            )
           ];
           break;
       }
-      return !editorWasEmpty && editorIsEmpty && ["merge_node", "set_node", "remove_text", "remove_node"].includes(operation.type) && (patches$1 = [...patches$1, patches.unset([])], change$.next({
+      return !editorWasEmpty && editorIsEmpty && ["merge_node", "set_node", "remove_text", "remove_node"].includes(
+        operation.type
+      ) && (patches$1 = [...patches$1, patches.unset([])], change$.next({
         type: "unset",
         previousValue: fromSlateValue(
           previousChildren,
@@ -2605,7 +3053,10 @@ function createWithPlaceholderBlock() {
         const node = op.node;
         if (op.path[0] === 0 && slate.Editor.isVoid(editor, node)) {
           const nextPath = slate.Path.next(op.path);
-          editor.children[nextPath[0]] || (debug$f("Adding placeholder block"), slate.Editor.insertNode(editor, editor.pteCreateEmptyBlock()));
+          editor.children[nextPath[0]] || (debug$f("Adding placeholder block"), slate.Editor.insertNode(
+            editor,
+            editor.pteCreateTextBlock({ decorators: [] })
+          ));
         }
       }
       apply2(op);
@@ -2624,7 +3075,11 @@ function createWithPortableTextBlockStyle(types2) {
         if (op.type === "split_node" && op.path.length === 1 && editor.isTextBlock(op.properties) && op.properties.style !== defaultStyle && op.path[0] === path[0] && !slate.Path.equals(path, op.path)) {
           const [child] = slate.Editor.node(editor, [op.path[0] + 1, 0]);
           if (slate.Text.isText(child) && child.text === "") {
-            debug$e(`Normalizing split node to ${defaultStyle} style`, op), slate.Transforms.setNodes(editor, { style: defaultStyle }, { at: [op.path[0] + 1], voids: !1 });
+            debug$e(`Normalizing split node to ${defaultStyle} style`, op), slate.Transforms.setNodes(
+              editor,
+              { style: defaultStyle },
+              { at: [op.path[0] + 1], voids: !1 }
+            );
             break;
           }
         }
@@ -2640,9 +3095,13 @@ function createWithPortableTextBlockStyle(types2) {
           match: (node) => editor.isTextBlock(node)
         })
       ].forEach(([node, path]) => {
-        editor.isTextBlock(node) && node.style === blockStyle ? (debug$e(`Unsetting block style '${blockStyle}'`), slate.Transforms.setNodes(editor, { ...node, style: defaultStyle }, {
-          at: path
-        })) : (blockStyle ? debug$e(`Setting style '${blockStyle}'`) : debug$e("Setting default style", defaultStyle), slate.Transforms.setNodes(
+        editor.isTextBlock(node) && node.style === blockStyle ? (debug$e(`Unsetting block style '${blockStyle}'`), slate.Transforms.setNodes(
+          editor,
+          { ...node, style: defaultStyle },
+          {
+            at: path
+          }
+        )) : (blockStyle ? debug$e(`Setting style '${blockStyle}'`) : debug$e("Setting default style", defaultStyle), slate.Transforms.setNodes(
           editor,
           {
             ...node,
@@ -2724,7 +3183,13 @@ function createWithPortableTextLists(types2) {
       return selectedBlocks.length === 0 ? !1 : (selectedBlocks.forEach(([node, path]) => {
         if (editor.isListBlock(node)) {
           let level = node.level || 1;
-          reverse ? (level--, debug$d("Decrementing list level", Math.min(MAX_LIST_LEVEL, Math.max(1, level)))) : (level++, debug$d("Incrementing list level", Math.min(MAX_LIST_LEVEL, Math.max(1, level)))), slate.Transforms.setNodes(
+          reverse ? (level--, debug$d(
+            "Decrementing list level",
+            Math.min(MAX_LIST_LEVEL, Math.max(1, level))
+          )) : (level++, debug$d(
+            "Incrementing list level",
+            Math.min(MAX_LIST_LEVEL, Math.max(1, level))
+          )), slate.Transforms.setNodes(
             editor,
             { level: Math.min(MAX_LIST_LEVEL, Math.max(1, level)) },
             { at: path }
@@ -2766,11 +3231,15 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
   return function(editor) {
     const { apply: apply2, normalizeNode } = editor, decorators = types2.decorators.map((t) => t.value), forceNewSelection = () => {
       editor.selection && (slate.Transforms.select(editor, { ...editor.selection }), editor.selection = { ...editor.selection });
-      const ptRange = toPortableTextRange(editor.children, editor.selection, types2);
+      const ptRange = toPortableTextRange(
+        editor.children,
+        editor.selection,
+        types2
+      );
       change$.next({ type: "selection", selection: ptRange });
     };
     return editor.normalizeNode = (nodeEntry) => {
-      const [node, path] = nodeEntry, isSpan = slate.Text.isText(node) && node._type === types2.span.name, isTextBlock = editor.isTextBlock(node);
+      const [node, path] = nodeEntry;
       if (editor.isTextBlock(node)) {
         const children = slate.Node.children(editor, path);
         for (const [child, childPath] of children) {
@@ -2780,73 +3249,80 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
               "Merging spans",
               JSON.stringify(child, null, 2),
               JSON.stringify(nextNode, null, 2)
-            ), slate.Transforms.mergeNodes(editor, { at: [childPath[0], childPath[1] + 1], voids: !0 });
+            ), slate.Transforms.mergeNodes(editor, {
+              at: [childPath[0], childPath[1] + 1],
+              voids: !0
+            });
             return;
           }
         }
       }
-      if (isSpan || isTextBlock) {
-        if (isSpan && !Array.isArray(node.marks)) {
-          debug$c("Adding .marks to span node"), slate.Transforms.setNodes(editor, { marks: [] }, { at: path });
-          return;
-        }
-        if (isSpan && (node.marks || []).length > 0) {
-          const spanMarks = node.marks || EMPTY_MARKS$1, annotationMarks = spanMarks.filter(
-            (mark) => !types2.decorators.map((dec) => dec.value).includes(mark)
+      if (editor.isTextBlock(node) && !Array.isArray(node.markDefs)) {
+        debug$c("Adding .markDefs to block node"), slate.Transforms.setNodes(editor, { markDefs: [] }, { at: path });
+        return;
+      }
+      if (editor.isTextSpan(node) && !Array.isArray(node.marks)) {
+        debug$c("Adding .marks to span node"), slate.Transforms.setNodes(editor, { marks: [] }, { at: path });
+        return;
+      }
+      if (editor.isTextSpan(node)) {
+        const blockPath = slate.Path.parent(path), [block] = slate.Editor.node(editor, blockPath), decorators2 = types2.decorators.map((decorator) => decorator.value), annotations = node.marks?.filter(
+          (mark) => !decorators2.includes(mark)
+        );
+        if (editor.isTextBlock(block) && node.text === "" && annotations && annotations.length > 0) {
+          debug$c("Removing annotations from empty span node"), slate.Transforms.setNodes(
+            editor,
+            { marks: node.marks?.filter((mark) => decorators2.includes(mark)) },
+            { at: path }
           );
-          if (annotationMarks.length > 0) {
-            const [block] = slate.Editor.node(editor, slate.Path.parent(path)), orphanedMarks = editor.isTextBlock(block) && annotationMarks.filter(
-              (mark) => !block.markDefs?.find((def) => def._key === mark)
-            ) || [];
-            if (orphanedMarks.length > 0) {
-              debug$c("Removing orphaned .marks from span node"), slate.Transforms.setNodes(
-                editor,
-                { marks: spanMarks.filter((mark) => !orphanedMarks.includes(mark)) },
-                { at: path }
-              );
-              return;
-            }
-          }
+          return;
         }
-        for (const op of editor.operations) {
-          if (op.type === "merge_node" && op.path.length === 1 && "markDefs" in op.properties && op.properties._type === types2.block.name && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] - 1 >= 0) {
-            const [targetBlock, targetPath] = slate.Editor.node(editor, [op.path[0] - 1]);
-            if (debug$c("Copying markDefs over to merged block", op), editor.isTextBlock(targetBlock)) {
-              const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = uniq__default.default([...oldDefs, ...op.properties.markDefs]);
-              if (!isEqual__default.default(newMarkDefs, targetBlock.markDefs)) {
-                slate.Transforms.setNodes(editor, { markDefs: newMarkDefs }, { at: targetPath, voids: !1 });
-                return;
-              }
-            }
-          }
-          if (op.type === "split_node" && op.path.length === 1 && slate.Element.isElementProps(op.properties) && op.properties._type === types2.block.name && "markDefs" in op.properties && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] + 1 < editor.children.length) {
-            const [targetBlock, targetPath] = slate.Editor.node(editor, [op.path[0] + 1]);
-            if (debug$c("Copying markDefs over to split block", op), editor.isTextBlock(targetBlock)) {
-              const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [];
-              slate.Transforms.setNodes(
+      }
+      if (editor.isTextBlock(node)) {
+        const decorators2 = types2.decorators.map((decorator) => decorator.value);
+        for (const [child, childPath] of slate.Node.children(editor, path))
+          if (editor.isTextSpan(child)) {
+            const marks = child.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !node.markDefs?.find((def) => def._key === mark));
+            if (orphanedAnnotations.length > 0) {
+              debug$c("Removing orphaned annotations from span node"), slate.Transforms.setNodes(
                 editor,
-                { markDefs: uniq__default.default([...oldDefs, ...op.properties.markDefs]) },
-                { at: targetPath, voids: !1 }
+                {
+                  marks: marks.filter(
+                    (mark) => !orphanedAnnotations.includes(mark)
+                  )
+                },
+                { at: childPath }
               );
               return;
             }
           }
-          if (op.type === "split_node" && op.path.length === 2 && op.properties._type === types2.span.name && "marks" in op.properties && Array.isArray(op.properties.marks) && op.properties.marks.length > 0 && op.path[0] + 1 < editor.children.length) {
-            const [child, childPath] = slate.Editor.node(editor, [op.path[0] + 1, 0]);
-            if (slate.Text.isText(child) && child.text === "" && Array.isArray(child.marks) && child.marks.length > 0) {
-              slate.Transforms.setNodes(editor, { marks: [] }, { at: childPath, voids: !1 });
-              return;
-            }
-          }
-          if (op.type === "split_node" && op.path.length === 1 && op.properties._type === types2.block.name && "markDefs" in op.properties && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0) {
-            const [block, blockPath] = slate.Editor.node(editor, [op.path[0]]);
-            if (editor.isTextBlock(block) && block.children.length === 1 && block.markDefs && block.markDefs.length > 0 && slate.Text.isText(block.children[0]) && block.children[0].text === "" && (!block.children[0].marks || block.children[0].marks.length === 0)) {
-              slate.Transforms.setNodes(editor, { markDefs: [] }, { at: blockPath });
-              return;
-            }
+      }
+      if (editor.isTextSpan(node)) {
+        const blockPath = slate.Path.parent(path), [block] = slate.Editor.node(editor, blockPath);
+        if (editor.isTextBlock(block)) {
+          const decorators2 = types2.decorators.map(
+            (decorator) => decorator.value
+          ), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
+          if (orphanedAnnotations.length > 0) {
+            debug$c("Removing orphaned annotations from span node"), slate.Transforms.setNodes(
+              editor,
+              {
+                marks: marks.filter(
+                  (mark) => !orphanedAnnotations.includes(mark)
+                )
+              },
+              { at: path }
+            );
+            return;
           }
         }
       }
+      if (editor.isTextBlock(node)) {
+        const markDefs = node.markDefs ?? [], markDefKeys = /* @__PURE__ */ new Set(), newMarkDefs = [];
+        for (const markDef of markDefs)
+          markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
+        markDefs.length !== newMarkDefs.length && (debug$c("Removing duplicate markDefs"), slate.Transforms.setNodes(editor, { markDefs: newMarkDefs }, { at: path }));
+      }
       if (editor.isTextBlock(node) && !editor.operations.some(
         (op) => op.type === "merge_node" && "markDefs" in op.properties && op.path.length === 1
       )) {
@@ -2874,7 +3350,9 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
       }
       if (op.type === "insert_text") {
         const { selection } = editor;
-        if (selection && slate.Range.isCollapsed(selection) && slate.Editor.marks(editor)?.marks?.some((mark) => !decorators.includes(mark))) {
+        if (selection && slate.Range.isCollapsed(selection) && slate.Editor.marks(editor)?.marks?.some(
+          (mark) => !decorators.includes(mark)
+        )) {
           const [node] = Array.from(
             slate.Editor.nodes(editor, {
               mode: "lowest",
@@ -2925,7 +3403,11 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
               ...slate.Editor.marks(editor) || {}
             }.marks || []).filter((mark) => decorators.includes(mark));
             slate.Editor.withoutNormalizing(editor, () => {
-              apply2(op), slate.Transforms.setNodes(editor, { marks: marksWithoutAnnotationMarks }, { at: op.path });
+              apply2(op), slate.Transforms.setNodes(
+                editor,
+                { marks: marksWithoutAnnotationMarks },
+                { at: op.path }
+              );
             }), editor.onChange();
             return;
           }
@@ -2937,13 +3419,34 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
           }
         }
       }
+      if (op.type === "merge_node" && op.path.length === 1 && "markDefs" in op.properties && op.properties._type === types2.block.name && Array.isArray(op.properties.markDefs) && op.properties.markDefs.length > 0 && op.path[0] - 1 >= 0) {
+        const [targetBlock, targetPath] = slate.Editor.node(editor, [op.path[0] - 1]);
+        if (editor.isTextBlock(targetBlock)) {
+          const oldDefs = Array.isArray(targetBlock.markDefs) && targetBlock.markDefs || [], newMarkDefs = uniq__default.default([...oldDefs, ...op.properties.markDefs]);
+          debug$c("Copying markDefs over to merged block", op), slate.Transforms.setNodes(
+            editor,
+            { markDefs: newMarkDefs },
+            { at: targetPath, voids: !1 }
+          ), apply2(op);
+          return;
+        }
+      }
       apply2(op);
     }, editor.addMark = (mark) => {
       if (editor.selection) {
         if (slate.Range.isExpanded(editor.selection))
           slate.Editor.withoutNormalizing(editor, () => {
-            slate.Transforms.setNodes(editor, {}, { match: slate.Text.isText, split: !0 });
-            const splitTextNodes = slate.Range.isRange(editor.selection) ? [...slate.Editor.nodes(editor, { at: editor.selection, match: slate.Text.isText })] : [];
+            slate.Transforms.setNodes(
+              editor,
+              {},
+              { match: slate.Text.isText, split: !0, hanging: !0 }
+            );
+            const splitTextNodes = slate.Range.isRange(editor.selection) ? [
+              ...slate.Editor.nodes(editor, {
+                at: editor.selection,
+                match: slate.Text.isText
+              })
+            ] : [];
             splitTextNodes.length > 1 && splitTextNodes.every((node) => node[0].marks?.includes(mark)) ? editor.removeMark(mark) : splitTextNodes.forEach(([node, path]) => {
               const marks = [
                 ...(Array.isArray(node.marks) ? node.marks : []).filter(
@@ -2959,13 +3462,32 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
             });
           });
         else {
-          const existingMarks = {
-            ...slate.Editor.marks(editor) || {}
-          }.marks || [], marks = {
-            ...slate.Editor.marks(editor) || {},
-            marks: [...existingMarks, mark]
-          };
-          return editor.marks = marks, forceNewSelection(), editor;
+          const [block, blockPath] = slate.Editor.node(editor, editor.selection, {
+            depth: 1
+          }), lonelyEmptySpan = editor.isTextBlock(block) && block.children.length === 1 && editor.isTextSpan(block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
+          if (lonelyEmptySpan) {
+            const existingMarks = lonelyEmptySpan.marks ?? [], existingMarksWithoutDecorator = existingMarks.filter(
+              (existingMark) => existingMark !== mark
+            );
+            slate.Transforms.setNodes(
+              editor,
+              {
+                marks: existingMarks.length === existingMarksWithoutDecorator.length ? [...existingMarks, mark] : existingMarksWithoutDecorator
+              },
+              {
+                at: blockPath,
+                match: (node) => editor.isTextSpan(node)
+              }
+            );
+          } else {
+            const existingMarks = {
+              ...slate.Editor.marks(editor) || {}
+            }.marks || [], marks = {
+              ...slate.Editor.marks(editor) || {},
+              marks: [...existingMarks, mark]
+            };
+            return editor.marks = marks, forceNewSelection(), editor;
+          }
         }
         editor.onChange(), forceNewSelection();
       }
@@ -2975,16 +3497,21 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
       if (selection) {
         if (slate.Range.isExpanded(selection))
           slate.Editor.withoutNormalizing(editor, () => {
-            slate.Transforms.setNodes(editor, {}, { match: slate.Text.isText, split: !0 }), editor.selection && [
-              ...slate.Editor.nodes(editor, { at: editor.selection, match: slate.Text.isText })
+            slate.Transforms.setNodes(
+              editor,
+              {},
+              { match: slate.Text.isText, split: !0, hanging: !0 }
+            ), editor.selection && [
+              ...slate.Editor.nodes(editor, {
+                at: editor.selection,
+                match: slate.Text.isText
+              })
             ].forEach(([node, path]) => {
               const block = editor.children[path[0]];
               slate.Element.isElement(block) && block.children.includes(node) && slate.Transforms.setNodes(
                 editor,
                 {
-                  marks: (Array.isArray(node.marks) ? node.marks : []).filter(
-                    (eMark) => eMark !== mark
-                  ),
+                  marks: (Array.isArray(node.marks) ? node.marks : []).filter((eMark) => eMark !== mark),
                   _type: "span"
                 },
                 { at: path }
@@ -2992,13 +3519,32 @@ function createWithPortableTextMarkModel(types2, change$, keyGenerator) {
             });
           }), slate.Editor.normalize(editor);
         else {
-          const existingMarks = {
-            ...slate.Editor.marks(editor) || {}
-          }.marks || [], marks = {
-            ...slate.Editor.marks(editor) || {},
-            marks: existingMarks.filter((eMark) => eMark !== mark)
-          };
-          return editor.marks = { marks: marks.marks, _type: "span" }, forceNewSelection(), editor;
+          const [block, blockPath] = slate.Editor.node(editor, selection, {
+            depth: 1
+          }), lonelyEmptySpan = editor.isTextBlock(block) && block.children.length === 1 && editor.isTextSpan(block.children[0]) && block.children[0].text === "" ? block.children[0] : void 0;
+          if (lonelyEmptySpan) {
+            const existingMarksWithoutDecorator = (lonelyEmptySpan.marks ?? []).filter(
+              (existingMark) => existingMark !== mark
+            );
+            slate.Transforms.setNodes(
+              editor,
+              {
+                marks: existingMarksWithoutDecorator
+              },
+              {
+                at: blockPath,
+                match: (node) => editor.isTextSpan(node)
+              }
+            );
+          } else {
+            const existingMarks = {
+              ...slate.Editor.marks(editor) || {}
+            }.marks || [], marks = {
+              ...slate.Editor.marks(editor) || {},
+              marks: existingMarks.filter((eMark) => eMark !== mark)
+            };
+            return editor.marks = { marks: marks.marks, _type: "span" }, forceNewSelection(), editor;
+          }
         }
         editor.onChange(), forceNewSelection();
       }
@@ -3063,7 +3609,11 @@ function createWithSchemaTypes({
       if (node._type === void 0 && path.length === 2) {
         debug$a("Setting span type on text node without a type");
         const span = node, key = span._key || keyGenerator();
-        slate.Transforms.setNodes(editor, { ...span, _type: schemaTypes.span.name, _key: key }, { at: path });
+        slate.Transforms.setNodes(
+          editor,
+          { ...span, _type: schemaTypes.span.name, _key: key },
+          { at: path }
+        );
       }
       if (node._key === void 0 && (path.length === 1 || path.length === 2)) {
         debug$a("Setting missing key on child node without a key");
@@ -3075,7 +3625,11 @@ function createWithSchemaTypes({
   };
 }
 const debug$9 = debugWithName("plugin:withUtils");
-function createWithUtils({ schemaTypes, keyGenerator, portableTextEditor }) {
+function createWithUtils({
+  schemaTypes,
+  keyGenerator,
+  portableTextEditor
+}) {
   return function(editor) {
     return editor.pteExpandToWord = () => {
       const { selection } = editor;
@@ -3095,7 +3649,7 @@ function createWithUtils({ schemaTypes, keyGenerator, portableTextEditor }) {
         }
         debug$9("pteExpandToWord: Can't expand to word here");
       }
-    }, editor.pteCreateEmptyBlock = () => toSlateValue(
+    }, editor.pteCreateTextBlock = (options) => toSlateValue(
       [
         {
           _type: schemaTypes.block.name,
@@ -3107,7 +3661,9 @@ function createWithUtils({ schemaTypes, keyGenerator, portableTextEditor }) {
               _type: "span",
               _key: keyGenerator(),
               text: "",
-              marks: []
+              marks: options.decorators.filter(
+                (decorator) => schemaTypes.decorators.find(({ value }) => value === decorator)
+              )
             }
           ]
         }
@@ -3156,59 +3712,46 @@ function createWithHotkeys(types$1, portableTextEditor, hotkeysFromOptions) {
             }
           }
       });
-      const isEnter = isHotkeyEsm.isHotkey("enter", event.nativeEvent), isTab = isHotkeyEsm.isHotkey("tab", event.nativeEvent), isShiftEnter = isHotkeyEsm.isHotkey("shift+enter", event.nativeEvent), isShiftTab = isHotkeyEsm.isHotkey("shift+tab", event.nativeEvent), isBackspace = isHotkeyEsm.isHotkey("backspace", event.nativeEvent), isDelete = isHotkeyEsm.isHotkey("delete", event.nativeEvent), isArrowDown = isHotkeyEsm.isHotkey("down", event.nativeEvent), isArrowUp = isHotkeyEsm.isHotkey("up", event.nativeEvent);
+      const isEnter = isHotkeyEsm.isHotkey("enter", event.nativeEvent), isTab = isHotkeyEsm.isHotkey("tab", event.nativeEvent), isShiftEnter = isHotkeyEsm.isHotkey("shift+enter", event.nativeEvent), isShiftTab = isHotkeyEsm.isHotkey("shift+tab", event.nativeEvent), isArrowDown = isHotkeyEsm.isHotkey("down", event.nativeEvent), isArrowUp = isHotkeyEsm.isHotkey("up", event.nativeEvent);
       if (isArrowDown && editor.selection) {
-        const focusBlock = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
+        const focusBlock = slate.Node.descendant(
+          editor,
+          editor.selection.focus.path.slice(0, 1)
+        );
         if (focusBlock && slate.Editor.isVoid(editor, focusBlock)) {
           const nextPath = slate.Path.next(editor.selection.focus.path.slice(0, 1));
           if (!slate.Node.has(editor, nextPath)) {
-            slate.Transforms.insertNodes(editor, editor.pteCreateEmptyBlock(), { at: nextPath }), editor.onChange();
+            slate.Transforms.insertNodes(
+              editor,
+              editor.pteCreateTextBlock({ decorators: [] }),
+              {
+                at: nextPath
+              }
+            ), editor.onChange();
             return;
           }
         }
       }
       if (isArrowUp && editor.selection) {
-        const isFirstBlock = editor.selection.focus.path[0] === 0, focusBlock = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
-        if (isFirstBlock && focusBlock && slate.Editor.isVoid(editor, focusBlock)) {
-          slate.Transforms.insertNodes(editor, editor.pteCreateEmptyBlock(), { at: [0] }), slate.Transforms.select(editor, { path: [0, 0], offset: 0 }), editor.onChange();
-          return;
-        }
-      }
-      if (isBackspace && editor.selection && editor.selection.focus.path[0] === 0 && slate.Range.isCollapsed(editor.selection)) {
-        const focusBlock = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1)), nextPath = slate.Path.next(editor.selection.focus.path.slice(0, 1)), nextBlock = slate.Node.has(editor, nextPath), isTextBlock = types.isPortableTextTextBlock(focusBlock), isEmptyFocusBlock = isTextBlock && focusBlock.children.length === 1 && focusBlock.children?.[0]?.text === "";
-        if (nextBlock && isTextBlock && isEmptyFocusBlock) {
-          event.preventDefault(), event.stopPropagation(), slate.Transforms.removeNodes(editor, { match: (n) => n === focusBlock }), editor.onChange();
-          return;
-        }
-      }
-      if (isBackspace && editor.selection && editor.selection.focus.path[0] > 0 && slate.Range.isCollapsed(editor.selection)) {
-        const prevPath = slate.Path.previous(editor.selection.focus.path.slice(0, 1)), prevBlock = slate.Node.descendant(editor, prevPath), focusBlock = slate.Node.descendant(editor, editor.selection.focus.path.slice(0, 1));
-        if (prevBlock && focusBlock && slate.Editor.isVoid(editor, prevBlock) && editor.selection.focus.offset === 0) {
-          debug$8("Preventing deleting void block above"), event.preventDefault(), event.stopPropagation();
-          const isTextBlock = types.isPortableTextTextBlock(focusBlock), isEmptyFocusBlock = isTextBlock && focusBlock.children.length === 1 && focusBlock.children?.[0]?.text === "";
-          if (!isTextBlock || isEmptyFocusBlock) {
-            slate.Transforms.removeNodes(editor, { match: (n) => n === focusBlock }), slate.Transforms.select(editor, prevPath), editor.onChange();
-            return;
-          }
-          if (isTextBlock && !isEmptyFocusBlock) {
-            slate.Transforms.select(editor, prevPath), editor.onChange();
-            return;
-          }
-          return;
-        }
-      }
-      if (isDelete && editor.selection && editor.selection.focus.offset === 0 && slate.Range.isCollapsed(editor.selection) && editor.children[editor.selection.focus.path[0] + 1]) {
-        const nextBlock = slate.Node.descendant(
+        const isFirstBlock = editor.selection.focus.path[0] === 0, focusBlock = slate.Node.descendant(
           editor,
-          slate.Path.next(editor.selection.focus.path.slice(0, 1))
-        ), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = slate.Node.descendant(editor, focusBlockPath), isEmptyFocusBlock = types.isPortableTextTextBlock(focusBlock) && focusBlock.children.length === 1 && focusBlock.children?.[0]?.text === "";
-        if (nextBlock && focusBlock && !slate.Editor.isVoid(editor, focusBlock) && slate.Editor.isVoid(editor, nextBlock) && isEmptyFocusBlock) {
-          debug$8("Preventing deleting void block below"), event.preventDefault(), event.stopPropagation(), slate.Transforms.removeNodes(editor, { match: (n) => n === focusBlock }), slate.Transforms.select(editor, focusBlockPath), editor.onChange();
+          editor.selection.focus.path.slice(0, 1)
+        );
+        if (isFirstBlock && focusBlock && slate.Editor.isVoid(editor, focusBlock)) {
+          slate.Transforms.insertNodes(
+            editor,
+            editor.pteCreateTextBlock({ decorators: [] }),
+            {
+              at: [0]
+            }
+          ), slate.Transforms.select(editor, { path: [0, 0], offset: 0 }), editor.onChange();
           return;
         }
       }
       if ((isTab || isShiftTab) && editor.selection) {
-        const [focusChild] = slate.Editor.node(editor, editor.selection.focus, { depth: 2 }), [focusBlock] = types.isPortableTextSpan(focusChild) ? slate.Editor.node(editor, editor.selection.focus, { depth: 1 }) : [], hasAnnotationFocus = focusChild && types.isPortableTextTextBlock(focusBlock) && types.isPortableTextSpan(focusChild) && (focusChild.marks || []).filter(
+        const [focusChild] = slate.Editor.node(editor, editor.selection.focus, {
+          depth: 2
+        }), [focusBlock] = types.isPortableTextSpan(focusChild) ? slate.Editor.node(editor, editor.selection.focus, { depth: 1 }) : [], hasAnnotationFocus = focusChild && types.isPortableTextTextBlock(focusBlock) && types.isPortableTextSpan(focusChild) && (focusChild.marks || []).filter(
           (m) => (focusBlock.markDefs || []).map((def) => def._key).includes(m)
         ).length > 0, [start] = slate.Range.edges(editor.selection), atStartOfNode = slate.Editor.isStart(editor, start, start.path);
         focusChild && types.isPortableTextSpan(focusChild) && (!hasAnnotationFocus || atStartOfNode) && editor.pteIncrementBlockLevels(isShiftTab) && event.preventDefault();
@@ -3222,12 +3765,15 @@ function createWithHotkeys(types$1, portableTextEditor, hotkeysFromOptions) {
         if (editor.isTextBlock(focusBlock) && focusBlock.style && focusBlock.style !== types$1.styles[0].value) {
           const [, end] = slate.Range.edges(editor.selection);
           if (slate.Editor.isEnd(editor, end, end.path)) {
-            slate.Editor.insertNode(editor, editor.pteCreateEmptyBlock()), event.preventDefault(), editor.onChange();
+            slate.Editor.insertNode(
+              editor,
+              editor.pteCreateTextBlock({ decorators: [] })
+            ), event.preventDefault(), editor.onChange();
             return;
           }
         }
         if (focusBlock && slate.Editor.isVoid(editor, focusBlock)) {
-          slate.Editor.insertNode(editor, editor.pteCreateEmptyBlock()), event.preventDefault(), editor.onChange();
+          slate.Editor.insertNode(editor, editor.pteCreateTextBlock({ decorators: [] })), event.preventDefault(), editor.onChange();
           return;
         }
         event.preventDefault(), editor.insertBreak(), editor.onChange();
@@ -3247,7 +3793,13 @@ function createWithHotkeys(types$1, portableTextEditor, hotkeysFromOptions) {
 }
 function validateValue(value, types$1, keyGenerator) {
   let resolution = null, valid = !0;
-  const validChildTypes = [types$1.span.name, ...types$1.inlineObjects.map((t) => t.name)], validBlockTypes = [types$1.block.name, ...types$1.blockObjects.map((t) => t.name)];
+  const validChildTypes = [
+    types$1.span.name,
+    ...types$1.inlineObjects.map((t) => t.name)
+  ], validBlockTypes = [
+    types$1.block.name,
+    ...types$1.blockObjects.map((t) => t.name)
+  ];
   return value === void 0 ? { valid: !0, resolution: null, value } : !Array.isArray(value) || value.length === 0 ? {
     valid: !1,
     resolution: {
@@ -3290,7 +3842,9 @@ function validateValue(value, types$1, keyGenerator) {
       if (blk._type === "block") {
         const currentBlockTypeName = types$1.block.name;
         return resolution = {
-          patches: [patches.set({ ...blk, _type: currentBlockTypeName }, [{ _key: blk._key }])],
+          patches: [
+            patches.set({ ...blk, _type: currentBlockTypeName }, [{ _key: blk._key }])
+          ],
           description: `Block with _key '${blk._key}' has invalid type name '${blk._type}'. According to the schema, the block type name is '${currentBlockTypeName}'`,
           action: `Use type '${currentBlockTypeName}'`,
           item: blk,
@@ -3302,7 +3856,9 @@ function validateValue(value, types$1, keyGenerator) {
         }, !0;
       }
       return !blk._type && types.isPortableTextTextBlock({ ...blk, _type: types$1.block.name }) ? (resolution = {
-        patches: [patches.set({ ...blk, _type: types$1.block.name }, [{ _key: blk._key }])],
+        patches: [
+          patches.set({ ...blk, _type: types$1.block.name }, [{ _key: blk._key }])
+        ],
         description: `Block with _key '${blk._key}' is missing a type name. According to the schema, the block type name is '${types$1.block.name}'`,
         action: `Use type '${types$1.block.name}'`,
         item: blk,
@@ -3372,7 +3928,11 @@ function validateValue(value, types$1, keyGenerator) {
       }
       if (blk.markDefs && !Array.isArray(blk.markDefs))
         return resolution = {
-          patches: [patches.set({ ...textBlock, markDefs: EMPTY_MARKDEFS }, [{ _key: textBlock._key }])],
+          patches: [
+            patches.set({ ...textBlock, markDefs: EMPTY_MARKDEFS }, [
+              { _key: textBlock._key }
+            ])
+          ],
           description: "Block has invalid required property 'markDefs'.",
           action: "Add empty markDefs array",
           item: textBlock,
@@ -3405,7 +3965,10 @@ function validateValue(value, types$1, keyGenerator) {
             i18n: {
               description: "inputs.portable-text.invalid-value.orphaned-mark-defs.description",
               action: "inputs.portable-text.invalid-value.orphaned-mark-defs.action",
-              values: { key: blk._key, unusedMarkDefs: unusedMarkDefs.map((m) => m.toString()) }
+              values: {
+                key: blk._key,
+                unusedMarkDefs: unusedMarkDefs.map((m) => m.toString())
+              }
             }
           }, !0;
       }
@@ -3423,7 +3986,9 @@ function validateValue(value, types$1, keyGenerator) {
           return resolution = {
             autoResolve: !0,
             patches: spanChildren.map((child) => patches.set(
-              (child.marks || []).filter((cMrk) => !orphanedMarks.includes(cMrk)),
+              (child.marks || []).filter(
+                (cMrk) => !orphanedMarks.includes(cMrk)
+              ),
               [{ _key: blk._key }, "children", { _key: child._key }, "marks"]
             )),
             description: `Block with _key '${blk._key}' contains marks (${orphaned}) not supported by the current content model.`,
@@ -3432,7 +3997,10 @@ function validateValue(value, types$1, keyGenerator) {
             i18n: {
               description: "inputs.portable-text.invalid-value.orphaned-marks.description",
               action: "inputs.portable-text.invalid-value.orphaned-marks.action",
-              values: { key: blk._key, orphanedMarks: orphanedMarks.map((m) => m.toString()) }
+              values: {
+                key: blk._key,
+                orphanedMarks: orphanedMarks.map((m) => m.toString())
+              }
             }
           }, !0;
         }
@@ -3454,7 +4022,9 @@ function validateValue(value, types$1, keyGenerator) {
           const newChild = { ...child, _key: keyGenerator() };
           return resolution = {
             autoResolve: !0,
-            patches: [patches.set(newChild, [{ _key: blk._key }, "children", cIndex])],
+            patches: [
+              patches.set(newChild, [{ _key: blk._key }, "children", cIndex])
+            ],
             description: `Child at index ${cIndex} is missing required _key in block with _key ${blk._key}.`,
             action: "Set a new random _key on the object",
             item: blk,
@@ -3467,7 +4037,11 @@ function validateValue(value, types$1, keyGenerator) {
         }
         return child._type ? validChildTypes.includes(child._type) ? child._type === types$1.span.name && typeof child.text != "string" ? (resolution = {
           patches: [
-            patches.set({ ...child, text: "" }, [{ _key: blk._key }, "children", { _key: child._key }])
+            patches.set({ ...child, text: "" }, [
+              { _key: blk._key },
+              "children",
+              { _key: child._key }
+            ])
           ],
           description: `Child with _key '${child._key}' in block with key '${blk._key}' has missing or invalid text property!`,
           action: "Write an empty text property to the object",
@@ -3478,17 +4052,25 @@ function validateValue(value, types$1, keyGenerator) {
             values: { key: blk._key, childKey: child._key }
           }
         }, !0) : !1 : (resolution = {
-          patches: [patches.unset([{ _key: blk._key }, "children", { _key: child._key }])],
+          patches: [
+            patches.unset([{ _key: blk._key }, "children", { _key: child._key }])
+          ],
           description: `Child with _key '${child._key}' in block with key '${blk._key}' has invalid '_type' property (${child._type}).`,
           action: "Remove the object",
           item: blk,
           i18n: {
             description: "inputs.portable-text.invalid-value.disallowed-child-type.description",
             action: "inputs.portable-text.invalid-value.disallowed-child-type.action",
-            values: { key: blk._key, childKey: child._key, childType: child._type }
+            values: {
+              key: blk._key,
+              childKey: child._key,
+              childType: child._type
+            }
           }
         }, !0) : (resolution = {
-          patches: [patches.unset([{ _key: blk._key }, "children", { _key: child._key }])],
+          patches: [
+            patches.unset([{ _key: blk._key }, "children", { _key: child._key }])
+          ],
           description: `Child with _key '${child._key}' in block with key '${blk._key}' is missing '_type' property.`,
           action: "Remove the object",
           item: blk,
@@ -3522,11 +4104,13 @@ function createWithInsertData(change$, schemaTypes, keyGenerator) {
         const [voidNode] = endVoid, r = domRange.cloneRange(), domNode = slateReact.ReactEditor.toDOMNode(editor, voidNode);
         r.setEndAfter(domNode), contents = r.cloneContents();
       }
-      Array.from(contents.querySelectorAll("[data-slate-zero-width]")).forEach((zw) => {
-        const isNewline = zw.getAttribute("data-slate-zero-width") === "n";
-        zw.textContent = isNewline ? `
+      Array.from(contents.querySelectorAll("[data-slate-zero-width]")).forEach(
+        (zw) => {
+          const isNewline = zw.getAttribute("data-slate-zero-width") === "n";
+          zw.textContent = isNewline ? `
 ` : "";
-      }), Array.from(contents.querySelectorAll("*")).forEach((elm) => {
+        }
+      ), Array.from(contents.querySelectorAll("*")).forEach((elm) => {
         elm.removeAttribute("contentEditable"), elm.removeAttribute("data-slate-inline"), elm.removeAttribute("data-slate-leaf"), elm.removeAttribute("data-slate-node"), elm.removeAttribute("data-slate-spacer"), elm.removeAttribute("data-slate-string"), elm.removeAttribute("data-slate-zero-width"), elm.removeAttribute("draggable");
         for (const key in elm.attributes)
           elm.hasAttribute(key) && elm.removeAttribute(key);
@@ -3536,7 +4120,10 @@ function createWithInsertData(change$, schemaTypes, keyGenerator) {
       const asHTML = div.innerHTML;
       contents.ownerDocument.body.removeChild(div);
       const fragment = editor.getFragment(), portableText = fromSlateValue(fragment, blockTypeName), asJSON = JSON.stringify(portableText), asPlainText = toPlainText(portableText);
-      data.clearData(), data.setData("text/plain", asPlainText), data.setData("text/html", asHTML), data.setData("application/json", asJSON), data.setData("application/x-portable-text", asJSON), debug$7("text", asPlainText), data.setData("application/x-portable-text-event-origin", originEvent || "external"), debug$7("Set fragment data", asJSON, asHTML);
+      data.clearData(), data.setData("text/plain", asPlainText), data.setData("text/html", asHTML), data.setData("application/json", asJSON), data.setData("application/x-portable-text", asJSON), debug$7("text", asPlainText), data.setData(
+        "application/x-portable-text-event-origin",
+        originEvent || "external"
+      ), debug$7("Set fragment data", asJSON, asHTML);
     }, editor.insertPortableTextData = (data) => {
       if (!editor.selection)
         return !1;
@@ -3576,7 +4163,9 @@ function createWithInsertData(change$, schemaTypes, keyGenerator) {
         if (html) {
           if (portableText = blockTools.htmlToBlocks(html, schemaTypes.portableText, {
             unstable_whitespaceOnPasteMode: whitespaceOnPasteMode
-          }).map((block) => blockTools.normalizeBlock(block, { blockTypeName })), fragment = toSlateValue(portableText, { schemaTypes }), insertedType = "HTML", portableText.length === 0)
+          }).map(
+            (block) => blockTools.normalizeBlock(block, { blockTypeName })
+          ), fragment = toSlateValue(portableText, { schemaTypes }), insertedType = "HTML", portableText.length === 0)
             return !1;
         } else {
           const textToHtml = `<html><body>${escapeHtml(text).split(/\n{2,}/).map(
@@ -3588,7 +4177,11 @@ function createWithInsertData(change$, schemaTypes, keyGenerator) {
             schemaTypes
           }), insertedType = "text";
         }
-        const validation = validateValue(portableText, schemaTypes, keyGenerator);
+        const validation = validateValue(
+          portableText,
+          schemaTypes,
+          keyGenerator
+        );
         if (!validation.valid) {
           const errorDescription = `Could not validate the resulting portable text to insert.
 ${validation.resolution?.description}
@@ -3601,7 +4194,9 @@ Try to insert as plain text (shift-paste) instead.`;
             data: validation
           }), debug$7("Invalid insert result", validation), !1;
         }
-        return debug$7(`Inserting ${insertedType} fragment at ${JSON.stringify(editor.selection)}`), _insertFragment(editor, fragment, schemaTypes), change$.next({ type: "loading", isLoading: !1 }), !0;
+        return debug$7(
+          `Inserting ${insertedType} fragment at ${JSON.stringify(editor.selection)}`
+        ), _insertFragment(editor, fragment, schemaTypes), change$.next({ type: "loading", isLoading: !1 }), !0;
       }
       return change$.next({ type: "loading", isLoading: !1 }), !1;
     }, editor.insertData = (data) => {
@@ -3666,18 +4261,30 @@ function _insertFragment(editor, fragment, schemaTypes) {
   editor.withoutNormalizing(() => {
     if (!editor.selection)
       return;
-    const [focusBlock, focusPath] = slate.Editor.node(editor, editor.selection, { depth: 1 });
+    const [focusBlock, focusPath] = slate.Editor.node(editor, editor.selection, {
+      depth: 1
+    });
     if (editor.isTextBlock(focusBlock) && editor.isTextBlock(fragment[0])) {
       const { markDefs } = focusBlock;
-      debug$7("Mixing markDefs of focusBlock and fragments[0] block", markDefs, fragment[0].markDefs), isEqual__default.default(markDefs, fragment[0].markDefs) || slate.Transforms.setNodes(
+      debug$7(
+        "Mixing markDefs of focusBlock and fragments[0] block",
+        markDefs,
+        fragment[0].markDefs
+      ), isEqual__default.default(markDefs, fragment[0].markDefs) || slate.Transforms.setNodes(
         editor,
         {
-          markDefs: uniq__default.default([...fragment[0].markDefs || [], ...markDefs || []])
+          markDefs: uniq__default.default([
+            ...fragment[0].markDefs || [],
+            ...markDefs || []
+          ])
         },
         { at: focusPath, mode: "lowest", voids: !1 }
       );
     }
-    isEqualToEmptyEditor(editor.children, schemaTypes) ? (slate.Transforms.splitNodes(editor, { at: [0, 0] }), editor.insertFragment(fragment), slate.Transforms.removeNodes(editor, { at: [0] })) : editor.insertFragment(fragment);
+    isEqualToEmptyEditor(
+      editor.children,
+      schemaTypes
+    ) ? (slate.Transforms.splitNodes(editor, { at: [0, 0] }), editor.insertFragment(fragment), slate.Transforms.removeNodes(editor, { at: [0] })) : editor.insertFragment(fragment);
   }), editor.onChange();
 }
 const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, options) => {
@@ -3687,7 +4294,11 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
     onChange: e.onChange,
     normalizeNode: e.normalizeNode
   });
-  const operationToPatches = createOperationToPatches(schemaTypes), withObjectKeys = createWithObjectKeys(schemaTypes, keyGenerator), withSchemaTypes = createWithSchemaTypes({ schemaTypes, keyGenerator }), withEditableAPI = createWithEditableAPI(portableTextEditor, schemaTypes, keyGenerator), withPatches = createWithPatches({
+  const operationToPatches = createOperationToPatches(schemaTypes), withObjectKeys = createWithObjectKeys(schemaTypes, keyGenerator), withSchemaTypes = createWithSchemaTypes({ schemaTypes, keyGenerator }), withEditableAPI = createWithEditableAPI(
+    portableTextEditor,
+    schemaTypes,
+    keyGenerator
+  ), withPatches = createWithPatches({
     change$,
     keyGenerator,
     patches$,
@@ -3702,7 +4313,14 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
     schemaTypes,
     change$,
     keyGenerator
-  ), withPortableTextBlockStyle = createWithPortableTextBlockStyle(schemaTypes), withPlaceholderBlock = createWithPlaceholderBlock(), withInsertBreak = createWithInsertBreak(schemaTypes), withUtils = createWithUtils({ keyGenerator, schemaTypes, portableTextEditor }), withPortableTextSelections = createWithPortableTextSelections(change$, schemaTypes);
+  ), withPortableTextBlockStyle = createWithPortableTextBlockStyle(schemaTypes), withPlaceholderBlock = createWithPlaceholderBlock(), withInsertBreak = createWithInsertBreak(schemaTypes, keyGenerator), withUtils = createWithUtils({
+    keyGenerator,
+    schemaTypes,
+    portableTextEditor
+  }), withPortableTextSelections = createWithPortableTextSelections(
+    change$,
+    schemaTypes
+  );
   return e.destroy = () => {
     const originalFunctions = originalFnMap.get(e);
     if (!originalFunctions)
@@ -3716,7 +4334,9 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
             withUtils(
               withPlaceholderBlock(
                 withPortableTextLists(
-                  withPortableTextSelections(withEditableAPI(withInsertBreak(e)))
+                  withPortableTextSelections(
+                    withEditableAPI(withInsertBreak(e))
+                  )
                 )
               )
             )
@@ -3735,7 +4355,11 @@ const originalFnMap = /* @__PURE__ */ new WeakMap(), withPlugins = (editor, opti
                 withUtils(
                   withMaxBlocks(
                     withUndoRedo(
-                      withPatches(withPortableTextSelections(withEditableAPI(withInsertBreak(e))))
+                      withPatches(
+                        withPortableTextSelections(
+                          withEditableAPI(withInsertBreak(e))
+                        )
+                      )
                     )
                   )
                 )
@@ -3782,8 +4406,15 @@ function SlateContainer(props) {
       portableTextEditor,
       readOnly
     });
-  }, [keyGenerator, portableTextEditor, maxBlocks, readOnly, patches$, slateEditor]);
-  const initialValue = react.useMemo(() => [slateEditor.pteCreateEmptyBlock()], [slateEditor]);
+  }, [
+    keyGenerator,
+    portableTextEditor,
+    maxBlocks,
+    readOnly,
+    patches$,
+    slateEditor
+  ]);
+  const initialValue = react.useMemo(() => [slateEditor.pteCreateTextBlock({ decorators: [] })], [slateEditor]);
   return react.useEffect(() => () => {
     debug$6("Destroying Slate editor"), slateEditor.destroy();
   }, [slateEditor]), /* @__PURE__ */ jsxRuntime.jsx(slateReact.Slate, { editor: slateEditor, initialValue, children: props.children });
@@ -3840,7 +4471,11 @@ function useSyncValue(props) {
               slate.Transforms.removeNodes(slateEditor, {
                 at: [childrenLength - 1 - index]
               });
-            }), slate.Transforms.insertNodes(slateEditor, slateEditor.pteCreateEmptyBlock(), { at: [0] }), hadSelection && slate.Transforms.select(slateEditor, [0, 0]);
+            }), slate.Transforms.insertNodes(
+              slateEditor,
+              slateEditor.pteCreateTextBlock({ decorators: [] }),
+              { at: [0] }
+            ), hadSelection && slate.Transforms.select(slateEditor, [0, 0]);
           });
         });
       }), isChanged = !0), value && value.length > 0) {
@@ -3859,34 +4494,53 @@ function useSyncValue(props) {
                     });
                   isChanged = !0;
                 }
-                slateValueFromProps.forEach((currentBlock, currentBlockIndex) => {
-                  const oldBlock = slateEditor.children[currentBlockIndex];
-                  if (oldBlock && !isEqual__default.default(currentBlock, oldBlock) && isValid) {
-                    const validationValue = [value[currentBlockIndex]], validation = validateValue(validationValue, schemaTypes, keyGenerator);
-                    !validation.valid && validation.resolution?.autoResolve && validation.resolution?.patches.length > 0 && !readOnly && previousValue.current && previousValue.current !== value && (console.warn(
-                      `${validation.resolution.action} for block with _key '${validationValue[0]._key}'. ${validation.resolution?.description}`
-                    ), validation.resolution.patches.forEach((patch) => {
-                      change$.next({ type: "patch", patch });
-                    })), validation.valid || validation.resolution?.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$5.enabled && debug$5("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$5.enabled && debug$5("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), isChanged = !0) : (change$.next({
-                      type: "invalidValue",
-                      resolution: validation.resolution,
-                      value
-                    }), isValid = !1);
-                  }
-                  if (!oldBlock && isValid) {
-                    const validationValue = [value[currentBlockIndex]], validation = validateValue(validationValue, schemaTypes, keyGenerator);
-                    debug$5.enabled && debug$5(
-                      "Validating and inserting new block in the end of the value",
-                      currentBlock
-                    ), validation.valid || validation.resolution?.autoResolve ? slate.Transforms.insertNodes(slateEditor, currentBlock, {
-                      at: [currentBlockIndex]
-                    }) : (debug$5("Invalid", validation), change$.next({
-                      type: "invalidValue",
-                      resolution: validation.resolution,
-                      value
-                    }), isValid = !1);
+                slateValueFromProps.forEach(
+                  (currentBlock, currentBlockIndex) => {
+                    const oldBlock = slateEditor.children[currentBlockIndex];
+                    if (oldBlock && !isEqual__default.default(currentBlock, oldBlock) && isValid) {
+                      const validationValue = [value[currentBlockIndex]], validation = validateValue(
+                        validationValue,
+                        schemaTypes,
+                        keyGenerator
+                      );
+                      !validation.valid && validation.resolution?.autoResolve && validation.resolution?.patches.length > 0 && !readOnly && previousValue.current && previousValue.current !== value && (console.warn(
+                        `${validation.resolution.action} for block with _key '${validationValue[0]._key}'. ${validation.resolution?.description}`
+                      ), validation.resolution.patches.forEach((patch) => {
+                        change$.next({ type: "patch", patch });
+                      })), validation.valid || validation.resolution?.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$5.enabled && debug$5("Updating block", oldBlock, currentBlock), _updateBlock(
+                        slateEditor,
+                        currentBlock,
+                        oldBlock,
+                        currentBlockIndex
+                      )) : (debug$5.enabled && debug$5("Replacing block", oldBlock, currentBlock), _replaceBlock(
+                        slateEditor,
+                        currentBlock,
+                        currentBlockIndex
+                      )), isChanged = !0) : (change$.next({
+                        type: "invalidValue",
+                        resolution: validation.resolution,
+                        value
+                      }), isValid = !1);
+                    }
+                    if (!oldBlock && isValid) {
+                      const validationValue = [value[currentBlockIndex]], validation = validateValue(
+                        validationValue,
+                        schemaTypes,
+                        keyGenerator
+                      );
+                      debug$5.enabled && debug$5(
+                        "Validating and inserting new block in the end of the value",
+                        currentBlock
+                      ), validation.valid || validation.resolution?.autoResolve ? slate.Transforms.insertNodes(slateEditor, currentBlock, {
+                        at: [currentBlockIndex]
+                      }) : (debug$5("Invalid", validation), change$.next({
+                        type: "invalidValue",
+                        resolution: validation.resolution,
+                        value
+                      }), isValid = !1);
+                    }
                   }
-                });
+                );
               });
             });
           });
@@ -3936,41 +4590,53 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
     at: [currentBlockIndex]
   }), slateEditor.isTextBlock(currentBlock) && slateEditor.isTextBlock(oldBlock)) {
     const oldBlockChildrenLength = oldBlock.children.length;
-    currentBlock.children.length < oldBlockChildrenLength && Array.from(Array(oldBlockChildrenLength - currentBlock.children.length)).forEach(
-      (_, index) => {
-        const childIndex = oldBlockChildrenLength - 1 - index;
-        childIndex > 0 && (debug$5("Removing child"), slate.Transforms.removeNodes(slateEditor, {
-          at: [currentBlockIndex, childIndex]
-        }));
+    currentBlock.children.length < oldBlockChildrenLength && Array.from(
+      Array(oldBlockChildrenLength - currentBlock.children.length)
+    ).forEach((_, index) => {
+      const childIndex = oldBlockChildrenLength - 1 - index;
+      childIndex > 0 && (debug$5("Removing child"), slate.Transforms.removeNodes(slateEditor, {
+        at: [currentBlockIndex, childIndex]
+      }));
+    }), currentBlock.children.forEach(
+      (currentBlockChild, currentBlockChildIndex) => {
+        const oldBlockChild = oldBlock.children[currentBlockChildIndex], isChildChanged = !isEqual__default.default(currentBlockChild, oldBlockChild), isTextChanged = !isEqual__default.default(
+          currentBlockChild.text,
+          oldBlockChild?.text
+        ), path = [currentBlockIndex, currentBlockChildIndex];
+        if (isChildChanged)
+          if (currentBlockChild._key === oldBlockChild?._key) {
+            debug$5("Updating changed child", currentBlockChild, oldBlockChild), slate.Transforms.setNodes(
+              slateEditor,
+              currentBlockChild,
+              {
+                at: path
+              }
+            );
+            const isSpanNode = slate.Text.isText(currentBlockChild) && currentBlockChild._type === "span" && slate.Text.isText(oldBlockChild) && oldBlockChild._type === "span";
+            isSpanNode && isTextChanged ? (slate.Transforms.delete(slateEditor, {
+              at: {
+                focus: { path, offset: 0 },
+                anchor: { path, offset: oldBlockChild.text.length }
+              }
+            }), slate.Transforms.insertText(slateEditor, currentBlockChild.text, {
+              at: path
+            }), slateEditor.onChange()) : isSpanNode || (debug$5("Updating changed inline object child", currentBlockChild), slate.Transforms.setNodes(
+              slateEditor,
+              { _key: VOID_CHILD_KEY },
+              {
+                at: [...path, 0],
+                voids: !0
+              }
+            ));
+          } else oldBlockChild ? (debug$5("Replacing child", currentBlockChild), slate.Transforms.removeNodes(slateEditor, {
+            at: [currentBlockIndex, currentBlockChildIndex]
+          }), slate.Transforms.insertNodes(slateEditor, currentBlockChild, {
+            at: [currentBlockIndex, currentBlockChildIndex]
+          }), slateEditor.onChange()) : oldBlockChild || (debug$5("Inserting new child", currentBlockChild), slate.Transforms.insertNodes(slateEditor, currentBlockChild, {
+            at: [currentBlockIndex, currentBlockChildIndex]
+          }), slateEditor.onChange());
       }
-    ), currentBlock.children.forEach((currentBlockChild, currentBlockChildIndex) => {
-      const oldBlockChild = oldBlock.children[currentBlockChildIndex], isChildChanged = !isEqual__default.default(currentBlockChild, oldBlockChild), isTextChanged = !isEqual__default.default(currentBlockChild.text, oldBlockChild?.text), path = [currentBlockIndex, currentBlockChildIndex];
-      if (isChildChanged)
-        if (currentBlockChild._key === oldBlockChild?._key) {
-          debug$5("Updating changed child", currentBlockChild, oldBlockChild), slate.Transforms.setNodes(slateEditor, currentBlockChild, {
-            at: path
-          });
-          const isSpanNode = slate.Text.isText(currentBlockChild) && currentBlockChild._type === "span" && slate.Text.isText(oldBlockChild) && oldBlockChild._type === "span";
-          isSpanNode && isTextChanged ? (slate.Transforms.delete(slateEditor, {
-            at: { focus: { path, offset: 0 }, anchor: { path, offset: oldBlockChild.text.length } }
-          }), slate.Transforms.insertText(slateEditor, currentBlockChild.text, {
-            at: path
-          }), slateEditor.onChange()) : isSpanNode || (debug$5("Updating changed inline object child", currentBlockChild), slate.Transforms.setNodes(
-            slateEditor,
-            { _key: VOID_CHILD_KEY },
-            {
-              at: [...path, 0],
-              voids: !0
-            }
-          ));
-        } else oldBlockChild ? (debug$5("Replacing child", currentBlockChild), slate.Transforms.removeNodes(slateEditor, {
-          at: [currentBlockIndex, currentBlockChildIndex]
-        }), slate.Transforms.insertNodes(slateEditor, currentBlockChild, {
-          at: [currentBlockIndex, currentBlockChildIndex]
-        }), slateEditor.onChange()) : oldBlockChild || (debug$5("Inserting new child", currentBlockChild), slate.Transforms.insertNodes(slateEditor, currentBlockChild, {
-          at: [currentBlockIndex, currentBlockChildIndex]
-        }), slateEditor.onChange());
-    });
+    );
   }
 }
 const debug$4 = debugWithName("component:PortableTextEditor:Synchronizer"), debugVerbose$1 = debug$4.enabled && !1, FLUSH_PATCHES_THROTTLED_MS = process.env.NODE_ENV === "test" ? 500 : 1e3;
@@ -3989,7 +4655,11 @@ function Synchronizer(props) {
       debug$4("Flushing pending patches"), debugVerbose$1 && debug$4(`Patches:
 ${JSON.stringify(pendingPatches.current, null, 2)}`);
       const snapshot = getValue();
-      change$.next({ type: "mutation", patches: pendingPatches.current, snapshot }), pendingPatches.current = [];
+      change$.next({
+        type: "mutation",
+        patches: pendingPatches.current,
+        snapshot
+      }), pendingPatches.current = [];
     }
     IS_PROCESSING_LOCAL_CHANGES.set(slateEditor, !1);
   }, [slateEditor, getValue, change$]), onFlushPendingPatchesThrottled = react.useMemo(() => throttle__default.default(
@@ -4075,7 +4745,9 @@ class PortableTextEditor extends react.Component {
   constructor(props) {
     if (super(props), !props.schemaType)
       throw new Error('PortableTextEditor: missing "schemaType" property');
-    props.incomingPatches$ && console.warn("The prop 'incomingPatches$' is deprecated and renamed to 'patches$'"), this.change$.next({ type: "loading", isLoading: !0 }), this.schemaTypes = getPortableTextMemberSchemaTypes(
+    props.incomingPatches$ && console.warn(
+      "The prop 'incomingPatches$' is deprecated and renamed to 'patches$'"
+    ), this.change$.next({ type: "loading", isLoading: !0 }), this.schemaTypes = getPortableTextMemberSchemaTypes(
       props.schemaType.hasOwnProperty("jsonType") ? props.schemaType : compileType(props.schemaType)
     );
   }
@@ -4167,14 +4839,26 @@ class PortableTextEditor extends react.Component {
   static isSelectionsOverlapping = (editor, selectionA, selectionB) => editor.editable?.isSelectionsOverlapping(selectionA, selectionB);
 }
 const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (props) => {
-  const { attributes, children, leaf, schemaTypes, renderChild, renderDecorator, renderAnnotation } = props, spanRef = react.useRef(null), portableTextEditor = usePortableTextEditor(), blockSelected = slateReact.useSelected(), [focused, setFocused] = react.useState(!1), [selected, setSelected] = react.useState(!1), block = children.props.parent, path = react.useMemo(
+  const {
+    attributes,
+    children,
+    leaf,
+    schemaTypes,
+    renderChild,
+    renderDecorator,
+    renderAnnotation
+  } = props, spanRef = react.useRef(null), portableTextEditor = usePortableTextEditor(), blockSelected = slateReact.useSelected(), [focused, setFocused] = react.useState(!1), [selected, setSelected] = react.useState(!1), block = children.props.parent, path = react.useMemo(
     () => block ? [{ _key: block?._key }, "children", { _key: leaf._key }] : [],
     [block, leaf._key]
   ), decoratorValues = react.useMemo(
     () => schemaTypes.decorators.map((dec) => dec.value),
     [schemaTypes.decorators]
   ), marks = react.useMemo(
-    () => uniq__default.default((leaf.marks || EMPTY_MARKS).filter((mark) => decoratorValues.includes(mark))),
+    () => uniq__default.default(
+      (leaf.marks || EMPTY_MARKS).filter(
+        (mark) => decoratorValues.includes(mark)
+      )
+    ),
     [decoratorValues, leaf.marks]
   ), annotationMarks = Array.isArray(leaf.marks) ? leaf.marks : EMPTY_MARKS, annotations = react.useMemo(
     () => annotationMarks.map(
@@ -4225,11 +4909,18 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     return () => {
       sub.unsubscribe();
     };
-  }, [path, portableTextEditor, setSelectedFromRange, shouldTrackSelectionAndFocus]), react.useEffect(() => setSelectedFromRange(), [setSelectedFromRange]);
+  }, [
+    path,
+    portableTextEditor,
+    setSelectedFromRange,
+    shouldTrackSelectionAndFocus
+  ]), react.useEffect(() => setSelectedFromRange(), [setSelectedFromRange]);
   const content2 = react.useMemo(() => {
     let returnedChildren = children;
     if (slate.Text.isText(leaf) && leaf._type === schemaTypes.span.name && (marks.forEach((mark) => {
-      const schemaType = schemaTypes.decorators.find((dec) => dec.value === mark);
+      const schemaType = schemaTypes.decorators.find(
+        (dec) => dec.value === mark
+      );
       if (schemaType && renderDecorator) {
         const _props = Object.defineProperty(
           {
@@ -4245,14 +4936,20 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
           {
             enumerable: !1,
             get() {
-              return console.warn("Property 'type' is deprecated, use 'schemaType' instead."), schemaType;
+              return console.warn(
+                "Property 'type' is deprecated, use 'schemaType' instead."
+              ), schemaType;
             }
           }
         );
-        returnedChildren = renderDecorator(_props);
+        returnedChildren = renderDecorator(
+          _props
+        );
       }
     }), block && annotations.length > 0 && annotations.forEach((annotation) => {
-      const schemaType = schemaTypes.annotations.find((t) => t.name === annotation._type);
+      const schemaType = schemaTypes.annotations.find(
+        (t) => t.name === annotation._type
+      );
       if (schemaType)
         if (renderAnnotation) {
           const _props = Object.defineProperty(
@@ -4270,7 +4967,9 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
             {
               enumerable: !1,
               get() {
-                return console.warn("Property 'type' is deprecated, use 'schemaType' instead."), schemaType;
+                return console.warn(
+                  "Property 'type' is deprecated, use 'schemaType' instead."
+                ), schemaType;
               }
             }
           );
@@ -4295,7 +4994,9 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
           {
             enumerable: !1,
             get() {
-              return console.warn("Property 'type' is deprecated, use 'schemaType' instead."), schemaTypes.span;
+              return console.warn(
+                "Property 'type' is deprecated, use 'schemaType' instead."
+              ), schemaTypes.span;
             }
           }
         );
@@ -4350,8 +5051,13 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     scrollSelectionIntoView,
     spellCheck,
     ...restProps
-  } = props, portableTextEditor = usePortableTextEditor(), readOnly = usePortableTextEditorReadOnlyStatus(), keyGenerator = usePortableTextEditorKeyGenerator(), ref = react.useRef(null), [editableElement, setEditableElement] = react.useState(null), [hasInvalidValue, setHasInvalidValue] = react.useState(!1), [rangeDecorationState, setRangeDecorationsState] = react.useState([]);
-  react.useImperativeHandle(forwardedRef, () => ref.current);
+  } = props, portableTextEditor = usePortableTextEditor(), readOnly = usePortableTextEditorReadOnlyStatus(), keyGenerator = usePortableTextEditorKeyGenerator(), ref = react.useRef(null), [editableElement, setEditableElement] = react.useState(
+    null
+  ), [hasInvalidValue, setHasInvalidValue] = react.useState(!1), [rangeDecorationState, setRangeDecorationsState] = react.useState([]);
+  react.useImperativeHandle(
+    forwardedRef,
+    () => ref.current
+  );
   const rangeDecorationsRef = react.useRef(rangeDecorations), { change$, schemaTypes } = portableTextEditor, slateEditor = slateReact.useSlate(), blockTypeName = schemaTypes.block.name, withInsertData = react.useMemo(
     () => createWithInsertData(change$, schemaTypes, keyGenerator),
     [change$, keyGenerator, schemaTypes]
@@ -4374,7 +5080,15 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
         spellCheck
       }
     ),
-    [schemaTypes, spellCheck, readOnly, renderBlock, renderChild, renderListItem, renderStyle]
+    [
+      schemaTypes,
+      spellCheck,
+      readOnly,
+      renderBlock,
+      renderChild,
+      renderListItem,
+      renderStyle
+    ]
   ), renderLeaf = react.useCallback(
     (lProps) => {
       if (lProps.leaf._type === "span") {
@@ -4399,7 +5113,14 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
       }
       return lProps.children;
     },
-    [readOnly, renderAnnotation, renderChild, renderDecorator, renderPlaceholder, schemaTypes]
+    [
+      readOnly,
+      renderAnnotation,
+      renderChild,
+      renderDecorator,
+      renderPlaceholder,
+      schemaTypes
+    ]
   ), restoreSelectionFromProps = react.useCallback(() => {
     if (propsSelection) {
       debug(`Selection from props ${JSON.stringify(propsSelection)}`);
@@ -4408,7 +5129,9 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
         fromSlateValue(slateEditor.children, blockTypeName)
       );
       if (normalizedSelection !== null) {
-        debug(`Normalized selection from props ${JSON.stringify(normalizedSelection)}`);
+        debug(
+          `Normalized selection from props ${JSON.stringify(normalizedSelection)}`
+        );
         const slateRange = toSlateRange(normalizedSelection, slateEditor);
         slateRange && (slate.Transforms.select(slateEditor, slateRange), slateEditor.operations.some((o) => o.type === "set_selection") || change$.next({ type: "selection", selection: normalizedSelection }), slateEditor.onChange());
       }
@@ -4418,7 +5141,10 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
       if (rangeDecorations && rangeDecorations.length > 0) {
         const newSlateRanges = [];
         if (rangeDecorations.forEach((rangeDecorationItem) => {
-          const slateRange = toSlateRange(rangeDecorationItem.selection, slateEditor);
+          const slateRange = toSlateRange(
+            rangeDecorationItem.selection,
+            slateEditor
+          );
           if (!slate.Range.isRange(slateRange)) {
             rangeDecorationItem.onMoved && rangeDecorationItem.onMoved({
               newSelection: null,
@@ -4429,14 +5155,21 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
           }
           let newRange;
           if (operation && (newRange = moveRangeByOperation(slateRange, operation), newRange && newRange !== slateRange || newRange === null && slateRange)) {
-            const value = PortableTextEditor.getValue(portableTextEditor), newRangeSelection = toPortableTextRange(value, newRange, schemaTypes);
+            const value = PortableTextEditor.getValue(portableTextEditor), newRangeSelection = toPortableTextRange(
+              value,
+              newRange,
+              schemaTypes
+            );
             rangeDecorationItem.onMoved && rangeDecorationItem.onMoved({
               newSelection: newRangeSelection,
               rangeDecoration: rangeDecorationItem,
               origin: "local"
             });
           }
-          newRange !== null && newSlateRanges.push({ ...newRange || slateRange, rangeDecoration: rangeDecorationItem });
+          newRange !== null && newSlateRanges.push({
+            ...newRange || slateRange,
+            rangeDecoration: rangeDecorationItem
+          });
         }), newSlateRanges.length > 0) {
           setRangeDecorationsState(newSlateRanges);
           return;
@@ -4489,11 +5222,20 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
         debug("Pasting normally"), slateEditor.insertData(event.clipboardData);
         return;
       }
-      const value = PortableTextEditor.getValue(portableTextEditor), path = toPortableTextRange(value, slateEditor.selection, schemaTypes)?.focus.path || [], onPasteResult = onPaste({ event, value, path, schemaTypes });
+      const value = PortableTextEditor.getValue(portableTextEditor), path = toPortableTextRange(
+        value,
+        slateEditor.selection,
+        schemaTypes
+      )?.focus.path || [], onPasteResult = onPaste({ event, value, path, schemaTypes });
       onPasteResult === void 0 ? (debug("No result from custom paste handler, pasting normally"), slateEditor.insertData(event.clipboardData)) : (change$.next({ type: "loading", isLoading: !0 }), Promise.resolve(onPasteResult).then((result) => {
         debug("Custom paste function from client resolved", result), !result || !result.insert ? (debug("No result from custom paste handler, pasting normally"), slateEditor.insertData(event.clipboardData)) : result.insert ? slateEditor.insertFragment(
-          toSlateValue(result.insert, { schemaTypes })
-        ) : console.warn("Your onPaste function returned something unexpected:", result);
+          toSlateValue(result.insert, {
+            schemaTypes
+          })
+        ) : console.warn(
+          "Your onPaste function returned something unexpected:",
+          result
+        );
       }).catch((error) => (console.error(error), error)).finally(() => {
         change$.next({ type: "loading", isLoading: !1 });
       }));
@@ -4518,7 +5260,10 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
         const [lastBlock, path] = slate.Node.last(slateEditor, []), focusPath = slateEditor.selection.focus.path.slice(0, 1), lastPath = path.slice(0, 1);
         if (slate.Path.equals(focusPath, lastPath)) {
           const node = slate.Node.descendant(slateEditor, path.slice(0, 1));
-          lastBlock && slate.Editor.isVoid(slateEditor, node) && (slate.Transforms.insertNodes(slateEditor, slateEditor.pteCreateEmptyBlock()), slateEditor.onChange());
+          lastBlock && slate.Editor.isVoid(slateEditor, node) && (slate.Transforms.insertNodes(
+            slateEditor,
+            slateEditor.pteCreateTextBlock({ decorators: [] })
+          ), slateEditor.onChange());
         }
       }
     },
@@ -4544,7 +5289,10 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
       return;
     const existingDOMRange = domSelection.getRangeAt(0);
     try {
-      const newDOMRange = slateReact.ReactEditor.toDOMRange(slateEditor, slateEditor.selection);
+      const newDOMRange = slateReact.ReactEditor.toDOMRange(
+        slateEditor,
+        slateEditor.selection
+      );
       (newDOMRange.startOffset !== existingDOMRange.startOffset || newDOMRange.endOffset !== existingDOMRange.endOffset) && (debug("DOM range out of sync, validating selection"), domSelection?.removeAllRanges(), domSelection.addRange(newDOMRange));
     } catch {
       debug("Could not resolve selection, selecting top document"), slate.Transforms.deselect(slateEditor), slateEditor.children.length > 0 && slate.Transforms.select(slateEditor, [0, 0]), slateEditor.onChange();
@@ -4592,13 +5340,19 @@ const debug$1 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
         ];
       if (path.length === 0)
         return [];
-      const result = rangeDecorationState.filter((item) => slate.Range.isCollapsed(item) ? path.length !== 2 ? !1 : slate.Path.equals(item.focus.path, path) && slate.Path.equals(item.anchor.path, path) : slate.Range.intersection(item, { anchor: { path, offset: 0 }, focus: { path, offset: 0 } }) || slate.Range.includes(item, path));
+      const result = rangeDecorationState.filter((item) => slate.Range.isCollapsed(item) ? path.length !== 2 ? !1 : slate.Path.equals(item.focus.path, path) && slate.Path.equals(item.anchor.path, path) : slate.Range.intersection(item, {
+        anchor: { path, offset: 0 },
+        focus: { path, offset: 0 }
+      }) || slate.Range.includes(item, path));
       return result.length > 0 ? result : [];
     },
     [slateEditor, schemaTypes, rangeDecorationState]
   );
   return react.useEffect(() => {
-    ref.current = slateReact.ReactEditor.toDOMNode(slateEditor, slateEditor), setEditableElement(ref.current);
+    ref.current = slateReact.ReactEditor.toDOMNode(
+      slateEditor,
+      slateEditor
+    ), setEditableElement(ref.current);
   }, [slateEditor, ref]), portableTextEditor ? hasInvalidValue ? null : /* @__PURE__ */ jsxRuntime.jsx(
     slateReact.Editable,
     {