@lofcz/platejs-core 52.3.4 → 52.3.6

package/dist/{index-NTp--CEF.d.ts → index-CLvWpTKx.d.ts}

@@ -1,19 +1,13 @@
 import * as _platejs_slate1 from "@platejs/slate";
 import { Ancestor, DOMRange, DecoratedRange, Descendant, Editor, EditorAboveOptions, EditorApi, EditorBase, EditorTransforms, LeafPosition, NodeEntry, NodeOf, NodeOperation, Operation, Path, QueryNodeOptions, ScrollIntoViewOptions, TElement, TNode, TRange, TSelection, TText, TextOperation, Value } from "@platejs/slate";
 import { nanoid as nanoid$1 } from "nanoid";
-import { AnyObject, Deep2Partial, Modify, Nullable, OmitFirst, Simplify, UnionToIntersection, UnknownObject } from "@udecode/utils";
+import { AnyObject, Deep2Partial, Modify, Nullable, OmitFirst, UnionToIntersection, UnknownObject } from "@udecode/utils";
 import { createVanillaStore, createVanillaStore as createZustandStore$1 } from "zustand-x/vanilla";
 import { KeyboardEventLike, isHotkey } from "is-hotkey";
-import * as slate0 from "slate";
-import { EditorPathOptions, EditorPointOptions, NodeEntry as NodeEntry$1, Selection } from "slate";
+import { NodeEntry as NodeEntry$1 } from "slate";
 import React$1, { JSX } from "react";
 import { TStateApi, TStateApi as ZustandStoreApi } from "zustand-x";
 import { Draft } from "mutative";
