@portabletext/editor 6.0.1-canary.2 → 6.0.1-canary.3

package/lib/_chunks-dts/behavior.types.action.d.ts

@@ -1,9 +1,9 @@
 import * as _portabletext_schema6 from "@portabletext/schema";
 import { AnnotationDefinition, AnnotationSchemaType, AnnotationSchemaType as AnnotationSchemaType$1, BaseDefinition, BlockObjectDefinition, BlockObjectSchemaType, BlockObjectSchemaType as BlockObjectSchemaType$1, DecoratorDefinition, DecoratorSchemaType, DecoratorSchemaType as DecoratorSchemaType$1, FieldDefinition, InlineObjectDefinition, InlineObjectSchemaType, InlineObjectSchemaType as InlineObjectSchemaType$1, ListDefinition, ListSchemaType, ListSchemaType as ListSchemaType$1, PortableTextBlock, PortableTextBlock as PortableTextBlock$1, PortableTextChild, PortableTextChild as PortableTextChild$1, PortableTextListBlock, PortableTextObject, PortableTextObject as PortableTextObject$1, PortableTextSpan, PortableTextSpan as PortableTextSpan$1, PortableTextTextBlock, PortableTextTextBlock as PortableTextTextBlock$1, Schema, SchemaDefinition, SchemaDefinition as SchemaDefinition$1, StyleDefinition, StyleSchemaType, StyleSchemaType as StyleSchemaType$1, TypedObject, defineSchema } from "@portabletext/schema";
-import * as xstate73 from "xstate";
+import * as xstate77 from "xstate";
 import { ActorRef, ActorRefFrom, EventObject, Snapshot } from "xstate";
 import * as react13 from "react";
