@portabletext/editor 1.48.9 → 1.48.11

package/lib/_chunks-es/editor-provider.js

@@ -11,7 +11,7 @@ import { unset, set, setIfMissing, insert, diffMatchPatch as diffMatchPatch$1, a
 import flatten from "lodash/flatten.js";
 import isPlainObject from "lodash/isPlainObject.js";
 import uniq from "lodash/uniq.js";
-import { isTextBlock, parseBlock, sliceBlocks, parseAnnotation, blockOffsetToSpanSelectionPoint, parseInlineObject, isSpan, isListBlock, isEmptyTextBlock, getBlockEndPoint, getBlockStartPoint, getTextBlockText } from "./util.slice-blocks.js";
+import { isTextBlock, parseBlock, sliceBlocks, parseAnnotation, blockOffsetToSpanSelectionPoint, parseInlineObject, isSpan$1 as isSpan, isListBlock, isEmptyTextBlock, getBlockStartPoint, getBlockEndPoint, isEqualSelectionPoints, getTextBlockText } from "./util.slice-blocks.js";
 import getRandomValues from "get-random-values-esm";
 import { htmlToBlocks } from "@portabletext/block-tools";
 import { toHTML } from "@portabletext/to-html";
@@ -21,13 +21,11 @@ import isUndefined from "lodash/isUndefined.js";
 import omitBy from "lodash/omitBy.js";
 import { isKeySegment, defineType, defineField, isPortableTextSpan as isPortableTextSpan$1 } from "@sanity/types";
 import omit from "lodash/omit.js";
-import { selectionPointToBlockOffset, blockOffsetsToSelection } from "./util.selection-point-to-block-offset.js";
-import { getTrimmedSelection, isActiveAnnotation, isActiveDecorator, getSelectedTextBlocks, isActiveListItem, isActiveStyle, isSelectingEntireBlocks, getActiveAnnotations } from "./selector.is-selecting-entire-blocks.js";
+import { selectionPointToBlockOffset, blockOffsetsToSelection, getSelectionStartPoint, getSelectionEndPoint } from "./util.selection-point-to-block-offset.js";
+import { getTrimmedSelection, isSelectionCollapsed, getCaretWordSelection, isSelectionExpanded, getFocusBlockObject, getPreviousBlock, getNextBlock, getFocusTextBlock, isOverlappingSelection, isAtTheEndOfBlock, getFocusSpan, isAtTheStartOfBlock, getFirstBlock as getFirstBlock$1, getLastBlock as getLastBlock$1, getSelectedBlocks, getSelectionStartBlock as getSelectionStartBlock$1, getSelectionEndBlock as getSelectionEndBlock$1, getFocusListBlock, isActiveAnnotation, isActiveDecorator, getSelectedTextBlocks, isActiveListItem, isActiveStyle, isSelectingEntireBlocks, getActiveAnnotations } from "./selector.is-selecting-entire-blocks.js";
 import { DOMEditor } from "slate-dom";
 import startCase from "lodash.startcase";
-import { defineBehavior, raise, coreBehaviors } from "./behavior.core.js";
-import { getFocusTextBlock, getPreviousBlock, getNextBlock, getFocusBlockObject, getFocusSpan, isSelectionCollapsed, isOverlappingSelection, getSelectedBlocks, isSelectionExpanded } from "./selector.is-overlapping-selection.js";
-import { getSelectionStartPoint, getSelectionEndPoint } from "./util.get-selection-start-point.js";
+import { defineBehavior, raise } from "../behaviors/index.js";
 import { Subject } from "rxjs";
 import { useEffectEvent } from "use-effect-event";
 const rootName = "sanity-pte:";
@@ -1652,8 +1650,11 @@ const debug$d = debugWithName("sync machine"), syncValueCallback = ({
         event
       }) => (assertEvent(event, "done syncing"), event.value)
     }),