-import * as slate_dom0 from "slate-dom";
-import { DOMEditor, DOMNode, DOMPoint, DOMRange as DOMRange$1 } from "slate-dom";
-import { StandardBehaviorOptions } from "scroll-into-view-if-needed";
-import { EditorFragmentDeletionOptions, EditorPathRefOptions, EditorPointRefOptions, EditorRangeRefOptions } from "slate/dist/interfaces/editor";
-import { SelectionCollapseOptions, SelectionMoveOptions, SelectionSetPointOptions } from "slate/dist/interfaces/transforms/selection";
 
 //#region src/lib/plugins/AstPlugin.d.ts
 /**
@@ -62,22 +56,26 @@ declare function BaseElementStatic({
   decorate,
   decorations,
   editor,
-  element
+  element,
+  path
 }: {
   decorate: EditableProps['decorate'];
   decorations: DecoratedRange[];
   editor: SlateEditor;
   element: TElement;
+  path: Path;
   style?: React$1.CSSProperties;
 }): React$1.JSX.Element;
 declare const ElementStatic: React$1.MemoExoticComponent<typeof BaseElementStatic>;
 declare function BaseLeafStatic({
   decorations,
   editor,
+  path,
   text
 }: {
   decorations: DecoratedRange[];
   editor: SlateEditor;
+  path: Path;
   text: TText;
 }): React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>> | undefined;
 declare const LeafStatic: React$1.MemoExoticComponent<typeof BaseLeafStatic>;
@@ -198,1725 +196,13 @@ declare const createStaticEditor: <V extends Value = Value, P extends AnyPluginC
   ...options
 }?: CreateStaticEditorOptions<V, P>) => TSlateEditor<V, P>;
 //#endregion
-//#region ../slate/dist/index.d.ts
-//#region src/internal/dom-editor/findDocumentOrShadowRoot.d.ts
-declare const findDocumentOrShadowRoot: (editor: Editor$1) => Document | ShadowRoot | undefined;
-//#endregion
-//#region src/internal/dom-editor/findEventRange.d.ts
-declare const findEventRange: (editor: Editor$1, event: any) => slate0.BaseRange | undefined;
-//#endregion
-//#region src/internal/dom-editor/findKey.d.ts
-declare const findKey: (editor: Editor$1, node: TNode$1) => slate_dom0.Key | undefined;
-//#endregion
-//#region src/internal/dom-editor/getWindow.d.ts
-declare const getWindow: (editor: Editor$1) => Window | undefined;
-//#endregion
-//#region src/internal/dom-editor/hasDOMNode.d.ts
-declare const hasDOMNode: (editor: Editor$1, target: DOMNode, options?: Parameters<typeof DOMEditor.hasDOMNode>[2]) => boolean;
-//#endregion
-//#region src/internal/dom-editor/hasRange.d.ts
-declare const hasRange: (editor: Editor$1, range: TRange$1) => boolean;
-//#endregion
-//#region src/internal/dom-editor/isComposing.d.ts
-declare const isComposing: (editor: Editor$1) => boolean;
-//#endregion
-//#region src/internal/dom-editor/isFocused.d.ts
-declare const isFocused: (editor: Editor$1) => boolean;
-//#endregion
-//#region src/internal/dom-editor/isReadOnly.d.ts
-declare const isReadOnly: (editor: Editor$1) => boolean;
-//#endregion
-//#region src/internal/dom-editor/isTargetInsideNonReadonlyVoid.d.ts
-declare const isTargetInsideNonReadonlyVoid: (editor: Editor$1, target: EventTarget | null) => boolean;
-//#endregion
-//#region src/types.d.ts
-type At = TLocation | TNode$1;
-type AtOrDescendant = Descendant$1 | TLocation;
-type LeafEdge = 'end' | 'start';
-type TextUnit = 'block' | 'character' | 'line' | 'word';
-type TextUnitAdjustment = TextUnit | 'offset';
-type TSelection$1 = Selection;
-//#endregion
-//#region src/interfaces/point.d.ts
-type Point = {
-  /** The index of the character in the text node. */
-  offset: number;
-  /** The path to the text node. */
-  path: Path$2;
-};
-/** Point retrieval, check and transform methods. */
-
-//#endregion
-//#region src/interfaces/range.d.ts
-/**
- * `TRange` objects are a set of points that refer to a specific span of a Slate
- * document. They can define a span inside a single node or a can span across
- * multiple nodes.
- */
-type TRange$1 = {
-  /** The start point of the range. */
-  anchor: Point;
-  /** The end point of the range. */
-  focus: Point;
-};
-//#endregion
-//#region src/interfaces/operation.d.ts
-/**
- * `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 Operation$1<N$1 extends Descendant$1 = Descendant$1> = NodeOperation$1<N$1> | SelectionOperation | TextOperation$1;
-/** Operation manipulation and check methods. */
-
-type InsertNodeOperation<N$1 extends Descendant$1 = Descendant$1> = {
-  [key: string]: unknown;
-  node: N$1;
-  path: Path$2;
-  type: 'insert_node';
-};
-type InsertTextOperation = {
-  [key: string]: unknown;
-  offset: number;
-  path: Path$2;
-  text: string;
-  type: 'insert_text';
-};
-type MergeNodeOperation<N$1 extends Descendant$1 = Descendant$1> = {
-  [key: string]: unknown;
-  path: Path$2;
-  position: number;
-  properties: Partial<NodeProps<N$1>>;
-  type: 'merge_node';
-};
-type MoveNodeOperation = {
-  [key: string]: unknown;
-  newPath: Path$2;
-  path: Path$2;
-  type: 'move_node';
-};
-type NodeOperation$1<N$1 extends Descendant$1 = Descendant$1> = InsertNodeOperation<N$1> | MergeNodeOperation<N$1> | MoveNodeOperation | RemoveNodeOperation<N$1> | SetNodeOperation<N$1> | SplitNodeOperation<N$1>;
-type RemoveNodeOperation<N$1 extends Descendant$1 = Descendant$1> = {
-  [key: string]: unknown;
-  node: N$1;
-  path: Path$2;
-  type: 'remove_node';
-};
-type RemoveTextOperation = {
-  [key: string]: unknown;
-  offset: number;
-  path: Path$2;
-  text: string;
-  type: 'remove_text';
-};
-type SelectionOperation = SetSelectionOperation;
-type SetNodeOperation<N1 extends Descendant$1 = Descendant$1, N2 extends Descendant$1 = Descendant$1> = {
-  [key: string]: unknown;
-  newProperties: Partial<NodeProps<N1>>;
-  path: Path$2;
-  properties: Partial<NodeProps<N2>>;
-  type: 'set_node';
-};
-type SetSelectionOperation = {
-  [key: string]: unknown;
-  newProperties: null;
-  properties: TRange$1;
-  type: 'set_selection';
-} | {
-  [key: string]: unknown;
-  newProperties: Partial<TRange$1>;
-  properties: Partial<TRange$1>;
-  type: 'set_selection';
-} | {
-  [key: string]: unknown;
-  newProperties: TRange$1;
-  properties: null;
-  type: 'set_selection';
-};
-type SplitNodeOperation<N$1 extends Descendant$1 = Descendant$1> = {
-  [key: string]: unknown;
-  path: Path$2;
-  position: number;
-  properties: Partial<NodeProps<N$1>>;
-  type: 'split_node';
-};
-type TextOperation$1 = InsertTextOperation | RemoveTextOperation;
-//#endregion
-//#region src/interfaces/path.d.ts
-/**
- * `Path` arrays are a list of indexes that describe a node's exact position in
- * a Slate node tree. Although they are usually relative to the root `Editor`
- * object, they can be relative to any `Node` object.
- */
-type Path$2 = number[];
-/** Path retrieval, check and transform methods. */
-
-/**
- * `TText` 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.
- */
-type TText$1 = {
-  text: string;
-} & UnknownObject;
-/** Text retrieval and check methods. */
-
-type MarksIn<V extends Value$1> = MarksOf<V[number]>;
-type MarksOf<N$1 extends TNode$1> = Simplify<UnionToIntersection<NodeProps<TextOf<N$1>>>>;
-/** A utility type to get all the text node types from a root node type. */
-type TextIn<V extends Value$1> = TextOf<V[number]>;
-type TextOf<N$1 extends TNode$1> = Editor$1 extends N$1 ? TText$1 : TElement$1 extends N$1 ? TText$1 : N$1 extends Editor$1 ? TextOf<N$1['children'][number]> : N$1 extends TElement$1 ? Extract<N$1['children'][number], TText$1> | TextOf<N$1['children'][number]> : N$1 extends TText$1 ? N$1 : never;
-//#endregion
-//#region src/interfaces/node-entry.d.ts
-/** Ancestor entry from a node. */
-
-/**
- * `NodeEntry` objects are returned when iterating over the nodes in a Slate
- * document tree. They consist of the node and its `Path` relative to the root
- * node in the document.
- */
-type NodeEntry$2<N$1 extends TNode$1 = TNode$1> = [N$1, Path$2];
-/** Node entry from an editor. */
-
-/**
- * The `Descendant` union type represents nodes that are descendants in the
- * tree. It is returned as a convenience in certain cases to narrow a value
- * further than the more generic `Node` union.
- */
-type Descendant$1 = TElement$1 | TText$1;
-/** Convenience type for returning the props of a node. */
-type NodeProps<N$1 extends TNode$1 = TNode$1> = N$1 extends Editor$1 ? Omit<N$1, 'children'> : N$1 extends TElement$1 ? Omit<N$1, 'children'> : Omit<N$1, 'text'>;
-/**
- * The `TNode` union type represents all of the different types of nodes that
- * occur in a Slate document tree.
- */
-type TNode$1 = Editor$1 | TElement$1 | TText$1;
-/** A utility type to get all the ancestor node types from a root node type. */
-type AncestorIn<V extends Value$1> = AncestorOf<Editor$1 | V[number]>;
-type AncestorOf<N$1 extends TNode$1> = Editor$1 extends N$1 ? Editor$1 | TElement$1 : TElement$1 extends N$1 ? TElement$1 : N$1 extends Editor$1 ? ElementOf<N$1['children'][number]> | N$1 | N$1['children'][number] : N$1 extends TElement$1 ? ElementOf<N$1> | N$1 : never;
-/** A utility type to get the child node types from a root node type. */
-
-/** A utility type to get all the descendant node types from a root node type. */
-type DescendantIn$1<V extends Value$1> = DescendantOf<V[number]>;
-type DescendantOf<N$1 extends TNode$1> = N$1 extends Editor$1 ? ElementOf<N$1> | TextOf<N$1> : N$1 extends TElement$1 ? ElementOf<N$1['children'][number]> | TextOf<N$1> : never;
-/**
- * The `Node` union type represents all of the different types of nodes that
- * occur in a Slate document tree.
- */
-
-/** A utility type to get all possible node types from a Value type */
-type NodeIn<V extends Value$1> = NodeOf$1<Editor$1 | V[number]>;
-/** A utility type to get all the node types from a root node type. */
-type NodeOf$1<N$1 extends TNode$1> = ElementOf<N$1> | N$1 | TextOf<N$1>;
-//#endregion
-//#region src/internal/dom-editor/toDOMNode.d.ts
-declare const toDOMNode: (editor: Editor$1, node: TNode$1) => HTMLElement | undefined;
-//#endregion
-//#region src/internal/dom-editor/toDOMPoint.d.ts
-declare const toDOMPoint: (editor: Editor$1, point: Point) => slate_dom0.DOMPoint | undefined;
-//#endregion
-//#region src/internal/dom-editor/toDOMRange.d.ts
-declare const toDOMRange: (editor: Editor$1, range: TRange$1) => Range | undefined;
-//#endregion
-//#region src/internal/dom-editor/toSlateNode.d.ts
-declare const toSlateNode: (editor: Editor$1, domNode: DOMNode) => TNode$1 | undefined;
-//#endregion
-//#region src/internal/dom-editor/toSlatePoint.d.ts
-declare const toSlatePoint: (editor: Editor$1, domPoint: DOMPoint, options: Omit<Parameters<typeof DOMEditor.toSlatePoint>[2], "suppressThrow">) => slate0.BasePoint | null | undefined;
-//#endregion
-//#region src/internal/dom-editor/toSlateRange.d.ts
-declare const toSlateRange: (editor: Editor$1, domRange: Parameters<typeof DOMEditor.toSlateRange>[1], options: Omit<Parameters<typeof DOMEditor.toSlateRange>[2], "supressThrow">) => slate0.BaseRange | null | undefined;
-//#endregion
-//#region src/internal/editor/createPathRef.d.ts
-declare const createPathRef: (editor: Editor$1, at: Path$2, options?: EditorPathRefOptions) => slate0.PathRef;
-//#endregion
-//#region src/internal/editor/createPointRef.d.ts
-declare const createPointRef: (editor: Editor$1, point: Point, options?: EditorPointRefOptions) => slate0.PointRef;
-//#endregion
-//#region src/internal/editor/createRangeRef.d.ts
-declare const createRangeRef: (editor: Editor$1, range: TRange$1, options?: EditorRangeRefOptions) => slate0.RangeRef;
-//#endregion
-//#region src/internal/editor/editor-path.d.ts
-declare const path$1: (editor: Editor$1, at: At, options?: EditorPathOptions) => slate0.Path | undefined;
-//#endregion
-//#region src/internal/editor/getEdgePoints.d.ts
-declare const getEdgePoints: (editor: Editor$1, at: At) => [slate0.BasePoint, slate0.BasePoint] | undefined;
-//#endregion
-//#region src/internal/editor/getEditorString.d.ts
-declare const getEditorString: (editor: Editor$1, at?: At | null, options?: EditorStringOptions) => string;
-//#endregion
-//#region src/internal/editor/getEndPoint.d.ts
-declare const getEndPoint: (editor: Editor$1, at: At, options?: EditorEndOptions) => slate0.BasePoint | undefined;
-//#endregion
-//#region src/internal/editor/getPathRefs.d.ts
-declare const getPathRefs: (editor: Editor$1) => Set<slate0.PathRef>;
-//#endregion
-//#region src/internal/editor/getPoint.d.ts
-declare const getPoint: (editor: Editor$1, at: At, options?: EditorPointOptions) => slate0.BasePoint | undefined;
-//#endregion
-//#region src/internal/editor/getPointAfter.d.ts
-declare const getPointAfter: (editor: Editor$1, at: At, options?: EditorAfterOptions) => slate0.BasePoint | undefined;
-//#endregion
-//#region src/internal/editor/getPointBefore.d.ts
-declare const getPointBefore: (editor: Editor$1, at: At, options?: EditorBeforeOptions) => Point | undefined;
-//#endregion
-//#region src/internal/editor/getPointRefs.d.ts
-declare const getPointRefs: (editor: Editor$1) => Set<slate0.PointRef>;
-//#endregion
-//#region src/internal/editor/getPositions.d.ts
-declare const getPositions: (editor: Editor$1, options?: EditorPositionsOptions) => Generator<slate0.BasePoint, void, undefined>;
-//#endregion
-//#region src/internal/editor/getRangeRefs.d.ts
-declare const getRangeRefs: (editor: Editor$1) => Set<slate0.RangeRef>;
-//#endregion
-//#region src/internal/editor/getStartPoint.d.ts
-declare const getStartPoint: (editor: Editor$1, at: At, options?: EditorStartOptions) => slate0.BasePoint | undefined;
-//#endregion
-//#region src/internal/editor/hasBlocks.d.ts
-declare const hasBlocks$1: (editor: Editor$1, element: TElement$1) => boolean;
-//#endregion
-//#region src/internal/editor/hasInlines.d.ts
-declare const hasInlines$1: (editor: Editor$1, element: TElement$1) => boolean;
-//#endregion
-//#region src/internal/editor/hasTexts.d.ts
-declare const hasTexts$1: (editor: Editor$1, element: TElement$1) => boolean;
-//#endregion
-//#region src/internal/editor/isBlock.d.ts
-declare const isBlock$1: (editor: Editor$1, value: any) => value is TElement$1;
-//#endregion
-//#region src/internal/editor/isEdgePoint.d.ts
-declare const isEdgePoint: (editor: Editor$1, point: Point, at: TLocation) => boolean;
-//#endregion
-//#region src/internal/editor/isEditorNormalizing.d.ts
-declare const isEditorNormalizing: (editor: Editor$1) => boolean;
-//#endregion
-//#region src/internal/editor/isElementReadOnly.d.ts
-declare const isElementReadOnly: <E extends Editor$1 = Editor$1>(editor: E, options?: EditorElementReadOnlyOptions) => slate0.NodeEntry<slate0.BaseElement> | undefined;
-//#endregion
-//#region src/internal/editor/isEmpty.d.ts
-declare const isEmpty$1: <E extends Editor$1>(editor: E, target?: At | null, options?: EditorEmptyOptions) => boolean;
-//#endregion
-//#region src/internal/editor/isEndPoint.d.ts
-declare const isEndPoint: (editor: Editor$1, point: Point | null | undefined, at: TLocation) => boolean;
-//#endregion
-//#region src/internal/editor/isStartPoint.d.ts
-declare const isStartPoint: (editor: Editor$1, point: Point | null | undefined, at: TLocation) => boolean;
-//#endregion
-//#region src/internal/editor/range.d.ts
-declare const range$1: (editor: Editor$1, at: At | "before" | "start", to?: At | null, options?: {
-  before?: EditorBeforeOptions;
-}) => TRange$1 | undefined;
-//#endregion
-//#region src/internal/editor/unhangRange.d.ts
-declare const unhangRange$1: (editor: Editor$1, range: TRange$1, options?: EditorUnhangRangeOptions) => TRange$1;
-//#endregion
-//#region src/internal/editor-extension/hasMark.d.ts
-declare const hasMark: (editor: Editor$1, key: string) => boolean;
-//#endregion
-//#region src/internal/editor-extension/isAt.d.ts
-/**
- * Check if a location (point/range) is at a specific position.
- *
- * For ranges:
- *
- * - If text=true, check if range is in single text node
- * - If block=true, check if range is in single block
- * - If blocks=true, check if range is across multiple blocks
- * - If start=true, check if range starts at block start
- * - If end=true, check if range ends at block end
- *
- * For points:
- *
- * - If word=true, check relative to word boundaries
- * - If start=true, check if at start
- * - If end=true, check if at end
- */
-declare const isAt: <E extends Editor$1>(editor: E, {
-  at,
-  block,
-  blocks,
-  end,
-  start,
-  text,
-  word,
-  ...options
-}?: {
-  /** The location to check. Defaults to current selection */
-  at?: TLocation | null;
-  /** Check if range is in single block */
-  block?: boolean;
-  /** Check if range is across multiple blocks */
-  blocks?: boolean;
-  /** Check if range ends at block end or point is at word end */
-  end?: boolean;
-  /** Check if range starts at block start */
-  start?: boolean;
-  /** Check if range is in single text node */
-  text?: boolean;
-  /** Check if point is at word boundary (only with end=true) */
-  word?: boolean;
-} & Omit<EditorAboveOptions$1<ValueOf$1<E>>, "at" | "block">) => boolean;
-//#endregion
-//#region src/internal/editor-extension/isText.d.ts
-/** Check if a node at a location is a Text node */
-declare const isText$1: (editor: Editor$1, at: At) => boolean;
-//#endregion
-//#region src/interfaces/scroll.d.ts
-type ScrollIntoViewOptions$1 = StandardBehaviorOptions | boolean;
-//#endregion
-//#region src/internal/editor-extension/scrollIntoView.d.ts
-declare function scrollIntoView(editor: Editor$1, target: DOMRange$1 | Point, options?: ScrollIntoViewOptions$1): void;
-//#endregion
-//#region src/internal/editor-extension/some.d.ts
-/**
- * Iterate through all of the nodes in the editor and break early for the first
- * truthy match. Otherwise returns false.
- */
-declare const some: <E extends Editor$1 = Editor$1>(editor: E, options: EditorNodesOptions<ValueOf$1<E>>) => boolean;
-//#endregion
-//#region src/slate-history/with-history.d.ts
-/**
- * The `withHistory` plugin keeps track of the operation history of a Slate
- * editor as operations are applied to it, using undo and redo stacks.
- */
-
-//#endregion
-//#region src/utils/match.d.ts
-type Predicate<T extends TNode$1> = PredicateFn<T> | PredicateObj;
-type PredicateFn<T extends TNode$1> = (obj: T, path: Path$2) => boolean;
-type PredicateObj = Record<string, any[] | any>;
-/**
- * Match the object with a predicate object or function. If predicate is:
- *
- * - Object: every predicate key/value should be in obj.
- * - Function: it should return true.
- */
-
-//#endregion
-//#region src/utils/queryNode.d.ts
-/** Filter nodes. */
-type QueryNodeOptions$1 = {
-  /** List of types that are valid. If empty or undefined - allow all. */
-  allow?: string[] | string | null;
-  /** List of types that are invalid. */
-  exclude?: string[] | string | null;
-  /** Query the node entry. */
-  filter?: <N$1 extends TNode$1>(entry: NodeEntry$2<N$1>) => boolean;
-  /** Valid path levels. */
-  level?: number[] | number | null;
-  /** Paths above that value are invalid. */
-  maxLevel?: number | null;
-};
-/** Query the node entry. */
-
-//#endregion
-//#region src/interfaces/location.d.ts
-/**
- * The `TLocation` 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 `TRange`. This eliminates the need for developers to manage
- * converting between the different interfaces in their own code base.
- */
-type TLocation = Path$2 | Point | TRange$1;
-/** Location check methods. */
-
-/**
- * The `Span` interface is a low-level way to refer to locations in nodes
- * without using `Point` which requires leaf text nodes to be present.
- */
-type Span$1 = [Path$2, Path$2];
-//#endregion
-//#region src/interfaces/editor/editor-api.d.ts
-type EditorAboveOptions$1<V extends Value$1 = Value$1> = QueryOptions<V> & QueryMode & QueryVoids;
-type EditorAfterOptions = {
-  distance?: number;
-} & QueryTextUnit & QueryVoids;
-type EditorApi$1<V extends Value$1 = Value$1> = {
-  /** Get the fragment at a location or selection. */
-  fragment: <N$1 extends ElementOrTextIn<V>>(at?: At | null, options?: EditorFragmentOptions) => N$1[];
-  /** Get the dirty paths of the editor. */
-  getDirtyPaths: <N$1 extends DescendantIn$1<V>>(operation: Operation$1<N$1>) => Path$2[];
-  /**
-   * Returns the fragment at the current selection. Used when cutting or
-   * copying, as an example, to get the fragment at the current selection.
-   */
-  getFragment: (at?: At) => ElementOrTextIn<V>[];
-  /** Check if a value is a read-only `Element` object. */
-  isElementReadOnly: <N$1 extends ElementIn<V>>(element: N$1) => boolean;
-  /** Check if a path is selected by the current selection. */
-  isSelected: (target: Path$2 | TRange$1, options?: EditorIsSelectedOptions) => boolean;
-  /** Check if a value is a void `Element` object. */
-  isVoid: <N$1 extends ElementIn<V>>(element: N$1) => boolean;
-  /** Check if a value is a markable `Element` object. */
-  markableVoid: <N$1 extends ElementIn<V>>(element: N$1) => boolean;
-  /**
-   * Manually set if the editor should currently be normalizing. Note: Using
-   * this incorrectly can leave the editor in an invalid state.
-   */
-  setNormalizing: (isNormalizing: boolean) => void;
-  /** Whether nodes should be merged. */
-  shouldMergeNodes: (prevNodeEntry: NodeEntry$2, curNodeEntry: NodeEntry$2, options?: {
-    reverse?: boolean;
-  }) => boolean;
-  /** Override this method to prevent normalizing the editor. */
-  shouldNormalize: (options: {
-    dirtyPaths: Path$2[];
-    initialDirtyPathsLength: number;
-    iteration: number;
-    operation?: Operation$1;
-  }) => boolean;
-  /**
-   * Override this method to prevent normalizing a specific node. Defaults to
-   * returning `true`.
-   */
-  shouldNormalizeNode: (entry: NodeEntry$2) => boolean;
-  /** Called when there is a change in the editor. */
-  onChange: (options?: {
-    operation?: Operation$1;
-  }) => void;
-} & {
-  /**
-   * Get the point after a location.
-   *
-   * If there is no point after the location (e.g. we are at the bottom of the
-   * document) returns `undefined`.
-   */
-  after: OmitFirst<typeof getPointAfter>;
-  /**
-   * Returns the point before a location with optional matching criteria.
-   *
-   * If there is no point before the location (e.g. we are at the top of the
-   * document) returns `undefined`.
-   */
-  before: OmitFirst<typeof getPointBefore>;
-  /** Get the start and end points of a location. */
-  edges: OmitFirst<typeof getEdgePoints>;
-  /** Check if an element is read-only. */
-  elementReadOnly: OmitFirst<typeof isElementReadOnly>;
-  /** Get the end point of a location. */
-  end: OmitFirst<typeof getEndPoint>;
-  /** Check if a node has block children. */
-  hasBlocks: OmitFirst<typeof hasBlocks$1>;
-  /** Check if a node has inline and text children. */
-  hasInlines: OmitFirst<typeof hasInlines$1>;
-  /** Check if mark is active at selection */
-  hasMark: OmitFirst<typeof hasMark>;
-  /** Check if a node has text children. */
-  hasTexts: OmitFirst<typeof hasTexts$1>;
-  /** Check if a value is a block `Element` object. */
-  isBlock: OmitFirst<typeof isBlock$1>;
-  /** Check if a point is an edge of a location. */
-  isEdge: OmitFirst<typeof isEdgePoint>;
-  /**
-   * Check if an element is empty, accounting for void nodes.
-   *
-   * @example
-   *   ```ts
-   *   editor.api.isEmpty() // Check if editor is empty
-   *   editor.api.isEmpty(at) // Check if nodes at location are empty
-   *   editor.api.isEmpty(at, { after: true }) // Check if text after location is empty
-   *   editor.api.isEmpty(at, { block: true }) // Check if block above location is empty
-   *   ```;
-   */
-  isEmpty: OmitFirst<typeof isEmpty$1>;
-  /** Check if a point is the end point of a location. */
-  isEnd: OmitFirst<typeof isEndPoint>;
-  /** Check if the editor is currently normalizing after each operation. */
-  isNormalizing: OmitFirst<typeof isEditorNormalizing>;
-  /** Check if a point is the start point of a location. */
-  isStart: OmitFirst<typeof isStartPoint>;
-  /** Get the path of a location. */
-  path: OmitFirst<typeof path$1>;
-  /**
-   * Create a mutable ref for a `Path` object, which will stay in sync as new
-   * operations are applied to the editor.
-   */
-  pathRef: OmitFirst<typeof createPathRef>;
-  /** Get the set of currently tracked path refs of the editor. */
-  pathRefs: OmitFirst<typeof getPathRefs>;
-  /** Get the `start` or `end` (default is `start`) point of a location. */
-  point: OmitFirst<typeof getPoint>;
-  /**
-   * Create a mutable ref for a `Point` object, which will stay in sync as new
-   * operations are applied to the editor.
-   */
-  pointRef: OmitFirst<typeof createPointRef>;
-  /** Get the set of currently tracked point refs of the editor. */
-  pointRefs: OmitFirst<typeof getPointRefs>;
-  /**
-   * Iterate through all of the positions in the document where a `Point` can be
-   * placed. The first `Point` returns is always the starting point followed by
-   * the next `Point` as determined by the `unit` option. Note: By default void
-   * nodes are treated as a single point and iteration will not happen inside
-   * their content unless the voids option is set, then iteration will occur.
-   */
-  positions: OmitFirst<typeof getPositions>;
-  /**
-   * Get a range from a location to another location.
-   *
-   * @example
-   *   ```ts
-   *   editor.api.range(at, to) // From a location to another location
-   *   editor.api.range('start', at) // From block start to a location
-   *   editor.api.range('before', at, { before }) // From the point before a location
-   *   ```;
-   */
-  range: OmitFirst<typeof range$1>;
-  /**
-   * Create a mutable ref for a `TRange` object, which will stay in sync as new
-   * operations are applied to the editor.
-   */
-  rangeRef: OmitFirst<typeof createRangeRef>;
-  /** Get the set of currently tracked range refs of the editor. */
-  rangeRefs: OmitFirst<typeof getRangeRefs>;
-  /** Get the start point of a location. */
-  start: OmitFirst<typeof getStartPoint>;
-  /**
-   * 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.
-   *
-   * @example
-   *   ```ts
-   *   editor.api.string() // Get selection string
-   *   editor.api.string([]) // Get whole editor string
-   *   editor.api.string(at) // Get string at location
-   *   ```;
-   */
-  string: OmitFirst<typeof getEditorString>;
-  /**
-   * Convert a range into a non-hanging one.
-   *
-   * A "hanging" range is one created by the browser's "triple-click" selection
-   * behavior. When triple-clicking a block, the browser selects from the start
-   * of that block to the start of the _next_ block. The range thus "hangs over"
-   * into the next block. If `unhangRange` is given such a range, it moves the
-   * end backwards until it's in a non-empty text node that precedes the hanging
-   * block.
-   *
-   * Note that `unhangRange` is designed for the specific purpose of fixing
-   * triple-clicked blocks, and therefore currently has a number of caveats:
-   *
-   * - It does not modify the start of the range; only the end. For example, it
-   *   does not "unhang" a selection that starts at the end of a previous
-   *   block.
-   * - It only does anything if the start block is fully selected. For example, it
-   *   does not handle ranges created by double-clicking the end of a paragraph
-   *   (which browsers treat by selecting from the end of that paragraph to the
-   *   start of the next).
-   */
-  unhangRange: OmitFirst<typeof unhangRange$1>;
-  /** Get the matching ancestor above a location in the document. */
-  above: <N$1 extends AncestorIn<V>>(options?: EditorAboveOptions$1<V>) => NodeEntry$2<N$1> | undefined;
-  /** Get the first node at a location. */
-  first: <N$1 extends DescendantIn$1<V>>(at: At) => NodeEntry$2<N$1> | undefined;
-  /** Get the fragment at a location. */
-  fragment: <N$1 extends ElementOrTextIn<V>>(at: At) => N$1[] | undefined;
-  /** Check if a path exists in the editor. */
-  hasPath: (path: Path$2) => boolean;
-  /** Get the last node at a location. */
-  last: <N$1 extends DescendantIn$1<V>>(at: At, options?: EditorLastOptions) => NodeEntry$2<N$1> | undefined;
-  /** Get the leaf text node at a location. */
-  leaf: <N$1 extends TextIn<V>>(at: At, options?: EditorLeafOptions) => NodeEntry$2<N$1> | undefined;
-  /** Iterate through all of the levels at a location. */
-  levels: <N$1 extends NodeIn<V>>(options?: EditorLevelsOptions<V>) => Generator<NodeEntry$2<N$1>, void, undefined>;
-  /** Get the marks that would be added to text at the current selection. */
-  marks: () => MarksIn<V> | null;
-  /**
-   * Get the matching node in the branch of the document after a location.
-   *
-   * Note: To find the next Point, and not the next Node, use the `Editor.after`
-   * method
-   */
-  next: <N$1 extends DescendantIn$1<V>>(options?: EditorNextOptions<V>) => NodeEntry$2<N$1> | undefined;
-  /**
-   * Get the node at a location or find the first node that matches options.
-   *
-   * @example
-   *   ```ts
-   *   editor.api.node([0]) // Get node at path [0]
-   *   editor.api.node({ at: [], id: '1' }) // Find first node with id '1'
-   *   editor.api.node({ at: path, block: true }) // Find first block at path
-   *   ```;
-   */
-  node: <N$1 extends DescendantIn$1<V>>(atOrOptions: AtOrDescendant | EditorNodesOptions<V>, nodeOptions?: EditorNodeOptions) => NodeEntry$2<N$1> | undefined;
-  /**
-   * At any given `Location` or `Span` in the editor provided by `at` (default
-   * is the current selection), the method returns a Generator of `NodeEntry`
-   * objects that represent the nodes that include `at`. At the top of the
-   * hierarchy is the `Editor` object itself.
-   */
-  nodes: <N$1 extends DescendantIn$1<V>>(options?: EditorNodesOptions<V>) => Generator<NodeEntry$2<N$1>, void, undefined>;
-  /** Get the parent node of a location. */
-  parent: <N$1 extends AncestorIn<V>>(at: At, options?: EditorParentOptions) => NodeEntry$2<N$1> | undefined;
-  /**
-   * Get the matching node in the branch of the document before a location.
-   *
-   * Note: To find the previous Point, and not the previous Node, use the
-   * `Editor.before` method
-   */
-  previous: <N$1 extends DescendantIn$1<V>>(options?: EditorPreviousOptions<V>) => NodeEntry$2<N$1> | undefined;
-  /** Match a void node in the current branch of the editor. */
-  void: <N$1 extends ElementIn<V>>(options?: EditorVoidOptions) => NodeEntry$2<N$1> | undefined;
-} & {
-  findDocumentOrShadowRoot: OmitFirst<typeof findDocumentOrShadowRoot>;
-  /** Get the target range from a DOM `event` */
-  findEventRange: OmitFirst<typeof findEventRange>;
-  /**
-   * Find a key for a Slate node. Returns an instance of `Key` which looks like
-   * `{ id: string }`
-   */
-  findKey: OmitFirst<typeof findKey>;
-  getWindow: OmitFirst<typeof getWindow>;
-  /** Check if a DOM node is within the editor */
-  hasDOMNode: OmitFirst<typeof hasDOMNode>;
-  hasRange: OmitFirst<typeof hasRange>;
-  /** Check if the user is currently composing inside the editor */
-  isComposing: OmitFirst<typeof isComposing>;
-  /** Check if the editor is focused */
-  isFocused: OmitFirst<typeof isFocused>;
-  /** Check if the editor is in read-only mode */
-  isReadOnly: OmitFirst<typeof isReadOnly>;
-  /** Check if the target is inside a non-readonly void element. */
-  isTargetInsideNonReadonlyVoid: OmitFirst<typeof isTargetInsideNonReadonlyVoid>;
-  /** Find the native DOM element from a Slate node */
-  toDOMNode: OmitFirst<typeof toDOMNode>;
-  /** Find a native DOM selection point from a Slate point */
-  toDOMPoint: OmitFirst<typeof toDOMPoint>;
-  /** Find a native DOM range from a Slate `range` */
-  toDOMRange: OmitFirst<typeof toDOMRange>;
-  /** Find a Slate point from a DOM selection's `domNode` and `domOffset`. */
-  toSlatePoint: OmitFirst<typeof toSlatePoint>;
-  /** Find a Slate range from a DOM range or selection. */
-  toSlateRange: OmitFirst<typeof toSlateRange>;
-  /**
-   * Find the path of Slate node. If DOM node is not found, it will use
-   * `findNodePath` (traversal method).
-   */
-  findPath: (node: TNode$1, options?: EditorFindPathOptions) => Path$2 | undefined;
-  hasEditableTarget: (target: EventTarget | null) => target is Node;
-  hasSelectableTarget: (target: EventTarget | null) => target is Node;
-  hasTarget: (target: EventTarget | null) => target is Node;
-  /** Find a Slate node from a native DOM `element` */
-  toSlateNode: <N$1 extends NodeIn<V>>(domNode: Parameters<typeof toSlateNode>[1]) => N$1 | undefined;
-} & {
-  /** Get the merge flag's current value. */
-  isMerging: OmitFirst<typeof HistoryApi.isMerging>;
-  /** Get the saving flag's current value. */
-  isSaving: OmitFirst<typeof HistoryApi.isSaving>;
-  isSplittingOnce: OmitFirst<typeof HistoryApi.isSplittingOnce>;
-} & {
-  create: {
-    /** Default block factory. */
-    block: (node?: Partial<TElement$1>, path?: Path$2) => TElement$1;
-    /** Default value factory. */
-    value: () => Value$1;
-  };
-  /**
-   * Check if a location (point/range) is at a specific position.
-   *
-   * @example
-   *   ```ts
-   *   // For ranges:
-   *   editor.api.isAt({ text: true }) // Check if range is in single text node
-   *   editor.api.isAt({ block: true }) // Check if range is in single block
-   *   editor.api.isAt({ blocks: true }) // Check if range is across multiple blocks
-   *   editor.api.isAt({ start: true }) // Check if range starts at block start
-   *   editor.api.isAt({ end: true }) // Check if range ends at block end
-   *
-   *   // For points:
-   *   editor.api.isAt({ word: true }) // Check relative to word boundaries
-   *   editor.api.isAt({ start: true }) // Check if at start
-   *   editor.api.isAt({ end: true }) // Check if at end
-   *   ```;
-   */
-  isAt: OmitFirst<typeof isAt>;
-  /** Check if a node at a location is a Text node */
-  isText: OmitFirst<typeof isText$1>;
-  /**
-   * Scroll the editor to bring a target point into view.
-   *
-   * @param target - The point to scroll into view
-   * @param options - Scroll options
-   */
-  scrollIntoView: OmitFirst<typeof scrollIntoView>;
-  /**
-   * Check if any node at a location (default: selection) matches the given
-   * criteria
-   */
-  some: OmitFirst<typeof some>;
-  /**
-   * Get the block at a location or find the first block that matches options.
-   * If `above` is true, get the block above the location, similar to
-   * `editor.api.above({ block: true })`. If `highest` is true, get the highest
-   * block at the location.
-   *
-   * @example
-   *   ```ts
-   *   editor.api.block() // Get block above selection
-   *   editor.api.block({ above: true }) // Get block above selection
-   *   editor.api.block({ at: [0, 0] }) // Get block at [0, 0]
-   *   editor.api.block({ at: [0, 0], above: true }) // Get block at [0]
-   *   editor.api.block({ highest: true }) // Get highest block at selection
-   *   ```;
-   */
-  block: <N$1 extends ElementIn<V>>(options?: EditorBlockOptions<V>) => NodeEntry$2<N$1> | undefined;
-  /** Returns all matching blocks. */
-  blocks: <N$1 extends ElementIn<V>>(options?: EditorNodesOptions<V>) => NodeEntry$2<N$1>[];
-  /** Returns the first matching descendant. */
-  descendant: <N$1 extends DescendantIn$1<V>>(options: EditorNodesOptions<V>) => NodeEntry$2<N$1> | undefined;
-  /** Returns the edge blocks above a location (default: selection). */
-  edgeBlocks: <N1 extends ElementIn<V>, N2 extends ElementIn<V> = N1>(options?: EditorAboveOptions$1<V>) => [NodeEntry$2<N1>, NodeEntry$2<N2>] | null;
-  /** Check if the selection is collapsed */
-  isCollapsed: () => boolean;
-  /** Check if selection is at editor end */
-  isEditorEnd: () => boolean;
-  /** Check if the selection is expanded */
-  isExpanded: () => boolean;
-  /** Check if a value is an inline `Element` object. */
-  isInline: <N$1 extends DescendantIn$1<V>>(element: N$1) => boolean;
-  /** Check if a value is a selectable `Element` object. */
-  isSelectable: <N$1 extends ElementIn<V>>(element: N$1) => boolean;
-  /** Returns the selection mark value by key. */
-  mark: <K$1 extends keyof MarksIn<V>>(key: K$1) => MarksIn<V>[K$1] | null | undefined;
-  /** Returns the range spanning the given node entries. */
-  nodesRange: (nodes: NodeEntry$2[]) => TRange$1 | undefined;
-  /**
-   * Get a property value from a list of nodes. Returns undefined if the
-   * property value is not consistent across all nodes.
-   */
-  prop: (options: EditorPropOptions<V>) => string | undefined;
-};
-type EditorBeforeOptions = {
-  distance?: number;
-} & QueryTextUnit & QueryVoids & {
-  /**
-   * If true, get the point after the matching point. If false, get the
-   * matching point.
-   */
-  afterMatch?: boolean;
-  /** Return block start point if no match found */
-  matchBlockStart?: boolean;
-  /**
-   * If true, `matchString` will be interpreted as regex expression(s).
-   * Otherwise, it will be compared by string equality.
-   *
-   * @default false
-   */
-  matchByRegex?: boolean;
-  /** Lookup before the location for `matchString`. */
-  matchString?: string[] | string;
-  /**
-   * If true, lookup until the start of the editor value. If false, lookup
-   * until the first invalid character.
-   */
-  skipInvalid?: boolean;
-  /** Lookup before the location until this predicate is true */
-  match?: (value: {
-    at: At;
-    beforePoint: Point;
-    beforeString: string;
-  }) => boolean;
-};
-type EditorBlockOptions<V extends Value$1 = Value$1> = Omit<EditorNodesOptions<V>, 'block' | 'mode'> & {
-  /**
-   * If true, get the block above the location. This has no effect when `at` is
-   * not a block path.
-   */
-  above?: boolean;
-  /**
-   * If true, get the highest block at the location. This will return the block
-   * at the root level (path length 1).
-   */
-  highest?: boolean;
-};
-type EditorElementReadOnlyOptions = {
-  at?: TLocation;
-} & QueryMode & QueryVoids;
-type EditorEmptyOptions = {
-  /** Check if text after selection is empty */
-  after?: boolean;
-  /** Check if block above location is empty */
-  block?: boolean;
-} & Omit<EditorNodesOptions, 'at' | 'block'>;
-type EditorEndOptions = {
-  /** Get the end point of the previous node */
-  previous?: boolean;
-};
-type EditorFindPathOptions = Omit<EditorNodesOptions<Value$1>, 'at' | 'block' | 'match'>;
-type EditorFragmentOptions = {
-  /** Types of container nodes to unwrap */
-  unwrap?: string[];
-};
-type EditorIsSelectedOptions = {
-  /** Check if selection contains the entire path range */
-  contains?: boolean;
-};
-type EditorLastOptions = {
-  /** Get last node at this level (0-based). */
-  level?: number;
-};
-type EditorLeafOptions = {
-  depth?: number;
-  edge?: LeafEdge;
-};
-type EditorLevelsOptions<V extends Value$1 = Value$1> = {
-  reverse?: boolean;
-} & QueryOptions<V> & QueryVoids;
-type EditorNextOptions<V extends Value$1 = Value$1> = QueryOptions<V> & QueryVoids & {
-  /**
-   * Determines where to start traversing from:
-   *
-   * - `'after'` (default): Start from the point after the current location
-   * - `'child'`: Start from the first child of the current path. `at` must be a
-   *   path.
-   */
-  from?: 'after' | 'child';
-  /**
-   * - `'all'` (default if `from` is `child`): Return all matching nodes.
-   * - `'highest'`: in a hierarchy of nodes, only return the highest level
-   *   matching nodes
-   * - `'lowest'` (default if `from` is `after`): in a hierarchy of nodes, only
-   *   return the lowest level matching nodes
-   */
-  mode?: 'all' | 'highest' | 'lowest';
-};
-type EditorNodeOptions = {
-  depth?: number;
-  edge?: LeafEdge;
-};
-type EditorNodesOptions<V extends Value$1 = Value$1> = {
-  /** Where to start at. @default editor.selection */
-  at?: At | Span$1;
-  ignoreNonSelectable?: boolean;
-  reverse?: boolean;
-  universal?: boolean;
-} & Omit<QueryOptions<V>, 'at'> & QueryMode & QueryVoids;
-type EditorNormalizeOptions = {
-  force?: boolean;
-  operation?: Operation$1;
-};
-type EditorParentOptions = {
-  depth?: number;
-  edge?: LeafEdge;
-};
-type EditorPositionsOptions = {
-  ignoreNonSelectable?: boolean;
-  /**
-   * When `true` returns the positions in reverse order. In the case of the
-   * `unit` being `word`, the actual returned positions are different (i.e. we
-   * will get the start of a word in reverse instead of the end).
-   */
-  reverse?: boolean;
-} & QueryAt & QueryVoids & QueryTextUnit;
-type EditorPreviousOptions<V extends Value$1 = Value$1> = QueryOptions<V> & QueryVoids & {
-  /**
-   * Determines where to start traversing from:
-   *
-   * - `'before'` (default): Start from the point before the current location
-   * - `'parent'`: Start from the parent of the current location
-   */
-  from?: 'before' | 'parent';
-  /**
-   * - `'all'`: Return all matching nodes
-   * - `'highest'`: in a hierarchy of nodes, only return the highest level
-   *   matching nodes
-   * - `'lowest'` (default): in a hierarchy of nodes, only return the lowest
-   *   level matching nodes
-   */
-  mode?: 'all' | 'highest' | 'lowest';
-  /** Get the previous sibling node */
-  sibling?: boolean;
-};
-type EditorPropOptions<V extends Value$1 = Value$1> = {
-  /** Nodes to get the property value from. */
-  nodes: TElement$1[];
-  /** Property key to get. */
-  key?: string;
-  /** Default value to return if property is not found. */
-  defaultValue?: string;
-  /**
-   * - `'all'`: Get the property value from all nodes.
-   * - `'block'`: Get the property value from the first block node.
-   * - `'text'`: Get the property value from the first text node.
-   */
-  mode?: 'all' | 'block' | 'text';
-  /** Function to get the property value from a node. */
-  getProp?: (node: DescendantIn$1<V>) => any;
-};
-type EditorStartOptions = {
-  /** Get the start point of the next node */
-  next?: boolean;
-};
-type EditorStringOptions = QueryVoids;
-type EditorUnhangRangeOptions = {
-  /**
-   * When true, unhang a range of length 1 so both edges are in the same text
-   * node. This is useful for handling ranges created by character-level
-   * operations.
-   */
-  character?: boolean;
-  /** @default true */
-  unhang?: boolean;
-  /** Allow placing the end of the selection in a void node */
-  voids?: boolean;
-};
-type EditorVoidOptions = QueryAt & QueryMode & QueryVoids;
-type QueryAt = {
-  /** Where to start at. @default editor.selection */
-  at?: At;
-};
-type QueryMode = {
-  /**
-   * - `'all'` (default): Return all matching nodes
-   * - `'highest'`: in a hierarchy of nodes, only return the highest level
-   *   matching nodes
-   * - `'lowest'`: in a hierarchy of nodes, only return the lowest level matching
-   *   nodes
-   */
-  mode?: 'all' | 'highest' | 'lowest';
-};
-type QueryOptions<V extends Value$1 = Value$1> = {
-  /** Match the node by id. `true` will match all nodes with an id. */
-  id?: boolean | string;
-  /** Match block nodes. */
-  block?: boolean;
-  /** When true, match only empty nodes. When false, match only non-empty nodes */
-  empty?: boolean;
-  /** Match the node. */
-  match?: Predicate<NodeIn<V>>;
-  /** When true, match only text nodes */
-  text?: boolean;
-} & QueryAt;
-type QueryTextUnit = {
-  /**
-   * - `offset`: Moves to the next offset `Point`. It will include the `Point` at
-   *   the end of a `Text` object and then move onto the first `Point` (at the
-   *   0th offset) of the next `Text` object. This may be counter-intuitive
-   *   because the end of a `Text` and the beginning of the next `Text` might be
-   *   thought of as the same position.
-   * - `character`: Moves to the next `character` but is not always the next
-   *   `index` in the string. This is because Unicode encodings may require
-   *   multiple bytes to create one character. Unlike `offset`, `character` will
-   *   not count the end of a `Text` and the beginning of the next `Text` as
-   *   separate positions to return. Warning: The character offsets for Unicode
-   *   characters does not appear to be reliable in some cases like a Smiley
-   *   Emoji will be identified as 2 characters.
-   * - `word`: Moves to the position immediately after the next `word`. In
-   *   `reverse` mode, moves to the position immediately before the previous
-   *   `word`.
-   * - `line` | `block`: Starts at the beginning position and then the position at
-   *   the end of the block. Then starts at the beginning of the next block and
-   *   then the end of the next block.
-   */
-  unit?: TextUnitAdjustment;
-};
-type QueryVoids = {
-  /** When `true` include void Nodes. */
-  voids?: boolean;
-};
-//#endregion
-//#region src/internal/dom-editor/blur.d.ts
-declare const blur: (editor: Editor$1) => void;
-//#endregion
-//#region src/internal/dom-editor/deselectDOM.d.ts
-declare const deselectDOM: (editor: Editor$1) => void;
-//#endregion
-//#region src/internal/dom-editor/focus.d.ts
-declare const focus$1: (editor: Editor$1, {
-  at,
-  edge,
-  retries
-}?: FocusOptions) => void;
-//#endregion
-//#region src/internal/editor/addMark.d.ts
-declare const addMark$1: (editor: Editor$1, key: string, value: any) => void;
-//#endregion
-//#region src/internal/editor/deleteBackward.d.ts
-declare const deleteBackward$1: (editor: Editor$1, unit?: TextUnit) => void;
-//#endregion
-//#region src/internal/editor/deleteForward.d.ts
-declare const deleteForward$1: (editor: Editor$1, unit?: TextUnit) => void;
-//#endregion
-//#region src/internal/editor/deleteFragment.d.ts
-declare const deleteFragment$1: (editor: Editor$1, options?: EditorFragmentDeletionOptions) => void;
-//#endregion
-//#region src/internal/editor/insertBreak.d.ts
-declare const insertBreak$1: (editor: Editor$1) => void;
-//#endregion
-//#region src/internal/editor/withoutNormalizing.d.ts
-declare const withoutNormalizing$1: (editor: Editor$1, fn: () => boolean | void) => boolean;
-//#endregion
-//#region src/internal/transforms/collapseSelection.d.ts
-declare const collapseSelection: (editor: Editor$1, options?: SelectionCollapseOptions) => void;
-//#endregion
-//#region src/internal/transforms/deleteText.d.ts
-declare const deleteText: <E extends Editor$1>(editor: E, options?: DeleteTextOptions) => void;
-//#endregion
-//#region src/internal/transforms/moveSelection.d.ts
-declare const moveSelection: (editor: Editor$1, options?: SelectionMoveOptions) => void;
-//#endregion
-//#region src/internal/transforms/select.d.ts
-declare const select$1: (editor: Editor$1, target?: At, options?: SelectOptions) => void;
-//#endregion
-//#region src/internal/transforms/setPoint.d.ts
-declare const setPoint$1: (editor: Editor$1, props: Partial<Point>, options?: SelectionSetPointOptions) => void;
-//#endregion
-//#region src/internal/transforms/setSelection.d.ts
-declare const setSelection$1: (editor: Editor$1, props: Partial<TRange$1>) => void;
-//#endregion
-//#region src/internal/transforms-extension/addMarks.d.ts
-declare const addMarks: (editor: Editor$1, marks: EditorMarks, {
-  remove
-}?: AddMarksOptions) => void;
-//#endregion
-//#region src/internal/transforms-extension/duplicateNodes.d.ts
-declare const duplicateNodes: (editor: Editor$1, {
-  block,
-  nodes,
-  ...options
-}?: DuplicateNodesOptions) => void;
-//#endregion
-//#region src/internal/transforms-extension/removeMarks.d.ts
-declare const removeMarks: (editor: Editor$1, keys?: string[] | string | null, {
-  at,
-  shouldChange,
-  ...options
-}?: RemoveMarksOptions) => void;
-//#endregion
-//#region src/internal/transforms-extension/reset.d.ts
-declare const reset: (editor: Editor$1, options?: ResetOptions) => void;
-//#endregion
-//#region src/internal/transforms-extension/toggleBlock.d.ts
-declare const toggleBlock: (editor: Editor$1, type: string, {
-  defaultType: defaultTypeProp,
-  someOptions,
-  wrap,
-  ...options
-}?: ToggleBlockOptions) => void;
-//#endregion
-//#region src/internal/transforms-extension/toggleMark.d.ts
-/** Add or remove mark in the selection. */
-declare const toggleMark: (editor: Editor$1, key: string, {
-  remove
-}?: ToggleMarkOptions) => void;
-//#endregion
-//#region src/interfaces/editor/editor-transforms.d.ts
-type AddMarksOptions = {
-  /** Marks to remove before adding new ones */
-  remove?: string[] | string;
-};
-type DeleteTextOptions = {
-  distance?: number;
-  hanging?: boolean;
-  reverse?: boolean;
-  unit?: TextUnit;
-} & QueryAt & QueryVoids & QueryTextUnit;
-type DuplicateNodesOptions<V extends Value$1 = Value$1> = {
-  /** Location to get nodes from and insert after. Default: selection */
-  at?: At;
-  /** If true, duplicate blocks above location. Ignored if `nodes` is provided */
-  block?: boolean;
-  /** Specific nodes to duplicate. If provided, ignores `block` option */
-  nodes?: NodeEntry$2[];
-} & Omit<InsertNodesOptions<V>, 'at' | 'block'>;
-type EditorTransforms$1<V extends Value$1 = Value$1> = {
-  /**
-   * Add a custom property to the leaf text nodes in the current selection.
-   *
-   * If the selection is currently collapsed, the marks will be added to the
-   * `editor.marks` property instead, and applied when text is inserted next.
-   */
-  addMark: OmitFirst<typeof addMark$1>;
-  /**
-   * Add multiple marks to the leaf text nodes in the current selection. If
-   * marks with the same keys exist, they will be removed first.
-   *
-   * @example
-   *   ```ts
-   *   editor.tf.addMarks({ bold: true, italic: true })
-   *   editor.tf.addMarks({ bold: subscript }, { remove: 'superscript' })
-   *   editor.tf.addMarks({ bold: true }, { remove: ['italic', 'underline'] })
-   *   ```;
-   */
-  addMarks: OmitFirst<typeof addMarks>;
-  /** Delete content in the editor backward from the current selection. */
-  deleteBackward: OmitFirst<typeof deleteBackward$1>;
-  /** Delete content in the editor forward from the current selection. */
-  deleteForward: OmitFirst<typeof deleteForward$1>;
-  /** Delete the content of the current selection. */
-  deleteFragment: OmitFirst<typeof deleteFragment$1>;
-  /**
-   * Duplicate nodes at a location. By default duplicates nodes at the current
-   * selection. When `block: true`, duplicates the blocks above the location.
-   */
-  duplicateNodes: OmitFirst<typeof duplicateNodes>;
-  /** Insert a block break at the current selection. */
-  insertBreak: OmitFirst<typeof insertBreak$1>;
-  /**
-   * Remove marks from text nodes.
-   *
-   * - If `keys` is provided: removes specific mark(s) from text nodes
-   * - If `at` is provided: removes from range
-   * - If `at` is not provided and selection is expanded: removes marks only if
-   *   `keys` is provided
-   * - If `at` is not provided and selection is collapsed: removes from
-   *   `editor.marks`
-   *
-   *   - If `keys` is provided: removes specific mark(s)
-   *   - If `keys` is not provided: removes all marks
-   *
-   * If the selection is currently collapsed, the removal will be stored on
-   * `editor.marks` and applied to the text inserted next.
-   *
-   * @example
-   *   ```ts
-   *   editor.tf.removeMarks() // Remove all marks from editor.marks
-   *   editor.tf.removeMarks('bold') // Remove bold mark at selection
-   *   editor.tf.removeMarks(['bold', 'italic']) // Remove multiple marks at selection
-   *   editor.tf.removeMarks('bold', { at: range }) // Remove bold in range
-   *   ```;
-   */
-  removeMarks: OmitFirst<typeof removeMarks>;
-  /**
-   * Reset the editor state. Use `children: true` to only reset children without
-   * clearing history and operations
-   */
-  reset: OmitFirst<typeof reset>;
-  /**
-   * Toggle a block type. If wrap is true, wrap/unwrap the block in the
-   * specified type. Otherwise, sets the block type directly.
-   *
-   * @example
-   *   ```ts
-   *   editor.tf.toggleBlock('blockquote') // Toggle blockquote
-   *   editor.tf.toggleBlock('list', { wrap: true }) // Toggle list wrapper
-   *   ```;
-   */
-  toggleBlock: OmitFirst<typeof toggleBlock>;
-  /**
-   * Toggle a mark on the leaf text nodes in the current selection. If the mark
-   * exists, it will be removed. Otherwise, it will be added.
-   *
-   * When adding a mark, you can specify marks to remove first using the
-   * `remove` option. This is useful for mutually exclusive marks like
-   * subscript/superscript.
-   *
-   * @example
-   *   ```ts
-   *   editor.tf.toggleMark('bold') // Toggle bold mark
-   *   editor.tf.toggleMark('subscript', { remove: 'superscript' }) // Add subscript, remove superscript
-   *   ```;
-   */
-  toggleMark: OmitFirst<typeof toggleMark>;
-  /**
-   * Call a function, deferring normalization until after it completes
-   *
-   * @returns True if normalized.
-   */
-  withoutNormalizing: OmitFirst<typeof withoutNormalizing$1>;
-  /**
-   * Handle `Escape`.
-   *
-   * @returns `true` if the event is handled, `false` otherwise.
-   */
-  escape: () => boolean | undefined;
-  /**
-   * Insert of fragment of nodes at the specified location or (if not defined)
-   * the current selection or (if not defined) the end of the document.
-   */
-  insertFragment: <N$1 extends ElementOrTextIn<V>>(fragment: N$1[], options?: InsertFragmentOptions) => void;
-  /**
-   * Atomically insert `node` at the specified location or (if not defined) the
-   * current selection or (if not defined) the end of the document.
-   */
-  insertNode: <N$1 extends DescendantIn$1<V>>(node: N$1, options?: InsertNodesOptions<V>) => void;
-  /**
-   * Atomically inserts `nodes` at the specified location or (if not defined)
-   * the current selection or (if not defined) the end of the document.
-   */
-  insertNodes: <N$1 extends ElementOrTextIn<V>>(nodes: N$1 | N$1[], options?: InsertNodesOptions<V>) => void;
-  /**
-   * Insert a soft break at the current selection. If the selection is currently
-   * expanded, delete it first.
-   */
-  insertSoftBreak: () => void;
-  /**
-   * Lift nodes at the specified location upwards in the document tree. If
-   * necessary, the parent node is split. If no location is specified, use the
-   * selection.
-   */
-  liftNodes: (options?: LiftNodesOptions<V>) => void;
-  /**
-   * Merge a node at the specified location with the previous node at the same
-   * depth. If no location is specified, use the selection. Resulting empty
-   * container nodes are removed.
-   */
-  mergeNodes: (options?: MergeNodesOptions<V>) => void;
-  /**
-   * Handle `ArrowDown` and `ArrowUp` (reverse).
-   *
-   * @returns `true` if the event is handled, `false` otherwise.
-   */
-  moveLine: (options: {
-    reverse: boolean;
-  }) => boolean | undefined;
-  /**
-   * Move the nodes from an origin to a destination. A destination must be
-   * specified in the `options`. If no origin is specified, move the selection.
-   */
-  moveNodes: (options: MoveNodesOptions<V>) => boolean | void;
-  /** Normalize any dirty objects in the editor. */
-  normalize: (options?: EditorNormalizeOptions) => void;
-  /** Redo to the next saved state. */
-  redo: () => void;
-  /**
-   * Remove a custom property from all of the leaf text nodes within non-void
-   * nodes or void nodes that `editor.api.markableVoid()` allows in the current
-   * selection.
-   *
-   * If the selection is currently collapsed, the removal will be stored on
-   * `editor.marks` and applied to the text inserted next.
-   */
-  removeMark: (key: string) => void;
-  /**
-   * Remove nodes at the specified location in the document. If no location is
-   * specified, remove the nodes in the selection.
-   */
-  removeNodes: (options?: RemoveNodesOptions<V>) => void;
-  /**
-   * Replace nodes at a location with new nodes.
-   *
-   * @example
-   *   ```ts
-   *   editor.tf.replaceNodes(node, { at }) // Replace node at location
-   *   editor.tf.replaceNodes(node, { at, select: true }) // Replace node then select
-   *   editor.tf.replaceNodes(node, { at, children: true }) // Replace children at location
-   *   ```;
-   */
-  replaceNodes: <N$1 extends ElementOrTextIn<V>>(nodes: N$1 | N$1[], options?: ReplaceNodesOptions<V>) => void;
-  /**
-   * Handle `mod+a`.
-   *
-   * @returns `true` if the event is handled, `false` otherwise.
-   */
-  selectAll: () => boolean | undefined;
-  /**
-   * Set properties of nodes at the specified location. If no location is
-   * specified, use the selection.
-   *
-   * If `props` contains `undefined` values, the node's corresponding property
-   * will also be set to `undefined` as opposed to ignored.
-   */
-  setNodes: <N$1 extends DescendantIn$1<V>>(props: Partial<NodeProps<N$1>>, options?: SetNodesOptions<V>) => void;
-  /**
-   * Split nodes at the specified location. If no location is specified, split
-   * the selection.
-   */
-  splitNodes: (options?: SplitNodesOptions<V>) => void;
-  /**
-   * Handle `Tab`, `Shift+Tab` (reverse).
-   *
-   * @returns `true` if the event is handled, `false` otherwise.
-   */
-  tab: (options: {
-    reverse: boolean;
-  }) => boolean | undefined;
-  /** Undo to the previous saved state. */
-  undo: () => void;
-  /**
-   * Unset properties of nodes at the specified location. If no location is
-   * specified, use the selection.
-   */
-  unsetNodes: <N$1 extends DescendantIn$1<V>>(props: (keyof NodeProps<N$1>)[] | keyof NodeProps<N$1>, options?: UnsetNodesOptions<V>) => void;
-  /**
-   * Unwrap nodes at the specified location. If necessary, the parent node is
-   * split. If no location is specified, use the selection.
-   */
-  unwrapNodes: (options?: UnwrapNodesOptions<V>) => void;
-  /**
-   * Wrap nodes at the specified location in the `element` container. If no
-   * location is specified, wrap the selection.
-   */
-  wrapNodes: <N$1 extends ElementIn<V>>(element: N$1, options?: WrapNodesOptions<V>) => void;
-  /**
-   * Push a batch of operations as either `undos` or `redos` onto `editor.undos`
-   * or `editor.redos`
-   */
-  writeHistory: (stack: 'redos' | 'undos', batch: any) => void;
-} /** Text Transforms */ & {
-  /** Delete text in the document. */
-  delete: OmitFirst<typeof deleteText>;
-  /**
-   * Insert a string of text at the specified location or (if not defined) the
-   * current selection or (if not defined) the end of the document.
-   */
-  insertText: (text: string, options?: InsertTextOptions) => void;
-} /** Selection Transforms */ & {
-  /** Collapse the selection to a single point. */
-  collapse: OmitFirst<typeof collapseSelection>;
-  /** Move the selection's point forward or backward. */
-  move: OmitFirst<typeof moveSelection>;
-  /**
-   * Set the selection to a new value specified by `at`. When a selection
-   * already exists, this method is just a proxy for `setSelection` and will
-   * update the existing value.
-   *
-   * @example
-   *   ```ts
-   *   editor.tf.select(at) // Select at location
-   *   editor.tf.select(at, { edge: 'end' }) // Select end of block above
-   *   editor.tf.select(at, { edge: 'start' }) // Select start of block above
-   *   ```;
-   */
-  select: OmitFirst<typeof select$1>;
-  /** Set new properties on one of the selection's points. */
-  setPoint: OmitFirst<typeof setPoint$1>;
-  /**
-   * Set new properties on an active selection. Since the value is a
-   * `Partial<TRange>`, this method can only handle updates to an existing
-   * selection. If there is no active selection the operation will be void. Use
-   * `select` if you'd like to create a selection when there is none.
-   */
-  setSelection: OmitFirst<typeof setSelection$1>;
-  /** Unset the selection. */
-  deselect: () => void;
-} & {
-  /** Blur the editor */
-  blur: OmitFirst<typeof blur>;
-  /** Deselect the editor. */
-  deselectDOM: OmitFirst<typeof deselectDOM>;
-  /**
-   * Focus the editor.
-   *
-   * - If `at` is defined: select the location and focus
-   * - If `edge` is defined: select the location (default: editor) edge ('start' |
-   *   'end') and focus
-   *
-   * @example
-   *   ```ts
-   *   editor.tf.focus() // focus editor
-   *   editor.tf.focus({ edge: 'end' }) // end of selection if selection exists
-   *   editor.tf.focus({ edge: 'end' }) // end of editor if selection is null
-   *   ```;
-   */
-  focus: OmitFirst<typeof focus$1>;
-  /**
-   * Insert data from a `DataTransfer` into the editor. This is a proxy method
-   * to call in this order `insertFragmentData(editor: Editor, data:
-   * DataTransfer)` and then `insertTextData(editor: Editor, data:
-   * DataTransfer)`.
-   */
-  insertData: DOMEditor['insertData'];
-  /**
-   * Insert fragment data from a `DataTransfer` into the editor. Returns true if
-   * some content has been effectively inserted.
-   */
-  insertFragmentData: DOMEditor['insertFragmentData'];
-  /**
-   * Insert text data from a `DataTransfer` into the editor. Returns true if
-   * some content has been effectively inserted.
-   */
-  insertTextData: DOMEditor['insertTextData'];
-  /** Sets data from the currently selected fragment on a `DataTransfer`. */
-  setFragmentData: DOMEditor['setFragmentData'];
-} & {
-  setSplittingOnce: OmitFirst<typeof HistoryApi.setSplittingOnce>;
-  /**
-   * Apply a series of changes inside a synchronous `fn`, These operations will
-   * be merged into the previous history.
-   */
-  withMerging: OmitFirst<typeof HistoryApi.withMerging>;
-  /**
-   * Apply a series of changes inside a synchronous `fn`, ensuring that the
-   * first operation starts a new batch in the history. Subsequent operations
-   * will be merged as usual.
-   */
-  withNewBatch: OmitFirst<typeof HistoryApi.withNewBatch>;
-  /**
-   * Apply a series of changes inside a synchronous `fn`, without merging any of
-   * the new operations into previous save point in the history.
-   */
-  withoutMerging: OmitFirst<typeof HistoryApi.withoutMerging>;
-  /**
-   * Apply a series of changes inside a synchronous `fn`, without saving any of
-   * their operations into the history.
-   */
-  withoutSaving: OmitFirst<typeof HistoryApi.withoutSaving>;
-} & {
-  /** Apply an operation in the editor. */
-  apply: <N$1 extends DescendantIn$1<V>>(operation: Operation$1<N$1>) => void;
-  /** Normalize a Node according to the schema. */
-  normalizeNode: <N$1 extends NodeIn<V>>(entry: NodeEntry$2<N$1>, options?: {
-    operation?: Operation$1;
-  }) => void;
-};
-type FocusOptions = {
-  /** Target location to select before focusing */
-  at?: At;
-  /** Focus at location or editor edge. Default location is at or selection. */
-  edge?: 'end' | 'endEditor' | 'start' | 'startEditor';
-  /** Number of times to retry focusing */
-  retries?: number;
-};
-type InsertFragmentOptions = {
-  batchDirty?: boolean;
-  hanging?: boolean;
-} & QueryAt & QueryVoids;
-type InsertNodesOptions<V extends Value$1 = Value$1> = {
-  batchDirty?: boolean;
-  hanging?: boolean;
-  /**
-   * Insert the nodes after the currect block. Does not apply if the removeEmpty
-   * option caused the current block to be removed.
-   */
-  nextBlock?: boolean;
-  /**
-   * Remove the currect block if empty before inserting. Only applies to
-   * paragraphs by default, but can be customized by passing a QueryNodeOptions
-   * object.
-   */
-  removeEmpty?: QueryNodeOptions$1 | boolean;
-  /** If true, select the inserted nodes. */
-  select?: boolean;
-} & QueryOptions<V> & QueryMode & QueryVoids;
-type InsertTextOptions = {
-  /** @default true */
-  marks?: boolean;
-} & QueryAt & QueryVoids;
-type LiftNodesOptions<V extends Value$1 = Value$1> = QueryOptions<V> & QueryMode & QueryVoids;
-type MergeNodesOptions<V extends Value$1, _E extends Editor$1 = Editor$1> = {
-  hanging?: boolean;
-  /** Whether it's merging node from `deleteForward`. */
-  reverse?: boolean;
-} & QueryOptions<V> & QueryMode & QueryVoids;
-type MoveNodesOptions<V extends Value$1 = Value$1> = {
-  to: Path$2;
-  /** Move only children of the node at location */
-  children?: boolean;
-  /** Start index of the children to move. Default: 0 */
-  fromIndex?: number;
-} & QueryOptions<V> & QueryMode & QueryVoids;
-type RemoveMarksOptions = {
-  /** Range where the mark(s) will be removed. Default: selection */
-  at?: TRange$1;
-  /** When true, trigger onChange if collapsed selection */
-  shouldChange?: boolean;
-} & Omit<UnsetNodesOptions, 'match' | 'split'>;
-type RemoveNodesOptions<V extends Value$1 = Value$1> = {
-  /** When true, remove all children of the node at the specified location */
-  children?: boolean;
-  event?: {
-    type: 'mergeNodes';
-  };
-  hanging?: boolean;
-  /** When true, remove the previous empty block if it exists */
-  previousEmptyBlock?: boolean;
-} & QueryOptions<V> & QueryMode & QueryVoids;
-type ReplaceNodesOptions<V extends Value$1 = Value$1> = {
-  /** When true, replace all children of the node at the specified location */
-  children?: boolean;
-  /** Options for removing nodes */
-  removeNodes?: Omit<RemoveNodesOptions<V>, 'at'>;
-} & InsertNodesOptions<V>;
-type ResetOptions = {
-  /** When true, only reset children without clearing history and operations */
-  children?: boolean;
-} & Omit<ReplaceNodesOptions, 'at' | 'children'>;
-type SelectOptions = {
-  /** Select edge of the block above location */
-  edge?: 'end' | 'start';
-  /** If true, focus the editor before selecting */
-  focus?: boolean;
-  /** Select start of next sibling */
-  next?: boolean;
-  /** Select end of previous sibling */
-  previous?: boolean;
-};
-type SetNodesOptions<V extends Value$1 = Value$1> = {
-  compare?: PropsCompare;
-  hanging?: boolean;
-  /**
-   * When true, only apply to text nodes in non-void nodes or markable void
-   * nodes
-   */
-  marks?: boolean;
-  merge?: PropsMerge;
-  split?: boolean;
-} & QueryOptions<V> & QueryMode & QueryVoids;
-type SplitNodesOptions<V extends Value$1 = Value$1> = {
-  always?: boolean;
-  height?: number;
-} & QueryOptions<V> & QueryMode & QueryVoids;
-type ToggleBlockOptions = {
-  /** The default block type to revert to when untoggling. Defaults to paragraph. */
-  defaultType?: string;
-  someOptions?: EditorNodesOptions;
-  /**
-   * If true, toggles wrapping the block with the specified type. Otherwise,
-   * toggles the block type directly.
-   */
-  wrap?: boolean;
-} & SetNodesOptions;
-type ToggleMarkOptions = {
-  /** Mark keys to remove when adding the mark. */
-  remove?: string[] | string;
-};
-type UnsetNodesOptions<V extends Value$1 = Value$1> = {
-  hanging?: boolean;
-  split?: boolean;
-} & QueryOptions<V> & QueryMode & QueryVoids;
-type UnwrapNodesOptions<V extends Value$1 = Value$1> = {
-  hanging?: boolean;
-  split?: boolean;
-} & QueryOptions<V> & QueryMode & QueryVoids;
-type WrapNodesOptions<V extends Value$1 = Value$1> = {
-  /**
-   * When true, wrap node children into a single element:
-   *
-   * - Wraps the first child node into the element
-   * - Move the other child nodes next to the element children
-   */
-  children?: boolean;
-  hanging?: boolean;
-  /**
-   * Indicates that it's okay to split a node in order to wrap the location. For
-   * example, if `ipsum` was selected in a `Text` node with `lorem ipsum dolar`,
-   * `split: true` would wrap the word `ipsum` only, resulting in splitting the
-   * `Text` node. If `split: false`, the entire `Text` node `lorem ipsum dolar`
-   * would be wrapped.
-   */
-  split?: boolean;
-} & QueryOptions<V> & QueryMode & QueryVoids;
-type PropsCompare = (prop: Partial<Descendant$1>, node: Partial<Descendant$1>) => boolean;
-type PropsMerge = (prop: Partial<Descendant$1>, node: Partial<Descendant$1>) => object;
-//#endregion
-//#region src/interfaces/editor/legacy-editor.d.ts
-
-//#endregion
-//#region src/interfaces/element.d.ts
-/**
- * `TElement` 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.
- */
-type TElement$1 = {
-  children: Descendant$1[];
-  type: string;
-} & UnknownObject;
-/** Element retrieval and check methods. */
-
-/** A utility type to get all the element nodes type from a root node. */
-type ElementIn<V extends Value$1> = ElementOf<V[number]>;
-type ElementOf<N$1 extends TNode$1> = Editor$1 extends N$1 ? TElement$1 : TElement$1 extends N$1 ? TElement$1 : N$1 extends Editor$1 ? ElementOf<N$1['children'][number]> | Extract<N$1['children'][number], TElement$1> : N$1 extends TElement$1 ? ElementOf<N$1['children'][number]> | Extract<N$1['children'][number], TElement$1> | N$1 : never;
-/**
- * `ElementEntry` objects refer to an `Element` and the `Path` where it can be
- * found inside a root node.
- */
-/** Element or text of an editor. */
-type ElementOrTextIn<V extends Value$1> = ElementIn<V> | TextIn<V>;
-//#endregion
-//#region src/slate-history/history.d.ts
-/** `HistoryApi` contains helpers for history-enabled editors. */
-declare const HistoryApi: {
-  /** Check if a value is a `History` object. */
-  isHistory(value: any): value is History;
-  /** Get the merge flag's current value. */
-  isMerging(editor: Editor$1): boolean | undefined;
-  /** Get the splitting once flag's current value. */
-  isSaving(editor: Editor$1): boolean | undefined;
-  isSplittingOnce(editor: Editor$1): boolean | undefined;
-  /** Get the saving flag's current value. */
-  redo(editor: Editor$1): void;
-  /** Redo to the previous saved state. */
-  setSplittingOnce(editor: Editor$1, value: boolean | undefined): void;
-  /** Undo to the previous saved state. */
-  undo(editor: Editor$1): void;
-  /**
-   * Apply a series of changes inside a synchronous `fn`, These operations will
-   * be merged into the previous history.
-   */
-  withMerging(editor: Editor$1, fn: () => void): void;
-  /**
-   * Apply a series of changes inside a synchronous `fn`, ensuring that the
-   * first operation starts a new batch in the history. Subsequent operations
-   * will be merged as usual.
-   */
-  withNewBatch(editor: Editor$1, fn: () => void): void;
-  /**
-   * Apply a series of changes inside a synchronous `fn`, without merging any of
-   * the new operations into previous save point in the history.
-   */
-  withoutMerging(editor: Editor$1, fn: () => void): void;
-  /**
-   * Apply a series of changes inside a synchronous `fn`, without saving any of
-   * their operations into the history.
-   */
-  withoutSaving(editor: Editor$1, fn: () => void): void;
-};
-type History = {
-  /** Redos of the editor. */
-  redos: Batch[];
-  /** Undos of the editor. */
-  undos: Batch[];
-};
-/**
- * `History` objects hold all of the operations that are applied to a value, so
- * they can be undone or redone as necessary.
- */
-type Batch = {
-  operations: Operation$1[];
-  selectionBefore: TRange$1 | null;
-};
-//#endregion
-//#region src/interfaces/editor/editor-type.d.ts
-type Editor$1<V extends Value$1 = Value$1> = EditorBase$1<V> & {
-  api: EditorApi$1<V>;
-  tf: EditorTransforms$1<V>;
-  transforms: EditorTransforms$1<V>;
-};
-type EditorBase$1<V extends Value$1 = Value$1> = {
-  /** Unique identifier for the editor. */
-  id: string;
-  /** Value of the editor. */
-  children: V;
-  /** Contains the undos and redos of the editor. */
-  history: History;
-  /** Marks that are currently applied to the editor. */
-  marks: EditorMarks | null;
-  /**
-   * Editor metadata. Use this for custom fields instead of extending the editor
-   * directly.
-   */
-  meta: UnknownObject & {
-    isNormalizing?: boolean;
-  };
-  /** Operations that have been applied to the editor. */
-  operations: Operation$1<DescendantIn$1<V>>[];
-  /** The current selection of the editor. */
-  selection: EditorSelection;
-} & EditorMethods<V> & UnknownObject;
-type EditorMarks = Record<string, any>;
-type EditorMethods<V extends Value$1 = Value$1> = Pick<EditorTransforms$1<V>, 'redo' | 'undo'>;
-type EditorSelection = TRange$1 | null;
-type Value$1 = TElement$1[];
-/** A helper type for getting the value of an editor. */
-type ValueOf$1<E extends Editor$1> = E['children'];
-//#endregion
-//#region src/create-editor.d.ts
-//#endregion
 //#region src/static/plugins/ViewPlugin.d.ts
 declare const ViewPlugin: SlatePlugin<PluginConfig<"dom", {
   scrollMode?: ScrollMode;
   scrollOperations?: AutoScrollOperationsMap;
-  scrollOptions?: ScrollIntoViewOptions$1;
+  scrollOptions?: _platejs_slate1.ScrollIntoViewOptions;
 }, {
-  getFragment: () => Descendant$1[];
+  getFragment: () => _platejs_slate1.Descendant[];
   isScrolling: () => boolean;
 }, {
   withScrolling: (fn: () => void, options?: WithAutoScrollOptions | undefined) => void;
@@ -1926,9 +212,9 @@ declare const ViewPlugin: SlatePlugin<PluginConfig<"dom", {
 declare const getStaticPlugins: () => SlatePlugin<PluginConfig<"dom", {
   scrollMode?: ScrollMode;
   scrollOperations?: AutoScrollOperationsMap;
-  scrollOptions?: ScrollIntoViewOptions$1;
+  scrollOptions?: _platejs_slate1.ScrollIntoViewOptions;
 }, {
-  getFragment: () => Descendant$1[];
+  getFragment: () => _platejs_slate1.Descendant[];
   isScrolling: () => boolean;
 }, {
   withScrolling: (fn: () => void, options?: WithAutoScrollOptions | undefined) => void;
@@ -1962,6 +248,7 @@ declare const getRenderNodeStaticProps: ({
   attributes: nodeAttributes,
   editor,
   node,
+  path,
   plugin,
   props
 }: {
@@ -1969,6 +256,8 @@ declare const getRenderNodeStaticProps: ({
   props: SlateRenderNodeProps;
   attributes?: AnyObject;
   node?: TElement | TText;
+  /** Pre-computed path to avoid expensive findPath traversal */
+  path?: Path;
   plugin?: AnyEditorPlugin;
 }) => SlateRenderNodeProps;
 //#endregion
@@ -2442,8 +731,8 @@ declare const insertExitBreak: (editor: SlateEditor, {
 //#endregion
 //#region src/lib/plugins/slate-extension/transforms/resetBlock.d.ts
 /**
- * Reset the current block to a paragraph, removing all properties except id and
- * type.
+ * Reset the current block to a paragraph, removing all properties except the
+ * configured node id key and type.
  */
 declare const resetBlock: (editor: SlateEditor, {
   at
@@ -2469,7 +758,9 @@ type SlateExtensionConfig = PluginConfig<'slateExtension', {
     prevText: string;
     text: string;
   }) => void;
-}, {}, {
+}, {
+  redecorate: () => void;
+}, {
   init: OmitFirst<typeof init>;
   insertExitBreak: OmitFirst<typeof insertExitBreak>;
   resetBlock: OmitFirst<typeof resetBlock>;
@@ -2490,7 +781,9 @@ declare const SlateExtensionPlugin: SlatePlugin<PluginConfig<"slateExtension", {
     prevText: string;
     text: string;
   }) => void;
-}, {}, {
+}, {
+  redecorate: () => void;
+}, {
   init: ((args_0: InitOptions) => void) & ((args_0: InitOptions) => void);
   insertExitBreak: ((args_0?: InsertExitBreakOptions | undefined) => true | undefined) & ((args_0?: InsertExitBreakOptions | undefined) => true | undefined);
   resetBlock: ((args_0?: {
@@ -2761,31 +1054,33 @@ declare const getCorePlugins: ({
 }: GetCorePluginsOptions) => (SlatePlugin<DebugConfig> | SlatePlugin<PluginConfig<"slateExtension", {
   onNodeChange: (options: {
     editor: SlateEditor;
-    node: Descendant$1;
-    operation: NodeOperation$1;
-    prevNode: Descendant$1;
+    node: _platejs_slate1.Descendant;
+    operation: _platejs_slate1.NodeOperation;
+    prevNode: _platejs_slate1.Descendant;
   }) => void;
   onTextChange: (options: {
     editor: SlateEditor;
-    node: Descendant$1;
-    operation: TextOperation$1;
+    node: _platejs_slate1.Descendant;
+    operation: _platejs_slate1.TextOperation;
     prevText: string;
     text: string;
   }) => void;
-}, {}, {
+}, {
+  redecorate: () => void;
+}, {
   init: ((args_0: InitOptions) => void) & ((args_0: InitOptions) => void);
   insertExitBreak: ((args_0?: InsertExitBreakOptions | undefined) => true | undefined) & ((args_0?: InsertExitBreakOptions | undefined) => true | undefined);
   resetBlock: ((args_0?: {
-    at?: Path$2;
+    at?: _platejs_slate1.Path;
   } | undefined) => true | undefined) & ((args_0?: {
-    at?: Path$2;
+    at?: _platejs_slate1.Path;
   } | undefined) => true | undefined);
-  setValue: ((value?: string | Value$1 | undefined) => void) & ((value?: string | Value$1 | undefined) => void);
-  apply: <N$1 extends TElement$1 | TText$1>(operation: Operation$1<N$1>) => void;
+  setValue: ((value?: string | _platejs_slate1.Value | undefined) => void) & ((value?: string | _platejs_slate1.Value | undefined) => void);
+  apply: <N$1 extends _platejs_slate1.TElement | _platejs_slate1.TText>(operation: _platejs_slate1.Operation<N$1>) => void;
 }, {}>> | SlatePlugin<PluginConfig<"dom", {
   scrollMode?: ScrollMode;
   scrollOperations?: AutoScrollOperationsMap;
-  scrollOptions?: ScrollIntoViewOptions$1;
+  scrollOptions?: _platejs_slate1.ScrollIntoViewOptions;
 }, {
   isScrolling: () => boolean;
 }, {
@@ -2795,7 +1090,7 @@ declare const getCorePlugins: ({
     element: HTMLElement | string;
     collapseWhiteSpace?: boolean;
     defaultElementPlugin?: WithRequiredKey;
-  }) => Descendant$1[];
+  }) => _platejs_slate1.Descendant[];
 }>, {}, {}>> | SlatePlugin<PluginConfig<"ast", {}, {}, {}, {}>> | SlatePlugin<PluginConfig<"nodeId", {
   disableInsertOverrides?: boolean;
   filterInline?: boolean;
@@ -2804,7 +1099,7 @@ declare const getCorePlugins: ({
   normalizeInitialValue?: boolean;
   reuseId?: boolean;
   idCreator?: () => any;
-} & QueryNodeOptions$1, {}, {
+} & _platejs_slate1.QueryNodeOptions, {}, {
   nodeId: {
     normalize: () => void;
   };
@@ -2844,7 +1139,7 @@ declare const HtmlPlugin: SlatePlugin<PluginConfig<"html", {}, Record<"html", {
     element: HTMLElement | string;
     collapseWhiteSpace?: boolean;
     defaultElementPlugin?: WithRequiredKey;
-  }) => Descendant$1[];
+  }) => _platejs_slate1.Descendant[];
 }>, {}, {}>>;
 //#endregion
 //#region src/lib/plugins/html/constants.d.ts
@@ -3181,6 +1476,13 @@ declare const endInlineFormattingContext: (state: CollapseWhiteSpaceState) => vo
 //#region src/lib/plugins/length/LengthPlugin.d.ts
 declare const LengthPlugin: SlatePlugin<LengthConfig>;
 //#endregion
+//#region src/lib/plugins/node-id/normalizeStaticValue.d.ts
+declare const STATIC_VALUE_CREATED_AT = 1704067200000;
+type NormalizeStaticValueOptions = NormalizeNodeIdOptions & {
+  createdAt?: number;
+};
+declare const normalizeStaticValue: <V extends Value>(value: V, options?: NormalizeStaticValueOptions) => V;
+//#endregion
 //#region src/lib/plugins/node-id/withNodeId.d.ts
 /** Enables support for inserting nodes with an id key. */
 declare const withNodeId: OverrideEditor<NodeIdConfig>;
@@ -4073,6 +2375,8 @@ type RenderElementProps<N$1 extends TElement = TElement> = {
   };
   children: any;
   element: N$1;
+  /** Pre-computed path for static rendering (avoids expensive findPath traversal). */
+  path?: Path;
 };
 //#endregion
 //#region src/lib/types/RenderLeafProps.d.ts
@@ -4085,6 +2389,8 @@ type RenderLeafProps<N$1 extends TText = TText> = {
   };
   children: any;
   leaf: N$1;
+  /** Pre-computed path for static rendering. */
+  path?: Path;
   text: N$1;
   /**
    * The position of the leaf within the Text node, only present when the text
@@ -4098,6 +2404,8 @@ type RenderTextFn = (props: RenderTextProps) => React$1.ReactElement<any>;
 type RenderTextProps<N$1 extends TText = TText> = {
   /** The text node being rendered. */
   text: N$1;
+  /** Pre-computed path for static rendering. */
+  path?: Path;
   /** The children (leaves) rendered within this text node. */
   children: any;
   /**
@@ -4290,5 +2598,4 @@ declare const pipeOnNodeChange: (editor: SlateEditor, node: Descendant, prevNode
 //#region src/lib/utils/pipeOnTextChange.d.ts
 declare const pipeOnTextChange: (editor: SlateEditor, node: Descendant, text: string, prevText: string, operation: TextOperation) => boolean;
 //#endregion
-export { TSlateEditor as $, ResetOptions as $i, HtmlPlugin as $n, getEditorPlugin as $r, WhiteSpaceRule as $t, applyDeepToNodes as A, PlateStatic as Aa, SlatePluginMethods as Ai, getHtmlComments as An, DOMPlugin as Ar, BaseParagraphPlugin as At, ZustandStoreApi as B, pluginRenderElementStatic as Ba, getSelectedDomFragment as Bi, cleanHtmlLinkElements as Bn, insertExitBreak as Br, endInlineFormattingContext as Bt, isSlateNode as C, SlateRenderLeafProps as Ca, RenderStaticNodeWrapper as Ci, inlineTagNames as Cn, getEdgeNodes as Cr, NodeComponents as Ct, isSlateText as D, serializeHtml as Da, SlatePlugin as Di, htmlElementToElement as Dn, ElementAffinity as Dr, SelectionRules as Dt, isSlateString as E, SerializeHtmlOptions as Ea, Serializer as Ei, htmlElementToLeaf as En, AffinityPlugin as Er, PluginConfig as Et, RenderLeafProps as F, SlateRenderLeaf as Fa, stripSlateDataAttributes as Fi, deserializeHtmlNode as Fn, SlateExtensionConfig as Fr, withBreakRules as Ft, WithSlateOptions as G, createStaticString as Gi, DeserializeHtmlChildren as Gn, withPlateHistory as Gr, collapseWhiteSpaceNode as Gt, nanoid$1 as H, AstPlugin as Ha, getRenderNodeStaticProps as Hi, cleanHtmlEmptyElements as Hn, init as Hr, isLastNonEmptyTextOfInlineFormattingContext as Ht, RenderElementFn as I, pipeRenderLeafStatic as Ia, stripHtmlClassNames as Ii, deserializeHtmlElement as In, SlateExtensionPlugin as Ir, OverridePlugin as It, BaseEditor as J, Descendant$1 as Ji, LINE_FEED as Jn, getPluginKey as Jr, collapseWhiteSpace as Jt, createSlateEditor as K, getStaticPlugins as Ki, DeserializeHtmlNodeReturnType as Kn, getContainerTypes as Kr, collapseWhiteSpaceElement as Kt, RenderElementProps as L, pluginRenderLeafStatic as La, pipeDecorate as Li, deserializeHtml as Ln, setValue as Lr, withOverrides as Lt, RenderTextFn as M, SlateRenderText as Ma, SlateShortcut as Mi, findHtmlElement as Mn, ScrollMode as Mr, withNormalizeRules as Mt, RenderTextProps as N, pipeRenderTextStatic as Na, TextStaticProps as Ni, someHtmlElement as Nn, WithAutoScrollOptions as Nr, withMergeRules as Nt, isSlateVoid as O, ElementStatic as Oa, SlatePluginConfig$1 as Oi, htmlBrToNewLine as On, AUTO_SCROLL as Or, WithAnyKey as Ot, RenderLeafFn as P, pluginRenderTextStatic as Pa, TransformOptions as Pi, deserializeHtmlNodeChildren as Pn, withScrolling as Pr, withDeleteRules as Pt, SlateEditor as Q, Path$2 as Qi, ZERO_WIDTH_SPACE as Qn, getSlatePlugin as Qr, TrimStartRule as Qt, RenderChunkFn as R, pipeRenderElementStatic as Ra, isSelectOutside as Ri, copyBlockMarksToSpanChild as Rn, resetBlock as Rr, withNodeId as Rt, isSlateLeaf as S, SlateRenderElementProps as Sa, PartialEditorPlugin as Si, isHtmlBlockElement as Sn, getMarkBoundaryAffinity as Sr, NodeComponent as St, isSlatePluginNode as T, SlateRenderTextProps as Ta, RenderStaticNodeWrapperProps as Ti, htmlStringToDOMNode as Tn, AffinityConfig as Tr, ParserOptions as Tt, BaseWithSlateOptions as U, getNodeDataAttributes as Ui, cleanHtmlCrLf as Un, ParserPlugin as Ur, inferWhiteSpaceRule as Ut, createZustandStore$1 as V, HandlerReturnType as Va, getSelectedDomBlocks as Vi, cleanHtmlFontElements as Vn, InitOptions as Vr, upsertInlineFormattingContext as Vt, CreateSlateEditorOptions as W, getPluginDataAttributes as Wi, cleanHtmlBrElements as Wn, HistoryPlugin as Wr, collapseWhiteSpaceText as Wt, KeyofNodePlugins as X, NodeOperation$1 as Xi, SPACE as Xn, getPluginType as Xr, CollapseWhiteSpaceState as Xt, InferPlugins as Y, NodeEntry$2 as Yi, NO_BREAK_SPACE as Yn, getPluginKeys as Yr, collapseString as Yt, KeyofPlugins as Z, Operation$1 as Zi, TAB as Zn, getPluginTypes as Zr, TrimEndRule as Zt, getInjectMatch as _, StyledSlateElementProps as _a, NodeStaticWrapperComponentProps as _i, isHtmlTable as _n, LogLevel as _r, InferOptions as _t, omitPluginContext as a, TextOperation$1 as aa, Deserializer as ai, replaceTagName as an, GetCorePluginsOptions as ar, BasePluginContext as at, isSlateEditor as b, useNodeAttributes as ba, OverrideEditor as bi, isHtmlElement as bn, isNodeAffinity as br, MatchRules as bt, isType as c, getEditorDOMFromHtmlString as ca, ExtendEditorApi as ci, preCleanHtml as cn, ChunkingConfig as cr, BaseTransformOptions as ct, isHotkey as d, SlateHTMLProps as da, HtmlSerializer as di, pipeDeserializeHtmlLeaf as dn, NodeIdOptions as dr, EditOnlyConfig as dt, ScrollIntoViewOptions$1 as ea, createSlatePlugin as ei, unwrapHtmlElement as en, withChunking as er, AnyPluginConfig as et, getSlateClass as f, SlateLeaf as fa, InferConfig as fi, pipeDeserializeHtmlElement as fn, NodeIdPlugin as fr, ExtendConfig as ft, getInjectedPlugins as g, SlateTextProps as ga, NodeStaticWrapperComponent as gi, isHtmlText as gn, DebugPlugin as gr, InferKey as gt, keyToDataAttribute as h, SlateText as ha, NodeStaticProps as hi, isOlSymbol as hn, DebugErrorType as hr, InferApi as ht, overridePluginsByKey as i, TText$1 as ia, Decorate as ii, traverseHtmlComments as in, DebugConfig as ir, BasePlugin as it, EditableProps as j, PlateStaticProps as ja, SlatePlugins as ji, getDataNodeProps as jn, DomConfig as jr, ParagraphConfig as jt, ApplyDeepToNodesOptions as k, LeafStatic as ka, SlatePluginContext as ki, htmlBodyToFragment as kn, AutoScrollOperationsMap as kr, WithRequiredKey as kt, Hotkeys as l, SlateElement as la, ExtendEditorTransforms as li, postCleanHtml as ln, ChunkingPlugin as lr, BreakRules as lt, getNodeDataAttributeKeys as m, SlateNodeProps as ma, LeafStaticProps as mi, parseHtmlDocument as mn, normalizeNodeId as mr, GetInjectNodePropsReturnType as mt, pipeOnNodeChange as n, TRange$1 as na, AnyEditorPlugin as ni, traverseHtmlNode as nn, CorePluginApi as nr, BaseHtmlDeserializer as nt, normalizeDescendantsToDocumentFragment as o, Value$1 as oa, EditorPlugin as oi, removeHtmlSurroundings as on, LengthConfig as or, BasePluginNode as ot, getPluginNodeProps as p, SlateLeafProps as pa, InjectNodeProps as pi, parseHtmlElement as pn, NormalizeNodeIdOptions as pr, GetInjectNodePropsOptions as pt, withSlate as q, ViewPlugin as qi, CARRIAGE_RETURN as qn, getPluginByType as qr, collapseWhiteSpaceChildren as qt, pipeInsertDataQuery as r, TSelection$1 as ra, AnySlatePlugin as ri, traverseHtmlElements as rn, CorePluginTransforms as rr, BaseInjectProps as rt, mergeDeepToNodes as s, createStaticEditor as sa, ExtendEditor as si, removeHtmlNodesBetweenComments as sn, getCorePlugins as sr, BaseSerializer as st, pipeOnTextChange as t, TElement$1 as ta, createTSlatePlugin as ti, traverseHtmlTexts as tn, CorePlugin as tr, BaseDeserializer as tt, createHotkey as u, SlateElementProps as ua, HtmlDeserializer as ui, pluginDeserializeHtml as un, NodeIdConfig as ur, DeleteRules as ut, defaultsDeepToNodes as v, StyledSlateLeafProps as va, NodeStaticWrapperComponentReturnType as vi, isHtmlInlineElement as vn, PlateError as vr, InferSelectors as vt, isSlatePluginElement as w, SlateRenderNodeProps as wa, RenderStaticNodeWrapperFunction as wi, htmlTextNodeToString as wn, EdgeNodes as wr, NormalizeRules as wt, isSlateElement as x, BoxStaticProps as xa, Parser as xi, isHtmlComment as xn, isNodesAffinity as xr, MergeRules as xt, getSlateElements as y, StyledSlateTextProps as ya, NormalizeInitialValue as yi, isHtmlFragmentHref as yn, setAffinitySelection as yr, InferTransforms as yt, RenderChunkProps as z, SlateRenderElement as za, getSelectedDomNode as zi, cleanHtmlTextNodes as zn, InsertExitBreakOptions as zr, LengthPlugin as zt };
-//# sourceMappingURL=index-NTp--CEF.d.ts.map
+export { TSlateEditor as $, SlateElement as $i, SPACE as $n, getPluginType as $r, CollapseWhiteSpaceState as $t, applyDeepToNodes as A, pluginRenderElementStatic as Aa, SlatePlugin as Ai, htmlElementToElement as An, ElementAffinity as Ar, BaseParagraphPlugin as At, ZustandStoreApi as B, pipeDecorate as Bi, deserializeHtml as Bn, setValue as Br, STATIC_VALUE_CREATED_AT as Bt, isSlateNode as C, pipeRenderTextStatic as Ca, OverrideEditor as Ci, isHtmlElement as Cn, isNodeAffinity as Cr, NodeComponents as Ct, isSlateText as D, pluginRenderLeafStatic as Da, RenderStaticNodeWrapperFunction as Di, htmlTextNodeToString as Dn, EdgeNodes as Dr, SelectionRules as Dt, isSlateString as E, pipeRenderLeafStatic as Ea, RenderStaticNodeWrapper as Ei, inlineTagNames as En, getEdgeNodes as Er, PluginConfig as Et, RenderLeafProps as F, SlateShortcut as Fi, findHtmlElement as Fn, ScrollMode as Fr, withBreakRules as Ft, WithSlateOptions as G, getRenderNodeStaticProps as Gi, cleanHtmlEmptyElements as Gn, init as Gr, isLastNonEmptyTextOfInlineFormattingContext as Gt, nanoid$1 as H, getSelectedDomNode as Hi, cleanHtmlTextNodes as Hn, InsertExitBreakOptions as Hr, LengthPlugin as Ht, RenderElementFn as I, TextStaticProps as Ii, someHtmlElement as In, WithAutoScrollOptions as Ir, OverridePlugin as It, BaseEditor as J, createStaticString as Ji, DeserializeHtmlChildren as Jn, withPlateHistory as Jr, collapseWhiteSpaceNode as Jt, createSlateEditor as K, getNodeDataAttributes as Ki, cleanHtmlCrLf as Kn, ParserPlugin as Kr, inferWhiteSpaceRule as Kt, RenderElementProps as L, TransformOptions as Li, deserializeHtmlNodeChildren as Ln, withScrolling as Lr, withOverrides as Lt, RenderTextFn as M, AstPlugin as Ma, SlatePluginContext as Mi, htmlBodyToFragment as Mn, AutoScrollOperationsMap as Mr, withNormalizeRules as Mt, RenderTextProps as N, SlatePluginMethods as Ni, getHtmlComments as Nn, DOMPlugin as Nr, withMergeRules as Nt, isSlateVoid as O, pipeRenderElementStatic as Oa, RenderStaticNodeWrapperProps as Oi, htmlStringToDOMNode as On, AffinityConfig as Or, WithAnyKey as Ot, RenderLeafFn as P, SlatePlugins as Pi, getDataNodeProps as Pn, DomConfig as Pr, withDeleteRules as Pt, SlateEditor as Q, getEditorDOMFromHtmlString as Qi, NO_BREAK_SPACE as Qn, getPluginKeys as Qr, collapseString as Qt, RenderChunkFn as R, stripSlateDataAttributes as Ri, deserializeHtmlNode as Rn, SlateExtensionConfig as Rr, withNodeId as Rt, isSlateLeaf as S, SlateRenderText as Sa, NormalizeInitialValue as Si, isHtmlFragmentHref as Sn, setAffinitySelection as Sr, NodeComponent as St, isSlatePluginNode as T, SlateRenderLeaf as Ta, PartialEditorPlugin as Ti, isHtmlBlockElement as Tn, getMarkBoundaryAffinity as Tr, ParserOptions as Tt, BaseWithSlateOptions as U, getSelectedDomFragment as Ui, cleanHtmlLinkElements as Un, insertExitBreak as Ur, endInlineFormattingContext as Ut, createZustandStore$1 as V, isSelectOutside as Vi, copyBlockMarksToSpanChild as Vn, resetBlock as Vr, normalizeStaticValue as Vt, CreateSlateEditorOptions as W, getSelectedDomBlocks as Wi, cleanHtmlFontElements as Wn, InitOptions as Wr, upsertInlineFormattingContext as Wt, KeyofNodePlugins as X, ViewPlugin as Xi, CARRIAGE_RETURN as Xn, getPluginByType as Xr, collapseWhiteSpaceChildren as Xt, InferPlugins as Y, getStaticPlugins as Yi, DeserializeHtmlNodeReturnType as Yn, getContainerTypes as Yr, collapseWhiteSpaceElement as Yt, KeyofPlugins as Z, createStaticEditor as Zi, LINE_FEED as Zn, getPluginKey as Zr, collapseWhiteSpace as Zt, getInjectMatch as _, serializeHtml as _a, LeafStaticProps as _i, parseHtmlDocument as _n, normalizeNodeId as _r, InferOptions as _t, omitPluginContext as a, SlateText as aa, AnyEditorPlugin as ai, traverseHtmlNode as an, CorePluginApi as ar, BasePluginContext as at, isSlateEditor as b, PlateStatic as ba, NodeStaticWrapperComponentProps as bi, isHtmlTable as bn, LogLevel as br, MatchRules as bt, isType as c, StyledSlateLeafProps as ca, Deserializer as ci, replaceTagName as cn, GetCorePluginsOptions as cr, BaseTransformOptions as ct, isHotkey as d, BoxStaticProps as da, ExtendEditorApi as di, preCleanHtml as dn, ChunkingConfig as dr, EditOnlyConfig as dt, SlateElementProps as ea, getPluginTypes as ei, TrimEndRule as en, TAB as er, AnyPluginConfig as et, getSlateClass as f, SlateRenderElementProps as fa, ExtendEditorTransforms as fi, postCleanHtml as fn, ChunkingPlugin as fr, ExtendConfig as ft, getInjectedPlugins as g, SerializeHtmlOptions as ga, InjectNodeProps as gi, parseHtmlElement as gn, NormalizeNodeIdOptions as gr, InferKey as gt, keyToDataAttribute as h, SlateRenderTextProps as ha, InferConfig as hi, pipeDeserializeHtmlElement as hn, NodeIdPlugin as hr, InferApi as ht, overridePluginsByKey as i, SlateNodeProps as ia, createTSlatePlugin as ii, traverseHtmlTexts as in, CorePlugin as ir, BasePlugin as it, EditableProps as j, HandlerReturnType as ja, SlatePluginConfig$1 as ji, htmlBrToNewLine as jn, AUTO_SCROLL as jr, ParagraphConfig as jt, ApplyDeepToNodesOptions as k, SlateRenderElement as ka, Serializer as ki, htmlElementToLeaf as kn, AffinityPlugin as kr, WithRequiredKey as kt, Hotkeys as l, StyledSlateTextProps as la, EditorPlugin as li, removeHtmlSurroundings as ln, LengthConfig as lr, BreakRules as lt, getNodeDataAttributeKeys as m, SlateRenderNodeProps as ma, HtmlSerializer as mi, pipeDeserializeHtmlLeaf as mn, NodeIdOptions as mr, GetInjectNodePropsReturnType as mt, pipeOnNodeChange as n, SlateLeaf as na, getEditorPlugin as ni, WhiteSpaceRule as nn, HtmlPlugin as nr, BaseHtmlDeserializer as nt, normalizeDescendantsToDocumentFragment as o, SlateTextProps as oa, AnySlatePlugin as oi, traverseHtmlElements as on, CorePluginTransforms as or, BasePluginNode as ot, getPluginNodeProps as p, SlateRenderLeafProps as pa, HtmlDeserializer as pi, pluginDeserializeHtml as pn, NodeIdConfig as pr, GetInjectNodePropsOptions as pt, withSlate as q, getPluginDataAttributes as qi, cleanHtmlBrElements as qn, HistoryPlugin as qr, collapseWhiteSpaceText as qt, pipeInsertDataQuery as r, SlateLeafProps as ra, createSlatePlugin as ri, unwrapHtmlElement as rn, withChunking as rr, BaseInjectProps as rt, mergeDeepToNodes as s, StyledSlateElementProps as sa, Decorate as si, traverseHtmlComments as sn, DebugConfig as sr, BaseSerializer as st, pipeOnTextChange as t, SlateHTMLProps as ta, getSlatePlugin as ti, TrimStartRule as tn, ZERO_WIDTH_SPACE as tr, BaseDeserializer as tt, createHotkey as u, useNodeAttributes as ua, ExtendEditor as ui, removeHtmlNodesBetweenComments as un, getCorePlugins as ur, DeleteRules as ut, defaultsDeepToNodes as v, ElementStatic as va, NodeStaticProps as vi, isOlSymbol as vn, DebugErrorType as vr, InferSelectors as vt, isSlatePluginElement as w, pluginRenderTextStatic as wa, Parser as wi, isHtmlComment as wn, isNodesAffinity as wr, NormalizeRules as wt, isSlateElement as x, PlateStaticProps as xa, NodeStaticWrapperComponentReturnType as xi, isHtmlInlineElement as xn, PlateError as xr, MergeRules as xt, getSlateElements as y, LeafStatic as ya, NodeStaticWrapperComponent as yi, isHtmlText as yn, DebugPlugin as yr, InferTransforms as yt, RenderChunkProps as z, stripHtmlClassNames as zi, deserializeHtmlElement as zn, SlateExtensionPlugin as zr, NormalizeStaticValueOptions as zt };