@portabletext/editor 1.15.0 → 1.15.2

package/lib/index.js

@@ -1,6 +1,16 @@
-import { getFirstBlock, getSelectedBlocks, getLastBlock, getFocusBlockObject, getNextBlock, getPreviousBlock, selectionIsCollapsed, getFocusTextBlock, getFocusSpan, getFocusListBlock, createGuards, getBlockTextBefore, getFocusBlock } from "./_chunks-es/selector.get-text-before.js";
-import { isPortableTextTextBlock, isPortableTextSpan as isPortableTextSpan$1, defineType, defineField, isKeySegment, isPortableTextListBlock } from "@sanity/types";
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty, __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp.call(b, prop) && __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b))
+      __propIsEnum.call(b, prop) && __defNormalProp(a, prop, b[prop]);
+  return a;
+};
 import { Schema } from "@sanity/schema";
+import { defineType, defineField, isKeySegment, isPortableTextTextBlock, isPortableTextSpan as isPortableTextSpan$1, isPortableTextListBlock } from "@sanity/types";
 import startCase from "lodash.startcase";
 import { jsx, Fragment, jsxs } from "react/jsx-runtime";
 import { useSelector, useActorRef } from "@xstate/react";
@@ -24,943 +34,18 @@ import { setup, assign, assertEvent, emit, enqueueActions, createActor } from "x
 import get from "lodash/get.js";
 import isUndefined from "lodash/isUndefined.js";
 import omitBy from "lodash/omitBy.js";
+import { createGuards } from "./_chunks-es/selectors.js";
+import { blockOffsetToSpanSelectionPoint, coreBehaviors, isHotkey } from "./_chunks-es/behavior.core.js";
 import getRandomValues from "get-random-values-esm";
 import { htmlToBlocks, normalizeBlock } from "@sanity/block-tools";
