@portabletext/editor 6.0.1-canary.1 → 6.0.1

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

@@ -3,7 +3,7 @@ import { AnnotationDefinition, AnnotationSchemaType, AnnotationSchemaType as Ann
 import * as xstate73 from "xstate";
 import { ActorRef, ActorRefFrom, EventObject, Snapshot } from "xstate";
 import * as react10 from "react";
-import React$1, { BaseSyntheticEvent, ClipboardEvent as ClipboardEvent$1, FocusEvent, JSX, PropsWithChildren, ReactElement, RefObject, TextareaHTMLAttributes } from "react";
+import React$1, { BaseSyntheticEvent, ClipboardEvent as ClipboardEvent$1, FocusEvent, JSX, MutableRefObject, PropsWithChildren, ReactElement, RefObject, TextareaHTMLAttributes } from "react";
 import { Patch, Patch as Patch$1 } from "@portabletext/patches";
 type MIMEType = `${string}/${string}`;
 /**
@@ -117,121 +117,6 @@ 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;
@@ -276,6 +161,11 @@ 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[];
@@ -300,25 +190,18 @@ 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?: {
@@ -332,7 +215,6 @@ 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>;
@@ -342,25 +224,18 @@ 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;
@@ -369,15 +244,15 @@ interface BaseEditor {
   parent: OmitFirstArg<typeof Editor$1.parent>;
   path: OmitFirstArg<typeof Editor$1.path>;
   pathRef: OmitFirstArg<typeof Editor$1.pathRef>;
-  pathRefs: OmitFirstArg<typeof Editor$1.pathRefs>;
+  pathRefs: Set<PathRef>;
   point: OmitFirstArg<typeof Editor$1.point>;
   pointRef: OmitFirstArg<typeof Editor$1.pointRef>;
-  pointRefs: OmitFirstArg<typeof Editor$1.pointRefs>;
+  pointRefs: Set<PointRef>;
   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: OmitFirstArg<typeof Editor$1.rangeRefs>;
+  rangeRefs: Set<RangeRef>;
   start: OmitFirstArg<typeof Editor$1.start>;
   string: OmitFirstArg<typeof Editor$1.string>;
   unhangRange: OmitFirstArg<typeof Editor$1.unhangRange>;
@@ -404,17 +279,11 @@ 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;
 }
@@ -499,13 +368,6 @@ 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.
    */
@@ -514,22 +376,6 @@ 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.
    */
@@ -538,27 +384,11 @@ 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.
    *
@@ -570,17 +400,6 @@ 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.
@@ -602,10 +421,6 @@ 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.
    */
@@ -630,10 +445,6 @@ 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.
    */
@@ -722,14 +533,6 @@ 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.
    *
@@ -1513,6 +1316,121 @@ 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;
 }
@@ -1522,9 +1440,6 @@ interface SelectionMoveOptions {
   reverse?: boolean;
   edge?: SelectionEdge;
 }
-interface SelectionSetPointOptions {
-  edge?: SelectionEdge;
-}
 interface SelectionTransforms {
   /**
    * Collapse the selection.
@@ -1542,10 +1457,6 @@ 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.
    */
@@ -1596,6 +1507,10 @@ declare class Key {
   id: string;
   constructor();
 }
+type Action = {
+  at?: Point | Range;
+  run: () => void;
+};
 /**
  * A DOM-specific version of the `Editor` interface.
  */
@@ -1609,6 +1524,32 @@ 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 {
   /**
@@ -1749,6 +1690,46 @@ 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.
  */
@@ -1759,6 +1740,7 @@ interface ReactEditor extends DOMEditor {
    * disabled.
    */
   getChunkSize: (node: Ancestor) => number | null;
+  keyToChunkTree: WeakMap<Key, ChunkTree>;
 }
 interface ReactEditorInterface extends DOMEditorInterface {}
 declare const ReactEditor: ReactEditorInterface;
@@ -1794,50 +1776,6 @@ 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';
@@ -1845,18 +1783,6 @@ 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;
-  }>;
   decoratorState: Record<string, boolean | undefined>;
   blockIndexMap: Map<string, number>;
   history: History;
@@ -1866,28 +1792,6 @@ 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;
@@ -2631,7 +2535,6 @@ type ScrollSelectionIntoViewFunction = (editor: PortableTextEditor, domRange: gl
  * @alpha */
 interface RangeDecorationOnMovedDetails {
   rangeDecoration: RangeDecoration;
-  previousSelection: EditorSelection;
   newSelection: EditorSelection;
   origin: 'remote' | 'local';
 }
@@ -2660,24 +2563,9 @@ interface RangeDecoration {
    */
   selection: EditorSelection;
   /**
-   * 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) => 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.
+   * A optional callback that will be called when the range decoration potentially moves according to user edits.
    */
-  id?: string;
+  onMoved?: (details: RangeDecorationOnMovedDetails) => void;
   /**
    * A custom payload that can be set on the range decoration
    */
@@ -3599,15 +3487,6 @@ 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;
 };
 /**