@lofcz/platejs-core 52.3.4 → 53.0.0

package/dist/{index-NTp--CEF.d.ts → index-C-LKDYK-.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 { Ancestor, DOMRange, DecoratedRange, Descendant, Editor, EditorAboveOptions, EditorApi, EditorBase, EditorTransforms, InsertTextOptions, LeafPosition, NodeEntry, NodeOf, NodeOperation, Operation, Path, PathRef, Point, 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>;
@@ -132,1791 +130,79 @@ type SlateRenderTextProps<N$1 extends TText = TText, C extends AnyPluginConfig =
 //#endregion
 //#region src/static/components/slate-nodes.d.ts
 declare const useNodeAttributes: (props: any, ref?: any) => any;
-type SlateElementProps<N$1 extends TElement = TElement, C extends AnyPluginConfig = PluginConfig> = SlateNodeProps<C> & RenderElementProps<N$1> & {
-  attributes: UnknownObject;
-  path: Path;
-} & DeprecatedNodeProps;
-type DeprecatedNodeProps = {
-  /**
-   * @deprecated Optional class to be merged with `attributes.className`.
-   * @default undefined
-   */
-  className?: string;
-  /**
-   * @deprecated Optional style to be merged with `attributes.style`
-   * @default undefined
-   */
-  style?: React$1.CSSProperties;
-};
-type SlateNodeProps<C extends AnyPluginConfig = PluginConfig> = SlatePluginContext<C> & {
-  /**
-   * Optional ref to be merged with `attributes.ref`
-   *
-   * @default undefined
-   */
-  ref?: any;
-};
-type SlateHTMLProps<C extends AnyPluginConfig = PluginConfig, T extends keyof HTMLElementTagNameMap = 'div'> = SlateNodeProps<C> & {
-  /** HTML attributes to pass to the underlying HTML element */
-  attributes: React$1.PropsWithoutRef<React$1.JSX.IntrinsicElements[T]> & UnknownObject;
-  as?: T;
-  /** Class to be merged with `attributes.className` */
-  className?: string;
-  /** Style to be merged with `attributes.style` */
-  style?: React$1.CSSProperties;
-};
-type StyledSlateElementProps<N$1 extends TElement = TElement, C extends AnyPluginConfig = PluginConfig, T extends keyof HTMLElementTagNameMap = 'div'> = Omit<SlateElementProps<N$1, C>, keyof DeprecatedNodeProps> & SlateHTMLProps<C, T>;
-declare const SlateElement: <N$1 extends TElement = TElement, C extends AnyPluginConfig = PluginConfig, T extends keyof HTMLElementTagNameMap = "div">(props: StyledSlateElementProps<N$1, C, T>) => React$1.ReactElement;
-type SlateTextProps<N$1 extends TText = TText, C extends AnyPluginConfig = PluginConfig> = SlateNodeProps<C> & RenderTextProps<N$1> & DeprecatedNodeProps & {
-  attributes: UnknownObject;
-};
-type StyledSlateTextProps<N$1 extends TText = TText, C extends AnyPluginConfig = PluginConfig, T extends keyof HTMLElementTagNameMap = 'span'> = Omit<SlateTextProps<N$1, C>, keyof DeprecatedNodeProps> & SlateHTMLProps<C, T>;
-declare const SlateText: <N$1 extends TText = TText, C extends AnyPluginConfig = PluginConfig, T extends keyof HTMLElementTagNameMap = "span">(props: StyledSlateTextProps<N$1, C, T>) => React$1.ReactElement;
-type SlateLeafProps<N$1 extends TText = TText, C extends AnyPluginConfig = PluginConfig> = SlateNodeProps<C> & RenderLeafProps<N$1> & DeprecatedNodeProps & {
-  attributes: UnknownObject;
-  inset?: boolean;
-};
-type StyledSlateLeafProps<N$1 extends TText = TText, C extends AnyPluginConfig = PluginConfig, T extends keyof HTMLElementTagNameMap = 'span'> = Omit<SlateLeafProps<N$1, C>, keyof DeprecatedNodeProps> & SlateHTMLProps<C, T>;
-declare const SlateLeaf: <N$1 extends TText = TText, C extends AnyPluginConfig = PluginConfig, T extends keyof HTMLElementTagNameMap = "span">({
-  className,
-  ...props
-}: StyledSlateLeafProps<N$1, C, T>) => React$1.ReactElement;
-//#endregion
-//#region src/static/deserialize/htmlStringToEditorDOM.d.ts
-/**
- * Convert HTML string exported from Plate into HTML element.
- *
- * @param html - The HTML string to convert exported from Plate.
- * @returns The Editor element without head and body.
- */
-declare const getEditorDOMFromHtmlString: (html: string) => HTMLElement;
-//#endregion
-//#region src/static/editor/withStatic.d.ts
-type CreateStaticEditorOptions<V extends Value = Value, P extends AnyPluginConfig = CorePlugin> = CreateSlateEditorOptions<V, P> & {};
-declare const createStaticEditor: <V extends Value = Value, P extends AnyPluginConfig = CorePlugin>({
-  editor,
-  ...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;
+type SlateElementProps<N$1 extends TElement = TElement, C extends AnyPluginConfig = PluginConfig> = SlateNodeProps<C> & RenderElementProps<N$1> & {
+  attributes: UnknownObject;
+  path: Path;
+} & DeprecatedNodeProps;
+type DeprecatedNodeProps = {
   /**
-   * When true, only apply to text nodes in non-void nodes or markable void
-   * nodes
+   * @deprecated Optional class to be merged with `attributes.className`.
+   * @default undefined
    */
-  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;
+  className?: string;
   /**
-   * If true, toggles wrapping the block with the specified type. Otherwise,
-   * toggles the block type directly.
+   * @deprecated Optional style to be merged with `attributes.style`
+   * @default undefined
    */
-  wrap?: boolean;
-} & SetNodesOptions;
-type ToggleMarkOptions = {
-  /** Mark keys to remove when adding the mark. */
-  remove?: string[] | string;
+  style?: React$1.CSSProperties;
 };
-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> = {
+type SlateNodeProps<C extends AnyPluginConfig = PluginConfig> = SlatePluginContext<C> & {
   /**
-   * When true, wrap node children into a single element:
+   * Optional ref to be merged with `attributes.ref`
    *
-   * - 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.
+   * @default undefined
    */
-  withoutSaving(editor: Editor$1, fn: () => void): void;
+  ref?: any;
+};
+type SlateHTMLProps<C extends AnyPluginConfig = PluginConfig, T extends keyof HTMLElementTagNameMap = 'div'> = SlateNodeProps<C> & {
+  /** HTML attributes to pass to the underlying HTML element */
+  attributes: React$1.PropsWithoutRef<React$1.JSX.IntrinsicElements[T]> & UnknownObject;
+  as?: T;
+  /** Class to be merged with `attributes.className` */
+  className?: string;
+  /** Style to be merged with `attributes.style` */
+  style?: React$1.CSSProperties;
+};
+type StyledSlateElementProps<N$1 extends TElement = TElement, C extends AnyPluginConfig = PluginConfig, T extends keyof HTMLElementTagNameMap = 'div'> = Omit<SlateElementProps<N$1, C>, keyof DeprecatedNodeProps> & SlateHTMLProps<C, T>;
+declare const SlateElement: <N$1 extends TElement = TElement, C extends AnyPluginConfig = PluginConfig, T extends keyof HTMLElementTagNameMap = "div">(props: StyledSlateElementProps<N$1, C, T>) => React$1.ReactElement;
+type SlateTextProps<N$1 extends TText = TText, C extends AnyPluginConfig = PluginConfig> = SlateNodeProps<C> & RenderTextProps<N$1> & DeprecatedNodeProps & {
+  attributes: UnknownObject;
 };
-type History = {
-  /** Redos of the editor. */
-  redos: Batch[];
-  /** Undos of the editor. */
-  undos: Batch[];
+type StyledSlateTextProps<N$1 extends TText = TText, C extends AnyPluginConfig = PluginConfig, T extends keyof HTMLElementTagNameMap = 'span'> = Omit<SlateTextProps<N$1, C>, keyof DeprecatedNodeProps> & SlateHTMLProps<C, T>;
+declare const SlateText: <N$1 extends TText = TText, C extends AnyPluginConfig = PluginConfig, T extends keyof HTMLElementTagNameMap = "span">(props: StyledSlateTextProps<N$1, C, T>) => React$1.ReactElement;
+type SlateLeafProps<N$1 extends TText = TText, C extends AnyPluginConfig = PluginConfig> = SlateNodeProps<C> & RenderLeafProps<N$1> & DeprecatedNodeProps & {
+  attributes: UnknownObject;
+  inset?: boolean;
 };
+type StyledSlateLeafProps<N$1 extends TText = TText, C extends AnyPluginConfig = PluginConfig, T extends keyof HTMLElementTagNameMap = 'span'> = Omit<SlateLeafProps<N$1, C>, keyof DeprecatedNodeProps> & SlateHTMLProps<C, T>;
+declare const SlateLeaf: <N$1 extends TText = TText, C extends AnyPluginConfig = PluginConfig, T extends keyof HTMLElementTagNameMap = "span">({
+  className,
+  ...props
+}: StyledSlateLeafProps<N$1, C, T>) => React$1.ReactElement;
+//#endregion
+//#region src/static/deserialize/htmlStringToEditorDOM.d.ts
 /**
- * `History` objects hold all of the operations that are applied to a value, so
- * they can be undone or redone as necessary.
+ * Convert HTML string exported from Plate into HTML element.
+ *
+ * @param html - The HTML string to convert exported from Plate.
+ * @returns The Editor element without head and body.
  */
-type Batch = {
-  operations: Operation$1[];
-  selectionBefore: TRange$1 | null;
-};
+declare const getEditorDOMFromHtmlString: (html: string) => HTMLElement;
 //#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
+//#region src/static/editor/withStatic.d.ts
+type CreateStaticEditorOptions<V extends Value = Value, P extends AnyPluginConfig = CorePlugin> = CreateSlateEditorOptions<V, P> & {};
+declare const createStaticEditor: <V extends Value = Value, P extends AnyPluginConfig = CorePlugin>({
+  editor,
+  ...options
+}?: CreateStaticEditorOptions<V, P>) => TSlateEditor<V, P>;
 //#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
@@ -2012,6 +301,197 @@ declare const stripHtmlClassNames: (html: string, {
 //#region src/static/utils/stripSlateDataAttributes.d.ts
 declare const stripSlateDataAttributes: (rawHtml: string) => string;
 //#endregion
+//#region src/lib/plugins/input-rules/types.d.ts
+type InputRuleTarget = 'insertBreak' | 'insertData' | 'insertText';
+type BivariantCallback$1<TArgs extends unknown[], TResult> = {
+  bivarianceHack: (...args: TArgs) => TResult;
+}['bivarianceHack'];
+type SelectionInputRuleContext<TEditor extends SlateEditor = SlateEditor> = {
+  editor: TEditor;
+  getBlockEntry: () => NodeEntry | undefined;
+  getBlockStartRange: () => TRange | undefined;
+  getBlockStartText: () => string | undefined;
+  getBlockTextBeforeSelection: () => string;
+  getCharAfter: () => string | undefined;
+  getCharBefore: () => string | undefined;
+  isCollapsed: boolean;
+  pluginKey: string;
+};
+type InsertBreakInputRuleContext<TEditor extends SlateEditor = SlateEditor> = SelectionInputRuleContext<TEditor> & {
+  cause: 'insertBreak';
+  insertBreak: () => void;
+};
+type InsertDataInputRuleContext<TEditor extends SlateEditor = SlateEditor> = SelectionInputRuleContext<TEditor> & {
+  cause: 'insertData';
+  data: DataTransfer;
+  insertData: (data: DataTransfer) => void;
+  text: string | null;
+};
+type InsertTextInputRuleContext<TEditor extends SlateEditor = SlateEditor> = SelectionInputRuleContext<TEditor> & {
+  cause: 'insertText';
+  insertText: (text: string, options?: InsertTextOptions) => void;
+  options?: InsertTextOptions;
+  text: string;
+};
+type BaseInputRule<TContext extends SelectionInputRuleContext = SelectionInputRuleContext> = {
+  enabled?: BivariantCallback$1<[context: TContext], boolean>;
+  priority?: number;
+};
+type MarkInputRuleConfig = BaseInputRule<InsertTextInputRuleContext> & {
+  end?: string;
+  mark?: string;
+  marks?: string[];
+  start: string;
+  trim?: 'allow' | 'reject';
+  trigger: string;
+};
+type BlockStartInputRuleMatch = {
+  range: TRange;
+  text: string;
+};
+type MatchBlockStartOptions<TMatch extends object = {}, TContext extends SelectionInputRuleContext = SelectionInputRuleContext> = {
+  match: RegExp | string | ((context: TContext) => RegExp | string | undefined);
+  resolveMatch?: (args: {
+    match: RegExpMatchArray | string;
+    range: TRange;
+    text: string;
+  }) => TMatch | undefined;
+};
+type BlockStartInputRuleConfig<TMatch extends object = {}> = BaseInputRule<InsertTextInputRuleContext> & {
+  apply?: (context: InsertTextInputRuleContext, match: BlockStartInputRuleMatch & TMatch) => boolean | void;
+  mode?: 'set' | 'toggle' | 'wrap';
+  node?: string;
+  removeMatchedText?: boolean;
+  trigger: string;
+} & MatchBlockStartOptions<TMatch, InsertTextInputRuleContext>;
+type BlockFenceInputRuleMatch = BlockStartInputRuleMatch & {
+  path: Path;
+};
+type MatchBlockFenceOptions<TMatch = BlockFenceInputRuleMatch> = {
+  block?: string;
+  fence: string;
+  resolveMatch?: (args: {
+    fence: string;
+    path: Path;
+    range: TRange;
+    text: string;
+  }) => TMatch | undefined;
+};
+type BlockFenceInputRuleConfig<TMatch = BlockFenceInputRuleMatch> = BaseInputRule<SelectionInputRuleContext> & MatchBlockFenceOptions<TMatch> & {
+  apply: (context: SelectionInputRuleContext, match: TMatch) => boolean | void;
+  on: 'break' | 'match';
+};
+type DelimitedInlineInputRuleMatch = {
+  content: string;
+  deleteRange: TRange;
+};
+type MatchDelimitedInlineOptions = {
+  boundaryRe?: RegExp;
+  close?: string;
+  followRe?: RegExp;
+  open: string;
+  rejectRepeatedOpen?: boolean;
+  requireClosingDelimiter?: boolean;
+  trim?: 'allow' | 'reject';
+};
+type TextSubstitutionPattern = {
+  format: readonly [string, string] | string;
+  match: readonly string[] | string;
+  trigger?: readonly string[] | string;
+};
+type TextSubstitutionMatch = {
+  end: string;
+  pattern: TextSubstitutionPattern;
+  points: {
+    afterStartMatchPoint: Point | undefined;
+    beforeEndMatchPoint: Point;
+    beforeStartMatchPoint: Point | undefined;
+  };
+};
+type TextSubstitutionInputRuleConfig = BaseInputRule<InsertTextInputRuleContext> & {
+  patterns: TextSubstitutionPattern[];
+};
+type InputRuleBuilder = {
+  blockFence: <TMatch = BlockFenceInputRuleMatch>(config: BlockFenceInputRuleConfig<TMatch>) => AnyInputRule<TMatch>;
+  blockStart: <TMatch extends object = {}>(config: BlockStartInputRuleConfig<TMatch>) => InsertTextInputRule<BlockStartInputRuleMatch & TMatch>;
+  insertBreak: <TMatch = true>(rule: InsertBreakInputRule<TMatch>) => InsertBreakInputRule<TMatch>;
+  insertData: <TMatch = true>(rule: InsertDataInputRule<TMatch>) => InsertDataInputRule<TMatch>;
+  insertText: <TMatch = true>(rule: InsertTextInputRule<TMatch>) => InsertTextInputRule<TMatch>;
+  mark: (config: MarkInputRuleConfig) => InsertTextInputRule<{
+    afterStartMatchPoint: Point;
+    beforeEndMatchPoint: Point;
+    beforeStartMatchPoint: Point;
+    end: string | undefined;
+  }>;
+};
+type InputRulesFactoryContext = {
+  rule: InputRuleBuilder;
+};
+type InsertBreakInputRule<TMatch = true, TEditor extends SlateEditor = SlateEditor> = BaseInputRule<InsertBreakInputRuleContext<TEditor>> & {
+  apply: BivariantCallback$1<[context: InsertBreakInputRuleContext<TEditor>, match: TMatch], boolean | void>;
+  resolve?: BivariantCallback$1<[context: InsertBreakInputRuleContext<TEditor>], TMatch | undefined>;
+  target: 'insertBreak';
+};
+type InsertDataInputRule<TMatch = true, TEditor extends SlateEditor = SlateEditor> = BaseInputRule<InsertDataInputRuleContext<TEditor>> & {
+  apply: BivariantCallback$1<[context: InsertDataInputRuleContext<TEditor>, match: TMatch], boolean | void>;
+  mimeTypes?: string[];
+  resolve?: BivariantCallback$1<[context: InsertDataInputRuleContext<TEditor>], TMatch | undefined>;
+  target: 'insertData';
+};
+type InsertTextInputRule<TMatch = true, TEditor extends SlateEditor = SlateEditor> = BaseInputRule<InsertTextInputRuleContext<TEditor>> & {
+  apply: BivariantCallback$1<[context: InsertTextInputRuleContext<TEditor>, match: TMatch], boolean | void>;
+  resolve?: BivariantCallback$1<[context: InsertTextInputRuleContext<TEditor>], TMatch | undefined>;
+  target: 'insertText';
+  trigger: readonly string[] | string;
+};
+type AnyInputRule<TMatch = unknown, TEditor extends SlateEditor = SlateEditor> = InsertBreakInputRule<TMatch, TEditor> | InsertDataInputRule<TMatch, TEditor> | InsertTextInputRule<TMatch, TEditor>;
+type StoredInsertBreakInputRule = BaseInputRule<InsertBreakInputRuleContext> & {
+  apply: BivariantCallback$1<[context: InsertBreakInputRuleContext, match: unknown], boolean | void>;
+  resolve?: BivariantCallback$1<[context: InsertBreakInputRuleContext], unknown>;
+  target: 'insertBreak';
+};
+type StoredInsertDataInputRule = BaseInputRule<InsertDataInputRuleContext> & {
+  apply: BivariantCallback$1<[context: InsertDataInputRuleContext, match: unknown], boolean | void>;
+  mimeTypes?: string[];
+  resolve?: BivariantCallback$1<[context: InsertDataInputRuleContext], unknown>;
+  target: 'insertData';
+};
+type StoredInsertTextInputRule = BaseInputRule<InsertTextInputRuleContext> & {
+  apply: BivariantCallback$1<[context: InsertTextInputRuleContext, match: unknown], boolean | void>;
+  resolve?: BivariantCallback$1<[context: InsertTextInputRuleContext], unknown>;
+  target: 'insertText';
+  trigger: readonly string[] | string;
+};
+type StoredInputRule = StoredInsertBreakInputRule | StoredInsertDataInputRule | StoredInsertTextInputRule;
+type InputRulesDefinition = InputRulesConfig | ((ctx: InputRulesFactoryContext) => InputRulesConfig);
+type InputRulesConfig = AnyInputRule<any, SlateEditor>[];
+type ResolvedInputRule = StoredInputRule & {
+  id: string;
+  pluginKey: string;
+  priority: number;
+  ruleIndex: number;
+  pluginIndex: number;
+};
+type ResolvedInputRulesMeta = {
+  insertBreak: Extract<ResolvedInputRule, {
+    target: 'insertBreak';
+  }>[];
+  insertData: Extract<ResolvedInputRule, {
+    target: 'insertData';
+  }>[];
+  insertText: {
+    all: Extract<ResolvedInputRule, {
+      target: 'insertText';
+    }>[];
+    byTrigger: Record<string, Extract<ResolvedInputRule, {
+      target: 'insertText';
+    }>[]>;
+  };
+  plugins: Record<string, {
+    rules: ResolvedInputRule[];
+  }>;
+};
+//#endregion
 //#region src/lib/plugin/SlatePlugin.d.ts
 type AnyEditorPlugin = EditorPlugin<AnyPluginConfig>;
 type AnySlatePlugin = SlatePlugin<AnyPluginConfig>;
@@ -2242,6 +722,7 @@ type SlatePlugin<C extends AnyPluginConfig = PluginConfig> = BasePlugin<C> & Nul
    * method, an API method, or use a custom handler function.
    */
   shortcuts: Partial<Record<(string & {}) | Exclude<keyof InferApi<C>[C['key']], keyof InferTransforms<C>[C['key']]> | keyof InferTransforms<C>[C['key']], SlateShortcut | null>>;
+  inputRules: InputRulesDefinition | InputRulesConfig;
 };
 type SlatePluginConfig$1<K$1 extends string = any, O = {}, A = {}, T = {}, S = {}, EO = {}, EA = {}, ET = {}, ES = {}> = Partial<Omit<SlatePlugin<PluginConfig<K$1, Partial<O>, A, T, S>>, keyof SlatePluginMethods | 'api' | 'node' | 'optionsStore' | 'transforms'> & {
   api: EA;
@@ -2396,6 +877,50 @@ declare const HistoryPlugin: SlatePlugin<PluginConfig<"history", {}, {}, {}, {}>
 //#region src/lib/plugins/ParserPlugin.d.ts
 declare const ParserPlugin: SlatePlugin<PluginConfig<"parser", {}, {}, {}, {}>>;
 //#endregion
+//#region src/lib/plugins/dom/withScrolling.d.ts
+type WithAutoScrollOptions = {
+  mode?: ScrollMode;
+  operations?: AutoScrollOperationsMap;
+  scrollOptions?: ScrollIntoViewOptions;
+};
+declare const withScrolling: (editor: SlateEditor, fn: () => void, options?: WithAutoScrollOptions) => void;
+//#endregion
+//#region src/lib/plugins/dom/DOMPlugin.d.ts
+declare const AUTO_SCROLL: WeakMap<SlateEditor, boolean>;
+type AutoScrollOperationsMap = Partial<Record<Operation['type'], boolean>>;
+type DomConfig = PluginConfig<'dom', {
+  /** Choose the first or last matching operation as the scroll target */
+  scrollMode?: ScrollMode;
+  /**
+   * Operations map; false to disable an operation, true or undefined to
+   * enable
+   */
+  scrollOperations?: AutoScrollOperationsMap;
+  /** Options passed to scrollIntoView */
+  scrollOptions?: ScrollIntoViewOptions;
+}>;
+/** Mode for picking target op when multiple enabled */
+type ScrollMode = 'first' | 'last';
+/**
+ * Placeholder plugin for DOM interaction, that could be replaced with
+ * ReactPlugin.
+ */
+declare const DOMPlugin: SlatePlugin<PluginConfig<"dom", {
+  /** Choose the first or last matching operation as the scroll target */
+  scrollMode?: ScrollMode;
+  /**
+   * Operations map; false to disable an operation, true or undefined to
+   * enable
+   */
+  scrollOperations?: AutoScrollOperationsMap;
+  /** Options passed to scrollIntoView */
+  scrollOptions?: ScrollIntoViewOptions;
+}, {
+  isScrolling: () => boolean;
+}, {
+  withScrolling: (fn: () => void, options?: WithAutoScrollOptions | undefined) => void;
+}, {}>>;
+//#endregion
 //#region src/lib/plugins/slate-extension/transforms/init.d.ts
 type InitOptions = {
   autoSelect?: boolean | 'end' | 'start';
@@ -2440,10 +965,27 @@ declare const insertExitBreak: (editor: SlateEditor, {
   reverse
 }?: InsertExitBreakOptions) => true | undefined;
 //#endregion
+//#region src/lib/plugins/slate-extension/transforms/liftBlock.d.ts
+type LiftBlockOptions = {
+  at?: EditorAboveOptions['at'];
+  match?: EditorAboveOptions['match'];
+};
+/**
+ * Lift the current block out of the nearest matching ancestor container.
+ *
+ * This unwraps only the current block and splits the ancestor around it when
+ * needed, so one keypress changes one structural level instead of exploding the
+ * whole container.
+ */
+declare const liftBlock: (editor: SlateEditor, {
+  at,
+  match
+}?: LiftBlockOptions) => true | undefined;
+//#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,9 +1011,12 @@ type SlateExtensionConfig = PluginConfig<'slateExtension', {
     prevText: string;
     text: string;
   }) => void;
-}, {}, {
+}, {
+  redecorate: () => void;
+}, {
   init: OmitFirst<typeof init>;
   insertExitBreak: OmitFirst<typeof insertExitBreak>;
+  liftBlock: OmitFirst<typeof liftBlock>;
   resetBlock: OmitFirst<typeof resetBlock>;
   setValue: OmitFirst<typeof setValue>;
 }>;
@@ -2490,9 +1035,12 @@ 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);
+  liftBlock: ((args_0?: LiftBlockOptions | undefined) => true | undefined) & ((args_0?: LiftBlockOptions | undefined) => true | undefined);
   resetBlock: ((args_0?: {
     at?: _platejs_slate1.Path;
   } | undefined) => true | undefined) & ((args_0?: {
@@ -2502,50 +1050,94 @@ declare const SlateExtensionPlugin: SlatePlugin<PluginConfig<"slateExtension", {
   apply: <N$1 extends _platejs_slate1.TElement | TText>(operation: _platejs_slate1.Operation<N$1>) => void;
 }, {}>>;
 //#endregion
-//#region src/lib/plugins/dom/withScrolling.d.ts
-type WithAutoScrollOptions = {
-  mode?: ScrollMode;
-  operations?: AutoScrollOperationsMap;
-  scrollOptions?: ScrollIntoViewOptions;
+//#region src/lib/plugins/navigation-feedback/types.d.ts
+declare const NAVIGATION_FEEDBACK_KEY = "navigationFeedback";
+declare const NavigationFeedbackPluginKey: {
+  readonly key: "navigationFeedback";
 };
-declare const withScrolling: (editor: SlateEditor, fn: () => void, options?: WithAutoScrollOptions) => void;
-//#endregion
-//#region src/lib/plugins/dom/DOMPlugin.d.ts
-declare const AUTO_SCROLL: WeakMap<SlateEditor, boolean>;
-type AutoScrollOperationsMap = Partial<Record<Operation['type'], boolean>>;
-type DomConfig = PluginConfig<'dom', {
-  /** Choose the first or last matching operation as the scroll target */
-  scrollMode?: ScrollMode;
-  /**
-   * Operations map; false to disable an operation, true or undefined to
-   * enable
-   */
-  scrollOperations?: AutoScrollOperationsMap;
-  /** Options passed to scrollIntoView */
-  scrollOptions?: ScrollIntoViewOptions;
+type NavigationFeedbackTarget = {
+  path: Path;
+  type: 'node';
+};
+type NavigationFeedbackActiveTarget = NavigationFeedbackTarget & {
+  cycle: 0 | 1;
+  duration: number;
+  pulse: number;
+  variant: string;
+};
+type NavigationFeedbackStoredTarget = Omit<NavigationFeedbackActiveTarget, 'path'> & {
+  pathRef: PathRef;
+};
+type NavigationFlashTargetOptions = {
+  duration?: number;
+  target: NavigationFeedbackTarget;
+  variant?: string;
+};
+type NavigationNavigateOptions = {
+  flash?: false | {
+    duration?: number;
+    variant?: string;
+  };
+  focus?: boolean;
+  scroll?: boolean;
+  scrollTarget?: Point;
+  select?: Point | TRange;
+  target: NavigationFeedbackTarget;
+};
+type NavigationFeedbackConfig = PluginConfig<typeof NAVIGATION_FEEDBACK_KEY, {
+  activeTarget: NavigationFeedbackStoredTarget | null;
+  duration: number;
+}, {
+  navigation: {
+    activeTarget: () => NavigationFeedbackActiveTarget | null;
+    clear: () => void;
+    isTarget: (path: Path) => boolean;
+  };
+}, {
+  navigation: {
+    clear: () => void;
+    flashTarget: (options: NavigationFlashTargetOptions) => boolean;
+    navigate: (options: NavigationNavigateOptions) => boolean;
+  };
 }>;
-/** Mode for picking target op when multiple enabled */
-type ScrollMode = 'first' | 'last';
-/**
- * Placeholder plugin for DOM interaction, that could be replaced with
- * ReactPlugin.
- */
-declare const DOMPlugin: SlatePlugin<PluginConfig<"dom", {
-  /** Choose the first or last matching operation as the scroll target */
-  scrollMode?: ScrollMode;
-  /**
-   * Operations map; false to disable an operation, true or undefined to
-   * enable
-   */
-  scrollOperations?: AutoScrollOperationsMap;
-  /** Options passed to scrollIntoView */
-  scrollOptions?: ScrollIntoViewOptions;
+//#endregion
+//#region src/lib/plugins/navigation-feedback/NavigationFeedbackPlugin.d.ts
+declare const NavigationFeedbackPlugin: SlatePlugin<PluginConfig<"navigationFeedback", {
+  activeTarget: NavigationFeedbackStoredTarget | null;
+  duration: number;
 }, {
-  isScrolling: () => boolean;
+  navigation: {
+    activeTarget: () => NavigationFeedbackActiveTarget | null;
+    clear: () => void;
+    isTarget: (path: _platejs_slate1.Path) => boolean;
+  };
 }, {
-  withScrolling: (fn: () => void, options?: WithAutoScrollOptions | undefined) => void;
+  navigation: {
+    clear: () => void;
+    flashTarget: (options: NavigationFlashTargetOptions) => boolean;
+    navigate: (options: NavigationNavigateOptions) => boolean;
+  };
 }, {}>>;
 //#endregion
+//#region src/lib/plugins/navigation-feedback/transforms/flashTarget.d.ts
+declare const resolveNavigationFeedbackTarget: (target?: NavigationFeedbackStoredTarget | null) => NavigationFeedbackActiveTarget | null;
+declare const clearNavigationFeedbackTarget: (editor: SlateEditor, pulse?: number) => boolean;
+declare const flashTarget: (editor: SlateEditor, {
+  duration,
+  target,
+  variant
+}: NavigationFlashTargetOptions) => boolean;
+//#endregion
+//#region src/lib/plugins/navigation-feedback/transforms/navigate.d.ts
+declare const navigate: (editor: SlateEditor, {
+  flash,
+  focus,
+  scroll,
+  scrollTarget,
+  select,
+  target
+}: NavigationNavigateOptions) => boolean;
+//#endregion
 //#region src/lib/plugins/affinity/AffinityPlugin.d.ts
 type ElementAffinity = {
   affinity: 'backward' | 'forward';
@@ -2747,6 +1339,8 @@ type GetCorePluginsOptions = {
   chunking?: ChunkingConfig['options'] | boolean;
   /** Specifies the maximum number of characters allowed in the editor. */
   maxLength?: number;
+  /** Configure the navigation feedback plugin. */
+  navigationFeedback?: NavigationFeedbackConfig['options'] | boolean;
   /** Configure the node id plugin. */
   nodeId?: NodeIdConfig['options'] | boolean;
   /** Override the core plugins using the same key. */
@@ -2756,46 +1350,65 @@ declare const getCorePlugins: ({
   affinity,
   chunking,
   maxLength,
+  navigationFeedback,
   nodeId,
   plugins
-}: GetCorePluginsOptions) => (SlatePlugin<DebugConfig> | SlatePlugin<PluginConfig<"slateExtension", {
+}: GetCorePluginsOptions) => (SlatePlugin<PluginConfig<"dom", {
+  scrollMode?: ScrollMode;
+  scrollOperations?: AutoScrollOperationsMap;
+  scrollOptions?: _platejs_slate1.ScrollIntoViewOptions;
+}, {
+  isScrolling: () => boolean;
+}, {
+  withScrolling: (fn: () => void, options?: WithAutoScrollOptions | undefined) => void;
+}, {}>> | 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);
+  liftBlock: ((args_0?: LiftBlockOptions | undefined) => true | undefined) & ((args_0?: LiftBlockOptions | 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;
-}, {}>> | SlatePlugin<PluginConfig<"dom", {
-  scrollMode?: ScrollMode;
-  scrollOperations?: AutoScrollOperationsMap;
-  scrollOptions?: ScrollIntoViewOptions$1;
+  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<"navigationFeedback", {
+  activeTarget: NavigationFeedbackStoredTarget | null;
+  duration: number;
 }, {
-  isScrolling: () => boolean;
+  navigation: {
+    activeTarget: () => NavigationFeedbackActiveTarget | null;
+    clear: () => void;
+    isTarget: (path: _platejs_slate1.Path) => boolean;
+  };
 }, {
-  withScrolling: (fn: () => void, options?: WithAutoScrollOptions | undefined) => void;
-}, {}>> | SlatePlugin<PluginConfig<"history", {}, {}, {}, {}>> | SlatePlugin<PluginConfig<"override", {}, {}, {}, {}>> | SlatePlugin<PluginConfig<"parser", {}, {}, {}, {}>> | SlatePlugin<LengthConfig> | SlatePlugin<PluginConfig<"html", {}, Record<"html", {
+  navigation: {
+    clear: () => void;
+    flashTarget: (options: NavigationFlashTargetOptions) => boolean;
+    navigate: (options: NavigationNavigateOptions) => boolean;
+  };
+}, {}>> | SlatePlugin<PluginConfig<"history", {}, {}, {}, {}>> | SlatePlugin<PluginConfig> | SlatePlugin<PluginConfig<"override", {}, {}, {}, {}>> | SlatePlugin<PluginConfig<"parser", {}, {}, {}, {}>> | SlatePlugin<LengthConfig> | SlatePlugin<PluginConfig<"html", {}, Record<"html", {
   deserialize: (args_0: {
     element: HTMLElement | string;
     collapseWhiteSpace?: boolean;
     defaultElementPlugin?: WithRequiredKey;
-  }) => Descendant$1[];
+  }) => _platejs_slate1.Descendant[];
 }>, {}, {}>> | SlatePlugin<PluginConfig<"ast", {}, {}, {}, {}>> | SlatePlugin<PluginConfig<"nodeId", {
   disableInsertOverrides?: boolean;
   filterInline?: boolean;
@@ -2804,15 +1417,15 @@ declare const getCorePlugins: ({
   normalizeInitialValue?: boolean;
   reuseId?: boolean;
   idCreator?: () => any;
-} & QueryNodeOptions$1, {}, {
+} & _platejs_slate1.QueryNodeOptions, {}, {
   nodeId: {
     normalize: () => void;
   };
 } & Record<"nodeId", {
   normalize(): void;
 }>, {}>> | SlatePlugin<AffinityConfig> | SlatePlugin<PluginConfig<"p", {}, {}, {}, {}>> | SlatePlugin<ChunkingConfig>)[];
-type CorePluginTransforms = SlateExtensionConfig['transforms'];
-type CorePluginApi = SlateExtensionConfig['api'];
+type CorePluginTransforms = SlateExtensionConfig['transforms'] & NavigationFeedbackConfig['transforms'];
+type CorePluginApi = SlateExtensionConfig['api'] & NavigationFeedbackConfig['api'];
 type DebugConfig = PluginConfig<'debug', {
   isProduction: boolean;
   logger: Partial<Record<LogLevel, LogFunction>>;
@@ -2844,7 +1457,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
@@ -3178,9 +1791,134 @@ declare const isLastNonEmptyTextOfInlineFormattingContext: (initialText: Text) =
 declare const upsertInlineFormattingContext: (state: CollapseWhiteSpaceState) => void;
 declare const endInlineFormattingContext: (state: CollapseWhiteSpaceState) => void;
 //#endregion
+//#region src/lib/plugins/input-rules/createInputRules.d.ts
+declare const createMarkInputRule: (config: MarkInputRuleConfig) => ReturnType<InputRuleBuilder["mark"]>;
+declare const matchBlockStart: <TMatch extends object = {}, TContext extends SelectionInputRuleContext = SelectionInputRuleContext>(context: TContext, config: MatchBlockStartOptions<TMatch, TContext>) => (BlockStartInputRuleMatch & TMatch) | undefined;
+declare const createBlockStartInputRule: <TMatch extends object = {}>(config: BlockStartInputRuleConfig<TMatch>) => InsertTextInputRule<BlockStartInputRuleMatch & TMatch, SlateEditor>;
+declare const matchBlockFence: <TMatch = BlockFenceInputRuleMatch, TContext extends SelectionInputRuleContext = SelectionInputRuleContext>(context: TContext, config: MatchBlockFenceOptions<TMatch>) => TMatch | undefined;
+declare function createBlockFenceInputRule<TMatch = BlockFenceInputRuleMatch>(config: BlockFenceInputRuleConfig<TMatch>): InsertBreakInputRule<TMatch, SlateEditor> | InsertTextInputRule<TMatch, SlateEditor>;
+declare const matchDelimitedInline: (context: SelectionInputRuleContext, {
+  boundaryRe,
+  close,
+  followRe,
+  open,
+  requireClosingDelimiter,
+  rejectRepeatedOpen,
+  trim
+}: MatchDelimitedInlineOptions) => DelimitedInlineInputRuleMatch | undefined;
+declare const createTextSubstitutionInputRule: ({
+  enabled,
+  patterns,
+  priority
+}: TextSubstitutionInputRuleConfig) => InsertTextInputRule<TextSubstitutionMatch, SlateEditor>;
+//#endregion
+//#region src/lib/plugins/input-rules/createRuleFactory.d.ts
+type FactoryValue<TInput, TValue> = TValue | ((input: TInput) => TValue);
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+type BivariantCallback<T extends (...args: never[]) => unknown> = {
+  bivarianceHack: T;
+}['bivarianceHack'];
+type RuntimeOptions<TContext> = {
+  enabled?: (context: TContext) => boolean;
+  priority?: number;
+};
+type FactoryInput<TContext, TDefaults extends object, TRequired extends object> = TContext & TDefaults & TRequired;
+type PublicOptions<TContext, TDefaults extends object, TRequired extends object> = Simplify<Partial<TDefaults> & TRequired & RuntimeOptions<TContext>>;
+type CreateRuleFactoryReturn<TContext, TDefaults extends object, TRequired extends object> = keyof TRequired extends never ? (options?: PublicOptions<TContext, TDefaults, TRequired>) => AnyInputRule<unknown> : (options: PublicOptions<TContext, TDefaults, TRequired>) => AnyInputRule<unknown>;
+type RuleFactoryConfigBuilder<TContext, TDefaults extends object, TRequired extends object, TConfig> = (options: PublicOptions<TContext, TDefaults, TRequired>) => TConfig;
+type MarkRuleFactoryConfig<TDefaults extends object, TRequired extends object> = {
+  type: 'mark';
+  end?: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, string | undefined>;
+  mark?: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, string | undefined>;
+  marks?: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, string[] | undefined>;
+  start: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, string>;
+  trim?: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, MarkInputRuleConfig['trim']>;
+  trigger: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, string>;
+  enabled?: (input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>) => boolean;
+  priority?: number;
+};
+type BlockStartRuleFactoryConfig<TDefaults extends object, TRequired extends object, TMatch extends object = {}> = {
+  type: 'blockStart';
+  apply?: BivariantCallback<(input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, match: BlockStartInputRuleMatch & TMatch) => boolean | void>;
+  match: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, RegExp | string | undefined>;
+  mode?: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, BlockStartInputRuleConfig<TMatch>['mode']>;
+  node?: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, string | undefined>;
+  removeMatchedText?: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, boolean | undefined>;
+  resolveMatch?: (args: {
+    match: RegExpMatchArray | string;
+    range: BlockStartInputRuleMatch['range'];
+    text: string;
+  }, input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>) => TMatch | undefined;
+  trigger: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, string>;
+  enabled?: (input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>) => boolean;
+  priority?: number;
+};
+type BlockFenceRuleFactoryConfig<TDefaults extends object, TRequired extends object, TMatch> = {
+  type: 'blockFence';
+  apply: BivariantCallback<(input: FactoryInput<SelectionInputRuleContext, TDefaults, TRequired>, match: TMatch) => boolean | void>;
+  block?: FactoryValue<FactoryInput<SelectionInputRuleContext, TDefaults, TRequired>, string | undefined>;
+  fence: FactoryValue<FactoryInput<SelectionInputRuleContext, TDefaults, TRequired>, string>;
+  on?: FactoryValue<FactoryInput<SelectionInputRuleContext, TDefaults, TRequired>, BlockFenceInputRuleConfig<TMatch>['on']>;
+  resolveMatch?: (args: {
+    fence: string;
+    path: BlockFenceInputRuleMatch['path'];
+    range: BlockFenceInputRuleMatch['range'];
+    text: string;
+  }, input: FactoryInput<SelectionInputRuleContext, TDefaults, TRequired>) => TMatch | undefined;
+  enabled?: (input: FactoryInput<SelectionInputRuleContext, TDefaults, TRequired>) => boolean;
+  priority?: number;
+};
+type InsertTextRuleFactoryConfig<TDefaults extends object, TRequired extends object, TMatch> = {
+  type: 'insertText';
+  apply: BivariantCallback<(input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, match: TMatch) => boolean | void>;
+  resolve?: (input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>) => TMatch | undefined;
+  trigger: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, InsertTextInputRule<TMatch>['trigger']>;
+  enabled?: (input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>) => boolean;
+  priority?: number;
+};
+type InsertBreakRuleFactoryConfig<TDefaults extends object, TRequired extends object, TMatch> = {
+  type: 'insertBreak';
+  apply: BivariantCallback<(input: FactoryInput<InsertBreakInputRuleContext, TDefaults, TRequired>, match: TMatch) => boolean | void>;
+  resolve?: (input: FactoryInput<InsertBreakInputRuleContext, TDefaults, TRequired>) => TMatch | undefined;
+  enabled?: (input: FactoryInput<InsertBreakInputRuleContext, TDefaults, TRequired>) => boolean;
+  priority?: number;
+};
+type InsertDataRuleFactoryConfig<TDefaults extends object, TRequired extends object, TMatch> = {
+  type: 'insertData';
+  apply: BivariantCallback<(input: FactoryInput<InsertDataInputRuleContext, TDefaults, TRequired>, match: TMatch) => boolean | void>;
+  mimeTypes?: FactoryValue<FactoryInput<InsertDataInputRuleContext, TDefaults, TRequired>, string[] | undefined>;
+  resolve?: (input: FactoryInput<InsertDataInputRuleContext, TDefaults, TRequired>) => TMatch | undefined;
+  enabled?: (input: FactoryInput<InsertDataInputRuleContext, TDefaults, TRequired>) => boolean;
+  priority?: number;
+};
+type TextSubstitutionRuleFactoryConfig<TDefaults extends object, TRequired extends object> = {
+  type: 'textSubstitution';
+  patterns: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, TextSubstitutionInputRuleConfig['patterns']>;
+  enabled?: (input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>) => boolean;
+  priority?: number;
+};
+type AnyRuleFactoryConfig<TDefaults extends object = Record<string, unknown>, TRequired extends object = Record<string, unknown>, TMatch = unknown> = MarkRuleFactoryConfig<TDefaults, TRequired> | BlockStartRuleFactoryConfig<TDefaults, TRequired, TMatch extends object ? TMatch : {}> | BlockFenceRuleFactoryConfig<TDefaults, TRequired, TMatch> | InsertTextRuleFactoryConfig<TDefaults, TRequired, TMatch> | InsertBreakRuleFactoryConfig<TDefaults, TRequired, TMatch> | InsertDataRuleFactoryConfig<TDefaults, TRequired, TMatch> | TextSubstitutionRuleFactoryConfig<TDefaults, TRequired>;
+type AnyRuleFactoryConfigLoose<TDefaults extends object = Record<string, unknown>, TRequired extends object = Record<string, unknown>> = MarkRuleFactoryConfig<TDefaults, TRequired> | BlockStartRuleFactoryConfig<TDefaults, TRequired, {}> | BlockFenceRuleFactoryConfig<TDefaults, TRequired, unknown> | InsertTextRuleFactoryConfig<TDefaults, TRequired, unknown> | InsertBreakRuleFactoryConfig<TDefaults, TRequired, unknown> | InsertDataRuleFactoryConfig<TDefaults, TRequired, unknown> | TextSubstitutionRuleFactoryConfig<TDefaults, TRequired>;
+type ContextFromFactoryConfig<TConfig> = TConfig extends MarkRuleFactoryConfig<any, any> | BlockStartRuleFactoryConfig<any, any, any> | InsertTextRuleFactoryConfig<any, any, any> | TextSubstitutionRuleFactoryConfig<any, any> ? InsertTextInputRuleContext : TConfig extends BlockFenceRuleFactoryConfig<any, any, any> ? SelectionInputRuleContext : TConfig extends InsertBreakRuleFactoryConfig<any, any, any> ? InsertBreakInputRuleContext : InsertDataInputRuleContext;
+declare function createRuleFactory<TRequired extends object = {}, TDefaults extends object = {}, TMatch = unknown, TConfig extends AnyRuleFactoryConfig<TDefaults, TRequired, TMatch> = AnyRuleFactoryConfig<TDefaults, TRequired, TMatch>>(config: TConfig & TDefaults): CreateRuleFactoryReturn<ContextFromFactoryConfig<TConfig>, TDefaults, TRequired>;
+declare function createRuleFactory<TRequired extends object = {}, TDefaults extends object = {}>(configBuilder: RuleFactoryConfigBuilder<SelectionInputRuleContext | InsertTextInputRuleContext | InsertBreakInputRuleContext | InsertDataInputRuleContext, TDefaults, TRequired, AnyRuleFactoryConfigLoose<TDefaults, TRequired>>): CreateRuleFactoryReturn<SelectionInputRuleContext | InsertTextInputRuleContext | InsertBreakInputRuleContext | InsertDataInputRuleContext, TDefaults, TRequired>;
+//#endregion
+//#region src/lib/plugins/input-rules/defineInputRule.d.ts
+declare function defineInputRule<TMatch = true, TEditor extends SlateEditor = SlateEditor>(rule: InsertBreakInputRule<TMatch, TEditor>): InsertBreakInputRule<TMatch, TEditor>;
+declare function defineInputRule<TMatch = true, TEditor extends SlateEditor = SlateEditor>(rule: InsertDataInputRule<TMatch, TEditor>): InsertDataInputRule<TMatch, TEditor>;
+declare function defineInputRule<TMatch = true, TEditor extends SlateEditor = SlateEditor>(rule: InsertTextInputRule<TMatch, TEditor>): InsertTextInputRule<TMatch, TEditor>;
+declare function defineInputRule<TRule extends AnyInputRule>(rule: TRule): TRule;
+//#endregion
 //#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>;
@@ -3378,6 +2116,7 @@ type BasePlugin<C extends AnyPluginConfig = PluginConfig> = {
      *
      * - `'default'`: Default behavior
      * - `'exit'`: Exit the current block
+     * - `'lift'`: Lift the current block out of the nearest matching ancestor
      * - `'reset'`: Reset block to default paragraph type
      * - `'lineBreak'`: Insert newline character
      * - `'deleteExit'`: Delete backward then exit
@@ -3387,6 +2126,7 @@ type BasePlugin<C extends AnyPluginConfig = PluginConfig> = {
      * Defines actions on delete based on block state.
      *
      * - `'default'`: Default behavior
+     * - `'lift'`: Lift the current block out of the nearest matching ancestor
      * - `'reset'`: Reset block to default paragraph type
      */
     delete?: DeleteRules;
@@ -3557,7 +2297,7 @@ type BaseTransformOptions = GetInjectNodePropsOptions & {
 };
 type BreakRules = {
   /** Action when Enter is pressed in an empty block. */
-  empty?: 'default' | 'deleteExit' | 'exit' | 'reset';
+  empty?: 'default' | 'deleteExit' | 'exit' | 'lift' | 'reset';
   /**
    * Action when Enter is pressed at the end of an empty line. This is typically
    * used with `default: 'lineBreak'`.
@@ -3598,7 +2338,7 @@ type DeleteRules = {
    *     </blockquote>
    * ```
    */
-  start?: 'default' | 'reset';
+  start?: 'default' | 'lift' | 'reset';
   /** Action when Backspace is pressed and the block is empty. */
   empty?: 'default' | 'reset';
 };
@@ -3795,6 +2535,7 @@ type SlateEditor = BaseEditor & {
   meta: BaseEditor['meta'] & {
     /** An array of plugins that are currently being used by the editor. */
     pluginList: AnyEditorPlugin[];
+    inputRules: ResolvedInputRulesMeta;
     shortcuts: any;
   };
   plugins: Record<string, AnyEditorPlugin>;
@@ -3810,6 +2551,7 @@ type TSlateEditor<V extends Value = Value, P extends AnyPluginConfig = CorePlugi
   api: EditorApi<V> & UnionToIntersection<InferApi<CorePlugin | P>>;
   children: V;
   meta: BaseEditor['meta'] & {
+    inputRules: ResolvedInputRulesMeta;
     pluginList: P[];
     shortcuts: any;
   };
@@ -3887,6 +2629,15 @@ type BaseWithSlateOptions<P extends AnyPluginConfig = CorePlugin> = {
    * limit is reached, further input will be prevented.
    */
   maxLength?: number;
+  /**
+   * Configuration for the built-in navigation feedback plugin.
+   *
+   * This core plugin flashes the landed target after navigation jumps such as
+   * TOC, footnote, search, or custom outline movement.
+   *
+   * @default { duration: 1600 }
+   */
+  navigationFeedback?: NavigationFeedbackConfig['options'] | boolean;
   /**
    * Configuration for automatic node ID generation and management.
    *
@@ -3987,6 +2738,7 @@ declare const withSlate: <V extends Value = Value, P extends AnyPluginConfig = C
   autoSelect,
   chunking,
   maxLength,
+  navigationFeedback,
   nodeId,
   optionsStoreFactory,
   plugins,
@@ -4073,6 +2825,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 +2839,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 +2854,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;
   /**
@@ -4174,7 +2932,7 @@ declare const getSlateElements: (element: HTMLElement) => HTMLElement[];
 declare const defaultsDeepToNodes: <N$1 extends TNode>(options: Omit<ApplyDeepToNodesOptions<N$1>, "apply">) => void;
 //#endregion
 //#region src/lib/utils/getInjectMatch.d.ts
-declare const getInjectMatch: <E extends SlateEditor>(editor: E, plugin: EditorPlugin) => (node: TNode, path: Path) => boolean;
+declare const getInjectMatch: <E extends SlateEditor>(editor: E, plugin: EditorPlugin) => (node: TNode, path?: Path) => boolean;
 //#endregion
 //#region src/lib/utils/getInjectedPlugins.d.ts
 /**
@@ -4271,7 +3029,7 @@ declare const normalizeDescendantsToDocumentFragment: (editor: SlateEditor, {
 }) => Descendant[];
 //#endregion
 //#region src/lib/utils/omitPluginContext.d.ts
-declare const omitPluginContext: <T extends SlatePluginContext<AnySlatePlugin>>(ctx: T) => Omit<T, "api" | "editor" | "getOptions" | "getOption" | "tf" | "type" | "setOptions" | "setOption" | "plugin">;
+declare const omitPluginContext: <T extends SlatePluginContext<AnySlatePlugin>>(ctx: T) => Omit<T, "api" | "editor" | "plugin" | "type" | "getOption" | "tf" | "getOptions" | "setOptions" | "setOption">;
 //#endregion
 //#region src/lib/utils/overridePluginsByKey.d.ts
 /**
@@ -4290,5 +3048,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 $, SlateHTMLProps as $a, Serializer as $i, cleanHtmlFontElements as $n, SlateExtensionConfig as $r, upsertInlineFormattingContext as $t, applyDeepToNodes as A, ResolvedInputRule as Aa, AnySlatePlugin as Ai, isHtmlInlineElement as An, AstPlugin as Ao, PlateError as Ar, BaseParagraphPlugin as At, ZustandStoreApi as B, getSelectedDomNode as Ba, InjectNodeProps as Bi, htmlBrToNewLine as Bn, navigate as Br, STATIC_VALUE_CREATED_AT as Bt, isSlateNode as C, InsertDataInputRuleContext as Ca, getPluginType as Ci, pipeDeserializeHtmlLeaf as Cn, SlateRenderLeaf as Co, NodeIdOptions as Cr, NodeComponents as Ct, isSlateText as D, MatchBlockFenceOptions as Da, createSlatePlugin as Di, isOlSymbol as Dn, SlateRenderElement as Do, DebugErrorType as Dr, SelectionRules as Dt, isSlateString as E, MarkInputRuleConfig as Ea, getEditorPlugin as Ei, parseHtmlDocument as En, pipeRenderElementStatic as Eo, normalizeNodeId as Er, PluginConfig as Et, RenderLeafProps as F, TextSubstitutionPattern as Fa, ExtendEditorApi as Fi, inlineTagNames as Fn, getEdgeNodes as Fr, withBreakRules as Ft, WithSlateOptions as G, getPluginDataAttributes as Ga, NodeStaticWrapperComponentReturnType as Gi, someHtmlElement as Gn, NAVIGATION_FEEDBACK_KEY as Gr, createBlockFenceInputRule as Gt, nanoid$1 as H, getSelectedDomBlocks as Ha, NodeStaticProps as Hi, getHtmlComments as Hn, flashTarget as Hr, LengthPlugin as Ht, RenderElementFn as I, stripSlateDataAttributes as Ia, ExtendEditorTransforms as Ii, htmlTextNodeToString as In, EdgeNodes as Ir, OverridePlugin as It, BaseEditor as J, ViewPlugin as Ja, Parser as Ji, deserializeHtmlElement as Jn, NavigationFeedbackPluginKey as Jr, createTextSubstitutionInputRule as Jt, createSlateEditor as K, createStaticString as Ka, NormalizeInitialValue as Ki, deserializeHtmlNodeChildren as Kn, NavigationFeedbackActiveTarget as Kr, createBlockStartInputRule as Kt, RenderElementProps as L, stripHtmlClassNames as La, HtmlDeserializer as Li, htmlStringToDOMNode as Ln, AffinityConfig as Lr, withOverrides as Lt, RenderTextFn as M, SelectionInputRuleContext as Ma, Deserializer as Mi, isHtmlElement as Mn, isNodeAffinity as Mr, withNormalizeRules as Mt, RenderTextProps as N, TextSubstitutionInputRuleConfig as Na, EditorPlugin as Ni, isHtmlComment as Nn, isNodesAffinity as Nr, withMergeRules as Nt, isSlateVoid as O, MatchBlockStartOptions as Oa, createTSlatePlugin as Oi, isHtmlText as On, pluginRenderElementStatic as Oo, DebugPlugin as Or, WithAnyKey as Ot, RenderLeafFn as P, TextSubstitutionMatch as Pa, ExtendEditor as Pi, isHtmlBlockElement as Pn, getMarkBoundaryAffinity as Pr, withDeleteRules as Pt, SlateEditor as Q, SlateElementProps as Qa, RenderStaticNodeWrapperProps as Qi, cleanHtmlLinkElements as Qn, NavigationNavigateOptions as Qr, endInlineFormattingContext as Qt, RenderChunkFn as R, pipeDecorate as Ra, HtmlSerializer as Ri, htmlElementToLeaf as Rn, AffinityPlugin as Rr, withNodeId as Rt, isSlateLeaf as S, InsertDataInputRule as Sa, getPluginKeys as Si, pluginDeserializeHtml as Sn, pluginRenderTextStatic as So, NodeIdConfig as Sr, NodeComponent as St, isSlatePluginNode as T, InsertTextInputRuleContext as Ta, getSlatePlugin as Ti, parseHtmlElement as Tn, pluginRenderLeafStatic as To, NormalizeNodeIdOptions as Tr, ParserOptions as Tt, BaseWithSlateOptions as U, getRenderNodeStaticProps as Ua, NodeStaticWrapperComponent as Ui, getDataNodeProps as Un, resolveNavigationFeedbackTarget as Ur, defineInputRule as Ut, createZustandStore$1 as V, getSelectedDomFragment as Va, LeafStaticProps as Vi, htmlBodyToFragment as Vn, clearNavigationFeedbackTarget as Vr, normalizeStaticValue as Vt, CreateSlateEditorOptions as W, getNodeDataAttributes as Wa, NodeStaticWrapperComponentProps as Wi, findHtmlElement as Wn, NavigationFeedbackPlugin as Wr, createRuleFactory as Wt, KeyofNodePlugins as X, getEditorDOMFromHtmlString as Xa, RenderStaticNodeWrapper as Xi, copyBlockMarksToSpanChild as Xn, NavigationFeedbackTarget as Xr, matchBlockStart as Xt, InferPlugins as Y, createStaticEditor as Ya, PartialEditorPlugin as Yi, deserializeHtml as Yn, NavigationFeedbackStoredTarget as Yr, matchBlockFence as Yt, KeyofPlugins as Z, SlateElement as Za, RenderStaticNodeWrapperFunction as Zi, cleanHtmlTextNodes as Zn, NavigationFlashTargetOptions as Zr, matchDelimitedInline as Zt, getInjectMatch as _, InputRulesConfig as _a, HistoryPlugin as _i, replaceTagName as _n, LeafStatic as _o, GetCorePluginsOptions as _r, InferOptions as _t, omitPluginContext as a, SlateShortcut as aa, InsertExitBreakOptions as ai, collapseWhiteSpaceChildren as an, StyledSlateElementProps as ao, CARRIAGE_RETURN as ar, BasePluginContext as at, isSlateEditor as b, InsertBreakInputRule as ba, getPluginByType as bi, preCleanHtml as bn, SlateRenderText as bo, ChunkingConfig as br, MatchRules as bt, isType as c, AnyInputRule as ca, init as ci, CollapseWhiteSpaceState as cn, useNodeAttributes as co, SPACE as cr, BaseTransformOptions as ct, isHotkey as d, BlockFenceInputRuleMatch as da, DOMPlugin as di, WhiteSpaceRule as dn, SlateRenderLeafProps as do, HtmlPlugin as dr, EditOnlyConfig as dt, SlatePlugin as ea, SlateExtensionPlugin as ei, isLastNonEmptyTextOfInlineFormattingContext as en, SlateLeaf as eo, cleanHtmlEmptyElements as er, AnyPluginConfig as et, getSlateClass as f, BlockStartInputRuleConfig as fa, DomConfig as fi, unwrapHtmlElement as fn, SlateRenderNodeProps as fo, withChunking as fr, ExtendConfig as ft, getInjectedPlugins as g, InputRuleTarget as ga, ParserPlugin as gi, traverseHtmlComments as gn, ElementStatic as go, DebugConfig as gr, InferKey as gt, keyToDataAttribute as h, InputRuleBuilder as ha, withScrolling as hi, traverseHtmlElements as hn, serializeHtml as ho, CorePluginTransforms as hr, InferApi as ht, overridePluginsByKey as i, SlatePlugins as ia, liftBlock as ii, collapseWhiteSpaceElement as in, SlateTextProps as io, DeserializeHtmlNodeReturnType as ir, BasePlugin as it, EditableProps as j, ResolvedInputRulesMeta as ja, Decorate as ji, isHtmlFragmentHref as jn, setAffinitySelection as jr, ParagraphConfig as jt, ApplyDeepToNodesOptions as k, MatchDelimitedInlineOptions as ka, AnyEditorPlugin as ki, isHtmlTable as kn, HandlerReturnType as ko, LogLevel as kr, WithRequiredKey as kt, Hotkeys as l, BaseInputRule as la, AUTO_SCROLL as li, TrimEndRule as ln, BoxStaticProps as lo, TAB as lr, BreakRules as lt, getNodeDataAttributeKeys as m, DelimitedInlineInputRuleMatch as ma, WithAutoScrollOptions as mi, traverseHtmlNode as mn, SerializeHtmlOptions as mo, CorePluginApi as mr, GetInjectNodePropsReturnType as mt, pipeOnNodeChange as n, SlatePluginContext as na, resetBlock as ni, collapseWhiteSpaceText as nn, SlateNodeProps as no, cleanHtmlBrElements as nr, BaseHtmlDeserializer as nt, normalizeDescendantsToDocumentFragment as o, TextStaticProps as oa, insertExitBreak as oi, collapseWhiteSpace as on, StyledSlateLeafProps as oo, LINE_FEED as or, BasePluginNode as ot, getPluginNodeProps as p, BlockStartInputRuleMatch as pa, ScrollMode as pi, traverseHtmlTexts as pn, SlateRenderTextProps as po, CorePlugin as pr, GetInjectNodePropsOptions as pt, withSlate as q, getStaticPlugins as qa, OverrideEditor as qi, deserializeHtmlNode as qn, NavigationFeedbackConfig as qr, createMarkInputRule as qt, pipeInsertDataQuery as r, SlatePluginMethods as ra, LiftBlockOptions as ri, collapseWhiteSpaceNode as rn, SlateText as ro, DeserializeHtmlChildren as rr, BaseInjectProps as rt, mergeDeepToNodes as s, TransformOptions as sa, InitOptions as si, collapseString as sn, StyledSlateTextProps as so, NO_BREAK_SPACE as sr, BaseSerializer as st, pipeOnTextChange as t, SlatePluginConfig$1 as ta, setValue as ti, inferWhiteSpaceRule as tn, SlateLeafProps as to, cleanHtmlCrLf as tr, BaseDeserializer as tt, createHotkey as u, BlockFenceInputRuleConfig as ua, AutoScrollOperationsMap as ui, TrimStartRule as un, SlateRenderElementProps as uo, ZERO_WIDTH_SPACE as ur, DeleteRules as ut, defaultsDeepToNodes as v, InputRulesDefinition as va, withPlateHistory as vi, removeHtmlSurroundings as vn, PlateStatic as vo, LengthConfig as vr, InferSelectors as vt, isSlatePluginElement as w, InsertTextInputRule as wa, getPluginTypes as wi, pipeDeserializeHtmlElement as wn, pipeRenderLeafStatic as wo, NodeIdPlugin as wr, NormalizeRules as wt, isSlateElement as x, InsertBreakInputRuleContext as xa, getPluginKey as xi, postCleanHtml as xn, pipeRenderTextStatic as xo, ChunkingPlugin as xr, MergeRules as xt, getSlateElements as y, InputRulesFactoryContext as ya, getContainerTypes as yi, removeHtmlNodesBetweenComments as yn, PlateStaticProps as yo, getCorePlugins as yr, InferTransforms as yt, RenderChunkProps as z, isSelectOutside as za, InferConfig as zi, htmlElementToElement as zn, ElementAffinity as zr, NormalizeStaticValueOptions as zt };