-const IS_MAC = typeof window < "u" && /Mac|iPod|iPhone|iPad/.test(window.navigator.userAgent), modifiers = {
-  alt: "altKey",
-  control: "ctrlKey",
-  meta: "metaKey",
-  shift: "shiftKey"
-}, aliases = {
-  add: "+",
-  break: "pause",
-  cmd: "meta",
-  command: "meta",
-  ctl: "control",
-  ctrl: "control",
-  del: "delete",
-  down: "arrowdown",
-  esc: "escape",
-  ins: "insert",
-  left: "arrowleft",
-  mod: IS_MAC ? "meta" : "control",
-  opt: "alt",
-  option: "alt",
-  return: "enter",
-  right: "arrowright",
-  space: " ",
-  spacebar: " ",
-  up: "arrowup",
-  win: "meta",
-  windows: "meta"
-}, keyCodes = {
-  backspace: 8,
-  tab: 9,
-  enter: 13,
-  shift: 16,
-  control: 17,
-  alt: 18,
-  pause: 19,
-  capslock: 20,
-  escape: 27,
-  " ": 32,
-  pageup: 33,
-  pagedown: 34,
-  end: 35,
-  home: 36,
-  arrowleft: 37,
-  arrowup: 38,
-  arrowright: 39,
-  arrowdown: 40,
-  insert: 45,
-  delete: 46,
-  meta: 91,
-  numlock: 144,
-  scrolllock: 145,
-  ";": 186,
-  "=": 187,
-  ",": 188,
-  "-": 189,
-  ".": 190,
-  "/": 191,
-  "`": 192,
-  "[": 219,
-  "\\": 220,
-  "]": 221,
-  "'": 222,
-  f1: 112,
-  f2: 113,
-  f3: 114,
-  f4: 115,
-  f5: 116,
-  f6: 117,
-  f7: 118,
-  f8: 119,
-  f9: 120,
-  f10: 121,
-  f11: 122,
-  f12: 123,
-  f13: 124,
-  f14: 125,
-  f15: 126,
-  f16: 127,
-  f17: 128,
-  f18: 129,
-  f19: 130,
-  f20: 131
-};
-function isHotkey(hotkey, event) {
-  return compareHotkey(parseHotkey(hotkey), event);
-}
-function parseHotkey(hotkey) {
-  const parsedHotkey = {
-    altKey: !1,
-    ctrlKey: !1,
-    metaKey: !1,
-    shiftKey: !1
-  }, hotkeySegments = hotkey.replace("++", "+add").split("+");
-  for (const rawHotkeySegment of hotkeySegments) {
-    const optional = rawHotkeySegment.endsWith("?") && rawHotkeySegment.length > 1, hotkeySegment = optional ? rawHotkeySegment.slice(0, -1) : rawHotkeySegment, keyName = toKeyName(hotkeySegment), modifier = modifiers[keyName], alias = aliases[hotkeySegment], code = keyCodes[keyName];
-    if (hotkeySegment.length > 1 && modifier === void 0 && alias === void 0 && code === void 0)
-      throw new TypeError(`Unknown modifier: "${hotkeySegment}"`);
-    (hotkeySegments.length === 1 || modifier === void 0) && (parsedHotkey.key = keyName, parsedHotkey.keyCode = toKeyCode(hotkeySegment)), modifier !== void 0 && (parsedHotkey[modifier] = optional ? null : !0);
-  }
-  return parsedHotkey;
-}
-function compareHotkey(parsedHotkey, event) {
-  return (parsedHotkey.altKey == null || parsedHotkey.altKey === event.altKey) && (parsedHotkey.ctrlKey == null || parsedHotkey.ctrlKey === event.ctrlKey) && (parsedHotkey.metaKey == null || parsedHotkey.metaKey === event.metaKey) && (parsedHotkey.shiftKey == null || parsedHotkey.shiftKey === event.shiftKey) ? parsedHotkey.keyCode !== void 0 && event.keyCode !== void 0 ? parsedHotkey.keyCode === 91 && event.keyCode === 93 ? !0 : parsedHotkey.keyCode === event.keyCode : parsedHotkey.keyCode === event.keyCode || parsedHotkey.key === event.key.toLowerCase() : !1;
-}
-function toKeyCode(name) {
-  const keyName = toKeyName(name);
-  return keyCodes[keyName] ?? keyName.toUpperCase().charCodeAt(0);
-}
-function toKeyName(name) {
-  const keyName = name.toLowerCase();
-  return aliases[keyName] ?? keyName;
-}
-function defineBehavior(behavior) {
-  return behavior;
-}
-function createCodeEditorBehaviors(config) {
-  return [{
-    on: "key.down",
-    guard: ({
-      context,
-      event
-    }) => {
-      const isMoveUpShortcut = isHotkey(config.moveBlockUpShortcut, event.keyboardEvent), firstBlock = getFirstBlock({
-        context
-      }), selectedBlocks = getSelectedBlocks({
-        context
-      }), blocksAbove = firstBlock?.node._key !== selectedBlocks[0]?.node._key;
-      return !isMoveUpShortcut || !blocksAbove ? !1 : {
-        paths: selectedBlocks.map((block) => block.path)
-      };
-    },
-    actions: [({
-      paths
-    }) => paths.map((at) => ({
-      type: "move.block up",
-      at
-    }))]
-  }, {
-    on: "key.down",
-    guard: ({
-      context,
-      event
-    }) => {
-      const isMoveDownShortcut = isHotkey(config.moveBlockDownShortcut, event.keyboardEvent), lastBlock = getLastBlock({
-        context
-      }), selectedBlocks = getSelectedBlocks({
-        context
-      }), blocksBelow = lastBlock?.node._key !== selectedBlocks[selectedBlocks.length - 1]?.node._key;
-      return !isMoveDownShortcut || !blocksBelow ? !1 : {
-        paths: selectedBlocks.map((block) => block.path).reverse()
-      };
-    },
-    actions: [({
-      paths
-    }) => paths.map((at) => ({
-      type: "move.block down",
-      at
-    }))]
-  }];
-}
-function isEmptyTextBlock(block) {
-  if (!isPortableTextTextBlock(block))
-    return !1;
-  const onlyText = block.children.every(isPortableTextSpan$1), blockText = getTextBlockText(block);
-  return onlyText && blockText === "";
-}
-function getTextBlockText(block) {
-  return block.children.map((child) => child.text ?? "").join("");
-}
-const arrowDownOnLonelyBlockObject = {
-  on: "key.down",
-  guard: ({
-    context,
-    event
-  }) => {
-    const isArrowDown = isHotkey("ArrowDown", event.keyboardEvent), focusBlockObject = getFocusBlockObject({
-      context
-    }), nextBlock = getNextBlock({
-      context
-    });
-    return isArrowDown && focusBlockObject && !nextBlock;
-  },
-  actions: [() => [{
-    type: "insert.text block",
-    placement: "after"
-  }]]
-}, arrowUpOnLonelyBlockObject = {
-  on: "key.down",
-  guard: ({
-    context,
-    event
-  }) => {
-    const isArrowUp = isHotkey("ArrowUp", event.keyboardEvent), focusBlockObject = getFocusBlockObject({
-      context
-    }), previousBlock = getPreviousBlock({
-      context
-    });
-    return isArrowUp && focusBlockObject && !previousBlock;
-  },
-  actions: [() => [{
-    type: "insert.text block",
-    placement: "before"
-  }, {
-    type: "select previous block"
-  }]]
-}, breakingBlockObject = {
-  on: "insert.break",
-  guard: ({
-    context
-  }) => {
-    const focusBlockObject = getFocusBlockObject({
-      context
-    });
-    return selectionIsCollapsed({
-      context
-    }) && focusBlockObject !== void 0;
-  },
-  actions: [() => [{
-    type: "insert.text block",
-    placement: "after"
-  }]]
-}, deletingEmptyTextBlockAfterBlockObject = {
-  on: "delete.backward",
-  guard: ({
-    context
-  }) => {
-    const focusTextBlock = getFocusTextBlock({
-      context
-    }), selectionCollapsed = selectionIsCollapsed({
-      context
-    }), previousBlock = getPreviousBlock({
-      context
-    });
-    return !focusTextBlock || !selectionCollapsed || !previousBlock ? !1 : isEmptyTextBlock(focusTextBlock.node) && !isPortableTextTextBlock(previousBlock.node) ? {
-      focusTextBlock,
-      previousBlock
-    } : !1;
-  },
-  actions: [({
-    focusTextBlock,
-    previousBlock
-  }) => [{
-    type: "delete.block",
-    blockPath: focusTextBlock.path
-  }, {
-    type: "select",
-    selection: {
-      anchor: {
-        path: previousBlock.path,
-        offset: 0
-      },
-      focus: {
-        path: previousBlock.path,
-        offset: 0
-      }
-    }
-  }]]
-}, deletingEmptyTextBlockBeforeBlockObject = {
-  on: "delete.forward",
-  guard: ({
-    context
-  }) => {
-    const focusTextBlock = getFocusTextBlock({
-      context
-    }), selectionCollapsed = selectionIsCollapsed({
-      context
-    }), nextBlock = getNextBlock({
-      context
-    });
-    return !focusTextBlock || !selectionCollapsed || !nextBlock ? !1 : isEmptyTextBlock(focusTextBlock.node) && !isPortableTextTextBlock(nextBlock.node) ? {
-      focusTextBlock,
-      nextBlock
-    } : !1;
-  },
-  actions: [({
-    focusTextBlock,
-    nextBlock
-  }) => [{
-    type: "delete.block",
-    blockPath: focusTextBlock.path
-  }, {
-    type: "select",
-    selection: {
-      anchor: {
-        path: nextBlock.path,
-        offset: 0
-      },
-      focus: {
-        path: nextBlock.path,
-        offset: 0
-      }
-    }
-  }]]
-}, coreBlockObjectBehaviors = {
-  arrowDownOnLonelyBlockObject,
-  arrowUpOnLonelyBlockObject,
-  breakingBlockObject,
-  deletingEmptyTextBlockAfterBlockObject,
-  deletingEmptyTextBlockBeforeBlockObject
-}, decoratorAdd = {
-  on: "decorator.add",
-  guard: ({
-    event
-  }) => ({
-    decorator: event.decorator
-  }),
-  actions: [({
-    decorator
-  }) => [{
-    type: "decorator.add",
-    decorator
-  }, {
-    type: "reselect"
-  }]]
-}, decoratorRemove = {
-  on: "decorator.remove",
-  guard: ({
-    event
-  }) => ({
-    decorator: event.decorator
-  }),
-  actions: [({
-    decorator
-  }) => [{
-    type: "decorator.remove",
-    decorator
-  }, {
-    type: "reselect"
-  }]]
-}, decoratorToggle = {
-  on: "decorator.toggle",
-  guard: ({
-    event
-  }) => ({
-    decorator: event.decorator
-  }),
-  actions: [({
-    decorator
-  }) => [{
-    type: "decorator.toggle",
-    decorator
-  }, {
-    type: "reselect"
-  }]]
-}, coreDecoratorBehaviors = {
-  decoratorAdd,
-  decoratorRemove,
-  decoratorToggle
-}, MAX_LIST_LEVEL = 10, clearListOnBackspace = {
-  on: "delete.backward",
-  guard: ({
-    context
-  }) => {
-    const selectionCollapsed = selectionIsCollapsed({
-      context
-    }), focusTextBlock = getFocusTextBlock({
-      context
-    }), focusSpan = getFocusSpan({
-      context
-    });
-    return !selectionCollapsed || !focusTextBlock || !focusSpan ? !1 : focusTextBlock.node.children[0]._key === focusSpan.node._key && context.selection.focus.offset === 0 && focusTextBlock.node.level === 1 ? {
-      focusTextBlock
-    } : !1;
-  },
-  actions: [({
-    focusTextBlock
-  }) => [{
-    type: "text block.unset",
-    props: ["listItem", "level"],
-    at: focusTextBlock.path
-  }]]
-}, unindentListOnBackspace = {
-  on: "delete.backward",
-  guard: ({
-    context
-  }) => {
-    const selectionCollapsed = selectionIsCollapsed({
-      context
-    }), focusTextBlock = getFocusTextBlock({
-      context
-    }), focusSpan = getFocusSpan({
-      context
-    });
-    return !selectionCollapsed || !focusTextBlock || !focusSpan ? !1 : focusTextBlock.node.children[0]._key === focusSpan.node._key && context.selection.focus.offset === 0 && focusTextBlock.node.level !== void 0 && focusTextBlock.node.level > 1 ? {
-      focusTextBlock,
-      level: focusTextBlock.node.level - 1
-    } : !1;
-  },
-  actions: [({
-    focusTextBlock,
-    level
-  }) => [{
-    type: "text block.set",
-    level,
-    at: focusTextBlock.path
-  }]]
-}, clearListOnEnter = {
-  on: "insert.break",
-  guard: ({
-    context
-  }) => {
-    const focusListBlock = getFocusListBlock({
-      context
-    }), selectionCollapsed = selectionIsCollapsed({
-      context
-    });
-    return !focusListBlock || !selectionCollapsed || !isEmptyTextBlock(focusListBlock.node) ? !1 : {
-      focusListBlock
-    };
-  },
-  actions: [({
-    focusListBlock
-  }) => [{
-    type: "text block.unset",
-    props: ["listItem", "level"],
-    at: focusListBlock.path
-  }]]
-}, indentListOnTab = {
-  on: "key.down",
-  guard: ({
-    context,
-    event
-  }) => {
-    if (!isHotkey("Tab", event.keyboardEvent))
-      return !1;
-    const selectedBlocks = getSelectedBlocks({
-      context
-    }), guards = createGuards(context), selectedListBlocks = selectedBlocks.flatMap((block) => guards.isListBlock(block.node) ? [{
-      node: block.node,
-      path: block.path
-    }] : []);
-    return selectedListBlocks.length === selectedBlocks.length ? {
-      selectedListBlocks
-    } : !1;
-  },
-  actions: [({
-    selectedListBlocks
-  }) => selectedListBlocks.map((selectedListBlock) => ({
-    type: "text block.set",
-    level: Math.min(MAX_LIST_LEVEL, Math.max(1, selectedListBlock.node.level + 1)),
-    at: selectedListBlock.path
-  }))]
-}, unindentListOnShiftTab = {
-  on: "key.down",
-  guard: ({
-    context,
-    event
-  }) => {
-    if (!isHotkey("Shift+Tab", event.keyboardEvent))
-      return !1;
-    const selectedBlocks = getSelectedBlocks({
-      context
-    }), guards = createGuards(context), selectedListBlocks = selectedBlocks.flatMap((block) => guards.isListBlock(block.node) ? [{
-      node: block.node,
-      path: block.path
-    }] : []);
-    return selectedListBlocks.length === selectedBlocks.length ? {
-      selectedListBlocks
-    } : !1;
-  },
-  actions: [({
-    selectedListBlocks
-  }) => selectedListBlocks.map((selectedListBlock) => ({
-    type: "text block.set",
-    level: Math.min(MAX_LIST_LEVEL, Math.max(1, selectedListBlock.node.level - 1)),
-    at: selectedListBlock.path
-  }))]
-}, coreListBehaviors = {
-  clearListOnBackspace,
-  unindentListOnBackspace,
-  clearListOnEnter,
-  indentListOnTab,
-  unindentListOnShiftTab
-}, softReturn = {
-  on: "insert.soft break",
-  actions: [() => [{
-    type: "insert.text",
-    text: `
-`
-  }]]
-}, coreBehaviors = [softReturn, coreDecoratorBehaviors.decoratorAdd, coreDecoratorBehaviors.decoratorRemove, coreDecoratorBehaviors.decoratorToggle, coreBlockObjectBehaviors.arrowDownOnLonelyBlockObject, coreBlockObjectBehaviors.arrowUpOnLonelyBlockObject, coreBlockObjectBehaviors.breakingBlockObject, coreBlockObjectBehaviors.deletingEmptyTextBlockAfterBlockObject, coreBlockObjectBehaviors.deletingEmptyTextBlockBeforeBlockObject, coreListBehaviors.clearListOnBackspace, coreListBehaviors.unindentListOnBackspace, coreListBehaviors.clearListOnEnter, coreListBehaviors.indentListOnTab, coreListBehaviors.unindentListOnShiftTab], coreBehavior = {
-  softReturn,
-  decorators: coreDecoratorBehaviors,
-  blockObjects: coreBlockObjectBehaviors,
-  lists: coreListBehaviors
-};
-function createLinkBehaviors(config) {
-  const pasteLinkOnSelection = {
-    on: "paste",
-    guard: ({
-      context,
-      event
-    }) => {
-      const selectionCollapsed = selectionIsCollapsed({
-        context
-      }), text = event.data.getData("text/plain"), url = looksLikeUrl(text) ? text : void 0, annotation = url !== void 0 ? config.linkAnnotation?.({
-        url,
-        schema: context.schema
-      }) : void 0;
-      return annotation && !selectionCollapsed ? {
-        annotation
-      } : !1;
-    },
-    actions: [({
-      annotation
-    }) => [{
-      type: "annotation.add",
-      annotation
-    }]]
-  }, pasteLinkAtCaret = {
-    on: "paste",
-    guard: ({
-      context,
-      event
-    }) => {
-      const focusSpan = getFocusSpan({
-        context
-      }), selectionCollapsed = selectionIsCollapsed({
-        context
-      });
-      if (!focusSpan || !selectionCollapsed)
-        return !1;
-      const text = event.data.getData("text/plain"), url = looksLikeUrl(text) ? text : void 0, annotation = url !== void 0 ? config.linkAnnotation?.({
-        url,
-        schema: context.schema
-      }) : void 0;
-      return url && annotation && selectionCollapsed ? {
-        focusSpan,
-        annotation,
-        url
-      } : !1;
-    },
-    actions: [({
-      annotation,
-      url
-    }) => [{
-      type: "insert.span",
-      text: url,
-      annotations: [annotation]
-    }]]
-  };
-  return [pasteLinkOnSelection, pasteLinkAtCaret];
-}
-function looksLikeUrl(text) {
-  let looksLikeUrl2 = !1;
-  try {
-    new URL(text), looksLikeUrl2 = !0;
-  } catch {
-  }
-  return looksLikeUrl2;
-}
-function blockOffsetToSpanSelectionPoint({
-  value,
-  blockOffset
-}) {
-  let offsetLeft = blockOffset.offset, selectionPoint;
-  for (const block of value)
-    if (block._key === blockOffset.path[0]._key && isPortableTextTextBlock(block)) {
-      for (const child of block.children)
-        if (isPortableTextSpan$1(child)) {
-          if (offsetLeft === 0) {
-            selectionPoint = {
-              path: [...blockOffset.path, "children", {
-                _key: child._key
-              }],
-              offset: 0
-            };
-            break;
-          }
-          if (offsetLeft <= child.text.length) {
-            selectionPoint = {
-              path: [...blockOffset.path, "children", {
-                _key: child._key
-              }],
-              offset: offsetLeft
-            };
-            break;
-          }
-          offsetLeft -= child.text.length;
-        }
-    }
-  return selectionPoint;
-}
-function spanSelectionPointToBlockOffset({
-  value,
-  selectionPoint
-}) {
-  let offset = 0;
-  for (const block of value)
-    if (block._key === selectionPoint.path[0]._key && isPortableTextTextBlock(block)) {
-      for (const child of block.children)
-        if (isPortableTextSpan$1(child)) {
-          if (child._key === selectionPoint.path[2]._key)
-            return {
-              path: [{
-                _key: block._key
-              }],
-              offset: offset + selectionPoint.offset
-            };
-          offset += child.text.length;
-        }
-    }
-}
-function createMarkdownBehaviors(config) {
-  const automaticBlockquoteOnSpace = {
-    on: "insert.text",
-    guard: ({
-      context,
-      event
-    }) => {
-      if (event.text !== " ")
-        return !1;
-      const selectionCollapsed = selectionIsCollapsed({
-        context
-      }), focusTextBlock = getFocusTextBlock({
-        context
-      }), focusSpan = getFocusSpan({
-        context
-      });
-      if (!selectionCollapsed || !focusTextBlock || !focusSpan)
-        return !1;
-      const blockOffset = spanSelectionPointToBlockOffset({
-        value: context.value,
-        selectionPoint: {
-          path: [{
-            _key: focusTextBlock.node._key
-          }, "children", {
-            _key: focusSpan.node._key
-          }],
-          offset: context.selection.focus.offset
-        }
-      });
-      if (!blockOffset)
-        return !1;
-      const blockText = getTextBlockText(focusTextBlock.node), caretAtTheEndOfQuote = blockOffset.offset === 1, looksLikeMarkdownQuote = /^>/.test(blockText), blockquoteStyle = config.blockquoteStyle?.(context);
-      return caretAtTheEndOfQuote && looksLikeMarkdownQuote && blockquoteStyle !== void 0 ? {
-        focusTextBlock,
-        style: blockquoteStyle
-      } : !1;
-    },
-    actions: [() => [{
-      type: "insert.text",
-      text: " "
-    }], ({
-      focusTextBlock,
-      style
-    }) => [{
-      type: "text block.unset",
-      props: ["listItem", "level"],
-      at: focusTextBlock.path
-    }, {
-      type: "text block.set",
-      style,
-      at: focusTextBlock.path
-    }, {
-      type: "delete.text",
-      anchor: {
-        path: focusTextBlock.path,
-        offset: 0
-      },
-      focus: {
-        path: focusTextBlock.path,
-        offset: 2
-      }
-    }]]
-  }, automaticHr = {
-    on: "insert.text",
-    guard: ({
-      context,
-      event
-    }) => {
-      const hrCharacter = event.text === "-" ? "-" : event.text === "*" ? "*" : event.text === "_" ? "_" : void 0;
-      if (hrCharacter === void 0)
-        return !1;
-      const hrObject = config.horizontalRuleObject?.(context), focusBlock = getFocusTextBlock({
-        context
-      }), selectionCollapsed = selectionIsCollapsed({
-        context
-      });
-      if (!hrObject || !focusBlock || !selectionCollapsed)
-        return !1;
-      const textBefore = getBlockTextBefore({
-        context
-      }), hrBlockOffsets = {
-        anchor: {
-          path: focusBlock.path,
-          offset: 0
-        },
-        focus: {
-          path: focusBlock.path,
-          offset: 3
-        }
-      };
-      return textBefore === `${hrCharacter}${hrCharacter}` ? {
-        hrObject,
-        focusBlock,
-        hrCharacter,
-        hrBlockOffsets
-      } : !1;
-    },
-    actions: [({
-      hrCharacter
-    }) => [{
-      type: "insert.text",
-      text: hrCharacter
-    }], ({
-      hrObject,
-      hrBlockOffsets
-    }) => [{
-      type: "insert.block object",
-      placement: "before",
-      blockObject: hrObject
-    }, {
-      type: "delete.text",
-      ...hrBlockOffsets
-    }]]
-  }, automaticHrOnPaste = {
-    on: "paste",
-    guard: ({
-      context,
-      event
-    }) => {
-      const text = event.data.getData("text/plain"), hrRegExp = /^(---)$|(___)$|(\*\*\*)$/gm, hrCharacters = text.match(hrRegExp)?.[0], hrObject = config.horizontalRuleObject?.(context), focusBlock = getFocusBlock({
-        context
-      });
-      return !hrCharacters || !hrObject || !focusBlock ? !1 : {
-        hrCharacters,
-        hrObject,
-        focusBlock
-      };
-    },
-    actions: [({
-      hrCharacters
-    }) => [{
-      type: "insert.text",
-      text: hrCharacters
-    }], ({
-      hrObject,
-      focusBlock
-    }) => isPortableTextTextBlock(focusBlock.node) ? [{
-      type: "insert.text block",
-      textBlock: {
-        children: focusBlock.node.children
-      },
-      placement: "after"
-    }, {
-      type: "insert.block object",
-      blockObject: hrObject,
-      placement: "after"
-    }, {
-      type: "delete.block",
-      blockPath: focusBlock.path
-    }] : [{
-      type: "insert.block object",
-      blockObject: hrObject,
-      placement: "after"
-    }]]
-  }, automaticHeadingOnSpace = {
-    on: "insert.text",
-    guard: ({
-      context,
-      event
-    }) => {
-      if (event.text !== " ")
-        return !1;
-      const selectionCollapsed = selectionIsCollapsed({
-        context
-      }), focusTextBlock = getFocusTextBlock({
-        context
-      }), focusSpan = getFocusSpan({
-        context
-      });
-      if (!selectionCollapsed || !focusTextBlock || !focusSpan)
-        return !1;
-      const blockOffset = spanSelectionPointToBlockOffset({
-        value: context.value,
-        selectionPoint: {
-          path: [{
-            _key: focusTextBlock.node._key
-          }, "children", {
-            _key: focusSpan.node._key
-          }],
-          offset: context.selection.focus.offset
-        }
-      });
-      if (!blockOffset)
-        return !1;
-      const blockText = getTextBlockText(focusTextBlock.node), markdownHeadingSearch = /^#+/.exec(blockText), level = markdownHeadingSearch ? markdownHeadingSearch[0].length : void 0;
-      if (blockOffset.offset !== level)
-        return !1;
-      const style = level !== void 0 ? config.headingStyle?.({
-        schema: context.schema,
-        level
-      }) : void 0;
-      return level !== void 0 && style !== void 0 ? {
-        focusTextBlock,
-        style,
-        level
-      } : !1;
-    },
-    actions: [() => [{
-      type: "insert.text",
-      text: " "
-    }], ({
-      focusTextBlock,
-      style,
-      level
-    }) => [{
-      type: "text block.unset",
-      props: ["listItem", "level"],
-      at: focusTextBlock.path
-    }, {
-      type: "text block.set",
-      style,
-      at: focusTextBlock.path
-    }, {
-      type: "delete.text",
-      anchor: {
-        path: focusTextBlock.path,
-        offset: 0
-      },
-      focus: {
-        path: focusTextBlock.path,
-        offset: level + 1
-      }
-    }]]
-  }, clearStyleOnBackspace = {
-    on: "delete.backward",
-    guard: ({
-      context
-    }) => {
-      const selectionCollapsed = selectionIsCollapsed({
-        context
-      }), focusTextBlock = getFocusTextBlock({
-        context
-      }), focusSpan = getFocusSpan({
-        context
-      });
-      if (!selectionCollapsed || !focusTextBlock || !focusSpan)
-        return !1;
-      const atTheBeginningOfBLock = focusTextBlock.node.children[0]._key === focusSpan.node._key && context.selection.focus.offset === 0, defaultStyle = config.defaultStyle?.(context);
-      return atTheBeginningOfBLock && defaultStyle && focusTextBlock.node.style !== defaultStyle ? {
-        defaultStyle,
-        focusTextBlock
-      } : !1;
-    },
-    actions: [({
-      defaultStyle,
-      focusTextBlock
-    }) => [{
-      type: "text block.set",
-      style: defaultStyle,
-      at: focusTextBlock.path
-    }]]
-  }, automaticListOnSpace = {
-    on: "insert.text",
-    guard: ({
-      context,
-      event
-    }) => {
-      if (event.text !== " ")
-        return !1;
-      const selectionCollapsed = selectionIsCollapsed({
-        context
-      }), focusTextBlock = getFocusTextBlock({
-        context
-      }), focusSpan = getFocusSpan({
-        context
-      });
-      if (!selectionCollapsed || !focusTextBlock || !focusSpan)
-        return !1;
-      const blockOffset = spanSelectionPointToBlockOffset({
-        value: context.value,
-        selectionPoint: {
-          path: [{
-            _key: focusTextBlock.node._key
-          }, "children", {
-            _key: focusSpan.node._key
-          }],
-          offset: context.selection.focus.offset
-        }
-      });
-      if (!blockOffset)
-        return !1;
-      const blockText = getTextBlockText(focusTextBlock.node), defaultStyle = config.defaultStyle?.(context), looksLikeUnorderedList = /^(-|\*)/.test(blockText), unorderedListStyle = config.unorderedListStyle?.(context), caretAtTheEndOfUnorderedList = blockOffset.offset === 1;
-      if (defaultStyle && caretAtTheEndOfUnorderedList && looksLikeUnorderedList && unorderedListStyle !== void 0)
-        return {
-          focusTextBlock,
-          listItem: unorderedListStyle,
-          listItemLength: 1,
-          style: defaultStyle
-        };
-      const looksLikeOrderedList = /^1\./.test(blockText), orderedListStyle = config.orderedListStyle?.(context), caretAtTheEndOfOrderedList = blockOffset.offset === 2;
-      return defaultStyle && caretAtTheEndOfOrderedList && looksLikeOrderedList && orderedListStyle !== void 0 ? {
-        focusTextBlock,
-        listItem: orderedListStyle,
-        listItemLength: 2,
-        style: defaultStyle
-      } : !1;
-    },
-    actions: [() => [{
-      type: "insert.text",
-      text: " "
-    }], ({
-      focusTextBlock,
-      style,
-      listItem,
-      listItemLength
-    }) => [{
-      type: "text block.set",
-      listItem,
-      level: 1,
-      style,
-      at: focusTextBlock.path
-    }, {
-      type: "delete.text",
-      anchor: {
-        path: focusTextBlock.path,
-        offset: 0
-      },
-      focus: {
-        path: focusTextBlock.path,
-        offset: listItemLength + 1
-      }
-    }]]
-  };
-  return [automaticBlockquoteOnSpace, automaticHeadingOnSpace, automaticHr, automaticHrOnPaste, clearStyleOnBackspace, automaticListOnSpace];
-}
 function getPortableTextMemberSchemaTypes(portableTextType) {
+  var _a, _b, _c;
   if (!portableTextType)
     throw new Error("Parameter 'portabletextType' missing (required)");
-  const blockType = portableTextType.of?.find(findBlockType);
+  const blockType = (_a = portableTextType.of) == null ? void 0 : _a.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 = (_b = blockType.fields) == null ? void 0 : _b.find((field) => field.name === "children");
   if (!childrenField)
     throw new Error("Children field for block type found in schema (required)");
   const ofType = childrenField.type.of;
@@ -969,7 +54,7 @@ function getPortableTextMemberSchemaTypes(portableTextType) {
   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 = ((_c = portableTextType.of) == null ? void 0 : _c.filter((field) => field.name !== blockType.name)) || [];
   return {
     styles: resolveEnabledStyles(blockType),
     decorators: resolveEnabledDecorators(spanType),
@@ -983,10 +68,11 @@ function getPortableTextMemberSchemaTypes(portableTextType) {
   };
 }
 function resolveEnabledStyles(blockType) {
-  const styleField = blockType.fields?.find((btField) => btField.name === "style");
+  var _a, _b, _c;
+  const styleField = (_a = blockType.fields) == null ? void 0 : _a.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);
+  const textStyles = ((_b = styleField.type.options) == null ? void 0 : _b.list) && ((_c = styleField.type.options.list) == null ? void 0 : _c.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'}.");
   return textStyles;
@@ -995,10 +81,11 @@ function resolveEnabledDecorators(spanType) {
   return spanType.decorators;
 }
 function resolveEnabledListItems(blockType) {
-  const listField = blockType.fields?.find((btField) => btField.name === "listItem");
+  var _a, _b;
+  const listField = (_a = blockType.fields) == null ? void 0 : _a.find((btField) => btField.name === "listItem");
   if (!listField)
     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);
+  const listItems = ((_b = listField.type.options) == null ? void 0 : _b.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");
   return listItems;
@@ -1006,11 +93,20 @@ function resolveEnabledListItems(blockType) {
 function findBlockType(type) {
   return type.type ? findBlockType(type.type) : type.name === "block" ? type : null;
 }
+var __defProp$p = Object.defineProperty, __defProps$j = Object.defineProperties, __getOwnPropDescs$j = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$p = Object.getOwnPropertySymbols, __hasOwnProp$p = Object.prototype.hasOwnProperty, __propIsEnum$p = Object.prototype.propertyIsEnumerable, __defNormalProp$p = (obj, key, value) => key in obj ? __defProp$p(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$p = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$p.call(b, prop) && __defNormalProp$p(a, prop, b[prop]);
+  if (__getOwnPropSymbols$p)
+    for (var prop of __getOwnPropSymbols$p(b))
+      __propIsEnum$p.call(b, prop) && __defNormalProp$p(a, prop, b[prop]);
+  return a;
+}, __spreadProps$j = (a, b) => __defProps$j(a, __getOwnPropDescs$j(b));
 function defineSchema(definition) {
   return definition;
 }
 function compileSchemaDefinition(definition) {
-  const blockObjects = definition?.blockObjects?.map((blockObject) => defineType({
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  const blockObjects = (_b = (_a = definition == null ? void 0 : definition.blockObjects) == null ? void 0 : _a.map((blockObject) => defineType({
     type: "object",
     // Very naive way to work around `SanitySchema.compile` adding default
     // fields to objects with the name `image`
@@ -1018,13 +114,13 @@ function compileSchemaDefinition(definition) {
     title: blockObject.title,
     icon: blockObject.icon,
     fields: []
-  })) ?? [], inlineObjects = definition?.inlineObjects?.map((inlineObject) => defineType({
+  }))) != null ? _b : [], inlineObjects = (_d = (_c = definition == null ? void 0 : definition.inlineObjects) == null ? void 0 : _c.map((inlineObject) => defineType({
     type: "object",
     name: inlineObject.name,
     title: inlineObject.title,
     icon: inlineObject.icon,
     fields: []
-  })) ?? [], portableTextSchema = defineField({
+  }))) != null ? _d : [], portableTextSchema = defineField({
     type: "array",
     name: "portable-text",
     of: [...blockObjects.map((blockObject) => ({
@@ -1036,43 +132,49 @@ function compileSchemaDefinition(definition) {
         type: inlineObject.name
       })),
       marks: {
-        decorators: definition?.decorators?.map((decorator) => ({
-          title: decorator.title ?? startCase(decorator.name),
-          value: decorator.name,
-          icon: decorator.icon
-        })) ?? [],
-        annotations: definition?.annotations?.map((annotation) => ({
+        decorators: (_f = (_e = definition == null ? void 0 : definition.decorators) == null ? void 0 : _e.map((decorator) => {
+          var _a2;
+          return {
+            title: (_a2 = decorator.title) != null ? _a2 : startCase(decorator.name),
+            value: decorator.name,
+            icon: decorator.icon
+          };
+        })) != null ? _f : [],
+        annotations: (_h = (_g = definition == null ? void 0 : definition.annotations) == null ? void 0 : _g.map((annotation) => ({
           name: annotation.name,
           type: "object",
           title: annotation.title,
           icon: annotation.icon
-        })) ?? []
+        }))) != null ? _h : []
       },
-      lists: definition?.lists?.map((list) => ({
-        value: list.name,
-        title: list.title ?? startCase(list.name),
-        icon: list.icon
-      })) ?? [],
-      styles: definition?.styles?.map((style) => ({
-        value: style.name,
-        title: style.title ?? startCase(style.name),
-        icon: style.icon
-      })) ?? []
+      lists: (_j = (_i = definition == null ? void 0 : definition.lists) == null ? void 0 : _i.map((list) => {
+        var _a2;
+        return {
+          value: list.name,
+          title: (_a2 = list.title) != null ? _a2 : startCase(list.name),
+          icon: list.icon
+        };
+      })) != null ? _j : [],
+      styles: (_l = (_k = definition == null ? void 0 : definition.styles) == null ? void 0 : _k.map((style) => {
+        var _a2;
+        return {
+          value: style.name,
+          title: (_a2 = style.title) != null ? _a2 : startCase(style.name),
+          icon: style.icon
+        };
+      })) != null ? _l : []
     }]
   }), schema = Schema.compile({
     types: [portableTextSchema, ...blockObjects, ...inlineObjects]
   }).get("portable-text"), pteSchema = getPortableTextMemberSchemaTypes(schema);
-  return {
-    ...pteSchema,
-    blockObjects: pteSchema.blockObjects.map((blockObject) => blockObject.name === "tmp-image" ? {
-      ...blockObject,
+  return __spreadProps$j(__spreadValues$p({}, pteSchema), {
+    blockObjects: pteSchema.blockObjects.map((blockObject) => blockObject.name === "tmp-image" ? __spreadProps$j(__spreadValues$p({}, blockObject), {
       name: "image",
-      type: {
-        ...blockObject.type,
+      type: __spreadProps$j(__spreadValues$p({}, blockObject.type), {
         name: "image"
-      }
-    } : blockObject)
-  };
+      })
+    }) : blockObject)
+  });
 }
 const rootName = "sanity-pte:";
 var debug$l = debug$m(rootName);
@@ -1207,6 +309,22 @@ function normalizeSelection(selection, value) {
     backward: selection.backward
   } : null;
 }
+var __defProp$o = Object.defineProperty, __defProps$i = Object.defineProperties, __getOwnPropDescs$i = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$o = Object.getOwnPropertySymbols, __hasOwnProp$o = Object.prototype.hasOwnProperty, __propIsEnum$o = Object.prototype.propertyIsEnumerable, __defNormalProp$o = (obj, key, value) => key in obj ? __defProp$o(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$o = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$o.call(b, prop) && __defNormalProp$o(a, prop, b[prop]);
+  if (__getOwnPropSymbols$o)
+    for (var prop of __getOwnPropSymbols$o(b))
+      __propIsEnum$o.call(b, prop) && __defNormalProp$o(a, prop, b[prop]);
+  return a;
+}, __spreadProps$i = (a, b) => __defProps$i(a, __getOwnPropDescs$i(b)), __objRest$3 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    __hasOwnProp$o.call(source, prop) && exclude.indexOf(prop) < 0 && (target[prop] = source[prop]);
+  if (source != null && __getOwnPropSymbols$o)
+    for (var prop of __getOwnPropSymbols$o(source))
+      exclude.indexOf(prop) < 0 && __propIsEnum$o.call(source, prop) && (target[prop] = source[prop]);
+  return target;
+};
 const VOID_CHILD_KEY = "void-child";
 function keepObjectEquality(object, keyMap) {
   const value = keyMap[object._key];
@@ -1216,11 +334,13 @@ function toSlateValue(value, {
   schemaTypes
 }, keyMap = {}) {
   return value && Array.isArray(value) ? value.map((block) => {
-    const {
+    const _a = block, {
       _type,
-      _key,
-      ...rest
-    } = block, voidChildren = [{
+      _key
+    } = _a, rest = __objRest$3(_a, [
+      "_type",
+      "_key"
+    ]), voidChildren = [{
       _key: VOID_CHILD_KEY,
       _type: "span",
       text: "",
@@ -1230,11 +350,13 @@ function toSlateValue(value, {
       const textBlock = block;
       let hasInlines = !1;
       const hasMissingStyle = typeof textBlock.style > "u", hasMissingMarkDefs = typeof textBlock.markDefs > "u", hasMissingChildren = typeof textBlock.children > "u", children = (textBlock.children || []).map((child) => {
-        const {
+        const _a2 = child, {
           _type: cType,
-          _key: cKey,
-          ...cRest
-        } = child;
+          _key: cKey
+        } = _a2, cRest = __objRest$3(_a2, [
+          "_type",
+          "_key"
+        ]);
         return cType !== "span" ? (hasInlines = !0, keepObjectEquality({
           _type: cType,
           _key: cKey,
@@ -1243,12 +365,12 @@ function toSlateValue(value, {
           __inline: !0
         }, keyMap)) : child;
       });
-      return !hasMissingStyle && !hasMissingMarkDefs && !hasMissingChildren && !hasInlines && Element$1.isElement(block) ? block : (hasMissingStyle && (rest.style = schemaTypes.styles[0].value), keepObjectEquality({
+      return !hasMissingStyle && !hasMissingMarkDefs && !hasMissingChildren && !hasInlines && Element$1.isElement(block) ? block : (hasMissingStyle && (rest.style = schemaTypes.styles[0].value), keepObjectEquality(__spreadProps$i(__spreadValues$o({
         _type,
-        _key,
-        ...rest,
+        _key
+      }, rest), {
         children
-      }, keyMap));
+      }), keyMap));
     }
     return keepObjectEquality({
       _type,
@@ -1274,40 +396,42 @@ function fromSlateValue(value, textBlockType, keyMap = {}) {
         } = child;
         if ("value" in child && _cType !== "span") {
           hasInlines = !0;
-          const {
+          const _a = child, {
             value: v,
             _key: k,
             _type: t,
             __inline: _i,
-            children: _c,
-            ...rest
-          } = child;
-          return keepObjectEquality({
-            ...rest,
-            ...v,
+            children: _c
+          } = _a, rest = __objRest$3(_a, [
+            "value",
+            "_key",
+            "_type",
+            "__inline",
+            "children"
+          ]);
+          return keepObjectEquality(__spreadProps$i(__spreadValues$o(__spreadValues$o({}, rest), v), {
             _key: k,
             _type: t
-          }, keyMap);
+          }), keyMap);
         }
         return child;
       });
-      return hasInlines ? keepObjectEquality({
-        ...block,
+      return hasInlines ? keepObjectEquality(__spreadProps$i(__spreadValues$o({}, block), {
         children,
         _key,
         _type
-      }, keyMap) : block;
+      }), keyMap) : block;
     }
     const blockValue = "value" in block && block.value;
-    return keepObjectEquality({
+    return keepObjectEquality(__spreadValues$o({
       _key,
-      _type,
-      ...typeof blockValue == "object" ? blockValue : {}
-    }, keyMap);
+      _type
+    }, typeof blockValue == "object" ? blockValue : {}), keyMap);
   });
 }
 function isEqualToEmptyEditor(children, schemaTypes) {
-  return children === void 0 || children && Array.isArray(children) && children.length === 0 || children && Array.isArray(children) && children.length === 1 && Element$1.isElement(children[0]) && children[0]._type === schemaTypes.block.name && "style" in children[0] && children[0].style === schemaTypes.styles[0].value && !("listItem" in children[0]) && Array.isArray(children[0].children) && children[0].children.length === 1 && Text.isText(children[0].children[0]) && children[0].children[0]._type === "span" && !children[0].children[0].marks?.join("") && children[0].children[0].text === "";
+  var _a;
+  return children === void 0 || children && Array.isArray(children) && children.length === 0 || children && Array.isArray(children) && children.length === 1 && Element$1.isElement(children[0]) && children[0]._type === schemaTypes.block.name && "style" in children[0] && children[0].style === schemaTypes.styles[0].value && !("listItem" in children[0]) && Array.isArray(children[0].children) && children[0].children.length === 1 && Text.isText(children[0].children[0]) && children[0].children[0]._type === "span" && !((_a = children[0].children[0].marks) != null && _a.join("")) && children[0].children[0].text === "";
 }
 const IS_PROCESSING_REMOTE_CHANGES = /* @__PURE__ */ new WeakMap(), IS_PROCESSING_LOCAL_CHANGES = /* @__PURE__ */ new WeakMap(), IS_DRAGGING = /* @__PURE__ */ new WeakMap(), IS_DRAGGING_BLOCK_ELEMENT = /* @__PURE__ */ new WeakMap(), IS_DRAGGING_ELEMENT_TARGET = /* @__PURE__ */ new WeakMap(), IS_DRAGGING_BLOCK_TARGET_POSITION = /* @__PURE__ */ new WeakMap(), KEY_TO_SLATE_ELEMENT = /* @__PURE__ */ new WeakMap(), KEY_TO_VALUE_ELEMENT = /* @__PURE__ */ new WeakMap(), SLATE_TO_PORTABLE_TEXT_RANGE = /* @__PURE__ */ new WeakMap(), DefaultObject = (props) => {
   const $ = c(4);
@@ -1607,6 +731,14 @@ const debug$k = debugWithName("components:DraggableBlock"), DraggableBlock = (t0
   ] }), $[41] = children, $[42] = handleDrag, $[43] = handleDragEnd, $[44] = handleDragOver, $[45] = handleDragStart, $[46] = handleDrop, $[47] = isVoid, $[48] = t17, $[49] = t18, $[50] = t19) : t19 = $[50], t19;
 };
 DraggableBlock.displayName = "DraggableBlock";
+var __defProp$n = Object.defineProperty, __defProps$h = Object.defineProperties, __getOwnPropDescs$h = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$n = Object.getOwnPropertySymbols, __hasOwnProp$n = Object.prototype.hasOwnProperty, __propIsEnum$n = Object.prototype.propertyIsEnumerable, __defNormalProp$n = (obj, key, value) => key in obj ? __defProp$n(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$n = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$n.call(b, prop) && __defNormalProp$n(a, prop, b[prop]);
+  if (__getOwnPropSymbols$n)
+    for (var prop of __getOwnPropSymbols$n(b))
+      __propIsEnum$n.call(b, prop) && __defNormalProp$n(a, prop, b[prop]);
+  return a;
+}, __spreadProps$h = (a, b) => __defProps$h(a, __getOwnPropDescs$h(b));
 debugWithName("components:Element");
 const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
   display: "inline-block"
@@ -1643,7 +775,7 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
       }, "children", {
         _key: element._key
       }];
-      return /* @__PURE__ */ jsxs("span", { ...attributes, children: [
+      return /* @__PURE__ */ jsxs("span", __spreadProps$h(__spreadValues$n({}, attributes), { children: [
         children,
         /* @__PURE__ */ jsxs("span", { draggable: !readOnly, className: "pt-inline-object", "data-testid": "pt-inline-object", ref: inlineBlockObjectRef, style: inlineBlockStyle, contentEditable: !1, children: [
           renderChild && renderChild({
@@ -1660,7 +792,7 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
           }),
           !renderChild && /* @__PURE__ */ jsx(DefaultObject, { value })
         ] }, element._key)
-      ] });
+      ] }));
     }
     throw new Error("Block not found!");
   }
@@ -1711,7 +843,7 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
         return console.warn("Property 'type' is deprecated, use 'schemaType' instead."), schemaTypes.block;
       }
     }), propsOrDefaultRendered = renderBlock ? renderBlock(renderProps) : children;
-    return /* @__PURE__ */ jsx("div", { ...attributes, className, spellCheck, children: /* @__PURE__ */ jsx(DraggableBlock, { element, readOnly, blockRef, children: /* @__PURE__ */ jsx("div", { ref: blockRef, children: propsOrDefaultRendered }) }) }, element._key);
+    return /* @__PURE__ */ jsx("div", __spreadProps$h(__spreadValues$n({}, attributes), { className, spellCheck, children: /* @__PURE__ */ jsx(DraggableBlock, { element, readOnly, blockRef, children: /* @__PURE__ */ jsx("div", { ref: blockRef, children: propsOrDefaultRendered }) }) }), element._key);
   }
   const schemaType_0 = schemaTypes.blockObjects.find((_type_0) => _type_0.name === element._type);
   if (!schemaType_0)
@@ -1736,13 +868,13 @@ const EMPTY_ANNOTATIONS = [], inlineBlockStyle = {
     });
     renderedBlockFromProps = renderBlock(_props);
   }
