@portabletext/editor 3.3.0 → 3.3.2

package/lib/_chunks-dts/index.d.ts

@@ -1,17 +1,1461 @@
+/// <reference types="react" />
 import * as _sanity_types4 from "@sanity/types";
 import { ArrayDefinition, ArraySchemaType, BlockDecoratorDefinition, BlockListDefinition, BlockStyleDefinition, ObjectSchemaType, Path, PortableTextBlock, PortableTextBlock as PortableTextBlock$1, PortableTextChild, PortableTextChild as PortableTextChild$1, PortableTextListBlock, PortableTextObject, PortableTextObject as PortableTextObject$2, PortableTextSpan, PortableTextSpan as PortableTextSpan$2, PortableTextTextBlock, PortableTextTextBlock as PortableTextTextBlock$2, TypedObject } from "@sanity/types";
-import { BaseRange, Descendant, Operation } from "slate";
 import * as xstate228 from "xstate";
 import { ActorRef, ActorRefFrom, EventObject, Snapshot } from "xstate";
-import * as react18 from "react";
-import React$1, { BaseSyntheticEvent, ClipboardEvent, Component, FocusEvent, JSX, KeyboardEvent as KeyboardEvent$1, MutableRefObject, PropsWithChildren, ReactElement, RefObject, TextareaHTMLAttributes } from "react";
+import * as react24 from "react";
+import React$1, { BaseSyntheticEvent, ClipboardEvent as ClipboardEvent$1, Component, FocusEvent, JSX as JSX$1, KeyboardEvent as KeyboardEvent$1, MutableRefObject, PropsWithChildren, ReactElement, RefObject, TextareaHTMLAttributes } from "react";
 import { Patch, Patch as Patch$1 } from "@portabletext/patches";
 import * as _portabletext_schema5 from "@portabletext/schema";
 import { AnnotationDefinition, AnnotationSchemaType, BaseDefinition, BlockObjectDefinition, BlockObjectSchemaType, DecoratorDefinition, DecoratorSchemaType, FieldDefinition, InlineObjectDefinition, InlineObjectSchemaType, ListDefinition, ListSchemaType, PortableTextObject as PortableTextObject$1, PortableTextSpan as PortableTextSpan$1, PortableTextTextBlock as PortableTextTextBlock$1, Schema, SchemaDefinition, SchemaDefinition as SchemaDefinition$1, StyleDefinition, StyleSchemaType, defineSchema } from "@portabletext/schema";
 import { Observable, Subject } from "rxjs";
-import { DOMNode } from "slate-dom";
-import { ReactEditor } from "slate-react";
 import * as xstate_guards12 from "xstate/guards";
