@portabletext/editor 3.3.3 → 3.3.5

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

@@ -1,1461 +1,16 @@
-/// <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 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 * as react18 from "react";
+import React$1, { BaseSyntheticEvent, ClipboardEvent, Component, FocusEvent, JSX, 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 { 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
@@ -1509,201 +64,6 @@ 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
  */
@@ -1887,7 +247,7 @@ declare class PortableTextEditor extends Component<PortableTextEditorProps<Inter
   componentDidUpdate(prevProps: PortableTextEditorProps): void;
   componentWillUnmount(): void;
   setEditable: (editable: EditableAPI) => void;
-  render(): react24.JSX.Element;
+  render(): react18.JSX.Element;
   /**
    * @deprecated
    * Use built-in selectors or write your own: https://www.portabletext.org/reference/selectors/
@@ -2296,7 +656,7 @@ type PortableTextEditableProps = Omit<TextareaHTMLAttributes<HTMLDivElement>, 'o
  * ```
  * @group Components
  */
-declare const PortableTextEditable: react24.ForwardRefExoticComponent<Omit<PortableTextEditableProps, "ref"> & react24.RefAttributes<Omit<HTMLDivElement, "as" | "onPaste" | "onBeforeInput">>>;
+declare const PortableTextEditable: react18.ForwardRefExoticComponent<Omit<PortableTextEditableProps, "ref"> & react18.RefAttributes<Omit<HTMLDivElement, "as" | "onPaste" | "onBeforeInput">>>;
 /**
  * @public
  */
@@ -2557,7 +917,7 @@ type OnPasteResult = {
 type OnPasteResultOrPromise = OnPasteResult | Promise<OnPasteResult>;
 /** @beta */
 interface PasteData {
-  event: ClipboardEvent$1;
+  event: ClipboardEvent;
   path: Path;
   schemaTypes: PortableTextMemberSchemaTypes;
   value: PortableTextBlock[] | undefined;
@@ -2572,7 +932,7 @@ type OnPasteFn = (data: PasteData) => OnPasteResultOrPromise;
 /** @beta */
 type OnBeforeInputFn = (event: InputEvent) => void;
 /** @beta */
-type OnCopyFn = (event: ClipboardEvent$1<HTMLDivElement | HTMLSpanElement>) => undefined | unknown;
+type OnCopyFn = (event: ClipboardEvent<HTMLDivElement | HTMLSpanElement>) => undefined | unknown;
 /** @beta */
 type PatchObservable = Observable<{
   patches: Patch[];
@@ -2644,17 +1004,17 @@ interface BlockListItemRenderProps {
   value: string;
 }
 /** @beta */
-type RenderBlockFunction = (props: BlockRenderProps) => JSX$1.Element;
+type RenderBlockFunction = (props: BlockRenderProps) => JSX.Element;
 /** @beta */
-type RenderChildFunction = (props: BlockChildRenderProps) => JSX$1.Element;
+type RenderChildFunction = (props: BlockChildRenderProps) => JSX.Element;
 /** @beta */
-type RenderEditableFunction = (props: PortableTextEditableProps) => JSX$1.Element;
+type RenderEditableFunction = (props: PortableTextEditableProps) => JSX.Element;
 /** @beta */
-type RenderAnnotationFunction = (props: BlockAnnotationRenderProps) => JSX$1.Element;
+type RenderAnnotationFunction = (props: BlockAnnotationRenderProps) => JSX.Element;
 /** @beta */
 type RenderPlaceholderFunction = () => React.ReactNode;
 /** @beta */
-type RenderStyleFunction = (props: BlockStyleRenderProps) => JSX$1.Element;
+type RenderStyleFunction = (props: BlockStyleRenderProps) => JSX.Element;
 /** @beta */
 interface BlockStyleRenderProps {
   block: PortableTextTextBlock;
@@ -2667,9 +1027,9 @@ interface BlockStyleRenderProps {
   value: string;
 }
 /** @beta */
-type RenderListItemFunction = (props: BlockListItemRenderProps) => JSX$1.Element;
+type RenderListItemFunction = (props: BlockListItemRenderProps) => JSX.Element;
 /** @beta */
-type RenderDecoratorFunction = (props: BlockDecoratorRenderProps) => JSX$1.Element;
+type RenderDecoratorFunction = (props: BlockDecoratorRenderProps) => JSX.Element;
 /** @beta */
 type ScrollSelectionIntoViewFunction = (editor: PortableTextEditor, domRange: globalThis.Range) => void;
 /**
@@ -2926,12 +1286,6 @@ type BlockOffset = {
   path: BlockPath;
   offset: number;
 };
-declare global {
-  type DOMNode = typeof globalThis.Node;
-  type DOMRange = typeof globalThis.Range;
-  type DOMSelection = typeof globalThis.Selection;
-  type DOMStaticRange = typeof globalThis.StaticRange;
-}
 type TextBlockWithOptionalKey = Omit<PortableTextTextBlock$1, '_key'> & {
   _key?: PortableTextTextBlock$1['_key'];
 };
@@ -3148,7 +1502,7 @@ declare const editorMachine: xstate228.StateMachine<{
   initialValue?: Array<PortableTextBlock>;
 }, xstate228.NonReducibleUnknown, InternalPatchEvent | MutationEvent | PatchesEvent | {
   type: "blurred";
-  event: react24.FocusEvent<HTMLDivElement, Element>;
+  event: react18.FocusEvent<HTMLDivElement, Element>;
 } | {
   type: "done loading";
 } | {
@@ -3160,7 +1514,7 @@ declare const editorMachine: xstate228.StateMachine<{
   data: unknown;
 } | {
   type: "focused";
-  event: react24.FocusEvent<HTMLDivElement, Element>;
+  event: react18.FocusEvent<HTMLDivElement, Element>;
 } | {
   type: "invalid value";
   resolution: InvalidValueResolution | null;
@@ -3727,7 +2081,7 @@ declare const editorMachine: xstate228.StateMachine<{
         editor: PortableTextSlateEditor;
       }, undefined, never, never, never, never, InternalPatchEvent | MutationEvent | PatchesEvent | {
         type: "blurred";
-        event: react24.FocusEvent<HTMLDivElement, Element>;
+        event: react18.FocusEvent<HTMLDivElement, Element>;
       } | {
         type: "done loading";
       } | {
@@ -3739,7 +2093,7 @@ declare const editorMachine: xstate228.StateMachine<{
         data: unknown;
       } | {
         type: "focused";
-        event: react24.FocusEvent<HTMLDivElement, Element>;
+        event: react18.FocusEvent<HTMLDivElement, Element>;
       } | {
         type: "invalid value";
         resolution: InvalidValueResolution | null;
@@ -4559,7 +2913,7 @@ declare const editorMachine: xstate228.StateMachine<{
                         editor: PortableTextSlateEditor;
                       }, undefined, never, never, never, never, InternalPatchEvent | MutationEvent | PatchesEvent | {
                         type: "blurred";
-                        event: react24.FocusEvent<HTMLDivElement, Element>;
+                        event: react18.FocusEvent<HTMLDivElement, Element>;
                       } | {
                         type: "done loading";
                       } | {
@@ -4571,7 +2925,7 @@ declare const editorMachine: xstate228.StateMachine<{
                         data: unknown;
                       } | {
                         type: "focused";
-                        event: react24.FocusEvent<HTMLDivElement, Element>;
+                        event: react18.FocusEvent<HTMLDivElement, Element>;
                       } | {
                         type: "invalid value";
                         resolution: InvalidValueResolution | null;