-  return /* @__PURE__ */ jsxs("div", { ...attributes, className, children: [
+  return /* @__PURE__ */ jsxs("div", __spreadProps$h(__spreadValues$n({}, attributes), { className, children: [
     children,
     /* @__PURE__ */ jsxs(DraggableBlock, { element, readOnly, blockRef, children: [
       renderedBlockFromProps && /* @__PURE__ */ jsx("div", { ref: blockRef, contentEditable: !1, children: renderedBlockFromProps }),
       !renderedBlockFromProps && /* @__PURE__ */ jsx(DefaultBlockObject, { selected, children: /* @__PURE__ */ jsx(DefaultObject, { value }) })
     ] })
-  ] }, element._key);
+  ] }), element._key);
 };
 Element.displayName = "Element";
 const PortableTextEditorContext = createContext(null), usePortableTextEditor = () => {
@@ -1770,6 +902,14 @@ function compileType(rawType) {
     types: [rawType]
   }).get(rawType.name);
 }
+var __defProp$m = Object.defineProperty, __defProps$g = Object.defineProperties, __getOwnPropDescs$g = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$m = Object.getOwnPropertySymbols, __hasOwnProp$m = Object.prototype.hasOwnProperty, __propIsEnum$m = Object.prototype.propertyIsEnumerable, __defNormalProp$m = (obj, key, value) => key in obj ? __defProp$m(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$m = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$m.call(b, prop) && __defNormalProp$m(a, prop, b[prop]);
+  if (__getOwnPropSymbols$m)
+    for (var prop of __getOwnPropSymbols$m(b))
+      __propIsEnum$m.call(b, prop) && __defNormalProp$m(a, prop, b[prop]);
+  return a;
+}, __spreadProps$g = (a, b) => __defProps$g(a, __getOwnPropDescs$g(b));
 function validateValue(value, types, keyGenerator) {
   let resolution = null, valid = !0;
   const validChildTypes = [types.span.name, ...types.inlineObjects.map((t) => t.name)], validBlockTypes = [types.block.name, ...types.blockObjects.map((t) => t.name)];
@@ -1807,10 +947,9 @@ function validateValue(value, types, keyGenerator) {
       }, !0;
     if (!blk._key || typeof blk._key != "string")
       return resolution = {
-        patches: [set({
-          ...blk,
+        patches: [set(__spreadProps$g(__spreadValues$m({}, blk), {
           _key: keyGenerator()
-        }, [index])],
+        }), [index])],
         description: `Block at index ${index} is missing required _key.`,
         action: "Set the block with a random _key value",
         item: blk,
@@ -1826,10 +965,9 @@ function validateValue(value, types, keyGenerator) {
       if (blk._type === "block") {
         const currentBlockTypeName = types.block.name;
         return resolution = {
-          patches: [set({
-            ...blk,
+          patches: [set(__spreadProps$g(__spreadValues$m({}, 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}'`,
@@ -1845,14 +983,12 @@ function validateValue(value, types, keyGenerator) {
           }
         }, !0;
       }
-      return !blk._type && isPortableTextTextBlock({
-        ...blk,
+      return !blk._type && isPortableTextTextBlock(__spreadProps$g(__spreadValues$m({}, blk), {
         _type: types.block.name
-      }) ? (resolution = {
-        patches: [set({
-          ...blk,
+      })) ? (resolution = {
+        patches: [set(__spreadProps$g(__spreadValues$m({}, blk), {
           _type: types.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.block.name}'`,
@@ -2012,10 +1148,9 @@ function validateValue(value, types, keyGenerator) {
             }
           }, !0;
         if (!child._key || typeof child._key != "string") {
-          const newChild = {
-            ...child,
+          const newChild = __spreadProps$g(__spreadValues$m({}, child), {
             _key: keyGenerator()
-          };
+          });
           return resolution = {
             autoResolve: !0,
             patches: [set(newChild, [{
@@ -2035,10 +1170,9 @@ function validateValue(value, types, keyGenerator) {
           }, !0;
         }
         return child._type ? validChildTypes.includes(child._type) ? child._type === types.span.name && typeof child.text != "string" ? (resolution = {
-          patches: [set({
-            ...child,
+          patches: [set(__spreadProps$g(__spreadValues$m({}, child), {
             text: ""
-          }, [{
+          }), [{
             _key: blk._key
           }, "children", {
             _key: child._key
@@ -2449,11 +1583,10 @@ function createDeadLine(timeout) {
   return typeof timeout < "u" && (t = timeout <= 0 ? Number.MAX_VALUE : timeout), Date.now() + t * 1e3;
 }
 function createInternalOpts(opts) {
-  return {
+  return __spreadValues({
     checkLines: !0,
-    deadline: createDeadLine(opts.timeout || 1),
-    ...opts
-  };
+    deadline: createDeadLine(opts.timeout || 1)
+  }, opts);
 }
 function combineChar(data, char, dir) {
   return dir === 1 ? data + char : char + data;
@@ -2517,10 +1650,7 @@ const DEFAULT_OPTIONS = {
   distance: 1e3
 };
 function applyDefaults(options) {
-  return {
-    ...DEFAULT_OPTIONS,
-    ...options
-  };
+  return __spreadValues(__spreadValues({}, DEFAULT_OPTIONS), options);
 }
 const MAX_BITS$1 = 32;
 function bitap(text, pattern, loc) {
@@ -2792,7 +1922,7 @@ function parse(textline) {
       let line;
       try {
         line = decodeURI(currentLine.slice(1));
-      } catch {
+      } catch (ex) {
         throw new Error("Illegal escape in parse: ".concat(currentLine));
       }
       const utf8Diff = countUtf8Bytes(line) - line.length;
@@ -2818,7 +1948,8 @@ function withUndoing(editor, fn) {
   IS_UDOING.set(editor, !0), fn(), IS_UDOING.set(editor, prev);
 }
 function isUndoing(editor) {
-  return IS_UDOING.get(editor) ?? !1;
+  var _a;
+  return (_a = IS_UDOING.get(editor)) != null ? _a : !1;
 }
 function setIsUndoing(editor, isUndoing2) {
   IS_UDOING.set(editor, isUndoing2);
@@ -2828,11 +1959,20 @@ function withRedoing(editor, fn) {
   IS_REDOING.set(editor, !0), fn(), IS_REDOING.set(editor, prev);
 }
 function isRedoing(editor) {
-  return IS_REDOING.get(editor) ?? !1;
+  var _a;
+  return (_a = IS_REDOING.get(editor)) != null ? _a : !1;
 }
 function setIsRedoing(editor, isRedoing2) {
   IS_REDOING.set(editor, isRedoing2);
 }
+var __defProp$l = Object.defineProperty, __getOwnPropSymbols$l = Object.getOwnPropertySymbols, __hasOwnProp$l = Object.prototype.hasOwnProperty, __propIsEnum$l = Object.prototype.propertyIsEnumerable, __defNormalProp$l = (obj, key, value) => key in obj ? __defProp$l(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$l = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$l.call(b, prop) && __defNormalProp$l(a, prop, b[prop]);
+  if (__getOwnPropSymbols$l)
+    for (var prop of __getOwnPropSymbols$l(b))
+      __propIsEnum$l.call(b, prop) && __defNormalProp$l(a, prop, b[prop]);
+  return a;
+};
 const debug$j = debugWithName("plugin:withUndoRedo"), debugVerbose$4 = debug$j.enabled && !1, SAVING = /* @__PURE__ */ new WeakMap(), REMOTE_PATCHES = /* @__PURE__ */ new WeakMap(), UNDO_STEP_LIMIT = 1e3, isSaving = (editor) => {
   const state = SAVING.get(editor);
   return state === void 0 ? !0 : state;
@@ -2989,9 +2129,7 @@ function createWithUndoRedo(options) {
 }
 function transformOperation(editor, patch, operation, snapshot, previousSnapshot) {
   debugVerbose$4 && (debug$j(`Adjusting '${operation.type}' operation paths for '${patch.type}' patch`), debug$j(`Operation ${JSON.stringify(operation)}`), debug$j(`Patch ${JSON.stringify(patch)}`));
-  const transformedOperation = {
-    ...operation
-  };
+  const transformedOperation = __spreadValues$l({}, operation);
   if (patch.type === "insert" && patch.path.length === 1) {
     const insertBlockIndex = (snapshot || []).findIndex((blk) => isEqual({
       _key: blk._key
@@ -3011,6 +2149,7 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
     return !operationTargetBlock || !isEqual({
       _key: operationTargetBlock._key
     }, patch.path[0]) ? [transformedOperation] : (parse(patch.value).forEach((diffPatch) => {
+      var _a, _b, _c, _d;
       let adjustOffsetBy = 0, changedOffset = diffPatch.utf8Start1;
       const {
         diffs
@@ -3019,15 +2158,7 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
         const [diffType, text] = diff2;
         diffType === DIFF_INSERT ? (adjustOffsetBy += text.length, changedOffset += text.length) : diffType === DIFF_DELETE ? (adjustOffsetBy -= text.length, changedOffset -= text.length) : diffType === DIFF_EQUAL && (diffs.slice(index).every(([dType]) => dType === DIFF_EQUAL) || (changedOffset += text.length));
       }), transformedOperation.type === "insert_text" && changedOffset < transformedOperation.offset && (transformedOperation.offset += adjustOffsetBy), transformedOperation.type === "remove_text" && changedOffset <= transformedOperation.offset - transformedOperation.text.length && (transformedOperation.offset += adjustOffsetBy), transformedOperation.type === "set_selection") {
-        const currentFocus = transformedOperation.properties?.focus ? {
-          ...transformedOperation.properties.focus
-        } : void 0, currentAnchor = transformedOperation?.properties?.anchor ? {
-          ...transformedOperation.properties.anchor
-        } : void 0, newFocus = transformedOperation?.newProperties?.focus ? {
-          ...transformedOperation.newProperties.focus
-        } : void 0, newAnchor = transformedOperation?.newProperties?.anchor ? {
-          ...transformedOperation.newProperties.anchor
-        } : void 0;
+        const currentFocus = (_a = transformedOperation.properties) != null && _a.focus ? __spreadValues$l({}, transformedOperation.properties.focus) : void 0, currentAnchor = (_b = transformedOperation == null ? void 0 : transformedOperation.properties) != null && _b.anchor ? __spreadValues$l({}, transformedOperation.properties.anchor) : void 0, newFocus = (_c = transformedOperation == null ? void 0 : transformedOperation.newProperties) != null && _c.focus ? __spreadValues$l({}, transformedOperation.newProperties.focus) : void 0, newAnchor = (_d = transformedOperation == null ? void 0 : transformedOperation.newProperties) != null && _d.anchor ? __spreadValues$l({}, transformedOperation.newProperties.anchor) : void 0;
         (currentFocus && currentAnchor || newFocus && newAnchor) && ([currentFocus, currentAnchor, newFocus, newAnchor].forEach((point) => {
           point && changedOffset < point.offset && (point.offset += adjustOffsetBy);
         }), currentFocus && currentAnchor && (transformedOperation.properties = {
@@ -3043,23 +2174,14 @@ function transformOperation(editor, patch, operation, snapshot, previousSnapshot
   return [transformedOperation];
 }
 function adjustBlockPath(operation, level, blockIndex) {
-  const transformedOperation = {
-    ...operation
-  };
+  var _a, _b, _c, _d;
+  const transformedOperation = __spreadValues$l({}, 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)];
     transformedOperation.path = newPath;
   }
   if (transformedOperation.type === "set_selection") {
-    const currentFocus = transformedOperation.properties?.focus ? {
-      ...transformedOperation.properties.focus
-    } : void 0, currentAnchor = transformedOperation?.properties?.anchor ? {
-      ...transformedOperation.properties.anchor
-    } : void 0, newFocus = transformedOperation?.newProperties?.focus ? {
-      ...transformedOperation.newProperties.focus
-    } : void 0, newAnchor = transformedOperation?.newProperties?.anchor ? {
-      ...transformedOperation.newProperties.anchor
-    } : void 0;
+    const currentFocus = (_a = transformedOperation.properties) != null && _a.focus ? __spreadValues$l({}, transformedOperation.properties.focus) : void 0, currentAnchor = (_b = transformedOperation == null ? void 0 : transformedOperation.properties) != null && _b.anchor ? __spreadValues$l({}, transformedOperation.properties.anchor) : void 0, newFocus = (_c = transformedOperation == null ? void 0 : transformedOperation.newProperties) != null && _c.focus ? __spreadValues$l({}, transformedOperation.newProperties.focus) : void 0, newAnchor = (_d = transformedOperation == null ? void 0 : transformedOperation.newProperties) != null && _d.anchor ? __spreadValues$l({}, transformedOperation.newProperties.anchor) : void 0;
     (currentFocus && currentAnchor || newFocus && newAnchor) && ([currentFocus, currentAnchor, newFocus, newAnchor].forEach((point) => {
       point && point.path[0] >= blockIndex + level && point.path[0] + level > -1 && (point.path = [point.path[0] + level, ...point.path.slice(1)]);
     }), currentFocus && currentAnchor && (transformedOperation.properties = {
@@ -3080,12 +2202,8 @@ function withoutSaving(editor, fn) {
 function createSelectOperation(editor) {
   return {
     type: "set_selection",
-    properties: {
-      ...editor.selection
-    },
-    newProperties: {
-      ...editor.selection
-    }
+    properties: __spreadValues$l({}, editor.selection),
+    newProperties: __spreadValues$l({}, editor.selection)
   };
 }
 function findOperationTargetBlock(editor, operation) {
@@ -3159,15 +2277,16 @@ function useSyncValue(props) {
                   isChanged = !0;
                 }
                 slateValueFromProps.forEach((currentBlock, currentBlockIndex) => {
+                  var _a, _b, _c, _d, _e;
                   const oldBlock = slateEditor.children[currentBlockIndex];
                   if (oldBlock && !isEqual(currentBlock, oldBlock) && isValid) {
                     const validationValue = [value[currentBlockIndex]], validation = validateValue(validationValue, schemaTypes, editorActor.getSnapshot().context.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) => {
+                    !validation.valid && (_a = validation.resolution) != null && _a.autoResolve && ((_b = validation.resolution) == null ? void 0 : _b.patches.length) > 0 && !readOnly && previousValue.current && previousValue.current !== value && (console.warn(`${validation.resolution.action} for block with _key '${validationValue[0]._key}'. ${(_c = validation.resolution) == null ? void 0 : _c.description}`), validation.resolution.patches.forEach((patch) => {
                       editorActor.send({
                         type: "patch",
                         patch
                       });
-                    })), validation.valid || validation.resolution?.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$i.enabled && debug$i("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$i.enabled && debug$i("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), isChanged = !0) : (editorActor.send({
+                    })), validation.valid || (_d = validation.resolution) != null && _d.autoResolve ? (oldBlock._key === currentBlock._key ? (debug$i.enabled && debug$i("Updating block", oldBlock, currentBlock), _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex)) : (debug$i.enabled && debug$i("Replacing block", oldBlock, currentBlock), _replaceBlock(slateEditor, currentBlock, currentBlockIndex)), isChanged = !0) : (editorActor.send({
                       type: "invalid value",
                       resolution: validation.resolution,
                       value
@@ -3175,7 +2294,7 @@ function useSyncValue(props) {
                   }
                   if (!oldBlock && isValid) {
                     const validationValue_0 = [value[currentBlockIndex]], validation_0 = validateValue(validationValue_0, schemaTypes, editorActor.getSnapshot().context.keyGenerator);
-                    debug$i.enabled && debug$i("Validating and inserting new block in the end of the value", currentBlock), validation_0.valid || validation_0.resolution?.autoResolve ? Transforms.insertNodes(slateEditor, currentBlock, {
+                    debug$i.enabled && debug$i("Validating and inserting new block in the end of the value", currentBlock), validation_0.valid || (_e = validation_0.resolution) != null && _e.autoResolve ? Transforms.insertNodes(slateEditor, currentBlock, {
                       at: [currentBlockIndex]
                     }) : (debug$i("Invalid", validation_0), editorActor.send({
                       type: "invalid value",
@@ -3244,9 +2363,9 @@ function _updateBlock(slateEditor, currentBlock, oldBlock, currentBlockIndex) {
         at: [currentBlockIndex, childIndex]
       }));
     }), currentBlock.children.forEach((currentBlockChild, currentBlockChildIndex) => {
-      const oldBlockChild = oldBlock.children[currentBlockChildIndex], isChildChanged = !isEqual(currentBlockChild, oldBlockChild), isTextChanged = !isEqual(currentBlockChild.text, oldBlockChild?.text), path = [currentBlockIndex, currentBlockChildIndex];
+      const oldBlockChild = oldBlock.children[currentBlockChildIndex], isChildChanged = !isEqual(currentBlockChild, oldBlockChild), isTextChanged = !isEqual(currentBlockChild.text, oldBlockChild == null ? void 0 : oldBlockChild.text), path = [currentBlockIndex, currentBlockChildIndex];
       if (isChildChanged)
-        if (currentBlockChild._key === oldBlockChild?._key) {
+        if (currentBlockChild._key === (oldBlockChild == null ? void 0 : oldBlockChild._key)) {
           debug$i("Updating changed child", currentBlockChild, oldBlockChild), Transforms.setNodes(slateEditor, currentBlockChild, {
             at: path
           });
@@ -3357,6 +2476,14 @@ function _temp(s) {
   return s.context.readOnly;
 }
 Synchronizer.displayName = "Synchronizer";
+var __defProp$k = Object.defineProperty, __defProps$f = Object.defineProperties, __getOwnPropDescs$f = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$k = Object.getOwnPropertySymbols, __hasOwnProp$k = Object.prototype.hasOwnProperty, __propIsEnum$k = Object.prototype.propertyIsEnumerable, __defNormalProp$k = (obj, key, value) => key in obj ? __defProp$k(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$k = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$k.call(b, prop) && __defNormalProp$k(a, prop, b[prop]);
+  if (__getOwnPropSymbols$k)
+    for (var prop of __getOwnPropSymbols$k(b))
+      __propIsEnum$k.call(b, prop) && __defNormalProp$k(a, prop, b[prop]);
+  return a;
+}, __spreadProps$f = (a, b) => __defProps$f(a, __getOwnPropDescs$f(b));
 const debug$g = debugWithName("operationToPatches");
 function createOperationToPatches(types) {
   const textBlockName = types.block.name;
@@ -3396,10 +2523,7 @@ function createOperationToPatches(types) {
       const block = editor.children[operation.path[0]];
       if (typeof block._key != "string")
         throw new Error("Expected block to have a _key");
-      const setNode = omitBy({
-        ...editor.children[operation.path[0]],
-        ...operation.newProperties
-      }, isUndefined);
+      const setNode = omitBy(__spreadValues$k(__spreadValues$k({}, editor.children[operation.path[0]]), operation.newProperties), isUndefined);
       return [set(fromSlateValue([setNode], textBlockName)[0], [{
         _key: block._key
       }])];
@@ -3434,14 +2558,12 @@ function createOperationToPatches(types) {
   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;
+      const position = operation.path[0] === 0 ? "before" : "after", beforeBlock = beforeValue[operation.path[0] - 1], targetKey = operation.path[0] === 0 ? block == null ? void 0 : block._key : beforeBlock == null ? void 0 : beforeBlock._key;
       return targetKey ? [insert([fromSlateValue([operation.node], textBlockName)[0]], position, [{
         _key: targetKey
       }])] : [setIfMissing(beforeValue, []), 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
-      };
+      const position = block.children.length === 0 || !block.children[operation.path[1] - 1] ? "before" : "after", node = __spreadValues$k({}, operation.node);
       !node._type && Text.isText(node) && (node._type = "span", node.marks = []);
       const child = fromSlateValue([{
         _key: "bogus",
@@ -3480,10 +2602,9 @@ function createOperationToPatches(types) {
     if (operation.path.length === 2) {
       const splitSpan = splitBlock.children[operation.path[1]];
       if (editor.isTextSpan(splitSpan)) {
-        const targetSpans = fromSlateValue([{
-          ...splitBlock,
+        const targetSpans = fromSlateValue([__spreadProps$f(__spreadValues$k({}, splitBlock), {
           children: splitBlock.children.slice(operation.path[1] + 1, operation.path[1] + 2)
-        }], textBlockName)[0].children;
+        })], textBlockName)[0].children;
         patches.push(insert(targetSpans, "after", [{
           _key: splitBlock._key
         }, "children", {
@@ -3519,7 +2640,7 @@ function createOperationToPatches(types) {
   function mergeNodePatch(editor, operation, beforeValue) {
     const patches = [], block = beforeValue[operation.path[0]], updatedBlock = editor.children[operation.path[0]];
     if (operation.path.length === 1)
-      if (block?._key) {
+      if (block != null && block._key) {
         const newBlock = fromSlateValue([editor.children[operation.path[0] - 1]], textBlockName)[0];
         patches.push(set(newBlock, [{
           _key: newBlock._key
@@ -3791,6 +2912,7 @@ function createWithMaxBlocks(editorActor) {
       apply: apply2
     } = editor;
     return editor.apply = (operation) => {
+      var _a;
       if (editorActor.getSnapshot().context.readOnly) {
         apply2(operation);
         return;
@@ -3803,11 +2925,19 @@ function createWithMaxBlocks(editorActor) {
         apply2(operation);
         return;
       }
-      const rows = editorActor.getSnapshot().context.maxBlocks ?? -1;
+      const rows = (_a = editorActor.getSnapshot().context.maxBlocks) != null ? _a : -1;
       rows > 0 && editor.children.length >= rows && (operation.type === "insert_node" || operation.type === "split_node") && operation.path.length === 1 || apply2(operation);
     }, editor;
   };
 }
+var __defProp$j = Object.defineProperty, __defProps$e = Object.defineProperties, __getOwnPropDescs$e = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$j = Object.getOwnPropertySymbols, __hasOwnProp$j = Object.prototype.hasOwnProperty, __propIsEnum$j = Object.prototype.propertyIsEnumerable, __defNormalProp$j = (obj, key, value) => key in obj ? __defProp$j(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$j = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$j.call(b, prop) && __defNormalProp$j(a, prop, b[prop]);
+  if (__getOwnPropSymbols$j)
+    for (var prop of __getOwnPropSymbols$j(b))
+      __propIsEnum$j.call(b, prop) && __defNormalProp$j(a, prop, b[prop]);
+  return a;
+}, __spreadProps$e = (a, b) => __defProps$e(a, __getOwnPropDescs$e(b));
 function createWithObjectKeys(editorActor, schemaTypes) {
   return function(editor) {
     const {
@@ -3824,23 +2954,19 @@ function createWithObjectKeys(editorActor, schemaTypes) {
         return;
       }
       if (operation.type === "split_node") {
-        apply2({
-          ...operation,
-          properties: {
-            ...operation.properties,
+        apply2(__spreadProps$e(__spreadValues$j({}, operation), {
+          properties: __spreadProps$e(__spreadValues$j({}, operation.properties), {
             _key: editorActor.getSnapshot().context.keyGenerator()
-          }
-        });
+          })
+        }));
         return;
       }
       if (operation.type === "insert_node" && !Editor.isEditor(operation.node)) {
-        apply2({
-          ...operation,
-          node: {
-            ...operation.node,
+        apply2(__spreadProps$e(__spreadValues$j({}, operation), {
+          node: __spreadProps$e(__spreadValues$j({}, operation.node), {
             _key: editorActor.getSnapshot().context.keyGenerator()
-          }
-        });
+          })
+        }));
         return;
       }
       apply2(operation);
@@ -3877,6 +3003,22 @@ function createWithObjectKeys(editorActor, schemaTypes) {
     }, editor;
   };
 }
+var __defProp$i = Object.defineProperty, __defProps$d = Object.defineProperties, __getOwnPropDescs$d = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$i = Object.getOwnPropertySymbols, __hasOwnProp$i = Object.prototype.hasOwnProperty, __propIsEnum$i = Object.prototype.propertyIsEnumerable, __defNormalProp$i = (obj, key, value) => key in obj ? __defProp$i(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$i = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$i.call(b, prop) && __defNormalProp$i(a, prop, b[prop]);
+  if (__getOwnPropSymbols$i)
+    for (var prop of __getOwnPropSymbols$i(b))
+      __propIsEnum$i.call(b, prop) && __defNormalProp$i(a, prop, b[prop]);
+  return a;
+}, __spreadProps$d = (a, b) => __defProps$d(a, __getOwnPropDescs$d(b)), __objRest$2 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    __hasOwnProp$i.call(source, prop) && exclude.indexOf(prop) < 0 && (target[prop] = source[prop]);
+  if (source != null && __getOwnPropSymbols$i)
+    for (var prop of __getOwnPropSymbols$i(source))
+      exclude.indexOf(prop) < 0 && __propIsEnum$i.call(source, prop) && (target[prop] = source[prop]);
+  return target;
+};
 const debug$f = debugWithName("applyPatches"), debugVerbose$2 = debug$f.enabled && !0;
 function createApplyPatch(schemaTypes) {
   return (editor, patch) => {
@@ -3966,10 +3108,9 @@ function insertPatch(editor, patch, schemaTypes) {
   } = patch;
   if (!targetChild || !targetChildPath)
     return debug$f("Child not found"), !1;
-  const childrenToInsert = targetBlock && toSlateValue([{
-    ...targetBlock,
+  const childrenToInsert = targetBlock && toSlateValue([__spreadProps$d(__spreadValues$i({}, targetBlock), {
     children: items
-  }], {
+  })], {
     schemaTypes
   }, KEY_TO_SLATE_ELEMENT.get(editor)), targetChildIndex = targetChildPath[1], normalizedIdx = position === "after" ? targetChildIndex + 1 : targetChildIndex, childInsertPath = [targetChildPath[0], normalizedIdx];
   return debug$f(`Inserting children at path ${childInsertPath}`), debugState(editor, "before"), childrenToInsert && Element$1.isElement(childrenToInsert[0]) && Transforms.insertNodes(editor, childrenToInsert[0].children, {
@@ -4014,21 +3155,19 @@ function setPatch(editor, patch) {
     return !0;
   } else if (Element$1.isElement(block) && patch.path.length === 1 && blockPath) {
     debug$f("Setting block property");
-    const {
-      children,
-      ...nextRest
-    } = value, {
-      children: prevChildren,
-      ...prevRest
-    } = block || {
+    const _a = value, {
+      children
+    } = _a, nextRest = __objRest$2(_a, [
+      "children"
+    ]), _b = block || {
       children: void 0
-    };
+    }, prevRest = __objRest$2(_b, [
+      "children"
+    ]);
     editor.apply({
       type: "set_node",
       path: blockPath,
-      properties: {
-        ...prevRest
-      },
+      properties: __spreadValues$i({}, prevRest),
       newProperties: nextRest
     }), debug$f("Setting children"), block.children.forEach((c2, cIndex) => {
       editor.apply({
@@ -4045,10 +3184,9 @@ function setPatch(editor, patch) {
     });
   } else if (block && "value" in block) {
     const newVal = applyAll([block.value], [patch])[0];
-    return Transforms.setNodes(editor, {
-      ...block,
+    return Transforms.setNodes(editor, __spreadProps$d(__spreadValues$i({}, block), {
       value: newVal
-    }, {
+    }), {
       at: blockPath
     }), !0;
   }
@@ -4131,7 +3269,7 @@ function findBlockAndChildFromPath(editor, path) {
     block,
     child,
     blockPath,
-    childPath: blockPath?.concat(childIndex)
+    childPath: blockPath == null ? void 0 : blockPath.concat(childIndex)
   } : {
     block,
     blockPath,
@@ -4139,6 +3277,14 @@ function findBlockAndChildFromPath(editor, path) {
     childPath: void 0
   };
 }
+var __defProp$h = Object.defineProperty, __defProps$c = Object.defineProperties, __getOwnPropDescs$c = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$h = Object.getOwnPropertySymbols, __hasOwnProp$h = Object.prototype.hasOwnProperty, __propIsEnum$h = Object.prototype.propertyIsEnumerable, __defNormalProp$h = (obj, key, value) => key in obj ? __defProp$h(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$h = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$h.call(b, prop) && __defNormalProp$h(a, prop, b[prop]);
+  if (__getOwnPropSymbols$h)
+    for (var prop of __getOwnPropSymbols$h(b))
+      __propIsEnum$h.call(b, prop) && __defNormalProp$h(a, prop, b[prop]);
+  return a;
+}, __spreadProps$c = (a, b) => __defProps$c(a, __getOwnPropDescs$c(b));
 const debug$e = debugWithName("plugin:withPatches");
 function createWithPatches({
   editorActor,
@@ -4225,10 +3371,9 @@ function createWithPatches({
       })), editorWasEmpty && patches.length > 0 && (patches = [setIfMissing([], []), ...patches]), patches.length > 0 && patches.forEach((patch) => {
         editorActor.send({
           type: "patch",
-          patch: {
-            ...patch,
+          patch: __spreadProps$c(__spreadValues$h({}, patch), {
             origin: "local"
-          }
+          })
         });
       }), editor;
     }, editor;
@@ -4339,6 +3484,14 @@ function getNextSpan({
     }
   return nextSpan;
 }
+var __defProp$g = Object.defineProperty, __defProps$b = Object.defineProperties, __getOwnPropDescs$b = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$g = Object.getOwnPropertySymbols, __hasOwnProp$g = Object.prototype.hasOwnProperty, __propIsEnum$g = Object.prototype.propertyIsEnumerable, __defNormalProp$g = (obj, key, value) => key in obj ? __defProp$g(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$g = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$g.call(b, prop) && __defNormalProp$g(a, prop, b[prop]);
+  if (__getOwnPropSymbols$g)
+    for (var prop of __getOwnPropSymbols$g(b))
+      __propIsEnum$g.call(b, prop) && __defNormalProp$g(a, prop, b[prop]);
+  return a;
+}, __spreadProps$b = (a, b) => __defProps$b(a, __getOwnPropDescs$b(b));
 const debug$b = debugWithName("plugin:withPortableTextMarkModel");
 function createWithPortableTextMarkModel(editorActor, types) {
   return function(editor) {
@@ -4347,12 +3500,19 @@ function createWithPortableTextMarkModel(editorActor, types) {
       normalizeNode
     } = editor, decorators = types.decorators.map((t) => t.value);
     return editor.normalizeNode = (nodeEntry) => {
+      var _a, _b, _c, _d, _e, _f, _g;
       const [node, path] = nodeEntry;
       if (editor.isTextBlock(node)) {
         const children = Node.children(editor, path);
         for (const [child, childPath] of children) {
           const nextNode = node.children[childPath[1] + 1];
-          if (editor.isTextSpan(child) && editor.isTextSpan(nextNode) && child.marks?.every((mark) => nextNode.marks?.includes(mark)) && nextNode.marks?.every((mark) => child.marks?.includes(mark))) {
+          if (editor.isTextSpan(child) && editor.isTextSpan(nextNode) && (_a = child.marks) != null && _a.every((mark) => {
+            var _a2;
+            return (_a2 = nextNode.marks) == null ? void 0 : _a2.includes(mark);
+          }) && (_b = nextNode.marks) != null && _b.every((mark) => {
+            var _a2;
+            return (_a2 = child.marks) == null ? void 0 : _a2.includes(mark);
+          })) {
             debug$b("Merging spans", JSON.stringify(child, null, 2), JSON.stringify(nextNode, null, 2)), editorActor.send({
               type: "normalizing"
             }), Transforms.mergeNodes(editor, {
@@ -4390,12 +3550,12 @@ function createWithPortableTextMarkModel(editorActor, types) {
         return;
       }
       if (editor.isTextSpan(node)) {
-        const blockPath = Path.parent(path), [block] = Editor.node(editor, blockPath), decorators2 = types.decorators.map((decorator) => decorator.value), annotations = node.marks?.filter((mark) => !decorators2.includes(mark));
+        const blockPath = Path.parent(path), [block] = Editor.node(editor, blockPath), decorators2 = types.decorators.map((decorator) => decorator.value), annotations = (_c = node.marks) == null ? void 0 : _c.filter((mark) => !decorators2.includes(mark));
         if (editor.isTextBlock(block) && node.text === "" && annotations && annotations.length > 0) {
           debug$b("Removing annotations from empty span node"), editorActor.send({
             type: "normalizing"
           }), Transforms.setNodes(editor, {
-            marks: node.marks?.filter((mark) => decorators2.includes(mark))
+            marks: (_d = node.marks) == null ? void 0 : _d.filter((mark) => decorators2.includes(mark))
           }, {
             at: path
           }), editorActor.send({
@@ -4408,7 +3568,10 @@ function createWithPortableTextMarkModel(editorActor, types) {
         const decorators2 = types.decorators.map((decorator) => decorator.value);
         for (const [child, childPath] of 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));
+            const marks = (_e = child.marks) != null ? _e : [], orphanedAnnotations = marks.filter((mark) => {
+              var _a2;
+              return !decorators2.includes(mark) && !((_a2 = node.markDefs) != null && _a2.find((def) => def._key === mark));
+            });
             if (orphanedAnnotations.length > 0) {
               debug$b("Removing orphaned annotations from span node"), editorActor.send({
                 type: "normalizing"
@@ -4426,7 +3589,10 @@ function createWithPortableTextMarkModel(editorActor, types) {
       if (editor.isTextSpan(node)) {
         const blockPath = Path.parent(path), [block] = Editor.node(editor, blockPath);
         if (editor.isTextBlock(block)) {
-          const decorators2 = types.decorators.map((decorator) => decorator.value), marks = node.marks ?? [], orphanedAnnotations = marks.filter((mark) => !decorators2.includes(mark) && !block.markDefs?.find((def) => def._key === mark));
+          const decorators2 = types.decorators.map((decorator) => decorator.value), marks = (_f = node.marks) != null ? _f : [], orphanedAnnotations = marks.filter((mark) => {
+            var _a2;
+            return !decorators2.includes(mark) && !((_a2 = block.markDefs) != null && _a2.find((def) => def._key === mark));
+          });
           if (orphanedAnnotations.length > 0) {
             debug$b("Removing orphaned annotations from span node"), editorActor.send({
               type: "normalizing"
@@ -4442,7 +3608,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         }
       }
       if (editor.isTextBlock(node)) {
-        const markDefs = node.markDefs ?? [], markDefKeys = /* @__PURE__ */ new Set(), newMarkDefs = [];
+        const markDefs = (_g = node.markDefs) != null ? _g : [], markDefKeys = /* @__PURE__ */ new Set(), newMarkDefs = [];
         for (const markDef of markDefs)
           markDefKeys.has(markDef._key) || (markDefKeys.add(markDef._key), newMarkDefs.push(markDef));
         if (markDefs.length !== newMarkDefs.length) {
@@ -4475,6 +3641,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
       }
       normalizeNode(nodeEntry);
     }, editor.apply = (op) => {
+      var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x, _y, _z, _A, _B, _C, _D, _E, _F;
       if (isChangingRemotely(editor)) {
         apply2(op);
         return;
@@ -4492,17 +3659,17 @@ function createWithPortableTextMarkModel(editorActor, types) {
           focus: op.newProperties.focus
         });
         if (previousSelectionIsCollapsed && newSelectionIsCollapsed) {
-          const focusSpan = Array.from(Editor.nodes(editor, {
+          const focusSpan = (_a = Array.from(Editor.nodes(editor, {
             mode: "lowest",
             at: op.properties.focus,
             match: (n) => editor.isTextSpan(n),
             voids: !1
-          }))[0]?.[0], newFocusSpan = Array.from(Editor.nodes(editor, {
+          }))[0]) == null ? void 0 : _a[0], newFocusSpan = (_b = Array.from(Editor.nodes(editor, {
             mode: "lowest",
             at: op.newProperties.focus,
             match: (n) => editor.isTextSpan(n),
             voids: !1
-          }))[0]?.[0], movedToNextSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] + 1 && focusSpan.text.length === op.properties.focus.offset && op.newProperties.focus.offset === 0, movedToPreviousSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] - 1 && op.properties.focus.offset === 0 && newFocusSpan.text.length === op.newProperties.focus.offset;
+          }))[0]) == null ? void 0 : _b[0], movedToNextSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] + 1 && focusSpan.text.length === op.properties.focus.offset && op.newProperties.focus.offset === 0, movedToPreviousSpan = focusSpan && newFocusSpan && op.newProperties.focus.path[0] === op.properties.focus.path[0] && op.newProperties.focus.path[1] === op.properties.focus.path[1] - 1 && op.properties.focus.offset === 0 && newFocusSpan.text.length === op.newProperties.focus.offset;
           if (movedToNextSpan || movedToPreviousSpan)
             return;
         }
@@ -4518,32 +3685,29 @@ function createWithPortableTextMarkModel(editorActor, types) {
             editor,
             blockPath,
             spanPath: op.path
-          }), previousSpanAnnotations = previousSpan ? previousSpan.marks?.filter((mark) => !decorators.includes(mark)) : [], nextSpan = getNextSpan({
+          }), previousSpanAnnotations = previousSpan ? (_c = previousSpan.marks) == null ? void 0 : _c.filter((mark) => !decorators.includes(mark)) : [], nextSpan = getNextSpan({
             editor,
             blockPath,
             spanPath: [op.path[0], op.path[1] - 1]
-          }), nextSpanAnnotations = nextSpan ? nextSpan.marks?.filter((mark) => !decorators.includes(mark)) : [], annotationsEnding = previousSpanAnnotations?.filter((annotation) => !nextSpanAnnotations?.includes(annotation)) ?? [], atTheEndOfAnnotation = annotationsEnding.length > 0;
-          if (atTheEndOfAnnotation && isPortableTextSpan(op.node) && op.node.marks?.some((mark) => annotationsEnding.includes(mark))) {
-            Transforms.insertNodes(editor, {
-              ...op.node,
-              marks: op.node.marks?.filter((mark) => !annotationsEnding.includes(mark)) ?? []
-            });
+          }), nextSpanAnnotations = nextSpan ? (_d = nextSpan.marks) == null ? void 0 : _d.filter((mark) => !decorators.includes(mark)) : [], annotationsEnding = (_e = previousSpanAnnotations == null ? void 0 : previousSpanAnnotations.filter((annotation) => !(nextSpanAnnotations != null && nextSpanAnnotations.includes(annotation)))) != null ? _e : [], atTheEndOfAnnotation = annotationsEnding.length > 0;
+          if (atTheEndOfAnnotation && isPortableTextSpan(op.node) && (_f = op.node.marks) != null && _f.some((mark) => annotationsEnding.includes(mark))) {
+            Transforms.insertNodes(editor, __spreadProps$b(__spreadValues$g({}, op.node), {
+              marks: (_h = (_g = op.node.marks) == null ? void 0 : _g.filter((mark) => !annotationsEnding.includes(mark))) != null ? _h : []
+            }));
             return;
           }
-          const annotationsStarting = nextSpanAnnotations?.filter((annotation) => !previousSpanAnnotations?.includes(annotation)) ?? [], atTheStartOfAnnotation = annotationsStarting.length > 0;
-          if (atTheStartOfAnnotation && isPortableTextSpan(op.node) && op.node.marks?.some((mark) => annotationsStarting.includes(mark))) {
-            Transforms.insertNodes(editor, {
-              ...op.node,
-              marks: op.node.marks?.filter((mark) => !annotationsStarting.includes(mark)) ?? []
-            });
+          const annotationsStarting = (_i = nextSpanAnnotations == null ? void 0 : nextSpanAnnotations.filter((annotation) => !(previousSpanAnnotations != null && previousSpanAnnotations.includes(annotation)))) != null ? _i : [], atTheStartOfAnnotation = annotationsStarting.length > 0;
+          if (atTheStartOfAnnotation && isPortableTextSpan(op.node) && (_j = op.node.marks) != null && _j.some((mark) => annotationsStarting.includes(mark))) {
+            Transforms.insertNodes(editor, __spreadProps$b(__spreadValues$g({}, op.node), {
+              marks: (_l = (_k = op.node.marks) == null ? void 0 : _k.filter((mark) => !annotationsStarting.includes(mark))) != null ? _l : []
+            }));
             return;
           }
-          const nextSpanDecorators = nextSpan?.marks?.filter((mark) => decorators.includes(mark)) ?? [];
-          if (nextSpanDecorators.length > 0 && atTheEndOfAnnotation && !atTheStartOfAnnotation && isPortableTextSpan(op.node) && op.node.marks?.length === 0) {
-            Transforms.insertNodes(editor, {
-              ...op.node,
+          const nextSpanDecorators = (_n = (_m = nextSpan == null ? void 0 : nextSpan.marks) == null ? void 0 : _m.filter((mark) => decorators.includes(mark))) != null ? _n : [];
+          if (nextSpanDecorators.length > 0 && atTheEndOfAnnotation && !atTheStartOfAnnotation && isPortableTextSpan(op.node) && ((_o = op.node.marks) == null ? void 0 : _o.length) === 0) {
+            Transforms.insertNodes(editor, __spreadProps$b(__spreadValues$g({}, op.node), {
               marks: nextSpanDecorators
-            });
+            }));
             return;
           }
         }
@@ -4555,12 +3719,12 @@ function createWithPortableTextMarkModel(editorActor, types) {
         if (selection && collapsedSelection) {
           const [_block, blockPath] = Editor.node(editor, selection, {
             depth: 1
-          }), [span, spanPath] = Array.from(Editor.nodes(editor, {
+          }), [span, spanPath] = (_p = Array.from(Editor.nodes(editor, {
             mode: "lowest",
             at: selection.focus,
             match: (n) => editor.isTextSpan(n),
             voids: !1
-          }))[0] ?? [void 0, void 0], marks = span.marks ?? [], marksWithoutAnnotations = marks.filter((mark) => decorators.includes(mark)), spanHasAnnotations = marks.length > marksWithoutAnnotations.length, spanIsEmpty = span.text.length === 0, atTheBeginningOfSpan = selection.anchor.offset === 0, atTheEndOfSpan = selection.anchor.offset === span.text.length, previousSpan = getPreviousSpan({
+          }))[0]) != null ? _p : [void 0, void 0], marks = (_q = span.marks) != null ? _q : [], marksWithoutAnnotations = marks.filter((mark) => decorators.includes(mark)), spanHasAnnotations = marks.length > marksWithoutAnnotations.length, spanIsEmpty = span.text.length === 0, atTheBeginningOfSpan = selection.anchor.offset === 0, atTheEndOfSpan = selection.anchor.offset === span.text.length, previousSpan = getPreviousSpan({
             editor,
             blockPath,
             spanPath
@@ -4568,7 +3732,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
             editor,
             blockPath,
             spanPath
-          }), nextSpanAnnotations = nextSpan?.marks?.filter((mark) => !decorators.includes(mark)) ?? [], spanAnnotations = marks.filter((mark) => !decorators.includes(mark)), previousSpanHasAnnotations = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark)) : !1, previousSpanHasSameAnnotations = previousSpan ? previousSpan.marks?.filter((mark) => !decorators.includes(mark)).every((mark) => marks.includes(mark)) : !1, previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, previousSpanHasSameMarks = previousSpan ? previousSpan.marks?.every((mark) => marks.includes(mark)) : !1, nextSpanSharesSomeAnnotations = spanAnnotations.some((mark) => nextSpanAnnotations?.includes(mark));
+          }), nextSpanAnnotations = (_s = (_r = nextSpan == null ? void 0 : nextSpan.marks) == null ? void 0 : _r.filter((mark) => !decorators.includes(mark))) != null ? _s : [], spanAnnotations = marks.filter((mark) => !decorators.includes(mark)), previousSpanHasAnnotations = previousSpan ? (_t = previousSpan.marks) == null ? void 0 : _t.some((mark) => !decorators.includes(mark)) : !1, previousSpanHasSameAnnotations = previousSpan ? (_u = previousSpan.marks) == null ? void 0 : _u.filter((mark) => !decorators.includes(mark)).every((mark) => marks.includes(mark)) : !1, previousSpanHasSameAnnotation = previousSpan ? (_v = previousSpan.marks) == null ? void 0 : _v.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, previousSpanHasSameMarks = previousSpan ? (_w = previousSpan.marks) == null ? void 0 : _w.every((mark) => marks.includes(mark)) : !1, nextSpanSharesSomeAnnotations = spanAnnotations.some((mark) => nextSpanAnnotations == null ? void 0 : nextSpanAnnotations.includes(mark));
           if (spanHasAnnotations && !spanIsEmpty) {
             if (atTheBeginningOfSpan) {
               if (previousSpanHasSameMarks) {
@@ -4576,7 +3740,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
                   _type: "span",
                   _key: editorActor.getSnapshot().context.keyGenerator(),
                   text: op.text,
-                  marks: previousSpan?.marks ?? []
+                  marks: (_x = previousSpan == null ? void 0 : previousSpan.marks) != null ? _x : []
                 });
                 return;
               } else if (previousSpanHasSameAnnotations) {
@@ -4584,7 +3748,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
                   _type: "span",
                   _key: editorActor.getSnapshot().context.keyGenerator(),
                   text: op.text,
-                  marks: previousSpan?.marks ?? []
+                  marks: (_y = previousSpan == null ? void 0 : previousSpan.marks) != null ? _y : []
                 });
                 return;
               } else if (previousSpanHasSameAnnotation) {
@@ -4606,7 +3770,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
                   _type: "span",
                   _key: editorActor.getSnapshot().context.keyGenerator(),
                   text: op.text,
-                  marks: nextSpan?.marks ?? []
+                  marks: (_z = nextSpan == null ? void 0 : nextSpan.marks) != null ? _z : []
                 });
                 return;
               }
@@ -4626,7 +3790,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
               _type: "span",
               _key: editorActor.getSnapshot().context.keyGenerator(),
               text: op.text,
-              marks: previousSpanHasAnnotations ? [] : (previousSpan.marks ?? []).filter((mark) => decorators.includes(mark))
+              marks: previousSpanHasAnnotations ? [] : ((_A = previousSpan.marks) != null ? _A : []).filter((mark) => decorators.includes(mark))
             });
             return;
           }
@@ -4639,7 +3803,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
         if (selection && Range.isExpanded(selection)) {
           const [block, blockPath] = Editor.node(editor, selection, {
             depth: 1
-          }), [span, spanPath] = Array.from(Editor.nodes(editor, {
+          }), [span, spanPath] = (_B = Array.from(Editor.nodes(editor, {
             mode: "lowest",
             at: {
               path: op.path,
@@ -4647,9 +3811,9 @@ function createWithPortableTextMarkModel(editorActor, types) {
             },
             match: (n) => editor.isTextSpan(n),
             voids: !1
-          }))[0] ?? [void 0, void 0];
+          }))[0]) != null ? _B : [void 0, void 0];
           if (span && block && isPortableTextBlock(block)) {
-            const markDefs = block.markDefs ?? [], marks = span.marks ?? [], spanHasAnnotations = marks.some((mark) => markDefs.find((markDef) => markDef._key === mark)), deletingFromTheEnd = op.offset + op.text.length === span.text.length, deletingAllText = op.offset === 0 && deletingFromTheEnd, previousSpan = getPreviousSpan({
+            const markDefs = (_C = block.markDefs) != null ? _C : [], marks = (_D = span.marks) != null ? _D : [], spanHasAnnotations = marks.some((mark) => markDefs.find((markDef) => markDef._key === mark)), deletingFromTheEnd = op.offset + op.text.length === span.text.length, deletingAllText = op.offset === 0 && deletingFromTheEnd, previousSpan = getPreviousSpan({
               editor,
               blockPath,
               spanPath
@@ -4657,11 +3821,9 @@ function createWithPortableTextMarkModel(editorActor, types) {
               editor,
               blockPath,
               spanPath
-            }), previousSpanHasSameAnnotation = previousSpan ? previousSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, nextSpanHasSameAnnotation = nextSpan ? nextSpan.marks?.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1;
+            }), previousSpanHasSameAnnotation = previousSpan ? (_E = previousSpan.marks) == null ? void 0 : _E.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1, nextSpanHasSameAnnotation = nextSpan ? (_F = nextSpan.marks) == null ? void 0 : _F.some((mark) => !decorators.includes(mark) && marks.includes(mark)) : !1;
             if (spanHasAnnotations && deletingAllText && !previousSpanHasSameAnnotation && !nextSpanHasSameAnnotation) {
-              const marksWithoutAnnotationMarks = ({
-                ...Editor.marks(editor) || {}
-              }.marks || []).filter((mark) => decorators.includes(mark));
+              const marksWithoutAnnotationMarks = (__spreadValues$g({}, Editor.marks(editor) || {}).marks || []).filter((mark) => decorators.includes(mark));
               Editor.withoutNormalizing(editor, () => {
                 apply2(op), Transforms.setNodes(editor, {
                   marks: marksWithoutAnnotationMarks
@@ -4694,6 +3856,7 @@ function createWithPortableTextMarkModel(editorActor, types) {
 const addDecoratorActionImplementation = ({
   action
 }) => {
+  var _a;
   const editor = action.editor, mark = action.decorator;
   if (editor.selection) {
     if (Range.isExpanded(editor.selection)) {
@@ -4706,7 +3869,10 @@ const addDecoratorActionImplementation = ({
         at: editor.selection,
         match: Text.isText
       })] : [];
-      splitTextNodes.length > 1 && splitTextNodes.every((node) => node[0].marks?.includes(mark)) ? editor.removeMark(mark) : splitTextNodes.forEach(([node, path]) => {
+      splitTextNodes.length > 1 && splitTextNodes.every((node) => {
+        var _a2;
+        return (_a2 = node[0].marks) == null ? void 0 : _a2.includes(mark);
+      }) ? editor.removeMark(mark) : splitTextNodes.forEach(([node, path]) => {
         const marks = [...(Array.isArray(node.marks) ? node.marks : []).filter((eMark) => eMark !== mark), mark];
         Transforms.setNodes(editor, {
           marks
@@ -4722,7 +3888,7 @@ const addDecoratorActionImplementation = ({
         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);
+        const existingMarks = (_a = lonelyEmptySpan.marks) != null ? _a : [], existingMarksWithoutDecorator = existingMarks.filter((existingMark) => existingMark !== mark);
         Transforms.setNodes(editor, {
           marks: existingMarks.length === existingMarksWithoutDecorator.length ? [...existingMarks, mark] : existingMarksWithoutDecorator
         }, {
@@ -4730,12 +3896,9 @@ const addDecoratorActionImplementation = ({
           match: (node) => editor.isTextSpan(node)
         });
       } else {
-        const existingMarks = {
-          ...Editor.marks(editor) || {}
-        }.marks || [], marks = {
-          ...Editor.marks(editor) || {},
+        const existingMarks = __spreadValues$g({}, Editor.marks(editor) || {}).marks || [], marks = __spreadProps$b(__spreadValues$g({}, Editor.marks(editor) || {}), {
           marks: [...existingMarks, mark]
-        };
+        });
         editor.marks = marks;
       }
     }
@@ -4744,6 +3907,7 @@ const addDecoratorActionImplementation = ({
 }, removeDecoratorActionImplementation = ({
   action
 }) => {
+  var _a;
   const editor = action.editor, mark = action.decorator, {
     selection
   } = editor;
@@ -4770,7 +3934,7 @@ const addDecoratorActionImplementation = ({
         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);
+        const existingMarksWithoutDecorator = ((_a = lonelyEmptySpan.marks) != null ? _a : []).filter((existingMark) => existingMark !== mark);
         Transforms.setNodes(editor, {
           marks: existingMarksWithoutDecorator
         }, {
@@ -4778,12 +3942,9 @@ const addDecoratorActionImplementation = ({
           match: (node) => editor.isTextSpan(node)
         });
       } else {
-        const existingMarks = {
-          ...Editor.marks(editor) || {}
-        }.marks || [], marks = {
-          ...Editor.marks(editor) || {},
+        const existingMarks = __spreadValues$g({}, Editor.marks(editor) || {}).marks || [], marks = __spreadProps$b(__spreadValues$g({}, Editor.marks(editor) || {}), {
           marks: existingMarks.filter((eMark) => eMark !== mark)
-        };
+        });
         editor.marks = {
           marks: marks.marks,
           _type: "span"
@@ -4802,11 +3963,10 @@ function isDecoratorActive({
     at: editor.selection
   }));
   return selectedTextNodes.length === 0 ? !1 : Range.isExpanded(editor.selection) ? selectedTextNodes.every((n) => {
+    var _a;
     const [node] = n;
-    return node.marks?.includes(decorator);
-  }) : ({
-    ...Editor.marks(editor) || {}
-  }.marks || []).includes(decorator);
+    return (_a = node.marks) == null ? void 0 : _a.includes(decorator);
+  }) : (__spreadValues$g({}, Editor.marks(editor) || {}).marks || []).includes(decorator);
 }
 const toggleDecoratorActionImplementation = ({
   context,
@@ -4864,6 +4024,14 @@ function createWithPortableTextSelections(editorActor, types) {
     }, editor;
   };
 }
+var __defProp$f = Object.defineProperty, __defProps$a = Object.defineProperties, __getOwnPropDescs$a = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$f = Object.getOwnPropertySymbols, __hasOwnProp$f = Object.prototype.hasOwnProperty, __propIsEnum$f = Object.prototype.propertyIsEnumerable, __defNormalProp$f = (obj, key, value) => key in obj ? __defProp$f(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$f = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$f.call(b, prop) && __defNormalProp$f(a, prop, b[prop]);
+  if (__getOwnPropSymbols$f)
+    for (var prop of __getOwnPropSymbols$f(b))
+      __propIsEnum$f.call(b, prop) && __defNormalProp$f(a, prop, b[prop]);
+  return a;
+}, __spreadProps$a = (a, b) => __defProps$a(a, __getOwnPropDescs$a(b));
 const debug$9 = debugWithName("plugin:withSchemaTypes");
 function createWithSchemaTypes({
   editorActor,
@@ -4881,11 +4049,10 @@ function createWithSchemaTypes({
         const span = node, key = span._key || editorActor.getSnapshot().context.keyGenerator();
         editorActor.send({
           type: "normalizing"
-        }), Transforms.setNodes(editor, {
-          ...span,
+        }), Transforms.setNodes(editor, __spreadProps$a(__spreadValues$f({}, span), {
           _type: schemaTypes.span.name,
           _key: key
-        }, {
+        }), {
           at: path
         }), editorActor.send({
           type: "done normalizing"
@@ -4910,6 +4077,14 @@ function createWithSchemaTypes({
     }, editor;
   };
 }
+var __defProp$e = Object.defineProperty, __defProps$9 = Object.defineProperties, __getOwnPropDescs$9 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$e = Object.getOwnPropertySymbols, __hasOwnProp$e = Object.prototype.hasOwnProperty, __propIsEnum$e = Object.prototype.propertyIsEnumerable, __defNormalProp$e = (obj, key, value) => key in obj ? __defProp$e(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$e = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$e.call(b, prop) && __defNormalProp$e(a, prop, b[prop]);
+  if (__getOwnPropSymbols$e)
+    for (var prop of __getOwnPropSymbols$e(b))
+      __propIsEnum$e.call(b, prop) && __defNormalProp$e(a, prop, b[prop]);
+  return a;
+}, __spreadProps$9 = (a, b) => __defProps$9(a, __getOwnPropDescs$9(b));
 const debug$8 = debugWithName("plugin:withUtils");
 function createWithUtils({
   editorActor,
@@ -4933,29 +4108,26 @@ function createWithUtils({
         } = selection, focusOffset = focus.offset, charsBefore = textNode.text.slice(0, focusOffset), charsAfter = textNode.text.slice(focusOffset, -1), isEmpty = (str) => str.match(/\s/g), whiteSpaceBeforeIndex = charsBefore.split("").reverse().findIndex((str) => isEmpty(str)), newStartOffset = whiteSpaceBeforeIndex > -1 ? charsBefore.length - whiteSpaceBeforeIndex : 0, whiteSpaceAfterIndex = charsAfter.split("").findIndex((obj) => isEmpty(obj)), newEndOffset = charsBefore.length + (whiteSpaceAfterIndex > -1 ? whiteSpaceAfterIndex : charsAfter.length + 1);
         if (!(newStartOffset === newEndOffset || Number.isNaN(newStartOffset) || Number.isNaN(newEndOffset))) {
           debug$8("pteExpandToWord: Expanding to focused word"), Transforms.setSelection(editor, {
-            anchor: {
-              ...selection.anchor,
+            anchor: __spreadProps$9(__spreadValues$e({}, selection.anchor), {
               offset: newStartOffset
-            },
-            focus: {
-              ...selection.focus,
+            }),
+            focus: __spreadProps$9(__spreadValues$e({}, selection.focus), {
               offset: newEndOffset
-            }
+            })
           });
           return;
         }
         debug$8("pteExpandToWord: Can't expand to word here");
       }
-    }, editor.pteCreateTextBlock = (options) => toSlateValue([{
+    }, editor.pteCreateTextBlock = (options) => toSlateValue([__spreadProps$9(__spreadValues$e(__spreadValues$e({
       _type: schemaTypes.block.name,
       _key: editorActor.getSnapshot().context.keyGenerator(),
-      style: schemaTypes.styles[0].value || "normal",
-      ...options.listItem ? {
-        listItem: options.listItem
-      } : {},
-      ...options.level ? {
-        level: options.level
-      } : {},
+      style: schemaTypes.styles[0].value || "normal"
+    }, options.listItem ? {
+      listItem: options.listItem
+    } : {}), options.level ? {
+      level: options.level
+    } : {}), {
       markDefs: [],
       children: [{
         _type: "span",
@@ -4965,7 +4137,7 @@ function createWithUtils({
           value
         }) => value === decorator))
       }]
-    }], {
+    })], {
       schemaTypes
     })[0], editor;
   };
@@ -5011,6 +4183,14 @@ function createSlateEditor(config) {
   };
   return slateEditors.set(config.editorActor, slateEditor), slateEditor;
 }
+var __defProp$d = Object.defineProperty, __defProps$8 = Object.defineProperties, __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$d = Object.getOwnPropertySymbols, __hasOwnProp$d = Object.prototype.hasOwnProperty, __propIsEnum$d = Object.prototype.propertyIsEnumerable, __defNormalProp$d = (obj, key, value) => key in obj ? __defProp$d(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$d = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$d.call(b, prop) && __defNormalProp$d(a, prop, b[prop]);
+  if (__getOwnPropSymbols$d)
+    for (var prop of __getOwnPropSymbols$d(b))
+      __propIsEnum$d.call(b, prop) && __defNormalProp$d(a, prop, b[prop]);
+  return a;
+}, __spreadProps$8 = (a, b) => __defProps$8(a, __getOwnPropDescs$8(b));
 const toggleListItemActionImplementation = ({
   context,
   action
@@ -5020,16 +4200,14 @@ const toggleListItemActionImplementation = ({
     listItem: action.listItem
   }) ? removeListItemActionImplementation({
     context,
-    action: {
-      ...action,
+    action: __spreadProps$8(__spreadValues$d({}, action), {
       type: "list item.remove"
-    }
+    })
   }) : addListItemActionImplementation({
     context,
-    action: {
-      ...action,
+    action: __spreadProps$8(__spreadValues$d({}, action), {
       type: "list item.add"
-    }
+    })
   });
 }, removeListItemActionImplementation = ({
   context,
@@ -5075,6 +4253,14 @@ function isListItemActive({
   })];
   return selectedBlocks.length > 0 ? selectedBlocks.every(([node]) => editor.isListBlock(node) && node.listItem === listItem) : !1;
 }
+var __defProp$c = Object.defineProperty, __defProps$7 = Object.defineProperties, __getOwnPropDescs$7 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$c = Object.getOwnPropertySymbols, __hasOwnProp$c = Object.prototype.hasOwnProperty, __propIsEnum$c = Object.prototype.propertyIsEnumerable, __defNormalProp$c = (obj, key, value) => key in obj ? __defProp$c(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$c = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$c.call(b, prop) && __defNormalProp$c(a, prop, b[prop]);
+  if (__getOwnPropSymbols$c)
+    for (var prop of __getOwnPropSymbols$c(b))
+      __propIsEnum$c.call(b, prop) && __defNormalProp$c(a, prop, b[prop]);
+  return a;
+}, __spreadProps$7 = (a, b) => __defProps$7(a, __getOwnPropDescs$7(b));
 const toggleStyleActionImplementation = ({
   context,
   action
@@ -5084,16 +4270,14 @@ const toggleStyleActionImplementation = ({
     style: action.style
   }) ? removeStyleActionImplementation({
     context,
-    action: {
-      ...action,
+    action: __spreadProps$7(__spreadValues$c({}, action), {
       type: "style.remove"
-    }
+    })
   }) : addStyleActionImplementation({
     context,
-    action: {
-      ...action,
+    action: __spreadProps$7(__spreadValues$c({}, action), {
       type: "style.add"
-    }
+    })
   });
 }, removeStyleActionImplementation = ({
   context,
@@ -5140,6 +4324,14 @@ function isStyleActive({
   })];
   return selectedBlocks.length > 0 ? selectedBlocks.every(([node]) => node.style === style) : !1;
 }
+var __defProp$b = Object.defineProperty, __getOwnPropSymbols$b = Object.getOwnPropertySymbols, __hasOwnProp$b = Object.prototype.hasOwnProperty, __propIsEnum$b = Object.prototype.propertyIsEnumerable, __defNormalProp$b = (obj, key, value) => key in obj ? __defProp$b(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$b = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$b.call(b, prop) && __defNormalProp$b(a, prop, b[prop]);
+  if (__getOwnPropSymbols$b)
+    for (var prop of __getOwnPropSymbols$b(b))
+      __propIsEnum$b.call(b, prop) && __defNormalProp$b(a, prop, b[prop]);
+  return a;
+};
 const debug$6 = debugWithName("API:editable");
 function createEditableAPI(editor, editorActor) {
   const types = editorActor.getSnapshot().context.schema;
@@ -5202,9 +4394,7 @@ function createEditableAPI(editor, editorActor) {
         return console.warn(err), !1;
       }
     },
-    marks: () => ({
-      ...Editor.marks(editor) || {}
-    }).marks || [],
+    marks: () => __spreadValues$b({}, Editor.marks(editor) || {}).marks || [],
     undo: () => editor.undo(),
     redo: () => editor.redo(),
     select: (selection) => {
@@ -5226,6 +4416,7 @@ function createEditableAPI(editor, editorActor) {
       }
     },
     insertChild: (type, value) => {
+      var _a, _b, _c;
       if (type.name !== types.span.name)
         return editorActor.send({
           type: "behavior event",
@@ -5237,7 +4428,7 @@ function createEditableAPI(editor, editorActor) {
             }
           },
           editor
-        }), toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types)?.focus.path ?? [];
+        }), (_b = (_a = toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types)) == null ? void 0 : _a.focus.path) != null ? _b : [];
       if (!editor.selection)
         throw new Error("The editor has no selection");
       const [focusBlock] = Array.from(Editor.nodes(editor, {
@@ -5251,11 +4442,10 @@ function createEditableAPI(editor, editorActor) {
       const child = toSlateValue([{
         _key: editorActor.getSnapshot().context.keyGenerator(),
         _type: types.block.name,
-        children: [{
+        children: [__spreadValues$b({
           _key: editorActor.getSnapshot().context.keyGenerator(),
-          _type: type.name,
-          ...value || {}
-        }]
+          _type: type.name
+        }, value || {})]
       }], {
         schemaTypes: editorActor.getSnapshot().context.schema
       })[0].children[0], focusChildPath = editor.selection.focus.path.slice(0, 2), isSpanNode = child._type === types.span.name, focusNode = Node.get(editor, focusChildPath);
@@ -5265,27 +4455,30 @@ function createEditableAPI(editor, editorActor) {
       })), Transforms.insertNodes(editor, child, {
         select: !0,
         at: editor.selection
-      }), editor.onChange(), toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types)?.focus.path || [];
+      }), editor.onChange(), ((_c = toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types)) == null ? void 0 : _c.focus.path) || [];
     },
-    insertBlock: (type, value) => (editorActor.send({
-      type: "behavior event",
-      behaviorEvent: {
-        type: "insert.block object",
-        blockObject: {
-          name: type.name,
-          value
+    insertBlock: (type, value) => {
+      var _a, _b;
+      return editorActor.send({
+        type: "behavior event",
+        behaviorEvent: {
+          type: "insert.block object",
+          blockObject: {
+            name: type.name,
+            value
+          },
+          placement: "auto"
         },
-        placement: "auto"
-      },
-      editor
-    }), toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types)?.focus.path ?? []),
+        editor
+      }), (_b = (_a = toPortableTextRange(fromSlateValue(editor.children, types.block.name, KEY_TO_VALUE_ELEMENT.get(editor)), editor.selection, types)) == null ? void 0 : _a.focus.path) != null ? _b : [];
+    },
     hasBlockStyle: (style) => {
       try {
         return isStyleActive({
           editor,
           style
         });
-      } catch {
+      } catch (e) {
         return !1;
       }
     },
@@ -5295,7 +4488,7 @@ function createEditableAPI(editor, editorActor) {
           editor,
           listItem
         });
-      } catch {
+      } catch (e) {
         return !1;
       }
     },
@@ -5340,11 +4533,12 @@ function createEditableAPI(editor, editorActor) {
           match: (n) => n._key === element._key
         }) || [])[0] || [void 0];
         node = ReactEditor.toDOMNode(editor, item);
-      } catch {
+      } catch (e) {
       }
       return node;
     },
     activeAnnotations: () => {
+      var _a;
       if (!editor.selection || editor.selection.focus.path.length < 2)
         return [];
       try {
@@ -5356,12 +4550,12 @@ function createEditableAPI(editor, editorActor) {
           const [block] = Editor.node(editor, path, {
             depth: 1
           });
-          editor.isTextBlock(block) && block.markDefs?.forEach((def) => {
+          editor.isTextBlock(block) && ((_a = block.markDefs) == null || _a.forEach((def) => {
             Text.isText(span) && span.marks && Array.isArray(span.marks) && span.marks.includes(def._key) && activeAnnotations.push(def);
-          });
+          }));
         }
         return activeAnnotations;
-      } catch {
+      } catch (e) {
         return [];
       }
     },
@@ -5383,7 +4577,7 @@ function createEditableAPI(editor, editorActor) {
             type: "annotation.add",
             annotation: {
               name: type.name,
-              value: value ?? {}
+              value: value != null ? value : {}
             },
             editor
           }
@@ -5396,7 +4590,7 @@ function createEditableAPI(editor, editorActor) {
         if (!(range && range.anchor.path.length > 0 && range.focus.path.length > 0))
           throw new Error("Invalid range");
         if (range) {
-          if (!options?.mode || options?.mode === "selected") {
+          if (!(options != null && options.mode) || (options == null ? void 0 : options.mode) === "selected") {
             debug$6("Deleting content in selection"), Transforms.delete(editor, {
               at: range,
               hanging: !0,
@@ -5404,11 +4598,11 @@ function createEditableAPI(editor, editorActor) {
             }), editor.onChange();
             return;
           }
-          options?.mode === "blocks" && (debug$6("Deleting blocks touched by selection"), Transforms.removeNodes(editor, {
+          (options == null ? void 0 : options.mode) === "blocks" && (debug$6("Deleting blocks touched by selection"), Transforms.removeNodes(editor, {
             at: range,
             voids: !0,
             match: (node) => editor.isTextBlock(node) || !editor.isTextBlock(node) && Element$1.isElement(node)
-          })), options?.mode === "children" && (debug$6("Deleting children touched by selection"), Transforms.removeNodes(editor, {
+          })), (options == null ? void 0 : options.mode) === "children" && (debug$6("Deleting children touched by selection"), Transforms.removeNodes(editor, {
             at: range,
             voids: !0,
             match: (node) => node._type === types.span.name || // Text children
@@ -5465,15 +4659,26 @@ function isAnnotationActive({
       at: editor.selection,
       match: (node) => Text.isText(node)
     })];
-    if (spans.length === 0 || spans.some(([span]) => !isPortableTextSpan$1(span) || !span.marks || span.marks?.length === 0)) return !1;
+    if (spans.length === 0 || spans.some(([span]) => {
+      var _a;
+      return !isPortableTextSpan$1(span) || !span.marks || ((_a = span.marks) == null ? void 0 : _a.length) === 0;
+    })) return !1;
     const selectionMarkDefs = spans.reduce((accMarkDefs, [, path]) => {
       const [block] = Editor.node(editor, path, {
         depth: 1
       });
       return editor.isTextBlock(block) && block.markDefs ? [...accMarkDefs, ...block.markDefs] : accMarkDefs;
     }, []);
-    return spans.every(([span]) => isPortableTextSpan$1(span) ? span.marks?.map((markKey) => selectionMarkDefs.find((def) => def?._key === markKey)?._type)?.includes(annotation.name) : !1);
-  } catch {
+    return spans.every(([span]) => {
+      var _a;
+      if (!isPortableTextSpan$1(span)) return !1;
+      const spanMarkDefs = (_a = span.marks) == null ? void 0 : _a.map((markKey) => {
+        var _a2;
+        return (_a2 = selectionMarkDefs.find((def) => (def == null ? void 0 : def._key) === markKey)) == null ? void 0 : _a2._type;
+      });
+      return spanMarkDefs == null ? void 0 : spanMarkDefs.includes(annotation.name);
+    });
+  } catch (e) {
     return !1;
   }
 }
@@ -5481,6 +4686,7 @@ const addAnnotationActionImplementation = ({
   context,
   action
 }) => {
+  var _a, _b;
   const editor = action.editor, {
     selection: originalSelection
   } = editor;
@@ -5498,13 +4704,12 @@ const addAnnotationActionImplementation = ({
     for (const [block, blockPath] of selectedBlocks) {
       if (block.children.length === 0 || block.children.length === 1 && block.children[0].text === "")
         continue;
-      const annotationKey = context.keyGenerator(), markDefs = block.markDefs ?? [];
+      const annotationKey = context.keyGenerator(), markDefs = (_a = block.markDefs) != null ? _a : [];
       markDefs.find((markDef) => markDef._type === action.annotation.name && markDef._key === annotationKey) === void 0 && (Transforms.setNodes(editor, {
-        markDefs: [...markDefs, {
+        markDefs: [...markDefs, __spreadValues$b({
           _type: action.annotation.name,
-          _key: annotationKey,
-          ...action.annotation.value
-        }]
+          _key: annotationKey
+        }, action.annotation.value)]
       }, {
         at: blockPath
       }), markDefPath = [{
@@ -5519,7 +4724,7 @@ const addAnnotationActionImplementation = ({
       for (const [span, path] of children) {
         if (!editor.isTextSpan(span) || !Range.includes(editor.selection, path))
           continue;
-        const marks = span.marks ?? [], existingSameTypeAnnotations = marks.filter((mark) => markDefs.some((markDef) => markDef._key === mark && markDef._type === action.annotation.name));
+        const marks = (_b = span.marks) != null ? _b : [], existingSameTypeAnnotations = marks.filter((mark) => markDefs.some((markDef) => markDef._key === mark && markDef._type === action.annotation.name));
         Transforms.setNodes(editor, {
           marks: [...marks.filter((mark) => !existingSameTypeAnnotations.includes(mark)), annotationKey]
         }, {
@@ -5541,6 +4746,7 @@ const addAnnotationActionImplementation = ({
 }, removeAnnotationActionImplementation = ({
   action
 }) => {
+  var _a, _b, _c, _d, _e, _f, _g;
   const editor = action.editor;
   if (debug$6("Removing annotation", action.annotation.name), !!editor.selection)
     if (Range.isCollapsed(editor.selection)) {
@@ -5549,12 +4755,12 @@ const addAnnotationActionImplementation = ({
       });
       if (!editor.isTextBlock(block))
         return;
-      const potentialAnnotations = (block.markDefs ?? []).filter((markDef) => markDef._type === action.annotation.name), [selectedChild, selectedChildPath] = Editor.node(editor, editor.selection, {
+      const potentialAnnotations = ((_a = block.markDefs) != null ? _a : []).filter((markDef) => markDef._type === action.annotation.name), [selectedChild, selectedChildPath] = Editor.node(editor, editor.selection, {
         depth: 2
       });
       if (!editor.isTextSpan(selectedChild))
         return;
-      const annotationToRemove = selectedChild.marks?.find((mark) => potentialAnnotations.some((markDef) => markDef._key === mark));
+      const annotationToRemove = (_b = selectedChild.marks) == null ? void 0 : _b.find((mark) => potentialAnnotations.some((markDef) => markDef._key === mark));
       if (!annotationToRemove)
         return;
       const previousSpansWithSameAnnotation = [];
@@ -5562,20 +4768,20 @@ const addAnnotationActionImplementation = ({
         reverse: !0
       }))
         if (editor.isTextSpan(child) && Path.isBefore(childPath, selectedChildPath))
-          if (child.marks?.includes(annotationToRemove))
+          if ((_c = child.marks) != null && _c.includes(annotationToRemove))
             previousSpansWithSameAnnotation.push([child, childPath]);
           else
             break;
       const nextSpansWithSameAnnotation = [];
       for (const [child, childPath] of Node.children(editor, blockPath))
         if (editor.isTextSpan(child) && Path.isAfter(childPath, selectedChildPath))
-          if (child.marks?.includes(annotationToRemove))
+          if ((_d = child.marks) != null && _d.includes(annotationToRemove))
             nextSpansWithSameAnnotation.push([child, childPath]);
           else
             break;
       for (const [child, childPath] of [...previousSpansWithSameAnnotation, [selectedChild, selectedChildPath], ...nextSpansWithSameAnnotation])
         Transforms.setNodes(editor, {
-          marks: child.marks?.filter((mark) => mark !== annotationToRemove)
+          marks: (_e = child.marks) == null ? void 0 : _e.filter((mark) => mark !== annotationToRemove)
         }, {
           at: childPath
         });
@@ -5594,7 +4800,10 @@ const addAnnotationActionImplementation = ({
         for (const [child, childPath] of children) {
           if (!editor.isTextSpan(child) || !Range.includes(editor.selection, childPath))
             continue;
-          const markDefs = block.markDefs ?? [], marks = child.marks ?? [], marksWithoutAnnotation = marks.filter((mark) => markDefs.find((markDef2) => markDef2._key === mark)?._type !== action.annotation.name);
+          const markDefs = (_f = block.markDefs) != null ? _f : [], marks = (_g = child.marks) != null ? _g : [], marksWithoutAnnotation = marks.filter((mark) => {
+            const markDef = markDefs.find((markDef2) => markDef2._key === mark);
+            return (markDef == null ? void 0 : markDef._type) !== action.annotation.name;
+          });
           marksWithoutAnnotation.length !== marks.length && Transforms.setNodes(editor, {
             marks: marksWithoutAnnotation
           }, {
@@ -5637,11 +4846,12 @@ function insertBlock({
   editor,
   schema
 }) {
+  var _a;
   if (editor.selection) {
-    const [focusBlock, focusBlockPath] = Array.from(Editor.nodes(editor, {
+    const [focusBlock, focusBlockPath] = (_a = Array.from(Editor.nodes(editor, {
       at: editor.selection.focus.path.slice(0, 1),
       match: (n) => !Editor.isEditor(n)
-    }))[0] ?? [void 0, void 0];
+    }))[0]) != null ? _a : [void 0, void 0];
     if (placement === "after") {
       const nextPath = [focusBlockPath[0] + 1];
       Transforms.insertNodes(editor, block, {
@@ -5673,15 +4883,22 @@ function insertBlock({
     });
   }
 }
+var __defProp$a = Object.defineProperty, __getOwnPropSymbols$a = Object.getOwnPropertySymbols, __hasOwnProp$a = Object.prototype.hasOwnProperty, __propIsEnum$a = Object.prototype.propertyIsEnumerable, __defNormalProp$a = (obj, key, value) => key in obj ? __defProp$a(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$a = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$a.call(b, prop) && __defNormalProp$a(a, prop, b[prop]);
+  if (__getOwnPropSymbols$a)
+    for (var prop of __getOwnPropSymbols$a(b))
+      __propIsEnum$a.call(b, prop) && __defNormalProp$a(a, prop, b[prop]);
+  return a;
+};
 const insertBlockObjectActionImplementation = ({
   context,
   action
 }) => {
-  const block = toSlateValue([{
+  const block = toSlateValue([__spreadValues$a({
     _key: context.keyGenerator(),
-    _type: action.blockObject.name,
-    ...action.blockObject.value ? action.blockObject.value : {}
-  }], {
+    _type: action.blockObject.name
+  }, action.blockObject.value ? action.blockObject.value : {})], {
     schemaTypes: context.schema
   })[0];
   insertBlock({
@@ -5690,19 +4907,29 @@ const insertBlockObjectActionImplementation = ({
     editor: action.editor,
     schema: context.schema
   });
-}, insertBreakActionImplementation = ({
+};
+var __defProp$9 = Object.defineProperty, __defProps$6 = Object.defineProperties, __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$9 = Object.getOwnPropertySymbols, __hasOwnProp$9 = Object.prototype.hasOwnProperty, __propIsEnum$9 = Object.prototype.propertyIsEnumerable, __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$9 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$9.call(b, prop) && __defNormalProp$9(a, prop, b[prop]);
+  if (__getOwnPropSymbols$9)
+    for (var prop of __getOwnPropSymbols$9(b))
+      __propIsEnum$9.call(b, prop) && __defNormalProp$9(a, prop, b[prop]);
+  return a;
+}, __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
+const insertBreakActionImplementation = ({
   context,
   action
 }) => {
+  var _a, _b, _c, _d, _e;
   const keyGenerator = context.keyGenerator, schema = context.schema, editor = action.editor;
   if (!editor.selection)
     return;
-  const [focusSpan] = Array.from(Editor.nodes(editor, {
+  const [focusSpan] = (_a = Array.from(Editor.nodes(editor, {
     mode: "lowest",
     at: editor.selection.focus,
     match: (n) => editor.isTextSpan(n),
     voids: !1
-  }))[0] ?? [void 0], focusDecorators = focusSpan?.marks?.filter((mark) => schema.decorators.some((decorator) => decorator.value === mark)) ?? [], focusAnnotations = focusSpan?.marks?.filter((mark) => !schema.decorators.some((decorator) => decorator.value === mark)) ?? [], anchorBlockPath = editor.selection.anchor.path.slice(0, 1), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = Node.descendant(editor, focusBlockPath);
+  }))[0]) != null ? _a : [void 0], focusDecorators = (_c = (_b = focusSpan == null ? void 0 : focusSpan.marks) == null ? void 0 : _b.filter((mark) => schema.decorators.some((decorator) => decorator.value === mark))) != null ? _c : [], focusAnnotations = (_e = (_d = focusSpan == null ? void 0 : focusSpan.marks) == null ? void 0 : _d.filter((mark) => !schema.decorators.some((decorator) => decorator.value === mark))) != null ? _e : [], anchorBlockPath = editor.selection.anchor.path.slice(0, 1), focusBlockPath = editor.selection.focus.path.slice(0, 1), focusBlock = Node.descendant(editor, focusBlockPath);
   if (editor.isTextBlock(focusBlock)) {
     const [start, end] = Range.edges(editor.selection), lastFocusBlockChild = focusBlock.children[focusBlock.children.length - 1], atTheEndOfBlock = isEqual(start, {
       path: [...focusBlockPath, focusBlock.children.length - 1],
@@ -5741,6 +4968,7 @@ const insertBlockObjectActionImplementation = ({
     const selectionAcrossBlocks = anchorBlockPath[0] !== focusBlockPath[0];
     if (!atTheStartOfBlock && !atTheEndOfBlock && !selectionAcrossBlocks) {
       Editor.withoutNormalizing(editor, () => {
+        var _a2;
         if (!editor.selection)
           return;
         Transforms.splitNodes(editor, {
@@ -5763,20 +4991,28 @@ const insertBlockObjectActionImplementation = ({
           for (const [child, childPath] of children) {
             if (!editor.isTextSpan(child))
               continue;
-            const marks = child.marks ?? [];
+            const marks = (_a2 = child.marks) != null ? _a2 : [];
             for (const mark of marks)
-              schema.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);
+              schema.decorators.some((decorator) => decorator.value === mark) || prevNodeSpans.some((prevNodeSpan) => {
+                var _a3;
+                return (_a3 = prevNodeSpan.marks) == null ? void 0 : _a3.includes(mark);
+              }) && !newMarkDefKeys.has(mark) && newMarkDefKeys.set(mark, keyGenerator());
+            const newMarks = marks.map((mark) => {
+              var _a3;
+              return (_a3 = newMarkDefKeys.get(mark)) != null ? _a3 : mark;
+            });
             isEqual(marks, newMarks) || Transforms.setNodes(editor, {
               marks: newMarks
             }, {
               at: childPath
             });
           }
-          const newMarkDefs = nextNode.markDefs.map((markDef) => ({
-            ...markDef,
-            _key: newMarkDefKeys.get(markDef._key) ?? markDef._key
-          }));
+          const newMarkDefs = nextNode.markDefs.map((markDef) => {
+            var _a3;
+            return __spreadProps$6(__spreadValues$9({}, markDef), {
+              _key: (_a3 = newMarkDefKeys.get(markDef._key)) != null ? _a3 : markDef._key
+            });
+          });
           isEqual(nextNode.markDefs, newMarkDefs) || Transforms.setNodes(editor, {
             markDefs: newMarkDefs
           }, {
@@ -5797,15 +5033,24 @@ const insertBlockObjectActionImplementation = ({
 }) => {
   insertBreakActionImplementation({
     context,
-    action: {
-      ...action,
+    action: __spreadProps$6(__spreadValues$9({}, action), {
       type: "insert.break"
-    }
+    })
   });
-}, insertInlineObjectActionImplementation = ({
+};
+var __defProp$8 = Object.defineProperty, __getOwnPropSymbols$8 = Object.getOwnPropertySymbols, __hasOwnProp$8 = Object.prototype.hasOwnProperty, __propIsEnum$8 = Object.prototype.propertyIsEnumerable, __defNormalProp$8 = (obj, key, value) => key in obj ? __defProp$8(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$8 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$8.call(b, prop) && __defNormalProp$8(a, prop, b[prop]);
+  if (__getOwnPropSymbols$8)
+    for (var prop of __getOwnPropSymbols$8(b))
+      __propIsEnum$8.call(b, prop) && __defNormalProp$8(a, prop, b[prop]);
+  return a;
+};
+const insertInlineObjectActionImplementation = ({
   context,
   action
 }) => {
+  var _a, _b;
   if (!context.schema.inlineObjects.some((inlineObject) => inlineObject.name === action.inlineObject.name)) {
     console.error("Unable to insert unknown inline object");
     return;
@@ -5814,60 +5059,77 @@ const insertBlockObjectActionImplementation = ({
     console.error("Unable to insert inline object without selection");
     return;
   }
-  const [focusTextBlock] = Array.from(Editor.nodes(action.editor, {
+  const [focusTextBlock] = (_a = Array.from(Editor.nodes(action.editor, {
     at: action.editor.selection.focus.path,
     match: (node) => action.editor.isTextBlock(node)
-  })).at(0) ?? [void 0, void 0];
+  })).at(0)) != null ? _a : [void 0, void 0];
   if (!focusTextBlock) {
     console.error("Unable to perform action without focus text block");
     return;
   }
-  const child = toSlateValue([{
+  const block = toSlateValue([{
     _type: context.schema.block.name,
     _key: context.keyGenerator(),
-    children: [{
+    children: [__spreadValues$8({
       _type: action.inlineObject.name,
-      _key: context.keyGenerator(),
-      ...action.inlineObject.value ?? {}
-    }]
+      _key: context.keyGenerator()
+    }, (_b = action.inlineObject.value) != null ? _b : {})]
   }], {
     schemaTypes: context.schema
-  }).at(0)?.children.at(0);
+  }).at(0), child = block == null ? void 0 : block.children.at(0);
   if (!child) {
     console.error("Unable to insert inline object");
     return;
   }
   Transforms.insertNodes(action.editor, child);
-}, insertSpanActionImplementation = ({
+};
+var __defProp$7 = Object.defineProperty, __getOwnPropSymbols$7 = Object.getOwnPropertySymbols, __hasOwnProp$7 = Object.prototype.hasOwnProperty, __propIsEnum$7 = Object.prototype.propertyIsEnumerable, __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$7 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$7.call(b, prop) && __defNormalProp$7(a, prop, b[prop]);
+  if (__getOwnPropSymbols$7)
+    for (var prop of __getOwnPropSymbols$7(b))
+      __propIsEnum$7.call(b, prop) && __defNormalProp$7(a, prop, b[prop]);
+  return a;
+};
+const insertSpanActionImplementation = ({
   context,
   action
 }) => {
+  var _a, _b, _c, _d;
   if (!action.editor.selection) {
     console.error("Unable to perform action without selection", action);
     return;
   }
-  const [focusBlock, focusBlockPath] = Array.from(Editor.nodes(action.editor, {
+  const [focusBlock, focusBlockPath] = (_a = Array.from(Editor.nodes(action.editor, {
     at: action.editor.selection.focus.path,
     match: (node) => action.editor.isTextBlock(node)
-  }))[0] ?? [void 0, void 0];
+  }))[0]) != null ? _a : [void 0, void 0];
   if (!focusBlock || !focusBlockPath) {
     console.error("Unable to perform action without focus block", action);
     return;
   }
-  const markDefs = focusBlock.markDefs ?? [], annotations = action.annotations ? action.annotations.map((annotation) => ({
+  const markDefs = (_b = focusBlock.markDefs) != null ? _b : [], annotations = action.annotations ? action.annotations.map((annotation) => __spreadValues$7({
     _type: annotation.name,
-    _key: context.keyGenerator(),
-    ...annotation.value
-  })) : void 0;
+    _key: context.keyGenerator()
+  }, annotation.value)) : void 0;
   annotations && annotations.length > 0 && Transforms.setNodes(action.editor, {
     markDefs: [...markDefs, ...annotations]
   }), Transforms.insertNodes(action.editor, {
     _type: "span",
     _key: context.keyGenerator(),
     text: action.text,
-    marks: [...annotations?.map((annotation) => annotation._key) ?? [], ...action.decorators ?? []]
+    marks: [...(_c = annotations == null ? void 0 : annotations.map((annotation) => annotation._key)) != null ? _c : [], ...(_d = action.decorators) != null ? _d : []]
   });
-}, textBlockSetActionImplementation = ({
+};
+var __defProp$6 = Object.defineProperty, __getOwnPropSymbols$6 = Object.getOwnPropertySymbols, __hasOwnProp$6 = Object.prototype.hasOwnProperty, __propIsEnum$6 = Object.prototype.propertyIsEnumerable, __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$6 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$6.call(b, prop) && __defNormalProp$6(a, prop, b[prop]);
+  if (__getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(b))
+      __propIsEnum$6.call(b, prop) && __defNormalProp$6(a, prop, b[prop]);
+  return a;
+};
+const textBlockSetActionImplementation = ({
   action
 }) => {
   const at = toSlateRange({
@@ -5880,17 +5142,13 @@ const insertBlockObjectActionImplementation = ({
       offset: 0
     }
   }, action.editor);
-  Transforms.setNodes(action.editor, {
-    ...action.style ? {
-      style: action.style
-    } : {},
-    ...action.listItem ? {
-      listItem: action.listItem
-    } : {},
-    ...action.level ? {
-      level: action.level
-    } : {}
-  }, {
+  Transforms.setNodes(action.editor, __spreadValues$6(__spreadValues$6(__spreadValues$6({}, action.style ? {
+    style: action.style
+  } : {}), action.listItem ? {
+    listItem: action.listItem
+  } : {}), action.level ? {
+    level: action.level
+  } : {}), {
     at
   });
 }, textBlockUnsetActionImplementation = ({
@@ -5909,7 +5167,16 @@ const insertBlockObjectActionImplementation = ({
   Transforms.unsetNodes(action.editor, action.props, {
     at
   });
-}, behaviorActionImplementations = {
+};
+var __defProp$5 = Object.defineProperty, __defProps$5 = Object.defineProperties, __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$5 = Object.getOwnPropertySymbols, __hasOwnProp$5 = Object.prototype.hasOwnProperty, __propIsEnum$5 = Object.prototype.propertyIsEnumerable, __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$5.call(b, prop) && __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(b))
+      __propIsEnum$5.call(b, prop) && __defNormalProp$5(a, prop, b[prop]);
+  return a;
+}, __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
+const behaviorActionImplementations = {
   "annotation.add": addAnnotationActionImplementation,
   "annotation.remove": removeAnnotationActionImplementation,
   "annotation.toggle": toggleAnnotationActionImplementation,
@@ -5998,15 +5265,15 @@ const insertBlockObjectActionImplementation = ({
     context,
     action
   }) => {
+    var _a, _b, _c, _d;
     const block = toSlateValue([{
       _key: context.keyGenerator(),
       _type: context.schema.block.name,
-      style: context.schema.styles[0].value ?? "normal",
+      style: (_a = context.schema.styles[0].value) != null ? _a : "normal",
       markDefs: [],
-      children: action.textBlock?.children?.map((child) => ({
-        ...child,
+      children: (_d = (_c = (_b = action.textBlock) == null ? void 0 : _b.children) == null ? void 0 : _c.map((child) => __spreadProps$5(__spreadValues$5({}, child), {
         _key: context.keyGenerator()
-      })) ?? [{
+      }))) != null ? _d : [{
         _type: context.schema.span.name,
         _key: context.keyGenerator(),
         text: ""
@@ -6099,11 +5366,7 @@ const insertBlockObjectActionImplementation = ({
     action
   }) => {
     const selection = action.editor.selection;
-    selection && (Transforms.select(action.editor, {
-      ...selection
-    }), action.editor.selection = {
-      ...selection
-    });
+    selection && (Transforms.select(action.editor, __spreadValues$5({}, selection)), action.editor.selection = __spreadValues$5({}, selection));
   },
   "style.toggle": toggleStyleActionImplementation,
   "style.add": addStyleActionImplementation,
@@ -6375,6 +5638,14 @@ function performDefaultAction({
       });
   }
 }
+var __defProp$4 = Object.defineProperty, __defProps$4 = Object.defineProperties, __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$4 = Object.getOwnPropertySymbols, __hasOwnProp$4 = Object.prototype.hasOwnProperty, __propIsEnum$4 = Object.prototype.propertyIsEnumerable, __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$4.call(b, prop) && __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b))
+      __propIsEnum$4.call(b, prop) && __defNormalProp$4(a, prop, b[prop]);
+  return a;
+}, __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
 const editorMachine = setup({
   types: {
     context: {},
@@ -6420,11 +5691,11 @@ const editorMachine = setup({
       event,
       enqueue
     }) => {
+      var _a;
       assertEvent(event, ["behavior event"]), debug$l("Behavior event", event);
-      const defaultAction = event.behaviorEvent.type === "copy" || event.behaviorEvent.type === "key.down" || event.behaviorEvent.type === "key.up" || event.behaviorEvent.type === "paste" ? void 0 : {
-        ...event.behaviorEvent,
+      const defaultAction = event.behaviorEvent.type === "copy" || event.behaviorEvent.type === "key.down" || event.behaviorEvent.type === "key.up" || event.behaviorEvent.type === "paste" ? void 0 : __spreadProps$4(__spreadValues$4({}, event.behaviorEvent), {
         editor: event.editor
-      }, eventBehaviors = context.behaviors.filter((behavior) => behavior.on === event.behaviorEvent.type);
+      }), eventBehaviors = context.behaviors.filter((behavior) => behavior.on === event.behaviorEvent.type);
       if (eventBehaviors.length === 0) {
         if (!defaultAction)
           return;
@@ -6460,7 +5731,10 @@ const editorMachine = setup({
         });
         if (!shouldRun)
           continue;
-        const actionIntendSets = eventBehavior.actions.map((actionSet) => actionSet(shouldRun));
+        const actionIntendSets = eventBehavior.actions.map((actionSet) => actionSet({
+          context: editorContext,
+          event: event.behaviorEvent
+        }, shouldRun));
         for (const actionIntends of actionIntendSets)
           behaviorOverwritten = behaviorOverwritten || actionIntends.length > 0 && actionIntends.some((actionIntend) => actionIntend.type !== "effect"), enqueue.raise({
             type: "behavior action intends",
@@ -6468,7 +5742,7 @@ const editorMachine = setup({
             actionIntends
           });
         if (behaviorOverwritten) {
-          event.nativeEvent?.preventDefault();
+          (_a = event.nativeEvent) == null || _a.preventDefault();
           break;
         }
       }
@@ -6487,16 +5761,19 @@ const editorMachine = setup({
   id: "editor",
   context: ({
     input
-  }) => ({
-    behaviors: input.behaviors ?? coreBehaviors,
-    keyGenerator: input.keyGenerator,
-    pendingEvents: [],
-    schema: input.schema,
-    selection: void 0,
-    readOnly: input.readOnly ?? !1,
-    maxBlocks: input.maxBlocks,
-    value: input.value
-  }),
+  }) => {
+    var _a, _b;
+    return {
+      behaviors: (_a = input.behaviors) != null ? _a : coreBehaviors,
+      keyGenerator: input.keyGenerator,
+      pendingEvents: [],
+      schema: input.schema,
+      selection: void 0,
+      readOnly: (_b = input.readOnly) != null ? _b : !1,
+      maxBlocks: input.maxBlocks,
+      value: input.value
+    };
+  },
   on: {
     "annotation.add": {
       actions: emit(({
@@ -6599,7 +5876,10 @@ const editorMachine = setup({
       actions: [assign({
         selection: ({
           event
-        }) => event.selection ?? void 0
+        }) => {
+          var _a;
+          return (_a = event.selection) != null ? _a : void 0;
+        }
       }), emit(({
         event
       }) => event)]
@@ -6674,10 +5954,9 @@ const editorMachine = setup({
       }) => {
         Editor.withoutNormalizing(event.editor, () => {
           for (const actionIntend of event.actionIntends) {
-            const action = {
-              ...actionIntend,
+            const action = __spreadProps$4(__spreadValues$4({}, actionIntend), {
               editor: event.editor
-            };
+            });
             performAction({
               context,
               action
@@ -6766,28 +6045,10 @@ function createEditor(config) {
   const editorActor = createActor(editorMachine, {
     input: editorConfigToMachineInput(config)
   });
-  editorActor.start();
-  const slateEditor = createSlateEditor({
-    editorActor
-  }), editable = createEditableAPI(slateEditor.instance, editorActor);
-  return {
-    send: (event) => {
-      editorActor.send(event);
-    },
-    on: (event, listener) => editorActor.on(
-      event,
-      // @ts-expect-error
-      listener
-    ),
-    _internal: {
-      editable,
-      editorActor,
-      slateEditor
-    }
-  };
+  return editorActor.start(), createEditorFromActor(editorActor);
 }
 function useCreateEditor(config) {
-  const $ = c(18);
+  const $ = c(6);
   let t0;
   $[0] !== config ? (t0 = editorConfigToMachineInput(config), $[0] = config, $[1] = t0) : t0 = $[1];
   let t1;
@@ -6795,38 +6056,40 @@ function useCreateEditor(config) {
     input: t0
   }, $[2] = t0, $[3] = t1) : t1 = $[3];
   const editorActor = useActorRef(editorMachine, t1);
-  let t2, slateEditor, t3;
-  $[4] !== editorActor ? (slateEditor = createSlateEditor({
-    editorActor
-  }), t3 = createEditableAPI(slateEditor.instance, editorActor), $[4] = editorActor, $[5] = slateEditor, $[6] = t3) : (slateEditor = $[5], t3 = $[6]);
-  const editable = t3;
-  let t4, t5;
-  $[7] !== editorActor ? (t4 = (event) => {
-    editorActor.send(event);
-  }, t5 = (event_0, listener) => editorActor.on(event_0, listener), $[7] = editorActor, $[8] = t4, $[9] = t5) : (t4 = $[8], t5 = $[9]);
-  let t6;
-  $[10] !== editable || $[11] !== editorActor || $[12] !== slateEditor ? (t6 = {
-    editable,
-    editorActor,
-    slateEditor
-  }, $[10] = editable, $[11] = editorActor, $[12] = slateEditor, $[13] = t6) : t6 = $[13];
-  let t7;
-  return $[14] !== t4 || $[15] !== t5 || $[16] !== t6 ? (t7 = {
-    send: t4,
-    on: t5,
-    _internal: t6
-  }, $[14] = t4, $[15] = t5, $[16] = t6, $[17] = t7) : t7 = $[17], t2 = t7, t2;
+  let t2, t3;
+  return $[4] !== editorActor ? (t3 = createEditorFromActor(editorActor), $[4] = editorActor, $[5] = t3) : t3 = $[5], t2 = t3, t2;
 }
 function editorConfigToMachineInput(config) {
+  var _a;
   return {
     behaviors: config.behaviors,
-    keyGenerator: config.keyGenerator ?? defaultKeyGenerator,
+    keyGenerator: (_a = config.keyGenerator) != null ? _a : defaultKeyGenerator,
     maxBlocks: config.maxBlocks,
     readOnly: config.readOnly,
     schema: config.schemaDefinition ? compileSchemaDefinition(config.schemaDefinition) : getPortableTextMemberSchemaTypes(config.schema.hasOwnProperty("jsonType") ? config.schema : compileType(config.schema)),
     value: config.initialValue
   };
 }
+function createEditorFromActor(editorActor) {
+  const slateEditor = createSlateEditor({
+    editorActor
+  }), editable = createEditableAPI(slateEditor.instance, editorActor);
+  return {
+    send: (event) => {
+      editorActor.send(event);
+    },
+    on: (event, listener) => editorActor.on(
+      event,
+      // @ts-expect-error
+      listener
+    ),
+    _internal: {
+      editable,
+      editorActor,
+      slateEditor
+    }
+  };
+}
 const EditorActorContext = createContext({}), PortableTextEditorSelectionContext = createContext(null), usePortableTextEditorSelection = () => {
   const selection = useContext(PortableTextEditorSelectionContext);
   if (selection === void 0)
@@ -6850,13 +6113,16 @@ function PortableTextEditorSelectionProvider(props) {
   let t2;
   return $[3] !== props.children || $[4] !== selection ? (t2 = /* @__PURE__ */ jsx(PortableTextEditorSelectionContext.Provider, { value: selection, children: props.children }), $[3] = props.children, $[4] = selection, $[5] = t2) : t2 = $[5], t2;
 }
+var __defProp$3 = Object.defineProperty, __defProps$3 = Object.defineProperties, __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$3 = Object.getOwnPropertySymbols, __hasOwnProp$3 = Object.prototype.hasOwnProperty, __propIsEnum$3 = Object.prototype.propertyIsEnumerable, __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$3.call(b, prop) && __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b))
+      __propIsEnum$3.call(b, prop) && __defNormalProp$3(a, prop, b[prop]);
+  return a;
+}, __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b)), __publicField = (obj, key, value) => __defNormalProp$3(obj, typeof key != "symbol" ? key + "" : key, value);
 const debug$4 = debugWithName("component:PortableTextEditor");
 class PortableTextEditor extends Component {
-  static displayName = "PortableTextEditor";
-  /**
-   * An observable of all the editor changes.
-   */
-  change$ = new Subject();
   /**
    * A lookup table for all the relevant schema types for this portable text type.
    */
@@ -6867,8 +6133,11 @@ class PortableTextEditor extends Component {
    * The editor API (currently implemented with Slate).
    */
   constructor(props) {
-    super(props), props.editor ? this.editor = props.editor : this.editor = createEditor({
-      keyGenerator: props.keyGenerator ?? defaultKeyGenerator,
+    var _a;
+    super(props), __publicField(this, "change$", new Subject()), __publicField(this, "setEditable", (editable) => {
+      this.editor._internal.editable = __spreadValues$3(__spreadValues$3({}, this.editor._internal.editable), editable);
+    }), props.editor ? this.editor = props.editor : this.editor = createEditor({
+      keyGenerator: (_a = props.keyGenerator) != null ? _a : defaultKeyGenerator,
       schema: props.schemaType,
       initialValue: props.value,
       maxBlocks: props.maxBlocks === void 0 ? void 0 : Number.parseInt(props.maxBlocks.toString(), 10),
@@ -6889,14 +6158,9 @@ class PortableTextEditor extends Component {
       value: this.props.value
     }), this.props.editorRef !== prevProps.editorRef && this.props.editorRef && (this.props.editorRef.current = this));
   }
-  setEditable = (editable) => {
-    this.editor._internal.editable = {
-      ...this.editor._internal.editable,
-      ...editable
-    };
-  };
   render() {
-    const legacyPatches = this.props.editor ? void 0 : this.props.incomingPatches$ ?? this.props.patches$;
+    var _a;
+    const legacyPatches = this.props.editor ? void 0 : (_a = this.props.incomingPatches$) != null ? _a : this.props.patches$;
     return /* @__PURE__ */ jsxs(Fragment, { children: [
       legacyPatches ? /* @__PURE__ */ jsx(RoutePatchesObservableToEditorActor, { editorActor: this.editor._internal.editorActor, patches$: legacyPatches }) : null,
       /* @__PURE__ */ jsx(RouteEventsToChanges, { editorActor: this.editor._internal.editorActor, onChange: (change) => {
@@ -6906,65 +6170,105 @@ class PortableTextEditor extends Component {
       /* @__PURE__ */ jsx(EditorActorContext.Provider, { value: this.editor._internal.editorActor, children: /* @__PURE__ */ jsx(Slate, { editor: this.editor._internal.slateEditor.instance, initialValue: this.editor._internal.slateEditor.initialValue, children: /* @__PURE__ */ jsx(PortableTextEditorContext.Provider, { value: this, children: /* @__PURE__ */ jsx(PortableTextEditorSelectionProvider, { editorActor: this.editor._internal.editorActor, children: this.props.children }) }) }) })
     ] });
   }
-  // Static API methods
-  static activeAnnotations = (editor) => editor && editor.editable ? editor.editable.activeAnnotations() : [];
-  static isAnnotationActive = (editor, annotationType) => editor && editor.editable ? editor.editable.isAnnotationActive(annotationType) : !1;
-  static addAnnotation = (editor, type, value) => editor.editable?.addAnnotation(type, value);
-  static blur = (editor) => {
-    debug$4("Host blurred"), editor.editable?.blur();
-  };
-  static delete = (editor, selection, options) => editor.editable?.delete(selection, options);
-  static findDOMNode = (editor, element) => editor.editable?.findDOMNode(element);
-  static findByPath = (editor, path) => editor.editable?.findByPath(path) || [];
-  static focus = (editor) => {
-    debug$4("Host requesting focus"), editor.editable?.focus();
-  };
-  static focusBlock = (editor) => editor.editable?.focusBlock();
-  static focusChild = (editor) => editor.editable?.focusChild();
-  static getSelection = (editor) => editor.editable ? editor.editable.getSelection() : null;
-  static getValue = (editor) => editor.editable?.getValue();
-  static hasBlockStyle = (editor, blockStyle) => editor.editable?.hasBlockStyle(blockStyle);
-  static hasListStyle = (editor, listStyle) => editor.editable?.hasListStyle(listStyle);
-  static isCollapsedSelection = (editor) => editor.editable?.isCollapsedSelection();
-  static isExpandedSelection = (editor) => editor.editable?.isExpandedSelection();
-  static isMarkActive = (editor, mark) => editor.editable?.isMarkActive(mark);
-  static insertChild = (editor, type, value) => (debug$4("Host inserting child"), editor.editable?.insertChild(type, value));
-  static insertBlock = (editor, type, value) => editor.editable?.insertBlock(type, value);
-  static insertBreak = (editor) => editor.editable?.insertBreak();
-  static isVoid = (editor, element) => editor.editable?.isVoid(element);
-  static isObjectPath = (_editor, path) => {
-    if (!path || !Array.isArray(path)) return !1;
-    const isChildObjectEditPath = path.length > 3 && path[1] === "children";
-    return path.length > 1 && path[1] !== "children" || isChildObjectEditPath;
-  };
-  static marks = (editor) => editor.editable?.marks();
-  static select = (editor, selection) => {
-    debug$4("Host setting selection", selection), editor.editable?.select(selection);
-  };
-  static removeAnnotation = (editor, type) => editor.editable?.removeAnnotation(type);
-  static toggleBlockStyle = (editor, blockStyle) => (debug$4("Host is toggling block style"), editor.editable?.toggleBlockStyle(blockStyle));
-  static toggleList = (editor, listStyle) => editor.editable?.toggleList(listStyle);
-  static toggleMark = (editor, mark) => {
-    debug$4("Host toggling mark", mark), editor.editable?.toggleMark(mark);
-  };
-  static getFragment = (editor) => (debug$4("Host getting fragment"), editor.editable?.getFragment());
-  static undo = (editor) => {
-    debug$4("Host undoing"), editor.editable?.undo();
-  };
-  static redo = (editor) => {
-    debug$4("Host redoing"), editor.editable?.redo();
-  };
-  static isSelectionsOverlapping = (editor, selectionA, selectionB) => editor.editable?.isSelectionsOverlapping(selectionA, selectionB);
 }
+__publicField(PortableTextEditor, "displayName", "PortableTextEditor"), // Static API methods
+__publicField(PortableTextEditor, "activeAnnotations", (editor) => editor && editor.editable ? editor.editable.activeAnnotations() : []), __publicField(PortableTextEditor, "isAnnotationActive", (editor, annotationType) => editor && editor.editable ? editor.editable.isAnnotationActive(annotationType) : !1), __publicField(PortableTextEditor, "addAnnotation", (editor, type, value) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.addAnnotation(type, value);
+}), __publicField(PortableTextEditor, "blur", (editor) => {
+  var _a;
+  debug$4("Host blurred"), (_a = editor.editable) == null || _a.blur();
+}), __publicField(PortableTextEditor, "delete", (editor, selection, options) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.delete(selection, options);
+}), __publicField(PortableTextEditor, "findDOMNode", (editor, element) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.findDOMNode(element);
+}), __publicField(PortableTextEditor, "findByPath", (editor, path) => {
+  var _a;
+  return ((_a = editor.editable) == null ? void 0 : _a.findByPath(path)) || [];
+}), __publicField(PortableTextEditor, "focus", (editor) => {
+  var _a;
+  debug$4("Host requesting focus"), (_a = editor.editable) == null || _a.focus();
+}), __publicField(PortableTextEditor, "focusBlock", (editor) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.focusBlock();
+}), __publicField(PortableTextEditor, "focusChild", (editor) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.focusChild();
+}), __publicField(PortableTextEditor, "getSelection", (editor) => editor.editable ? editor.editable.getSelection() : null), __publicField(PortableTextEditor, "getValue", (editor) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.getValue();
+}), __publicField(PortableTextEditor, "hasBlockStyle", (editor, blockStyle) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.hasBlockStyle(blockStyle);
+}), __publicField(PortableTextEditor, "hasListStyle", (editor, listStyle) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.hasListStyle(listStyle);
+}), __publicField(PortableTextEditor, "isCollapsedSelection", (editor) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.isCollapsedSelection();
+}), __publicField(PortableTextEditor, "isExpandedSelection", (editor) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.isExpandedSelection();
+}), __publicField(PortableTextEditor, "isMarkActive", (editor, mark) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.isMarkActive(mark);
+}), __publicField(PortableTextEditor, "insertChild", (editor, type, value) => {
+  var _a;
+  return debug$4("Host inserting child"), (_a = editor.editable) == null ? void 0 : _a.insertChild(type, value);
+}), __publicField(PortableTextEditor, "insertBlock", (editor, type, value) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.insertBlock(type, value);
+}), __publicField(PortableTextEditor, "insertBreak", (editor) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.insertBreak();
+}), __publicField(PortableTextEditor, "isVoid", (editor, element) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.isVoid(element);
+}), __publicField(PortableTextEditor, "isObjectPath", (_editor, path) => {
+  if (!path || !Array.isArray(path)) return !1;
+  const isChildObjectEditPath = path.length > 3 && path[1] === "children";
+  return path.length > 1 && path[1] !== "children" || isChildObjectEditPath;
+}), __publicField(PortableTextEditor, "marks", (editor) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.marks();
+}), __publicField(PortableTextEditor, "select", (editor, selection) => {
+  var _a;
+  debug$4("Host setting selection", selection), (_a = editor.editable) == null || _a.select(selection);
+}), __publicField(PortableTextEditor, "removeAnnotation", (editor, type) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.removeAnnotation(type);
+}), __publicField(PortableTextEditor, "toggleBlockStyle", (editor, blockStyle) => {
+  var _a;
+  return debug$4("Host is toggling block style"), (_a = editor.editable) == null ? void 0 : _a.toggleBlockStyle(blockStyle);
+}), __publicField(PortableTextEditor, "toggleList", (editor, listStyle) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.toggleList(listStyle);
+}), __publicField(PortableTextEditor, "toggleMark", (editor, mark) => {
+  var _a;
+  debug$4("Host toggling mark", mark), (_a = editor.editable) == null || _a.toggleMark(mark);
+}), __publicField(PortableTextEditor, "getFragment", (editor) => {
+  var _a;
+  return debug$4("Host getting fragment"), (_a = editor.editable) == null ? void 0 : _a.getFragment();
+}), __publicField(PortableTextEditor, "undo", (editor) => {
+  var _a;
+  debug$4("Host undoing"), (_a = editor.editable) == null || _a.undo();
+}), __publicField(PortableTextEditor, "redo", (editor) => {
+  var _a;
+  debug$4("Host redoing"), (_a = editor.editable) == null || _a.redo();
+}), __publicField(PortableTextEditor, "isSelectionsOverlapping", (editor, selectionA, selectionB) => {
+  var _a;
+  return (_a = editor.editable) == null ? void 0 : _a.isSelectionsOverlapping(selectionA, selectionB);
+});
 function RoutePatchesObservableToEditorActor(props) {
   const $ = c(4);
   let t0, t1;
   return $[0] !== props.editorActor || $[1] !== props.patches$ ? (t0 = () => {
     const subscription = props.patches$.subscribe((payload) => {
-      props.editorActor.send({
-        type: "patches",
-        ...payload
-      });
+      props.editorActor.send(__spreadValues$3({
+        type: "patches"
+      }, payload));
     });
     return () => {
       subscription.unsubscribe();
@@ -7029,10 +6333,9 @@ function RouteEventsToChanges(props) {
           break bb5;
         }
         case "error": {
-          handleChange({
-            ...event,
+          handleChange(__spreadProps$3(__spreadValues$3({}, event), {
             level: "warning"
-          });
+          }));
           break bb5;
         }
         case "annotation.add":
@@ -7059,6 +6362,14 @@ function RouteEventsToChanges(props) {
     };
   }, t2 = [props.editorActor, handleChange], $[2] = handleChange, $[3] = props.editorActor, $[4] = t1, $[5] = t2) : (t1 = $[4], t2 = $[5]), useEffect(t1, t2), null;
 }
+var __defProp$2 = Object.defineProperty, __defProps$2 = Object.defineProperties, __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$2 = Object.getOwnPropertySymbols, __hasOwnProp$2 = Object.prototype.hasOwnProperty, __propIsEnum$2 = Object.prototype.propertyIsEnumerable, __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b))
+      __propIsEnum$2.call(b, prop) && __defNormalProp$2(a, prop, b[prop]);
+  return a;
+}, __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
 const debug$3 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (props) => {
   const {
     editorActor,
@@ -7070,10 +6381,13 @@ const debug$3 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     renderDecorator,
     renderAnnotation
   } = props, spanRef = useRef(null), portableTextEditor = usePortableTextEditor(), blockSelected = useSelected(), [focused, setFocused] = useState(!1), [selected, setSelected] = useState(!1), block = children.props.parent, path = useMemo(() => block ? [{
-    _key: block?._key
+    _key: block == null ? void 0 : block._key
   }, "children", {
     _key: leaf._key
-  }] : [], [block, leaf._key]), decoratorValues = useMemo(() => schemaTypes.decorators.map((dec) => dec.value), [schemaTypes.decorators]), marks = useMemo(() => uniq((leaf.marks || EMPTY_MARKS).filter((mark) => decoratorValues.includes(mark))), [decoratorValues, leaf.marks]), annotationMarks = Array.isArray(leaf.marks) ? leaf.marks : EMPTY_MARKS, annotations = useMemo(() => annotationMarks.map((mark_0) => !decoratorValues.includes(mark_0) && block?.markDefs?.find((def) => def._key === mark_0)).filter(Boolean), [annotationMarks, block, decoratorValues]), shouldTrackSelectionAndFocus = annotations.length > 0 && blockSelected;
+  }] : [], [block, leaf._key]), decoratorValues = useMemo(() => schemaTypes.decorators.map((dec) => dec.value), [schemaTypes.decorators]), marks = useMemo(() => uniq((leaf.marks || EMPTY_MARKS).filter((mark) => decoratorValues.includes(mark))), [decoratorValues, leaf.marks]), annotationMarks = Array.isArray(leaf.marks) ? leaf.marks : EMPTY_MARKS, annotations = useMemo(() => annotationMarks.map((mark_0) => {
+    var _a;
+    return !decoratorValues.includes(mark_0) && ((_a = block == null ? void 0 : block.markDefs) == null ? void 0 : _a.find((def) => def._key === mark_0));
+  }).filter(Boolean), [annotationMarks, block, decoratorValues]), shouldTrackSelectionAndFocus = annotations.length > 0 && blockSelected;
   useEffect(() => {
     if (!shouldTrackSelectionAndFocus) {
       setFocused(!1);
@@ -7180,7 +6494,7 @@ const debug$3 = debugWithName("components:Leaf"), EMPTY_MARKS = [], Leaf = (prop
     }
     return returnedChildren;
   }, [annotations, block, children, focused, leaf, marks, path, renderAnnotation, renderChild, renderDecorator, schemaTypes.annotations, schemaTypes.decorators, schemaTypes.span, selected]);
-  return useMemo(() => /* @__PURE__ */ jsx("span", { ...attributes, ref: spanRef, children: content }, leaf._key), [leaf, attributes, content]);
+  return useMemo(() => /* @__PURE__ */ jsx("span", __spreadProps$2(__spreadValues$2({}, attributes), { ref: spanRef, children: content }), leaf._key), [leaf, attributes, content]);
 };
 Leaf.displayName = "Leaf";
 const debug$2 = debugWithName("plugin:withHotKeys"), DEFAULT_HOTKEYS = {
@@ -7233,10 +6547,32 @@ function createWithHotkeys(editorActor, portableTextEditor, hotkeysFromOptions)
     }, editor;
   };
 }
+var __defProp$1 = Object.defineProperty, __defProps$1 = Object.defineProperties, __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors, __getOwnPropSymbols$1 = Object.getOwnPropertySymbols, __hasOwnProp$1 = Object.prototype.hasOwnProperty, __propIsEnum$1 = Object.prototype.propertyIsEnumerable, __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp$1.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b))
+      __propIsEnum$1.call(b, prop) && __defNormalProp$1(a, prop, b[prop]);
+  return a;
+}, __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b)), __objRest$1 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    __hasOwnProp$1.call(source, prop) && exclude.indexOf(prop) < 0 && (target[prop] = source[prop]);
+  if (source != null && __getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(source))
+      exclude.indexOf(prop) < 0 && __propIsEnum$1.call(source, prop) && (target[prop] = source[prop]);
+  return target;
+};
 const debug$1 = debugWithName("plugin:withInsertData");
 function createWithInsertData(editorActor, schemaTypes) {
   return function(editor) {
-    const blockTypeName = schemaTypes.block.name, spanTypeName = schemaTypes.span.name, whitespaceOnPasteMode = schemaTypes.block.options.unstable_whitespaceOnPasteMode, toPlainText = (blocks) => blocks.map((block) => editor.isTextBlock(block) ? block.children.map((child) => child._type === spanTypeName ? child.text : `[${schemaTypes.inlineObjects.find((t) => t.name === child._type)?.title || "Object"}]`).join("") : `[${schemaTypes.blockObjects.find((t) => t.name === block._type)?.title || "Object"}]`).join(`
+    const blockTypeName = schemaTypes.block.name, spanTypeName = schemaTypes.span.name, whitespaceOnPasteMode = schemaTypes.block.options.unstable_whitespaceOnPasteMode, toPlainText = (blocks) => blocks.map((block) => {
+      var _a;
+      return editor.isTextBlock(block) ? block.children.map((child) => {
+        var _a2;
+        return child._type === spanTypeName ? child.text : `[${((_a2 = schemaTypes.inlineObjects.find((t) => t.name === child._type)) == null ? void 0 : _a2.title) || "Object"}]`;
+      }).join("") : `[${((_a = schemaTypes.blockObjects.find((t) => t.name === block._type)) == null ? void 0 : _a.title) || "Object"}]`;
+    }).join(`
 
 `);
     return editor.setFragmentData = (data, originEvent) => {
@@ -7274,6 +6610,7 @@ function createWithInsertData(editorActor, schemaTypes) {
       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$1("text", asPlainText), data.setData("application/x-portable-text-event-origin", originEvent || "external"), debug$1("Set fragment data", asJSON, asHTML);
     }, editor.insertPortableTextData = (data) => {
+      var _a, _b;
       if (!editor.selection)
         return !1;
       const pText = data.getData("application/x-portable-text"), origin = data.getData("application/x-portable-text-event-origin");
@@ -7283,8 +6620,8 @@ function createWithInsertData(editorActor, schemaTypes) {
           const slateValue = _regenerateKeys(editor, toSlateValue(parsed, {
             schemaTypes
           }), editorActor.getSnapshot().context.keyGenerator, spanTypeName, schemaTypes), validation = validateValue(parsed, schemaTypes, editorActor.getSnapshot().context.keyGenerator);
-          if (!validation.valid && !validation.resolution?.autoResolve) {
-            const errorDescription = `${validation.resolution?.description}`;
+          if (!validation.valid && !((_a = validation.resolution) != null && _a.autoResolve)) {
+            const errorDescription = `${(_b = validation.resolution) == null ? void 0 : _b.description}`;
             return editorActor.send({
               type: "error",
               name: "pasteError",
@@ -7297,6 +6634,7 @@ function createWithInsertData(editorActor, schemaTypes) {
       }
       return !1;
     }, editor.insertTextOrHTMLData = (data) => {
+      var _a;
       if (!editor.selection)
         return debug$1("No selection, not inserting"), !1;
       const html = data.getData("text/html"), text = data.getData("text/plain");
@@ -7323,7 +6661,7 @@ function createWithInsertData(editorActor, schemaTypes) {
         const validation = validateValue(portableText, schemaTypes, editorActor.getSnapshot().context.keyGenerator);
         if (!validation.valid) {
           const errorDescription = `Could not validate the resulting portable text to insert.
-${validation.resolution?.description}
+${(_a = validation.resolution) == null ? void 0 : _a.description}
 Try to insert as plain text (shift-paste) instead.`;
           return editorActor.send({
             type: "error",
@@ -7362,46 +6700,37 @@ function escapeHtml(str) {
 }
 function _regenerateKeys(editor, fragment, keyGenerator, spanTypeName, editorTypes) {
   return fragment.map((node) => {
-    const newNode = {
-      ...node
-    };
+    const newNode = __spreadValues$1({}, node);
     if (editor.isTextBlock(newNode)) {
       const annotations = editorTypes.annotations.map((t) => t.name);
       if (annotations.length === 0) {
-        const {
-          markDefs,
-          ...NewNodeNoDefs
-        } = newNode;
-        return {
-          ...NewNodeNoDefs,
+        const _a = newNode, NewNodeNoDefs = __objRest$1(_a, [
+          "markDefs"
+        ]);
+        return __spreadProps$1(__spreadValues$1({}, NewNodeNoDefs), {
           _key: keyGenerator()
-        };
+        });
       }
       if ((newNode.markDefs || []).some((def) => !annotations.includes(def._type))) {
         const allowedAnnotations = (newNode.markDefs || []).filter((def) => annotations.includes(def._type));
-        return {
-          ...newNode,
+        return __spreadProps$1(__spreadValues$1({}, newNode), {
           markDefs: allowedAnnotations,
           _key: keyGenerator()
-        };
+        });
       }
       newNode.markDefs = (newNode.markDefs || []).map((def) => {
         const oldKey = def._key, newKey = keyGenerator();
-        return newNode.children = newNode.children.map((child) => child._type === spanTypeName && editor.isTextSpan(child) ? {
-          ...child,
+        return newNode.children = newNode.children.map((child) => child._type === spanTypeName && editor.isTextSpan(child) ? __spreadProps$1(__spreadValues$1({}, child), {
           marks: child.marks && child.marks.includes(oldKey) ? [...child.marks].filter((mark) => mark !== oldKey).concat(newKey) : child.marks
-        } : child), {
-          ...def,
+        }) : child), __spreadProps$1(__spreadValues$1({}, def), {
           _key: newKey
-        };
+        });
       });
     }
-    const nodeWithNewKeys = {
-      ...newNode,
+    const nodeWithNewKeys = __spreadProps$1(__spreadValues$1({}, newNode), {
       _key: keyGenerator()
-    };
-    return editor.isTextBlock(nodeWithNewKeys) && (nodeWithNewKeys.children = nodeWithNewKeys.children.map((child) => ({
-      ...child,
+    });
+    return editor.isTextBlock(nodeWithNewKeys) && (nodeWithNewKeys.children = nodeWithNewKeys.children.map((child) => __spreadProps$1(__spreadValues$1({}, child), {
       _key: keyGenerator()
     }))), nodeWithNewKeys;
   });
@@ -7440,6 +6769,22 @@ function withSyncRangeDecorations(slateEditor, syncRangeDecorations) {
     slateEditor.apply = originalApply;
   };
 }
+var __defProp2 = Object.defineProperty, __defProps = Object.defineProperties, __getOwnPropDescs = Object.getOwnPropertyDescriptors, __getOwnPropSymbols2 = Object.getOwnPropertySymbols, __hasOwnProp2 = Object.prototype.hasOwnProperty, __propIsEnum2 = Object.prototype.propertyIsEnumerable, __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, __spreadValues2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    __hasOwnProp2.call(b, prop) && __defNormalProp2(a, prop, b[prop]);
+  if (__getOwnPropSymbols2)
+    for (var prop of __getOwnPropSymbols2(b))
+      __propIsEnum2.call(b, prop) && __defNormalProp2(a, prop, b[prop]);
+  return a;
+}, __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b)), __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    __hasOwnProp2.call(source, prop) && exclude.indexOf(prop) < 0 && (target[prop] = source[prop]);
+  if (source != null && __getOwnPropSymbols2)
+    for (var prop of __getOwnPropSymbols2(source))
+      exclude.indexOf(prop) < 0 && __propIsEnum2.call(source, prop) && (target[prop] = source[prop]);
+  return target;
+};
 const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
   position: "absolute",
   userSelect: "none",
@@ -7447,7 +6792,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
   left: 0,
   right: 0
 }, PortableTextEditable = forwardRef(function(props, forwardedRef) {
-  const {
+  const _a = props, {
     hotkeys,
     onBlur,
     onFocus,
@@ -7465,9 +6810,27 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     renderStyle,
     selection: propsSelection,
     scrollSelectionIntoView,
-    spellCheck,
-    ...restProps
-  } = props, portableTextEditor = usePortableTextEditor(), ref = useRef(null), [editableElement, setEditableElement] = useState(null), [hasInvalidValue, setHasInvalidValue] = useState(!1), [rangeDecorationState, setRangeDecorationsState] = useState([]);
+    spellCheck
+  } = _a, restProps = __objRest(_a, [
+    "hotkeys",
+    "onBlur",
+    "onFocus",
+    "onBeforeInput",
+    "onPaste",
+    "onCopy",
+    "onClick",
+    "rangeDecorations",
+    "renderAnnotation",
+    "renderBlock",
+    "renderChild",
+    "renderDecorator",
+    "renderListItem",
+    "renderPlaceholder",
+    "renderStyle",
+    "selection",
+    "scrollSelectionIntoView",
+    "spellCheck"
+  ]), portableTextEditor = usePortableTextEditor(), ref = useRef(null), [editableElement, setEditableElement] = useState(null), [hasInvalidValue, setHasInvalidValue] = useState(!1), [rangeDecorationState, setRangeDecorationsState] = useState([]);
   useImperativeHandle(forwardedRef, () => ref.current);
   const rangeDecorationsRef = useRef(rangeDecorations), editorActor = useContext(EditorActorContext), readOnly = useSelector(editorActor, (s) => s.context.readOnly), schemaTypes = useSelector(editorActor, (s_0) => s_0.context.schema), slateEditor = useSlate(), blockTypeName = schemaTypes.block.name;
   useMemo(() => {
@@ -7477,9 +6840,9 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     const withHotKeys = createWithHotkeys(editorActor, portableTextEditor, hotkeys);
     return debug("Editable is in edit mode"), withInsertData(withHotKeys(slateEditor));
   }, [editorActor, hotkeys, portableTextEditor, readOnly, schemaTypes, slateEditor]);
-  const renderElement = useCallback((eProps) => /* @__PURE__ */ jsx(Element, { ...eProps, readOnly, renderBlock, renderChild, renderListItem, renderStyle, schemaTypes, spellCheck }), [schemaTypes, spellCheck, readOnly, renderBlock, renderChild, renderListItem, renderStyle]), renderLeaf = useCallback((lProps) => {
+  const renderElement = useCallback((eProps) => /* @__PURE__ */ jsx(Element, __spreadProps(__spreadValues2({}, eProps), { readOnly, renderBlock, renderChild, renderListItem, renderStyle, schemaTypes, spellCheck })), [schemaTypes, spellCheck, readOnly, renderBlock, renderChild, renderListItem, renderStyle]), renderLeaf = useCallback((lProps) => {
     if (lProps.leaf._type === "span") {
-      let rendered = /* @__PURE__ */ jsx(Leaf, { ...lProps, editorActor, schemaTypes, renderAnnotation, renderChild, renderDecorator, readOnly });
+      let rendered = /* @__PURE__ */ jsx(Leaf, __spreadProps(__spreadValues2({}, lProps), { editorActor, schemaTypes, renderAnnotation, renderChild, renderDecorator, readOnly }));
       if (renderPlaceholder && lProps.leaf.placeholder && lProps.text.text === "")
         return /* @__PURE__ */ jsxs(Fragment, { children: [
           /* @__PURE__ */ jsx("span", { style: PLACEHOLDER_STYLE, contentEditable: !1, children: renderPlaceholder() }),
@@ -7526,10 +6889,9 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
             origin: "local"
           });
         }
-        newRange !== null && newSlateRanges.push({
-          ...newRange || slateRange_0,
+        newRange !== null && newSlateRanges.push(__spreadProps(__spreadValues2({}, newRange || slateRange_0), {
           rangeDecoration: rangeDecorationItem
-        });
+        }));
       }), newSlateRanges.length > 0) {
         setRangeDecorationsState(newSlateRanges);
         return;
@@ -7571,7 +6933,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
       nativeEvent: event
     });
   }, [onCopy, editorActor, slateEditor]), handlePaste = useCallback((event_0) => {
-    const value_0 = PortableTextEditor.getValue(portableTextEditor), path = toPortableTextRange(value_0, slateEditor.selection, schemaTypes)?.focus.path || [], onPasteResult = onPaste?.({
+    const value_0 = PortableTextEditor.getValue(portableTextEditor), ptRange = toPortableTextRange(value_0, slateEditor.selection, schemaTypes), path = (ptRange == null ? void 0 : ptRange.focus.path) || [], onPasteResult = onPaste == null ? void 0 : onPaste({
       event: event_0,
       value: value_0,
       path,
@@ -7636,8 +6998,8 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     const existingDOMRange = domSelection.getRangeAt(0);
     try {
       const newDOMRange = 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 {
+      (newDOMRange.startOffset !== existingDOMRange.startOffset || newDOMRange.endOffset !== existingDOMRange.endOffset) && (debug("DOM range out of sync, validating selection"), domSelection == null || domSelection.removeAllRanges(), domSelection.addRange(newDOMRange));
+    } catch (e) {
       debug("Could not resolve selection, selecting top document"), Transforms.deselect(slateEditor), slateEditor.children.length > 0 && Transforms.select(slateEditor, [0, 0]), slateEditor.onChange();
     }
   }, [ref, slateEditor]);
@@ -7725,8 +7087,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
     ref.current = ReactEditor.toDOMNode(slateEditor, slateEditor), setEditableElement(ref.current);
   }, [slateEditor, ref]), portableTextEditor ? hasInvalidValue ? null : /* @__PURE__ */ jsx(
     Editable,
-    {
-      ...restProps,
+    __spreadProps(__spreadValues2({}, restProps), {
       autoFocus: !1,
       className: restProps.className || "pt-editable",
       decorate,
@@ -7743,7 +7104,7 @@ const debug = debugWithName("component:Editable"), PLACEHOLDER_STYLE = {
       renderElement,
       renderLeaf,
       scrollSelectionIntoView: scrollSelectionIntoViewToSlate
-    }
+    })
   ) : null;
 });
 PortableTextEditable.displayName = "ForwardRef(PortableTextEditable)";
@@ -7820,12 +7181,6 @@ export {
   EditorProvider,
   PortableTextEditable,
   PortableTextEditor,
-  coreBehavior,
-  coreBehaviors,
-  createCodeEditorBehaviors,
-  createLinkBehaviors,
-  createMarkdownBehaviors,
-  defineBehavior,
   defineSchema,
   editorMachine,
   defaultKeyGenerator as keyGenerator,