-    "emit done syncing initial value": emit({
-      type: "done syncing initial value"
+    "emit done syncing value": emit({
+      type: "done syncing value"
+    }),
+    "emit syncing value": emit({
+      type: "syncing value"
     })
   },
   guards: {
@@ -1729,7 +1730,7 @@ const debug$d = debugWithName("sync machine"), syncValueCallback = ({
           }
         },
         "done syncing initial value": {
-          entry: ["emit done syncing initial value", () => {
+          entry: ["emit done syncing value", () => {
             debug$d("entry: done syncing initial value");
           }],
           exit: [() => {
@@ -1788,10 +1789,10 @@ const debug$d = debugWithName("sync machine"), syncValueCallback = ({
         syncing: {
           entry: [() => {
             debug$d("entry: syncing->syncing");
-          }],
+          }, "emit syncing value"],
           exit: [() => {
             debug$d("exit: syncing->syncing");
-          }],
+          }, "emit done syncing value"],
           always: {
             guard: "pending value equals previous value",
             target: "idle",
@@ -5720,7 +5721,6 @@ function editorConfigToMachineInput(config) {
     schema
   } = compileSchemasFromEditorConfig(config);
   return {
-    behaviors: config.behaviors,
     converters: createCoreConverters(legacySchema),
     getLegacySchema: () => legacySchema,
     keyGenerator: config.keyGenerator ?? defaultKeyGenerator,
@@ -5752,7 +5752,6 @@ function createInternalEditor(editorActor) {
       switch (event.type) {
         case "add behavior":
         case "remove behavior":
-        case "update behaviors":
         case "update key generator":
         case "update readOnly":
         case "patches":
@@ -5834,7 +5833,669 @@ function createGloballyScopedContext(key, defaultValue) {
   const symbol = Symbol.for(key);
   return typeof document > "u" ? createContext(defaultValue) : (globalScope[symbol] = globalScope[symbol] ?? createContext(defaultValue), globalScope[symbol]);
 }
-const EditorContext = createGloballyScopedContext("@portabletext/editor/context/editor", null), abstractAnnotationBehaviors = [defineBehavior({
+const EditorContext = createGloballyScopedContext("@portabletext/editor/context/editor", null), addAnnotationOnCollapsedSelection = defineBehavior({
+  on: "annotation.add",
+  guard: ({
+    snapshot
+  }) => {
+    if (!isSelectionCollapsed(snapshot))
+      return !1;
+    const caretWordSelection = getCaretWordSelection(snapshot);
+    return !caretWordSelection || !isSelectionExpanded({
+      context: {
+        ...snapshot.context,
+        selection: caretWordSelection
+      }
+    }) ? !1 : {
+      caretWordSelection
+    };
+  },
+  actions: [({
+    event
+  }, {
+    caretWordSelection
+  }) => [raise({
+    type: "select",
+    at: caretWordSelection
+  }), raise({
+    type: "annotation.add",
+    annotation: event.annotation
+  })]]
+}), coreAnnotationBehaviors = {
+  addAnnotationOnCollapsedSelection
+}, 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;
+}
+const arrowDownOnLonelyBlockObject = defineBehavior({
+  on: "keyboard.keydown",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    if (!isHotkey("ArrowDown", event.originEvent) || !isSelectionCollapsed(snapshot))
+      return !1;
+    const focusBlockObject = getFocusBlockObject(snapshot), nextBlock = getNextBlock(snapshot);
+    return focusBlockObject && !nextBlock;
+  },
+  actions: [({
+    snapshot
+  }) => [raise({
+    type: "insert.block",
+    block: {
+      _type: snapshot.context.schema.block.name
+    },
+    placement: "after"
+  })]]
+}), arrowUpOnLonelyBlockObject = defineBehavior({
+  on: "keyboard.keydown",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    if (!isHotkey("ArrowUp", event.originEvent) || !isSelectionCollapsed(snapshot))
+      return !1;
+    const focusBlockObject = getFocusBlockObject(snapshot), previousBlock = getPreviousBlock(snapshot);
+    return focusBlockObject && !previousBlock;
+  },
+  actions: [({
+    snapshot
+  }) => [raise({
+    type: "insert.block",
+    block: {
+      _type: snapshot.context.schema.block.name
+    },
+    placement: "before"
+  })]]
+}), breakingBlockObject = defineBehavior({
+  on: "insert.break",
+  guard: ({
+    snapshot
+  }) => {
+    const focusBlockObject = getFocusBlockObject(snapshot);
+    return isSelectionCollapsed(snapshot) && focusBlockObject !== void 0;
+  },
+  actions: [({
+    snapshot
+  }) => [raise({
+    type: "insert.block",
+    block: {
+      _type: snapshot.context.schema.block.name
+    },
+    placement: "after"
+  })]]
+}), clickingAboveLonelyBlockObject = defineBehavior({
+  on: "mouse.click",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    if (snapshot.context.readOnly || snapshot.context.selection && !isSelectionCollapsed(snapshot))
+      return !1;
+    const focusBlockObject = getFocusBlockObject({
+      context: {
+        ...snapshot.context,
+        selection: event.position.selection
+      }
+    }), previousBlock = getPreviousBlock({
+      context: {
+        ...snapshot.context,
+        selection: event.position.selection
+      }
+    });
+    return event.position.isEditor && event.position.block === "start" && focusBlockObject && !previousBlock;
+  },
+  actions: [({
+    snapshot,
+    event
+  }) => [raise({
+    type: "select",
+    at: event.position.selection
+  }), raise({
+    type: "insert.block",
+    block: {
+      _type: snapshot.context.schema.block.name
+    },
+    placement: "before",
+    select: "start"
+  })]]
+}), clickingBelowLonelyBlockObject = defineBehavior({
+  on: "mouse.click",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    if (snapshot.context.readOnly || snapshot.context.selection && !isSelectionCollapsed(snapshot))
+      return !1;
+    const focusBlockObject = getFocusBlockObject({
+      context: {
+        ...snapshot.context,
+        selection: event.position.selection
+      }
+    }), nextBlock = getNextBlock({
+      context: {
+        ...snapshot.context,
+        selection: event.position.selection
+      }
+    });
+    return event.position.isEditor && event.position.block === "end" && focusBlockObject && !nextBlock;
+  },
+  actions: [({
+    snapshot,
+    event
+  }) => [raise({
+    type: "select",
+    at: event.position.selection
+  }), raise({
+    type: "insert.block",
+    block: {
+      _type: snapshot.context.schema.block.name
+    },
+    placement: "after",
+    select: "start"
+  })]]
+}), deletingEmptyTextBlockAfterBlockObject = defineBehavior({
+  on: "delete.backward",
+  guard: ({
+    snapshot
+  }) => {
+    const focusTextBlock = getFocusTextBlock(snapshot), selectionCollapsed = isSelectionCollapsed(snapshot), previousBlock = getPreviousBlock(snapshot);
+    return !focusTextBlock || !selectionCollapsed || !previousBlock ? !1 : isEmptyTextBlock(snapshot.context, focusTextBlock.node) && !isTextBlock(snapshot.context, previousBlock.node) ? {
+      focusTextBlock,
+      previousBlock
+    } : !1;
+  },
+  actions: [(_, {
+    focusTextBlock,
+    previousBlock
+  }) => [raise({
+    type: "delete.block",
+    at: focusTextBlock.path
+  }), raise({
+    type: "select",
+    at: {
+      anchor: {
+        path: previousBlock.path,
+        offset: 0
+      },
+      focus: {
+        path: previousBlock.path,
+        offset: 0
+      }
+    }
+  })]]
+}), deletingEmptyTextBlockBeforeBlockObject = defineBehavior({
+  on: "delete.forward",
+  guard: ({
+    snapshot
+  }) => {
+    const focusTextBlock = getFocusTextBlock(snapshot), selectionCollapsed = isSelectionCollapsed(snapshot), nextBlock = getNextBlock(snapshot);
+    return !focusTextBlock || !selectionCollapsed || !nextBlock ? !1 : isEmptyTextBlock(snapshot.context, focusTextBlock.node) && !isTextBlock(snapshot.context, nextBlock.node) ? {
+      focusTextBlock,
+      nextBlock
+    } : !1;
+  },
+  actions: [(_, {
+    focusTextBlock,
+    nextBlock
+  }) => [raise({
+    type: "delete.block",
+    at: focusTextBlock.path
+  }), raise({
+    type: "select",
+    at: {
+      anchor: {
+        path: nextBlock.path,
+        offset: 0
+      },
+      focus: {
+        path: nextBlock.path,
+        offset: 0
+      }
+    }
+  })]]
+}), coreBlockObjectBehaviors = {
+  arrowDownOnLonelyBlockObject,
+  arrowUpOnLonelyBlockObject,
+  breakingBlockObject,
+  clickingAboveLonelyBlockObject,
+  clickingBelowLonelyBlockObject,
+  deletingEmptyTextBlockAfterBlockObject,
+  deletingEmptyTextBlockBeforeBlockObject
+}, coreDecoratorBehaviors = {
+  strongShortcut: defineBehavior({
+    on: "keyboard.keydown",
+    guard: ({
+      snapshot,
+      event
+    }) => isHotkey("mod+b", event.originEvent) && snapshot.context.schema.decorators.some((decorator) => decorator.name === "strong"),
+    actions: [() => [raise({
+      type: "decorator.toggle",
+      decorator: "strong"
+    })]]
+  }),
+  emShortcut: defineBehavior({
+    on: "keyboard.keydown",
+    guard: ({
+      snapshot,
+      event
+    }) => isHotkey("mod+i", event.originEvent) && snapshot.context.schema.decorators.some((decorator) => decorator.name === "em"),
+    actions: [() => [raise({
+      type: "decorator.toggle",
+      decorator: "em"
+    })]]
+  }),
+  underlineShortcut: defineBehavior({
+    on: "keyboard.keydown",
+    guard: ({
+      snapshot,
+      event
+    }) => isHotkey("mod+u", event.originEvent) && snapshot.context.schema.decorators.some((decorator) => decorator.name === "underline"),
+    actions: [() => [raise({
+      type: "decorator.toggle",
+      decorator: "underline"
+    })]]
+  }),
+  codeShortcut: defineBehavior({
+    on: "keyboard.keydown",
+    guard: ({
+      snapshot,
+      event
+    }) => isHotkey("mod+'", event.originEvent) && snapshot.context.schema.decorators.some((decorator) => decorator.name === "code"),
+    actions: [() => [raise({
+      type: "decorator.toggle",
+      decorator: "code"
+    })]]
+  })
+}, coreDndBehaviors = [
+  /**
+   * When dragging over the drag origin, we don't want to show the caret in the
+   * text.
+   */
+  defineBehavior({
+    on: "drag.dragover",
+    guard: ({
+      snapshot,
+      event
+    }) => {
+      const dragOrigin = snapshot.beta.internalDrag?.origin;
+      return dragOrigin ? isOverlappingSelection(event.position.selection)({
+        ...snapshot,
+        context: {
+          ...snapshot.context,
+          selection: dragOrigin.selection
+        }
+      }) : !1;
+    },
+    actions: []
+  })
+], breakingAtTheEndOfTextBlock = defineBehavior({
+  on: "insert.break",
+  guard: ({
+    snapshot
+  }) => {
+    const focusTextBlock = getFocusTextBlock(snapshot), selectionCollapsed = isSelectionCollapsed(snapshot);
+    if (!snapshot.context.selection || !focusTextBlock || !selectionCollapsed)
+      return !1;
+    const atTheEndOfBlock = isAtTheEndOfBlock(focusTextBlock)(snapshot), focusListItem = focusTextBlock.node.listItem, focusLevel = focusTextBlock.node.level;
+    return atTheEndOfBlock ? {
+      focusListItem,
+      focusLevel
+    } : !1;
+  },
+  actions: [({
+    snapshot
+  }, {
+    focusListItem,
+    focusLevel
+  }) => [raise({
+    type: "insert.block",
+    block: {
+      _type: snapshot.context.schema.block.name,
+      children: [{
+        _type: snapshot.context.schema.span.name,
+        text: "",
+        marks: []
+      }],
+      markDefs: [],
+      listItem: focusListItem,
+      level: focusLevel,
+      style: snapshot.context.schema.styles[0]?.name
+    },
+    placement: "after"
+  })]]
+}), breakingAtTheStartOfTextBlock = defineBehavior({
+  on: "insert.break",
+  guard: ({
+    snapshot
+  }) => {
+    const focusTextBlock = getFocusTextBlock(snapshot), selectionCollapsed = isSelectionCollapsed(snapshot);
+    if (!snapshot.context.selection || !focusTextBlock || !selectionCollapsed)
+      return !1;
+    const focusSpan = getFocusSpan(snapshot), focusDecorators = focusSpan?.node.marks?.filter((mark) => snapshot.context.schema.decorators.some((decorator) => decorator.name === mark) ?? []), focusAnnotations = focusSpan?.node.marks?.filter((mark) => !snapshot.context.schema.decorators.some((decorator) => decorator.name === mark)) ?? [], focusListItem = focusTextBlock.node.listItem, focusLevel = focusTextBlock.node.level;
+    return isAtTheStartOfBlock(focusTextBlock)(snapshot) ? {
+      focusAnnotations,
+      focusDecorators,
+      focusListItem,
+      focusLevel
+    } : !1;
+  },
+  actions: [({
+    snapshot
+  }, {
+    focusAnnotations,
+    focusDecorators,
+    focusListItem,
+    focusLevel
+  }) => [raise({
+    type: "insert.block",
+    block: {
+      _type: snapshot.context.schema.block.name,
+      children: [{
+        _type: snapshot.context.schema.span.name,
+        marks: focusAnnotations.length === 0 ? focusDecorators : [],
+        text: ""
+      }],
+      listItem: focusListItem,
+      level: focusLevel,
+      style: snapshot.context.schema.styles[0]?.name
+    },
+    placement: "before",
+    select: "none"
+  })]]
+}), breakingEntireDocument = defineBehavior({
+  on: "insert.break",
+  guard: ({
+    snapshot
+  }) => {
+    if (!snapshot.context.selection || !isSelectionExpanded(snapshot))
+      return !1;
+    const firstBlock = getFirstBlock$1(snapshot), lastBlock = getLastBlock$1(snapshot);
+    if (!firstBlock || !lastBlock)
+      return !1;
+    const firstBlockStartPoint = getBlockStartPoint({
+      context: snapshot.context,
+      block: firstBlock
+    }), selectionStartPoint = getSelectionStartPoint(snapshot.context.selection), lastBlockEndPoint = getBlockEndPoint({
+      context: snapshot.context,
+      block: lastBlock
+    }), selectionEndPoint = getSelectionEndPoint(snapshot.context.selection);
+    return isEqualSelectionPoints(firstBlockStartPoint, selectionStartPoint) && isEqualSelectionPoints(lastBlockEndPoint, selectionEndPoint) ? {
+      selection: snapshot.context.selection
+    } : !1;
+  },
+  actions: [(_, {
+    selection
+  }) => [raise({
+    type: "delete",
+    at: selection
+  })]]
+}), breakingEntireBlocks = defineBehavior({
+  on: "insert.break",
+  guard: ({
+    snapshot
+  }) => {
+    if (!snapshot.context.selection || !isSelectionExpanded(snapshot))
+      return !1;
+    const selectedBlocks = getSelectedBlocks(snapshot), selectionStartBlock = getSelectionStartBlock$1(snapshot), selectionEndBlock = getSelectionEndBlock$1(snapshot);
+    if (!selectionStartBlock || !selectionEndBlock)
+      return !1;
+    const startBlockStartPoint = getBlockStartPoint({
+      context: snapshot.context,
+      block: selectionStartBlock
+    }), selectionStartPoint = getSelectionStartPoint(snapshot.context.selection), endBlockEndPoint = getBlockEndPoint({
+      context: snapshot.context,
+      block: selectionEndBlock
+    }), selectionEndPoint = getSelectionEndPoint(snapshot.context.selection);
+    return isEqualSelectionPoints(selectionStartPoint, startBlockStartPoint) && isEqualSelectionPoints(selectionEndPoint, endBlockEndPoint) ? {
+      selectedBlocks
+    } : !1;
+  },
+  actions: [({
+    snapshot
+  }, {
+    selectedBlocks
+  }) => [raise({
+    type: "insert.block",
+    block: {
+      _type: snapshot.context.schema.block.name,
+      children: [{
+        _type: snapshot.context.schema.span.name,
+        text: "",
+        marks: []
+      }]
+    },
+    placement: "before",
+    select: "start"
+  }), ...selectedBlocks.map((block) => raise({
+    type: "delete.block",
+    at: block.path
+  }))]]
+}), coreInsertBreakBehaviors = {
+  breakingAtTheEndOfTextBlock,
+  breakingAtTheStartOfTextBlock,
+  breakingEntireDocument,
+  breakingEntireBlocks
+}, MAX_LIST_LEVEL = 10, clearListOnBackspace = defineBehavior({
+  on: "delete.backward",
+  guard: ({
+    snapshot
+  }) => {
+    const selectionCollapsed = isSelectionCollapsed(snapshot), focusTextBlock = getFocusTextBlock(snapshot), focusSpan = getFocusSpan(snapshot);
+    return !selectionCollapsed || !focusTextBlock || !focusSpan ? !1 : focusTextBlock.node.children[0]._key === focusSpan.node._key && snapshot.context.selection?.focus.offset === 0 && focusTextBlock.node.level === 1 ? {
+      focusTextBlock
+    } : !1;
+  },
+  actions: [(_, {
+    focusTextBlock
+  }) => [raise({
+    type: "block.unset",
+    props: ["listItem", "level"],
+    at: focusTextBlock.path
+  })]]
+}), unindentListOnBackspace = defineBehavior({
+  on: "delete.backward",
+  guard: ({
+    snapshot
+  }) => {
+    const selectionCollapsed = isSelectionCollapsed(snapshot), focusTextBlock = getFocusTextBlock(snapshot), focusSpan = getFocusSpan(snapshot);
+    return !selectionCollapsed || !focusTextBlock || !focusSpan ? !1 : focusTextBlock.node.children[0]._key === focusSpan.node._key && snapshot.context.selection?.focus.offset === 0 && focusTextBlock.node.level !== void 0 && focusTextBlock.node.level > 1 ? {
+      focusTextBlock,
+      level: focusTextBlock.node.level - 1
+    } : !1;
+  },
+  actions: [(_, {
+    focusTextBlock,
+    level
+  }) => [raise({
+    type: "block.set",
+    props: {
+      level
+    },
+    at: focusTextBlock.path
+  })]]
+}), clearListOnEnter = defineBehavior({
+  on: "insert.break",
+  guard: ({
+    snapshot
+  }) => {
+    const selectionCollapsed = isSelectionCollapsed(snapshot), focusListBlock = getFocusListBlock(snapshot);
+    return !selectionCollapsed || !focusListBlock || !isEmptyTextBlock(snapshot.context, focusListBlock.node) ? !1 : {
+      focusListBlock
+    };
+  },
+  actions: [(_, {
+    focusListBlock
+  }) => [raise({
+    type: "block.unset",
+    props: ["listItem", "level"],
+    at: focusListBlock.path
+  })]]
+}), indentListOnTab = defineBehavior({
+  on: "keyboard.keydown",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    if (!isHotkey("Tab", event.originEvent))
+      return !1;
+    const selectedBlocks = getSelectedBlocks(snapshot), selectedListBlocks = selectedBlocks.flatMap((block) => isListBlock(snapshot.context, block.node) ? [{
+      node: block.node,
+      path: block.path
+    }] : []);
+    return selectedListBlocks.length === selectedBlocks.length ? {
+      selectedListBlocks
+    } : !1;
+  },
+  actions: [(_, {
+    selectedListBlocks
+  }) => selectedListBlocks.map((selectedListBlock) => raise({
+    type: "block.set",
+    props: {
+      level: Math.min(MAX_LIST_LEVEL, Math.max(1, selectedListBlock.node.level + 1))
+    },
+    at: selectedListBlock.path
+  }))]
+}), unindentListOnShiftTab = defineBehavior({
+  on: "keyboard.keydown",
+  guard: ({
+    snapshot,
+    event
+  }) => {
+    if (!isHotkey("Shift+Tab", event.originEvent))
+      return !1;
+    const selectedBlocks = getSelectedBlocks(snapshot), selectedListBlocks = selectedBlocks.flatMap((block) => isListBlock(snapshot.context, block.node) ? [{
+      node: block.node,
+      path: block.path
+    }] : []);
+    return selectedListBlocks.length === selectedBlocks.length ? {
+      selectedListBlocks
+    } : !1;
+  },
+  actions: [(_, {
+    selectedListBlocks
+  }) => selectedListBlocks.map((selectedListBlock) => raise({
+    type: "block.set",
+    props: {
+      level: Math.min(MAX_LIST_LEVEL, Math.max(1, selectedListBlock.node.level - 1))
+    },
+    at: selectedListBlock.path
+  }))]
+}), coreListBehaviors = {
+  clearListOnBackspace,
+  unindentListOnBackspace,
+  clearListOnEnter,
+  indentListOnTab,
+  unindentListOnShiftTab
+}, coreBehaviors = [coreAnnotationBehaviors.addAnnotationOnCollapsedSelection, coreDecoratorBehaviors.strongShortcut, coreDecoratorBehaviors.emShortcut, coreDecoratorBehaviors.underlineShortcut, coreDecoratorBehaviors.codeShortcut, ...coreDndBehaviors, coreBlockObjectBehaviors.clickingAboveLonelyBlockObject, coreBlockObjectBehaviors.clickingBelowLonelyBlockObject, coreBlockObjectBehaviors.arrowDownOnLonelyBlockObject, coreBlockObjectBehaviors.arrowUpOnLonelyBlockObject, coreBlockObjectBehaviors.breakingBlockObject, coreBlockObjectBehaviors.deletingEmptyTextBlockAfterBlockObject, coreBlockObjectBehaviors.deletingEmptyTextBlockBeforeBlockObject, coreListBehaviors.clearListOnBackspace, coreListBehaviors.unindentListOnBackspace, coreListBehaviors.clearListOnEnter, coreListBehaviors.indentListOnTab, coreListBehaviors.unindentListOnShiftTab, coreInsertBreakBehaviors.breakingAtTheEndOfTextBlock, coreInsertBreakBehaviors.breakingAtTheStartOfTextBlock, coreInsertBreakBehaviors.breakingEntireDocument, coreInsertBreakBehaviors.breakingEntireBlocks], abstractAnnotationBehaviors = [defineBehavior({
   on: "annotation.toggle",
   guard: ({
     snapshot,
@@ -6962,11 +7623,6 @@ const editorMachine = setup({
         event
       }) => (assertEvent(event, "remove behavior"), context.behaviors.delete(event.behavior), /* @__PURE__ */ new Set([...context.behaviors]))
     }),
-    "assign behaviors": assign({
-      behaviors: ({
-        event
-      }) => (assertEvent(event, "update behaviors"), /* @__PURE__ */ new Set([...event.behaviors]))
-    }),
     "assign schema": assign({
       schema: ({
         event
@@ -7012,6 +7668,22 @@ const editorMachine = setup({
     "clear pending events": assign({
       pendingEvents: []
     }),
+    "defer incoming patches": assign({
+      pendingIncomingPatchesEvents: ({
+        context,
+        event
+      }) => event.type === "patches" ? [...context.pendingIncomingPatchesEvents, event] : context.pendingIncomingPatchesEvents
+    }),
+    "emit pending incoming patches": enqueueActions(({
+      context,
+      enqueue
+    }) => {
+      for (const event of context.pendingIncomingPatchesEvents)
+        enqueue.emit(event);
+    }),
+    "clear pending incoming patches": assign({
+      pendingIncomingPatchesEvents: []
+    }),
     "handle blur": ({
       event
     }) => {
@@ -7074,11 +7746,12 @@ const editorMachine = setup({
   context: ({
     input
   }) => ({
-    behaviors: /* @__PURE__ */ new Set([...input.behaviors ?? coreBehaviors]),
+    behaviors: /* @__PURE__ */ new Set([...coreBehaviors]),
     converters: new Set(input.converters ?? []),
     getLegacySchema: input.getLegacySchema,
     keyGenerator: input.keyGenerator,
     pendingEvents: [],
+    pendingIncomingPatchesEvents: [],
     schema: input.schema,
     selection: null,
     initialReadOnly: input.readOnly ?? !1,
@@ -7162,14 +7835,6 @@ const editorMachine = setup({
     "remove behavior": {
       actions: "remove behavior from context"
     },
-    patches: {
-      actions: emit(({
-        event
-      }) => event)
-    },
-    "update behaviors": {
-      actions: "assign behaviors"
-    },
     "update key generator": {
       actions: assign({
         keyGenerator: ({
@@ -7213,7 +7878,7 @@ const editorMachine = setup({
           states: {
             "determine initial edit mode": {
               on: {
-                "done syncing initial value": [{
+                "done syncing value": [{
                   target: "#editor.edit mode.read only.read only",
                   guard: ({
                     context
@@ -7329,7 +7994,7 @@ const editorMachine = setup({
       initial: "setting up",
       states: {
         "setting up": {
-          exit: ["emit ready"],
+          exit: ["emit ready", "emit pending incoming patches", "clear pending incoming patches"],
           on: {
             "internal.patch": {
               actions: "defer event"
@@ -7337,54 +8002,95 @@ const editorMachine = setup({
             mutation: {
               actions: "defer event"
             },
-            "done syncing initial value": {
-              target: "pristine"
+            "done syncing value": {
+              target: "set up"
+            },
+            patches: {
+              actions: ["defer incoming patches"]
             }
           }
         },
-        pristine: {
-          initial: "idle",
+        "set up": {
+          type: "parallel",
           states: {
-            idle: {
-              on: {
-                normalizing: {
-                  target: "normalizing"
-                },
-                "internal.patch": {
-                  actions: "defer event",
-                  target: "#editor.setup.dirty"
+            "value sync": {
+              initial: "idle",
+              states: {
+                idle: {
+                  on: {
+                    patches: {
+                      actions: [emit(({
+                        event
+                      }) => event)]
+                    },
+                    "syncing value": {
+                      target: "syncing value"
+                    }
+                  }
                 },
-                mutation: {
-                  actions: "defer event",
-                  target: "#editor.setup.dirty"
+                "syncing value": {
+                  exit: ["emit pending incoming patches", "clear pending incoming patches"],
+                  on: {
+                    patches: {
+                      actions: ["defer incoming patches"]
+                    },
+                    "done syncing value": {
+                      target: "idle"
+                    }
+                  }
                 }
               }
             },
-            normalizing: {
-              on: {
-                "done normalizing": {
-                  target: "idle"
-                },
-                "internal.patch": {
-                  actions: "defer event"
+            writing: {
+              initial: "pristine",
+              states: {
+                pristine: {
+                  initial: "idle",
+                  states: {
+                    idle: {
+                      on: {
+                        normalizing: {
+                          target: "normalizing"
+                        },
+                        "internal.patch": {
+                          actions: "defer event",
+                          target: "#editor.setup.set up.writing.dirty"
+                        },
+                        mutation: {
+                          actions: "defer event",
+                          target: "#editor.setup.set up.writing.dirty"
+                        }
+                      }
+                    },
+                    normalizing: {
+                      on: {
+                        "done normalizing": {
+                          target: "idle"
+                        },
+                        "internal.patch": {
+                          actions: "defer event"
+                        },
+                        mutation: {
+                          actions: "defer event"
+                        }
+                      }
+                    }
+                  }
                 },
-                mutation: {
-                  actions: "defer event"
+                dirty: {
+                  entry: ["emit pending events", "clear pending events"],
+                  on: {
+                    "internal.patch": {
+                      actions: "emit patch event"
+                    },
+                    mutation: {
+                      actions: "emit mutation event"
+                    }
+                  }
                 }
               }
             }
           }
-        },
-        dirty: {
-          entry: ["emit pending events", "clear pending events"],
-          on: {
-            "internal.patch": {
-              actions: "emit patch event"
-            },
-            mutation: {
-              actions: "emit mutation event"
-            }
-          }
         }
       }
     }
@@ -7959,6 +8665,7 @@ export {
   EditorProvider,
   KEY_TO_VALUE_ELEMENT,
   PortableTextEditor,
+  coreBehaviors,
   debugWithName,
   defaultKeyGenerator,
   defineSchema,
@@ -7968,6 +8675,7 @@ export {
   getLastBlock,
   getNodeBlock,
   isEqualToEmptyEditor,
+  isHotkey,
   moveRangeByOperation,
   slateRangeToSelection,
   toSlateRange,