slate

  • Version 0.103.0
  • Published
  • 2.11 MB
  • 3 dependencies
  • MIT license

Install

npm i slate
yarn add slate
pnpm add slate

Overview

A completely customizable framework for building rich text editors.

Index

Variables

Functions

Interfaces

Type Aliases

Variables

variable above

const above: <T extends Ancestor>(
editor: BaseEditor,
options?: EditorAboveOptions<T>
) => NodeEntry<T>;

    variable addMark

    const addMark: (editor: BaseEditor, key: string, value: any) => void;

      variable after

      const after: (
      editor: BaseEditor,
      at: Location,
      options?: EditorAfterOptions
      ) => BasePoint;

        variable apply

        const apply: WithEditorFirstArg<(operation: BaseOperation) => void>;

          variable before

          const before: (
          editor: BaseEditor,
          at: Location,
          options?: EditorBeforeOptions
          ) => BasePoint;

            variable collapse

            const collapse: (editor: BaseEditor, options?: SelectionCollapseOptions) => void;

              variable deleteBackward

              const deleteBackward: WithEditorFirstArg<(unit: TextUnit) => void>;

                variable deleteForward

                const deleteForward: WithEditorFirstArg<(unit: TextUnit) => void>;

                  variable deleteFragment

                  const deleteFragment: (
                  editor: BaseEditor,
                  options?: EditorFragmentDeletionOptions
                  ) => void;

                    variable deleteText

                    const deleteText: (editor: BaseEditor, options?: TextDeleteOptions) => void;

                      variable deselect

                      const deselect: (editor: BaseEditor) => void;

                        variable edges

                        const edges: (editor: BaseEditor, at: Location) => [BasePoint, BasePoint];

                          variable Editor

                          const Editor: EditorInterface;

                            variable Element

                            const Element: ElementInterface;

                              variable elementReadOnly

                              const elementReadOnly: (
                              editor: BaseEditor,
                              options?: EditorElementReadOnlyOptions
                              ) => NodeEntry<BaseElement>;

                                variable end

                                const end: (editor: BaseEditor, at: Location) => BasePoint;

                                  variable first

                                  const first: (editor: BaseEditor, at: Location) => NodeEntry<Node>;

                                    variable fragment

                                    const fragment: (editor: BaseEditor, at: Location) => Descendant[];

                                      variable getDirtyPaths

                                      const getDirtyPaths: WithEditorFirstArg<(operation: BaseOperation) => Path[]>;
                                      • Get the "dirty" paths generated from an operation.

                                      variable getFragment

                                      const getFragment: WithEditorFirstArg<() => Descendant[]>;

                                        variable getVoid

                                        const getVoid: (
                                        editor: BaseEditor,
                                        options?: EditorVoidOptions
                                        ) => NodeEntry<BaseElement>;

                                          variable hasBlocks

                                          const hasBlocks: (editor: BaseEditor, element: BaseElement) => boolean;

                                            variable hasInlines

                                            const hasInlines: (editor: BaseEditor, element: BaseElement) => boolean;

                                              variable hasPath

                                              const hasPath: (editor: BaseEditor, path: Path) => boolean;

                                                variable hasTexts

                                                const hasTexts: (editor: BaseEditor, element: BaseElement) => boolean;

                                                  variable insertBreak

                                                  const insertBreak: (editor: BaseEditor) => void;

                                                    variable insertFragment

                                                    const insertFragment: (
                                                    editor: BaseEditor,
                                                    fragment: Node[],
                                                    options?: TextInsertFragmentOptions
                                                    ) => void;

                                                      variable insertNode

                                                      const insertNode: <T extends Node>(
                                                      editor: BaseEditor,
                                                      node: Node,
                                                      options?: NodeInsertNodesOptions<T>
                                                      ) => void;

                                                        variable insertNodes

                                                        const insertNodes: <T extends Node>(
                                                        editor: BaseEditor,
                                                        nodes: Node | Node[],
                                                        options?: NodeInsertNodesOptions<T>
                                                        ) => void;

                                                          variable insertSoftBreak

                                                          const insertSoftBreak: (editor: BaseEditor) => void;

                                                            variable insertText

                                                            const insertText: (
                                                            editor: BaseEditor,
                                                            text: string,
                                                            options?: TextInsertTextOptions
                                                            ) => void;

                                                              variable isBlock

                                                              const isBlock: (editor: BaseEditor, value: BaseElement) => boolean;

                                                                variable isEdge

                                                                const isEdge: (editor: BaseEditor, point: BasePoint, at: Location) => boolean;

                                                                  variable isEditor

                                                                  const isEditor: (value: any) => value is BaseEditor;

                                                                    variable isEmpty

                                                                    const isEmpty: (editor: BaseEditor, element: BaseElement) => boolean;

                                                                      variable isEnd

                                                                      const isEnd: (editor: BaseEditor, point: BasePoint, at: Location) => boolean;

                                                                        variable isNormalizing

                                                                        const isNormalizing: (editor: BaseEditor) => boolean;

                                                                          variable isStart

                                                                          const isStart: (editor: BaseEditor, point: BasePoint, at: Location) => boolean;

                                                                            variable last

                                                                            const last: (editor: BaseEditor, at: Location) => NodeEntry<Node>;

                                                                              variable leaf

                                                                              const leaf: (
                                                                              editor: BaseEditor,
                                                                              at: Location,
                                                                              options?: EditorLeafOptions
                                                                              ) => NodeEntry<BaseText>;

                                                                                variable liftNodes

                                                                                const liftNodes: <T extends Node>(
                                                                                editor: BaseEditor,
                                                                                options?: {
                                                                                at?: Location;
                                                                                match?: NodeMatch<T>;
                                                                                mode?: MaximizeMode;
                                                                                voids?: boolean;
                                                                                }
                                                                                ) => void;

                                                                                  variable Location

                                                                                  const Location: LocationInterface;

                                                                                    variable marks

                                                                                    const marks: (editor: BaseEditor) => Omit<BaseText, 'text'>;

                                                                                      variable mergeNodes

                                                                                      const mergeNodes: <T extends Node>(
                                                                                      editor: BaseEditor,
                                                                                      options?: {
                                                                                      at?: Location;
                                                                                      match?: NodeMatch<T>;
                                                                                      mode?: RangeMode;
                                                                                      hanging?: boolean;
                                                                                      voids?: boolean;
                                                                                      }
                                                                                      ) => void;

                                                                                        variable move

                                                                                        const move: (editor: BaseEditor, options?: SelectionMoveOptions) => void;

                                                                                          variable moveNodes

                                                                                          const moveNodes: <T extends Node>(
                                                                                          editor: BaseEditor,
                                                                                          options: {
                                                                                          at?: Location;
                                                                                          match?: NodeMatch<T>;
                                                                                          mode?: MaximizeMode;
                                                                                          to: Path;
                                                                                          voids?: boolean;
                                                                                          }
                                                                                          ) => void;

                                                                                            variable next

                                                                                            const next: <T extends Descendant>(
                                                                                            editor: BaseEditor,
                                                                                            options?: EditorNextOptions<T>
                                                                                            ) => NodeEntry<T>;

                                                                                              variable node

                                                                                              const node: (
                                                                                              editor: BaseEditor,
                                                                                              at: Location,
                                                                                              options?: EditorNodeOptions
                                                                                              ) => NodeEntry<Node>;

                                                                                                variable Node

                                                                                                const Node: NodeInterface;

                                                                                                  variable normalize

                                                                                                  const normalize: (editor: BaseEditor, options?: EditorNormalizeOptions) => void;

                                                                                                    variable normalizeNode

                                                                                                    const normalizeNode: WithEditorFirstArg<
                                                                                                    (entry: NodeEntry<Node>, options?: { operation?: BaseOperation }) => void
                                                                                                    >;

                                                                                                      variable Operation

                                                                                                      const Operation: OperationInterface;

                                                                                                        variable parent

                                                                                                        const parent: (
                                                                                                        editor: BaseEditor,
                                                                                                        at: Location,
                                                                                                        options?: EditorParentOptions
                                                                                                        ) => NodeEntry<Ancestor>;

                                                                                                          variable path

                                                                                                          const path: (editor: BaseEditor, at: Location, options?: EditorPathOptions) => Path;

                                                                                                            variable Path

                                                                                                            const Path: PathInterface;

                                                                                                              variable pathRef

                                                                                                              const pathRef: (
                                                                                                              editor: BaseEditor,
                                                                                                              path: Path,
                                                                                                              options?: EditorPathRefOptions
                                                                                                              ) => PathRef;

                                                                                                                variable PathRef

                                                                                                                const PathRef: PathRefInterface;

                                                                                                                  variable pathRefs

                                                                                                                  const pathRefs: (editor: BaseEditor) => Set<PathRef>;

                                                                                                                    variable point

                                                                                                                    const point: (
                                                                                                                    editor: BaseEditor,
                                                                                                                    at: Location,
                                                                                                                    options?: EditorPointOptions
                                                                                                                    ) => BasePoint;

                                                                                                                      variable Point

                                                                                                                      const Point: PointInterface;

                                                                                                                        variable pointRef

                                                                                                                        const pointRef: (
                                                                                                                        editor: BaseEditor,
                                                                                                                        point: BasePoint,
                                                                                                                        options?: EditorPointRefOptions
                                                                                                                        ) => PointRef;

                                                                                                                          variable PointRef

                                                                                                                          const PointRef: PointRefInterface;

                                                                                                                            variable pointRefs

                                                                                                                            const pointRefs: (editor: BaseEditor) => Set<PointRef>;

                                                                                                                              variable previous

                                                                                                                              const previous: <T extends Node>(
                                                                                                                              editor: BaseEditor,
                                                                                                                              options?: EditorPreviousOptions<T>
                                                                                                                              ) => NodeEntry<T>;

                                                                                                                                variable range

                                                                                                                                const range: (editor: BaseEditor, at: Location, to?: Location) => BaseRange;

                                                                                                                                  variable Range

                                                                                                                                  const Range: RangeInterface;

                                                                                                                                    variable rangeRef

                                                                                                                                    const rangeRef: (
                                                                                                                                    editor: BaseEditor,
                                                                                                                                    range: BaseRange,
                                                                                                                                    options?: EditorRangeRefOptions
                                                                                                                                    ) => RangeRef;

                                                                                                                                      variable RangeRef

                                                                                                                                      const RangeRef: RangeRefInterface;

                                                                                                                                        variable rangeRefs

                                                                                                                                        const rangeRefs: (editor: BaseEditor) => Set<RangeRef>;

                                                                                                                                          variable removeMark

                                                                                                                                          const removeMark: (editor: BaseEditor, key: string) => void;

                                                                                                                                            variable removeNodes

                                                                                                                                            const removeNodes: <T extends Node>(
                                                                                                                                            editor: BaseEditor,
                                                                                                                                            options?: {
                                                                                                                                            at?: Location;
                                                                                                                                            match?: NodeMatch<T>;
                                                                                                                                            mode?: RangeMode;
                                                                                                                                            hanging?: boolean;
                                                                                                                                            voids?: boolean;
                                                                                                                                            }
                                                                                                                                            ) => void;

                                                                                                                                              variable Scrubber

                                                                                                                                              const Scrubber: ScrubberInterface;
                                                                                                                                              • This interface implements a stringify() function, which is used by Slate internally when generating exceptions containing end user data. Developers using Slate may call Scrubber.setScrubber() to alter the behavior of this stringify() function.

                                                                                                                                                For example, to prevent the cleartext logging of 'text' fields within Nodes:

                                                                                                                                                import { Scrubber } from 'slate'; Scrubber.setScrubber((key, val) => { if (key === 'text') return '...scrubbed...' return val });

                                                                                                                                              variable select

                                                                                                                                              const select: (editor: BaseEditor, target: Location) => void;

                                                                                                                                                variable setNodes

                                                                                                                                                const setNodes: <T extends Node>(
                                                                                                                                                editor: BaseEditor,
                                                                                                                                                props: Partial<T>,
                                                                                                                                                options?: {
                                                                                                                                                at?: Location;
                                                                                                                                                match?: NodeMatch<T>;
                                                                                                                                                mode?: MaximizeMode;
                                                                                                                                                hanging?: boolean;
                                                                                                                                                split?: boolean;
                                                                                                                                                voids?: boolean;
                                                                                                                                                compare?: PropsCompare;
                                                                                                                                                merge?: PropsMerge;
                                                                                                                                                }
                                                                                                                                                ) => void;

                                                                                                                                                  variable setNormalizing

                                                                                                                                                  const setNormalizing: (editor: BaseEditor, isNormalizing: boolean) => void;

                                                                                                                                                    variable setPoint

                                                                                                                                                    const setPoint: (
                                                                                                                                                    editor: BaseEditor,
                                                                                                                                                    props: Partial<BasePoint>,
                                                                                                                                                    options?: SelectionSetPointOptions
                                                                                                                                                    ) => void;

                                                                                                                                                      variable setSelection

                                                                                                                                                      const setSelection: (editor: BaseEditor, props: Partial<BaseRange>) => void;

                                                                                                                                                        variable shouldMergeNodesRemovePrevNode

                                                                                                                                                        const shouldMergeNodesRemovePrevNode: (
                                                                                                                                                        editor: BaseEditor,
                                                                                                                                                        prevNodeEntry: NodeEntry<Node>,
                                                                                                                                                        curNodeEntry: NodeEntry<Node>
                                                                                                                                                        ) => boolean;

                                                                                                                                                          variable shouldNormalize

                                                                                                                                                          const shouldNormalize: WithEditorFirstArg<
                                                                                                                                                          ({
                                                                                                                                                          iteration,
                                                                                                                                                          dirtyPaths,
                                                                                                                                                          operation,
                                                                                                                                                          }: {
                                                                                                                                                          iteration: number;
                                                                                                                                                          initialDirtyPathsLength: number;
                                                                                                                                                          dirtyPaths: Path[];
                                                                                                                                                          operation?: BaseOperation;
                                                                                                                                                          }) => boolean
                                                                                                                                                          >;

                                                                                                                                                            variable Span

                                                                                                                                                            const Span: SpanInterface;

                                                                                                                                                              variable splitNodes

                                                                                                                                                              const splitNodes: <T extends Node>(
                                                                                                                                                              editor: BaseEditor,
                                                                                                                                                              options?: {
                                                                                                                                                              at?: Location;
                                                                                                                                                              match?: NodeMatch<T>;
                                                                                                                                                              mode?: RangeMode;
                                                                                                                                                              always?: boolean;
                                                                                                                                                              height?: number;
                                                                                                                                                              voids?: boolean;
                                                                                                                                                              }
                                                                                                                                                              ) => void;

                                                                                                                                                                variable start

                                                                                                                                                                const start: (editor: BaseEditor, at: Location) => BasePoint;

                                                                                                                                                                  variable string

                                                                                                                                                                  const string: (
                                                                                                                                                                  editor: BaseEditor,
                                                                                                                                                                  at: Location,
                                                                                                                                                                  options?: EditorStringOptions
                                                                                                                                                                  ) => string;

                                                                                                                                                                    variable Text

                                                                                                                                                                    const Text: TextInterface;

                                                                                                                                                                      variable Transforms

                                                                                                                                                                      const Transforms: GeneralTransforms &
                                                                                                                                                                      NodeTransforms &
                                                                                                                                                                      SelectionTransforms &
                                                                                                                                                                      TextTransforms;

                                                                                                                                                                        variable unhangRange

                                                                                                                                                                        const unhangRange: (
                                                                                                                                                                        editor: BaseEditor,
                                                                                                                                                                        range: BaseRange,
                                                                                                                                                                        options?: EditorUnhangRangeOptions
                                                                                                                                                                        ) => BaseRange;

                                                                                                                                                                          variable unsetNodes

                                                                                                                                                                          const unsetNodes: <T extends Node>(
                                                                                                                                                                          editor: BaseEditor,
                                                                                                                                                                          props: string | string[],
                                                                                                                                                                          options?: {
                                                                                                                                                                          at?: Location;
                                                                                                                                                                          match?: NodeMatch<T>;
                                                                                                                                                                          mode?: MaximizeMode;
                                                                                                                                                                          hanging?: boolean;
                                                                                                                                                                          split?: boolean;
                                                                                                                                                                          voids?: boolean;
                                                                                                                                                                          }
                                                                                                                                                                          ) => void;

                                                                                                                                                                            variable unwrapNodes

                                                                                                                                                                            const unwrapNodes: <T extends Node>(
                                                                                                                                                                            editor: BaseEditor,
                                                                                                                                                                            options?: {
                                                                                                                                                                            at?: Location;
                                                                                                                                                                            match?: NodeMatch<T>;
                                                                                                                                                                            mode?: MaximizeMode;
                                                                                                                                                                            split?: boolean;
                                                                                                                                                                            voids?: boolean;
                                                                                                                                                                            }
                                                                                                                                                                            ) => void;

                                                                                                                                                                              variable withoutNormalizing

                                                                                                                                                                              const withoutNormalizing: (editor: BaseEditor, fn: () => void) => void;

                                                                                                                                                                                variable wrapNodes

                                                                                                                                                                                const wrapNodes: <T extends Node>(
                                                                                                                                                                                editor: BaseEditor,
                                                                                                                                                                                element: BaseElement,
                                                                                                                                                                                options?: {
                                                                                                                                                                                at?: Location;
                                                                                                                                                                                match?: NodeMatch<T>;
                                                                                                                                                                                mode?: MaximizeMode;
                                                                                                                                                                                split?: boolean;
                                                                                                                                                                                voids?: boolean;
                                                                                                                                                                                }
                                                                                                                                                                                ) => void;

                                                                                                                                                                                  Functions

                                                                                                                                                                                  function createEditor

                                                                                                                                                                                  createEditor: () => Editor;
                                                                                                                                                                                  • Create a new Slate Editor object.

                                                                                                                                                                                  function levels

                                                                                                                                                                                  levels: <T extends Node>(
                                                                                                                                                                                  editor: Editor,
                                                                                                                                                                                  options?: EditorLevelsOptions<T>
                                                                                                                                                                                  ) => Generator<NodeEntry<T>, void, undefined>;

                                                                                                                                                                                    function nodes

                                                                                                                                                                                    nodes: <T extends Node>(
                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                    options?: EditorNodesOptions<T>
                                                                                                                                                                                    ) => Generator<NodeEntry<T>, void, undefined>;

                                                                                                                                                                                      function positions

                                                                                                                                                                                      positions: (
                                                                                                                                                                                      editor: Editor,
                                                                                                                                                                                      options?: EditorPositionsOptions
                                                                                                                                                                                      ) => Generator<Point, void, undefined>;

                                                                                                                                                                                        Interfaces

                                                                                                                                                                                        interface BaseEditor

                                                                                                                                                                                        interface BaseEditor {}
                                                                                                                                                                                        • 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.

                                                                                                                                                                                        property above

                                                                                                                                                                                        above: <T extends Ancestor>(
                                                                                                                                                                                        options?: EditorAboveOptions<T>
                                                                                                                                                                                        ) => NodeEntry<T> | undefined;

                                                                                                                                                                                          property addMark

                                                                                                                                                                                          addMark: OmitFirstArg<typeof Editor.addMark>;

                                                                                                                                                                                            property after

                                                                                                                                                                                            after: OmitFirstArg<typeof Editor.after>;

                                                                                                                                                                                              property apply

                                                                                                                                                                                              apply: (operation: Operation) => void;

                                                                                                                                                                                                property before

                                                                                                                                                                                                before: OmitFirstArg<typeof Editor.before>;

                                                                                                                                                                                                  property children

                                                                                                                                                                                                  children: Descendant[];

                                                                                                                                                                                                    property collapse

                                                                                                                                                                                                    collapse: OmitFirstArg<typeof Transforms.collapse>;

                                                                                                                                                                                                      property delete

                                                                                                                                                                                                      delete: OmitFirstArg<typeof Transforms.delete>;

                                                                                                                                                                                                        property deleteBackward

                                                                                                                                                                                                        deleteBackward: (unit: TextUnit) => void;

                                                                                                                                                                                                          property deleteForward

                                                                                                                                                                                                          deleteForward: (unit: TextUnit) => void;

                                                                                                                                                                                                            property deleteFragment

                                                                                                                                                                                                            deleteFragment: OmitFirstArg<typeof Editor.deleteFragment>;

                                                                                                                                                                                                              property deselect

                                                                                                                                                                                                              deselect: OmitFirstArg<typeof Transforms.deselect>;

                                                                                                                                                                                                                property edges

                                                                                                                                                                                                                edges: OmitFirstArg<typeof Editor.edges>;

                                                                                                                                                                                                                  property elementReadOnly

                                                                                                                                                                                                                  elementReadOnly: OmitFirstArg<typeof Editor.elementReadOnly>;

                                                                                                                                                                                                                    property end

                                                                                                                                                                                                                    end: OmitFirstArg<typeof Editor.end>;

                                                                                                                                                                                                                      property first

                                                                                                                                                                                                                      first: OmitFirstArg<typeof Editor.first>;

                                                                                                                                                                                                                        property fragment

                                                                                                                                                                                                                        fragment: OmitFirstArg<typeof Editor.fragment>;

                                                                                                                                                                                                                          property getDirtyPaths

                                                                                                                                                                                                                          getDirtyPaths: (operation: Operation) => Path[];

                                                                                                                                                                                                                            property getFragment

                                                                                                                                                                                                                            getFragment: () => Descendant[];

                                                                                                                                                                                                                              property getMarks

                                                                                                                                                                                                                              getMarks: OmitFirstArg<typeof Editor.marks>;

                                                                                                                                                                                                                                property hasBlocks

                                                                                                                                                                                                                                hasBlocks: OmitFirstArg<typeof Editor.hasBlocks>;

                                                                                                                                                                                                                                  property hasInlines

                                                                                                                                                                                                                                  hasInlines: OmitFirstArg<typeof Editor.hasInlines>;

                                                                                                                                                                                                                                    property hasPath

                                                                                                                                                                                                                                    hasPath: OmitFirstArg<typeof Editor.hasPath>;

                                                                                                                                                                                                                                      property hasTexts

                                                                                                                                                                                                                                      hasTexts: OmitFirstArg<typeof Editor.hasTexts>;

                                                                                                                                                                                                                                        property insertBreak

                                                                                                                                                                                                                                        insertBreak: OmitFirstArg<typeof Editor.insertBreak>;

                                                                                                                                                                                                                                          property insertFragment

                                                                                                                                                                                                                                          insertFragment: OmitFirstArg<typeof Transforms.insertFragment>;

                                                                                                                                                                                                                                            property insertNode

                                                                                                                                                                                                                                            insertNode: OmitFirstArg<typeof Editor.insertNode>;

                                                                                                                                                                                                                                              property insertNodes

                                                                                                                                                                                                                                              insertNodes: OmitFirstArg<typeof Transforms.insertNodes>;

                                                                                                                                                                                                                                                property insertSoftBreak

                                                                                                                                                                                                                                                insertSoftBreak: OmitFirstArg<typeof Editor.insertSoftBreak>;

                                                                                                                                                                                                                                                  property insertText

                                                                                                                                                                                                                                                  insertText: OmitFirstArg<typeof Transforms.insertText>;

                                                                                                                                                                                                                                                    property isBlock

                                                                                                                                                                                                                                                    isBlock: OmitFirstArg<typeof Editor.isBlock>;

                                                                                                                                                                                                                                                      property isEdge

                                                                                                                                                                                                                                                      isEdge: OmitFirstArg<typeof Editor.isEdge>;

                                                                                                                                                                                                                                                        property isElementReadOnly

                                                                                                                                                                                                                                                        isElementReadOnly: (element: Element) => boolean;

                                                                                                                                                                                                                                                          property isEmpty

                                                                                                                                                                                                                                                          isEmpty: OmitFirstArg<typeof Editor.isEmpty>;

                                                                                                                                                                                                                                                            property isEnd

                                                                                                                                                                                                                                                            isEnd: OmitFirstArg<typeof Editor.isEnd>;

                                                                                                                                                                                                                                                              property isInline

                                                                                                                                                                                                                                                              isInline: OmitFirstArg<typeof Editor.isInline>;

                                                                                                                                                                                                                                                                property isNormalizing

                                                                                                                                                                                                                                                                isNormalizing: OmitFirstArg<typeof Editor.isNormalizing>;

                                                                                                                                                                                                                                                                  property isSelectable

                                                                                                                                                                                                                                                                  isSelectable: (element: Element) => boolean;

                                                                                                                                                                                                                                                                    property isStart

                                                                                                                                                                                                                                                                    isStart: OmitFirstArg<typeof Editor.isStart>;

                                                                                                                                                                                                                                                                      property isVoid

                                                                                                                                                                                                                                                                      isVoid: OmitFirstArg<typeof Editor.isVoid>;

                                                                                                                                                                                                                                                                        property last

                                                                                                                                                                                                                                                                        last: OmitFirstArg<typeof Editor.last>;

                                                                                                                                                                                                                                                                          property leaf

                                                                                                                                                                                                                                                                          leaf: OmitFirstArg<typeof Editor.leaf>;

                                                                                                                                                                                                                                                                            property levels

                                                                                                                                                                                                                                                                            levels: <T extends Node>(
                                                                                                                                                                                                                                                                            options?: EditorLevelsOptions<T>
                                                                                                                                                                                                                                                                            ) => Generator<NodeEntry<T>, void, undefined>;

                                                                                                                                                                                                                                                                              property liftNodes

                                                                                                                                                                                                                                                                              liftNodes: OmitFirstArg<typeof Transforms.liftNodes>;

                                                                                                                                                                                                                                                                                property markableVoid

                                                                                                                                                                                                                                                                                markableVoid: (element: Element) => boolean;

                                                                                                                                                                                                                                                                                  property marks

                                                                                                                                                                                                                                                                                  marks: EditorMarks | null;

                                                                                                                                                                                                                                                                                    property mergeNodes

                                                                                                                                                                                                                                                                                    mergeNodes: OmitFirstArg<typeof Transforms.mergeNodes>;

                                                                                                                                                                                                                                                                                      property move

                                                                                                                                                                                                                                                                                      move: OmitFirstArg<typeof Transforms.move>;

                                                                                                                                                                                                                                                                                        property moveNodes

                                                                                                                                                                                                                                                                                        moveNodes: OmitFirstArg<typeof Transforms.moveNodes>;

                                                                                                                                                                                                                                                                                          property next

                                                                                                                                                                                                                                                                                          next: <T extends Descendant>(
                                                                                                                                                                                                                                                                                          options?: EditorNextOptions<T>
                                                                                                                                                                                                                                                                                          ) => NodeEntry<T> | undefined;

                                                                                                                                                                                                                                                                                            property node

                                                                                                                                                                                                                                                                                            node: OmitFirstArg<typeof Editor.node>;

                                                                                                                                                                                                                                                                                              property nodes

                                                                                                                                                                                                                                                                                              nodes: <T extends Node>(
                                                                                                                                                                                                                                                                                              options?: EditorNodesOptions<T>
                                                                                                                                                                                                                                                                                              ) => Generator<NodeEntry<T>, void, undefined>;

                                                                                                                                                                                                                                                                                                property normalize

                                                                                                                                                                                                                                                                                                normalize: OmitFirstArg<typeof Editor.normalize>;

                                                                                                                                                                                                                                                                                                  property normalizeNode

                                                                                                                                                                                                                                                                                                  normalizeNode: (
                                                                                                                                                                                                                                                                                                  entry: NodeEntry,
                                                                                                                                                                                                                                                                                                  options?: {
                                                                                                                                                                                                                                                                                                  operation?: Operation;
                                                                                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                                                                                  ) => void;

                                                                                                                                                                                                                                                                                                    property onChange

                                                                                                                                                                                                                                                                                                    onChange: (options?: { operation?: Operation }) => void;

                                                                                                                                                                                                                                                                                                      property operations

                                                                                                                                                                                                                                                                                                      operations: Operation[];

                                                                                                                                                                                                                                                                                                        property parent

                                                                                                                                                                                                                                                                                                        parent: OmitFirstArg<typeof Editor.parent>;

                                                                                                                                                                                                                                                                                                          property path

                                                                                                                                                                                                                                                                                                          path: OmitFirstArg<typeof Editor.path>;

                                                                                                                                                                                                                                                                                                            property pathRef

                                                                                                                                                                                                                                                                                                            pathRef: OmitFirstArg<typeof Editor.pathRef>;

                                                                                                                                                                                                                                                                                                              property pathRefs

                                                                                                                                                                                                                                                                                                              pathRefs: OmitFirstArg<typeof Editor.pathRefs>;

                                                                                                                                                                                                                                                                                                                property point

                                                                                                                                                                                                                                                                                                                point: OmitFirstArg<typeof Editor.point>;

                                                                                                                                                                                                                                                                                                                  property pointRef

                                                                                                                                                                                                                                                                                                                  pointRef: OmitFirstArg<typeof Editor.pointRef>;

                                                                                                                                                                                                                                                                                                                    property pointRefs

                                                                                                                                                                                                                                                                                                                    pointRefs: OmitFirstArg<typeof Editor.pointRefs>;

                                                                                                                                                                                                                                                                                                                      property positions

                                                                                                                                                                                                                                                                                                                      positions: OmitFirstArg<typeof Editor.positions>;

                                                                                                                                                                                                                                                                                                                        property previous

                                                                                                                                                                                                                                                                                                                        previous: <T extends Node>(
                                                                                                                                                                                                                                                                                                                        options?: EditorPreviousOptions<T>
                                                                                                                                                                                                                                                                                                                        ) => NodeEntry<T> | undefined;

                                                                                                                                                                                                                                                                                                                          property range

                                                                                                                                                                                                                                                                                                                          range: OmitFirstArg<typeof Editor.range>;

                                                                                                                                                                                                                                                                                                                            property rangeRef

                                                                                                                                                                                                                                                                                                                            rangeRef: OmitFirstArg<typeof Editor.rangeRef>;

                                                                                                                                                                                                                                                                                                                              property rangeRefs

                                                                                                                                                                                                                                                                                                                              rangeRefs: OmitFirstArg<typeof Editor.rangeRefs>;

                                                                                                                                                                                                                                                                                                                                property removeMark

                                                                                                                                                                                                                                                                                                                                removeMark: OmitFirstArg<typeof Editor.removeMark>;

                                                                                                                                                                                                                                                                                                                                  property removeNodes

                                                                                                                                                                                                                                                                                                                                  removeNodes: OmitFirstArg<typeof Transforms.removeNodes>;

                                                                                                                                                                                                                                                                                                                                    property select

                                                                                                                                                                                                                                                                                                                                    select: OmitFirstArg<typeof Transforms.select>;

                                                                                                                                                                                                                                                                                                                                      property selection

                                                                                                                                                                                                                                                                                                                                      selection: Selection;

                                                                                                                                                                                                                                                                                                                                        property setNodes

                                                                                                                                                                                                                                                                                                                                        setNodes: <T extends Node>(
                                                                                                                                                                                                                                                                                                                                        props: Partial<T>,
                                                                                                                                                                                                                                                                                                                                        options?: {
                                                                                                                                                                                                                                                                                                                                        at?: Location;
                                                                                                                                                                                                                                                                                                                                        match?: NodeMatch<T>;
                                                                                                                                                                                                                                                                                                                                        mode?: MaximizeMode;
                                                                                                                                                                                                                                                                                                                                        hanging?: boolean;
                                                                                                                                                                                                                                                                                                                                        split?: boolean;
                                                                                                                                                                                                                                                                                                                                        voids?: boolean;
                                                                                                                                                                                                                                                                                                                                        compare?: PropsCompare;
                                                                                                                                                                                                                                                                                                                                        merge?: PropsMerge;
                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                        ) => void;

                                                                                                                                                                                                                                                                                                                                          property setNormalizing

                                                                                                                                                                                                                                                                                                                                          setNormalizing: OmitFirstArg<typeof Editor.setNormalizing>;

                                                                                                                                                                                                                                                                                                                                            property setPoint

                                                                                                                                                                                                                                                                                                                                            setPoint: OmitFirstArg<typeof Transforms.setPoint>;

                                                                                                                                                                                                                                                                                                                                              property setSelection

                                                                                                                                                                                                                                                                                                                                              setSelection: OmitFirstArg<typeof Transforms.setSelection>;

                                                                                                                                                                                                                                                                                                                                                property shouldMergeNodesRemovePrevNode

                                                                                                                                                                                                                                                                                                                                                shouldMergeNodesRemovePrevNode: OmitFirstArg<
                                                                                                                                                                                                                                                                                                                                                typeof Editor.shouldMergeNodesRemovePrevNode
                                                                                                                                                                                                                                                                                                                                                >;

                                                                                                                                                                                                                                                                                                                                                  property shouldNormalize

                                                                                                                                                                                                                                                                                                                                                  shouldNormalize: ({
                                                                                                                                                                                                                                                                                                                                                  iteration,
                                                                                                                                                                                                                                                                                                                                                  dirtyPaths,
                                                                                                                                                                                                                                                                                                                                                  operation,
                                                                                                                                                                                                                                                                                                                                                  }: {
                                                                                                                                                                                                                                                                                                                                                  iteration: number;
                                                                                                                                                                                                                                                                                                                                                  initialDirtyPathsLength: number;
                                                                                                                                                                                                                                                                                                                                                  dirtyPaths: Path[];
                                                                                                                                                                                                                                                                                                                                                  operation?: Operation;
                                                                                                                                                                                                                                                                                                                                                  }) => boolean;

                                                                                                                                                                                                                                                                                                                                                    property splitNodes

                                                                                                                                                                                                                                                                                                                                                    splitNodes: OmitFirstArg<typeof Transforms.splitNodes>;

                                                                                                                                                                                                                                                                                                                                                      property start

                                                                                                                                                                                                                                                                                                                                                      start: OmitFirstArg<typeof Editor.start>;

                                                                                                                                                                                                                                                                                                                                                        property string

                                                                                                                                                                                                                                                                                                                                                        string: OmitFirstArg<typeof Editor.string>;

                                                                                                                                                                                                                                                                                                                                                          property unhangRange

                                                                                                                                                                                                                                                                                                                                                          unhangRange: OmitFirstArg<typeof Editor.unhangRange>;

                                                                                                                                                                                                                                                                                                                                                            property unsetNodes

                                                                                                                                                                                                                                                                                                                                                            unsetNodes: OmitFirstArg<typeof Transforms.unsetNodes>;

                                                                                                                                                                                                                                                                                                                                                              property unwrapNodes

                                                                                                                                                                                                                                                                                                                                                              unwrapNodes: OmitFirstArg<typeof Transforms.unwrapNodes>;

                                                                                                                                                                                                                                                                                                                                                                property void

                                                                                                                                                                                                                                                                                                                                                                void: OmitFirstArg<typeof Editor.void>;

                                                                                                                                                                                                                                                                                                                                                                  property withoutNormalizing

                                                                                                                                                                                                                                                                                                                                                                  withoutNormalizing: OmitFirstArg<typeof Editor.withoutNormalizing>;

                                                                                                                                                                                                                                                                                                                                                                    property wrapNodes

                                                                                                                                                                                                                                                                                                                                                                    wrapNodes: OmitFirstArg<typeof Transforms.wrapNodes>;

                                                                                                                                                                                                                                                                                                                                                                      interface BaseElement

                                                                                                                                                                                                                                                                                                                                                                      interface BaseElement {}
                                                                                                                                                                                                                                                                                                                                                                      • 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.

                                                                                                                                                                                                                                                                                                                                                                      property children

                                                                                                                                                                                                                                                                                                                                                                      children: Descendant[];

                                                                                                                                                                                                                                                                                                                                                                        interface BasePoint

                                                                                                                                                                                                                                                                                                                                                                        interface BasePoint {}
                                                                                                                                                                                                                                                                                                                                                                        • 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.

                                                                                                                                                                                                                                                                                                                                                                        property offset

                                                                                                                                                                                                                                                                                                                                                                        offset: number;

                                                                                                                                                                                                                                                                                                                                                                          property path

                                                                                                                                                                                                                                                                                                                                                                          path: Path;

                                                                                                                                                                                                                                                                                                                                                                            interface BaseRange

                                                                                                                                                                                                                                                                                                                                                                            interface BaseRange {}
                                                                                                                                                                                                                                                                                                                                                                            • 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.

                                                                                                                                                                                                                                                                                                                                                                            property anchor

                                                                                                                                                                                                                                                                                                                                                                            anchor: Point;

                                                                                                                                                                                                                                                                                                                                                                              property focus

                                                                                                                                                                                                                                                                                                                                                                              focus: Point;

                                                                                                                                                                                                                                                                                                                                                                                interface BaseText

                                                                                                                                                                                                                                                                                                                                                                                interface BaseText {}
                                                                                                                                                                                                                                                                                                                                                                                • 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.

                                                                                                                                                                                                                                                                                                                                                                                property text

                                                                                                                                                                                                                                                                                                                                                                                text: string;

                                                                                                                                                                                                                                                                                                                                                                                  interface CustomTypes

                                                                                                                                                                                                                                                                                                                                                                                  interface CustomTypes {}

                                                                                                                                                                                                                                                                                                                                                                                    index signature

                                                                                                                                                                                                                                                                                                                                                                                    [key: string]: unknown;

                                                                                                                                                                                                                                                                                                                                                                                      interface EditorAboveOptions

                                                                                                                                                                                                                                                                                                                                                                                      interface EditorAboveOptions<T extends Ancestor> {}

                                                                                                                                                                                                                                                                                                                                                                                        property at

                                                                                                                                                                                                                                                                                                                                                                                        at?: Location;

                                                                                                                                                                                                                                                                                                                                                                                          property match

                                                                                                                                                                                                                                                                                                                                                                                          match?: NodeMatch<T>;

                                                                                                                                                                                                                                                                                                                                                                                            property mode

                                                                                                                                                                                                                                                                                                                                                                                            mode?: MaximizeMode;

                                                                                                                                                                                                                                                                                                                                                                                              property voids

                                                                                                                                                                                                                                                                                                                                                                                              voids?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                interface EditorAfterOptions

                                                                                                                                                                                                                                                                                                                                                                                                interface EditorAfterOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                  property distance

                                                                                                                                                                                                                                                                                                                                                                                                  distance?: number;

                                                                                                                                                                                                                                                                                                                                                                                                    property unit

                                                                                                                                                                                                                                                                                                                                                                                                    unit?: TextUnitAdjustment;

                                                                                                                                                                                                                                                                                                                                                                                                      property voids

                                                                                                                                                                                                                                                                                                                                                                                                      voids?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                        interface EditorBeforeOptions

                                                                                                                                                                                                                                                                                                                                                                                                        interface EditorBeforeOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                          property distance

                                                                                                                                                                                                                                                                                                                                                                                                          distance?: number;

                                                                                                                                                                                                                                                                                                                                                                                                            property unit

                                                                                                                                                                                                                                                                                                                                                                                                            unit?: TextUnitAdjustment;

                                                                                                                                                                                                                                                                                                                                                                                                              property voids

                                                                                                                                                                                                                                                                                                                                                                                                              voids?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                interface EditorDirectedDeletionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                interface EditorDirectedDeletionOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                  property unit

                                                                                                                                                                                                                                                                                                                                                                                                                  unit?: TextUnit;

                                                                                                                                                                                                                                                                                                                                                                                                                    interface EditorElementReadOnlyOptions

                                                                                                                                                                                                                                                                                                                                                                                                                    interface EditorElementReadOnlyOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                      property at

                                                                                                                                                                                                                                                                                                                                                                                                                      at?: Location;

                                                                                                                                                                                                                                                                                                                                                                                                                        property mode

                                                                                                                                                                                                                                                                                                                                                                                                                        mode?: MaximizeMode;

                                                                                                                                                                                                                                                                                                                                                                                                                          property voids

                                                                                                                                                                                                                                                                                                                                                                                                                          voids?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                            interface EditorFragmentDeletionOptions

                                                                                                                                                                                                                                                                                                                                                                                                                            interface EditorFragmentDeletionOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                              property direction

                                                                                                                                                                                                                                                                                                                                                                                                                              direction?: TextDirection;

                                                                                                                                                                                                                                                                                                                                                                                                                                interface EditorInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                interface EditorInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                  property above

                                                                                                                                                                                                                                                                                                                                                                                                                                  above: <T extends Ancestor>(
                                                                                                                                                                                                                                                                                                                                                                                                                                  editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: EditorAboveOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => NodeEntry<T> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the ancestor above a location in the document.

                                                                                                                                                                                                                                                                                                                                                                                                                                  property addMark

                                                                                                                                                                                                                                                                                                                                                                                                                                  addMark: (editor: Editor, key: string, value: any) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                  property after

                                                                                                                                                                                                                                                                                                                                                                                                                                  after: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                  at: Location,
                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: EditorAfterOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Point | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the point after a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                  property before

                                                                                                                                                                                                                                                                                                                                                                                                                                  before: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                  at: Location,
                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: EditorBeforeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Point | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the point before a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                  property deleteBackward

                                                                                                                                                                                                                                                                                                                                                                                                                                  deleteBackward: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: EditorDirectedDeletionOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Delete content in the editor backward from the current selection.

                                                                                                                                                                                                                                                                                                                                                                                                                                  property deleteForward

                                                                                                                                                                                                                                                                                                                                                                                                                                  deleteForward: (editor: Editor, options?: EditorDirectedDeletionOptions) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Delete content in the editor forward from the current selection.

                                                                                                                                                                                                                                                                                                                                                                                                                                  property deleteFragment

                                                                                                                                                                                                                                                                                                                                                                                                                                  deleteFragment: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: EditorFragmentDeletionOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Delete the content in the current selection.

                                                                                                                                                                                                                                                                                                                                                                                                                                  property edges

                                                                                                                                                                                                                                                                                                                                                                                                                                  edges: (editor: Editor, at: Location) => [Point, Point];
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the start and end points of a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                  property elementReadOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                  elementReadOnly: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: EditorElementReadOnlyOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => NodeEntry<Element> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Match a read-only element in the current branch of the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                  property end

                                                                                                                                                                                                                                                                                                                                                                                                                                  end: (editor: Editor, at: Location) => Point;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the end point of a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                  property first

                                                                                                                                                                                                                                                                                                                                                                                                                                  first: (editor: Editor, at: Location) => NodeEntry;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the first node at a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                  property fragment

                                                                                                                                                                                                                                                                                                                                                                                                                                  fragment: (editor: Editor, at: Location) => Descendant[];
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the fragment at a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                  property hasBlocks

                                                                                                                                                                                                                                                                                                                                                                                                                                  hasBlocks: (editor: Editor, element: Element) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Check if a node has block children.

                                                                                                                                                                                                                                                                                                                                                                                                                                  property hasInlines

                                                                                                                                                                                                                                                                                                                                                                                                                                  hasInlines: (editor: Editor, element: Element) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                  • Check if a node has inline and text children.

                                                                                                                                                                                                                                                                                                                                                                                                                                  property hasPath

                                                                                                                                                                                                                                                                                                                                                                                                                                  hasPath: (editor: Editor, path: Path) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                    property hasTexts

                                                                                                                                                                                                                                                                                                                                                                                                                                    hasTexts: (editor: Editor, element: Element) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Check if a node has text children.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property insertBreak

                                                                                                                                                                                                                                                                                                                                                                                                                                    insertBreak: (editor: Editor) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Insert a block break at the current selection.

                                                                                                                                                                                                                                                                                                                                                                                                                                      If the selection is currently expanded, it will be deleted first.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property insertFragment

                                                                                                                                                                                                                                                                                                                                                                                                                                    insertFragment: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                    fragment: Node[],
                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: TextInsertFragmentOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Inserts a fragment at the specified location or (if not defined) the current selection or (if not defined) the end of the document.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property insertNode

                                                                                                                                                                                                                                                                                                                                                                                                                                    insertNode: <T extends Node>(
                                                                                                                                                                                                                                                                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                    node: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: NodeInsertNodesOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Atomically inserts nodes at the specified location or (if not defined) the current selection or (if not defined) the end of the document.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property insertSoftBreak

                                                                                                                                                                                                                                                                                                                                                                                                                                    insertSoftBreak: (editor: Editor) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Insert a soft break at the current selection.

                                                                                                                                                                                                                                                                                                                                                                                                                                      If the selection is currently expanded, it will be deleted first.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property insertText

                                                                                                                                                                                                                                                                                                                                                                                                                                    insertText: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                    text: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: TextInsertTextOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property isBlock

                                                                                                                                                                                                                                                                                                                                                                                                                                    isBlock: (editor: Editor, value: Element) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Check if a value is a block Element object.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property isEdge

                                                                                                                                                                                                                                                                                                                                                                                                                                    isEdge: (editor: Editor, point: Point, at: Location) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Check if a point is an edge of a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property isEditor

                                                                                                                                                                                                                                                                                                                                                                                                                                    isEditor: (value: any) => value is Editor;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Check if a value is an Editor object.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property isElementReadOnly

                                                                                                                                                                                                                                                                                                                                                                                                                                    isElementReadOnly: (editor: Editor, element: Element) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Check if a value is a read-only Element object.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property isEmpty

                                                                                                                                                                                                                                                                                                                                                                                                                                    isEmpty: (editor: Editor, element: Element) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Check if an element is empty, accounting for void nodes.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property isEnd

                                                                                                                                                                                                                                                                                                                                                                                                                                    isEnd: (editor: Editor, point: Point, at: Location) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Check if a point is the end point of a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property isInline

                                                                                                                                                                                                                                                                                                                                                                                                                                    isInline: (editor: Editor, value: Element) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Check if a value is an inline Element object.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property isNormalizing

                                                                                                                                                                                                                                                                                                                                                                                                                                    isNormalizing: (editor: Editor) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Check if the editor is currently normalizing after each operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property isSelectable

                                                                                                                                                                                                                                                                                                                                                                                                                                    isSelectable: (editor: Editor, element: Element) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Check if a value is a selectable Element object.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property isStart

                                                                                                                                                                                                                                                                                                                                                                                                                                    isStart: (editor: Editor, point: Point, at: Location) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Check if a point is the start point of a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property isVoid

                                                                                                                                                                                                                                                                                                                                                                                                                                    isVoid: (editor: Editor, value: Element) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Check if a value is a void Element object.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property last

                                                                                                                                                                                                                                                                                                                                                                                                                                    last: (editor: Editor, at: Location) => NodeEntry;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get the last node at a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property leaf

                                                                                                                                                                                                                                                                                                                                                                                                                                    leaf: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                    at: Location,
                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: EditorLeafOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => NodeEntry<Text>;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get the leaf text node at a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property levels

                                                                                                                                                                                                                                                                                                                                                                                                                                    levels: <T extends Node>(
                                                                                                                                                                                                                                                                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: EditorLevelsOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Generator<NodeEntry<T>, void, undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Iterate through all of the levels at a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property marks

                                                                                                                                                                                                                                                                                                                                                                                                                                    marks: (editor: Editor) => Omit<Text, 'text'> | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get the marks that would be added to text at the current selection.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property next

                                                                                                                                                                                                                                                                                                                                                                                                                                    next: <T extends Descendant>(
                                                                                                                                                                                                                                                                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: EditorNextOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => NodeEntry<T> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get the matching node in the branch of the document after a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property node

                                                                                                                                                                                                                                                                                                                                                                                                                                    node: (editor: Editor, at: Location, options?: EditorNodeOptions) => NodeEntry;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get the node at a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property nodes

                                                                                                                                                                                                                                                                                                                                                                                                                                    nodes: <T extends Node>(
                                                                                                                                                                                                                                                                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: EditorNodesOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Generator<NodeEntry<T>, void, undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Iterate through all of the nodes in the Editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property normalize

                                                                                                                                                                                                                                                                                                                                                                                                                                    normalize: (editor: Editor, options?: EditorNormalizeOptions) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Normalize any dirty objects in the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property parent

                                                                                                                                                                                                                                                                                                                                                                                                                                    parent: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                    at: Location,
                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: EditorParentOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => NodeEntry<Ancestor>;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get the parent node of a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property path

                                                                                                                                                                                                                                                                                                                                                                                                                                    path: (editor: Editor, at: Location, options?: EditorPathOptions) => Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get the path of a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property pathRef

                                                                                                                                                                                                                                                                                                                                                                                                                                    pathRef: (editor: Editor, path: Path, options?: EditorPathRefOptions) => PathRef;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Create a mutable ref for a Path object, which will stay in sync as new operations are applied to the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property pathRefs

                                                                                                                                                                                                                                                                                                                                                                                                                                    pathRefs: (editor: Editor) => Set<PathRef>;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get the set of currently tracked path refs of the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property point

                                                                                                                                                                                                                                                                                                                                                                                                                                    point: (editor: Editor, at: Location, options?: EditorPointOptions) => Point;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get the start or end point of a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property pointRef

                                                                                                                                                                                                                                                                                                                                                                                                                                    pointRef: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                    point: Point,
                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: EditorPointRefOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => PointRef;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Create a mutable ref for a Point object, which will stay in sync as new operations are applied to the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property pointRefs

                                                                                                                                                                                                                                                                                                                                                                                                                                    pointRefs: (editor: Editor) => Set<PointRef>;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get the set of currently tracked point refs of the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property positions

                                                                                                                                                                                                                                                                                                                                                                                                                                    positions: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: EditorPositionsOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Generator<Point, void, undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property previous

                                                                                                                                                                                                                                                                                                                                                                                                                                    previous: <T extends Node>(
                                                                                                                                                                                                                                                                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: EditorPreviousOptions<T>
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => NodeEntry<T> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get the matching node in the branch of the document before a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property range

                                                                                                                                                                                                                                                                                                                                                                                                                                    range: (editor: Editor, at: Location, to?: Location) => Range;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get a range of a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property rangeRef

                                                                                                                                                                                                                                                                                                                                                                                                                                    rangeRef: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                    range: Range,
                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: EditorRangeRefOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => RangeRef;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Create a mutable ref for a Range object, which will stay in sync as new operations are applied to the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property rangeRefs

                                                                                                                                                                                                                                                                                                                                                                                                                                    rangeRefs: (editor: Editor) => Set<RangeRef>;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get the set of currently tracked range refs of the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property removeMark

                                                                                                                                                                                                                                                                                                                                                                                                                                    removeMark: (editor: Editor, key: string) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property setNormalizing

                                                                                                                                                                                                                                                                                                                                                                                                                                    setNormalizing: (editor: Editor, isNormalizing: boolean) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Manually set if the editor should currently be normalizing.

                                                                                                                                                                                                                                                                                                                                                                                                                                      Note: Using this incorrectly can leave the editor in an invalid state.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property shouldMergeNodesRemovePrevNode

                                                                                                                                                                                                                                                                                                                                                                                                                                    shouldMergeNodesRemovePrevNode: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                    prevNodeEntry: NodeEntry,
                                                                                                                                                                                                                                                                                                                                                                                                                                    curNodeEntry: NodeEntry
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Call a function, Determine whether or not remove the previous node when merge.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property start

                                                                                                                                                                                                                                                                                                                                                                                                                                    start: (editor: Editor, at: Location) => Point;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Get the start point of a location.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property string

                                                                                                                                                                                                                                                                                                                                                                                                                                    string: (editor: Editor, at: Location, options?: EditorStringOptions) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • 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

                                                                                                                                                                                                                                                                                                                                                                                                                                    property unhangRange

                                                                                                                                                                                                                                                                                                                                                                                                                                    unhangRange: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                    range: Range,
                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: EditorUnhangRangeOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Range;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Convert a range into a non-hanging one.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property void

                                                                                                                                                                                                                                                                                                                                                                                                                                    void: (
                                                                                                                                                                                                                                                                                                                                                                                                                                    editor: Editor,
                                                                                                                                                                                                                                                                                                                                                                                                                                    options?: EditorVoidOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => NodeEntry<Element> | undefined;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Match a void node in the current branch of the editor.

                                                                                                                                                                                                                                                                                                                                                                                                                                    property withoutNormalizing

                                                                                                                                                                                                                                                                                                                                                                                                                                    withoutNormalizing: (editor: Editor, fn: () => void) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                    • Call a function, deferring normalization until after it completes.

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EditorLeafOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EditorLeafOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                      property depth

                                                                                                                                                                                                                                                                                                                                                                                                                                      depth?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                        property edge

                                                                                                                                                                                                                                                                                                                                                                                                                                        edge?: LeafEdge;

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface EditorLevelsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                          interface EditorLevelsOptions<T extends Node> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                            property at

                                                                                                                                                                                                                                                                                                                                                                                                                                            at?: Location;

                                                                                                                                                                                                                                                                                                                                                                                                                                              property match

                                                                                                                                                                                                                                                                                                                                                                                                                                              match?: NodeMatch<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                property reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                reverse?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                  property voids

                                                                                                                                                                                                                                                                                                                                                                                                                                                  voids?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EditorNextOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EditorNextOptions<T extends Descendant> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                      property at

                                                                                                                                                                                                                                                                                                                                                                                                                                                      at?: Location;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        property match

                                                                                                                                                                                                                                                                                                                                                                                                                                                        match?: NodeMatch<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                          property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                          mode?: SelectionMode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            property voids

                                                                                                                                                                                                                                                                                                                                                                                                                                                            voids?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EditorNodeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EditorNodeOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                property depth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                depth?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property edge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  edge?: LeafEdge;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EditorNodesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EditorNodesOptions<T extends Node> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      at?: Location | Span;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property ignoreNonSelectable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ignoreNonSelectable?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property match

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          match?: NodeMatch<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            mode?: SelectionMode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reverse?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property universal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                universal?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property voids

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  voids?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EditorNormalizeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EditorNormalizeOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property force

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      force?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property operation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        operation?: Operation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface EditorParentOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface EditorParentOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property depth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            depth?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property edge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              edge?: LeafEdge;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface EditorPathOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface EditorPathOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property depth

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  depth?: number;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property edge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    edge?: LeafEdge;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface EditorPathRefOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface EditorPathRefOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property affinity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        affinity?: TextDirection | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface EditorPointOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface EditorPointOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property edge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            edge?: LeafEdge;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EditorPointRefOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EditorPointRefOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property affinity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                affinity?: TextDirection | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface EditorPositionsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface EditorPositionsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    at?: Location;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property ignoreNonSelectable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ignoreNonSelectable?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        reverse?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property unit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          unit?: TextUnitAdjustment;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property voids

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            voids?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EditorPreviousOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface EditorPreviousOptions<T extends Node> {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                at?: Location;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property match

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  match?: NodeMatch<T>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    mode?: SelectionMode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property voids

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      voids?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface EditorRangeRefOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface EditorRangeRefOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property affinity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          affinity?: RangeDirection | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface EditorStringOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface EditorStringOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property voids

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              voids?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface EditorUnhangRangeOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface EditorUnhangRangeOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property voids

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  voids?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EditorVoidOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface EditorVoidOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property at

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      at?: Location;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property mode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        mode?: MaximizeMode;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property voids

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          voids?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ElementInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface ElementInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isAncestor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isAncestor: (value: any) => value is Ancestor;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a value implements the 'Ancestor' interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isElement

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isElement: (value: any) => value is Element;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a value implements the Element interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isElementList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isElementList: (value: any) => value is Element[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a value is an array of Element objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isElementProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isElementProps: (props: any) => props is Partial<Element>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a set of props is a partial of Element.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isElementType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isElementType: <T extends Element>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              value: any,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              elementVal: string,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              elementKey?: string
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => value is T;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a value implements the Element interface and has elementKey with selected value. Default it check to type key value

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property matches

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              matches: (element: Element, props: Partial<Element>) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if an element matches set of properties.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Note: this checks custom properties, and it does not ensure that any children are equivalent.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LocationInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface LocationInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isLocation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isLocation: (value: any) => value is Location;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Check if a value implements the Location interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface NodeAncestorsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface NodeAncestorsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  reverse?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface NodeChildrenOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface NodeChildrenOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      reverse?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface NodeDescendantsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface NodeDescendantsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          from?: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property pass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            pass?: (node: NodeEntry) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reverse?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                to?: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NodeElementsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NodeElementsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    from?: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property pass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pass?: (node: NodeEntry) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        reverse?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          to?: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NodeInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NodeInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ancestor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ancestor: (root: Node, path: Path) => Ancestor;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the node at a specific path, asserting that it's an ancestor node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ancestors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ancestors: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              root: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: Path,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: NodeAncestorsOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Generator<NodeEntry<Ancestor>, void, undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property child

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              child: (root: Node, index: number) => Descendant;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the child of a node at a specific index.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property children

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              children: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              root: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: Path,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: NodeChildrenOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Generator<NodeEntry<Descendant>, void, undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Iterate over the children of a node at a specific path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property common

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              common: (root: Node, path: Path, another: Path) => NodeEntry;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get an entry for the common ancesetor node of two paths.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property descendant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              descendant: (root: Node, path: Path) => Descendant;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the node at a specific path, asserting that it's a descendant node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property descendants

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              descendants: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              root: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: NodeDescendantsOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Generator<NodeEntry<Descendant>, void, undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Return a generator of all the descendant node entries inside a root node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property elements

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              elements: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              root: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: NodeElementsOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Generator<ElementEntry, 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property extractProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              extractProps: (node: Node) => NodeProps;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Extract props from a Node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property first

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              first: (root: Node, path: Path) => NodeEntry;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the first node entry in a root node from a path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property fragment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              fragment: (root: Node, range: Range) => Descendant[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the sliced fragment represented by a range inside a root node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property get

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              get: (root: Node, path: Path) => Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the descendant node referred to by a specific path. If the path is an empty array, it refers to the root node itself.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property has

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              has: (root: Node, path: Path) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a descendant node exists at a specific path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isNode: (value: any) => value is Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a value implements the Node interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isNodeList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isNodeList: (value: any) => value is Node[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a value is a list of Node objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property last

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              last: (root: Node, path: Path) => NodeEntry;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the last node entry in a root node from a path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property leaf

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              leaf: (root: Node, path: Path) => Text;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the node at a specific path, ensuring it's a leaf text node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property levels

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              levels: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              root: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: Path,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: NodeLevelsOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Generator<NodeEntry, void, undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property matches

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              matches: (node: Node, props: Partial<Node>) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a node matches a set of props.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property nodes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              nodes: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              root: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: NodeNodesOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Generator<NodeEntry, void, undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parent: (root: Node, path: Path) => Ancestor;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the parent of a node at a specific path.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              string: (node: Node) => string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property texts

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              texts: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              root: Node,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: NodeTextsOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Generator<NodeEntry<Text>, void, undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Return a generator of all leaf text nodes in a root node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface NodeLevelsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface NodeLevelsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reverse?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NodeNodesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface NodeNodesOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    from?: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property pass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      pass?: (entry: NodeEntry) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        reverse?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          to?: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NodeTextsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface NodeTextsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property from

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              from?: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property pass

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                pass?: (node: NodeEntry) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  reverse?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property to

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    to?: Path;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface OperationInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface OperationInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property inverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        inverse: (op: Operation) => Operation;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Invert an operation, returning a new operation that will exactly undo the original when applied.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isNodeOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isNodeOperation: (value: any) => value is NodeOperation;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Check if a value is a NodeOperation object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isOperation: (value: any) => value is Operation;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Check if a value is an Operation object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isOperationList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isOperationList: (value: any) => value is Operation[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Check if a value is a list of Operation objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isSelectionOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isSelectionOperation: (value: any) => value is SelectionOperation;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Check if a value is a SelectionOperation object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property isTextOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        isTextOperation: (value: any) => value is TextOperation;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Check if a value is a TextOperation object.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PathAncestorsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PathAncestorsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          reverse?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PathInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface PathInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property ancestors

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ancestors: (path: Path, options?: PathAncestorsOptions) => Path[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property common

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              common: (path: Path, another: Path) => Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get the common ancestor path of two paths.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property compare

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              compare: (path: Path, another: Path) => -1 | 0 | 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property endsAfter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              endsAfter: (path: Path, another: Path) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a path ends after one of the indexes in another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property endsAt

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              endsAt: (path: Path, another: Path) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a path ends at one of the indexes in another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property endsBefore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              endsBefore: (path: Path, another: Path) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a path ends before one of the indexes in another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property equals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              equals: (path: Path, another: Path) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a path is exactly equal to another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property hasPrevious

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              hasPrevious: (path: Path) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if the path of previous sibling node exists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isAfter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isAfter: (path: Path, another: Path) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a path is after another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isAncestor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isAncestor: (path: Path, another: Path) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a path is an ancestor of another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isBefore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isBefore: (path: Path, another: Path) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a path is before another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isChild

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isChild: (path: Path, another: Path) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a path is a child of another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isCommon

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isCommon: (path: Path, another: Path) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a path is equal to or an ancestor of another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isDescendant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isDescendant: (path: Path, another: Path) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a path is a descendant of another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isParent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isParent: (path: Path, another: Path) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a path is the parent of another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isPath: (value: any) => value is Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check is a value implements the Path interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property isSibling

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              isSibling: (path: Path, another: Path) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Check if a path is a sibling of another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property levels

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              levels: (path: Path, options?: PathLevelsOptions) => Path[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property next

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              next: (path: Path) => Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Given a path, get the path to the next sibling node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property operationCanTransformPath

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              operationCanTransformPath: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              operation: Operation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => operation is
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | InsertNodeOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | RemoveNodeOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MergeNodeOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | SplitNodeOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | MoveNodeOperation;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 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

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property parent

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              parent: (path: Path) => Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Given a path, return a new path referring to the parent node above it.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property previous

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              previous: (path: Path) => Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Given a path, get the path to the previous sibling node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property relative

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              relative: (path: Path, ancestor: Path) => Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Get a path relative to an ancestor.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              transform: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: Path,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              operation: Operation,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              options?: PathTransformOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Path | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • Transform a path by an operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PathLevelsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PathLevelsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                reverse?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PathRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface PathRef {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property affinity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  affinity: 'forward' | 'backward' | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property current

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    current: Path | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method unref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      unref: () => Path | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PathRefInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PathRefInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          transform: (ref: PathRef, op: Operation) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Transform the path ref's current value by an operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PathTransformOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface PathTransformOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property affinity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            affinity?: TextDirection | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PointInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface PointInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property compare

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                compare: (point: Point, another: Point) => -1 | 0 | 1;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Compare a point to another, returning an integer indicating whether the point was before, at, or after the other.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property equals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                equals: (point: Point, another: Point) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Check if a point is exactly equal to another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isAfter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isAfter: (point: Point, another: Point) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Check if a point is after another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isBefore

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isBefore: (point: Point, another: Point) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Check if a point is before another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property isPoint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                isPoint: (value: any) => value is Point;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Check if a value implements the Point interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                transform: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                point: Point,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                op: Operation,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                options?: PointTransformOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) => Point | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • Transform a point by an operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PointRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface PointRef {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                property affinity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                affinity: TextDirection | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property current

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  current: Point | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    method unref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    unref: () => Point | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PointRefInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface PointRefInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        transform: (ref: PointRef, op: Operation) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • Transform the point ref's current value by an operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PointTransformOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface PointTransformOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property affinity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          affinity?: TextDirection | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RangeEdgesOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            interface RangeEdgesOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              property reverse

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              reverse?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface RangeInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                interface RangeInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property edges

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  edges: (range: Range, options?: RangeEdgesOptions) => [Point, Point];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the start and end points of a range, in the order in which they appear in the document.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property end

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  end: (range: Range) => Point;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the end point of a range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property equals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  equals: (range: Range, another: Range) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Check if a range is exactly equal to another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property includes

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  includes: (range: Range, target: Path | Point | Range) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Check if a range includes a path, a point or part of another range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property intersection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  intersection: (range: Range, another: Range) => Range | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the intersection of a range with another.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property isBackward

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isBackward: (range: Range) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Check if a range is backward, meaning that its anchor point appears in the document _after_ its focus point.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property isCollapsed

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isCollapsed: (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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property isExpanded

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isExpanded: (range: Range) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Check if a range is expanded.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is the opposite of [[Range.isCollapsed]] and is provided for legibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property isForward

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isForward: (range: Range) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Check if a range is forward.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    This is the opposite of [[Range.isBackward]] and is provided for legibility.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property isRange

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  isRange: (value: any) => value is Range;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Check if a value implements the [[Range]] interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property points

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  points: (range: Range) => Generator<PointEntry, void, undefined>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Iterate through all of the point entries in a range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property start

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  start: (range: Range) => Point;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Get the start point of a range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  transform: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  range: Range,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  op: Operation,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  options?: RangeTransformOptions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => Range | null;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • Transform a range by an operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RangeRef

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  interface RangeRef {}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  property affinity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  affinity: 'forward' | 'backward' | 'outward' | 'inward' | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    property current

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    current: Range | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      method unref

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      unref: () => Range | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RangeRefInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        interface RangeRefInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          property transform

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          transform: (ref: RangeRef, op: Operation) => void;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Transform the range ref's current value by an operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RangeTransformOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface RangeTransformOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property affinity

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            affinity?: RangeDirection | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ScrubberInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              interface ScrubberInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                method setScrubber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                setScrubber: (scrubber: Scrubber | undefined) => void;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  method stringify

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  stringify: (value: any) => string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SpanInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    interface SpanInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      property isSpan

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      isSpan: (value: any) => value is Span;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • Check if a value implements the Span interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TextEqualsOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      interface TextEqualsOptions {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        property loose

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        loose?: boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TextInterface

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          interface TextInterface {}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property decorations

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            decorations: (node: Text, decorations: Range[]) => Text[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Get the leaves for a text node given decorations.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property equals

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            equals: (text: Text, another: Text, options?: TextEqualsOptions) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isText

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isText: (value: any) => value is Text;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Check if a value implements the Text interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isTextList

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTextList: (value: any) => value is Text[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Check if a value is a list of Text objects.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property isTextProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            isTextProps: (props: any) => props is Partial<Text>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • Check if some props are a partial of Text.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            property matches

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            matches: (text: Text, props: Partial<Text>) => boolean;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 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.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Type Aliases

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Ancestor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Ancestor = Editor | Element;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 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 BaseInsertNodeOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type BaseInsertNodeOperation = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type: 'insert_node';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            path: Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            node: Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type BaseInsertTextOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type BaseInsertTextOperation = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'insert_text';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              offset: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              text: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type BaseMergeNodeOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type BaseMergeNodeOperation = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type: 'merge_node';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                path: Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                position: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                properties: Partial<Node>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type BaseMoveNodeOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type BaseMoveNodeOperation = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type: 'move_node';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  path: Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  newPath: Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type BaseNode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type BaseNode = Editor | Element | Text;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • The Node union type represents all of the different types of nodes that occur in a Slate document tree.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type BaseOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type BaseOperation = NodeOperation | SelectionOperation | TextOperation;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    • 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 BaseRemoveNodeOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type BaseRemoveNodeOperation = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type: 'remove_node';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    path: Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    node: Node;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type BaseRemoveTextOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type BaseRemoveTextOperation = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type: 'remove_text';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      path: Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      offset: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      text: string;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type BaseSelection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type BaseSelection = Range | null;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type BaseSetNodeOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type BaseSetNodeOperation = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type: 'set_node';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          path: Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          properties: Partial<Node>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          newProperties: Partial<Node>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type BaseSetSelectionOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            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 BaseSplitNodeOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type BaseSplitNodeOperation = {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type: 'split_node';
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              path: Path;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              position: number;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              properties: Partial<Node>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Descendant

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Descendant = Element | Text;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                • 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 Editor

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type Editor = ExtendedType<'Editor', BaseEditor>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EditorMarks

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type EditorMarks = Omit<Text, 'text'>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Element

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type Element = ExtendedType<'Element', BaseElement>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ElementEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ElementEntry = [Element, Path];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      • ElementEntry objects refer to an Element and the Path where it can be found inside a root node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ExtendedType

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type ExtendedType<K extends ExtendableTypes, B> = unknown extends CustomTypes[K]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ? B
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      : CustomTypes[K];

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type InsertNodeOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type InsertNodeOperation = ExtendedType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'InsertNodeOperation',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        BaseInsertNodeOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type InsertTextOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type InsertTextOperation = ExtendedType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'InsertTextOperation',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          BaseInsertTextOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type LeafEdge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type LeafEdge = 'start' | 'end';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Location

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Location = Path | Point | Range;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • 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 MaximizeMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type MaximizeMode = RangeMode | 'all';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MergeNodeOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type MergeNodeOperation = ExtendedType<'MergeNodeOperation', BaseMergeNodeOperation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MoveNodeOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type MoveNodeOperation = ExtendedType<'MoveNodeOperation', BaseMoveNodeOperation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MoveUnit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type MoveUnit = 'offset' | 'character' | 'word' | 'line';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Node

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type Node = Editor | Element | Text;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NodeEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NodeEntry<T extends Node = Node> = [T, Path];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • 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 NodeMatch

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NodeMatch<T extends Node> =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((node: Node, path: Path) => node is T)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | ((node: Node, path: Path) => boolean);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        • A helper type for narrowing matched nodes with a predicate.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NodeOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type NodeOperation =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | InsertNodeOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | MergeNodeOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | MoveNodeOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | RemoveNodeOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | SetNodeOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | SplitNodeOperation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NodeProps

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type NodeProps =
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Omit<Editor, 'children'>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Omit<Element, 'children'>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | Omit<Text, 'text'>;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • Convenience type for returning the props of a node.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Operation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Operation = ExtendedType<'Operation', BaseOperation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Path

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Path = number[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            • 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 Point

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Point = ExtendedType<'Point', BasePoint>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type PointEntry

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type PointEntry = [Point, 'anchor' | 'focus'];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              • PointEntry objects are returned when iterating over Point objects that belong to a range.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type PropsCompare

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type PropsCompare = (prop: Partial<Node>, node: Partial<Node>) => boolean;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type PropsMerge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type PropsMerge = (prop: Partial<Node>, node: Partial<Node>) => object;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Range

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type Range = ExtendedType<'Range', BaseRange>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RangeDirection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type RangeDirection = TextDirection | 'outward' | 'inward';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RangeMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type RangeMode = 'highest' | 'lowest';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type RemoveNodeOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type RemoveNodeOperation = ExtendedType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'RemoveNodeOperation',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        BaseRemoveNodeOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RemoveTextOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type RemoveTextOperation = ExtendedType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          'RemoveTextOperation',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          BaseRemoveTextOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Scrubber

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Scrubber = (key: string, value: unknown) => unknown;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Selection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type Selection = ExtendedType<'Selection', BaseSelection>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SelectionEdge

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type SelectionEdge = 'anchor' | 'focus' | 'start' | 'end';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SelectionMode

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type SelectionMode = 'all' | 'highest' | 'lowest';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SelectionOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type SelectionOperation = SetSelectionOperation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SetNodeOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type SetNodeOperation = ExtendedType<'SetNodeOperation', BaseSetNodeOperation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SetSelectionOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type SetSelectionOperation = ExtendedType<
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        'SetSelectionOperation',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        BaseSetSelectionOperation
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        >;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Span

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Span = [Path, Path];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          • 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 SplitNodeOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type SplitNodeOperation = ExtendedType<'SplitNodeOperation', BaseSplitNodeOperation>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Text

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type Text = ExtendedType<'Text', BaseText>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TextDirection

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TextDirection = 'forward' | 'backward';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TextOperation

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TextOperation = InsertTextOperation | RemoveTextOperation;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TextUnit

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  type TextUnit = 'character' | 'word' | 'line' | 'block';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TextUnitAdjustment

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    type TextUnitAdjustment = TextUnit | 'offset';

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package Files (96)