@lofcz/platejs-core 52.3.4

package/dist/index-NTp--CEF.d.ts

@@ -0,0 +1,4294 @@
+import * as _platejs_slate1 from "@platejs/slate";
+import { Ancestor, DOMRange, DecoratedRange, Descendant, Editor, EditorAboveOptions, EditorApi, EditorBase, EditorTransforms, LeafPosition, NodeEntry, NodeOf, NodeOperation, Operation, Path, QueryNodeOptions, ScrollIntoViewOptions, TElement, TNode, TRange, TSelection, TText, TextOperation, Value } from "@platejs/slate";
+import { nanoid as nanoid$1 } from "nanoid";
+import { AnyObject, Deep2Partial, Modify, Nullable, OmitFirst, Simplify, UnionToIntersection, UnknownObject } from "@udecode/utils";
+import { 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 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
+/**
+ * Enables support for deserializing inserted content from Slate Ast format to
+ * Slate format while apply a small bug fix.
+ */
+declare const AstPlugin: SlatePlugin<PluginConfig<"ast", {}, {}, {}, {}>>;
+//#endregion
+//#region src/lib/plugin/HandlerReturnType.d.ts
+/** If true, the next handlers will be skipped. */
+type HandlerReturnType = boolean | void;
+//#endregion
+//#region src/static/pluginRenderElementStatic.d.ts
+type SlateRenderElement = (props: RenderElementProps) => React$1.ReactElement<any> | undefined;
+declare const pluginRenderElementStatic: (editor: SlateEditor, plugin: AnyEditorPlugin) => SlateRenderElement;
+//#endregion
+//#region src/static/pipeRenderElementStatic.d.ts
+declare const pipeRenderElementStatic: (editor: SlateEditor, {
+  renderElement: renderElementProp
+}?: {
+  renderElement?: SlateRenderElement;
+}) => SlateRenderElement;
+//#endregion
+//#region src/static/pluginRenderLeafStatic.d.ts
+type SlateRenderLeaf = (props: RenderLeafProps) => React$1.ReactElement<any> | undefined;
+declare const pluginRenderLeafStatic: (editor: SlateEditor, plugin: SlatePlugin) => SlateRenderLeaf;
+/** @see {@link RenderLeaf} */
+declare const pipeRenderLeafStatic: (editor: SlateEditor, {
+  renderLeaf: renderLeafProp
+}?: {
+  renderLeaf?: SlateRenderLeaf;
+}) => SlateRenderLeaf;
+//#endregion
+//#region src/static/pluginRenderTextStatic.d.ts
+type SlateRenderText = (props: RenderTextProps) => React$1.ReactElement<any> | undefined;
+declare const pluginRenderTextStatic: (editor: SlateEditor, plugin: SlatePlugin) => SlateRenderText;
+/** @see {@link RenderText} */
+declare const pipeRenderTextStatic: (editor: SlateEditor, {
+  renderText: renderTextProp
+}?: {
+  renderText?: SlateRenderText;
+}) => SlateRenderText;
+//#endregion
+//#region src/static/components/PlateStatic.d.ts
+declare function BaseElementStatic({
+  decorate,
+  decorations,
+  editor,
+  element
+}: {
+  decorate: EditableProps['decorate'];
+  decorations: DecoratedRange[];
+  editor: SlateEditor;
+  element: TElement;
+  style?: React$1.CSSProperties;
+}): React$1.JSX.Element;
+declare const ElementStatic: React$1.MemoExoticComponent<typeof BaseElementStatic>;
+declare function BaseLeafStatic({
+  decorations,
+  editor,
+  text
+}: {
+  decorations: DecoratedRange[];
+  editor: SlateEditor;
+  text: TText;
+}): React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>> | undefined;
+declare const LeafStatic: React$1.MemoExoticComponent<typeof BaseLeafStatic>;
+type PlateStaticProps = {
+  /** Editor instance. */
+  editor: SlateEditor;
+  style?: React$1.CSSProperties;
+  /** Controlled value. Alias to `editor.children`. */
+  value?: Value;
+} & React$1.HTMLAttributes<HTMLDivElement>;
+declare function PlateStatic(props: PlateStaticProps): React$1.ReactElement<unknown, string | React$1.JSXElementConstructor<any>>;
+//#endregion
+//#region src/static/serializeHtml.d.ts
+type SerializeHtmlOptions<T extends PlateStaticProps = PlateStaticProps> = {
+  /** The component used to render the editor content */
+  editorComponent?: React$1.ComponentType<T>;
+  /** List of className prefixes to preserve from being stripped out */
+  preserveClassNames?: string[];
+  /** Props to pass to the editor component */
+  props?: Partial<T>;
+  /** Enable stripping class names */
+  stripClassNames?: boolean;
+  /** Enable stripping data attributes */
+  stripDataAttributes?: boolean;
+};
+/**
+ * Serialize the editor content to HTML. By default, uses `PlateStatic` as the
+ * editor component, but you can provide a custom component (e.g.
+ * `EditorStatic`).
+ */
+declare const serializeHtml: <T extends PlateStaticProps = PlateStaticProps>(editor: SlateEditor, {
+  editorComponent: EditorComponent,
+  preserveClassNames,
+  props,
+  stripClassNames,
+  stripDataAttributes
+}?: SerializeHtmlOptions<T>) => Promise<string>;
+//#endregion
+//#region src/static/types.d.ts
+type BoxStaticProps = React.ComponentProps<'div'> & {
+  as?: React.ElementType;
+};
+type SlateRenderElementProps<N$1 extends TElement = TElement, C extends AnyPluginConfig = PluginConfig> = SlateRenderNodeProps<C> & RenderElementProps<N$1>;
+type SlateRenderLeafProps<N$1 extends TText = TText, C extends AnyPluginConfig = PluginConfig> = SlateRenderNodeProps<C> & RenderLeafProps<N$1>;
+type SlateRenderNodeProps<C extends AnyPluginConfig = PluginConfig> = SlatePluginContext<C> & {
+  attributes?: AnyObject;
+  className?: string;
+  /** @see {@link NodeProps} */
+  nodeProps?: AnyObject;
+};
+type SlateRenderTextProps<N$1 extends TText = TText, C extends AnyPluginConfig = PluginConfig> = SlateRenderNodeProps<C> & RenderTextProps<N$1>;
+//#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;
+  /**
+   * When true, only apply to text nodes in non-void nodes or markable void
+   * nodes
+   */
+  marks?: boolean;
+  merge?: PropsMerge;
+  split?: boolean;
+} & QueryOptions<V> & QueryMode & QueryVoids;
+type SplitNodesOptions<V extends Value$1 = Value$1> = {
+  always?: boolean;
+  height?: number;
+} & QueryOptions<V> & QueryMode & QueryVoids;
+type ToggleBlockOptions = {
+  /** The default block type to revert to when untoggling. Defaults to paragraph. */
+  defaultType?: string;
+  someOptions?: EditorNodesOptions;
+  /**
+   * If true, toggles wrapping the block with the specified type. Otherwise,
+   * toggles the block type directly.
+   */
+  wrap?: boolean;
+} & SetNodesOptions;
+type ToggleMarkOptions = {
+  /** Mark keys to remove when adding the mark. */
+  remove?: string[] | string;
+};
+type UnsetNodesOptions<V extends Value$1 = Value$1> = {
+  hanging?: boolean;
+  split?: boolean;
+} & QueryOptions<V> & QueryMode & QueryVoids;
+type UnwrapNodesOptions<V extends Value$1 = Value$1> = {
+  hanging?: boolean;
+  split?: boolean;
+} & QueryOptions<V> & QueryMode & QueryVoids;
+type WrapNodesOptions<V extends Value$1 = Value$1> = {
+  /**
+   * When true, wrap node children into a single element:
+   *
+   * - Wraps the first child node into the element
+   * - Move the other child nodes next to the element children
+   */
+  children?: boolean;
+  hanging?: boolean;
+  /**
+   * Indicates that it's okay to split a node in order to wrap the location. For
+   * example, if `ipsum` was selected in a `Text` node with `lorem ipsum dolar`,
+   * `split: true` would wrap the word `ipsum` only, resulting in splitting the
+   * `Text` node. If `split: false`, the entire `Text` node `lorem ipsum dolar`
+   * would be wrapped.
+   */
+  split?: boolean;
+} & QueryOptions<V> & QueryMode & QueryVoids;
+type PropsCompare = (prop: Partial<Descendant$1>, node: Partial<Descendant$1>) => boolean;
+type PropsMerge = (prop: Partial<Descendant$1>, node: Partial<Descendant$1>) => object;
+//#endregion
+//#region src/interfaces/editor/legacy-editor.d.ts
+
+//#endregion
+//#region src/interfaces/element.d.ts
+/**
+ * `TElement` objects are a type of node in a Slate document that contain other
+ * element nodes or text nodes. They can be either "blocks" or "inlines"
+ * depending on the Slate editor's configuration.
+ */
+type TElement$1 = {
+  children: Descendant$1[];
+  type: string;
+} & UnknownObject;
+/** Element retrieval and check methods. */
+
+/** A utility type to get all the element nodes type from a root node. */
+type ElementIn<V extends Value$1> = ElementOf<V[number]>;
+type ElementOf<N$1 extends TNode$1> = Editor$1 extends N$1 ? TElement$1 : TElement$1 extends N$1 ? TElement$1 : N$1 extends Editor$1 ? ElementOf<N$1['children'][number]> | Extract<N$1['children'][number], TElement$1> : N$1 extends TElement$1 ? ElementOf<N$1['children'][number]> | Extract<N$1['children'][number], TElement$1> | N$1 : never;
+/**
+ * `ElementEntry` objects refer to an `Element` and the `Path` where it can be
+ * found inside a root node.
+ */
+/** Element or text of an editor. */
+type ElementOrTextIn<V extends Value$1> = ElementIn<V> | TextIn<V>;
+//#endregion
+//#region src/slate-history/history.d.ts
+/** `HistoryApi` contains helpers for history-enabled editors. */
+declare const HistoryApi: {
+  /** Check if a value is a `History` object. */
+  isHistory(value: any): value is History;
+  /** Get the merge flag's current value. */
+  isMerging(editor: Editor$1): boolean | undefined;
+  /** Get the splitting once flag's current value. */
+  isSaving(editor: Editor$1): boolean | undefined;
+  isSplittingOnce(editor: Editor$1): boolean | undefined;
+  /** Get the saving flag's current value. */
+  redo(editor: Editor$1): void;
+  /** Redo to the previous saved state. */
+  setSplittingOnce(editor: Editor$1, value: boolean | undefined): void;
+  /** Undo to the previous saved state. */
+  undo(editor: Editor$1): void;
+  /**
+   * Apply a series of changes inside a synchronous `fn`, These operations will
+   * be merged into the previous history.
+   */
+  withMerging(editor: Editor$1, fn: () => void): void;
+  /**
+   * Apply a series of changes inside a synchronous `fn`, ensuring that the
+   * first operation starts a new batch in the history. Subsequent operations
+   * will be merged as usual.
+   */
+  withNewBatch(editor: Editor$1, fn: () => void): void;
+  /**
+   * Apply a series of changes inside a synchronous `fn`, without merging any of
+   * the new operations into previous save point in the history.
+   */
+  withoutMerging(editor: Editor$1, fn: () => void): void;
+  /**
+   * Apply a series of changes inside a synchronous `fn`, without saving any of
+   * their operations into the history.
+   */
+  withoutSaving(editor: Editor$1, fn: () => void): void;
+};
+type History = {
+  /** Redos of the editor. */
+  redos: Batch[];
+  /** Undos of the editor. */
+  undos: Batch[];
+};
+/**
+ * `History` objects hold all of the operations that are applied to a value, so
+ * they can be undone or redone as necessary.
+ */
+type Batch = {
+  operations: Operation$1[];
+  selectionBefore: TRange$1 | null;
+};
+//#endregion
+//#region src/interfaces/editor/editor-type.d.ts
+type Editor$1<V extends Value$1 = Value$1> = EditorBase$1<V> & {
+  api: EditorApi$1<V>;
+  tf: EditorTransforms$1<V>;
+  transforms: EditorTransforms$1<V>;
+};
+type EditorBase$1<V extends Value$1 = Value$1> = {
+  /** Unique identifier for the editor. */
+  id: string;
+  /** Value of the editor. */
+  children: V;
+  /** Contains the undos and redos of the editor. */
+  history: History;
+  /** Marks that are currently applied to the editor. */
+  marks: EditorMarks | null;
+  /**
+   * Editor metadata. Use this for custom fields instead of extending the editor
+   * directly.
+   */
+  meta: UnknownObject & {
+    isNormalizing?: boolean;
+  };
+  /** Operations that have been applied to the editor. */
+  operations: Operation$1<DescendantIn$1<V>>[];
+  /** The current selection of the editor. */
+  selection: EditorSelection;
+} & EditorMethods<V> & UnknownObject;
+type EditorMarks = Record<string, any>;
+type EditorMethods<V extends Value$1 = Value$1> = Pick<EditorTransforms$1<V>, 'redo' | 'undo'>;
+type EditorSelection = TRange$1 | null;
+type Value$1 = TElement$1[];
+/** A helper type for getting the value of an editor. */
+type ValueOf$1<E extends Editor$1> = E['children'];
+//#endregion
+//#region src/create-editor.d.ts
+//#endregion
+//#region src/static/plugins/ViewPlugin.d.ts
+declare const ViewPlugin: SlatePlugin<PluginConfig<"dom", {
+  scrollMode?: ScrollMode;
+  scrollOperations?: AutoScrollOperationsMap;
+  scrollOptions?: ScrollIntoViewOptions$1;
+}, {
+  getFragment: () => Descendant$1[];
+  isScrolling: () => boolean;
+}, {
+  withScrolling: (fn: () => void, options?: WithAutoScrollOptions | undefined) => void;
+}, {}>>;
+//#endregion
+//#region src/static/plugins/getStaticPlugins.d.ts
+declare const getStaticPlugins: () => SlatePlugin<PluginConfig<"dom", {
+  scrollMode?: ScrollMode;
+  scrollOperations?: AutoScrollOperationsMap;
+  scrollOptions?: ScrollIntoViewOptions$1;
+}, {
+  getFragment: () => Descendant$1[];
+  isScrolling: () => boolean;
+}, {
+  withScrolling: (fn: () => void, options?: WithAutoScrollOptions | undefined) => void;
+}, {}>>[];
+//#endregion
+//#region src/static/utils/createStaticString.d.ts
+declare function createStaticString({
+  text
+}: {
+  text: string;
+}): React$1.ReactElement<{
+  'data-slate-string': boolean;
+}, string | React$1.JSXElementConstructor<any>>;
+//#endregion
+//#region src/static/utils/getNodeDataAttributes.d.ts
+declare const getNodeDataAttributes: (editor: SlateEditor, node: TElement | TText, {
+  isElement,
+  isLeaf,
+  isText
+}: {
+  isElement?: boolean;
+  isLeaf?: boolean;
+  isText?: boolean;
+}) => Record<string, any>;
+declare const getPluginDataAttributes: (editor: SlateEditor, plugin: AnyEditorPlugin, node: TElement | TText) => {
+  [x: string]: any;
+};
+//#endregion
+//#region src/static/utils/getRenderNodeStaticProps.d.ts
+declare const getRenderNodeStaticProps: ({
+  attributes: nodeAttributes,
+  editor,
+  node,
+  plugin,
+  props
+}: {
+  editor: SlateEditor;
+  props: SlateRenderNodeProps;
+  attributes?: AnyObject;
+  node?: TElement | TText;
+  plugin?: AnyEditorPlugin;
+}) => SlateRenderNodeProps;
+//#endregion
+//#region src/static/utils/getSelectedDomBlocks.d.ts
+/** Get the slate nodes from the DOM selection */
+/** @deprecated Use getSelectedDomFragment instead */
+declare const getSelectedDomBlocks: () => Element[] | undefined;
+//#endregion
+//#region src/static/utils/getSelectedDomFragment.d.ts
+declare const getSelectedDomFragment: (editor: SlateEditor) => Descendant[];
+//#endregion
+//#region src/static/utils/getSelectedDomNode.d.ts
+/** Get the DOM node from the DOM selection */
+declare const getSelectedDomNode: () => HTMLDivElement | undefined;
+//#endregion
+//#region src/static/utils/isSelectOutside.d.ts
+/** Check if the DOM selection is outside the editor */
+declare const isSelectOutside: (html?: HTMLElement) => boolean;
+//#endregion
+//#region src/static/utils/pipeDecorate.d.ts
+/**
+ * @see {@link Decorate} .
+ * Optimization: return undefined if empty list so Editable uses a memo.
+ */
+declare const pipeDecorate: (editor: SlateEditor, decorateProp?: ((ctx: {
+  editor: SlateEditor;
+  entry: NodeEntry;
+}) => TRange[] | undefined) | null) => EditableProps["decorate"];
+//#endregion
+//#region src/static/utils/stripHtmlClassNames.d.ts
+/**
+ * Remove all class names that do not start with one of preserveClassNames
+ * (`slate-` by default)
+ */
+declare const stripHtmlClassNames: (html: string, {
+  preserveClassNames
+}: {
+  preserveClassNames?: string[];
+}) => string;
+//#endregion
+//#region src/static/utils/stripSlateDataAttributes.d.ts
+declare const stripSlateDataAttributes: (rawHtml: string) => string;
+//#endregion
+//#region src/lib/plugin/SlatePlugin.d.ts
+type AnyEditorPlugin = EditorPlugin<AnyPluginConfig>;
+type AnySlatePlugin = SlatePlugin<AnyPluginConfig>;
+/**
+ * Property used by Plate to decorate editor ranges. If the function returns
+ * undefined then no ranges are modified. If the function returns an array the
+ * returned ranges are merged with the ranges called by other plugins.
+ */
+type Decorate<C extends AnyPluginConfig = PluginConfig> = (ctx: SlatePluginContext<C> & {
+  entry: NodeEntry;
+}) => DecoratedRange[] | undefined;
+type Deserializer<C extends AnyPluginConfig = PluginConfig> = BaseDeserializer & {
+  parse?: (options: AnyObject & SlatePluginContext<C> & {
+    element: any;
+  }) => Partial<Descendant> | undefined | void;
+  query?: (options: AnyObject & SlatePluginContext<C> & {
+    element: any;
+  }) => boolean;
+};
+type EditorPlugin<C extends AnyPluginConfig = PluginConfig> = Omit<SlatePlugin<C>, keyof SlatePluginMethods | 'override' | 'plugins'>;
+/** Plate plugin overriding the `editor` methods. Naming convention is `with*`. */
+type ExtendEditor<C extends AnyPluginConfig = PluginConfig> = (ctx: SlatePluginContext<C>) => SlateEditor;
+type ExtendEditorApi<C extends AnyPluginConfig = PluginConfig, EA = {}> = (ctx: SlatePluginContext<C>) => EA & Deep2Partial<EditorApi & CorePluginApi> & { [K in keyof InferApi<C>]?: InferApi<C>[K] extends ((...args: any[]) => any) ? (...args: Parameters<InferApi<C>[K]>) => ReturnType<InferApi<C>[K]> : InferApi<C>[K] extends Record<string, (...args: any[]) => any> ? { [N in keyof InferApi<C>[K]]?: (...args: Parameters<InferApi<C>[K][N]>) => ReturnType<InferApi<C>[K][N]> } : never };
+type ExtendEditorTransforms<C extends AnyPluginConfig = PluginConfig, EA = {}> = (ctx: SlatePluginContext<C>) => EA & Deep2Partial<EditorTransforms & CorePluginTransforms> & { [K in keyof InferTransforms<C>]?: InferTransforms<C>[K] extends ((...args: any[]) => any) ? (...args: Parameters<InferTransforms<C>[K]>) => ReturnType<InferTransforms<C>[K]> : InferTransforms<C>[K] extends Record<string, (...args: any[]) => any> ? { [N in keyof InferTransforms<C>[K]]?: (...args: Parameters<InferTransforms<C>[K][N]>) => ReturnType<InferTransforms<C>[K][N]> } : never };
+type HtmlDeserializer<C extends AnyPluginConfig = PluginConfig> = BaseHtmlDeserializer & {
+  /**
+   * Whether to disable the default node props parsing logic. By default, all
+   * data-slate-* attributes will be parsed into node props.
+   *
+   * @default false
+   */
+  disableDefaultNodeProps?: boolean;
+  parse?: (options: SlatePluginContext<C> & {
+    element: HTMLElement;
+    node: AnyObject;
+  }) => Partial<Descendant> | undefined | void;
+  query?: (options: SlatePluginContext<C> & {
+    element: HTMLElement;
+  }) => boolean;
+  toNodeProps?: (options: SlatePluginContext<C> & {
+    element: HTMLElement;
+  }) => Partial<Descendant> | undefined | void;
+};
+type HtmlSerializer<C extends AnyPluginConfig = PluginConfig> = BaseSerializer & {
+  parse?: (options: SlatePluginContext<C> & {
+    node: Descendant;
+  }) => string;
+  query?: (options: SlatePluginContext<C> & {
+    node: Descendant;
+  }) => boolean;
+};
+type InferConfig<P> = P extends SlatePlugin<infer C> ? C : never;
+type InjectNodeProps<C extends AnyPluginConfig = PluginConfig> = BaseInjectProps & {
+  query?: (options: NonNullable<NonNullable<InjectNodeProps>> & SlatePluginContext<C> & {
+    nodeProps: GetInjectNodePropsOptions;
+  }) => boolean;
+  transformClassName?: (options: TransformOptions<C>) => any;
+  transformNodeValue?: (options: TransformOptions<C>) => any;
+  transformProps?: (options: TransformOptions<C> & {
+    props: GetInjectNodePropsReturnType;
+  }) => AnyObject | undefined;
+  transformStyle?: (options: TransformOptions<C>) => CSSStyleDeclaration;
+};
+type LeafStaticProps<C extends AnyPluginConfig = PluginConfig> = ((props: SlateRenderLeafProps<TText, C>) => AnyObject | undefined) | AnyObject;
+type NodeStaticProps<C extends AnyPluginConfig = PluginConfig> = ((props: SlateRenderElementProps<TElement, C> & SlateRenderLeafProps<TText, C>) => AnyObject | undefined) | AnyObject;
+/** @deprecated Use {@link RenderStaticNodeWrapper} instead. */
+type NodeStaticWrapperComponent<C extends AnyPluginConfig = PluginConfig> = (props: NodeStaticWrapperComponentProps<C>) => NodeStaticWrapperComponentReturnType<C>;
+/** @deprecated Use {@link RenderStaticNodeWrapperProps} instead. */
+interface NodeStaticWrapperComponentProps<C extends AnyPluginConfig = PluginConfig> extends SlateRenderElementProps<TElement, C> {
+  key: string;
+}
+/** @deprecated Use {@link RenderStaticNodeWrapperFunction} instead. */
+type NodeStaticWrapperComponentReturnType<C extends AnyPluginConfig = PluginConfig> = React.FC<SlateRenderElementProps<TElement, C>> | undefined;
+type NormalizeInitialValue<C extends AnyPluginConfig = PluginConfig> = (ctx: SlatePluginContext<C> & {
+  value: Value;
+}) => void;
+type OverrideEditor<C extends AnyPluginConfig = PluginConfig> = (ctx: SlatePluginContext<C>) => {
+  api?: Deep2Partial<EditorApi & CorePluginApi> & { [K in keyof InferApi<C>]?: InferApi<C>[K] extends ((...args: any[]) => any) ? (...args: Parameters<InferApi<C>[K]>) => ReturnType<InferApi<C>[K]> : InferApi<C>[K] extends Record<string, (...args: any[]) => any> ? { [N in keyof InferApi<C>[K]]?: (...args: Parameters<InferApi<C>[K][N]>) => ReturnType<InferApi<C>[K][N]> } : never };
+  transforms?: Deep2Partial<EditorTransforms & CorePluginTransforms> & { [K in keyof InferTransforms<C>]?: InferTransforms<C>[K] extends ((...args: any[]) => any) ? (...args: Parameters<InferTransforms<C>[K]>) => ReturnType<InferTransforms<C>[K]> : InferTransforms<C>[K] extends Record<string, (...args: any[]) => any> ? { [N in keyof InferTransforms<C>[K]]?: (...args: Parameters<InferTransforms<C>[K][N]>) => ReturnType<InferTransforms<C>[K][N]> } : never };
+};
+type Parser<C extends AnyPluginConfig = PluginConfig> = {
+  format?: string[] | string;
+  mimeTypes?: string[];
+  deserialize?: (options: ParserOptions & SlatePluginContext<C>) => Descendant[] | undefined;
+  preInsert?: (options: ParserOptions & SlatePluginContext<C> & {
+    fragment: Descendant[];
+  }) => HandlerReturnType;
+  query?: (options: ParserOptions & SlatePluginContext<C>) => boolean;
+  transformData?: (options: ParserOptions & SlatePluginContext<C>) => string;
+  transformFragment?: (options: ParserOptions & SlatePluginContext<C> & {
+    fragment: Descendant[];
+  }) => Descendant[];
+};
+type PartialEditorPlugin<C extends AnyPluginConfig = PluginConfig> = Omit<Partial<EditorPlugin<C>>, 'node'> & {
+  node?: Partial<EditorPlugin<C>['node']>;
+};
+type RenderStaticNodeWrapper<C extends AnyPluginConfig = PluginConfig> = (props: RenderStaticNodeWrapperProps<C>) => RenderStaticNodeWrapperFunction;
+type RenderStaticNodeWrapperFunction = ((hocProps: SlateRenderElementProps) => React.ReactNode) | undefined;
+interface RenderStaticNodeWrapperProps<C extends AnyPluginConfig = PluginConfig> extends SlateRenderElementProps<TElement, C> {
+  key: string;
+}
+type Serializer<C extends AnyPluginConfig = PluginConfig> = BaseSerializer & {
+  parse?: (options: AnyObject & SlatePluginContext<C> & {
+    node: Descendant;
+  }) => any;
+  query?: (options: AnyObject & SlatePluginContext<C> & {
+    node: Descendant;
+  }) => boolean;
+};
+/** The `PlatePlugin` interface is a base interface for all plugins. */
+type SlatePlugin<C extends AnyPluginConfig = PluginConfig> = BasePlugin<C> & Nullable<{
+  decorate?: Decorate<WithAnyKey<C>>;
+  extendEditor?: ExtendEditor<WithAnyKey<C>>;
+  normalizeInitialValue?: NormalizeInitialValue<WithAnyKey<C>>;
+}> & SlatePluginMethods<C> & {
+  handlers: Nullable<{
+    onNodeChange?: (ctx: SlatePluginContext<C> & {
+      node: Descendant;
+      operation: NodeOperation;
+      prevNode: Descendant;
+    }) => HandlerReturnType;
+    onTextChange?: (ctx: SlatePluginContext<C> & {
+      node: Descendant;
+      operation: TextOperation;
+      prevText: string;
+      text: string;
+    }) => HandlerReturnType;
+  }>;
+  inject: Nullable<{
+    nodeProps?: InjectNodeProps<WithAnyKey<C>>;
+    plugins?: Record<string, PartialEditorPlugin<AnyPluginConfig>>;
+    targetPluginToInject?: (ctx: SlatePluginContext<C> & {
+      targetPlugin: string;
+    }) => Partial<SlatePlugin<AnyPluginConfig>>;
+  }>;
+  node: {
+    /** Override `data-slate-leaf` element attributes */
+    leafProps?: LeafStaticProps<WithAnyKey<C>>;
+    /** Override node attributes */
+    props?: NodeStaticProps<WithAnyKey<C>>;
+    /** Override `data-slate-node="text"` element attributes */
+    textProps?: TextStaticProps<WithAnyKey<C>>;
+  };
+  override: {
+    components?: NodeComponents;
+    plugins?: Record<string, PartialEditorPlugin<AnyPluginConfig>>;
+  };
+  parser: Nullable<Parser<WithAnyKey<C>>>;
+  parsers: (Record<string, {
+    deserializer?: Deserializer<WithAnyKey<C>>;
+    serializer?: Serializer<WithAnyKey<C>>;
+  }> & {
+    html?: never;
+  }) | {
+    html?: Nullable<{
+      deserializer?: HtmlDeserializer<WithAnyKey<C>>;
+      serializer?: HtmlSerializer<WithAnyKey<C>>;
+    }>;
+  };
+  /**
+   * Recursive plugin support to allow having multiple plugins in a single
+   * plugin. Plate eventually flattens all the plugins into the editor.
+   */
+  plugins: any[];
+  render: Nullable<{
+    /**
+     * When other plugins' `node` components are rendered, this function can
+     * return an optional wrapper function that turns a `node`'s props to a
+     * wrapper React node as its parent. Useful for wrapping or decorating
+     * nodes with additional UI elements.
+     *
+     * NOTE: The function can run React hooks. NOTE: Do not run React hooks
+     * in the wrapper function. It is not equivalent to a React component.
+     */
+    aboveNodes?: RenderStaticNodeWrapper<WithAnyKey<C>>;
+    /**
+     * When other plugins' `node` components are rendered, this function can
+     * return an optional wrapper function that turns a `node`'s props to a
+     * wrapper React node. The wrapper node is the `node`'s child and its
+     * original children's parent. Useful for wrapping or decorating nodes
+     * with additional UI elements.
+     *
+     * NOTE: The function can run React hooks. NOTE: Do not run React hooks
+     * in the wrapper function. It is not equivalent to a React component.
+     */
+    belowNodes?: RenderStaticNodeWrapper<WithAnyKey<C>>;
+    /** Renders a component above the main Slate component, as its sibling. */
+    aboveSlate?: () => React.ReactElement<any> | null;
+    /** Renders a component after the main editor container. */
+    afterContainer?: () => React.ReactElement<any> | null;
+    /**
+     * Renders a component after the `Editable` component. This is the last
+     * render position within the editor structure.
+     */
+    afterEditable?: () => React.ReactElement<any> | null;
+    /** Renders a component before the main editor container. */
+    beforeContainer?: () => React.ReactElement<any> | null;
+    /** Renders a component before the `Editable` component. */
+    beforeEditable?: () => React.ReactElement<any> | null;
+    /**
+     * Function to render content below the root element but above its
+     * children. Similar to belowNodes but renders directly in the element
+     * rather than wrapping. Multiple plugins can provide this, and all
+     * their content will be rendered in sequence.
+     */
+    belowRootNodes?: (props: SlateElementProps<TElement, AnySlatePlugin>) => React.ReactNode;
+  }>;
+  rules: {
+    /**
+     * Function to determine if this plugin's rules should apply to a node.
+     * Used to override behavior based on node properties beyond just type
+     * matching.
+     *
+     * Example: List plugin sets `match: ({ node }) => !!node.listStyleType`
+     * to override paragraph behavior when the paragraph is a list item.
+     *
+     * @default type === node.type
+     */
+    match?: (options: {
+      node: TElement;
+      path: Path;
+      rule: MatchRules;
+    } & SlatePluginContext<C>) => boolean;
+  };
+  /**
+   * Keyboard shortcuts configuration mapping shortcut names to their key
+   * combinations and handlers. Each shortcut can link to a transform
+   * 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>>;
+};
+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;
+  node: Partial<SlatePlugin['node']>;
+  options: EO;
+  selectors: ES;
+  transforms: ET;
+}>;
+type SlatePluginContext<C extends AnyPluginConfig = PluginConfig> = BasePluginContext<C> & {
+  editor: SlateEditor;
+  plugin: EditorPlugin<C>;
+};
+type SlatePluginMethods<C extends AnyPluginConfig = PluginConfig> = {
+  __apiExtensions: ((ctx: SlatePluginContext<AnyPluginConfig>) => any)[];
+  __configuration: ((ctx: SlatePluginContext<AnyPluginConfig>) => any) | null;
+  __extensions: ((ctx: SlatePluginContext<AnyPluginConfig>) => any)[];
+  __selectorExtensions: ((ctx: SlatePluginContext<AnyPluginConfig>) => any)[];
+  clone: () => SlatePlugin<C>;
+  configure: (config: ((ctx: SlatePluginContext<C>) => SlatePluginConfig$1<C['key'], InferOptions<C>, InferApi<C>, InferTransforms<C>, InferSelectors<C>>) | SlatePluginConfig$1<C['key'], InferOptions<C>, InferApi<C>, InferTransforms<C>, InferSelectors<C>>) => SlatePlugin<C>;
+  configurePlugin: <P extends AnySlatePlugin>(plugin: Partial<P>, config: ((ctx: SlatePluginContext<P>) => SlatePluginConfig$1<any, InferOptions<P>, InferApi<P>, InferTransforms<P>, InferSelectors<P>>) | SlatePluginConfig$1<any, InferOptions<P>, InferApi<P>, InferTransforms<P>, InferSelectors<P>>) => SlatePlugin<C>;
+  extend: <EO = {}, EA = {}, ET = {}, ES = {}>(extendConfig: ((ctx: SlatePluginContext<C>) => SlatePluginConfig$1<C['key'], InferOptions<C>, InferApi<C>, InferTransforms<C>, InferSelectors<C>, EO, EA, ET, ES>) | SlatePluginConfig$1<C['key'], InferOptions<C>, InferApi<C>, InferTransforms<C>, InferSelectors<C>, EO, EA, ET, ES>) => SlatePlugin<PluginConfig<C['key'], EO & InferOptions<C>, EA & InferApi<C>, ET & InferTransforms<C>, ES & InferSelectors<C>>>;
+  extendApi: <EA extends Record<string, (...args: any[]) => any> = Record<string, never>>(extension: (ctx: SlatePluginContext<C>) => EA) => SlatePlugin<PluginConfig<C['key'], InferOptions<C>, InferApi<C> & Record<C['key'], EA>, InferTransforms<C>, InferSelectors<C>>>;
+  extendEditorApi: <EA extends Record<string, ((...args: any[]) => any) | Record<string, (...args: any[]) => any>> = Record<string, never>>(extension: ExtendEditorApi<C, EA>) => SlatePlugin<PluginConfig<C['key'], InferOptions<C>, { [K in keyof (EA & InferApi<C>)]: (EA & InferApi<C>)[K] extends ((...args: any[]) => any) ? (EA & InferApi<C>)[K] : { [N in keyof (EA & InferApi<C>)[K]]: (EA & InferApi<C>)[K][N] } }, InferTransforms<C>, InferSelectors<C>>>;
+  extendEditorTransforms: <ET extends Record<string, ((...args: any[]) => any) | Record<string, (...args: any[]) => any>> = Record<string, never>>(extension: ExtendEditorTransforms<C, ET>) => SlatePlugin<PluginConfig<C['key'], InferOptions<C>, InferApi<C>, { [K in keyof (ET & InferTransforms<C>)]: (ET & InferTransforms<C>)[K] extends ((...args: any[]) => any) ? (ET & InferTransforms<C>)[K] : { [N in keyof (ET & InferTransforms<C>)[K]]: (ET & InferTransforms<C>)[K][N] } }, InferSelectors<C>>>;
+  extendPlugin: <P extends AnySlatePlugin, EO = {}, EA = {}, ET = {}, ES = {}>(plugin: Partial<P>, extendConfig: ((ctx: SlatePluginContext<P>) => SlatePluginConfig$1<any, InferOptions<P>, InferApi<P>, InferTransforms<P>, InferSelectors<P>, EO, EA, ET, ES>) | SlatePluginConfig$1<any, InferOptions<P>, InferApi<P>, InferTransforms<P>, InferSelectors<P>, EO, EA, ET, ES>) => SlatePlugin<C>;
+  extendSelectors: <ES extends Record<string, (...args: any[]) => any> = Record<string, never>>(extension: (ctx: SlatePluginContext<C>) => ES) => SlatePlugin<PluginConfig<C['key'], InferOptions<C>, InferApi<C>, InferTransforms<C>, ES & InferSelectors<C>>>;
+  extendTransforms: <ET extends Record<string, (...args: any[]) => any> = Record<string, never>>(extension: (ctx: SlatePluginContext<C>) => ET) => SlatePlugin<PluginConfig<C['key'], InferOptions<C>, InferApi<C>, InferTransforms<C> & Record<C['key'], ET>, InferSelectors<C>>>;
+  overrideEditor: (override: OverrideEditor<C>) => SlatePlugin<C>;
+  /** Returns a new instance of the plugin with the component. */
+  withComponent: (component: NodeComponent) => SlatePlugin<C>;
+  __resolved?: boolean;
+};
+type SlatePlugins = AnySlatePlugin[];
+type TextStaticProps<C extends AnyPluginConfig = PluginConfig> = ((props: SlateRenderTextProps<TText, C>) => AnyObject | undefined) | AnyObject;
+type TransformOptions<C extends AnyPluginConfig = PluginConfig> = BaseTransformOptions & SlatePluginContext<C>;
+type SlateShortcut = {
+  keys?: (({} & string)[][] | readonly string[] | string) | null;
+  delimiter?: string;
+  description?: string;
+  document?: Document;
+  enabled?: Trigger;
+  enableOnContentEditable?: boolean;
+  enableOnFormTags?: boolean;
+  ignoreEventWhenPrevented?: boolean;
+  ignoreModifiers?: boolean;
+  keydown?: boolean;
+  keyup?: boolean;
+  preventDefault?: Trigger;
+  priority?: number;
+  scopes?: readonly string[] | string;
+  splitKey?: string;
+  useKey?: boolean;
+  handler?: (ctx: {
+    editor: SlateEditor;
+    event: KeyboardEvent;
+    eventDetails: any;
+  }) => boolean | void;
+  ignoreEventWhen?: (e: KeyboardEvent) => boolean;
+};
+type Trigger = ((keyboardEvent: KeyboardEvent, hotkeysEvent: any) => boolean) | boolean;
+//#endregion
+//#region src/lib/plugin/createSlatePlugin.d.ts
+type SlatePluginConfig<K$1 extends string = any, O = {}, A = {}, T = {}, S = {}> = Omit<Partial<Modify<SlatePlugin<PluginConfig<K$1, O, A, T, S>>, {
+  node?: Partial<SlatePlugin<PluginConfig<K$1, O, A, T, S>>['node']>;
+}>>, keyof SlatePluginMethods | 'optionsStore'>;
+type TSlatePluginConfig<C extends AnyPluginConfig = PluginConfig> = Omit<Partial<Modify<SlatePlugin<C>, {
+  node?: Partial<SlatePlugin<C>['node']>;
+}>>, keyof SlatePluginMethods | 'optionsStore'>;
+/**
+ * Creates a new Plate plugin with the given configuration.
+ *
+ * @remarks
+ *   - The plugin's key is required and specified by the K generic.
+ *   - The `__extensions` array stores functions to be applied when `resolvePlugin`
+ *       is called with an editor.
+ *   - The `extend` method adds new extensions to be applied later.
+ *   - The `extendPlugin` method extends an existing plugin (including nested
+ *       plugins) or adds a new one if not found.
+ *
+ * @example
+ *   const myPlugin = createSlatePlugin<
+ *     'myPlugin',
+ *     MyOptions,
+ *     MyApi,
+ *     MyTransforms
+ *   >({
+ *     key: 'myPlugin',
+ *     options: { someOption: true },
+ *     transforms: { someTransform: () => {} },
+ *   });
+ *
+ *   const extendedPlugin = myPlugin.extend({
+ *     options: { anotherOption: false },
+ *   });
+ *
+ *   const pluginWithNestedExtension = extendedPlugin.extendPlugin(
+ *     nestedPlugin,
+ *     { options: { nestedOption: true } }
+ *   );
+ *
+ * @template K - The literal type of the plugin key.
+ * @template O - The type of the plugin options.
+ * @template A - The type of the plugin utilities.
+ * @template T - The type of the plugin transforms.
+ * @template S - The type of the plugin storage.
+ * @param {Partial<SlatePlugin<K, O, A, T, S>>} config - The configuration
+ *   object for the plugin.
+ * @returns {SlatePlugin<K, O, A, T, S>} A new Plate plugin instance with the
+ *   following properties and methods:
+ *
+ *   - All properties from the input config, merged with default values.
+ *   - `configure`: A method to create a new plugin instance with updated options.
+ *   - `extend`: A method to create a new plugin instance with additional
+ *       configuration.
+ *   - `extendPlugin`: A method to extend an existing plugin (including nested
+ *       plugins) or add a new one if not found.
+ */
+declare function createSlatePlugin<K$1 extends string = any, O = {}, A = {}, T = {}, S = {}>(config?: ((editor: SlateEditor) => SlatePluginConfig<K$1, O, A, T, S>) | SlatePluginConfig<K$1, O, A, T, S>): SlatePlugin<PluginConfig<K$1, O, A, T, S>>;
+/**
+ * Explicitly typed version of `createSlatePlugin`.
+ *
+ * @remarks
+ *   While `createSlatePlugin` uses type inference, this function requires an
+ *   explicit type parameter. Use this when you need precise control over the
+ *   plugin's type structure or when type inference doesn't provide the desired
+ *   result.
+ */
+declare function createTSlatePlugin<C extends AnyPluginConfig = PluginConfig>(config?: ((editor: SlateEditor) => TSlatePluginConfig<C>) | TSlatePluginConfig<C>): SlatePlugin<C>;
+//#endregion
+//#region src/lib/plugin/getEditorPlugin.d.ts
+declare function getEditorPlugin<P extends AnyPluginConfig | SlatePlugin<AnyPluginConfig>>(editor: SlateEditor, p: WithRequiredKey<P>): SlatePluginContext<InferConfig<P> extends never ? P : InferConfig<P>>;
+//#endregion
+//#region src/lib/plugin/getSlatePlugin.d.ts
+/** Get editor plugin by key or plugin object. */
+declare function getSlatePlugin<C extends AnyPluginConfig = PluginConfig>(editor: SlateEditor, p: WithRequiredKey<C>): C extends {
+  node: any;
+} ? C : SlatePlugin<C>;
+/** Get editor plugin type by key or plugin object. */
+declare function getPluginType(editor: SlateEditor, key: string): string;
+/** Get editor plugin types by key. */
+declare const getPluginTypes: (editor: SlateEditor, keys: string[]) => string[];
+declare const getPluginKey: (editor: SlateEditor, type: string) => string | undefined;
+declare const getPluginKeys: (editor: SlateEditor, types: string[]) => string[];
+declare const getPluginByType: (editor: SlateEditor, type: string) => EditorPlugin<AnyPluginConfig> | null;
+declare const getContainerTypes: (editor: SlateEditor) => string[];
+//#endregion
+//#region src/lib/plugins/HistoryPlugin.d.ts
+declare const withPlateHistory: ExtendEditor;
+/** @see {@link withHistory} */
+declare const HistoryPlugin: SlatePlugin<PluginConfig<"history", {}, {}, {}, {}>>;
+//#endregion
+//#region src/lib/plugins/ParserPlugin.d.ts
+declare const ParserPlugin: SlatePlugin<PluginConfig<"parser", {}, {}, {}, {}>>;
+//#endregion
+//#region src/lib/plugins/slate-extension/transforms/init.d.ts
+type InitOptions = {
+  autoSelect?: boolean | 'end' | 'start';
+  selection?: TSelection;
+  shouldNormalizeEditor?: boolean;
+  value?: any;
+  onReady?: (ctx: {
+    editor: SlateEditor;
+    isAsync: boolean;
+    value: Value;
+  }) => void;
+};
+declare const init: (editor: SlateEditor, {
+  autoSelect,
+  selection,
+  shouldNormalizeEditor,
+  value,
+  onReady
+}: InitOptions) => void;
+//#endregion
+//#region src/lib/plugins/slate-extension/transforms/insertExitBreak.d.ts
+type InsertExitBreakOptions = {
+  match?: EditorAboveOptions['match'];
+  reverse?: boolean;
+};
+/**
+ * Exits the current block structure by creating a new block next to the
+ * appropriate ancestor.
+ *
+ * This function automatically determines the exit point by finding the first
+ * ancestor that doesn't have strict sibling constraints (`isStrictSiblings:
+ * false`), allowing standard text blocks to be inserted as siblings.
+ *
+ * For example:
+ *
+ * - In `column_group > column > codeblock > codeline`, exits after `codeblock`,
+ *   then after `column_group`
+ * - In `table > tr > td > p`, exits after `table`
+ */
+declare const insertExitBreak: (editor: SlateEditor, {
+  match,
+  reverse
+}?: InsertExitBreakOptions) => 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.
+ */
+declare const resetBlock: (editor: SlateEditor, {
+  at
+}?: {
+  at?: Path;
+}) => true | undefined;
+//#endregion
+//#region src/lib/plugins/slate-extension/transforms/setValue.d.ts
+declare const setValue: <V extends Value>(editor: SlateEditor, value?: V | string) => void;
+//#endregion
+//#region src/lib/plugins/slate-extension/SlateExtensionPlugin.d.ts
+type SlateExtensionConfig = PluginConfig<'slateExtension', {
+  onNodeChange: (options: {
+    editor: SlateEditor;
+    node: Descendant;
+    operation: NodeOperation;
+    prevNode: Descendant;
+  }) => void;
+  onTextChange: (options: {
+    editor: SlateEditor;
+    node: Descendant;
+    operation: TextOperation;
+    prevText: string;
+    text: string;
+  }) => void;
+}, {}, {
+  init: OmitFirst<typeof init>;
+  insertExitBreak: OmitFirst<typeof insertExitBreak>;
+  resetBlock: OmitFirst<typeof resetBlock>;
+  setValue: OmitFirst<typeof setValue>;
+}>;
+/** Opinionated extension of slate default behavior. */
+declare const SlateExtensionPlugin: SlatePlugin<PluginConfig<"slateExtension", {
+  onNodeChange: (options: {
+    editor: SlateEditor;
+    node: Descendant;
+    operation: NodeOperation;
+    prevNode: Descendant;
+  }) => void;
+  onTextChange: (options: {
+    editor: SlateEditor;
+    node: Descendant;
+    operation: TextOperation;
+    prevText: string;
+    text: string;
+  }) => void;
+}, {}, {
+  init: ((args_0: InitOptions) => void) & ((args_0: InitOptions) => void);
+  insertExitBreak: ((args_0?: InsertExitBreakOptions | undefined) => true | undefined) & ((args_0?: InsertExitBreakOptions | undefined) => true | undefined);
+  resetBlock: ((args_0?: {
+    at?: _platejs_slate1.Path;
+  } | undefined) => true | undefined) & ((args_0?: {
+    at?: _platejs_slate1.Path;
+  } | undefined) => true | undefined);
+  setValue: ((value?: string | _platejs_slate1.Value | undefined) => void) & ((value?: string | _platejs_slate1.Value | undefined) => void);
+  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;
+};
+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/affinity/AffinityPlugin.d.ts
+type ElementAffinity = {
+  affinity: 'backward' | 'forward';
+  at: Path;
+  type: string;
+};
+type AffinityConfig = PluginConfig<'affinity'>;
+declare const AffinityPlugin: SlatePlugin<AffinityConfig>;
+//#endregion
+//#region src/lib/plugins/affinity/types.d.ts
+type EdgeNodes = [NodeEntry$1<TElement | TText>, NodeEntry$1<TElement | TText>] | [NodeEntry$1<TElement | TText>, null] | [null, NodeEntry$1<TElement | TText>];
+//#endregion
+//#region src/lib/plugins/affinity/queries/getEdgeNodes.d.ts
+/**
+ * When the cursor is at a mark edge, this function returns the inward node and
+ * the outward node (if any). If the cursor is at the start of the text, then
+ * the node before the text is returned. If the cursor is at the end of the
+ * text, then the node after the text is returned. Otherwise, null is returned.
+ */
+declare const getEdgeNodes: (editor: SlateEditor) => EdgeNodes | null;
+//#endregion
+//#region src/lib/plugins/affinity/queries/getMarkBoundaryAffinity.d.ts
+declare const getMarkBoundaryAffinity: (editor: SlateEditor, markBoundary: EdgeNodes) => "backward" | "forward" | undefined;
+//#endregion
+//#region src/lib/plugins/affinity/queries/isNodeAffinity.d.ts
+declare const isNodeAffinity: (editor: SlateEditor, node: TElement | TText, affinity: "directional" | "hard" | "outward") => boolean;
+declare const isNodesAffinity: (editor: SlateEditor, edgeNodes: EdgeNodes, affinity: "directional" | "hard" | "outward") => boolean | null;
+//#endregion
+//#region src/lib/plugins/affinity/transforms/setAffinitySelection.d.ts
+declare const setAffinitySelection: (editor: SlateEditor, edgeNodes: EdgeNodes, affinity: "backward" | "forward") => void;
+//#endregion
+//#region src/lib/plugins/debug/DebugPlugin.d.ts
+type DebugErrorType = (string & {}) | 'DEFAULT' | 'OPTION_UNDEFINED' | 'OVERRIDE_MISSING' | 'PLUGIN_DEPENDENCY_MISSING' | 'PLUGIN_MISSING' | 'USE_CREATE_PLUGIN' | 'USE_ELEMENT_CONTEXT';
+type LogLevel = 'error' | 'info' | 'log' | 'warn';
+declare class PlateError extends Error {
+  type: DebugErrorType;
+  constructor(message: string, type?: DebugErrorType);
+}
+declare const DebugPlugin: SlatePlugin<PluginConfig<"debug", {
+  isProduction: boolean;
+  logger: Partial<Record<LogLevel, (message: string, type?: DebugErrorType, details?: any) => void>>;
+  logLevel: LogLevel;
+  throwErrors: boolean;
+}, {
+  debug: {
+    error: (message: string | unknown, type?: DebugErrorType, details?: any) => void;
+    info: (message: string, type?: DebugErrorType, details?: any) => void;
+    log: (message: string, type?: DebugErrorType, details?: any) => void;
+    warn: (message: string, type?: DebugErrorType, details?: any) => void;
+  };
+}, {}, {}>>;
+//#endregion
+//#region src/lib/plugins/node-id/NodeIdPlugin.d.ts
+type NodeIdOptions = {
+  /**
+   * By default, when a node inserted using editor.tf.insertNode(s) has an id,
+   * it will be used instead of the id generator, except if it already exists in
+   * the document. Set this option to true to disable this behavior.
+   */
+  disableInsertOverrides?: boolean;
+  /**
+   * Filter inline `Element` nodes.
+   *
+   * @default true
+   */
+  filterInline?: boolean;
+  /**
+   * Filter `Text` nodes.
+   *
+   * @default true
+   */
+  filterText?: boolean;
+  /**
+   * Node key to store the id.
+   *
+   * @default 'id'
+   */
+  idKey?: string;
+  /**
+   * Normalize initial value. If false, normalize only the first and last node
+   * are missing id. To disable this behavior, use `NodeIdPlugin.configure({
+   * normalizeInitialValue: null })`.
+   *
+   * @default false
+   */
+  normalizeInitialValue?: boolean;
+  /**
+   * Reuse ids on undo/redo and copy/pasting if not existing in the document.
+   * This is disabled by default to avoid duplicate ids across documents.
+   *
+   * @default false
+   */
+  reuseId?: boolean;
+  /**
+   * A function that generates and returns a unique ID.
+   *
+   * @default () => nanoid(10)
+   */
+  idCreator?: () => any;
+} & QueryNodeOptions;
+type NormalizeNodeIdOptions = Pick<NodeIdOptions, 'allow' | 'exclude' | 'filter' | 'filterInline' | 'filterText' | 'idCreator' | 'idKey'>;
+/**
+ * Normalize node IDs in a value without using editor operations. This is a pure
+ * function that returns a new normalized value.
+ */
+declare const normalizeNodeId: <V extends Value>(value: V, options?: NormalizeNodeIdOptions) => V;
+type NodeIdConfig = PluginConfig<'nodeId', NodeIdOptions, {}, {
+  nodeId: {
+    normalize: () => void;
+  };
+}>;
+/** @see {@link withNodeId} */
+declare const NodeIdPlugin: SlatePlugin<PluginConfig<"nodeId", {
+  /**
+   * By default, when a node inserted using editor.tf.insertNode(s) has an id,
+   * it will be used instead of the id generator, except if it already exists in
+   * the document. Set this option to true to disable this behavior.
+   */
+  disableInsertOverrides?: boolean;
+  /**
+   * Filter inline `Element` nodes.
+   *
+   * @default true
+   */
+  filterInline?: boolean;
+  /**
+   * Filter `Text` nodes.
+   *
+   * @default true
+   */
+  filterText?: boolean;
+  /**
+   * Node key to store the id.
+   *
+   * @default 'id'
+   */
+  idKey?: string;
+  /**
+   * Normalize initial value. If false, normalize only the first and last node
+   * are missing id. To disable this behavior, use `NodeIdPlugin.configure({
+   * normalizeInitialValue: null })`.
+   *
+   * @default false
+   */
+  normalizeInitialValue?: boolean;
+  /**
+   * Reuse ids on undo/redo and copy/pasting if not existing in the document.
+   * This is disabled by default to avoid duplicate ids across documents.
+   *
+   * @default false
+   */
+  reuseId?: boolean;
+  /**
+   * A function that generates and returns a unique ID.
+   *
+   * @default () => nanoid(10)
+   */
+  idCreator?: () => any;
+} & QueryNodeOptions, {}, {
+  nodeId: {
+    normalize: () => void;
+  };
+} & Record<"nodeId", {
+  normalize(): void;
+}>, {}>>;
+//#endregion
+//#region src/lib/plugins/chunking/ChunkingPlugin.d.ts
+type ChunkingConfig = PluginConfig<'chunking', {
+  /**
+   * The number of blocks per chunk.
+   *
+   * @default 1000
+   */
+  chunkSize?: number;
+  /**
+   * Whether to render each chunk as a DOM element with `content-visibility:
+   * auto`, which optimizes DOM painting. When set to `false`, no DOM element
+   * will be rendered for each chunk.
+   *
+   * @default true
+   */
+  contentVisibilityAuto?: boolean;
+  /**
+   * Determine which ancestors should have chunking applied to their children.
+   * Only blocks containing other blocks can have chunking applied.
+   *
+   * @default NodeApi.isEditor
+   */
+  query?: (ancestor: Ancestor) => boolean;
+}>;
+declare const ChunkingPlugin: SlatePlugin<ChunkingConfig>;
+//#endregion
+//#region src/lib/plugins/getCorePlugins.d.ts
+type CorePlugin = ReturnType<typeof getCorePlugins>[number];
+type GetCorePluginsOptions = {
+  /** Enable mark/element affinity. */
+  affinity?: boolean;
+  /** Configure Slate's chunking optimization. */
+  chunking?: ChunkingConfig['options'] | boolean;
+  /** Specifies the maximum number of characters allowed in the editor. */
+  maxLength?: number;
+  /** Configure the node id plugin. */
+  nodeId?: NodeIdConfig['options'] | boolean;
+  /** Override the core plugins using the same key. */
+  plugins?: AnyPluginConfig[];
+};
+declare const getCorePlugins: ({
+  affinity,
+  chunking,
+  maxLength,
+  nodeId,
+  plugins
+}: GetCorePluginsOptions) => (SlatePlugin<DebugConfig> | SlatePlugin<PluginConfig<"slateExtension", {
+  onNodeChange: (options: {
+    editor: SlateEditor;
+    node: Descendant$1;
+    operation: NodeOperation$1;
+    prevNode: Descendant$1;
+  }) => void;
+  onTextChange: (options: {
+    editor: SlateEditor;
+    node: Descendant$1;
+    operation: TextOperation$1;
+    prevText: string;
+    text: string;
+  }) => void;
+}, {}, {
+  init: ((args_0: InitOptions) => void) & ((args_0: InitOptions) => void);
+  insertExitBreak: ((args_0?: InsertExitBreakOptions | undefined) => true | undefined) & ((args_0?: InsertExitBreakOptions | undefined) => true | undefined);
+  resetBlock: ((args_0?: {
+    at?: Path$2;
+  } | undefined) => true | undefined) & ((args_0?: {
+    at?: Path$2;
+  } | 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;
+}, {
+  isScrolling: () => boolean;
+}, {
+  withScrolling: (fn: () => void, options?: WithAutoScrollOptions | undefined) => void;
+}, {}>> | SlatePlugin<PluginConfig<"history", {}, {}, {}, {}>> | 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[];
+}>, {}, {}>> | SlatePlugin<PluginConfig<"ast", {}, {}, {}, {}>> | SlatePlugin<PluginConfig<"nodeId", {
+  disableInsertOverrides?: boolean;
+  filterInline?: boolean;
+  filterText?: boolean;
+  idKey?: string;
+  normalizeInitialValue?: boolean;
+  reuseId?: boolean;
+  idCreator?: () => any;
+} & QueryNodeOptions$1, {}, {
+  nodeId: {
+    normalize: () => void;
+  };
+} & Record<"nodeId", {
+  normalize(): void;
+}>, {}>> | SlatePlugin<AffinityConfig> | SlatePlugin<PluginConfig<"p", {}, {}, {}, {}>> | SlatePlugin<ChunkingConfig>)[];
+type CorePluginTransforms = SlateExtensionConfig['transforms'];
+type CorePluginApi = SlateExtensionConfig['api'];
+type DebugConfig = PluginConfig<'debug', {
+  isProduction: boolean;
+  logger: Partial<Record<LogLevel, LogFunction>>;
+  logLevel: LogLevel;
+  throwErrors: boolean;
+}, {
+  debug: {
+    error: (message: string | unknown, type?: DebugErrorType, details?: any) => void;
+    info: (message: string, type?: DebugErrorType, details?: any) => void;
+    log: (message: string, type?: DebugErrorType, details?: any) => void;
+    warn: (message: string, type?: DebugErrorType, details?: any) => void;
+  };
+}>;
+type LengthConfig = PluginConfig<'length', {
+  maxLength: number;
+}>;
+type LogFunction = (message: string, type?: DebugErrorType, details?: any) => void;
+//#endregion
+//#region src/lib/plugins/chunking/withChunking.d.ts
+declare const withChunking: OverrideEditor<ChunkingConfig>;
+//#endregion
+//#region src/lib/plugins/html/HtmlPlugin.d.ts
+/**
+ * Enables support for deserializing inserted content from HTML format to Slate
+ * format and serializing Slate content to HTML format.
+ */
+declare const HtmlPlugin: SlatePlugin<PluginConfig<"html", {}, Record<"html", {
+  deserialize: (args_0: {
+    element: HTMLElement | string;
+    collapseWhiteSpace?: boolean;
+    defaultElementPlugin?: WithRequiredKey;
+  }) => Descendant$1[];
+}>, {}, {}>>;
+//#endregion
+//#region src/lib/plugins/html/constants.d.ts
+declare const CARRIAGE_RETURN = "\r";
+declare const LINE_FEED = "\n";
+declare const NO_BREAK_SPACE = "\u00A0";
+declare const SPACE = " ";
+declare const TAB = "\t";
+declare const ZERO_WIDTH_SPACE = "\u200B";
+//#endregion
+//#region src/lib/plugins/html/types.d.ts
+type DeserializeHtmlChildren = ChildNode | Descendant | string | null;
+/** De */
+type DeserializeHtmlNodeReturnType = Descendant | Descendant[] | DeserializeHtmlChildren[] | string | null;
+//#endregion
+//#region src/lib/plugins/html/utils/cleanHtmlBrElements.d.ts
+/** Replace BR elements with line feeds. */
+declare const cleanHtmlBrElements: (rootNode: Node) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/cleanHtmlCrLf.d.ts
+/** Replace \r\n and \r with \n */
+declare const cleanHtmlCrLf: (html: string) => string;
+//#endregion
+//#region src/lib/plugins/html/utils/cleanHtmlEmptyElements.d.ts
+/** Remove empty elements from rootNode. Allowed empty elements: BR, IMG. */
+declare const cleanHtmlEmptyElements: (rootNode: Node) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/cleanHtmlFontElements.d.ts
+/**
+ * Replace FONT elements with SPAN elements if there is textContent (remove
+ * otherwise).
+ */
+declare const cleanHtmlFontElements: (rootNode: Node) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/cleanHtmlLinkElements.d.ts
+/** Remove fragment hrefs and spans without inner text. */
+declare const cleanHtmlLinkElements: (rootNode: Node) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/cleanHtmlTextNodes.d.ts
+declare const cleanHtmlTextNodes: (rootNode: Node) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/copyBlockMarksToSpanChild.d.ts
+/**
+ * Set HTML blocks mark styles to a new child span element if any. This allows
+ * Plate to use block marks.
+ */
+declare const copyBlockMarksToSpanChild: (rootNode: Node) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/deserializeHtml.d.ts
+/** Deserialize HTML element to a valid document fragment. */
+declare const deserializeHtml: (editor: SlateEditor, {
+  collapseWhiteSpace: shouldCollapseWhiteSpace,
+  defaultElementPlugin,
+  element
+}: {
+  element: HTMLElement | string;
+  collapseWhiteSpace?: boolean;
+  defaultElementPlugin?: WithRequiredKey;
+}) => Descendant[];
+//#endregion
+//#region src/lib/plugins/html/utils/deserializeHtmlElement.d.ts
+/** Deserialize HTML element to fragment. */
+declare const deserializeHtmlElement: (editor: SlateEditor, element: HTMLElement) => DeserializeHtmlNodeReturnType;
+//#endregion
+//#region src/lib/plugins/html/utils/deserializeHtmlNode.d.ts
+/** Deserialize HTML element or child node. */
+declare const deserializeHtmlNode: (editor: SlateEditor) => (node: ChildNode | HTMLElement) => DeserializeHtmlNodeReturnType;
+//#endregion
+//#region src/lib/plugins/html/utils/deserializeHtmlNodeChildren.d.ts
+declare const deserializeHtmlNodeChildren: (editor: SlateEditor, node: ChildNode | HTMLElement, isSlateParent?: boolean) => DeserializeHtmlChildren[];
+//#endregion
+//#region src/lib/plugins/html/utils/findHtmlElement.d.ts
+/**
+ * Find the first HTML element that matches the given selector.
+ *
+ * @param rootNode
+ * @param predicate
+ */
+declare const findHtmlElement: (rootNode: Node, predicate: (node: HTMLElement) => boolean) => null;
+declare const someHtmlElement: (rootNode: Node, predicate: (node: HTMLElement) => boolean) => boolean;
+//#endregion
+//#region src/lib/plugins/html/utils/getDataNodeProps.d.ts
+declare const getDataNodeProps: ({
+  editor,
+  element,
+  plugin
+}: {
+  editor: SlateEditor;
+  element: HTMLElement;
+  plugin: AnyEditorPlugin;
+}) => Record<string, any> | undefined;
+//#endregion
+//#region src/lib/plugins/html/utils/getHtmlComments.d.ts
+declare const getHtmlComments: (node: Node) => string[];
+//#endregion
+//#region src/lib/plugins/html/utils/htmlBodyToFragment.d.ts
+/** Deserialize HTML body element to Fragment. */
+declare const htmlBodyToFragment: (editor: SlateEditor, element: HTMLElement) => Descendant[] | undefined;
+//#endregion
+//#region src/lib/plugins/html/utils/htmlBrToNewLine.d.ts
+/** Deserialize HTML to break line. */
+declare const htmlBrToNewLine: (node: ChildNode | HTMLElement) => "\n" | undefined;
+//#endregion
+//#region src/lib/plugins/html/utils/htmlElementToElement.d.ts
+/** Deserialize HTML to Element. */
+declare const htmlElementToElement: (editor: SlateEditor, element: HTMLElement, isSlate?: boolean) => Descendant | undefined;
+//#endregion
+//#region src/lib/plugins/html/utils/htmlElementToLeaf.d.ts
+/**
+ * Deserialize HTML to Descendant[] with marks on Text. Build the leaf from the
+ * leaf deserializers of each plugin.
+ */
+declare const htmlElementToLeaf: (editor: SlateEditor, element: HTMLElement) => Descendant[];
+//#endregion
+//#region src/lib/plugins/html/utils/htmlStringToDOMNode.d.ts
+/** Convert HTML string into HTML element. */
+declare const htmlStringToDOMNode: (rawHtml: string) => HTMLBodyElement;
+//#endregion
+//#region src/lib/plugins/html/utils/htmlTextNodeToString.d.ts
+declare const htmlTextNodeToString: (node: ChildNode | HTMLElement) => string | undefined;
+//#endregion
+//#region src/lib/plugins/html/utils/inlineTagNames.d.ts
+/**
+ * # Methodology
+ *
+ * ## Step 1. Get the list of all standard tag names
+ *
+ * Go to https://developer.mozilla.org/en-US/docs/Web/HTML/Element and run the
+ * following in the console to generate a JSON array of tag names:
+ *
+ * ```js
+ * JSON.stringify(
+ *   Array.from(document.querySelectorAll('article table td:first-child'))
+ *     .map((td) => {
+ *       const body = document.createElement('body');
+ *       body.innerHTML = td.textContent;
+ *       return body.firstChild?.tagName;
+ *     })
+ *     .filter((tagName) => tagName)
+ * );
+ * ```
+ *
+ * Output (as of 2023-11-06):
+ *
+ * ```json
+ * '["BASE","LINK","META","STYLE","TITLE","ADDRESS","ARTICLE","ASIDE","FOOTER","HEADER","H1","HGROUP","MAIN","NAV","SECTION","SEARCH","BLOCKQUOTE","DD","DIV","DL","DT","FIGCAPTION","FIGURE","HR","LI","MENU","OL","P","PRE","UL","A","ABBR","B","BDI","BDO","BR","CITE","CODE","DATA","DFN","EM","I","KBD","MARK","Q","RP","RT","RUBY","S","SAMP","SMALL","SPAN","STRONG","SUB","SUP","TIME","U","VAR","WBR","AREA","AUDIO","IMG","MAP","TRACK","VIDEO","EMBED","IFRAME","OBJECT","PICTURE","PORTAL","SOURCE","svg","math","CANVAS","NOSCRIPT","SCRIPT","DEL","INS","TABLE","BUTTON","DATALIST","FIELDSET","FORM","INPUT","LABEL","LEGEND","METER","OPTGROUP","OPTION","OUTPUT","PROGRESS","SELECT","TEXTAREA","DETAILS","DIALOG","SUMMARY","SLOT","TEMPLATE","ACRONYM","BIG","CENTER","CONTENT","DIR","FONT","IMG","MARQUEE","MENUITEM","NOBR","NOEMBED","NOFRAMES","PARAM","PLAINTEXT","RB","RTC","SHADOW","STRIKE","TT","XMP"]'
+ * ```
+ *
+ * ## Step 2. For each tag name, determine the default browser style
+ *
+ * Open an empty HTML file in the browser and run the following in the console:
+ *
+ * ```js
+ * const tagNames = JSON.parse(<JSON string from step 1>);
+ *
+ * JSON.stringify(
+ *   tagNames.filter((tagName) => {
+ *     const element = document.createElement(tagName);
+ *     document.body.appendChild(element);
+ *     const display = window.getComputedStyle(element).display;
+ *     element.remove();
+ *     return display.startsWith('inline');
+ *   })
+ * );
+ * ```
+ *
+ * Place the result in the array below (accurate as of 2023-11-06).
+ */
+declare const inlineTagNames: Set<string>;
+//#endregion
+//#region src/lib/plugins/html/utils/isHtmlBlockElement.d.ts
+declare const isHtmlBlockElement: (node: Node) => boolean;
+//#endregion
+//#region src/lib/plugins/html/utils/isHtmlComment.d.ts
+declare const isHtmlComment: (node: Node) => node is Comment;
+//#endregion
+//#region src/lib/plugins/html/utils/isHtmlElement.d.ts
+declare const isHtmlElement: (node: Node) => node is Element;
+//#endregion
+//#region src/lib/plugins/html/utils/isHtmlFragmentHref.d.ts
+/** If href starts with '#'. */
+declare const isHtmlFragmentHref: (href: string) => boolean;
+//#endregion
+//#region src/lib/plugins/html/utils/isHtmlInlineElement.d.ts
+declare const isHtmlInlineElement: (node: Node) => boolean;
+//#endregion
+//#region src/lib/plugins/html/utils/isHtmlTable.d.ts
+declare const isHtmlTable: (element: Element) => boolean;
+//#endregion
+//#region src/lib/plugins/html/utils/isHtmlText.d.ts
+declare const isHtmlText: (node: Node) => node is Text;
+//#endregion
+//#region src/lib/plugins/html/utils/isOlSymbol.d.ts
+declare const isOlSymbol: (symbol: string) => boolean;
+//#endregion
+//#region src/lib/plugins/html/utils/parseHtmlDocument.d.ts
+declare const parseHtmlDocument: (html: string) => Document;
+//#endregion
+//#region src/lib/plugins/html/utils/parseHtmlElement.d.ts
+declare const parseHtmlElement: (html: string) => HTMLElement;
+//#endregion
+//#region src/lib/plugins/html/utils/pipeDeserializeHtmlElement.d.ts
+declare const pipeDeserializeHtmlElement: (editor: SlateEditor, element: HTMLElement) => (Nullable<HtmlDeserializer> & {
+  node: AnyObject;
+}) | undefined;
+//#endregion
+//#region src/lib/plugins/html/utils/pipeDeserializeHtmlLeaf.d.ts
+declare const pipeDeserializeHtmlLeaf: (editor: SlateEditor, element: HTMLElement) => AnyObject;
+//#endregion
+//#region src/lib/plugins/html/utils/pluginDeserializeHtml.d.ts
+/** Get a deserializer by type, node names, class names and styles. */
+declare const pluginDeserializeHtml: (editor: SlateEditor, plugin: AnyEditorPlugin, {
+  deserializeLeaf,
+  element: el
+}: {
+  element: HTMLElement;
+  deserializeLeaf?: boolean;
+}) => (Nullable<HtmlDeserializer> & {
+  node: AnyObject;
+}) | undefined;
+//#endregion
+//#region src/lib/plugins/html/utils/postCleanHtml.d.ts
+/** Trim the html and remove zero width spaces, then wrap it with a body element. */
+declare const postCleanHtml: (html: string) => string;
+//#endregion
+//#region src/lib/plugins/html/utils/preCleanHtml.d.ts
+/** Remove HTML surroundings and clean HTML from CR/LF */
+declare const preCleanHtml: (html: string) => string;
+//#endregion
+//#region src/lib/plugins/html/utils/removeHtmlNodesBetweenComments.d.ts
+/** Removes HTML nodes between HTML comments. */
+declare const removeHtmlNodesBetweenComments: (rootNode: Node, start: string, end: string) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/removeHtmlSurroundings.d.ts
+/** Remove string before <html and after </html> */
+declare const removeHtmlSurroundings: (html: string) => string;
+//#endregion
+//#region src/lib/plugins/html/utils/replaceTagName.d.ts
+/**
+ * Replace `element` tag name by `tagName`. Attributes, innerHTML and parent
+ * relationship is kept.
+ */
+declare const replaceTagName: (element: Element, tagName: string) => Element;
+//#endregion
+//#region src/lib/plugins/html/utils/traverseHtmlComments.d.ts
+type Callback$3 = (node: Comment) => boolean;
+/** Traverse HTML comments. */
+declare const traverseHtmlComments: (rootNode: Node, callback: Callback$3) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/traverseHtmlElements.d.ts
+type Callback$2 = (node: Element) => boolean;
+/**
+ * Traverse the HTML elements of the given HTML node.
+ *
+ * @param rootNode The root HTML node to traverse.
+ * @param callback The callback to call for each HTML element.
+ */
+declare const traverseHtmlElements: (rootNode: Node, callback: Callback$2) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/traverseHtmlNode.d.ts
+type Callback$1 = (node: Node) => boolean;
+/**
+ * Depth-first pre-order tree traverse the given HTML node and calls the given
+ * callback for each node. see:
+ * https://en.wikipedia.org/wiki/Tree_traversal#Pre-order_(NLR)
+ *
+ * @param callback Returns a boolean indicating whether traversal should be
+ *   continued
+ */
+declare const traverseHtmlNode: (node: Node, callback: Callback$1) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/traverseHtmlTexts.d.ts
+type Callback = (node: Text) => boolean;
+declare const traverseHtmlTexts: (rootNode: Node, callback: Callback) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/unwrapHtmlElement.d.ts
+/** Unwrap the given HTML element. */
+declare const unwrapHtmlElement: (element: Element) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/collapse-white-space/types.d.ts
+type CollapseWhiteSpaceState = {
+  inlineFormattingContext: {
+    atStart: boolean;
+    lastHasTrailingWhiteSpace: boolean;
+  } | null;
+  whiteSpaceRule: WhiteSpaceRule;
+};
+type TrimEndRule = 'collapse' | 'single-newline';
+type TrimStartRule = 'all' | 'collapse';
+type WhiteSpaceRule = 'normal' | 'pre' | 'pre-line';
+//#endregion
+//#region src/lib/plugins/html/utils/collapse-white-space/collapseString.d.ts
+declare const collapseString: (text: string, {
+  shouldCollapseWhiteSpace,
+  trimEnd,
+  trimStart,
+  whiteSpaceIncludesNewlines
+}?: {
+  shouldCollapseWhiteSpace?: boolean;
+  trimEnd?: TrimEndRule;
+  trimStart?: TrimStartRule;
+  whiteSpaceIncludesNewlines?: boolean;
+}) => string;
+//#endregion
+//#region src/lib/plugins/html/utils/collapse-white-space/collapseWhiteSpace.d.ts
+declare const collapseWhiteSpace: (element: HTMLElement) => HTMLElement;
+//#endregion
+//#region src/lib/plugins/html/utils/collapse-white-space/collapseWhiteSpaceChildren.d.ts
+declare const collapseWhiteSpaceChildren: (node: Node, state: CollapseWhiteSpaceState) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/collapse-white-space/collapseWhiteSpaceElement.d.ts
+/**
+ * Note: We do not want to start an inline formatting context until we encounter
+ * a text node.
+ */
+declare const collapseWhiteSpaceElement: (element: HTMLElement, state: CollapseWhiteSpaceState) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/collapse-white-space/collapseWhiteSpaceNode.d.ts
+declare const collapseWhiteSpaceNode: (node: Node, state: CollapseWhiteSpaceState) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/collapse-white-space/collapseWhiteSpaceText.d.ts
+declare const collapseWhiteSpaceText: (text: Text, state: CollapseWhiteSpaceState) => void;
+//#endregion
+//#region src/lib/plugins/html/utils/collapse-white-space/inferWhiteSpaceRule.d.ts
+declare const inferWhiteSpaceRule: (element: HTMLElement) => WhiteSpaceRule | null;
+//#endregion
+//#region src/lib/plugins/html/utils/collapse-white-space/isLastNonEmptyTextOfInlineFormattingContext.d.ts
+declare const isLastNonEmptyTextOfInlineFormattingContext: (initialText: Text) => boolean;
+//#endregion
+//#region src/lib/plugins/html/utils/collapse-white-space/stateTransforms.d.ts
+declare const upsertInlineFormattingContext: (state: CollapseWhiteSpaceState) => void;
+declare const endInlineFormattingContext: (state: CollapseWhiteSpaceState) => void;
+//#endregion
+//#region src/lib/plugins/length/LengthPlugin.d.ts
+declare const LengthPlugin: SlatePlugin<LengthConfig>;
+//#endregion
+//#region src/lib/plugins/node-id/withNodeId.d.ts
+/** Enables support for inserting nodes with an id key. */
+declare const withNodeId: OverrideEditor<NodeIdConfig>;
+//#endregion
+//#region src/lib/plugins/override/OverridePlugin.d.ts
+/**
+ * Merge and register all the inline types and void types from the plugins and
+ * options, using `editor.api.isInline`, `editor.api.markableVoid` and
+ * `editor.api.isVoid`
+ */
+declare const withOverrides: OverrideEditor;
+/** Override the editor api and transforms based on the plugins. */
+declare const OverridePlugin: SlatePlugin<PluginConfig<"override", {}, {}, {}, {}>>;
+//#endregion
+//#region src/lib/plugins/override/withBreakRules.d.ts
+declare const withBreakRules: OverrideEditor;
+//#endregion
+//#region src/lib/plugins/override/withDeleteRules.d.ts
+declare const withDeleteRules: OverrideEditor;
+//#endregion
+//#region src/lib/plugins/override/withMergeRules.d.ts
+declare const withMergeRules: OverrideEditor;
+//#endregion
+//#region src/lib/plugins/override/withNormalizeRules.d.ts
+declare const withNormalizeRules: OverrideEditor;
+//#endregion
+//#region src/lib/plugins/paragraph/BaseParagraphPlugin.d.ts
+type ParagraphConfig = PluginConfig<'p'>;
+declare const BaseParagraphPlugin: SlatePlugin<PluginConfig<"p", {}, {}, {}, {}>>;
+//#endregion
+//#region src/lib/plugin/BasePlugin.d.ts
+type AnyPluginConfig = {
+  key: any;
+  api: any;
+  options: any;
+  selectors: any;
+  transforms: any;
+};
+type BaseDeserializer = AnyObject & {
+  /**
+   * Deserialize an element. Overrides plugin.isElement.
+   *
+   * @default plugin.isElement
+   */
+  isElement?: boolean;
+  /**
+   * Deserialize a leaf. Overrides plugin.isLeaf.
+   *
+   * @default plugin.isLeaf
+   */
+  isLeaf?: boolean;
+};
+type BaseHtmlDeserializer = BaseDeserializer & {
+  /** List of HTML attribute names to store their values in `node.attributes`. */
+  attributeNames?: string[];
+  rules?: {
+    /**
+     * Deserialize an element:
+     *
+     * - If this option (string) is in the element attribute names.
+     * - If this option (object) values match the element attributes.
+     */
+    validAttribute?: Record<string, string[] | string> | string;
+    /** Valid element `className`. */
+    validClassName?: string;
+    /** Valid element `nodeName`. Set '*' to allow any node name. */
+    validNodeName?: string[] | string;
+    /**
+     * Valid element style values. Can be a list of string (only one match is
+     * needed).
+     */
+    validStyle?: Partial<Record<keyof CSSStyleDeclaration, string[] | string | undefined>>;
+  }[];
+  /** Whether or not to include deserialized children on this node */
+  withoutChildren?: boolean;
+};
+type BaseInjectProps = {
+  /**
+   * Object whose keys are node values and values are classNames which will be
+   * extended.
+   */
+  classNames?: AnyObject;
+  /**
+   * Default node value. The node key would be unset if the node value =
+   * defaultNodeValue.
+   */
+  defaultNodeValue?: any;
+  /** Node key to map to the styles. */
+  nodeKey?: string;
+  /**
+   * Style key to override.
+   *
+   * @default nodeKey
+   */
+  styleKey?: keyof CSSStyleDeclaration;
+  /** List of supported node values. */
+  validNodeValues?: any[];
+};
+type BasePlugin<C extends AnyPluginConfig = PluginConfig> = {
+  /** Unique identifier for this plugin. */
+  key: C['key'];
+  /** API methods provided by this plugin. */
+  api: InferApi<C>;
+  /**
+   * An array of plugin keys that this plugin depends on. These plugins will be
+   * loaded before this plugin.
+   */
+  dependencies: string[];
+  inject: Nullable<{
+    /** Plugin keys of elements to exclude the children from */
+    excludeBelowPlugins?: string[];
+    /** Plugin keys of elements to exclude */
+    excludePlugins?: string[];
+    /** Whether to filter blocks */
+    isBlock?: boolean;
+    /** Whether to filter elements */
+    isElement?: boolean;
+    /** Whether to filter leaves */
+    isLeaf?: boolean;
+    /** Filter nodes with path above this level. */
+    maxLevel?: number;
+    /**
+     * Plugin keys used by {@link InjectNodeProps} and the targetPluginToInject
+     * function. For plugin injection by key, use the inject.plugins property.
+     *
+     * @default [ParagraphPlugin.key]
+     */
+    targetPlugins?: string[];
+  }>;
+  /** Node-specific configuration for this plugin. */
+  node: BasePluginNode<C>;
+  /** Extended properties used by any plugin as options. */
+  options: InferOptions<C>;
+  /** Store for managing plugin options. */
+  optionsStore: TStateApi<C['options'], [['zustand/mutative-x', never]], {}, C['selectors']>;
+  override: {
+    /** Enable or disable plugins */
+    enabled?: Partial<Record<string, boolean>>;
+  };
+  /**
+   * Defines the order in which plugins are registered and executed.
+   *
+   * Plugins with higher priority values are registered and executed before
+   * those with lower values. This affects two main aspects:
+   *
+   * 1. Plugin Order: Plugins with higher priority will be added to the editor
+   *    earlier.
+   * 2. Execution Order: For operations that involve multiple plugins (e.g., editor
+   *    methods), plugins with higher priority will be processed first.
+   *
+   * @default 100
+   */
+  priority: number;
+  render: Nullable<{
+    /**
+     * Renders a component above the `Editable` component but within the `Slate`
+     * wrapper. Useful for adding UI elements that should appear above the
+     * editable area.
+     */
+    aboveEditable?: React.FC<{
+      children: React.ReactNode;
+    }>;
+    /**
+     * Renders a component above the `Slate` wrapper. This is the outermost
+     * render position in the editor structure.
+     */
+    aboveSlate?: React.FC<{
+      children: React.ReactNode;
+    }>;
+    /**
+     * Specifies the HTML tag name to use when rendering the node component.
+     * Only used when no custom `component` is provided for the plugin.
+     *
+     * @default 'div' for elements, 'span' for leaves
+     */
+    as?: keyof HTMLElementTagNameMap;
+    /**
+     * Renders a component below leaf nodes when `isLeaf: true` and
+     * `isDecoration: false`. Use `render.node` instead when `isDecoration:
+     * true`.
+     */
+    leaf?: NodeComponent;
+    /**
+     * Renders a component for:
+     *
+     * - Elements nodes if `isElement: true`
+     * - Below text nodes if `isLeaf: true` and `isDecoration: false`
+     * - Below leaf if `isLeaf: true` and `isDecoration: true`
+     */
+    node?: NodeComponent;
+  }>;
+  rules: {
+    /**
+     * Defines actions on insert break based on block state.
+     *
+     * - `'default'`: Default behavior
+     * - `'exit'`: Exit the current block
+     * - `'reset'`: Reset block to default paragraph type
+     * - `'lineBreak'`: Insert newline character
+     * - `'deleteExit'`: Delete backward then exit
+     */
+    break?: BreakRules;
+    /**
+     * Defines actions on delete based on block state.
+     *
+     * - `'default'`: Default behavior
+     * - `'reset'`: Reset block to default paragraph type
+     */
+    delete?: DeleteRules;
+    /** Defines the behavior of merging nodes. */
+    merge?: MergeRules;
+    /** Defines the behavior of normalizing nodes. */
+    normalize?: NormalizeRules;
+    /** Defines the behavior of selection. */
+    selection?: SelectionRules;
+  };
+  /** Selectors for the plugin. */
+  selectors: InferSelectors<C>;
+  /** Transforms (state-modifying operations) that can be applied to the editor. */
+  transforms: InferTransforms<C>;
+  /**
+   * Configures edit-only behavior for various plugin functionalities.
+   *
+   * - If `true` (boolean):
+   *
+   *   - `render`, `handlers`, and `inject.nodeProps` are active only when the
+   *       editor is NOT read-only.
+   * - If an object ({@link EditOnlyConfig}): Allows fine-grained control:
+   *
+   *   - `render`: Edit-only by default (true if not specified). Set to `false` to
+   *       always be active.
+   *   - `handlers`: Edit-only by default (true if not specified). Set to `false` to
+   *       always be active.
+   *   - `inject` (for `inject.nodeProps`): Edit-only by default (true if not
+   *       specified). Set to `false` to always be active.
+   *   - `normalizeInitialValue`: NOT edit-only by default (false if not specified).
+   *       Set to `true` to make it edit-only.
+   */
+  editOnly?: EditOnlyConfig | boolean;
+  /**
+   * Enables or disables the plugin. Used by Plate to determine if the plugin
+   * should be used.
+   */
+  enabled?: boolean;
+};
+type BasePluginContext<C extends AnyPluginConfig = PluginConfig> = {
+  api: C['api'] & EditorApi & CorePluginApi;
+  setOptions: (options: ((state: Draft<Partial<InferOptions<C>>>) => void) | Partial<InferOptions<C>>) => void;
+  tf: C['transforms'] & EditorTransforms & CorePluginTransforms;
+  type: string;
+  getOption: <K$1 extends keyof InferOptions<C> | keyof InferSelectors<C> | 'state'>(key: K$1, ...args: K$1 extends keyof InferSelectors<C> ? Parameters<InferSelectors<C>[K$1]> : unknown[]) => K$1 extends 'state' ? InferOptions<C> : K$1 extends keyof InferSelectors<C> ? ReturnType<InferSelectors<C>[K$1]> : K$1 extends keyof InferOptions<C> ? InferOptions<C>[K$1] : never;
+  getOptions: () => InferOptions<C>;
+  setOption: <K$1 extends keyof InferOptions<C>>(optionKey: K$1, value: InferOptions<C>[K$1]) => void;
+};
+type BasePluginNode<C extends AnyPluginConfig = PluginConfig> = {
+  /**
+   * Specifies the type identifier for this plugin's nodes.
+   *
+   * For elements (when {@link isElement} is `true`):
+   *
+   * - The {@link NodeComponent} will be used for any node where `node.type ===
+   *   type`.
+   *
+   * For leaves/marks (when {@link isLeaf} is `true`):
+   *
+   * - The {@link NodeComponent} will be used for any leaf where `node[type] ===
+   *   true`.
+   *
+   * This property is crucial for Plate to correctly match nodes to their
+   * respective plugins.
+   *
+   * @default plugin.key
+   */
+  type: string;
+  component?: NodeComponent | null;
+  /**
+   * Controls which (if any) attribute names in the `attributes` property of an
+   * element will be passed as `nodeProps` to the {@link NodeComponent}, and
+   * subsequently rendered as DOM attributes.
+   *
+   * WARNING: If used improperly, this property WILL make your application
+   * vulnerable to cross-site scripting (XSS) or information exposure attacks.
+   *
+   * For example, if the `href` attribute is allowed and the component passes
+   * `nodeProps` to an `<a>` element, then attackers can direct users to open a
+   * document containing a malicious link element:
+   *
+   * { type: 'link', url: 'https://safesite.com/', attributes: { href:
+   * 'javascript:alert("xss")' }, children: [{ text: 'Click me' }], }
+   *
+   * The same is true of the `src` attribute when passed to certain HTML
+   * elements, such as `<iframe>`.
+   *
+   * If the `style` attribute (or another attribute that can load URLs, such as
+   * `background`) is allowed, then attackers can direct users to open a
+   * document that will send a HTTP request to an arbitrary URL. This can leak
+   * the victim's IP address or confirm to the attacker that the victim opened
+   * the document.
+   *
+   * Before allowing any attribute name, ensure that you thoroughly research and
+   * assess any potential risks associated with it.
+   *
+   * @default [ ]
+   */
+  dangerouslyAllowAttributes?: string[];
+  /**
+   * Indicates if this plugin's elements are primarily containers for other
+   * content. Container elements are typically unwrapped when querying
+   * fragments.
+   *
+   * Examples: table, tr, td, column, column_group
+   *
+   * @default false
+   */
+  isContainer?: boolean;
+  /**
+   * Indicates if this plugin's nodes can be rendered as decorated leaf. Set to
+   * false to render node component only once per text node.
+   *
+   * @default true
+   */
+  isDecoration?: boolean;
+  /**
+   * Indicates if this plugin's nodes should be rendered as elements. Used by
+   * Plate for {@link NodeComponent} rendering as elements.
+   */
+  isElement?: boolean;
+  /**
+   * Indicates if this plugin's elements should be treated as inline. Used by
+   * the inlineVoid core plugin.
+   */
+  isInline?: boolean;
+  /**
+   * Indicates if this plugin's nodes should be rendered as leaves. Used by
+   * Plate for {@link NodeComponent} rendering as leaves.
+   */
+  isLeaf?: boolean;
+  /**
+   * Indicates if this plugin's void elements should be markable. Used by the
+   * inlineVoid core plugin.
+   */
+  isMarkableVoid?: boolean;
+  /**
+   * Whether the node is selectable.
+   *
+   * @default true
+   */
+  isSelectable?: boolean;
+  /**
+   * Indicates whether this element enforces strict sibling type constraints.
+   * Set to true `true` when the element only allows specific siblings (e.g.,
+   * `td` can only have `td` siblings, `column` can only have `column` siblings)
+   * and prevents standard text blocks like paragraphs from being inserted as
+   * siblings.
+   */
+  isStrictSiblings?: boolean;
+  /**
+   * Property used by `inlineVoid` core plugin to set elements of this `type` as
+   * void.
+   */
+  isVoid?: boolean;
+  /**
+   * Function that returns an object of data attributes to be added to the
+   * element.
+   */
+  toDataAttributes?: (options: BasePluginContext<C> & {
+    node: TElement;
+  }) => AnyObject | undefined;
+};
+type BaseSerializer = AnyObject;
+type BaseTransformOptions = GetInjectNodePropsOptions & {
+  nodeValue?: any;
+  value?: any;
+};
+type BreakRules = {
+  /** Action when Enter is pressed in an empty block. */
+  empty?: 'default' | 'deleteExit' | 'exit' | 'reset';
+  /**
+   * Action when Enter is pressed at the end of an empty line. This is typically
+   * used with `default: 'lineBreak'`.
+   *
+   * Example:
+   *
+   * ```tsx
+   *     <blockquote>
+   *     This is some text\n
+   *     |
+   *     </blockquote>
+   * ```
+   */
+  emptyLineEnd?: 'default' | 'deleteExit' | 'exit';
+  /** Default action when Enter is pressed. Defaults to splitting the block. */
+  default?: 'default' | 'deleteExit' | 'exit' | 'lineBreak';
+  /** If true, the new block after splitting will be reset to the default type. */
+  splitReset?: boolean;
+};
+type MergeRules = {
+  /** Whether to remove the node when it's empty. */
+  removeEmpty?: boolean;
+};
+type NormalizeRules = {
+  /** Whether to remove nodes with empty text. */
+  removeEmpty?: boolean;
+};
+type DeleteRules = {
+  /**
+   * Action when Backspace is pressed at the start of the block. This applies
+   * whether the block is empty or not.
+   *
+   * Example:
+   *
+   * ```tsx
+   *     <blockquote>
+   *     |Text
+   *     </blockquote>
+   * ```
+   */
+  start?: 'default' | 'reset';
+  /** Action when Backspace is pressed and the block is empty. */
+  empty?: 'default' | 'reset';
+};
+type SelectionRules = {
+  /**
+   * Defines the selection behavior at the boundaries of nodes.
+   *
+   * - `directional`: Selection affinity is determined by the direction of cursor
+   *   movement. Maintains inward or outward affinity based on approach.
+   * - `outward`: Forces outward affinity. Typing at the edge of a mark will not
+   *   apply the mark to new text.
+   * - `hard`: Creates a 'hard' edge that requires two key presses to move across.
+   *   Uses offset-based navigation.
+   * - `default`: Uses Slate's default behavior.
+   */
+  affinity?: 'default' | 'directional' | 'hard' | 'outward';
+};
+type MatchRules = 'break.default' | 'break.empty' | 'break.emptyLineEnd' | 'break.splitReset' | 'delete.empty' | 'delete.start' | 'merge.removeEmpty' | 'normalize.removeEmpty' | 'selection.affinity';
+type EditOnlyConfig = {
+  /**
+   * If true, `handlers` are only active when the editor is not read-only.
+   *
+   * @default true (when `editOnly` is an object or `true` boolean)
+   */
+  handlers?: boolean;
+  /**
+   * If true, `inject.nodeProps` is only active when the editor is not
+   * read-only.
+   *
+   * @default true (when `editOnly` is an object or `true` boolean)
+   */
+  inject?: boolean;
+  /**
+   * If true, `normalizeInitialValue` is only called when the editor is not
+   * read-only.
+   *
+   * @default false (This is an exception. It's not edit-only by default, even if `editOnly` is true or an object, unless explicitly set to true here).
+   */
+  normalizeInitialValue?: boolean;
+  /**
+   * If true, `render` functions are only active when the editor is not
+   * read-only.
+   *
+   * @default true (when `editOnly` is an object or `true` boolean)
+   */
+  render?: boolean;
+};
+type ExtendConfig<C extends PluginConfig, EO = {}, EA = {}, ET = {}, ES = {}> = {
+  key: C['key'];
+  api: C['api'] & EA;
+  options: C['options'] & EO;
+  selectors: C['selectors'] & ES;
+  transforms: C['transforms'] & ET;
+};
+type GetInjectNodePropsOptions = {
+  /** Existing className. */
+  className?: string;
+  /** Style value or className key. */
+  element?: TElement;
+  /** Existing style. */
+  style?: CSSStyleDeclaration;
+  /** Style value or className key. */
+  text?: TText;
+};
+type GetInjectNodePropsReturnType = AnyObject & {
+  className?: string;
+  style?: CSSStyleDeclaration;
+};
+type InferKey<P> = P extends PluginConfig ? P['key'] : never;
+type InferApi<P> = P extends PluginConfig ? P['api'] : never;
+type InferOptions<P> = P extends PluginConfig ? P['options'] : never;
+type InferSelectors<P> = P extends PluginConfig ? P['selectors'] : never;
+type InferTransforms<P> = P extends PluginConfig ? P['transforms'] : never;
+/**
+ * Renders a component for Slate Nodes (elements if `isElement: true` or leaves
+ * if `isLeaf: true`) that match this plugin's type. This is the primary render
+ * method for plugin-specific node content.
+ *
+ * @default DefaultElement for elements, DefaultLeaf for leaves
+ */
+type NodeComponent<T = any> = React.FC<T>;
+type NodeComponents = Record<string, NodeComponent>;
+type ParserOptions = {
+  data: string;
+  dataTransfer: DataTransfer;
+  mimeType: string;
+};
+type PluginConfig<K$1 extends string = any, O = {}, A = {}, T = {}, S = {}> = {
+  key: K$1;
+  api: A;
+  options: O;
+  selectors: S;
+  transforms: T;
+};
+type WithAnyKey<C extends AnyPluginConfig = PluginConfig> = PluginConfig<any, InferOptions<C>, InferApi<C>, InferTransforms<C>, InferSelectors<C>>;
+type WithRequiredKey<P = {}> = (P extends {
+  key: string;
+} ? P : never) | {
+  key: string;
+};
+//#endregion
+//#region src/lib/editor/SlateEditor.d.ts
+type BaseEditor = EditorBase & {
+  /** DOM state */
+  dom: {
+    /** Whether the editor is composing text. */
+    composing: boolean;
+    /** The current keyboard event. */
+    currentKeyboardEvent: KeyboardEventLike | null;
+    /** Whether the editor is focused. */
+    focused: boolean;
+    /** The previous selection. */
+    prevSelection: TRange | null;
+    /** Whether the editor is read-only. */
+    readOnly: boolean;
+  };
+  meta: EditorBase['meta'] & {
+    /**
+     * A key that can be used to uniquely identify the editor. For RSC usage,
+     * use `uid` instead.
+     */
+    key: any;
+    /** A record of plugin components. */
+    components: NodeComponents;
+    /**
+     * Current user ID for collaborative features (e.g., Yjs). Used to identify
+     * the creator of elements like combobox inputs.
+     */
+    userId?: string | null;
+    /** Whether the editor is a fallback editor. */
+    isFallback: boolean;
+    /** Plugin cache by feature. */
+    pluginCache: {
+      decorate: string[];
+      handlers: {
+        onChange: string[];
+        onNodeChange: string[];
+        onTextChange: string[];
+      };
+      inject: {
+        nodeProps: string[];
+      };
+      node: {
+        isContainer: string[];
+        isLeaf: string[];
+        isText: string[];
+        leafProps: string[];
+        textProps: string[];
+        /** Node types to plugin keys. */
+        types: Record<string, string>;
+      };
+      normalizeInitialValue: string[];
+      render: {
+        aboveEditable: string[];
+        aboveNodes: string[];
+        aboveSlate: string[];
+        afterContainer: string[];
+        afterEditable: string[];
+        beforeContainer: string[];
+        beforeEditable: string[];
+        belowNodes: string[];
+        belowRootNodes: string[];
+      };
+      rules: {
+        match: string[];
+      };
+      useHooks: string[];
+    };
+    /** All plugins. */
+    pluginList: any[];
+    /**
+     * A stable unique identifier that remains constant from Plate RSC to client
+     * hydration.
+     */
+    uid?: string;
+  };
+  plugins: Record<string, any>;
+  setOptions: <C extends AnyPluginConfig>(plugin: WithRequiredKey<C>, options: ((state: Draft<Partial<InferOptions<C>>>) => void) | Partial<InferOptions<C>>) => void;
+  getInjectProps: <C extends AnyPluginConfig = PluginConfig>(plugin: WithRequiredKey<C>) => InjectNodeProps<C>;
+  getOption: <C extends AnyPluginConfig, StateType extends InferOptions<C>, TSelectors extends InferSelectors<C>, K$1 extends keyof StateType | keyof TSelectors | 'state'>(plugin: WithRequiredKey<C>, key: K$1, ...args: K$1 extends keyof TSelectors ? Parameters<TSelectors[K$1]> : []) => K$1 extends 'state' ? StateType : K$1 extends keyof TSelectors ? ReturnType<TSelectors[K$1]> : K$1 extends keyof StateType ? StateType[K$1] : never;
+  getOptions: <C extends AnyPluginConfig = PluginConfig>(plugin: WithRequiredKey<C>) => InferOptions<C>;
+  getOptionsStore: <C extends AnyPluginConfig>(plugin: WithRequiredKey<C>) => TStateApi<InferOptions<C>, [['zustand/mutative-x', never]], {}, InferSelectors<C>>;
+  getPlugin: <C extends AnyPluginConfig = PluginConfig>(plugin: WithRequiredKey<C>) => C extends {
+    node: any;
+  } ? C : EditorPlugin<C>;
+  getType: (pluginKey: string) => string;
+  setOption: <C extends AnyPluginConfig, K$1 extends keyof InferOptions<C>>(plugin: WithRequiredKey<C>, optionKey: K$1, value: InferOptions<C>[K$1]) => void;
+};
+type InferPlugins<T extends AnyPluginConfig[]> = T[number];
+type KeyofPlugins<T extends AnyPluginConfig> = (string & {}) | InferKey<CorePlugin | T>;
+type KeyofNodePlugins<T extends AnyPluginConfig> = (string & {}) | InferKey<T | typeof BaseParagraphPlugin>;
+type SlateEditor = BaseEditor & {
+  api: EditorApi & UnionToIntersection<InferApi<CorePlugin>>;
+  meta: BaseEditor['meta'] & {
+    /** An array of plugins that are currently being used by the editor. */
+    pluginList: AnyEditorPlugin[];
+    shortcuts: any;
+  };
+  plugins: Record<string, AnyEditorPlugin>;
+  tf: EditorTransforms & UnionToIntersection<InferTransforms<CorePlugin>>;
+  transforms: EditorTransforms & UnionToIntersection<InferTransforms<CorePlugin>>;
+  getApi: <C extends AnyPluginConfig = PluginConfig>(plugin?: WithRequiredKey<C>) => SlateEditor['api'] & InferApi<C>;
+  getPlugin: <C extends AnyPluginConfig = PluginConfig>(plugin: WithRequiredKey<C>) => C extends {
+    node: any;
+  } ? C : EditorPlugin<C>;
+  getTransforms: <C extends AnyPluginConfig = PluginConfig>(plugin?: WithRequiredKey<C>) => SlateEditor['tf'] & InferTransforms<C>;
+};
+type TSlateEditor<V extends Value = Value, P extends AnyPluginConfig = CorePlugin> = SlateEditor & {
+  api: EditorApi<V> & UnionToIntersection<InferApi<CorePlugin | P>>;
+  children: V;
+  meta: BaseEditor['meta'] & {
+    pluginList: P[];
+    shortcuts: any;
+  };
+  plugins: { [K in P['key']]: Extract<P, {
+    key: K;
+  }> };
+  tf: EditorTransforms<V> & UnionToIntersection<InferTransforms<CorePlugin | P>>;
+  transforms: EditorTransforms<V> & UnionToIntersection<InferTransforms<CorePlugin | P>>;
+  getApi: <C extends AnyPluginConfig = PluginConfig>(plugin?: WithRequiredKey<C>) => TSlateEditor<V>['api'] & InferApi<C>;
+  getTransforms: <C extends AnyPluginConfig = PluginConfig>(plugin?: WithRequiredKey<C>) => TSlateEditor<V>['tf'] & InferTransforms<C>;
+};
+//#endregion
+//#region src/internal/plugin/resolvePlugins.d.ts
+/**
+ * Initialize and configure the editor's plugin system. This function sets up
+ * the editor's plugins, resolving core and custom plugins, and applying any
+ * overrides specified in the plugins.
+ */
+type PluginStoreFactory = typeof createVanillaStore;
+//#endregion
+//#region src/lib/editor/withSlate.d.ts
+type BaseWithSlateOptions<P extends AnyPluginConfig = CorePlugin> = {
+  /**
+   * Unique identifier for the editor instance.
+   *
+   * @default nanoid()
+   */
+  id?: string;
+  /**
+   * Current user ID for collaborative features (e.g., Yjs). Used to identify
+   * the creator of elements like combobox inputs.
+   */
+  userId?: string | null;
+  /**
+   * Determines which mark/element to apply at boundaries between different
+   * marks, based on cursor movement using the left/right arrow keys.
+   *
+   * Example: <text bold>Bold</text><cursor><text italic>Italic</text>
+   *
+   * If the cursor moved here from the left (via → key), typing applies
+   * **bold**.
+   *
+   * If the cursor moved here from the right (via ← key), typing applies
+   * _italic_.
+   *
+   * Without mark affinity, the preceding mark (**bold**) is always applied
+   * regardless of direction.
+   *
+   * @default true
+   */
+  affinity?: boolean;
+  /**
+   * Select the editor after initialization.
+   *
+   * @default false
+   *
+   * - `true` | 'end': Select the end of the editor
+   * - `false`: Do not select anything
+   * - `'start'`: Select the start of the editor
+   */
+  autoSelect?: boolean | 'end' | 'start';
+  /**
+   * Configure Slate's chunking optimization, which reduces latency while
+   * typing. Set to `false` to disable.
+   *
+   * @default true
+   * @see https://docs.slatejs.org/walkthroughs/09-performance
+   */
+  chunking?: ChunkingConfig['options'] | boolean;
+  /** Specifies the component for each plugin key. */
+  components?: NodeComponents;
+  /** Specifies the component for each plugin key. */
+  /**
+   * Specifies the maximum number of characters allowed in the editor. When the
+   * limit is reached, further input will be prevented.
+   */
+  maxLength?: number;
+  /**
+   * Configuration for automatic node ID generation and management.
+   *
+   * Unless set to `false`, the editor automatically adds unique IDs to nodes
+   * through the core NodeIdPlugin:
+   *
+   * - Normalizes the initial value for missing IDs
+   * - Adds IDs to new nodes during insertion
+   * - Preserves or reuses IDs on undo/redo and copy/paste operations
+   * - Handles ID conflicts and duplicates
+   *
+   * @default { idKey: 'id', filterInline: true, filterText: true, idCreator: () => nanoid(10) }
+   */
+  nodeId?: NodeIdConfig['options'] | boolean;
+  /**
+   * Factory used to create the per-plugin options store
+   *
+   * @default createVanillaStore from zustand-x/vanilla
+   */
+  optionsStoreFactory?: PluginStoreFactory;
+  /**
+   * Array of plugins to be loaded into the editor. Plugins extend the editor's
+   * functionality and define custom behavior.
+   */
+  plugins?: P[];
+  /**
+   * Editor read-only initial state. For dynamic read-only control, use the
+   * `Plate.readOnly` prop instead.
+   *
+   * @default false
+   */
+  readOnly?: boolean;
+  /**
+   * Initial selection state for the editor. Defines where the cursor should be
+   * positioned when the editor loads.
+   */
+  selection?: TSelection;
+  /**
+   * When `true`, normalizes the initial `value` passed to the editor. This is
+   * useful when adding normalization rules to already existing content or when
+   * the initial value might not conform to the current schema.
+   *
+   * Note: Normalization may take time for large documents.
+   *
+   * @default false
+   */
+  shouldNormalizeEditor?: boolean;
+  /**
+   * When `true`, skips the initial value, selection, and normalization logic.
+   * Useful when the editor state is managed externally (e.g., with Yjs
+   * collaboration) or when you want to manually control the initialization
+   * process.
+   *
+   * @default false
+   */
+  skipInitialization?: boolean;
+};
+type WithSlateOptions<V extends Value = Value, P extends AnyPluginConfig = CorePlugin> = BaseWithSlateOptions<P> & Pick<Partial<AnySlatePlugin>, 'api' | 'decorate' | 'extendEditor' | 'inject' | 'normalizeInitialValue' | 'options' | 'override' | 'transforms'> & {
+  /**
+   * Initial content for the editor.
+   *
+   * Can be:
+   *
+   * - A static value (array of nodes)
+   * - An HTML string that will be deserialized
+   * - A function that returns a value or Promise<value>
+   * - `null` for an empty editor
+   *
+   * @default [{ type: 'p'; children: [{ text: '' }] }]
+   */
+  value?: ((editor: SlateEditor) => Promise<V> | V) | V | string | null;
+  /** Function to configure the root plugin */
+  rootPlugin?: (plugin: AnySlatePlugin) => AnySlatePlugin;
+  /**
+   * Callback called when the editor is ready (after initialization
+   * completes).
+   */
+  onReady?: (ctx: {
+    editor: SlateEditor;
+    isAsync: boolean;
+    value: V;
+  }) => void;
+};
+/**
+ * Applies Plate enhancements to an editor instance (non-React version).
+ *
+ * @remarks
+ *   This function supports server-side usage as it doesn't include React-specific
+ *   features like component rendering or hooks integration.
+ * @see {@link createSlateEditor} for a higher-level non-React editor creation function.
+ * @see {@link createPlateEditor} for a React-specific version of editor creation.
+ * @see {@link usePlateEditor} for a memoized React version.
+ * @see {@link withPlate} for the React-specific enhancement function.
+ */
+declare const withSlate: <V extends Value = Value, P extends AnyPluginConfig = CorePlugin>(e: Editor, {
+  id,
+  affinity,
+  autoSelect,
+  chunking,
+  maxLength,
+  nodeId,
+  optionsStoreFactory,
+  plugins,
+  readOnly,
+  rootPlugin,
+  selection,
+  shouldNormalizeEditor,
+  skipInitialization,
+  userId,
+  value,
+  onReady,
+  ...pluginConfig
+}?: WithSlateOptions<V, P>) => TSlateEditor<V, InferPlugins<P[]>>;
+type CreateSlateEditorOptions<V extends Value = Value, P extends AnyPluginConfig = CorePlugin> = WithSlateOptions<V, P> & {
+  /**
+   * Initial editor to be extended with `withSlate`.
+   *
+   * @default createEditor()
+   */
+  editor?: Editor;
+};
+/**
+ * Creates a Slate editor (non-React version).
+ *
+ * This function creates a fully configured Plate editor instance that can be
+ * used in non-React environments or server-side contexts. It applies all the
+ * specified plugins and configurations to create a functional editor.
+ *
+ * Examples:
+ *
+ * ```ts
+ * const editor = createSlateEditor({
+ *   plugins: [ParagraphPlugin, HeadingPlugin],
+ *   value: [{ type: 'p', children: [{ text: 'Hello world!' }] }],
+ * });
+ *
+ * // Editor with custom configuration
+ * const editor = createSlateEditor({
+ *   plugins: [ParagraphPlugin],
+ *   maxLength: 1000,
+ *   nodeId: { idCreator: () => uuidv4() },
+ *   autoSelect: 'end',
+ * });
+ *
+ * // Server-side editor
+ * const editor = createSlateEditor({
+ *   plugins: [ParagraphPlugin],
+ *   value: '<p>HTML content</p>',
+ *   skipInitialization: true,
+ * });
+ * ```
+ *
+ * @see {@link createPlateEditor} for a React-specific version of editor creation.
+ * @see {@link usePlateEditor} for a memoized React version.
+ * @see {@link withSlate} for the underlying function that applies Slate enhancements to an editor.
+ */
+declare const createSlateEditor: <V extends Value = Value, P extends AnyPluginConfig = CorePlugin>({
+  editor,
+  ...options
+}?: CreateSlateEditorOptions<V, P>) => TSlateEditor<V, P>;
+//#endregion
+//#region src/lib/types/RenderChunkProps.d.ts
+type RenderChunkFn = (props: RenderChunkProps) => React$1.ReactElement<any>;
+type RenderChunkProps = {
+  attributes: {
+    'data-slate-chunk': true;
+  };
+  children: any;
+  highest: boolean;
+  lowest: boolean;
+};
+//#endregion
+//#region src/lib/types/RenderElementProps.d.ts
+type RenderElementFn = (props: RenderElementProps) => React$1.ReactElement<any>;
+type RenderElementProps<N$1 extends TElement = TElement> = {
+  attributes: {
+    'data-slate-node': 'element';
+    ref: any;
+    className?: string;
+    'data-slate-inline'?: true;
+    'data-slate-void'?: true;
+    dir?: 'rtl';
+    style?: React$1.CSSProperties;
+  };
+  children: any;
+  element: N$1;
+};
+//#endregion
+//#region src/lib/types/RenderLeafProps.d.ts
+type RenderLeafFn = (props: RenderLeafProps) => React.ReactElement<any>;
+type RenderLeafProps<N$1 extends TText = TText> = {
+  attributes: {
+    className?: string;
+    'data-slate-leaf'?: true;
+    style?: React.CSSProperties;
+  };
+  children: any;
+  leaf: N$1;
+  text: N$1;
+  /**
+   * The position of the leaf within the Text node, only present when the text
+   * node is split by decorations.
+   */
+  leafPosition?: LeafPosition;
+};
+//#endregion
+//#region src/lib/types/RenderTextProps.d.ts
+type RenderTextFn = (props: RenderTextProps) => React$1.ReactElement<any>;
+type RenderTextProps<N$1 extends TText = TText> = {
+  /** The text node being rendered. */
+  text: N$1;
+  /** The children (leaves) rendered within this text node. */
+  children: any;
+  /**
+   * HTML attributes to be spread onto the rendered container element. Includes
+   * `data-slate-node="text"` and `ref`.
+   */
+  attributes: {
+    'data-slate-node': 'text';
+    ref: any;
+    className?: string;
+    style?: React$1.CSSProperties;
+  };
+};
+//#endregion
+//#region src/lib/types/EditableProps.d.ts
+/** `EditableProps` are passed to the <Editable> component. */
+type EditableProps = {
+  as?: React.ElementType;
+  disableDefaultStyles?: boolean;
+  placeholder?: string;
+  readOnly?: boolean;
+  renderChunk?: RenderChunkFn;
+  renderElement?: RenderElementFn;
+  renderLeaf?: RenderLeafFn;
+  renderText?: RenderTextFn;
+  role?: string;
+  style?: React.CSSProperties;
+  decorate?: (entry: NodeEntry) => TRange[];
+  renderPlaceholder?: (props: {
+    attributes: {
+      contentEditable: boolean;
+      'data-slate-placeholder': boolean;
+      ref: React.RefCallback<any>;
+      style: React.CSSProperties;
+      dir?: 'rtl';
+    };
+    children: any;
+  }) => JSX.Element;
+  scrollSelectionIntoView?: (editor: Editor, domRange: DOMRange) => void;
+  onDOMBeforeInput?: (event: InputEvent) => void;
+} & React.TextareaHTMLAttributes<HTMLDivElement>;
+//#endregion
+//#region src/lib/utils/applyDeepToNodes.d.ts
+type ApplyDeepToNodesOptions<N$1 extends TNode> = {
+  apply: (node: NodeOf<N$1>, source: (() => Record<string, any>) | Record<string, any>) => void;
+  node: N$1;
+  source: (() => Record<string, any>) | Record<string, any>;
+  path?: Path;
+  query?: QueryNodeOptions;
+};
+/** Recursively apply an operation to children nodes with a query. */
+declare const applyDeepToNodes: <N$1 extends TNode>({
+  apply,
+  node,
+  path,
+  query,
+  source
+}: ApplyDeepToNodesOptions<N$1>) => void;
+//#endregion
+//#region src/lib/utils/checkUtils.d.ts
+declare const isSlateVoid: (element: HTMLElement) => boolean;
+declare const isSlateElement: (element: HTMLElement) => boolean;
+declare const isSlateText: (element: HTMLElement) => boolean;
+declare const isSlateString: (element: HTMLElement) => boolean;
+declare const isSlateLeaf: (element: HTMLElement) => boolean;
+declare const isSlateEditor: (element: HTMLElement) => boolean;
+declare const isSlateNode: (element: HTMLElement) => boolean;
+declare const isSlatePluginElement: (element: HTMLElement, pluginKey: string) => boolean;
+declare const isSlatePluginNode: (element: HTMLElement, pluginKey: string) => boolean;
+declare const getSlateElements: (element: HTMLElement) => HTMLElement[];
+//#endregion
+//#region src/lib/utils/defaultsDeepToNodes.d.ts
+/** Recursively merge a source object to children nodes with a query. */
+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;
+//#endregion
+//#region src/lib/utils/getInjectedPlugins.d.ts
+/**
+ * Get all plugins having a defined `inject.plugins[plugin.key]`. It includes
+ * `plugin` itself.
+ */
+declare const getInjectedPlugins: (editor: SlateEditor, plugin: AnyEditorPlugin) => Partial<AnyEditorPlugin>[];
+//#endregion
+//#region src/lib/utils/getNodeDataAttributeKeys.d.ts
+declare const getNodeDataAttributeKeys: (node: TElement | TText) => string[];
+declare const keyToDataAttribute: (key: string) => string;
+//#endregion
+//#region src/lib/utils/getPluginNodeProps.d.ts
+declare const getPluginNodeProps: ({
+  attributes: nodeAttributes,
+  node,
+  plugin,
+  props
+}: {
+  props: SlateRenderNodeProps;
+  attributes?: AnyObject;
+  node?: TElement | TText;
+  plugin?: AnyEditorPlugin;
+}) => any;
+//#endregion
+//#region src/lib/utils/getSlateClass.d.ts
+/** Get slate class name: slate-<type> */
+declare const getSlateClass: (type?: string) => string;
+//#endregion
+//#region src/lib/utils/hotkeys.d.ts
+/** Create a platform-aware hotkey checker. */
+declare const createHotkey: (key: string) => (event: KeyboardEventLike) => boolean;
+declare const Hotkeys: {
+  isBold: (event: KeyboardEventLike) => boolean;
+  isCompose: (event: KeyboardEventLike) => boolean;
+  isDeleteBackward: (event: KeyboardEventLike) => boolean;
+  isDeleteForward: (event: KeyboardEventLike) => boolean;
+  isDeleteLineBackward: (event: KeyboardEventLike) => boolean;
+  isDeleteLineForward: (event: KeyboardEventLike) => boolean;
+  isDeleteWordBackward: (event: KeyboardEventLike) => boolean;
+  isDeleteWordForward: (event: KeyboardEventLike) => boolean;
+  isEscape: (event: KeyboardEventLike) => boolean;
+  isExtendBackward: (event: KeyboardEventLike) => boolean;
+  isExtendDownward: (event: KeyboardEventLike) => boolean;
+  isExtendForward: (event: KeyboardEventLike) => boolean;
+  isExtendLineBackward: (event: KeyboardEventLike) => boolean;
+  isExtendLineForward: (event: KeyboardEventLike) => boolean;
+  isExtendUpward: (event: KeyboardEventLike) => boolean;
+  isItalic: (event: KeyboardEventLike) => boolean;
+  isMoveBackward: (event: KeyboardEventLike) => boolean;
+  isMoveDownward: (event: KeyboardEventLike) => boolean;
+  isMoveForward: (event: KeyboardEventLike) => boolean;
+  isMoveLineBackward: (event: KeyboardEventLike) => boolean;
+  isMoveLineForward: (event: KeyboardEventLike) => boolean;
+  isMoveUpward: (event: KeyboardEventLike) => boolean;
+  isMoveWordBackward: (event: KeyboardEventLike) => boolean;
+  isMoveWordForward: (event: KeyboardEventLike) => boolean;
+  isRedo: (event: KeyboardEventLike) => boolean;
+  isSelectAll: (event: KeyboardEventLike) => boolean;
+  isSoftBreak: (event: KeyboardEventLike) => boolean;
+  isSplitBlock: (event: KeyboardEventLike) => boolean;
+  isTab: (editor: Editor, event: React.KeyboardEvent, {
+    composing
+  }?: {
+    /** Ignore the event if composing. */
+    composing?: boolean;
+  }) => boolean;
+  isTransposeCharacter: (event: KeyboardEventLike) => boolean;
+  isUndo: (event: KeyboardEventLike) => boolean;
+  isUntab: (editor: Editor, event: React.KeyboardEvent, {
+    composing
+  }?: {
+    /** Ignore the event if composing. */
+    composing?: boolean;
+  }) => boolean;
+};
+//#endregion
+//#region src/lib/utils/isType.d.ts
+/** Does the node match the type provided. */
+declare const isType: (editor: SlateEditor, node: any, key?: string[] | string) => boolean;
+//#endregion
+//#region src/lib/utils/mergeDeepToNodes.d.ts
+/** Recursively merge a source object to children nodes with a query. */
+declare const mergeDeepToNodes: <N$1 extends TNode>(options: Omit<ApplyDeepToNodesOptions<N$1>, "apply">) => void;
+//#endregion
+//#region src/lib/utils/normalizeDescendantsToDocumentFragment.d.ts
+/** Normalize the descendants to a valid document fragment. */
+declare const normalizeDescendantsToDocumentFragment: (editor: SlateEditor, {
+  defaultElementPlugin,
+  descendants
+}: {
+  descendants: Descendant[];
+  defaultElementPlugin?: WithRequiredKey;
+}) => 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">;
+//#endregion
+//#region src/lib/utils/overridePluginsByKey.d.ts
+/**
+ * Recursive deep merge of each plugin from `override.plugins` into plugin with
+ * same key (plugin > plugin.plugins).
+ */
+declare const overridePluginsByKey: (plugin: AnySlatePlugin, overrideByKey?: Record<string, Partial<AnySlatePlugin>>, nested?: boolean) => AnySlatePlugin;
+//#endregion
+//#region src/lib/utils/pipeInsertDataQuery.d.ts
+/** Is the plugin disabled by another plugin. */
+declare const pipeInsertDataQuery: (editor: SlateEditor, plugins: Partial<AnyEditorPlugin>[], options: ParserOptions) => boolean;
+//#endregion
+//#region src/lib/utils/pipeOnNodeChange.d.ts
+declare const pipeOnNodeChange: (editor: SlateEditor, node: Descendant, prevNode: Descendant, operation: NodeOperation) => boolean;
+//#endregion
+//#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