+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';
+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;
+interface NodeInsertNodesOptions<T$1 extends Node$1> {
+  at?: Location;
+  match?: NodeMatch<T$1>;
+  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$1 extends Node$1>(editor: Editor$1, nodes: Node$1 | Node$1[], options?: NodeInsertNodesOptions<T$1>) => void;
+  /**
+   * Lift nodes at a specific location upwards in the document tree, splitting
+   * their parent in two if necessary.
+   */
+  liftNodes: <T$1 extends Node$1>(editor: Editor$1, options?: {
+    at?: Location;
+    match?: NodeMatch<T$1>;
+    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$1 extends Node$1>(editor: Editor$1, options?: {
+    at?: Location;
+    match?: NodeMatch<T$1>;
+    mode?: RangeMode;
+    hanging?: boolean;
+    voids?: boolean;
+  }) => void;
+  /**
+   * Move the nodes at a location to a new location.
+   */
+  moveNodes: <T$1 extends Node$1>(editor: Editor$1, options: {
+    at?: Location;
+    match?: NodeMatch<T$1>;
+    mode?: MaximizeMode;
+    to: Path$1;
+    voids?: boolean;
+  }) => void;
+  /**
+   * Remove the nodes at a specific location in the document.
+   */
+  removeNodes: <T$1 extends Node$1>(editor: Editor$1, options?: {
+    at?: Location;
+    match?: NodeMatch<T$1>;
+    mode?: RangeMode;
+    hanging?: boolean;
+    voids?: boolean;
+  }) => void;
+  /**
+   * Set new properties on the nodes at a location.
+   */
+  setNodes: <T$1 extends Node$1>(editor: Editor$1, props: Partial<T$1>, options?: {
+    at?: Location;
+    match?: NodeMatch<T$1>;
+    mode?: MaximizeMode;
+    hanging?: boolean;
+    split?: boolean;
+    voids?: boolean;
+    compare?: PropsCompare;
+    merge?: PropsMerge;
+  }) => void;
+  /**
+   * Split the nodes at a specific location.
+   */
+  splitNodes: <T$1 extends Node$1>(editor: Editor$1, options?: {
+    at?: Location;
+    match?: NodeMatch<T$1>;
+    mode?: RangeMode;
+    always?: boolean;
+    height?: number;
+    voids?: boolean;
+  }) => void;
+  /**
+   * Unset properties on the nodes at a location.
+   */
+  unsetNodes: <T$1 extends Node$1>(editor: Editor$1, props: string | string[], options?: {
+    at?: Location;
+    match?: NodeMatch<T$1>;
+    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$1 extends Node$1>(editor: Editor$1, options?: {
+    at?: Location;
+    match?: NodeMatch<T$1>;
+    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$1 extends Node$1>(editor: Editor$1, element: Element$1, options?: {
+    at?: Location;
+    match?: NodeMatch<T$1>;
+    mode?: MaximizeMode;
+    split?: boolean;
+    voids?: boolean;
+  }) => void;
+}
+declare const NodeTransforms: NodeTransforms;
+/**
+ * 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;
+  apply: (operation: Operation) => void;
+  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;
+  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$1 extends Node$1>(props: Partial<T$1>, options?: {
+    at?: Location;
+    match?: NodeMatch<T$1>;
+    mode?: MaximizeMode;
+    hanging?: boolean;
+    split?: boolean;
+    voids?: boolean;
+    compare?: PropsCompare;
+    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>;
+  unwrapNodes: OmitFirstArg<typeof Transforms.unwrapNodes>;
+  withoutNormalizing: OmitFirstArg<typeof Editor$1.withoutNormalizing>;
+  wrapNodes: OmitFirstArg<typeof Transforms.wrapNodes>;
+  above: <T$1 extends Ancestor>(options?: EditorAboveOptions<T$1>) => NodeEntry<T$1> | 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$1 extends Node$1>(options?: EditorLevelsOptions<T$1>) => Generator<NodeEntry<T$1>, void, undefined>;
+  next: <T$1 extends Descendant>(options?: EditorNextOptions<T$1>) => NodeEntry<T$1> | undefined;
+  node: OmitFirstArg<typeof Editor$1.node>;
+  nodes: <T$1 extends Node$1>(options?: EditorNodesOptions<T$1>) => Generator<NodeEntry<T$1>, void, undefined>;
+  parent: OmitFirstArg<typeof Editor$1.parent>;
+  path: OmitFirstArg<typeof Editor$1.path>;
+  pathRef: OmitFirstArg<typeof Editor$1.pathRef>;
+  pathRefs: OmitFirstArg<typeof Editor$1.pathRefs>;
+  point: OmitFirstArg<typeof Editor$1.point>;
+  pointRef: OmitFirstArg<typeof Editor$1.pointRef>;
+  pointRefs: OmitFirstArg<typeof Editor$1.pointRefs>;
+  positions: OmitFirstArg<typeof Editor$1.positions>;
+  previous: <T$1 extends Node$1>(options?: EditorPreviousOptions<T$1>) => NodeEntry<T$1> | undefined;
+  range: OmitFirstArg<typeof Editor$1.range>;
+  rangeRef: OmitFirstArg<typeof Editor$1.rangeRef>;
+  rangeRefs: OmitFirstArg<typeof Editor$1.rangeRefs>;
+  start: OmitFirstArg<typeof Editor$1.start>;
+  string: OmitFirstArg<typeof Editor$1.string>;
+  unhangRange: OmitFirstArg<typeof Editor$1.unhangRange>;
+  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, 'text'>;
+interface EditorAboveOptions<T$1 extends Ancestor> {
+  at?: Location;
+  match?: NodeMatch<T$1>;
+  mode?: MaximizeMode;
+  voids?: boolean;
+}
+interface EditorAfterOptions {
+  distance?: number;
+  unit?: TextUnitAdjustment;
+  voids?: boolean;
+}
+interface EditorBeforeOptions {
+  distance?: number;
+  unit?: TextUnitAdjustment;
+  voids?: boolean;
+}
+interface EditorDirectedDeletionOptions {
+  unit?: TextUnit;
+}
+interface EditorElementReadOnlyOptions {
+  at?: Location;
+  mode?: MaximizeMode;
+  voids?: boolean;
+}
+interface EditorFragmentDeletionOptions {
+  direction?: TextDirection;
+}
+interface EditorIsEditorOptions {
+  deep?: boolean;
+}
+interface EditorLeafOptions {
+  depth?: number;
+  edge?: LeafEdge;
+}
+interface EditorLevelsOptions<T$1 extends Node$1> {
+  at?: Location;
+  match?: NodeMatch<T$1>;
+  reverse?: boolean;
+  voids?: boolean;
+}
+interface EditorNextOptions<T$1 extends Descendant> {
+  at?: Location;
+  match?: NodeMatch<T$1>;
+  mode?: SelectionMode;
+  voids?: boolean;
+}
+interface EditorNodeOptions {
+  depth?: number;
+  edge?: LeafEdge;
+}
+interface EditorNodesOptions<T$1 extends Node$1> {
+  at?: Location | Span;
+  match?: NodeMatch<T$1>;
+  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$1 extends Node$1> {
+  at?: Location;
+  match?: NodeMatch<T$1>;
+  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$1 extends Ancestor>(editor: Editor$1, options?: EditorAboveOptions<T$1>) => NodeEntry<T$1> | 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.
+   */
+  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;
+  /**
+   * 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.
+   */
+  elementReadOnly: (editor: Editor$1, options?: EditorElementReadOnlyOptions) => NodeEntry<Element$1> | undefined;
+  /**
+   * 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.
+   *
+   * 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;
+  /**
+   * 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$1 extends Node$1>(editor: Editor$1, node: Node$1, options?: NodeInsertNodesOptions<T$1>) => 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.
+   */
+  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 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.
+   */
+  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 last node at a location.
+   */
+  last: (editor: Editor$1, at: Location) => NodeEntry;
+  /**
+   * Get the leaf text node at a location.
+   */
+  leaf: (editor: Editor$1, at: Location, options?: EditorLeafOptions) => NodeEntry<Text>;
+  /**
+   * Iterate through all of the levels at a location.
+   */
+  levels: <T$1 extends Node$1>(editor: Editor$1, options?: EditorLevelsOptions<T$1>) => Generator<NodeEntry<T$1>, void, undefined>;
+  /**
+   * Get the marks that would be added to text at the current selection.
+   */
+  marks: (editor: Editor$1) => Omit<Text, 'text'> | null;
+  /**
+   * Get the matching node in the branch of the document after a location.
+   */
+  next: <T$1 extends Descendant>(editor: Editor$1, options?: EditorNextOptions<T$1>) => NodeEntry<T$1> | 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$1 extends Node$1>(editor: Editor$1, options?: EditorNodesOptions<T$1>) => Generator<NodeEntry<T$1>, 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$1 extends Node$1>(editor: Editor$1, options?: EditorPreviousOptions<T$1>) => NodeEntry<T$1> | 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>;
+  /**
+   * 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.
+   *
+   * 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$1 extends Node$1> = ((node: Node$1, path: Path$1) => node is T$1) | ((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;
+type OmitFirstArg<F> = F extends ((x: any, ...args: infer P) => infer R) ? (...args: P) => R : never;
+/**
+ * `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.
+ */
+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$1 extends Element$1>(value: any, elementVal: string, elementKey?: string) => value is T$1;
+  /**
+   * 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;
+/**
+ * `ElementEntry` objects refer to an `Element` and the `Path` where it can be
+ * found inside a root node.
+ */
+type ElementEntry = [Element$1, Path$1];
+/**
+ * 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 Location = Path$1 | Point | Range;
+interface LocationInterface {
+  /**
+   * Check if a value implements the `Location` interface.
+   */
+  isLocation: (value: any) => value is Location;
+}
+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.
+ */
+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;
+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$1 extends Ancestor = Editor$1>(root: T$1, range: Range) => T$1['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;
+  /**
+   * 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>, void, undefined>;
+}
+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;
+/**
+ * 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$1 extends Node$1 = Node$1> = [T$1, Path$1];
+/**
+ * Convenience type for returning the props of a node.
+ */
+type NodeProps = Omit<Editor$1, 'children'> | Omit<Element$1, 'children'> | Omit<Text, 'text'>;
+type BaseInsertNodeOperation = {
+  type: 'insert_node';
+  path: Path$1;
+  node: Node$1;
+};
+type InsertNodeOperation = ExtendedType<'InsertNodeOperation', BaseInsertNodeOperation>;
+type BaseInsertTextOperation = {
+  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: 'remove_node';
+  path: Path$1;
+  node: Node$1;
+};
+type RemoveNodeOperation = ExtendedType<'RemoveNodeOperation', BaseRemoveNodeOperation>;
+type BaseRemoveTextOperation = {
+  type: 'remove_text';
+  path: Path$1;
+  offset: number;
+  text: string;
+};
+type RemoveTextOperation = ExtendedType<'RemoveTextOperation', BaseRemoveTextOperation>;
+type BaseSetNodeOperation = {
+  type: 'set_node';
+  path: Path$1;
+  properties: Partial<Node$1>;
+  newProperties: Partial<Node$1>;
+};
+type SetNodeOperation = ExtendedType<'SetNodeOperation', BaseSetNodeOperation>;
+type BaseSetSelectionOperation = {
+  type: 'set_selection';
+  properties: null;
+  newProperties: Range;
+} | {
+  type: 'set_selection';
+  properties: Partial<Range>;
+  newProperties: Partial<Range>;
+} | {
+  type: 'set_selection';
+  properties: Range;
+  newProperties: null;
+};
+type SetSelectionOperation = ExtendedType<'SetSelectionOperation', BaseSetSelectionOperation>;
+type BaseSplitNodeOperation = {
+  type: 'split_node';
+  path: Path$1;
+  position: number;
+  properties: Partial<Node$1>;
+};
+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.
+ */
+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;
+/**
+ * `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
+ * at any time for the up-to-date path value.
+ */
+interface PathRef {
+  current: Path$1 | null;
+  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;
+}
+declare const Point: PointInterface;
+/**
+ * `PointEntry` objects are returned when iterating over `Point` objects that
+ * belong to a range.
+ */
+type PointEntry = [Point, 'anchor' | 'focus'];
+/**
+ * `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
+ * at any time for the up-to-date range value.
+ */
+interface RangeRef {
+  current: Range | null;
+  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.
+ */
+interface BaseText {
+  text: string;
+}
+type Text = 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, 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, another: Text, options?: TextEqualsOptions) => boolean;
+  /**
+   * Check if a value implements the `Text` interface.
+   */
+  isText: (value: any) => value is Text;
+  /**
+   * Check if a value is a list of `Text` objects.
+   */
+  isTextList: (value: any) => value is Text[];
+  /**
+   * Check if some props are a partial of Text.
+   */
+  isTextProps: (props: any) => props is Partial<Text>;
+  /**
+   * 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, props: Partial<Text>) => boolean;
+  /**
+   * Get the leaves for a text node given decorations.
+   */
+  decorations: (node: Text, decorations: DecoratedRange$1[]) => {
+    leaf: Text;
+    position?: LeafPosition;
+  }[];
+}
+declare const Text: TextInterface;
+interface GeneralTransforms {
+  /**
+   * Transform the editor by an operation.
+   */
+  transform: (editor: Editor$1, op: Operation) => void;
+}
+declare const GeneralTransforms: GeneralTransforms;
+interface SelectionCollapseOptions {
+  edge?: SelectionEdge;
+}
+interface SelectionMoveOptions {
+  distance?: number;
+  unit?: MoveUnit;
+  reverse?: boolean;
+  edge?: SelectionEdge;
+}
+interface SelectionSetPointOptions {
+  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 one of the selection's points.
+   */
+  setPoint: (editor: Editor$1, props: Partial<Point>, options?: SelectionSetPointOptions) => 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;
 type MIMEType = `${string}/${string}`;
 /**
  * @internal
@@ -65,6 +1509,242 @@ type Deserializer<TMIMEType extends MIMEType> = ({
   snapshot: EditorSnapshot;
   event: PickFromUnion<ConverterEvent<TMIMEType>, 'type', 'deserialize'>;
 }) => PickFromUnion<ConverterEvent<TMIMEType>, 'type', 'deserialization.success' | 'deserialization.failure'>;
+type StringDiff = {
+  start: number;
+  end: number;
+  text: string;
+};
+type TextDiff = {
+  id: number;
+  path: Path$1;
+  diff: StringDiff;
+};
+declare global {
+  interface Window {
+    Selection: (typeof Selection)['constructor'];
+    DataTransfer: (typeof DataTransfer)['constructor'];
+    Node: (typeof Node)['constructor'];
+  }
+}
+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();
+}
+/**
+ * A DOM-specific version of the `Editor` interface.
+ */
+interface DOMEditor extends BaseEditor {
+  hasEditableTarget: (editor: DOMEditor, target: EventTarget | null) => target is DOMNode;
+  hasRange: (editor: DOMEditor, range: Range) => boolean;
+  hasSelectableTarget: (editor: DOMEditor, target: EventTarget | null) => boolean;
+  hasTarget: (editor: DOMEditor, target: EventTarget | null) => target is DOMNode;
+  insertData: (data: DataTransfer) => void;
+  insertFragmentData: (data: DataTransfer) => boolean;
+  insertTextData: (data: DataTransfer) => boolean;
+  isTargetInsideNonReadonlyVoid: (editor: DOMEditor, target: EventTarget | null) => boolean;
+  setFragmentData: (data: DataTransfer, originEvent?: 'drag' | 'copy' | 'cut') => void;
+}
+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: DOMEditor) => void;
+  /**
+   * Deselect the editor.
+   */
+  deselect: (editor: DOMEditor) => void;
+  /**
+   * Find the DOM node that implements DocumentOrShadowRoot for the editor.
+   */
+  findDocumentOrShadowRoot: (editor: DOMEditor) => Document | ShadowRoot;
+  /**
+   * Get the target range from a DOM `event`.
+   */
+  findEventRange: (editor: DOMEditor, event: any) => Range;
+  /**
+   * Find a key for a Slate node.
+   */
+  findKey: (editor: DOMEditor, node: Node$1) => Key;
+  /**
+   * Find the path of Slate node.
+   */
+  findPath: (editor: DOMEditor, node: Node$1) => Path$1;
+  /**
+   * Focus the editor.
+   */
+  focus: (editor: DOMEditor, options?: {
+    retries: number;
+  }) => void;
+  /**
+   * Return the host window of the current editor.
+   */
+  getWindow: (editor: DOMEditor) => Window;
+  /**
+   * Check if a DOM node is within the editor.
+   */
+  hasDOMNode: (editor: DOMEditor, target: DOMNode, options?: {
+    editable?: boolean;
+  }) => boolean;
+  /**
+   * Check if the target is editable and in the editor.
+   */
+  hasEditableTarget: (editor: DOMEditor, target: EventTarget | null) => target is DOMNode;
+  /**
+   *
+   */
+  hasRange: (editor: DOMEditor, range: Range) => boolean;
+  /**
+   * Check if the target can be selectable
+   */
+  hasSelectableTarget: (editor: DOMEditor, target: EventTarget | null) => boolean;
+  /**
+   * Check if the target is in the editor.
+   */
+  hasTarget: (editor: DOMEditor, target: EventTarget | null) => target is DOMNode;
+  /**
+   * Insert data from a `DataTransfer` into the editor.
+   */
+  insertData: (editor: DOMEditor, data: DataTransfer) => void;
+  /**
+   * Insert fragment data from a `DataTransfer` into the editor.
+   */
+  insertFragmentData: (editor: DOMEditor, data: DataTransfer) => boolean;
+  /**
+   * Insert text data from a `DataTransfer` into the editor.
+   */
+  insertTextData: (editor: DOMEditor, data: DataTransfer) => boolean;
+  /**
+   * Check if the user is currently composing inside the editor.
+   */
+  isComposing: (editor: DOMEditor) => boolean;
+  /**
+   * Check if the editor is focused.
+   */
+  isFocused: (editor: DOMEditor) => boolean;
+  /**
+   * Check if the editor is in read-only mode.
+   */
+  isReadOnly: (editor: DOMEditor) => boolean;
+  /**
+   * Check if the target is inside void and in an non-readonly editor.
+   */
+  isTargetInsideNonReadonlyVoid: (editor: DOMEditor, target: EventTarget | null) => boolean;
+  /**
+   * Sets data from the currently selected fragment on a `DataTransfer`.
+   */
+  setFragmentData: (editor: DOMEditor, data: DataTransfer, originEvent?: 'drag' | 'copy' | 'cut') => void;
+  /**
+   * Find the native DOM element from a Slate node.
+   */
+  toDOMNode: (editor: DOMEditor, node: Node$1) => HTMLElement;
+  /**
+   * Find a native DOM selection point from a Slate point.
+   */
+  toDOMPoint: (editor: DOMEditor, point: Point) => DOMPoint;
+  /**
+   * Find a native DOM range from a Slate `range`.
+   *
+   * Notice: the returned range will always be ordinal regardless of the direction of Slate `range` due to DOM API limit.
+   *
+   * there is no way to create a reverse DOM Range using Range.setStart/setEnd
+   * according to https://dom.spec.whatwg.org/#concept-range-bp-set.
+   */
+  toDOMRange: (editor: DOMEditor, range: Range) => DOMRange;
+  /**
+   * Find a Slate node from a native DOM `element`.
+   */
+  toSlateNode: (editor: DOMEditor, domNode: DOMNode) => Node$1;
+  /**
+   * Find a Slate point from a DOM selection's `domNode` and `domOffset`.
+   */
+  toSlatePoint: <T$1 extends boolean>(editor: DOMEditor, domPoint: DOMPoint, options: {
+    exactMatch: boolean;
+    suppressThrow: T$1;
+    /**
+     * The direction to search for Slate leaf nodes if `domPoint` is
+     * non-editable and non-void.
+     */
+    searchDirection?: 'forward' | 'backward';
+  }) => T$1 extends true ? Point | null : Point;
+  /**
+   * Find a Slate range from a DOM range or selection.
+   */
+  toSlateRange: <T$1 extends boolean>(editor: DOMEditor, domRange: DOMRange | DOMStaticRange | DOMSelection, options: {
+    exactMatch: boolean;
+    suppressThrow: T$1;
+  }) => T$1 extends true ? Range | null : Range;
+}
+declare const DOMEditor: DOMEditorInterface;
+/**
+ * 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;
+}
+interface ReactEditorInterface extends DOMEditorInterface {}
+declare const ReactEditor: ReactEditorInterface;
+/**
+ * @public
+ */
+type EditorSchema = Schema;
+type DecoratedRange = BaseRange & {
+  rangeDecoration: RangeDecoration;
+};
+type HistoryItem = {
+  operations: Operation[];
+  timestamp: Date;
+};
+interface History {
+  redos: HistoryItem[];
+  undos: HistoryItem[];
+}
+interface PortableTextSlateEditor extends ReactEditor {
+  _key: 'editor';
+  _type: 'editor';
+  createPlaceholderBlock: () => Descendant;
+  history: History;
+  isTextBlock: (value: unknown) => value is PortableTextTextBlock;
+  isTextSpan: (value: unknown) => value is PortableTextSpan;
+  isListBlock: (value: unknown) => value is PortableTextListBlock;
+  value: Array<PortableTextBlock>;
+  decoratedRanges: Array<DecoratedRange>;
+  decoratorState: Record<string, boolean | undefined>;
+  blockIndexMap: Map<string, number>;
+  listIndexMap: Map<string, number>;
+  /**
+   * Use hotkeys
+   */
+  pteWithHotKeys: (event: KeyboardEvent$1<HTMLDivElement>) => void;
+  /**
+   * Undo
+   */
+  undo: () => void;
+  /**
+   * Redo
+   */
+  redo: () => void;
+}
 /**
  * @public
  */
@@ -126,10 +1806,6 @@ type SlateEditor = {
   instance: PortableTextSlateEditor;
   initialValue: Array<Descendant>;
 };
-/**
- * @public
- */
-type EditorSchema = Schema;
 type InternalEditor = Editor & {
   _internal: {
     editable: EditableAPI;
@@ -211,7 +1887,7 @@ declare class PortableTextEditor extends Component<PortableTextEditorProps<Inter
   componentDidUpdate(prevProps: PortableTextEditorProps): void;
   componentWillUnmount(): void;
   setEditable: (editable: EditableAPI) => void;
-  render(): react18.JSX.Element;
+  render(): react24.JSX.Element;
   /**
    * @deprecated
    * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
@@ -620,10 +2296,7 @@ type PortableTextEditableProps = Omit<TextareaHTMLAttributes<HTMLDivElement>, 'o
  * ```
  * @group Components
  */
-declare const PortableTextEditable: react18.ForwardRefExoticComponent<Omit<PortableTextEditableProps, "ref"> & react18.RefAttributes<Omit<HTMLDivElement, "as" | "onPaste" | "onBeforeInput">>>;
-type DecoratedRange = BaseRange & {
-  rangeDecoration: RangeDecoration;
-};
+declare const PortableTextEditable: react24.ForwardRefExoticComponent<Omit<PortableTextEditableProps, "ref"> & react24.RefAttributes<Omit<HTMLDivElement, "as" | "onPaste" | "onBeforeInput">>>;
 /**
  * @public
  */
@@ -679,7 +2352,7 @@ interface EditableAPI {
   blur: () => void;
   delete: (selection: EditorSelection, options?: EditableAPIDeleteOptions) => void;
   findByPath: (path: Path) => [PortableTextBlock | PortableTextChild | undefined, Path | undefined];
-  findDOMNode: (element: PortableTextBlock | PortableTextChild) => DOMNode | undefined;
+  findDOMNode: (element: PortableTextBlock | PortableTextChild) => Node | undefined;
   focus: () => void;
   focusBlock: () => PortableTextBlock | undefined;
   focusChild: () => PortableTextChild | undefined;
@@ -715,14 +2388,6 @@ interface EditableAPI {
   toggleMark: (mark: string) => void;
   undo: () => void;
 }
-type HistoryItem = {
-  operations: Operation[];
-  timestamp: Date;
-};
-interface History {
-  redos: HistoryItem[];
-  undos: HistoryItem[];
-}
 /** @public */
 type EditorSelectionPoint = {
   path: Path;
@@ -734,35 +2399,6 @@ type EditorSelection = {
   focus: EditorSelectionPoint;
   backward?: boolean;
 } | null;
-interface PortableTextSlateEditor extends ReactEditor {
-  _key: 'editor';
-  _type: 'editor';
-  createPlaceholderBlock: () => Descendant;
-  editable: EditableAPI;
-  history: History;
-  insertPortableTextData: (data: DataTransfer) => boolean;
-  insertTextOrHTMLData: (data: DataTransfer) => boolean;
-  isTextBlock: (value: unknown) => value is PortableTextTextBlock;
-  isTextSpan: (value: unknown) => value is PortableTextSpan;
-  isListBlock: (value: unknown) => value is PortableTextListBlock;
-  value: Array<PortableTextBlock>;
-  decoratedRanges: Array<DecoratedRange>;
-  decoratorState: Record<string, boolean | undefined>;
-  blockIndexMap: Map<string, number>;
-  listIndexMap: Map<string, number>;
-  /**
-   * Use hotkeys
-   */
-  pteWithHotKeys: (event: KeyboardEvent$1<HTMLDivElement>) => void;
-  /**
-   * Undo
-   */
-  undo: () => void;
-  /**
-   * Redo
-   */
-  redo: () => void;
-}
 /**
  * The editor has mutated it's content.
  * @beta */
@@ -921,7 +2557,7 @@ type OnPasteResult = {
 type OnPasteResultOrPromise = OnPasteResult | Promise<OnPasteResult>;
 /** @beta */
 interface PasteData {
-  event: ClipboardEvent;
+  event: ClipboardEvent$1;
   path: Path;
   schemaTypes: PortableTextMemberSchemaTypes;
   value: PortableTextBlock[] | undefined;
@@ -936,7 +2572,7 @@ type OnPasteFn = (data: PasteData) => OnPasteResultOrPromise;
 /** @beta */
 type OnBeforeInputFn = (event: InputEvent) => void;
 /** @beta */
-type OnCopyFn = (event: ClipboardEvent<HTMLDivElement | HTMLSpanElement>) => undefined | unknown;
+type OnCopyFn = (event: ClipboardEvent$1<HTMLDivElement | HTMLSpanElement>) => undefined | unknown;
 /** @beta */
 type PatchObservable = Observable<{
   patches: Patch[];
@@ -1008,17 +2644,17 @@ interface BlockListItemRenderProps {
   value: string;
 }
 /** @beta */
-type RenderBlockFunction = (props: BlockRenderProps) => JSX.Element;
+type RenderBlockFunction = (props: BlockRenderProps) => JSX$1.Element;
 /** @beta */
-type RenderChildFunction = (props: BlockChildRenderProps) => JSX.Element;
+type RenderChildFunction = (props: BlockChildRenderProps) => JSX$1.Element;
 /** @beta */
-type RenderEditableFunction = (props: PortableTextEditableProps) => JSX.Element;
+type RenderEditableFunction = (props: PortableTextEditableProps) => JSX$1.Element;
 /** @beta */
-type RenderAnnotationFunction = (props: BlockAnnotationRenderProps) => JSX.Element;
+type RenderAnnotationFunction = (props: BlockAnnotationRenderProps) => JSX$1.Element;
 /** @beta */
 type RenderPlaceholderFunction = () => React.ReactNode;
 /** @beta */
-type RenderStyleFunction = (props: BlockStyleRenderProps) => JSX.Element;
+type RenderStyleFunction = (props: BlockStyleRenderProps) => JSX$1.Element;
 /** @beta */
 interface BlockStyleRenderProps {
   block: PortableTextTextBlock;
@@ -1031,9 +2667,9 @@ interface BlockStyleRenderProps {
   value: string;
 }
 /** @beta */
-type RenderListItemFunction = (props: BlockListItemRenderProps) => JSX.Element;
+type RenderListItemFunction = (props: BlockListItemRenderProps) => JSX$1.Element;
 /** @beta */
-type RenderDecoratorFunction = (props: BlockDecoratorRenderProps) => JSX.Element;
+type RenderDecoratorFunction = (props: BlockDecoratorRenderProps) => JSX$1.Element;
 /** @beta */
 type ScrollSelectionIntoViewFunction = (editor: PortableTextEditor, domRange: globalThis.Range) => void;
 /**
@@ -1506,7 +3142,7 @@ declare const editorMachine: xstate228.StateMachine<{
   initialValue?: Array<PortableTextBlock>;
 }, xstate228.NonReducibleUnknown, InternalPatchEvent | MutationEvent | PatchesEvent | {
   type: "blurred";
-  event: react18.FocusEvent<HTMLDivElement, Element>;
+  event: react24.FocusEvent<HTMLDivElement, Element>;
 } | {
   type: "done loading";
 } | {
@@ -1518,7 +3154,7 @@ declare const editorMachine: xstate228.StateMachine<{
   data: unknown;
 } | {
   type: "focused";
-  event: react18.FocusEvent<HTMLDivElement, Element>;
+  event: react24.FocusEvent<HTMLDivElement, Element>;
 } | {
   type: "invalid value";
   resolution: InvalidValueResolution | null;
@@ -1663,7 +3299,7 @@ declare const editorMachine: xstate228.StateMachine<{
     }, xstate228.AnyEventObject>;
   }) => {
     behaviors: Set<{
-      behavior: Behavior<"*" | "split" | `custom.${string}` | "annotation.add" | "annotation.remove" | "block.set" | "block.unset" | "child.set" | "child.unset" | "decorator.add" | "decorator.remove" | "delete" | "history.redo" | "history.undo" | "insert.block" | "insert.child" | "insert.text" | "move.backward" | "move.block" | "move.forward" | "select" | "annotation.set" | "annotation.toggle" | "decorator.toggle" | "delete.backward" | "delete.block" | "delete.child" | "delete.forward" | "delete.text" | "deserialize" | "deserialize.data" | "deserialization.success" | "deserialization.failure" | "insert.blocks" | "insert.break" | "insert.inline object" | "insert.soft break" | "insert.span" | "list item.add" | "list item.remove" | "list item.toggle" | "move.block down" | "move.block up" | "select.block" | "select.previous block" | "select.next block" | "serialize" | "serialize.data" | "serialization.success" | "serialization.failure" | "style.add" | "style.remove" | "style.toggle" | "clipboard.copy" | "clipboard.cut" | "clipboard.paste" | "drag.dragstart" | "drag.drag" | "drag.dragend" | "drag.dragenter" | "drag.dragover" | "drag.dragleave" | "drag.drop" | "input.*" | "keyboard.keydown" | "keyboard.keyup" | "mouse.click" | "style.*" | "history.*" | "split.*" | "delete.*" | "select.*" | "deserialize.*" | "serialize.*" | "annotation.*" | "block.*" | "child.*" | "decorator.*" | "insert.*" | "move.*" | "deserialization.*" | "list item.*" | "serialization.*" | "clipboard.*" | "drag.*" | "keyboard.*" | "mouse.*", true, {
+      behavior: Behavior<"*" | "split" | `custom.${string}` | "annotation.add" | "annotation.remove" | "block.set" | "block.unset" | "child.set" | "child.unset" | "decorator.add" | "decorator.remove" | "delete" | "history.redo" | "history.undo" | "insert.block" | "insert.child" | "insert.text" | "move.backward" | "move.block" | "move.forward" | "select" | "annotation.set" | "annotation.toggle" | "decorator.toggle" | "delete.backward" | "delete.block" | "delete.child" | "delete.forward" | "delete.text" | "deserialize" | "deserialize.data" | "deserialization.success" | "deserialization.failure" | "insert.blocks" | "insert.break" | "insert.inline object" | "insert.soft break" | "insert.span" | "list item.add" | "list item.remove" | "list item.toggle" | "move.block down" | "move.block up" | "select.block" | "select.previous block" | "select.next block" | "serialize" | "serialize.data" | "serialization.success" | "serialization.failure" | "style.add" | "style.remove" | "style.toggle" | "clipboard.copy" | "clipboard.cut" | "clipboard.paste" | "drag.dragstart" | "drag.drag" | "drag.dragend" | "drag.dragenter" | "drag.dragover" | "drag.dragleave" | "drag.drop" | "input.*" | "keyboard.keydown" | "keyboard.keyup" | "mouse.click" | "history.*" | "split.*" | "delete.*" | "select.*" | "deserialize.*" | "serialize.*" | "annotation.*" | "block.*" | "child.*" | "decorator.*" | "insert.*" | "move.*" | "deserialization.*" | "list item.*" | "serialization.*" | "style.*" | "clipboard.*" | "drag.*" | "keyboard.*" | "mouse.*", true, {
         type: StrictExtract<"split" | "annotation.add" | "annotation.remove" | "block.set" | "block.unset" | "child.set" | "child.unset" | "decorator.add" | "decorator.remove" | "delete" | "history.redo" | "history.undo" | "insert.block" | "insert.child" | "insert.text" | "move.backward" | "move.block" | "move.forward" | "select" | "annotation.set" | "annotation.toggle" | "decorator.toggle" | "delete.backward" | "delete.block" | "delete.child" | "delete.forward" | "delete.text" | "deserialize" | "deserialize.data" | "deserialization.success" | "deserialization.failure" | "insert.blocks" | "insert.break" | "insert.inline object" | "insert.soft break" | "insert.span" | "list item.add" | "list item.remove" | "list item.toggle" | "move.block down" | "move.block up" | "select.block" | "select.previous block" | "select.next block" | "serialize" | "serialize.data" | "serialization.success" | "serialization.failure" | "style.add" | "style.remove" | "style.toggle", "annotation.add">;
         annotation: {
           name: string;
@@ -2085,7 +3721,7 @@ declare const editorMachine: xstate228.StateMachine<{
         editor: PortableTextSlateEditor;
       }, undefined, never, never, never, never, InternalPatchEvent | MutationEvent | PatchesEvent | {
         type: "blurred";
-        event: react18.FocusEvent<HTMLDivElement, Element>;
+        event: react24.FocusEvent<HTMLDivElement, Element>;
       } | {
         type: "done loading";
       } | {
@@ -2097,7 +3733,7 @@ declare const editorMachine: xstate228.StateMachine<{
         data: unknown;
       } | {
         type: "focused";
-        event: react18.FocusEvent<HTMLDivElement, Element>;
+        event: react24.FocusEvent<HTMLDivElement, Element>;
       } | {
         type: "invalid value";
         resolution: InvalidValueResolution | null;
@@ -2917,7 +4553,7 @@ declare const editorMachine: xstate228.StateMachine<{
                         editor: PortableTextSlateEditor;
                       }, undefined, never, never, never, never, InternalPatchEvent | MutationEvent | PatchesEvent | {
                         type: "blurred";
-                        event: react18.FocusEvent<HTMLDivElement, Element>;
+                        event: react24.FocusEvent<HTMLDivElement, Element>;
                       } | {
                         type: "done loading";
                       } | {
@@ -2929,7 +4565,7 @@ declare const editorMachine: xstate228.StateMachine<{
                         data: unknown;
                       } | {
                         type: "focused";
-                        event: react18.FocusEvent<HTMLDivElement, Element>;
+                        event: react24.FocusEvent<HTMLDivElement, Element>;
                       } | {
                         type: "invalid value";
                         resolution: InvalidValueResolution | null;
@@ -3479,4 +5115,4 @@ type BehaviorActionSet<TBehaviorEvent, TGuardResponse> = (payload: {
   event: TBehaviorEvent;
   dom: EditorDom;
 }, guardResponse: TGuardResponse) => Array<BehaviorAction>;
-export { BlockAnnotationRenderProps as $, EditorSchema as $t, PortableTextTextBlock$2 as A, ReadyChange as At, EditorSelector as B, ScrollSelectionIntoViewFunction as Bt, ListDefinition as C, OnPasteResultOrPromise as Ct, PortableTextChild$1 as D, PortableTextMemberSchemaTypes as Dt, PortableTextBlock$1 as E, PatchObservable as Et, BlockOffset as F, RenderDecoratorFunction as Ft, EditorConfig as G, AnnotationPath as Gt, EditorProvider as H, UndoChange as Ht, useEditor as I, RenderEditableFunction as It, defineBehavior as J, PortableTextEditable as Jt, EditorEvent as K, BlockPath as Kt, defaultKeyGenerator as L, RenderListItemFunction as Lt, StyleDefinition as M, RenderAnnotationFunction as Mt, StyleSchemaType as N, RenderBlockFunction as Nt, PortableTextObject$2 as O, RangeDecoration as Ot, defineSchema as P, RenderChildFunction as Pt, AddedAnnotationPaths as Q, PortableTextEditorProps as Qt, usePortableTextEditorSelection as R, RenderPlaceholderFunction as Rt, InlineObjectSchemaType as S, OnPasteResult as St, Patch$1 as T, PatchChange as Tt, EditorProviderProps as U, UnsetChange as Ut, useEditorSelector as V, SelectionChange as Vt, Editor as W, ValueChange as Wt, EditorContext as X, HotkeyOptions as Xt, BehaviorGuard as Y, PortableTextEditableProps as Yt, EditorSnapshot as Z, PortableTextEditor as Zt, BlockObjectSchemaType as _, LoadingChange as _t, forward as a, BlurChange as at, FieldDefinition as b, OnCopyFn as bt, CustomBehaviorEvent as c, EditableAPIDeleteOptions as ct, SyntheticBehaviorEvent as d, EditorSelection as dt, EditorEmittedEvent as en, BlockChildRenderProps as et, PatchesEvent as f, EditorSelectionPoint as ft, BlockObjectDefinition as g, InvalidValueResolution as gt, BaseDefinition as h, InvalidValue as ht, execute as i, BlockStyleRenderProps as it, SchemaDefinition$1 as j, RedoChange as jt, PortableTextSpan$2 as k, RangeDecorationOnMovedDetails as kt, InsertPlacement as l, EditorChange as lt, AnnotationSchemaType as m, FocusChange as mt, BehaviorActionSet as n, BlockListItemRenderProps as nt, raise as o, ConnectionChange as ot, AnnotationDefinition as p, ErrorChange as pt, Behavior as q, ChildPath as qt, effect as r, BlockRenderProps as rt, BehaviorEvent as s, EditableAPI as st, BehaviorAction as t, MutationEvent as tn, BlockDecoratorRenderProps as tt, NativeBehaviorEvent as u, EditorChanges as ut, DecoratorDefinition as v, MutationChange as vt, ListSchemaType as w, PasteData as wt, InlineObjectDefinition as x, OnPasteFn as xt, DecoratorSchemaType as y, OnBeforeInputFn as yt, usePortableTextEditor as z, RenderStyleFunction as zt };
+export { BlockAnnotationRenderProps as $, EditorEmittedEvent as $t, PortableTextTextBlock$2 as A, ReadyChange as At, EditorSelector as B, ScrollSelectionIntoViewFunction as Bt, ListDefinition as C, OnPasteResultOrPromise as Ct, PortableTextChild$1 as D, PortableTextMemberSchemaTypes as Dt, PortableTextBlock$1 as E, PatchObservable as Et, BlockOffset as F, RenderDecoratorFunction as Ft, EditorConfig as G, AnnotationPath as Gt, EditorProvider as H, UndoChange as Ht, useEditor as I, RenderEditableFunction as It, defineBehavior as J, PortableTextEditable as Jt, EditorEvent as K, BlockPath as Kt, defaultKeyGenerator as L, RenderListItemFunction as Lt, StyleDefinition as M, RenderAnnotationFunction as Mt, StyleSchemaType as N, RenderBlockFunction as Nt, PortableTextObject$2 as O, RangeDecoration as Ot, defineSchema as P, RenderChildFunction as Pt, AddedAnnotationPaths as Q, PortableTextEditorProps as Qt, usePortableTextEditorSelection as R, RenderPlaceholderFunction as Rt, InlineObjectSchemaType as S, OnPasteResult as St, Patch$1 as T, PatchChange as Tt, EditorProviderProps as U, UnsetChange as Ut, useEditorSelector as V, SelectionChange as Vt, Editor as W, ValueChange as Wt, EditorContext as X, HotkeyOptions as Xt, BehaviorGuard as Y, PortableTextEditableProps as Yt, EditorSnapshot as Z, PortableTextEditor as Zt, BlockObjectSchemaType as _, LoadingChange as _t, forward as a, BlurChange as at, FieldDefinition as b, OnCopyFn as bt, CustomBehaviorEvent as c, EditableAPIDeleteOptions as ct, SyntheticBehaviorEvent as d, EditorSelection as dt, MutationEvent as en, BlockChildRenderProps as et, PatchesEvent as f, EditorSelectionPoint as ft, BlockObjectDefinition as g, InvalidValueResolution as gt, BaseDefinition as h, InvalidValue as ht, execute as i, BlockStyleRenderProps as it, SchemaDefinition$1 as j, RedoChange as jt, PortableTextSpan$2 as k, RangeDecorationOnMovedDetails as kt, InsertPlacement as l, EditorChange as lt, AnnotationSchemaType as m, FocusChange as mt, BehaviorActionSet as n, BlockListItemRenderProps as nt, raise as o, ConnectionChange as ot, AnnotationDefinition as p, ErrorChange as pt, Behavior as q, ChildPath as qt, effect as r, BlockRenderProps as rt, BehaviorEvent as s, EditableAPI as st, BehaviorAction as t, EditorSchema as tn, BlockDecoratorRenderProps as tt, NativeBehaviorEvent as u, EditorChanges as ut, DecoratorDefinition as v, MutationChange as vt, ListSchemaType as w, PasteData as wt, InlineObjectDefinition as x, OnPasteFn as xt, DecoratorSchemaType as y, OnBeforeInputFn as yt, usePortableTextEditor as z, RenderStyleFunction as zt };