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

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 { 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, 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 { 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 * as react4 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}`;
 /**
@@ -106,771 +106,66 @@ type ChildPath = [{
 }, 'children', {
   _key: string;
 }];
-type LeafEdge = 'start' | 'end';
-type MaximizeMode = RangeMode | 'all';
-type MoveUnit = 'offset' | 'character' | 'word' | 'line';
-type RangeDirection = TextDirection | 'outward' | 'inward';
-type RangeMode = 'highest' | 'lowest';
-type SelectionEdge = 'anchor' | 'focus' | 'start' | 'end';
-type SelectionMode = 'all' | 'highest' | 'lowest';
-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 TextDeleteOptions {
-  at?: Location;
-  distance?: number;
-  unit?: TextUnit;
-  reverse?: boolean;
-  hanging?: boolean;
-  voids?: boolean;
-}
-interface TextInsertFragmentOptions {
-  at?: Location;
-  hanging?: boolean;
-  voids?: boolean;
-  batchDirty?: boolean;
-}
-interface TextInsertTextOptions {
-  at?: Location;
-  voids?: boolean;
-}
-interface TextTransforms {
-  /**
-   * Delete content in the editor.
-   */
-  delete: (editor: Editor$1, options?: TextDeleteOptions) => void;
-  /**
-   * Insert a fragment in the editor
-   * 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;
-  /**
-   * Insert a string of text in the editor
-   * at the specified location or (if not defined) the current selection or (if not defined) the end of the document.
-   */
-  insertText: (editor: Editor$1, text: string, options?: TextInsertTextOptions) => void;
-}
-declare const TextTransforms: TextTransforms;
-/**
- * The `Editor` interface stores all the state of a Slate editor. It is extended
- * by plugins that wish to add their own helpers and implement new behaviors.
- */
-interface BaseEditor {
-  children: Descendant[];
-  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[];
-  getFragment: () => Descendant[];
-  isElementReadOnly: (element: Element$1) => boolean;
-  isSelectable: (element: Element$1) => boolean;
-  markableVoid: (element: Element$1) => boolean;
-  normalizeNode: (entry: NodeEntry, options?: {
-    operation?: Operation;
-    fallbackElement?: () => Element$1;
-  }) => void;
-  onChange: (options?: {
-    operation?: Operation;
-  }) => void;
-  shouldNormalize: ({
-    iteration,
-    dirtyPaths,
-    operation
-  }: {
-    iteration: number;
-    initialDirtyPathsLength: number;
-    dirtyPaths: Path$1[];
-    operation?: Operation;
-  }) => boolean;
-  collapse: OmitFirstArg<typeof Transforms.collapse>;
-  delete: OmitFirstArg<typeof Transforms.delete>;
-  deselect: OmitFirstArg<typeof Transforms.deselect>;
-  insertBreak: OmitFirstArg<typeof Editor$1.insertBreak>;
-  insertFragment: OmitFirstArg<typeof Transforms.insertFragment>;
-  insertNodes: OmitFirstArg<typeof Transforms.insertNodes>;
-  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>;
-  removeNodes: OmitFirstArg<typeof Transforms.removeNodes>;
-  select: OmitFirstArg<typeof Transforms.select>;
-  setNodes: <T extends Node$1>(props: Partial<T>, options?: {
-    at?: Location;
-    match?: NodeMatch<T>;
-    mode?: MaximizeMode;
-    hanging?: boolean;
-    split?: boolean;
-    voids?: boolean;
-    compare?: PropsCompare;
-    merge?: PropsMerge;
-  }) => void;
-  setNormalizing: OmitFirstArg<typeof Editor$1.setNormalizing>;
-  setSelection: OmitFirstArg<typeof Transforms.setSelection>;
-  splitNodes: OmitFirstArg<typeof Transforms.splitNodes>;
-  unsetNodes: OmitFirstArg<typeof Transforms.unsetNodes>;
-  unwrapNodes: OmitFirstArg<typeof Transforms.unwrapNodes>;
-  withoutNormalizing: OmitFirstArg<typeof Editor$1.withoutNormalizing>;
-  wrapNodes: OmitFirstArg<typeof Transforms.wrapNodes>;
-  above: <T extends Ancestor>(options?: EditorAboveOptions<T>) => NodeEntry<T> | undefined;
-  after: OmitFirstArg<typeof Editor$1.after>;
-  before: OmitFirstArg<typeof Editor$1.before>;
-  elementReadOnly: OmitFirstArg<typeof Editor$1.elementReadOnly>;
-  end: OmitFirstArg<typeof Editor$1.end>;
-  getMarks: OmitFirstArg<typeof Editor$1.marks>;
-  hasInlines: OmitFirstArg<typeof Editor$1.hasInlines>;
-  hasPath: OmitFirstArg<typeof Editor$1.hasPath>;
-  isBlock: OmitFirstArg<typeof Editor$1.isBlock>;
-  isEdge: OmitFirstArg<typeof Editor$1.isEdge>;
-  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>;
-  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;
-  node: OmitFirstArg<typeof Editor$1.node>;
-  nodes: <T extends Node$1>(options?: EditorNodesOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
-  parent: OmitFirstArg<typeof Editor$1.parent>;
-  path: OmitFirstArg<typeof Editor$1.path>;
-  pathRef: OmitFirstArg<typeof Editor$1.pathRef>;
-  pathRefs: Set<PathRef>;
-  point: OmitFirstArg<typeof Editor$1.point>;
-  pointRef: OmitFirstArg<typeof Editor$1.pointRef>;
-  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: Set<RangeRef>;
-  start: OmitFirstArg<typeof Editor$1.start>;
-  string: OmitFirstArg<typeof Editor$1.string>;
-  unhangRange: OmitFirstArg<typeof Editor$1.unhangRange>;
-  void: OmitFirstArg<typeof Editor$1.void>;
-  shouldMergeNodesRemovePrevNode: OmitFirstArg<typeof Editor$1.shouldMergeNodesRemovePrevNode>;
-}
-type Editor$1 = ExtendedType<'Editor', BaseEditor>;
-type BaseSelection = Range | null;
-type Selection$1 = ExtendedType<'Selection', BaseSelection>;
-type EditorMarks = Omit<Text$1, 'text'>;
-interface EditorAboveOptions<T extends Ancestor> {
-  at?: Location;
-  match?: NodeMatch<T>;
-  mode?: MaximizeMode;
-  voids?: boolean;
-}
-interface EditorAfterOptions {
-  distance?: number;
-  unit?: TextUnitAdjustment;
-  voids?: boolean;
-}
-interface EditorBeforeOptions {
-  distance?: number;
-  unit?: TextUnitAdjustment;
-  voids?: boolean;
-}
-interface EditorElementReadOnlyOptions {
-  at?: Location;
-  mode?: MaximizeMode;
-  voids?: boolean;
-}
-interface EditorIsEditorOptions {
-  deep?: boolean;
-}
-interface EditorLeafOptions {
-  depth?: number;
-  edge?: LeafEdge;
-}
-interface EditorLevelsOptions<T extends Node$1> {
-  at?: Location;
-  match?: NodeMatch<T>;
-  reverse?: boolean;
-  voids?: boolean;
-}
-interface EditorNextOptions<T extends Descendant> {
-  at?: Location;
-  match?: NodeMatch<T>;
-  mode?: SelectionMode;
-  voids?: boolean;
-}
-interface EditorNodeOptions {
-  depth?: number;
-  edge?: LeafEdge;
-}
-interface EditorNodesOptions<T extends Node$1> {
-  at?: Location | Span;
-  match?: NodeMatch<T>;
-  mode?: SelectionMode;
-  universal?: boolean;
-  reverse?: boolean;
-  voids?: boolean;
-  pass?: (entry: NodeEntry) => boolean;
-}
-interface EditorNormalizeOptions {
-  force?: boolean;
-  operation?: Operation;
-}
-interface EditorParentOptions {
-  depth?: number;
-  edge?: LeafEdge;
-}
-interface EditorPathOptions {
-  depth?: number;
-  edge?: LeafEdge;
-}
-interface EditorPathRefOptions {
-  affinity?: TextDirection | null;
-}
-interface EditorPointOptions {
-  edge?: LeafEdge;
-}
-interface EditorPointRefOptions {
-  affinity?: TextDirection | null;
-}
-interface EditorPositionsOptions {
-  at?: Location;
-  unit?: TextUnitAdjustment;
-  reverse?: boolean;
-  voids?: boolean;
-}
-interface EditorPreviousOptions<T extends Node$1> {
-  at?: Location;
-  match?: NodeMatch<T>;
-  mode?: SelectionMode;
-  voids?: boolean;
-}
-interface EditorRangeRefOptions {
-  affinity?: RangeDirection | null;
-}
-interface EditorStringOptions {
-  voids?: boolean;
-}
-interface EditorUnhangRangeOptions {
-  voids?: boolean;
-}
-interface EditorVoidOptions {
-  at?: Location;
-  mode?: MaximizeMode;
-  voids?: boolean;
-}
-interface EditorInterface {
-  /**
-   * Get the ancestor above a location in the document.
-   */
-  above: <T extends Ancestor>(editor: Editor$1, options?: EditorAboveOptions<T>) => NodeEntry<T> | undefined;
-  /**
-   * Get the point after a location.
-   */
-  after: (editor: Editor$1, at: Location, options?: EditorAfterOptions) => Point | undefined;
-  /**
-   * Get the point before a location.
-   */
-  before: (editor: Editor$1, at: Location, options?: EditorBeforeOptions) => Point | undefined;
-  /**
-   * Match a read-only element in the current branch of the editor.
-   */
-  elementReadOnly: (editor: Editor$1, options?: EditorElementReadOnlyOptions) => NodeEntry<Element$1> | undefined;
-  /**
-   * Get the end point of a location.
-   */
-  end: (editor: Editor$1, at: Location) => Point;
-  /**
-   * 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;
-  /**
-   * Insert a block break at the current selection.
-   *
-   * If the selection is currently expanded, it will be deleted first.
-   */
-  insertBreak: (editor: Editor$1) => void;
-  /**
-   * Inserts a fragment
-   * 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;
-  /**
-   * 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.
-   */
-  insertText: (editor: Editor$1, text: string, options?: TextInsertTextOptions) => void;
-  /**
-   * Check if a value is a block `Element` object.
-   */
-  isBlock: (editor: Editor$1, value: Element$1) => boolean;
-  /**
-   * Check if a point is an edge of a location.
-   */
-  isEdge: (editor: Editor$1, point: Point, at: Location) => boolean;
-  /**
-   * Check if a value is an `Editor` object.
-   */
-  isEditor: (value: any, options?: EditorIsEditorOptions) => value is Editor$1;
-  /**
-   * Check if a value is a read-only `Element` object.
-   */
-  isElementReadOnly: (editor: Editor$1, element: Element$1) => boolean;
-  /**
-   * Check if a point is the end point of a location.
-   */
-  isEnd: (editor: Editor$1, point: Point, at: Location) => boolean;
-  /**
-   * Check if a value is an inline `Element` object.
-   */
-  isInline: (editor: Editor$1, value: Element$1) => boolean;
-  /**
-   * Check if the editor is currently normalizing after each operation.
-   */
-  isNormalizing: (editor: Editor$1) => boolean;
-  /**
-   * Check if a value is a selectable `Element` object.
-   */
-  isSelectable: (editor: Editor$1, element: Element$1) => boolean;
-  /**
-   * Check if a point is the start point of a location.
-   */
-  isStart: (editor: Editor$1, point: Point, at: Location) => boolean;
-  /**
-   * Check if a value is a void `Element` object.
-   */
-  isVoid: (editor: Editor$1, value: Element$1) => boolean;
-  /**
-   * Get the leaf text node at a location.
-   */
-  leaf: (editor: Editor$1, at: Location, options?: EditorLeafOptions) => NodeEntry<Text$1>;
-  /**
-   * Iterate through all of the levels at a location.
-   */
-  levels: <T extends Node$1>(editor: Editor$1, options?: EditorLevelsOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
-  /**
-   * Get the marks that would be added to text at the current selection.
-   */
-  marks: (editor: Editor$1) => Omit<Text$1, 'text'> | null;
-  /**
-   * Get the matching node in the branch of the document after a location.
-   */
-  next: <T extends Descendant>(editor: Editor$1, options?: EditorNextOptions<T>) => NodeEntry<T> | undefined;
-  /**
-   * Get the node at a location.
-   */
-  node: (editor: Editor$1, at: Location, options?: EditorNodeOptions) => NodeEntry;
-  /**
-   * Iterate through all of the nodes in the Editor.
-   */
-  nodes: <T extends Node$1>(editor: Editor$1, options?: EditorNodesOptions<T>) => Generator<NodeEntry<T>, void, undefined>;
-  /**
-   * Normalize any dirty objects in the editor.
-   */
-  normalize: (editor: Editor$1, options?: EditorNormalizeOptions) => void;
-  /**
-   * Get the parent node of a location.
-   */
-  parent: (editor: Editor$1, at: Location, options?: EditorParentOptions) => NodeEntry<Ancestor>;
-  /**
-   * Get the path of a location.
-   */
-  path: (editor: Editor$1, at: Location, options?: EditorPathOptions) => Path$1;
-  /**
-   * Create a mutable ref for a `Path` object, which will stay in sync as new
-   * operations are applied to the editor.
-   */
-  pathRef: (editor: Editor$1, path: Path$1, options?: EditorPathRefOptions) => PathRef;
-  /**
-   * Get the set of currently tracked path refs of the editor.
-   */
-  pathRefs: (editor: Editor$1) => Set<PathRef>;
-  /**
-   * Get the start or end point of a location.
-   */
-  point: (editor: Editor$1, at: Location, options?: EditorPointOptions) => Point;
-  /**
-   * Create a mutable ref for a `Point` object, which will stay in sync as new
-   * operations are applied to the editor.
-   */
-  pointRef: (editor: Editor$1, point: Point, options?: EditorPointRefOptions) => PointRef;
-  /**
-   * Get the set of currently tracked point refs of the editor.
-   */
-  pointRefs: (editor: Editor$1) => Set<PointRef>;
-  /**
-   * Return all the positions in `at` range where a `Point` can be placed.
-   *
-   * By default, moves forward by individual offsets at a time, but
-   * the `unit` option can be used to to move by character, word, line, or block.
-   *
-   * The `reverse` option can be used to change iteration direction.
-   *
-   * Note: By default void nodes are treated as a single point and iteration
-   * will not happen inside their content unless you pass in true for the
-   * `voids` option, then iteration will occur.
-   */
-  positions: (editor: Editor$1, options?: EditorPositionsOptions) => Generator<Point, void, undefined>;
-  /**
-   * Get the matching node in the branch of the document before a location.
-   */
-  previous: <T extends Node$1>(editor: Editor$1, options?: EditorPreviousOptions<T>) => NodeEntry<T> | undefined;
-  /**
-   * Get a range of a location.
-   */
-  range: (editor: Editor$1, at: Location, to?: Location) => Range;
-  /**
-   * Create a mutable ref for a `Range` object, which will stay in sync as new
-   * operations are applied to the editor.
-   */
-  rangeRef: (editor: Editor$1, range: Range, options?: EditorRangeRefOptions) => RangeRef;
-  /**
-   * Get the set of currently tracked range refs of the editor.
-   */
-  rangeRefs: (editor: Editor$1) => Set<RangeRef>;
-  /**
-   * Manually set if the editor should currently be normalizing.
-   *
-   * Note: Using this incorrectly can leave the editor in an invalid state.
-   *
-   */
-  setNormalizing: (editor: Editor$1, isNormalizing: boolean) => void;
-  /**
-   * Get the start point of a location.
-   */
-  start: (editor: Editor$1, at: Location) => Point;
-  /**
-   * Get the text string content of a location.
-   *
-   * Note: by default the text of void nodes is considered to be an empty
-   * string, regardless of content, unless you pass in true for the voids option
-   */
-  string: (editor: Editor$1, at: Location, options?: EditorStringOptions) => string;
-  /**
-   * Convert a range into a non-hanging one.
-   */
-  unhangRange: (editor: Editor$1, range: Range, options?: EditorUnhangRangeOptions) => Range;
-  /**
-   * Match a void node in the current branch of the editor.
-   */
-  void: (editor: Editor$1, options?: EditorVoidOptions) => NodeEntry<Element$1> | undefined;
-  /**
-   * Call a function, deferring normalization until after it completes.
-   */
-  withoutNormalizing: (editor: Editor$1, fn: () => void) => void;
-  /**
-   *  Call a function, Determine whether or not remove the previous node when merge.
-   */
-  shouldMergeNodesRemovePrevNode: (editor: Editor$1, prevNodeEntry: NodeEntry, curNodeEntry: NodeEntry) => boolean;
-}
-declare const Editor$1: EditorInterface;
-/**
- * A helper type for narrowing matched nodes with a predicate.
- */
-type NodeMatch<T extends Node$1> = ((node: Node$1, path: Path$1) => node is T) | ((node: Node$1, path: Path$1) => boolean);
-type PropsCompare = (prop: Partial<Node$1>, node: Partial<Node$1>) => boolean;
-type PropsMerge = (prop: Partial<Node$1>, node: Partial<Node$1>) => object;
 /**
- * `Element` objects are a type of node in a Slate document that contain other
- * element nodes or text nodes. They can be either "blocks" or "inlines"
- * depending on the Slate editor's configuration.
+ * @public
  */
-interface BaseElement {
-  children: Descendant[];
-}
-type Element$1 = ExtendedType<'Element', BaseElement>;
-interface ElementIsElementOptions {
-  deep?: boolean;
-}
-interface ElementInterface {
-  /**
-   * Check if a value implements the 'Ancestor' interface.
-   */
-  isAncestor: (value: any, options?: ElementIsElementOptions) => value is Ancestor;
-  /**
-   * Check if a value implements the `Element` interface.
-   */
-  isElement: (value: any, options?: ElementIsElementOptions) => value is Element$1;
-  /**
-   * Check if a value is an array of `Element` objects.
-   */
-  isElementList: (value: any, options?: ElementIsElementOptions) => value is Element$1[];
-  /**
-   * Check if a set of props is a partial of Element.
-   */
-  isElementProps: (props: any) => props is Partial<Element$1>;
-  /**
-   * Check if a value implements the `Element` interface and has elementKey with selected value.
-   * Default it check to `type` key value
-   */
-  isElementType: <T extends Element$1>(value: any, elementVal: string, elementKey?: string) => value is T;
-  /**
-   * Check if an element matches set of properties.
-   *
-   * Note: this checks custom properties, and it does not ensure that any
-   * children are equivalent.
-   */
-  matches: (element: Element$1, props: Partial<Element$1>) => boolean;
-}
-declare const Element$1: ElementInterface;
+type EditorSchema = Schema;
 /**
- * `ElementEntry` objects refer to an `Element` and the `Path` where it can be
- * found inside a root node.
+ * `Path` arrays are a list of indexes that describe a node's exact position in
+ * a Slate node tree. Although they are usually relative to the root `Editor`
+ * object, they can be relative to any `Node` object.
  */
-type ElementEntry = [Element$1, Path$1];
+type Path$1 = number[];
+type Node$1 = PortableTextTextBlock | PortableTextObject | PortableTextSpan;
+type TextDirection = 'forward' | 'backward';
 /**
- * The `Location` interface is a union of the ways to refer to a specific
- * location in a Slate document: paths, points or ranges.
- *
- * Methods will often accept a `Location` instead of requiring only a `Path`,
- * `Point` or `Range`. This eliminates the need for developers to manage
- * converting between the different interfaces in their own code base.
+ * `Point` objects refer to a specific location in a text node in a Slate
+ * document. Its path refers to the location of the node in the tree, and its
+ * offset refers to the distance into the node's string of text. Points can
+ * only refer to `Text` nodes.
  */
-type Location = Path$1 | Point | Range;
-interface LocationInterface {
-  /**
-   * Check if a value implements the `Location` interface.
-   */
-  isLocation: (value: any) => value is Location;
+interface Point {
+  path: number[];
+  offset: number;
 }
-declare const Location: LocationInterface;
 /**
- * The `Span` interface is a low-level way to refer to locations in nodes
- * without using `Point` which requires leaf text nodes to be present.
+ * `Range` objects are a set of points that refer to a specific span of a Slate
+ * document. They can define a span inside a single node or a can span across
+ * multiple nodes.
  */
-type Span = [Path$1, Path$1];
-interface SpanInterface {
-  /**
-   * Check if a value implements the `Span` interface.
-   */
-  isSpan: (value: any) => value is Span;
-}
-declare const Span: SpanInterface;
-type Node$1 = Editor$1 | Element$1 | Text$1;
-interface NodeAncestorsOptions {
-  reverse?: boolean;
-}
-interface NodeChildrenOptions {
-  reverse?: boolean;
-}
-interface NodeDescendantsOptions {
-  from?: Path$1;
-  to?: Path$1;
-  reverse?: boolean;
-  pass?: (node: NodeEntry) => boolean;
-}
-interface NodeElementsOptions {
-  from?: Path$1;
-  to?: Path$1;
-  reverse?: boolean;
-  pass?: (node: NodeEntry) => boolean;
-}
-interface NodeIsNodeOptions {
-  deep?: boolean;
-}
-interface NodeLevelsOptions {
-  reverse?: boolean;
-}
-interface NodeNodesOptions {
-  from?: Path$1;
-  to?: Path$1;
-  reverse?: boolean;
-  pass?: (entry: NodeEntry) => boolean;
-}
-interface NodeTextsOptions {
-  from?: Path$1;
-  to?: Path$1;
-  reverse?: boolean;
-  pass?: (node: NodeEntry) => boolean;
-}
-interface NodeInterface {
-  /**
-   * Get the node at a specific path, asserting that it's an ancestor node.
-   */
-  ancestor: (root: Node$1, path: Path$1) => Ancestor;
-  /**
-   * Return a generator of all the ancestor nodes above a specific path.
-   *
-   * By default the order is top-down, from highest to lowest ancestor in
-   * the tree, but you can pass the `reverse: true` option to go bottom-up.
-   */
-  ancestors: (root: Node$1, path: Path$1, options?: NodeAncestorsOptions) => Generator<NodeEntry<Ancestor>, void, undefined>;
-  /**
-   * Get the child of a node at a specific index.
-   */
-  child: (root: Node$1, index: number) => Descendant;
-  /**
-   * Iterate over the children of a node at a specific path.
-   */
-  children: (root: Node$1, path: Path$1, options?: NodeChildrenOptions) => Generator<NodeEntry<Descendant>, void, undefined>;
-  /**
-   * Get an entry for the common ancesetor node of two paths.
-   */
-  common: (root: Node$1, path: Path$1, another: Path$1) => NodeEntry;
-  /**
-   * Get the node at a specific path, asserting that it's a descendant node.
-   */
-  descendant: (root: Node$1, path: Path$1) => Descendant;
-  /**
-   * Return a generator of all the descendant node entries inside a root node.
-   */
-  descendants: (root: Node$1, options?: NodeDescendantsOptions) => Generator<NodeEntry<Descendant>, void, undefined>;
-  /**
-   * Return a generator of all the element nodes inside a root node. Each iteration
-   * will return an `ElementEntry` tuple consisting of `[Element, Path]`. If the
-   * root node is an element it will be included in the iteration as well.
-   */
-  elements: (root: Node$1, options?: NodeElementsOptions) => Generator<ElementEntry, void, undefined>;
-  /**
-   * Extract props from a Node.
-   */
-  extractProps: (node: Node$1) => NodeProps;
-  /**
-   * Get the first leaf node entry in a root node from a path.
-   */
-  first: (root: Node$1, path: Path$1) => NodeEntry;
-  /**
-   * Get the sliced fragment represented by a range inside a root node.
-   */
-  fragment: <T extends Ancestor = Editor$1>(root: T, range: Range) => T['children'];
-  /**
-   * Get the descendant node referred to by a specific path. If the path is an
-   * empty array, it refers to the root node itself.
-   */
-  get: (root: Node$1, path: Path$1) => Node$1;
-  /**
-   * Similar to get, but returns undefined if the node does not exist.
-   */
-  getIf: (root: Node$1, path: Path$1) => Node$1 | undefined;
-  /**
-   * Check if a descendant node exists at a specific path.
-   */
-  has: (root: Node$1, path: Path$1) => boolean;
-  /**
-   * Check if a value implements the `Node` interface.
-   */
-  isNode: (value: any, options?: NodeIsNodeOptions) => value is Node$1;
-  /**
-   * Check if a value is a list of `Node` objects.
-   */
-  isNodeList: (value: any, options?: NodeIsNodeOptions) => value is Node$1[];
-  /**
-   * Get the last leaf node entry in a root node from a path.
-   */
-  last: (root: Node$1, path: Path$1) => NodeEntry;
-  /**
-   * Get the node at a specific path, ensuring it's a leaf text node.
-   */
-  leaf: (root: Node$1, path: Path$1) => Text$1;
-  /**
-   * Return a generator of the in a branch of the tree, from a specific path.
-   *
-   * By default the order is top-down, from highest to lowest node in the tree,
-   * but you can pass the `reverse: true` option to go bottom-up.
-   */
-  levels: (root: Node$1, path: Path$1, options?: NodeLevelsOptions) => Generator<NodeEntry, void, undefined>;
-  /**
-   * Check if a node matches a set of props.
-   */
-  matches: (node: Node$1, props: Partial<Node$1>) => boolean;
-  /**
-   * Return a generator of all the node entries of a root node. Each entry is
-   * returned as a `[Node, Path]` tuple, with the path referring to the node's
-   * position inside the root node.
-   */
-  nodes: (root: Node$1, options?: NodeNodesOptions) => Generator<NodeEntry, void, undefined>;
-  /**
-   * Get the parent of a node at a specific path.
-   */
-  parent: (root: Node$1, path: Path$1) => Ancestor;
-  /**
-   * Get the concatenated text string of a node's content.
-   *
-   * Note that this will not include spaces or line breaks between block nodes.
-   * It is not a user-facing string, but a string for performing offset-related
-   * computations for a node.
-   */
-  string: (node: Node$1) => string;
-  /**
-   * Return a generator of all leaf text nodes in a root node.
-   */
-  texts: (root: Node$1, options?: NodeTextsOptions) => Generator<NodeEntry<Text$1>, void, undefined>;
+interface Range {
+  anchor: Point;
+  focus: Point;
 }
-declare const Node$1: NodeInterface;
-/**
- * The `Descendant` union type represents nodes that are descendants in the
- * tree. It is returned as a convenience in certain cases to narrow a value
- * further than the more generic `Node` union.
- */
-type Descendant = Element$1 | Text$1;
-/**
- * The `Ancestor` union type represents nodes that are ancestors in the tree.
- * It is returned as a convenience in certain cases to narrow a value further
- * than the more generic `Node` union.
- */
-type Ancestor = Editor$1 | Element$1;
-/**
- * `NodeEntry` objects are returned when iterating over the nodes in a Slate
- * document tree. They consist of the node and its `Path` relative to the root
- * node in the document.
- */
-type NodeEntry<T extends Node$1 = Node$1> = [T, Path$1];
-/**
- * Convenience type for returning the props of a node.
- */
-type NodeProps = Omit<Editor$1, 'children'> | Omit<Element$1, 'children'> | Omit<Text$1, 'text'>;
-type BaseInsertNodeOperation = {
+type InsertNodeOperation = {
   type: 'insert_node';
   path: Path$1;
   node: Node$1;
 };
-type InsertNodeOperation = ExtendedType<'InsertNodeOperation', BaseInsertNodeOperation>;
-type BaseInsertTextOperation = {
+type InsertTextOperation = {
   type: 'insert_text';
   path: Path$1;
   offset: number;
   text: string;
 };
-type InsertTextOperation = ExtendedType<'InsertTextOperation', BaseInsertTextOperation>;
-type BaseMergeNodeOperation = {
-  type: 'merge_node';
-  path: Path$1;
-  position: number;
-  properties: Partial<Node$1>;
-};
-type MergeNodeOperation = ExtendedType<'MergeNodeOperation', BaseMergeNodeOperation>;
-type BaseMoveNodeOperation = {
-  type: 'move_node';
-  path: Path$1;
-  newPath: Path$1;
-};
-type MoveNodeOperation = ExtendedType<'MoveNodeOperation', BaseMoveNodeOperation>;
-type BaseRemoveNodeOperation = {
+type RemoveNodeOperation = {
   type: 'remove_node';
   path: Path$1;
   node: Node$1;
 };
-type RemoveNodeOperation = ExtendedType<'RemoveNodeOperation', BaseRemoveNodeOperation>;
-type BaseRemoveTextOperation = {
+type RemoveTextOperation = {
   type: 'remove_text';
   path: Path$1;
   offset: number;
   text: string;
 };
-type RemoveTextOperation = ExtendedType<'RemoveTextOperation', BaseRemoveTextOperation>;
-type BaseSetNodeOperation = {
+type SetNodeOperation = {
   type: 'set_node';
   path: Path$1;
   properties: Partial<Node$1>;
   newProperties: Partial<Node$1>;
 };
-type SetNodeOperation = ExtendedType<'SetNodeOperation', BaseSetNodeOperation>;
-type BaseSetSelectionOperation = {
+type SetSelectionOperation = {
   type: 'set_selection';
   properties: null;
   newProperties: Range;
@@ -883,53 +178,20 @@ type BaseSetSelectionOperation = {
   properties: Range;
   newProperties: null;
 };
-type SetSelectionOperation = ExtendedType<'SetSelectionOperation', BaseSetSelectionOperation>;
-type BaseSplitNodeOperation = {
-  type: 'split_node';
-  path: Path$1;
-  position: number;
-  properties: Partial<Node$1>;
+type Operation = InsertNodeOperation | RemoveNodeOperation | SetNodeOperation | SetSelectionOperation | InsertTextOperation | RemoveTextOperation;
+type DecoratedRange = Range & {
+  rangeDecoration: RangeDecoration;
+  merge: (leaf: Record<string, unknown>, decoration: Record<string, unknown>) => void;
 };
-type SplitNodeOperation = ExtendedType<'SplitNodeOperation', BaseSplitNodeOperation>;
-type NodeOperation = InsertNodeOperation | MergeNodeOperation | MoveNodeOperation | RemoveNodeOperation | SetNodeOperation | SplitNodeOperation;
-type SelectionOperation = SetSelectionOperation;
-type TextOperation = InsertTextOperation | RemoveTextOperation;
 /**
- * `Operation` objects define the low-level instructions that Slate editors use
- * to apply changes to their internal state. Representing all changes as
- * operations is what allows Slate editors to easily implement history,
- * collaboration, and other features.
+ * The `Location` interface is a union of the ways to refer to a specific
+ * location in a Slate document: paths, points or ranges.
+ *
+ * Methods will often accept a `Location` instead of requiring only a `Path`,
+ * `Point` or `Range`. This eliminates the need for developers to manage
+ * converting between the different interfaces in their own code base.
  */
-type BaseOperation = NodeOperation | SelectionOperation | TextOperation;
-type Operation = ExtendedType<'Operation', BaseOperation>;
-interface OperationInterface {
-  /**
-   * Check if a value is a `NodeOperation` object.
-   */
-  isNodeOperation: (value: any) => value is NodeOperation;
-  /**
-   * Check if a value is an `Operation` object.
-   */
-  isOperation: (value: any) => value is Operation;
-  /**
-   * Check if a value is a list of `Operation` objects.
-   */
-  isOperationList: (value: any) => value is Operation[];
-  /**
-   * Check if a value is a `SelectionOperation` object.
-   */
-  isSelectionOperation: (value: any) => value is SelectionOperation;
-  /**
-   * Check if a value is a `TextOperation` object.
-   */
-  isTextOperation: (value: any) => value is TextOperation;
-  /**
-   * Invert an operation, returning a new operation that will exactly undo the
-   * original when applied.
-   */
-  inverse: (op: Operation) => Operation;
-}
-declare const Operation: OperationInterface;
+type Location = Path$1 | Point | Range;
 /**
  * `PathRef` objects keep a specific path in a document synced over time as new
  * operations are applied to the editor. You can access their `current` property
@@ -940,207 +202,24 @@ interface PathRef {
   affinity: 'forward' | 'backward' | null;
   unref(): Path$1 | null;
 }
-interface PathRefInterface {
-  /**
-   * Transform the path ref's current value by an operation.
-   */
-  transform: (ref: PathRef, op: Operation) => void;
-}
-declare const PathRef: PathRefInterface;
-/**
- * `Path` arrays are a list of indexes that describe a node's exact position in
- * a Slate node tree. Although they are usually relative to the root `Editor`
- * object, they can be relative to any `Node` object.
- */
-type Path$1 = number[];
-interface PathAncestorsOptions {
-  reverse?: boolean;
-}
-interface PathLevelsOptions {
-  reverse?: boolean;
-}
-interface PathTransformOptions {
-  affinity?: TextDirection | null;
-}
-interface PathInterface {
-  /**
-   * Get a list of ancestor paths for a given path.
-   *
-   * The paths are sorted from shallowest to deepest ancestor. However, if the
-   * `reverse: true` option is passed, they are reversed.
-   */
-  ancestors: (path: Path$1, options?: PathAncestorsOptions) => Path$1[];
-  /**
-   * Get the common ancestor path of two paths.
-   */
-  common: (path: Path$1, another: Path$1) => Path$1;
-  /**
-   * Compare a path to another, returning an integer indicating whether the path
-   * was before, at, or after the other.
-   *
-   * Note: Two paths of unequal length can still receive a `0` result if one is
-   * directly above or below the other. If you want exact matching, use
-   * [[Path.equals]] instead.
-   */
-  compare: (path: Path$1, another: Path$1) => -1 | 0 | 1;
-  /**
-   * Check if a path ends after one of the indexes in another.
-   */
-  endsAfter: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if a path ends at one of the indexes in another.
-   */
-  endsAt: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if a path ends before one of the indexes in another.
-   */
-  endsBefore: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if a path is exactly equal to another.
-   */
-  equals: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if the path of previous sibling node exists
-   */
-  hasPrevious: (path: Path$1) => boolean;
-  /**
-   * Check if a path is after another.
-   */
-  isAfter: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if a path is an ancestor of another.
-   */
-  isAncestor: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if a path is before another.
-   */
-  isBefore: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if a path is a child of another.
-   */
-  isChild: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if a path is equal to or an ancestor of another.
-   */
-  isCommon: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if a path is a descendant of another.
-   */
-  isDescendant: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check if a path is the parent of another.
-   */
-  isParent: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Check is a value implements the `Path` interface.
-   */
-  isPath: (value: any) => value is Path$1;
-  /**
-   * Check if a path is a sibling of another.
-   */
-  isSibling: (path: Path$1, another: Path$1) => boolean;
-  /**
-   * Get a list of paths at every level down to a path. Note: this is the same
-   * as `Path.ancestors`, but including the path itself.
-   *
-   * The paths are sorted from shallowest to deepest. However, if the `reverse:
-   * true` option is passed, they are reversed.
-   */
-  levels: (path: Path$1, options?: PathLevelsOptions) => Path$1[];
-  /**
-   * Given a path, get the path to the next sibling node.
-   */
-  next: (path: Path$1) => Path$1;
-  /**
-   * Returns whether this operation can affect paths or not. Used as an
-   * optimization when updating dirty paths during normalization
-   *
-   * NOTE: This *must* be kept in sync with the implementation of 'transform'
-   * below
-   */
-  operationCanTransformPath: (operation: Operation) => operation is InsertNodeOperation | RemoveNodeOperation | MergeNodeOperation | SplitNodeOperation | MoveNodeOperation;
-  /**
-   * Given a path, return a new path referring to the parent node above it.
-   */
-  parent: (path: Path$1) => Path$1;
-  /**
-   * Given a path, get the path to the previous sibling node.
-   */
-  previous: (path: Path$1) => Path$1;
-  /**
-   * Get a path relative to an ancestor.
-   */
-  relative: (path: Path$1, ancestor: Path$1) => Path$1;
-  /**
-   * Transform a path by an operation.
-   */
-  transform: (path: Path$1, operation: Operation, options?: PathTransformOptions) => Path$1 | null;
-}
-declare const Path$1: PathInterface;
-/**
- * `PointRef` objects keep a specific point in a document synced over time as new
- * operations are applied to the editor. You can access their `current` property
- * at any time for the up-to-date point value.
- */
-interface PointRef {
-  current: Point | null;
-  affinity: TextDirection | null;
-  unref(): Point | null;
-}
-interface PointRefInterface {
-  /**
-   * Transform the point ref's current value by an operation.
-   */
-  transform: (ref: PointRef, op: Operation) => void;
-}
-declare const PointRef: PointRefInterface;
-/**
- * `Point` objects refer to a specific location in a text node in a Slate
- * document. Its path refers to the location of the node in the tree, and its
- * offset refers to the distance into the node's string of text. Points can
- * only refer to `Text` nodes.
- */
-interface BasePoint {
-  path: Path$1;
-  offset: number;
-}
-type Point = ExtendedType<'Point', BasePoint>;
-interface PointTransformOptions {
-  affinity?: TextDirection | null;
-}
-interface PointInterface {
-  /**
-   * Compare a point to another, returning an integer indicating whether the
-   * point was before, at, or after the other.
-   */
-  compare: (point: Point, another: Point) => -1 | 0 | 1;
-  /**
-   * Check if a point is after another.
-   */
-  isAfter: (point: Point, another: Point) => boolean;
-  /**
-   * Check if a point is before another.
-   */
-  isBefore: (point: Point, another: Point) => boolean;
-  /**
-   * Check if a point is exactly equal to another.
-   */
-  equals: (point: Point, another: Point) => boolean;
-  /**
-   * Check if a value implements the `Point` interface.
-   */
-  isPoint: (value: any) => value is Point;
-  /**
-   * Transform a point by an operation.
-   */
-  transform: (point: Point, op: Operation, options?: PointTransformOptions) => Point | null;
+interface PathRefInterface {
+  transform: (ref: PathRef, op: Operation) => void;
 }
-declare const Point: PointInterface;
+declare const PathRef: PathRefInterface;
 /**
- * `PointEntry` objects are returned when iterating over `Point` objects that
- * belong to a range.
+ * `PointRef` objects keep a specific point in a document synced over time as new
+ * operations are applied to the editor. You can access their `current` property
+ * at any time for the up-to-date point value.
  */
-type PointEntry = [Point, 'anchor' | 'focus'];
+interface PointRef {
+  current: Point | null;
+  affinity: TextDirection | null;
+  unref(): Point | null;
+}
+interface PointRefInterface {
+  transform: (ref: PointRef, op: Operation) => void;
+}
+declare const PointRef: PointRefInterface;
 /**
  * `RangeRef` objects keep a specific range in a document synced over time as new
  * operations are applied to the editor. You can access their `current` property
@@ -1151,326 +230,46 @@ interface RangeRef {
   affinity: 'forward' | 'backward' | 'outward' | 'inward' | null;
   unref(): Range | null;
 }
-interface RangeRefInterface {
-  /**
-   * Transform the range ref's current value by an operation.
-   */
-  transform: (ref: RangeRef, op: Operation) => void;
-}
-declare const RangeRef: RangeRefInterface;
-/**
- * `Range` objects are a set of points that refer to a specific span of a Slate
- * document. They can define a span inside a single node or a can span across
- * multiple nodes.
- */
-interface BaseRange {
-  anchor: Point;
-  focus: Point;
-}
-type Range = ExtendedType<'Range', BaseRange>;
-interface RangeEdgesOptions {
-  reverse?: boolean;
-}
-interface RangeTransformOptions {
-  affinity?: RangeDirection | null;
-}
-interface RangeInterface {
-  /**
-   * Get the start and end points of a range, in the order in which they appear
-   * in the document.
-   */
-  edges: (range: Range, options?: RangeEdgesOptions) => [Point, Point];
-  /**
-   * Get the end point of a range.
-   */
-  end: (range: Range) => Point;
-  /**
-   * Check if a range is exactly equal to another.
-   */
-  equals: (range: Range, another: Range) => boolean;
-  /**
-   * Check if a range includes a path, a point or part of another range.
-   */
-  includes: (range: Range, target: Path$1 | Point | Range) => boolean;
-  /**
-   * Check if a range includes another range.
-   */
-  surrounds: (range: Range, target: Range) => boolean;
-  /**
-   * Get the intersection of a range with another.
-   */
-  intersection: (range: Range, another: Range) => Range | null;
-  /**
-   * Check if a range is backward, meaning that its anchor point appears in the
-   * document _after_ its focus point.
-   */
-  isBackward: (range: Range) => boolean;
-  /**
-   * Check if a range is collapsed, meaning that both its anchor and focus
-   * points refer to the exact same position in the document.
-   */
-  isCollapsed: (range: Range) => boolean;
-  /**
-   * Check if a range is expanded.
-   *
-   * This is the opposite of [[Range.isCollapsed]] and is provided for legibility.
-   */
-  isExpanded: (range: Range) => boolean;
-  /**
-   * Check if a range is forward.
-   *
-   * This is the opposite of [[Range.isBackward]] and is provided for legibility.
-   */
-  isForward: (range: Range) => boolean;
-  /**
-   * Check if a value implements the [[Range]] interface.
-   */
-  isRange: (value: any) => value is Range;
-  /**
-   * Iterate through all of the point entries in a range.
-   */
-  points: (range: Range) => Generator<PointEntry, void, undefined>;
-  /**
-   * Get the start point of a range.
-   */
-  start: (range: Range) => Point;
-  /**
-   * Transform a range by an operation.
-   */
-  transform: (range: Range, op: Operation, options?: RangeTransformOptions) => Range | null;
-}
-declare const Range: RangeInterface;
-/**
- * Extendable Custom Types Interface
- */
-type ExtendableTypes = 'Editor' | 'Element' | 'Text' | 'Selection' | 'Range' | 'Point' | 'Operation' | 'InsertNodeOperation' | 'InsertTextOperation' | 'MergeNodeOperation' | 'MoveNodeOperation' | 'RemoveNodeOperation' | 'RemoveTextOperation' | 'SetNodeOperation' | 'SetSelectionOperation' | 'SplitNodeOperation';
-interface CustomTypes {
-  [key: string]: unknown;
-}
-type ExtendedType<K$1 extends ExtendableTypes, B> = unknown extends CustomTypes[K$1] ? B : CustomTypes[K$1];
 /**
- * `Text` objects represent the nodes that contain the actual text content of a
- * Slate document along with any formatting properties. They are always leaf
- * nodes in the document tree as they cannot contain any children.
+ * The `Editor` interface stores all the state of a Slate editor. It is extended
+ * by plugins that wish to add their own helpers and implement new behaviors.
  */
-interface BaseText {
-  text: string;
-}
-type Text$1 = ExtendedType<'Text', BaseText>;
-interface LeafPosition {
-  start: number;
-  end: number;
-  isFirst?: true;
-  isLast?: true;
-}
-interface TextEqualsOptions {
-  loose?: boolean;
-}
-type DecoratedRange$1 = Range & {
-  /**
-   * Customize how another decoration is merged into a text node. If not specified, `Object.assign` would be used.
-   * It is useful for overlapping decorations with the same key but different values.
-   */
-  merge?: (leaf: Text$1, decoration: object) => void;
-};
-interface TextInterface {
-  /**
-   * Check if two text nodes are equal.
-   *
-   * When loose is set, the text is not compared. This is
-   * used to check whether sibling text nodes can be merged.
-   */
-  equals: (text: Text$1, another: Text$1, options?: TextEqualsOptions) => boolean;
-  /**
-   * Check if a value implements the `Text` interface.
-   */
-  isText: (value: any) => value is Text$1;
-  /**
-   * Check if a value is a list of `Text` objects.
-   */
-  isTextList: (value: any) => value is Text$1[];
-  /**
-   * Check if some props are a partial of Text.
-   */
-  isTextProps: (props: any) => props is Partial<Text$1>;
-  /**
-   * Check if an text matches set of properties.
-   *
-   * Note: this is for matching custom properties, and it does not ensure that
-   * the `text` property are two nodes equal.
-   */
-  matches: (text: Text$1, props: Partial<Text$1>) => boolean;
-  /**
-   * Get the leaves for a text node given decorations.
-   */
-  decorations: (node: Text$1, decorations: DecoratedRange$1[]) => {
-    leaf: Text$1;
-    position?: LeafPosition;
-  }[];
-}
-declare const Text$1: TextInterface;
-interface GeneralTransforms {
-  /**
-   * Transform the editor by an operation.
-   */
-  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;
+interface BaseEditor {
+  children: PortableTextBlock[];
+  readonly value: PortableTextBlock[];
+  selection: Selection$1;
+  operations: Operation[];
+  marks: EditorMarks | null;
+  dirtyPaths: Path$1[];
+  dirtyPathKeys: Set<string>;
+  flushing: boolean;
+  normalizing: boolean;
+  pathRefs: Set<PathRef>;
+  pointRefs: Set<PointRef>;
+  rangeRefs: Set<RangeRef>;
+  apply: (operation: Operation) => void;
+  normalizeNode: (entry: [Editor$1 | Node$1, Path$1], options?: {
+    operation?: Operation;
   }) => 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;
+  onChange: (options?: {
+    operation?: Operation;
   }) => void;
+  shouldNormalize: ({
+    iteration,
+    dirtyPaths,
+    operation
+  }: {
+    iteration: number;
+    initialDirtyPathsLength: number;
+    dirtyPaths: Path$1[];
+    operation?: Operation;
+  }) => boolean;
+  select: (target: Location) => void;
+  setSelection: (props: Partial<Range>) => void;
 }
-declare const NodeTransforms: NodeTransforms;
-interface SelectionCollapseOptions {
-  edge?: SelectionEdge;
-}
-interface SelectionMoveOptions {
-  distance?: number;
-  unit?: MoveUnit;
-  reverse?: boolean;
-  edge?: SelectionEdge;
-}
-interface SelectionTransforms {
-  /**
-   * Collapse the selection.
-   */
-  collapse: (editor: Editor$1, options?: SelectionCollapseOptions) => void;
-  /**
-   * Unset the selection.
-   */
-  deselect: (editor: Editor$1) => void;
-  /**
-   * Move the selection's point forward or backward.
-   */
-  move: (editor: Editor$1, options?: SelectionMoveOptions) => void;
-  /**
-   * Set the selection to a new value.
-   */
-  select: (editor: Editor$1, target: Location) => void;
-  /**
-   * Set new properties on the selection.
-   */
-  setSelection: (editor: Editor$1, props: Partial<Range>) => void;
-}
-declare const SelectionTransforms: SelectionTransforms;
-declare const Transforms: GeneralTransforms & NodeTransforms & SelectionTransforms & TextTransforms;
-/**
- * @public
- */
-type EditorSchema = Schema;
-type DecoratedRange = BaseRange & {
-  rangeDecoration: RangeDecoration;
-};
+type Editor$1 = BaseEditor & ReactEditor & PortableTextSlateEditor;
+type Selection$1 = Range | null;
+type EditorMarks = Omit<PortableTextSpan, 'text'>;
 type StringDiff = {
   start: number;
   end: number;
@@ -1496,17 +295,6 @@ declare global {
   }
 }
 type DOMPoint = [Node, number];
-/**
- * An auto-incrementing identifier for keys.
- */
-/**
- * A class that keeps track of a key string. We use a full class here because we
- * want to be able to use them as keys in `WeakMap` objects.
- */
-declare class Key {
-  id: string;
-  constructor();
-}
 type Action = {
   at?: Point | Range;
   run: () => void;
@@ -1519,23 +307,12 @@ interface DOMEditor extends BaseEditor {
   hasRange: (editor: Editor$1, range: Range) => boolean;
   hasSelectableTarget: (editor: Editor$1, target: EventTarget | null) => boolean;
   hasTarget: (editor: Editor$1, target: EventTarget | null) => target is DOMNode;
-  insertData: (data: DataTransfer) => void;
-  insertFragmentData: (data: DataTransfer) => boolean;
-  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;
@@ -1544,46 +321,22 @@ interface DOMEditor extends BaseEditor {
     operation?: Operation;
   }) => void) | null;
   scheduleFlush: (() => void) | null;
-  pendingInsertionMarks: Partial<Text$1> | null;
-  userMarks: Partial<Text$1> | null;
+  pendingInsertionMarks: EditorMarks | null;
+  userMarks: EditorMarks | null;
   pendingDiffs: TextDiff[];
   pendingAction: Action | null;
   pendingSelection: Range | null;
   forceRender: (() => void) | null;
 }
 interface DOMEditorInterface {
-  /**
-   * Experimental and android specific: Get pending diffs
-   */
-  androidPendingDiffs: (editor: Editor$1) => TextDiff[] | undefined;
-  /**
-   * Experimental and android specific: Flush all pending diffs and cancel composition at the next possible time.
-   */
-  androidScheduleFlush: (editor: Editor$1) => void;
   /**
    * Blur the editor.
    */
   blur: (editor: Editor$1) => void;
-  /**
-   * Deselect the editor.
-   */
-  deselect: (editor: Editor$1) => void;
   /**
    * Find the DOM node that implements DocumentOrShadowRoot for the editor.
    */
   findDocumentOrShadowRoot: (editor: Editor$1) => Document | ShadowRoot;
-  /**
-   * Get the target range from a DOM `event`.
-   */
-  findEventRange: (editor: Editor$1, event: any) => Range;
-  /**
-   * Find a key for a Slate node.
-   */
-  findKey: (editor: Editor$1, node: Node$1) => Key;
-  /**
-   * Find the path of Slate node.
-   */
-  findPath: (editor: Editor$1, node: Node$1) => Path$1;
   /**
    * Focus the editor.
    */
@@ -1616,18 +369,6 @@ interface DOMEditorInterface {
    * Check if the target is in the editor.
    */
   hasTarget: (editor: Editor$1, target: EventTarget | null) => target is DOMNode;
-  /**
-   * Insert data from a `DataTransfer` into the editor.
-   */
-  insertData: (editor: Editor$1, data: DataTransfer) => void;
-  /**
-   * Insert fragment data from a `DataTransfer` into the editor.
-   */
-  insertFragmentData: (editor: Editor$1, data: DataTransfer) => boolean;
-  /**
-   * Insert text data from a `DataTransfer` into the editor.
-   */
-  insertTextData: (editor: Editor$1, data: DataTransfer) => boolean;
   /**
    * Check if the user is currently composing inside the editor.
    */
@@ -1636,22 +377,10 @@ interface DOMEditorInterface {
    * Check if the editor is focused.
    */
   isFocused: (editor: Editor$1) => boolean;
-  /**
-   * Check if the editor is in read-only mode.
-   */
-  isReadOnly: (editor: Editor$1) => boolean;
   /**
    * Check if the target is inside void and in an non-readonly editor.
    */
   isTargetInsideNonReadonlyVoid: (editor: Editor$1, target: EventTarget | null) => boolean;
-  /**
-   * Sets data from the currently selected fragment on a `DataTransfer`.
-   */
-  setFragmentData: (editor: Editor$1, data: DataTransfer, originEvent?: 'drag' | 'copy' | 'cut') => void;
-  /**
-   * Find the native DOM element from a Slate node.
-   */
-  toDOMNode: (editor: Editor$1, node: Node$1) => HTMLElement;
   /**
    * Find a native DOM selection point from a Slate point.
    */
@@ -1665,10 +394,6 @@ interface DOMEditorInterface {
    * according to https://dom.spec.whatwg.org/#concept-range-bp-set.
    */
   toDOMRange: (editor: Editor$1, range: Range) => DOMRange;
-  /**
-   * Find a Slate node from a native DOM `element`.
-   */
-  toSlateNode: (editor: Editor$1, domNode: DOMNode) => Node$1;
   /**
    * Find a Slate point from a DOM selection's `domNode` and `domOffset`.
    */
@@ -1690,81 +415,17 @@ 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.
  */
-interface ReactEditor extends DOMEditor {
-  /**
-   * Determines the chunk size used by the children chunking optimization. If
-   * null is returned (which is the default), the chunking optimization is
-   * disabled.
-   */
-  getChunkSize: (node: Ancestor) => number | null;
-  keyToChunkTree: WeakMap<Key, ChunkTree>;
-}
+interface ReactEditor extends DOMEditor {}
 interface ReactEditorInterface extends DOMEditorInterface {}
 declare const ReactEditor: ReactEditorInterface;
-interface VoidElement {
-  _type: string;
-  _key: string;
-  children: Descendant[];
-  __inline: boolean;
-  value: Record<string, unknown>;
-}
-interface SlateTextBlock extends Omit<PortableTextTextBlock, 'children'> {
-  children: Descendant[];
-}
-declare module '../slate/index' {
-  interface CustomTypes {
-    Editor: BaseEditor & ReactEditor & PortableTextSlateEditor;
-    Element: SlateTextBlock | VoidElement;
-    Text: PortableTextSpan;
-  }
-}
-//# sourceMappingURL=slate.d.ts.map
 type HistoryItem = {
   operations: Operation[];
   timestamp: Date;
+  splitContext?: SplitContext | null;
+  mergeContext?: MergeContext | null;
 };
 interface History {
   redos: HistoryItem[];
@@ -1776,13 +437,75 @@ 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';
-  isTextBlock: (value: unknown) => value is PortableTextTextBlock;
-  isTextSpan: (value: unknown) => value is PortableTextSpan;
-  isListBlock: (value: unknown) => value is PortableTextListBlock;
+  schema: EditorSchema;
+  keyGenerator: () => string;
+  editableTypes: Set<string>;
   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;
@@ -1791,7 +514,41 @@ interface PortableTextSlateEditor extends ReactEditor {
   listIndexMap: Map<string, number>;
   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;
+  /**
+   * Accumulates decoration shift records between mutation flushes.
+   * Consumed and cleared by the mutation machine's `'emit mutations'`
+   * action so that `MutationEvent` includes `rangeDecorationShifts`.
+   */
+  pendingDecorationShifts: Array<RangeDecorationShift>;
+  /**
+   * When > 0, the decoration `sendBack` interceptor skips firing
+   * `slate operation` events. Used by `applyMergeNode` and `applySplitNode`
+   * to suppress events for their decomposed operations, which would
+   * otherwise double-transform or invalidate decoration ranges.
+   */
+  _suppressDecorationSendBack: number;
   isDeferringMutations: boolean;
   isNormalizingNode: boolean;
   isPatching: boolean;
@@ -1800,15 +557,13 @@ interface PortableTextSlateEditor extends ReactEditor {
   isRedoing: boolean;
   isUndoing: boolean;
   withHistory: boolean;
-  /**
-   * Undo
-   */
-  undo: () => void;
-  /**
-   * Redo
-   */
-  redo: () => void;
 }
+/**
+ * @public
+ */
+type RangeDecorationShift = Omit<RangeDecorationOnMovedDetails, 'rangeDecoration'> & {
+  rangeDecoration: RangeDecoration;
+};
 /**
  * @public
  */
@@ -1861,20 +616,17 @@ type MutationEvent = {
   type: 'mutation';
   patches: Array<Patch>;
   value: Array<PortableTextBlock> | undefined;
+  rangeDecorationShifts: Array<RangeDecorationShift>;
 };
 type PatchEvent = {
   type: 'patch';
   patch: Patch;
 };
-type SlateEditor = {
-  instance: PortableTextSlateEditor;
-  initialValue: Array<Descendant>;
-};
 type InternalEditor = Editor & {
   _internal: {
     editable: EditableAPI;
     editorActor: EditorActor;
-    slateEditor: SlateEditor;
+    slateEditor: PortableTextSlateEditor;
   };
 };
 /**
@@ -2316,7 +1068,7 @@ type PortableTextEditableProps = Omit<TextareaHTMLAttributes<HTMLDivElement>, 'o
  * ```
  * @group Components
  */
-declare const PortableTextEditable: react13.ForwardRefExoticComponent<Omit<PortableTextEditableProps, "ref"> & react13.RefAttributes<Omit<HTMLDivElement, "as" | "onPaste" | "onBeforeInput">>>;
+declare const PortableTextEditable: react4.ForwardRefExoticComponent<Omit<PortableTextEditableProps, "ref"> & react4.RefAttributes<Omit<HTMLDivElement, "as" | "onPaste" | "onBeforeInput">>>;
 /** @beta */
 interface EditableAPIDeleteOptions {
   mode?: 'blocks' | 'children' | 'selected';
@@ -2373,8 +1125,8 @@ interface EditableAPI {
   isCollapsedSelection: () => boolean;
   isExpandedSelection: () => boolean;
   isMarkActive: (mark: string) => boolean;
-  isSelectionsOverlapping: (selectionA: EditorSelection, selectionB: EditorSelection) => boolean;
   isVoid: (element: PortableTextBlock | PortableTextChild) => boolean;
+  isSelectionsOverlapping: (selectionA: EditorSelection, selectionB: EditorSelection) => boolean;
   marks: () => string[];
   redo: () => void;
   removeAnnotation: <TSchemaType extends {
@@ -2535,8 +1287,16 @@ type ScrollSelectionIntoViewFunction = (editor: PortableTextEditor, domRange: gl
  * @alpha */
 interface RangeDecorationOnMovedDetails {
   rangeDecoration: RangeDecoration;
+  previousSelection: EditorSelection;
   newSelection: EditorSelection;
   origin: 'remote' | 'local';
+  /**
+   * - `'moved'` — the range's boundary points shifted or the range was
+   *   invalidated.
+   * - `'contentChanged'` — the boundary points are unchanged but content
+   *   inside the range was modified.
+   */
+  reason: 'moved' | 'contentChanged';
 }
 /**
  * A range decoration is a UI affordance that wraps a given selection range in the editor
@@ -2563,9 +1323,17 @@ 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.
+   *
+   * For transactional handling of moves alongside content changes, use
+   * `rangeDecorationShifts` on the `'mutation'` event instead.
    */
   onMoved?: (details: RangeDecorationOnMovedDetails) => 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
    */
@@ -2952,7 +1720,7 @@ declare const editorMachine: xstate73.StateMachine<{
   initialValue?: Array<PortableTextBlock>;
 }, xstate73.NonReducibleUnknown, InternalPatchEvent | MutationEvent | PatchesEvent | {
   type: "blurred";
-  event: react13.FocusEvent<HTMLDivElement, Element>;
+  event: react4.FocusEvent<HTMLDivElement, Element>;
 } | {
   type: "done loading";
 } | {
@@ -2964,7 +1732,7 @@ declare const editorMachine: xstate73.StateMachine<{
   data: unknown;
 } | {
   type: "focused";
-  event: react13.FocusEvent<HTMLDivElement, Element>;
+  event: react4.FocusEvent<HTMLDivElement, Element>;
 } | {
   type: "invalid value";
   resolution: InvalidValueResolution | null;
@@ -3487,6 +2255,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;
 };
 /**
@@ -3630,5 +2407,5 @@ type BehaviorActionSet<TBehaviorEvent, TGuardResponse> = (payload: {
   event: TBehaviorEvent;
   dom: EditorDom;
 }, guardResponse: TGuardResponse) => Array<BehaviorAction>;
-export { BlockAnnotationRenderProps as $, PortableTextTextBlock$1 as A, MutationEvent as At, EditorSelector as B, ListDefinition as C, RenderStyleFunction as Ct, PortableTextChild$1 as D, HotkeyOptions as Dt, PortableTextBlock$1 as E, PortableTextEditableProps as Et, BlockOffset as F, KeyedSegment as Ft, EditorConfig as G, EditorProvider as H, useEditor as I, Path as It, defineBehavior as J, EditorEvent as K, defaultKeyGenerator as L, StyleDefinition as M, AnnotationPath as Mt, StyleSchemaType$1 as N, BlockPath as Nt, PortableTextObject$1 as O, PortableTextEditor as Ot, defineSchema as P, ChildPath as Pt, AddedAnnotationPaths as Q, usePortableTextEditorSelection as R, InlineObjectSchemaType$1 as S, RenderPlaceholderFunction as St, Patch$1 as T, PortableTextEditable as Tt, EditorProviderProps as U, useEditorSelector as V, Editor as W, EditorContext as X, BehaviorGuard as Y, EditorSnapshot as Z, BlockObjectSchemaType$1 as _, RenderBlockFunction as _t, forward as a, EditableAPIDeleteOptions as at, FieldDefinition as b, RenderEditableFunction as bt, CustomBehaviorEvent as c, InvalidValueResolution as ct, SyntheticBehaviorEvent as d, OnPasteResult as dt, BlockChildRenderProps as et, PatchesEvent as f, OnPasteResultOrPromise as ft, BlockObjectDefinition as g, RenderAnnotationFunction as gt, BaseDefinition as h, RangeDecorationOnMovedDetails as ht, execute as i, BlockStyleRenderProps as it, SchemaDefinition$1 as j, EditorSchema as jt, PortableTextSpan$1 as k, EditorEmittedEvent as kt, InsertPlacement as l, OnCopyFn as lt, AnnotationSchemaType$1 as m, RangeDecoration as mt, BehaviorActionSet as n, BlockListItemRenderProps as nt, raise as o, EditorSelection as ot, AnnotationDefinition as p, PasteData as pt, Behavior as q, effect as r, BlockRenderProps as rt, BehaviorEvent as s, EditorSelectionPoint as st, BehaviorAction as t, BlockDecoratorRenderProps as tt, NativeBehaviorEvent as u, OnPasteFn as ut, DecoratorDefinition as v, RenderChildFunction as vt, ListSchemaType$1 as w, ScrollSelectionIntoViewFunction as wt, InlineObjectDefinition as x, RenderListItemFunction as xt, DecoratorSchemaType$1 as y, RenderDecoratorFunction as yt, usePortableTextEditor as z };
+export { BlockAnnotationRenderProps as $, PortableTextTextBlock$1 as A, MutationEvent as At, EditorSelector as B, ListDefinition as C, RenderStyleFunction as Ct, PortableTextChild$1 as D, HotkeyOptions as Dt, PortableTextBlock$1 as E, PortableTextEditableProps as Et, BlockOffset as F, ChildPath as Ft, EditorConfig as G, EditorProvider as H, useEditor as I, KeyedSegment as It, defineBehavior as J, EditorEvent as K, defaultKeyGenerator as L, Path as Lt, StyleDefinition as M, EditorSchema as Mt, StyleSchemaType$1 as N, AnnotationPath as Nt, PortableTextObject$1 as O, PortableTextEditor as Ot, defineSchema as P, BlockPath as Pt, AddedAnnotationPaths as Q, usePortableTextEditorSelection as R, InlineObjectSchemaType$1 as S, RenderPlaceholderFunction as St, Patch$1 as T, PortableTextEditable as Tt, EditorProviderProps as U, useEditorSelector as V, Editor as W, EditorContext as X, BehaviorGuard as Y, EditorSnapshot as Z, BlockObjectSchemaType$1 as _, RenderBlockFunction as _t, forward as a, EditableAPIDeleteOptions as at, FieldDefinition as b, RenderEditableFunction as bt, CustomBehaviorEvent as c, InvalidValueResolution as ct, SyntheticBehaviorEvent as d, OnPasteResult as dt, BlockChildRenderProps as et, PatchesEvent as f, OnPasteResultOrPromise as ft, BlockObjectDefinition as g, RenderAnnotationFunction as gt, BaseDefinition as h, RangeDecorationOnMovedDetails as ht, execute as i, BlockStyleRenderProps as it, SchemaDefinition$1 as j, RangeDecorationShift as jt, PortableTextSpan$1 as k, EditorEmittedEvent as kt, InsertPlacement as l, OnCopyFn as lt, AnnotationSchemaType$1 as m, RangeDecoration as mt, BehaviorActionSet as n, BlockListItemRenderProps as nt, raise as o, EditorSelection as ot, AnnotationDefinition as p, PasteData as pt, Behavior as q, effect as r, BlockRenderProps as rt, BehaviorEvent as s, EditorSelectionPoint as st, BehaviorAction as t, BlockDecoratorRenderProps as tt, NativeBehaviorEvent as u, OnPasteFn as ut, DecoratorDefinition as v, RenderChildFunction as vt, ListSchemaType$1 as w, ScrollSelectionIntoViewFunction as wt, InlineObjectDefinition as x, RenderListItemFunction as xt, DecoratorSchemaType$1 as y, RenderDecoratorFunction as yt, usePortableTextEditor as z };
 //# sourceMappingURL=behavior.types.action.d.ts.map