-import React$1, { BaseSyntheticEvent, ClipboardEvent as ClipboardEvent$1, FocusEvent, JSX, MutableRefObject, PropsWithChildren, ReactElement, RefObject, TextareaHTMLAttributes } from "react";
+import React$1, { BaseSyntheticEvent, ClipboardEvent as ClipboardEvent$1, FocusEvent, JSX, PropsWithChildren, ReactElement, RefObject, TextareaHTMLAttributes } from "react";
 import { Patch, Patch as Patch$1 } from "@portabletext/patches";
 type MIMEType = `${string}/${string}`;
 /**
@@ -117,6 +117,121 @@ type TextDirection = 'forward' | 'backward';
 type TextUnit = 'character' | 'word' | 'line' | 'block';
 type TextUnitAdjustment = TextUnit | 'offset';
 type OmitFirstArg<F> = F extends ((x: any, ...args: infer P) => infer R) ? (...args: P) => R : never;
+interface NodeInsertNodesOptions<T extends Node$1> {
+  at?: Location;
+  match?: NodeMatch<T>;
+  mode?: RangeMode;
+  hanging?: boolean;
+  select?: boolean;
+  voids?: boolean;
+  batchDirty?: boolean;
+}
+interface NodeTransforms {
+  /**
+   * Insert nodes in the editor
+   * at the specified location or (if not defined) the current selection or (if not defined) the end of the document.
+   */
+  insertNodes: <T extends Node$1>(editor: Editor$1, nodes: Node$1 | Node$1[], options?: NodeInsertNodesOptions<T>) => void;
+  /**
+   * Lift nodes at a specific location upwards in the document tree, splitting
+   * their parent in two if necessary.
+   */
+  liftNodes: <T extends Node$1>(editor: Editor$1, options?: {
+    at?: Location;
+    match?: NodeMatch<T>;
+    mode?: MaximizeMode;
+    voids?: boolean;
+  }) => void;
+  /**
+   * Merge a node at a location with the previous node of the same depth,
+   * removing any empty containing nodes after the merge if necessary.
+   */
+  mergeNodes: <T extends Node$1>(editor: Editor$1, options?: {
+    at?: Location;
+    match?: NodeMatch<T>;
+    mode?: RangeMode;
+    hanging?: boolean;
+    voids?: boolean;
+  }) => void;
+  /**
+   * Move the nodes at a location to a new location.
+   */
+  moveNodes: <T extends Node$1>(editor: Editor$1, options: {
+    at?: Location;
+    match?: NodeMatch<T>;
+    mode?: MaximizeMode;
+    to: Path$1;
+    voids?: boolean;
+  }) => void;
+  /**
+   * Remove the nodes at a specific location in the document.
+   */
+  removeNodes: <T extends Node$1>(editor: Editor$1, options?: {
+    at?: Location;
+    match?: NodeMatch<T>;
+    mode?: RangeMode;
+    hanging?: boolean;
+    voids?: boolean;
+  }) => void;
+  /**
+   * Set new properties on the nodes at a location.
+   */
+  setNodes: <T extends Node$1>(editor: Editor$1, props: Partial<T>, options?: {
+    at?: Location;
+    match?: NodeMatch<T>;
+    mode?: MaximizeMode;
+    hanging?: boolean;
+    split?: boolean;
+    voids?: boolean;
+    compare?: PropsCompare;
+    merge?: PropsMerge;
+  }) => void;
+  /**
+   * Split the nodes at a specific location.
+   */
+  splitNodes: <T extends Node$1>(editor: Editor$1, options?: {
+    at?: Location;
+    match?: NodeMatch<T>;
+    mode?: RangeMode;
+    always?: boolean;
+    height?: number;
+    voids?: boolean;
+  }) => void;
+  /**
+   * Unset properties on the nodes at a location.
+   */
+  unsetNodes: <T extends Node$1>(editor: Editor$1, props: string | string[], options?: {
+    at?: Location;
+    match?: NodeMatch<T>;
+    mode?: MaximizeMode;
+    hanging?: boolean;
+    split?: boolean;
+    voids?: boolean;
+  }) => void;
+  /**
+   * Unwrap the nodes at a location from a parent node, splitting the parent if
+   * necessary to ensure that only the content in the range is unwrapped.
+   */
+  unwrapNodes: <T extends Node$1>(editor: Editor$1, options?: {
+    at?: Location;
+    match?: NodeMatch<T>;
+    mode?: MaximizeMode;
+    split?: boolean;
+    voids?: boolean;
+  }) => void;
+  /**
+   * Wrap the nodes at a location in a new container node, splitting the edges
+   * of the range first to ensure that only the content in the range is wrapped.
+   */
+  wrapNodes: <T extends Node$1>(editor: Editor$1, element: Element$1, options?: {
+    at?: Location;
+    match?: NodeMatch<T>;
+    mode?: MaximizeMode;
+    split?: boolean;
+    voids?: boolean;
+  }) => void;
+}
+declare const NodeTransforms: NodeTransforms;
 interface TextDeleteOptions {
   at?: Location;
   distance?: number;
@@ -161,11 +276,6 @@ interface BaseEditor {
   selection: Selection$1;
   operations: Operation[];
   marks: EditorMarks | null;
-  dirtyPaths: Path$1[];
-  dirtyPathKeys: Set<string>;
-  flushing: boolean;
-  normalizing: boolean;
-  batchingDirtyPaths: boolean;
   apply: (operation: Operation) => void;
   createSpan: () => Text$1;
   getDirtyPaths: (operation: Operation) => Path$1[];
@@ -190,18 +300,25 @@ interface BaseEditor {
     dirtyPaths: Path$1[];
     operation?: Operation;
   }) => boolean;
+  addMark: OmitFirstArg<typeof Editor$1.addMark>;
   collapse: OmitFirstArg<typeof Transforms.collapse>;
   delete: OmitFirstArg<typeof Transforms.delete>;
+  deleteBackward: (unit: TextUnit) => void;
+  deleteForward: (unit: TextUnit) => void;
+  deleteFragment: OmitFirstArg<typeof Editor$1.deleteFragment>;
   deselect: OmitFirstArg<typeof Transforms.deselect>;
   insertBreak: OmitFirstArg<typeof Editor$1.insertBreak>;
   insertFragment: OmitFirstArg<typeof Transforms.insertFragment>;
+  insertNode: OmitFirstArg<typeof Editor$1.insertNode>;
   insertNodes: OmitFirstArg<typeof Transforms.insertNodes>;
+  insertSoftBreak: OmitFirstArg<typeof Editor$1.insertSoftBreak>;
   insertText: OmitFirstArg<typeof Transforms.insertText>;
   liftNodes: OmitFirstArg<typeof Transforms.liftNodes>;
   mergeNodes: OmitFirstArg<typeof Transforms.mergeNodes>;
   move: OmitFirstArg<typeof Transforms.move>;
   moveNodes: OmitFirstArg<typeof Transforms.moveNodes>;
   normalize: OmitFirstArg<typeof Editor$1.normalize>;
+  removeMark: OmitFirstArg<typeof Editor$1.removeMark>;
   removeNodes: OmitFirstArg<typeof Transforms.removeNodes>;
   select: OmitFirstArg<typeof Transforms.select>;
   setNodes: <T extends Node$1>(props: Partial<T>, options?: {
@@ -215,6 +332,7 @@ interface BaseEditor {
     merge?: PropsMerge;
   }) => void;
   setNormalizing: OmitFirstArg<typeof Editor$1.setNormalizing>;
+  setPoint: OmitFirstArg<typeof Transforms.setPoint>;
   setSelection: OmitFirstArg<typeof Transforms.setSelection>;
   splitNodes: OmitFirstArg<typeof Transforms.splitNodes>;
   unsetNodes: OmitFirstArg<typeof Transforms.unsetNodes>;
@@ -224,18 +342,25 @@ interface BaseEditor {
   above: <T extends Ancestor>(options?: EditorAboveOptions<T>) => NodeEntry<T> | undefined;
   after: OmitFirstArg<typeof Editor$1.after>;
   before: OmitFirstArg<typeof Editor$1.before>;
+  edges: OmitFirstArg<typeof Editor$1.edges>;
   elementReadOnly: OmitFirstArg<typeof Editor$1.elementReadOnly>;
   end: OmitFirstArg<typeof Editor$1.end>;
+  first: OmitFirstArg<typeof Editor$1.first>;
+  fragment: OmitFirstArg<typeof Editor$1.fragment>;
   getMarks: OmitFirstArg<typeof Editor$1.marks>;
+  hasBlocks: OmitFirstArg<typeof Editor$1.hasBlocks>;
   hasInlines: OmitFirstArg<typeof Editor$1.hasInlines>;
   hasPath: OmitFirstArg<typeof Editor$1.hasPath>;
+  hasTexts: OmitFirstArg<typeof Editor$1.hasTexts>;
   isBlock: OmitFirstArg<typeof Editor$1.isBlock>;
   isEdge: OmitFirstArg<typeof Editor$1.isEdge>;
+  isEmpty: OmitFirstArg<typeof Editor$1.isEmpty>;
   isEnd: OmitFirstArg<typeof Editor$1.isEnd>;
   isInline: OmitFirstArg<typeof Editor$1.isInline>;
   isNormalizing: OmitFirstArg<typeof Editor$1.isNormalizing>;
   isStart: OmitFirstArg<typeof Editor$1.isStart>;
   isVoid: OmitFirstArg<typeof Editor$1.isVoid>;
+  last: OmitFirstArg<typeof Editor$1.last>;
   leaf: OmitFirstArg<typeof Editor$1.leaf>;
   levels: <T extends Node$1>(options?: EditorLevelsOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
   next: <T extends Descendant>(options?: EditorNextOptions<T>) => NodeEntry<T> | undefined;
@@ -244,15 +369,15 @@ interface BaseEditor {
   parent: OmitFirstArg<typeof Editor$1.parent>;
   path: OmitFirstArg<typeof Editor$1.path>;
   pathRef: OmitFirstArg<typeof Editor$1.pathRef>;
-  pathRefs: Set<PathRef>;
+  pathRefs: OmitFirstArg<typeof Editor$1.pathRefs>;
   point: OmitFirstArg<typeof Editor$1.point>;
   pointRef: OmitFirstArg<typeof Editor$1.pointRef>;
-  pointRefs: Set<PointRef>;
+  pointRefs: OmitFirstArg<typeof Editor$1.pointRefs>;
   positions: OmitFirstArg<typeof Editor$1.positions>;
   previous: <T extends Node$1>(options?: EditorPreviousOptions<T>) => NodeEntry<T> | undefined;
   range: OmitFirstArg<typeof Editor$1.range>;
   rangeRef: OmitFirstArg<typeof Editor$1.rangeRef>;
-  rangeRefs: Set<RangeRef>;
+  rangeRefs: OmitFirstArg<typeof Editor$1.rangeRefs>;
   start: OmitFirstArg<typeof Editor$1.start>;
   string: OmitFirstArg<typeof Editor$1.string>;
   unhangRange: OmitFirstArg<typeof Editor$1.unhangRange>;
@@ -279,11 +404,17 @@ interface EditorBeforeOptions {
   unit?: TextUnitAdjustment;
   voids?: boolean;
 }
+interface EditorDirectedDeletionOptions {
+  unit?: TextUnit;
+}
 interface EditorElementReadOnlyOptions {
   at?: Location;
   mode?: MaximizeMode;
   voids?: boolean;
 }
+interface EditorFragmentDeletionOptions {
+  direction?: TextDirection;
+}
 interface EditorIsEditorOptions {
   deep?: boolean;
 }
@@ -368,6 +499,13 @@ interface EditorInterface {
    * Get the ancestor above a location in the document.
    */
   above: <T extends Ancestor>(editor: Editor$1, options?: EditorAboveOptions<T>) => NodeEntry<T> | undefined;
+  /**
+   * Add a custom property to the leaf text nodes in the current selection.
+   *
+   * If the selection is currently collapsed, the marks will be added to the
+   * `editor.marks` property instead, and applied when text is inserted next.
+   */
+  addMark: (editor: Editor$1, key: string, value: any) => void;
   /**
    * Get the point after a location.
    */
@@ -376,6 +514,22 @@ interface EditorInterface {
    * Get the point before a location.
    */
   before: (editor: Editor$1, at: Location, options?: EditorBeforeOptions) => Point | undefined;
+  /**
+   * Delete content in the editor backward from the current selection.
+   */
+  deleteBackward: (editor: Editor$1, options?: EditorDirectedDeletionOptions) => void;
+  /**
+   * Delete content in the editor forward from the current selection.
+   */
+  deleteForward: (editor: Editor$1, options?: EditorDirectedDeletionOptions) => void;
+  /**
+   * Delete the content in the current selection.
+   */
+  deleteFragment: (editor: Editor$1, options?: EditorFragmentDeletionOptions) => void;
+  /**
+   * Get the start and end points of a location.
+   */
+  edges: (editor: Editor$1, at: Location) => [Point, Point];
   /**
    * Match a read-only element in the current branch of the editor.
    */
@@ -384,11 +538,27 @@ interface EditorInterface {
    * Get the end point of a location.
    */
   end: (editor: Editor$1, at: Location) => Point;
+  /**
+   * Get the first node at a location.
+   */
+  first: (editor: Editor$1, at: Location) => NodeEntry;
+  /**
+   * Get the fragment at a location.
+   */
+  fragment: (editor: Editor$1, at: Location) => Descendant[];
+  /**
+   * Check if a node has block children.
+   */
+  hasBlocks: (editor: Editor$1, element: Element$1) => boolean;
   /**
    * Check if a node has inline and text children.
    */
   hasInlines: (editor: Editor$1, element: Element$1) => boolean;
   hasPath: (editor: Editor$1, path: Path$1) => boolean;
+  /**
+   * Check if a node has text children.
+   */
+  hasTexts: (editor: Editor$1, element: Element$1) => boolean;
   /**
    * Insert a block break at the current selection.
    *
@@ -400,6 +570,17 @@ interface EditorInterface {
    * at the specified location or (if not defined) the current selection or (if not defined) the end of the document.
    */
   insertFragment: (editor: Editor$1, fragment: Node$1[], options?: TextInsertFragmentOptions) => void;
+  /**
+   * Atomically inserts `nodes`
+   * at the specified location or (if not defined) the current selection or (if not defined) the end of the document.
+   */
+  insertNode: <T extends Node$1>(editor: Editor$1, node: Node$1, options?: NodeInsertNodesOptions<T>) => void;
+  /**
+   * Insert a soft break at the current selection.
+   *
+   * If the selection is currently expanded, it will be deleted first.
+   */
+  insertSoftBreak: (editor: Editor$1) => void;
   /**
    * Insert a string of text
    * at the specified location or (if not defined) the current selection or (if not defined) the end of the document.
@@ -421,6 +602,10 @@ interface EditorInterface {
    * Check if a value is a read-only `Element` object.
    */
   isElementReadOnly: (editor: Editor$1, element: Element$1) => boolean;
+  /**
+   * Check if an element is empty, accounting for void nodes.
+   */
+  isEmpty: (editor: Editor$1, element: Element$1) => boolean;
   /**
    * Check if a point is the end point of a location.
    */
@@ -445,6 +630,10 @@ interface EditorInterface {
    * Check if a value is a void `Element` object.
    */
   isVoid: (editor: Editor$1, value: Element$1) => boolean;
+  /**
+   * Get the last node at a location.
+   */
+  last: (editor: Editor$1, at: Location) => NodeEntry;
   /**
    * Get the leaf text node at a location.
    */
@@ -533,6 +722,14 @@ interface EditorInterface {
    * Get the set of currently tracked range refs of the editor.
    */
   rangeRefs: (editor: Editor$1) => Set<RangeRef>;
+  /**
+   * Remove a custom property from all of the leaf text nodes in the current
+   * selection.
+   *
+   * If the selection is currently collapsed, the removal will be stored on
+   * `editor.marks` and applied to the text inserted next.
+   */
+  removeMark: (editor: Editor$1, key: string) => void;
   /**
    * Manually set if the editor should currently be normalizing.
    *
@@ -1316,121 +1513,6 @@ interface GeneralTransforms {
   transform: (editor: Editor$1, op: Operation) => void;
 }
 declare const GeneralTransforms: GeneralTransforms;
-interface NodeInsertNodesOptions<T extends Node$1> {
-  at?: Location;
-  match?: NodeMatch<T>;
-  mode?: RangeMode;
-  hanging?: boolean;
-  select?: boolean;
-  voids?: boolean;
-  batchDirty?: boolean;
-}
-interface NodeTransforms {
-  /**
-   * Insert nodes in the editor
-   * at the specified location or (if not defined) the current selection or (if not defined) the end of the document.
-   */
-  insertNodes: <T extends Node$1>(editor: Editor$1, nodes: Node$1 | Node$1[], options?: NodeInsertNodesOptions<T>) => void;
-  /**
-   * Lift nodes at a specific location upwards in the document tree, splitting
-   * their parent in two if necessary.
-   */
-  liftNodes: <T extends Node$1>(editor: Editor$1, options?: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: MaximizeMode;
-    voids?: boolean;
-  }) => void;
-  /**
-   * Merge a node at a location with the previous node of the same depth,
-   * removing any empty containing nodes after the merge if necessary.
-   */
-  mergeNodes: <T extends Node$1>(editor: Editor$1, options?: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: RangeMode;
-    hanging?: boolean;
-    voids?: boolean;
-  }) => void;
-  /**
-   * Move the nodes at a location to a new location.
-   */
-  moveNodes: <T extends Node$1>(editor: Editor$1, options: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: MaximizeMode;
-    to: Path$1;
-    voids?: boolean;
-  }) => void;
-  /**
-   * Remove the nodes at a specific location in the document.
-   */
-  removeNodes: <T extends Node$1>(editor: Editor$1, options?: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: RangeMode;
-    hanging?: boolean;
-    voids?: boolean;
-  }) => void;
-  /**
-   * Set new properties on the nodes at a location.
-   */
-  setNodes: <T extends Node$1>(editor: Editor$1, props: Partial<T>, options?: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: MaximizeMode;
-    hanging?: boolean;
-    split?: boolean;
-    voids?: boolean;
-    compare?: PropsCompare;
-    merge?: PropsMerge;
-  }) => void;
-  /**
-   * Split the nodes at a specific location.
-   */
-  splitNodes: <T extends Node$1>(editor: Editor$1, options?: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: RangeMode;
-    always?: boolean;
-    height?: number;
-    voids?: boolean;
-  }) => void;
-  /**
-   * Unset properties on the nodes at a location.
-   */
-  unsetNodes: <T extends Node$1>(editor: Editor$1, props: string | string[], options?: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: MaximizeMode;
-    hanging?: boolean;
-    split?: boolean;
-    voids?: boolean;
-  }) => void;
-  /**
-   * Unwrap the nodes at a location from a parent node, splitting the parent if
-   * necessary to ensure that only the content in the range is unwrapped.
-   */
-  unwrapNodes: <T extends Node$1>(editor: Editor$1, options?: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: MaximizeMode;
-    split?: boolean;
-    voids?: boolean;
-  }) => void;
-  /**
-   * Wrap the nodes at a location in a new container node, splitting the edges
-   * of the range first to ensure that only the content in the range is wrapped.
-   */
-  wrapNodes: <T extends Node$1>(editor: Editor$1, element: Element$1, options?: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: MaximizeMode;
-    split?: boolean;
-    voids?: boolean;
-  }) => void;
-}
-declare const NodeTransforms: NodeTransforms;
 interface SelectionCollapseOptions {
   edge?: SelectionEdge;
 }
@@ -1440,6 +1522,9 @@ interface SelectionMoveOptions {
   reverse?: boolean;
   edge?: SelectionEdge;
 }
+interface SelectionSetPointOptions {
+  edge?: SelectionEdge;
+}
 interface SelectionTransforms {
   /**
    * Collapse the selection.
@@ -1457,6 +1542,10 @@ interface SelectionTransforms {
    * Set the selection to a new value.
    */
   select: (editor: Editor$1, target: Location) => void;
+  /**
+   * Set new properties on one of the selection's points.
+   */
+  setPoint: (editor: Editor$1, props: Partial<Point>, options?: SelectionSetPointOptions) => void;
   /**
    * Set new properties on the selection.
    */
@@ -1470,6 +1559,7 @@ declare const Transforms: GeneralTransforms & NodeTransforms & SelectionTransfor
 type EditorSchema = Schema;
 type DecoratedRange = BaseRange & {
   rangeDecoration: RangeDecoration;
+  merge: (leaf: Record<string, unknown>, decoration: Record<string, unknown>) => void;
 };
 type StringDiff = {
   start: number;
@@ -1507,10 +1597,6 @@ declare class Key {
   id: string;
   constructor();
 }
-type Action = {
-  at?: Point | Range;
-  run: () => void;
-};
 /**
  * A DOM-specific version of the `Editor` interface.
  */
@@ -1524,32 +1610,6 @@ interface DOMEditor extends BaseEditor {
   insertTextData: (data: DataTransfer) => boolean;
   isTargetInsideNonReadonlyVoid: (editor: Editor$1, target: EventTarget | null) => boolean;
   setFragmentData: (data: DataTransfer, originEvent?: 'drag' | 'copy' | 'cut') => void;
-  isNodeMapDirty: boolean;
-  domWindow: Window | null;
-  domElement: HTMLElement | null;
-  domPlaceholder: string;
-  domPlaceholderElement: HTMLElement | null;
-  keyToElement: WeakMap<Key, HTMLElement>;
-  nodeToIndex: WeakMap<Node$1, number>;
-  nodeToParent: WeakMap<Node$1, Ancestor>;
-  elementToNode: WeakMap<HTMLElement, Node$1>;
-  nodeToElement: WeakMap<Node$1, HTMLElement>;
-  nodeToKey: WeakMap<Node$1, Key>;
-  changeVersion: MutableRefObject<number>;
-  readOnly: boolean;
-  focused: boolean;
-  composing: boolean;
-  userSelection: RangeRef | null;
-  onContextChange: ((options?: {
-    operation?: Operation;
-  }) => void) | null;
-  scheduleFlush: (() => void) | null;
-  pendingInsertionMarks: Partial<Text$1> | null;
-  userMarks: Partial<Text$1> | null;
-  pendingDiffs: TextDiff[];
-  pendingAction: Action | null;
-  pendingSelection: Range | null;
-  forceRender: (() => void) | null;
 }
 interface DOMEditorInterface {
   /**
@@ -1690,46 +1750,6 @@ interface DOMEditorInterface {
   }) => T extends true ? Range | null : Range;
 }
 declare const DOMEditor: DOMEditorInterface;
-interface ChunkTree {
-  type: 'root';
-  children: ChunkDescendant[];
-  /**
-   * The keys of any Slate nodes that have been moved using move_node since the
-   * last render
-   *
-   * Detecting when a node has been moved to a different position in the
-   * children array is impossible to do efficiently while reconciling the chunk
-   * tree. This interferes with the reconciliation logic since it is treated as
-   * if the intermediate nodes were inserted and removed, causing them to be
-   * re-chunked unnecessarily.
-   *
-   * This set is used to detect when a node has been moved so that this case
-   * can be handled correctly and efficiently.
-   */
-  movedNodeKeys: Set<Key>;
-  /**
-   * The chunks whose descendants have been modified during the most recent
-   * reconciliation
-   *
-   * Used to determine when the otherwise memoized React components for each
-   * chunk should be re-rendered.
-   */
-  modifiedChunks: Set<Chunk>;
-}
-interface Chunk {
-  type: 'chunk';
-  key: Key;
-  parent: ChunkAncestor;
-  children: ChunkDescendant[];
-}
-interface ChunkLeaf {
-  type: 'leaf';
-  key: Key;
-  node: Descendant;
-  index: number;
-}
-type ChunkAncestor = ChunkTree | Chunk;
-type ChunkDescendant = Chunk | ChunkLeaf;
 /**
  * A React and DOM-specific version of the `Editor` interface.
  */
@@ -1740,7 +1760,6 @@ interface ReactEditor extends DOMEditor {
    * disabled.
    */
   getChunkSize: (node: Ancestor) => number | null;
-  keyToChunkTree: WeakMap<Key, ChunkTree>;
 }
 interface ReactEditorInterface extends DOMEditorInterface {}
 declare const ReactEditor: ReactEditorInterface;
@@ -1776,6 +1795,50 @@ type RemotePatch = {
   snapshot: PortableTextBlock[] | undefined;
   previousSnapshot: PortableTextBlock[] | undefined;
 };
+/**
+ * Context passed during a split operation to help RangeDecorator
+ * recompute decoration positions correctly.
+ */
+interface SplitContext {
+  /** The offset in the original block where the split occurs */
+  splitOffset: number;
+  /** The child index of the span being split */
+  splitChildIndex: number;
+  /** The _key of the block being split */
+  originalBlockKey: string;
+  /** The _key of the new block created after the split */
+  newBlockKey: string;
+  /** The _key of the original span (child) being split */
+  originalSpanKey: string;
+  /** The _key of the new span in the new block (may be same or different) */
+  newSpanKey: string;
+}
+/**
+ * Context passed during a merge operation to help RangeDecorator
+ * recompute decoration positions correctly.
+ *
+ * During a forward-delete merge (Delete at end of block 1) or
+ * backward-delete merge (Backspace at start of block 2), the
+ * second block is deleted and its content is re-inserted into
+ * the first block. This context helps track that relationship.
+ */
+interface MergeContext {
+  /** The _key of the block being deleted (block whose content is moving) */
+  deletedBlockKey: string;
+  /** The _key of the block receiving the content */
+  targetBlockKey: string;
+  /** The text length of the target block before merge (insertion offset) */
+  targetBlockTextLength: number;
+  /** The index of the deleted block at the time context was created */
+  deletedBlockIndex: number;
+  /** The index of the target block at the time context was created */
+  targetBlockIndex: number;
+  /** The number of children in the target block before merge.
+   *  Used to compute correct insertion indices for multi-child blocks
+   *  (e.g., blocks with bold/italic spans). Child N from the deleted block
+   *  ends up at index targetOriginalChildCount + N in the target block. */
+  targetOriginalChildCount: number;
+}
 interface PortableTextSlateEditor extends ReactEditor {
   _key: 'editor';
   _type: 'editor';
@@ -1783,6 +1846,24 @@ interface PortableTextSlateEditor extends ReactEditor {
   isTextSpan: (value: unknown) => value is PortableTextSpan;
   isListBlock: (value: unknown) => value is PortableTextListBlock;
   decoratedRanges: Array<DecoratedRange>;
+  /**
+   * Snapshot of decoration state taken before a remote batch starts.
+   * Used by the reconciliation handler to diff pre-batch vs post-batch
+   * and fire a single onMoved callback per changed decoration.
+   * Stores both the Slate Range (for change detection) and the
+   * EditorSelection (for previousSelection in onMoved callbacks).
+   * Managed by the apply interceptor in range-decorations-machine.
+   */
+  preBatchDecorationRanges: Map<RangeDecoration, {
+    range: Range | null;
+    selection: EditorSelection;
+  }>;
+  /**
+   * Tracks decorations whose interior content was modified during a remote
+   * batch. Populated by the `move range decorations` action when callbacks
+   * are suppressed; consumed and cleared by `reconcile range decorations`.
+   */
+  batchContentChangedDecorations: Set<RangeDecoration>;
   decoratorState: Record<string, boolean | undefined>;
   blockIndexMap: Map<string, number>;
   history: History;
@@ -1792,6 +1873,28 @@ interface PortableTextSlateEditor extends ReactEditor {
   remotePatches: Array<RemotePatch>;
   undoStepId: string | undefined;
   value: Array<PortableTextBlock>;
+  /**
+   * Context for the current split operation.
+   * Set before delete+insert operations, cleared after.
+   * Used by RangeDecorator to correctly recompute decoration positions.
+   */
+  splitContext: SplitContext | null;
+  /**
+   * Context for the current merge operation.
+   * Set before delete+insert operations, cleared after.
+   * Used by RangeDecorator to correctly recompute decoration positions.
+   */
+  mergeContext: MergeContext | null;
+  /**
+   * Tracks which decoration points were on the deleted block BEFORE
+   * `remove_node` shifts paths. Computed during `remove_node` and consumed
+   * during `insert_node` to avoid stale-index collisions where a shifted
+   * point coincidentally lands at `deletedBlockIndex`.
+   */
+  mergeDeletedBlockFlags: Map<RangeDecoration, {
+    anchor: boolean;
+    focus: boolean;
+  }> | null;
   isDeferringMutations: boolean;
   isNormalizingNode: boolean;
   isPatching: boolean;
@@ -2535,8 +2638,21 @@ type ScrollSelectionIntoViewFunction = (editor: PortableTextEditor, domRange: gl
  * @alpha */
 interface RangeDecorationOnMovedDetails {
   rangeDecoration: RangeDecoration;
+  previousSelection: EditorSelection;
   newSelection: EditorSelection;
   origin: 'remote' | 'local';
+  /**
+   * Why the callback fired.
+   *
+   * - `'moved'` — the range's boundary points (anchor/focus) shifted due to
+   *   an editing operation, or the range was invalidated (`newSelection` is
+   *   `null`).
+   * - `'contentChanged'` — the boundary points are unchanged, but content
+   *   inside the range was modified (text edits, node changes, etc.).
+   *   `previousSelection` and `newSelection` will be identical.
+   *   The return value is ignored for this reason.
+   */
+  reason: 'moved' | 'contentChanged';
 }
 /**
  * A range decoration is a UI affordance that wraps a given selection range in the editor
@@ -2563,9 +2679,24 @@ interface RangeDecoration {
    */
   selection: EditorSelection;
   /**
-   * A optional callback that will be called when the range decoration potentially moves according to user edits.
+   * Called when the range decoration moves due to edits.
+   *
+   * When `origin` is `'remote'`, the return value is honored: return an
+   * `EditorSelection` to override the auto-resolved position (e.g. re-resolve
+   * from a W3C annotation or other source of truth). This is useful because
+   * remote structural ops (split/merge) may truncate or invalidate the
+   * decoration, and the editor cannot reconstruct the full range without
+   * consumer knowledge.
+   *
+   * When `origin` is `'local'`, the return value is ignored — local transforms
+   * (split/merge context) already produce correct positions.
    */
-  onMoved?: (details: RangeDecorationOnMovedDetails) => void;
+  onMoved?: (details: RangeDecorationOnMovedDetails) => EditorSelection | void;
+  /**
+   * Stable identifier for matching to external data (e.g., annotation/comment ID).
+   * Set by the consumer — PTE preserves it and passes it through in onMoved details.
+   */
+  id?: string;
   /**
    * A custom payload that can be set on the range decoration
    */
@@ -2803,7 +2934,7 @@ type EditorActor = ActorRefFrom<typeof editorMachine>;
 /**
  * @internal
  */
-declare const editorMachine: xstate73.StateMachine<{
+declare const editorMachine: xstate77.StateMachine<{
   behaviors: Set<BehaviorConfig>;
   behaviorsSorted: boolean;
   converters: Set<Converter>;
@@ -2819,7 +2950,7 @@ declare const editorMachine: xstate73.StateMachine<{
   };
   dragGhost?: HTMLElement;
   slateEditor?: PortableTextSlateEditor;
-}, InternalPatchEvent | MutationEvent | PatchesEvent | {
+}, MutationEvent | InternalPatchEvent | PatchesEvent | {
   type: "update readOnly";
   readOnly: boolean;
 } | {
@@ -2864,52 +2995,52 @@ declare const editorMachine: xstate73.StateMachine<{
   editor: PortableTextSlateEditor;
 }, {}, never, {
   type: "add behavior to context";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "remove behavior from context";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "add slate editor to context";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "emit patch event";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "emit mutation event";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "emit read only";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "emit editable";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "defer event";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "emit pending events";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "emit ready";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "clear pending events";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "discard conflicting pending patches";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "discard all pending events";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "defer incoming patches";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "emit pending incoming patches";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "clear pending incoming patches";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 } | {
   type: "handle blur";
   params: unknown;
@@ -2921,7 +3052,7 @@ declare const editorMachine: xstate73.StateMachine<{
   params: unknown;
 } | {
   type: "sort behaviors";
-  params: xstate73.NonReducibleUnknown;
+  params: xstate77.NonReducibleUnknown;
 }, {
   type: "slate is busy";
   params: unknown;
@@ -2950,7 +3081,7 @@ declare const editorMachine: xstate73.StateMachine<{
   readOnly?: boolean;
   schema: EditorSchema;
   initialValue?: Array<PortableTextBlock>;
-}, xstate73.NonReducibleUnknown, InternalPatchEvent | MutationEvent | PatchesEvent | {
+}, xstate77.NonReducibleUnknown, {
   type: "blurred";
   event: react13.FocusEvent<HTMLDivElement, Element>;
 } | {
@@ -2971,7 +3102,7 @@ declare const editorMachine: xstate73.StateMachine<{
   value: Array<PortableTextBlock> | undefined;
 } | {
   type: "loading";
-} | {
+} | MutationEvent | {
   type: "read only";
 } | {
   type: "ready";
@@ -2981,7 +3112,7 @@ declare const editorMachine: xstate73.StateMachine<{
 } | {
   type: "value changed";
   value: Array<PortableTextBlock> | undefined;
-}, xstate73.MetaObject, {
+} | InternalPatchEvent | PatchesEvent, xstate77.MetaObject, {
   id: "editor";
   states: {
     readonly 'edit mode': {
@@ -3487,6 +3618,15 @@ type BehaviorAction = {
      * ```
      */
     send: (event: ExternalBehaviorEvent) => void;
+    /**
+     * The underlying Slate editor instance.
+     *
+     * Use this sparingly and only for setting transient state like
+     * `splitContext` that coordinates between behaviors and other systems.
+     *
+     * @internal
+     */
+    slateEditor: PortableTextSlateEditor;
   }) => void;
 };
 /**