import * as _platejs_slate1 from "@platejs/slate";
import { Ancestor, DOMRange, DecoratedRange, Descendant, Editor, EditorAboveOptions, EditorApi, EditorBase, EditorTransforms, InsertTextOptions, LeafPosition, NodeEntry, NodeOf, NodeOperation, Operation, Path, PathRef, Point, QueryNodeOptions, ScrollIntoViewOptions, TElement, TNode, TRange, TSelection, TText, TextOperation, Value } from "@platejs/slate";
import { nanoid as nanoid$1 } from "nanoid";
import { AnyObject, Deep2Partial, Modify, Nullable, OmitFirst, UnionToIntersection, UnknownObject } from "@udecode/utils";
import { createVanillaStore, createVanillaStore as createZustandStore$1 } from "zustand-x/vanilla";
import { KeyboardEventLike, isHotkey } from "is-hotkey";
import { NodeEntry as NodeEntry$1 } from "slate";
import React$1, { JSX } from "react";
import { TStateApi, TStateApi as ZustandStoreApi } from "zustand-x";
import { Draft } from "mutative";

//#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,
  path
}: {
  decorate: EditableProps['decorate'];
  decorations: DecoratedRange[];
  editor: SlateEditor;
  element: TElement;
  path: Path;
  style?: React$1.CSSProperties;
}): React$1.JSX.Element;
declare const ElementStatic: React$1.MemoExoticComponent<typeof BaseElementStatic>;
declare function BaseLeafStatic({
  decorations,
  editor,
  path,
  text
}: {
  decorations: DecoratedRange[];
  editor: SlateEditor;
  path: Path;
  text: TText;
}): React$1.ReactElement<any, string | React$1.JSXElementConstructor<any>> | undefined;
declare const LeafStatic: React$1.MemoExoticComponent<typeof BaseLeafStatic>;
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 src/static/plugins/ViewPlugin.d.ts
declare const ViewPlugin: SlatePlugin<PluginConfig<"dom", {
  scrollMode?: ScrollMode;
  scrollOperations?: AutoScrollOperationsMap;
  scrollOptions?: _platejs_slate1.ScrollIntoViewOptions;
}, {
  getFragment: () => _platejs_slate1.Descendant[];
  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?: _platejs_slate1.ScrollIntoViewOptions;
}, {
  getFragment: () => _platejs_slate1.Descendant[];
  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,
  path,
  plugin,
  props
}: {
  editor: SlateEditor;
  props: SlateRenderNodeProps;
  attributes?: AnyObject;
  node?: TElement | TText;
  /** Pre-computed path to avoid expensive findPath traversal */
  path?: Path;
  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/plugins/input-rules/types.d.ts
type InputRuleTarget = 'insertBreak' | 'insertData' | 'insertText';
type BivariantCallback$1<TArgs extends unknown[], TResult> = {
  bivarianceHack: (...args: TArgs) => TResult;
}['bivarianceHack'];
type SelectionInputRuleContext<TEditor extends SlateEditor = SlateEditor> = {
  editor: TEditor;
  getBlockEntry: () => NodeEntry | undefined;
  getBlockStartRange: () => TRange | undefined;
  getBlockStartText: () => string | undefined;
  getBlockTextBeforeSelection: () => string;
  getCharAfter: () => string | undefined;
  getCharBefore: () => string | undefined;
  isCollapsed: boolean;
  pluginKey: string;
};
type InsertBreakInputRuleContext<TEditor extends SlateEditor = SlateEditor> = SelectionInputRuleContext<TEditor> & {
  cause: 'insertBreak';
  insertBreak: () => void;
};
type InsertDataInputRuleContext<TEditor extends SlateEditor = SlateEditor> = SelectionInputRuleContext<TEditor> & {
  cause: 'insertData';
  data: DataTransfer;
  insertData: (data: DataTransfer) => void;
  text: string | null;
};
type InsertTextInputRuleContext<TEditor extends SlateEditor = SlateEditor> = SelectionInputRuleContext<TEditor> & {
  cause: 'insertText';
  insertText: (text: string, options?: InsertTextOptions) => void;
  options?: InsertTextOptions;
  text: string;
};
type BaseInputRule<TContext extends SelectionInputRuleContext = SelectionInputRuleContext> = {
  enabled?: BivariantCallback$1<[context: TContext], boolean>;
  priority?: number;
};
type MarkInputRuleConfig = BaseInputRule<InsertTextInputRuleContext> & {
  end?: string;
  mark?: string;
  marks?: string[];
  start: string;
  trim?: 'allow' | 'reject';
  trigger: string;
};
type BlockStartInputRuleMatch = {
  range: TRange;
  text: string;
};
type MatchBlockStartOptions<TMatch extends object = {}, TContext extends SelectionInputRuleContext = SelectionInputRuleContext> = {
  match: RegExp | string | ((context: TContext) => RegExp | string | undefined);
  resolveMatch?: (args: {
    match: RegExpMatchArray | string;
    range: TRange;
    text: string;
  }) => TMatch | undefined;
};
type BlockStartInputRuleConfig<TMatch extends object = {}> = BaseInputRule<InsertTextInputRuleContext> & {
  apply?: (context: InsertTextInputRuleContext, match: BlockStartInputRuleMatch & TMatch) => boolean | void;
  mode?: 'set' | 'toggle' | 'wrap';
  node?: string;
  removeMatchedText?: boolean;
  trigger: string;
} & MatchBlockStartOptions<TMatch, InsertTextInputRuleContext>;
type BlockFenceInputRuleMatch = BlockStartInputRuleMatch & {
  path: Path;
};
type MatchBlockFenceOptions<TMatch = BlockFenceInputRuleMatch> = {
  block?: string;
  fence: string;
  resolveMatch?: (args: {
    fence: string;
    path: Path;
    range: TRange;
    text: string;
  }) => TMatch | undefined;
};
type BlockFenceInputRuleConfig<TMatch = BlockFenceInputRuleMatch> = BaseInputRule<SelectionInputRuleContext> & MatchBlockFenceOptions<TMatch> & {
  apply: (context: SelectionInputRuleContext, match: TMatch) => boolean | void;
  on: 'break' | 'match';
};
type DelimitedInlineInputRuleMatch = {
  content: string;
  deleteRange: TRange;
};
type MatchDelimitedInlineOptions = {
  boundaryRe?: RegExp;
  close?: string;
  followRe?: RegExp;
  open: string;
  rejectRepeatedOpen?: boolean;
  requireClosingDelimiter?: boolean;
  trim?: 'allow' | 'reject';
};
type TextSubstitutionPattern = {
  format: readonly [string, string] | string;
  match: readonly string[] | string;
  trigger?: readonly string[] | string;
};
type TextSubstitutionMatch = {
  end: string;
  pattern: TextSubstitutionPattern;
  points: {
    afterStartMatchPoint: Point | undefined;
    beforeEndMatchPoint: Point;
    beforeStartMatchPoint: Point | undefined;
  };
};
type TextSubstitutionInputRuleConfig = BaseInputRule<InsertTextInputRuleContext> & {
  patterns: TextSubstitutionPattern[];
};
type InputRuleBuilder = {
  blockFence: <TMatch = BlockFenceInputRuleMatch>(config: BlockFenceInputRuleConfig<TMatch>) => AnyInputRule<TMatch>;
  blockStart: <TMatch extends object = {}>(config: BlockStartInputRuleConfig<TMatch>) => InsertTextInputRule<BlockStartInputRuleMatch & TMatch>;
  insertBreak: <TMatch = true>(rule: InsertBreakInputRule<TMatch>) => InsertBreakInputRule<TMatch>;
  insertData: <TMatch = true>(rule: InsertDataInputRule<TMatch>) => InsertDataInputRule<TMatch>;
  insertText: <TMatch = true>(rule: InsertTextInputRule<TMatch>) => InsertTextInputRule<TMatch>;
  mark: (config: MarkInputRuleConfig) => InsertTextInputRule<{
    afterStartMatchPoint: Point;
    beforeEndMatchPoint: Point;
    beforeStartMatchPoint: Point;
    end: string | undefined;
  }>;
};
type InputRulesFactoryContext = {
  rule: InputRuleBuilder;
};
type InsertBreakInputRule<TMatch = true, TEditor extends SlateEditor = SlateEditor> = BaseInputRule<InsertBreakInputRuleContext<TEditor>> & {
  apply: BivariantCallback$1<[context: InsertBreakInputRuleContext<TEditor>, match: TMatch], boolean | void>;
  resolve?: BivariantCallback$1<[context: InsertBreakInputRuleContext<TEditor>], TMatch | undefined>;
  target: 'insertBreak';
};
type InsertDataInputRule<TMatch = true, TEditor extends SlateEditor = SlateEditor> = BaseInputRule<InsertDataInputRuleContext<TEditor>> & {
  apply: BivariantCallback$1<[context: InsertDataInputRuleContext<TEditor>, match: TMatch], boolean | void>;
  mimeTypes?: string[];
  resolve?: BivariantCallback$1<[context: InsertDataInputRuleContext<TEditor>], TMatch | undefined>;
  target: 'insertData';
};
type InsertTextInputRule<TMatch = true, TEditor extends SlateEditor = SlateEditor> = BaseInputRule<InsertTextInputRuleContext<TEditor>> & {
  apply: BivariantCallback$1<[context: InsertTextInputRuleContext<TEditor>, match: TMatch], boolean | void>;
  resolve?: BivariantCallback$1<[context: InsertTextInputRuleContext<TEditor>], TMatch | undefined>;
  target: 'insertText';
  trigger: readonly string[] | string;
};
type AnyInputRule<TMatch = unknown, TEditor extends SlateEditor = SlateEditor> = InsertBreakInputRule<TMatch, TEditor> | InsertDataInputRule<TMatch, TEditor> | InsertTextInputRule<TMatch, TEditor>;
type StoredInsertBreakInputRule = BaseInputRule<InsertBreakInputRuleContext> & {
  apply: BivariantCallback$1<[context: InsertBreakInputRuleContext, match: unknown], boolean | void>;
  resolve?: BivariantCallback$1<[context: InsertBreakInputRuleContext], unknown>;
  target: 'insertBreak';
};
type StoredInsertDataInputRule = BaseInputRule<InsertDataInputRuleContext> & {
  apply: BivariantCallback$1<[context: InsertDataInputRuleContext, match: unknown], boolean | void>;
  mimeTypes?: string[];
  resolve?: BivariantCallback$1<[context: InsertDataInputRuleContext], unknown>;
  target: 'insertData';
};
type StoredInsertTextInputRule = BaseInputRule<InsertTextInputRuleContext> & {
  apply: BivariantCallback$1<[context: InsertTextInputRuleContext, match: unknown], boolean | void>;
  resolve?: BivariantCallback$1<[context: InsertTextInputRuleContext], unknown>;
  target: 'insertText';
  trigger: readonly string[] | string;
};
type StoredInputRule = StoredInsertBreakInputRule | StoredInsertDataInputRule | StoredInsertTextInputRule;
type InputRulesDefinition = InputRulesConfig | ((ctx: InputRulesFactoryContext) => InputRulesConfig);
type InputRulesConfig = AnyInputRule<any, SlateEditor>[];
type ResolvedInputRule = StoredInputRule & {
  id: string;
  pluginKey: string;
  priority: number;
  ruleIndex: number;
  pluginIndex: number;
};
type ResolvedInputRulesMeta = {
  insertBreak: Extract<ResolvedInputRule, {
    target: 'insertBreak';
  }>[];
  insertData: Extract<ResolvedInputRule, {
    target: 'insertData';
  }>[];
  insertText: {
    all: Extract<ResolvedInputRule, {
      target: 'insertText';
    }>[];
    byTrigger: Record<string, Extract<ResolvedInputRule, {
      target: 'insertText';
    }>[]>;
  };
  plugins: Record<string, {
    rules: ResolvedInputRule[];
  }>;
};
//#endregion
//#region src/lib/plugin/SlatePlugin.d.ts
type AnyEditorPlugin = EditorPlugin<AnyPluginConfig>;
type AnySlatePlugin = SlatePlugin<AnyPluginConfig>;
/**
 * 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 TransformInitialValue<C extends AnyPluginConfig = PluginConfig> = (ctx: SlatePluginContext<C> & {
  value: Value;
}) => Value;
/** @deprecated Use {@link TransformInitialValue} instead. */
type NormalizeInitialValue<C extends AnyPluginConfig = PluginConfig> = (ctx: SlatePluginContext<C> & {
  value: 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>>;
  transformInitialValue?: TransformInitialValue<WithAnyKey<C>>;
  /** @deprecated Use `transformInitialValue` instead. */
  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>>;
  inputRules: InputRulesDefinition | InputRulesConfig;
};
type SlatePluginConfig$1<K$1 extends string = any, O = {}, A = {}, T = {}, S = {}, EO = {}, EA = {}, ET = {}, ES = {}> = Partial<Omit<SlatePlugin<PluginConfig<K$1, Partial<O>, A, T, S>>, keyof SlatePluginMethods | 'api' | 'node' | 'optionsStore' | 'transforms'> & {
  api: EA;
  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/liftBlock.d.ts
type LiftBlockOptions = {
  at?: EditorAboveOptions['at'];
  match?: EditorAboveOptions['match'];
};
/**
 * Lift the current block out of the nearest matching ancestor container.
 *
 * This unwraps only the current block and splits the ancestor around it when
 * needed, so one keypress changes one structural level instead of exploding the
 * whole container.
 */
declare const liftBlock: (editor: SlateEditor, {
  at,
  match
}?: LiftBlockOptions) => true | undefined;
//#endregion
//#region src/lib/plugins/slate-extension/transforms/resetBlock.d.ts
/**
 * Reset the current block to a paragraph, removing all properties except the
 * configured node id key 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
declare const isElementStateEmpty: (editor: SlateEditor, element: TElement) => boolean;
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;
}, {
  redecorate: () => void;
}, {
  init: OmitFirst<typeof init>;
  insertExitBreak: OmitFirst<typeof insertExitBreak>;
  liftBlock: OmitFirst<typeof liftBlock>;
  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;
}, {
  isElementStateEmpty: (element: TElement) => boolean;
  redecorate: () => void;
}, {
  init: ((args_0: InitOptions) => void) & ((args_0: InitOptions) => void);
  insertExitBreak: ((args_0?: InsertExitBreakOptions | undefined) => true | undefined) & ((args_0?: InsertExitBreakOptions | undefined) => true | undefined);
  liftBlock: ((args_0?: LiftBlockOptions | undefined) => true | undefined) & ((args_0?: LiftBlockOptions | undefined) => true | undefined);
  resetBlock: ((args_0?: {
    at?: _platejs_slate1.Path;
  } | undefined) => true | undefined) & ((args_0?: {
    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 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/navigation-feedback/types.d.ts
declare const NAVIGATION_FEEDBACK_KEY = "navigationFeedback";
declare const NavigationFeedbackPluginKey: {
  readonly key: "navigationFeedback";
};
type NavigationFeedbackTarget = {
  path: Path;
  type: 'node';
};
type NavigationFeedbackActiveTarget = NavigationFeedbackTarget & {
  cycle: 0 | 1;
  duration: number;
  pulse: number;
  variant: string;
};
type NavigationFeedbackStoredTarget = Omit<NavigationFeedbackActiveTarget, 'path'> & {
  pathRef: PathRef;
};
type NavigationFlashTargetOptions = {
  duration?: number;
  target: NavigationFeedbackTarget;
  variant?: string;
};
type NavigationNavigateOptions = {
  flash?: false | {
    duration?: number;
    variant?: string;
  };
  focus?: boolean;
  scroll?: boolean;
  scrollTarget?: Point;
  select?: Point | TRange;
  target: NavigationFeedbackTarget;
};
type NavigationFeedbackConfig = PluginConfig<typeof NAVIGATION_FEEDBACK_KEY, {
  activeTarget: NavigationFeedbackStoredTarget | null;
  duration: number;
}, {
  navigation: {
    activeTarget: () => NavigationFeedbackActiveTarget | null;
    clear: () => void;
    isTarget: (path: Path) => boolean;
  };
}, {
  navigation: {
    clear: () => void;
    flashTarget: (options: NavigationFlashTargetOptions) => boolean;
    navigate: (options: NavigationNavigateOptions) => boolean;
  };
}>;
//#endregion
//#region src/lib/plugins/navigation-feedback/NavigationFeedbackPlugin.d.ts
declare const NavigationFeedbackPlugin: SlatePlugin<PluginConfig<"navigationFeedback", {
  activeTarget: NavigationFeedbackStoredTarget | null;
  duration: number;
}, {
  navigation: {
    activeTarget: () => NavigationFeedbackActiveTarget | null;
    clear: () => void;
    isTarget: (path: _platejs_slate1.Path) => boolean;
  };
}, {
  navigation: {
    clear: () => void;
    flashTarget: (options: NavigationFlashTargetOptions) => boolean;
    navigate: (options: NavigationNavigateOptions) => boolean;
  };
}, {}>>;
//#endregion
//#region src/lib/plugins/navigation-feedback/transforms/flashTarget.d.ts
declare const resolveNavigationFeedbackTarget: (target?: NavigationFeedbackStoredTarget | null) => NavigationFeedbackActiveTarget | null;
declare const clearNavigationFeedbackTarget: (editor: SlateEditor, pulse?: number) => boolean;
declare const flashTarget: (editor: SlateEditor, {
  duration,
  target,
  variant
}: NavigationFlashTargetOptions) => boolean;
//#endregion
//#region src/lib/plugins/navigation-feedback/transforms/navigate.d.ts
declare const navigate: (editor: SlateEditor, {
  flash,
  focus,
  scroll,
  scrollTarget,
  select,
  target
}: NavigationNavigateOptions) => boolean;
//#endregion
//#region src/lib/plugins/affinity/AffinityPlugin.d.ts
type ElementAffinity = {
  affinity: 'backward' | 'forward';
  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;
  /**
   * Controls how missing ids are assigned in the initial value.
   *
   * - `'if-needed'`: normalize only when the first or last top-level node is
   *   missing an id
   * - `'always'`: walk the whole initial value and fill any missing ids
   * - `false`: skip initial-value id assignment
   *
   * @default 'if-needed'
   */
  initialValueIds?: false | 'always' | 'if-needed';
  /**
   * Legacy alias for `initialValueIds`.
   *
   * - `false`: only check the first and last top-level nodes
   * - `true`: walk the whole initial value and fill missing ids
   * - `null`: skip initial-value id assignment
   *
   * @deprecated Use `initialValueIds` instead.
   */
  normalizeInitialValue?: boolean | null;
  /**
   * Reports duplicate-id scan cost during inserted-node normalization.
   */
  onDuplicateIdScan?: (stats: {
    candidateCount: number;
    duration: number;
    existingCount: number;
    visitedCount: number;
  }) => void;
  /**
   * 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'>;
declare const normalizeNodeId: <V extends Value>(value: V, options?: NormalizeNodeIdOptions) => V;
declare const normalizeNodeIdWithEditor: <V extends Value>(editor: {
  api: {
    isBlock: (node: Descendant) => boolean;
  };
}, 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;
  /**
   * Controls how missing ids are assigned in the initial value.
   *
   * - `'if-needed'`: normalize only when the first or last top-level node is
   *   missing an id
   * - `'always'`: walk the whole initial value and fill any missing ids
   * - `false`: skip initial-value id assignment
   *
   * @default 'if-needed'
   */
  initialValueIds?: false | "always" | "if-needed";
  /**
   * Legacy alias for `initialValueIds`.
   *
   * - `false`: only check the first and last top-level nodes
   * - `true`: walk the whole initial value and fill missing ids
   * - `null`: skip initial-value id assignment
   *
   * @deprecated Use `initialValueIds` instead.
   */
  normalizeInitialValue?: boolean | null;
  /**
   * Reports duplicate-id scan cost during inserted-node normalization.
   */
  onDuplicateIdScan?: (stats: {
    candidateCount: number;
    duration: number;
    existingCount: number;
    visitedCount: number;
  }) => void;
  /**
   * 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 navigation feedback plugin. */
  navigationFeedback?: NavigationFeedbackConfig['options'] | boolean;
  /** 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,
  navigationFeedback,
  nodeId,
  plugins
}: GetCorePluginsOptions) => (SlatePlugin<DebugConfig> | SlatePlugin<PluginConfig<"slateExtension", {
  onNodeChange: (options: {
    editor: SlateEditor;
    node: _platejs_slate1.Descendant;
    operation: _platejs_slate1.NodeOperation;
    prevNode: _platejs_slate1.Descendant;
  }) => void;
  onTextChange: (options: {
    editor: SlateEditor;
    node: _platejs_slate1.Descendant;
    operation: _platejs_slate1.TextOperation;
    prevText: string;
    text: string;
  }) => void;
}, {
  isElementStateEmpty: (element: _platejs_slate1.TElement) => boolean;
  redecorate: () => void;
}, {
  init: ((args_0: InitOptions) => void) & ((args_0: InitOptions) => void);
  insertExitBreak: ((args_0?: InsertExitBreakOptions | undefined) => true | undefined) & ((args_0?: InsertExitBreakOptions | undefined) => true | undefined);
  liftBlock: ((args_0?: LiftBlockOptions | undefined) => true | undefined) & ((args_0?: LiftBlockOptions | undefined) => true | undefined);
  resetBlock: ((args_0?: {
    at?: _platejs_slate1.Path;
  } | undefined) => true | undefined) & ((args_0?: {
    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 | _platejs_slate1.TText>(operation: _platejs_slate1.Operation<N$1>) => void;
}, {}>> | SlatePlugin<PluginConfig<"dom", {
  scrollMode?: ScrollMode;
  scrollOperations?: AutoScrollOperationsMap;
  scrollOptions?: _platejs_slate1.ScrollIntoViewOptions;
}, {
  isScrolling: () => boolean;
}, {
  withScrolling: (fn: () => void, options?: WithAutoScrollOptions | undefined) => void;
}, {}>> | SlatePlugin<PluginConfig<"navigationFeedback", {
  activeTarget: NavigationFeedbackStoredTarget | null;
  duration: number;
}, {
  navigation: {
    activeTarget: () => NavigationFeedbackActiveTarget | null;
    clear: () => void;
    isTarget: (path: _platejs_slate1.Path) => boolean;
  };
}, {
  navigation: {
    clear: () => void;
    flashTarget: (options: NavigationFlashTargetOptions) => boolean;
    navigate: (options: NavigationNavigateOptions) => boolean;
  };
}, {}>> | SlatePlugin<PluginConfig<"history", {}, {}, {}, {}>> | SlatePlugin<PluginConfig> | SlatePlugin<PluginConfig<"override", {}, {}, {}, {}>> | SlatePlugin<PluginConfig<"parser", {}, {}, {}, {}>> | SlatePlugin<LengthConfig> | SlatePlugin<PluginConfig<"html", {}, Record<"html", {
  deserialize: (args_0: {
    element: HTMLElement | string;
    collapseWhiteSpace?: boolean;
    defaultElementPlugin?: WithRequiredKey;
  }) => _platejs_slate1.Descendant[];
}>, {}, {}>> | SlatePlugin<PluginConfig<"ast", {}, {}, {}, {}>> | SlatePlugin<PluginConfig<"nodeId", {
  disableInsertOverrides?: boolean;
  filterInline?: boolean;
  filterText?: boolean;
  idKey?: string;
  initialValueIds?: false | "always" | "if-needed";
  normalizeInitialValue?: boolean | null;
  onDuplicateIdScan?: (stats: {
    candidateCount: number;
    duration: number;
    existingCount: number;
    visitedCount: number;
  }) => void;
  reuseId?: boolean;
  idCreator?: () => any;
} & _platejs_slate1.QueryNodeOptions, {}, {
  nodeId: {
    normalize: () => void;
  };
} & Record<"nodeId", {
  normalize(): void;
}>, {}>> | SlatePlugin<AffinityConfig> | SlatePlugin<PluginConfig<"p", {}, {}, {}, {}>> | SlatePlugin<ChunkingConfig>)[];
type CorePluginTransforms = SlateExtensionConfig['transforms'] & NavigationFeedbackConfig['transforms'];
type CorePluginApi = SlateExtensionConfig['api'] & NavigationFeedbackConfig['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;
  }) => _platejs_slate1.Descendant[];
}>, {}, {}>>;
//#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) => HTMLElement;
//#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
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/input-rules/createInputRules.d.ts
declare const createMarkInputRule: (config: MarkInputRuleConfig) => ReturnType<InputRuleBuilder["mark"]>;
declare const matchBlockStart: <TMatch extends object = {}, TContext extends SelectionInputRuleContext = SelectionInputRuleContext>(context: TContext, config: MatchBlockStartOptions<TMatch, TContext>) => (BlockStartInputRuleMatch & TMatch) | undefined;
declare const createBlockStartInputRule: <TMatch extends object = {}>(config: BlockStartInputRuleConfig<TMatch>) => InsertTextInputRule<BlockStartInputRuleMatch & TMatch, SlateEditor>;
declare const matchBlockFence: <TMatch = BlockFenceInputRuleMatch, TContext extends SelectionInputRuleContext = SelectionInputRuleContext>(context: TContext, config: MatchBlockFenceOptions<TMatch>) => TMatch | undefined;
declare function createBlockFenceInputRule<TMatch = BlockFenceInputRuleMatch>(config: BlockFenceInputRuleConfig<TMatch>): InsertBreakInputRule<TMatch, SlateEditor> | InsertTextInputRule<TMatch, SlateEditor>;
declare const matchDelimitedInline: (context: SelectionInputRuleContext, {
  boundaryRe,
  close,
  followRe,
  open,
  requireClosingDelimiter,
  rejectRepeatedOpen,
  trim
}: MatchDelimitedInlineOptions) => DelimitedInlineInputRuleMatch | undefined;
declare const createTextSubstitutionInputRule: ({
  enabled,
  patterns,
  priority
}: TextSubstitutionInputRuleConfig) => InsertTextInputRule<TextSubstitutionMatch, SlateEditor>;
//#endregion
//#region src/lib/plugins/input-rules/createRuleFactory.d.ts
type FactoryValue<TInput, TValue> = TValue | ((input: TInput) => TValue);
type Simplify<T> = { [K in keyof T]: T[K] } & {};
type BivariantCallback<T extends (...args: never[]) => unknown> = {
  bivarianceHack: T;
}['bivarianceHack'];
type RuntimeOptions<TContext> = {
  enabled?: (context: TContext) => boolean;
  priority?: number;
};
type FactoryInput<TContext, TDefaults extends object, TRequired extends object> = TContext & TDefaults & TRequired;
type PublicOptions<TContext, TDefaults extends object, TRequired extends object> = Simplify<Partial<TDefaults> & TRequired & RuntimeOptions<TContext>>;
type CreateRuleFactoryReturn<TContext, TDefaults extends object, TRequired extends object> = keyof TRequired extends never ? (options?: PublicOptions<TContext, TDefaults, TRequired>) => AnyInputRule<unknown> : (options: PublicOptions<TContext, TDefaults, TRequired>) => AnyInputRule<unknown>;
type RuleFactoryConfigBuilder<TContext, TDefaults extends object, TRequired extends object, TConfig> = (options: PublicOptions<TContext, TDefaults, TRequired>) => TConfig;
type MarkRuleFactoryConfig<TDefaults extends object, TRequired extends object> = {
  type: 'mark';
  end?: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, string | undefined>;
  mark?: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, string | undefined>;
  marks?: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, string[] | undefined>;
  start: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, string>;
  trim?: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, MarkInputRuleConfig['trim']>;
  trigger: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, string>;
  enabled?: (input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>) => boolean;
  priority?: number;
};
type BlockStartRuleFactoryConfig<TDefaults extends object, TRequired extends object, TMatch extends object = {}> = {
  type: 'blockStart';
  apply?: BivariantCallback<(input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, match: BlockStartInputRuleMatch & TMatch) => boolean | void>;
  match: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, RegExp | string | undefined>;
  mode?: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, BlockStartInputRuleConfig<TMatch>['mode']>;
  node?: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, string | undefined>;
  removeMatchedText?: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, boolean | undefined>;
  resolveMatch?: (args: {
    match: RegExpMatchArray | string;
    range: BlockStartInputRuleMatch['range'];
    text: string;
  }, input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>) => TMatch | undefined;
  trigger: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, string>;
  enabled?: (input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>) => boolean;
  priority?: number;
};
type BlockFenceRuleFactoryConfig<TDefaults extends object, TRequired extends object, TMatch> = {
  type: 'blockFence';
  apply: BivariantCallback<(input: FactoryInput<SelectionInputRuleContext, TDefaults, TRequired>, match: TMatch) => boolean | void>;
  block?: FactoryValue<FactoryInput<SelectionInputRuleContext, TDefaults, TRequired>, string | undefined>;
  fence: FactoryValue<FactoryInput<SelectionInputRuleContext, TDefaults, TRequired>, string>;
  on?: FactoryValue<FactoryInput<SelectionInputRuleContext, TDefaults, TRequired>, BlockFenceInputRuleConfig<TMatch>['on']>;
  resolveMatch?: (args: {
    fence: string;
    path: BlockFenceInputRuleMatch['path'];
    range: BlockFenceInputRuleMatch['range'];
    text: string;
  }, input: FactoryInput<SelectionInputRuleContext, TDefaults, TRequired>) => TMatch | undefined;
  enabled?: (input: FactoryInput<SelectionInputRuleContext, TDefaults, TRequired>) => boolean;
  priority?: number;
};
type InsertTextRuleFactoryConfig<TDefaults extends object, TRequired extends object, TMatch> = {
  type: 'insertText';
  apply: BivariantCallback<(input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, match: TMatch) => boolean | void>;
  resolve?: (input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>) => TMatch | undefined;
  trigger: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, InsertTextInputRule<TMatch>['trigger']>;
  enabled?: (input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>) => boolean;
  priority?: number;
};
type InsertBreakRuleFactoryConfig<TDefaults extends object, TRequired extends object, TMatch> = {
  type: 'insertBreak';
  apply: BivariantCallback<(input: FactoryInput<InsertBreakInputRuleContext, TDefaults, TRequired>, match: TMatch) => boolean | void>;
  resolve?: (input: FactoryInput<InsertBreakInputRuleContext, TDefaults, TRequired>) => TMatch | undefined;
  enabled?: (input: FactoryInput<InsertBreakInputRuleContext, TDefaults, TRequired>) => boolean;
  priority?: number;
};
type InsertDataRuleFactoryConfig<TDefaults extends object, TRequired extends object, TMatch> = {
  type: 'insertData';
  apply: BivariantCallback<(input: FactoryInput<InsertDataInputRuleContext, TDefaults, TRequired>, match: TMatch) => boolean | void>;
  mimeTypes?: FactoryValue<FactoryInput<InsertDataInputRuleContext, TDefaults, TRequired>, string[] | undefined>;
  resolve?: (input: FactoryInput<InsertDataInputRuleContext, TDefaults, TRequired>) => TMatch | undefined;
  enabled?: (input: FactoryInput<InsertDataInputRuleContext, TDefaults, TRequired>) => boolean;
  priority?: number;
};
type TextSubstitutionRuleFactoryConfig<TDefaults extends object, TRequired extends object> = {
  type: 'textSubstitution';
  patterns: FactoryValue<FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>, TextSubstitutionInputRuleConfig['patterns']>;
  enabled?: (input: FactoryInput<InsertTextInputRuleContext, TDefaults, TRequired>) => boolean;
  priority?: number;
};
type AnyRuleFactoryConfig<TDefaults extends object = Record<string, unknown>, TRequired extends object = Record<string, unknown>, TMatch = unknown> = MarkRuleFactoryConfig<TDefaults, TRequired> | BlockStartRuleFactoryConfig<TDefaults, TRequired, TMatch extends object ? TMatch : {}> | BlockFenceRuleFactoryConfig<TDefaults, TRequired, TMatch> | InsertTextRuleFactoryConfig<TDefaults, TRequired, TMatch> | InsertBreakRuleFactoryConfig<TDefaults, TRequired, TMatch> | InsertDataRuleFactoryConfig<TDefaults, TRequired, TMatch> | TextSubstitutionRuleFactoryConfig<TDefaults, TRequired>;
type AnyRuleFactoryConfigLoose<TDefaults extends object = Record<string, unknown>, TRequired extends object = Record<string, unknown>> = MarkRuleFactoryConfig<TDefaults, TRequired> | BlockStartRuleFactoryConfig<TDefaults, TRequired, {}> | BlockFenceRuleFactoryConfig<TDefaults, TRequired, unknown> | InsertTextRuleFactoryConfig<TDefaults, TRequired, unknown> | InsertBreakRuleFactoryConfig<TDefaults, TRequired, unknown> | InsertDataRuleFactoryConfig<TDefaults, TRequired, unknown> | TextSubstitutionRuleFactoryConfig<TDefaults, TRequired>;
type ContextFromFactoryConfig<TConfig> = TConfig extends MarkRuleFactoryConfig<any, any> | BlockStartRuleFactoryConfig<any, any, any> | InsertTextRuleFactoryConfig<any, any, any> | TextSubstitutionRuleFactoryConfig<any, any> ? InsertTextInputRuleContext : TConfig extends BlockFenceRuleFactoryConfig<any, any, any> ? SelectionInputRuleContext : TConfig extends InsertBreakRuleFactoryConfig<any, any, any> ? InsertBreakInputRuleContext : InsertDataInputRuleContext;
declare function createRuleFactory<TRequired extends object = {}, TDefaults extends object = {}, TMatch = unknown, TConfig extends AnyRuleFactoryConfig<TDefaults, TRequired, TMatch> = AnyRuleFactoryConfig<TDefaults, TRequired, TMatch>>(config: TConfig & TDefaults): CreateRuleFactoryReturn<ContextFromFactoryConfig<TConfig>, TDefaults, TRequired>;
declare function createRuleFactory<TRequired extends object = {}, TDefaults extends object = {}>(configBuilder: RuleFactoryConfigBuilder<SelectionInputRuleContext | InsertTextInputRuleContext | InsertBreakInputRuleContext | InsertDataInputRuleContext, TDefaults, TRequired, AnyRuleFactoryConfigLoose<TDefaults, TRequired>>): CreateRuleFactoryReturn<SelectionInputRuleContext | InsertTextInputRuleContext | InsertBreakInputRuleContext | InsertDataInputRuleContext, TDefaults, TRequired>;
//#endregion
//#region src/lib/plugins/input-rules/defineInputRule.d.ts
declare function defineInputRule<TMatch = true, TEditor extends SlateEditor = SlateEditor>(rule: InsertBreakInputRule<TMatch, TEditor>): InsertBreakInputRule<TMatch, TEditor>;
declare function defineInputRule<TMatch = true, TEditor extends SlateEditor = SlateEditor>(rule: InsertDataInputRule<TMatch, TEditor>): InsertDataInputRule<TMatch, TEditor>;
declare function defineInputRule<TMatch = true, TEditor extends SlateEditor = SlateEditor>(rule: InsertTextInputRule<TMatch, TEditor>): InsertTextInputRule<TMatch, TEditor>;
declare function defineInputRule<TRule extends AnyInputRule>(rule: TRule): TRule;
//#endregion
//#region src/lib/plugins/length/LengthPlugin.d.ts
declare const LengthPlugin: SlatePlugin<LengthConfig>;
//#endregion
//#region src/lib/plugins/node-id/normalizeStaticValue.d.ts
declare const STATIC_VALUE_CREATED_AT = 1704067200000;
type NormalizeStaticValueOptions = NormalizeNodeIdOptions & {
  createdAt?: number;
};
declare const normalizeStaticValue: <V extends Value>(value: V, options?: NormalizeStaticValueOptions) => V;
//#endregion
//#region src/lib/plugins/node-id/withNodeId.d.ts
/** Enables support for inserting nodes with an id key. */
declare const withNodeId: OverrideEditor<NodeIdConfig>;
//#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
     * - `'lift'`: Lift the current block out of the nearest matching ancestor
     * - `'reset'`: Reset block to default paragraph type
     * - `'lineBreak'`: Insert newline character
     * - `'deleteExit'`: Delete backward then exit
     */
    break?: BreakRules;
    /**
     * Defines actions on delete based on block state.
     *
     * - `'default'`: Default behavior
     * - `'lift'`: Lift the current block out of the nearest matching ancestor
     * - `'reset'`: Reset block to default paragraph type
     */
    delete?: DeleteRules;
    /** 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.
   *   - `transformInitialValue`: 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;
  /**
   * Returns whether an element prop is inert metadata for empty-state checks.
   *
   * Props not claimed by a plugin are treated as meaningful state.
   */
  isMetadataProp?: (options: BasePluginContext<C> & {
    key: string;
    node: TElement;
    value: unknown;
  }) => 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' | 'lift' | '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' | 'lift' | '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, `transformInitialValue` 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).
   */
  transformInitialValue?: boolean;
  /**
   * @deprecated Use `transformInitialValue` instead.
   */
  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[];
        isMetadataProp: string[];
        isText: string[];
        leafProps: string[];
        textProps: string[];
        /** Node types to plugin keys. */
        types: Record<string, string>;
      };
      transformInitialValue: 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[];
    inputRules: ResolvedInputRulesMeta;
    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'] & {
    inputRules: ResolvedInputRulesMeta;
    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 the built-in navigation feedback plugin.
   *
   * This core plugin flashes the landed target after navigation jumps such as
   * TOC, footnote, search, or custom outline movement.
   *
   * @default { duration: 1600 }
   */
  navigationFeedback?: NavigationFeedbackConfig['options'] | boolean;
  /**
   * Configuration for automatic node ID generation and management.
   *
   * 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' | 'transformInitialValue' | '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,
  navigationFeedback,
  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;
  /** Pre-computed path for static rendering (avoids expensive findPath traversal). */
  path?: Path;
};
//#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;
  /** Pre-computed path for static rendering. */
  path?: Path;
  text: N$1;
  /**
   * The position of the leaf within the Text node, only present when the text
   * 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;
  /** Pre-computed path for static rendering. */
  path?: Path;
  /** 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" | "type" | "getOption" | "tf" | "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 $, getEditorDOMFromHtmlString as $a, RenderStaticNodeWrapperFunction as $i, cleanHtmlFontElements as $n, NavigationNavigateOptions as $r, upsertInlineFormattingContext as $t, applyDeepToNodes as A, MatchBlockFenceOptions as Aa, createTSlatePlugin as Ai, isHtmlInlineElement as An, SlateRenderElement as Ao, LogLevel as Ar, BaseParagraphPlugin as At, ZustandStoreApi as B, stripHtmlClassNames as Ba, HtmlSerializer as Bi, htmlBrToNewLine as Bn, ElementAffinity as Br, STATIC_VALUE_CREATED_AT as Bt, isSlateNode as C, InsertBreakInputRule as Ca, getPluginKey as Ci, pipeDeserializeHtmlLeaf as Cn, SlateRenderText as Co, NodeIdOptions as Cr, NodeComponents as Ct, isSlateText as D, InsertTextInputRule as Da, getSlatePlugin as Di, isOlSymbol as Dn, pipeRenderLeafStatic as Do, normalizeNodeIdWithEditor as Dr, SelectionRules as Dt, isSlateString as E, InsertDataInputRuleContext as Ea, getPluginTypes as Ei, parseHtmlDocument as En, SlateRenderLeaf as Eo, normalizeNodeId as Er, PluginConfig as Et, RenderLeafProps as F, SelectionInputRuleContext as Fa, EditorPlugin as Fi, inlineTagNames as Fn, getMarkBoundaryAffinity as Fr, withBreakRules as Ft, WithSlateOptions as G, getSelectedDomBlocks as Ga, NodeStaticWrapperComponent as Gi, someHtmlElement as Gn, NavigationFeedbackPlugin as Gr, createBlockFenceInputRule as Gt, nanoid$1 as H, isSelectOutside as Ha, InjectNodeProps as Hi, getHtmlComments as Hn, clearNavigationFeedbackTarget as Hr, LengthPlugin as Ht, RenderElementFn as I, TextSubstitutionInputRuleConfig as Ia, ExtendEditor as Ii, htmlTextNodeToString as In, getEdgeNodes as Ir, OverridePlugin as It, BaseEditor as J, getPluginDataAttributes as Ja, NormalizeInitialValue as Ji, deserializeHtmlElement as Jn, NavigationFeedbackConfig as Jr, createTextSubstitutionInputRule as Jt, createSlateEditor as K, getRenderNodeStaticProps as Ka, NodeStaticWrapperComponentProps as Ki, deserializeHtmlNodeChildren as Kn, NAVIGATION_FEEDBACK_KEY as Kr, createBlockStartInputRule as Kt, RenderElementProps as L, TextSubstitutionMatch as La, ExtendEditorApi as Li, htmlStringToDOMNode as Ln, EdgeNodes as Lr, withOverrides as Lt, RenderTextFn as M, MatchDelimitedInlineOptions as Ma, AnySlatePlugin as Mi, isHtmlElement as Mn, HandlerReturnType as Mo, setAffinitySelection as Mr, withNormalizeRules as Mt, RenderTextProps as N, ResolvedInputRule as Na, Decorate as Ni, isHtmlComment as Nn, AstPlugin as No, isNodeAffinity as Nr, withMergeRules as Nt, isSlateVoid as O, InsertTextInputRuleContext as Oa, getEditorPlugin as Oi, isHtmlText as On, pluginRenderLeafStatic as Oo, DebugErrorType as Or, WithAnyKey as Ot, RenderLeafFn as P, ResolvedInputRulesMeta as Pa, Deserializer as Pi, isHtmlBlockElement as Pn, isNodesAffinity as Pr, withDeleteRules as Pt, SlateEditor as Q, createStaticEditor as Qa, RenderStaticNodeWrapper as Qi, cleanHtmlLinkElements as Qn, NavigationFlashTargetOptions as Qr, endInlineFormattingContext as Qt, RenderChunkFn as R, TextSubstitutionPattern as Ra, ExtendEditorTransforms as Ri, htmlElementToLeaf as Rn, AffinityConfig as Rr, withNodeId as Rt, isSlateLeaf as S, InputRulesFactoryContext as Sa, getPluginByType as Si, pluginDeserializeHtml as Sn, PlateStaticProps as So, NodeIdConfig as Sr, NodeComponent as St, isSlatePluginNode as T, InsertDataInputRule as Ta, getPluginType as Ti, parseHtmlElement as Tn, pluginRenderTextStatic as To, NormalizeNodeIdOptions as Tr, ParserOptions as Tt, BaseWithSlateOptions as U, getSelectedDomNode as Ua, LeafStaticProps as Ui, getDataNodeProps as Un, flashTarget as Ur, defineInputRule as Ut, createZustandStore$1 as V, pipeDecorate as Va, InferConfig as Vi, htmlBodyToFragment as Vn, navigate as Vr, normalizeStaticValue as Vt, CreateSlateEditorOptions as W, getSelectedDomFragment as Wa, NodeStaticProps as Wi, findHtmlElement as Wn, resolveNavigationFeedbackTarget as Wr, createRuleFactory as Wt, KeyofNodePlugins as X, getStaticPlugins as Xa, Parser as Xi, copyBlockMarksToSpanChild as Xn, NavigationFeedbackStoredTarget as Xr, matchBlockStart as Xt, InferPlugins as Y, createStaticString as Ya, OverrideEditor as Yi, deserializeHtml as Yn, NavigationFeedbackPluginKey as Yr, matchBlockFence as Yt, KeyofPlugins as Z, ViewPlugin as Za, PartialEditorPlugin as Zi, cleanHtmlTextNodes as Zn, NavigationFeedbackTarget as Zr, matchDelimitedInline as Zt, getInjectMatch as _, DelimitedInlineInputRuleMatch as _a, init as _i, replaceTagName as _n, SerializeHtmlOptions as _o, GetCorePluginsOptions as _r, InferOptions as _t, omitPluginContext as a, SlatePluginMethods as aa, WithAutoScrollOptions as ai, collapseWhiteSpaceChildren as an, SlateNodeProps as ao, CARRIAGE_RETURN as ar, BasePluginContext as at, isSlateEditor as b, InputRulesConfig as ba, withPlateHistory as bi, preCleanHtml as bn, LeafStatic as bo, ChunkingConfig as br, MatchRules as bt, isType as c, TextStaticProps as ca, SlateExtensionPlugin as ci, CollapseWhiteSpaceState as cn, StyledSlateElementProps as co, SPACE as cr, BaseTransformOptions as ct, isHotkey as d, AnyInputRule as da, resetBlock as di, WhiteSpaceRule as dn, useNodeAttributes as do, HtmlPlugin as dr, EditOnlyConfig as dt, RenderStaticNodeWrapperProps as ea, AUTO_SCROLL as ei, isLastNonEmptyTextOfInlineFormattingContext as en, SlateElement as eo, cleanHtmlEmptyElements as er, AnyPluginConfig as et, getSlateClass as f, BaseInputRule as fa, LiftBlockOptions as fi, unwrapHtmlElement as fn, BoxStaticProps as fo, withChunking as fr, ExtendConfig as ft, getInjectedPlugins as g, BlockStartInputRuleMatch as ga, InitOptions as gi, traverseHtmlComments as gn, SlateRenderTextProps as go, DebugConfig as gr, InferKey as gt, keyToDataAttribute as h, BlockStartInputRuleConfig as ha, insertExitBreak as hi, traverseHtmlElements as hn, SlateRenderNodeProps as ho, CorePluginTransforms as hr, InferApi as ht, overridePluginsByKey as i, SlatePluginContext as ia, ScrollMode as ii, collapseWhiteSpaceElement as in, SlateLeafProps as io, DeserializeHtmlNodeReturnType as ir, BasePlugin as it, EditableProps as j, MatchBlockStartOptions as ja, AnyEditorPlugin as ji, isHtmlFragmentHref as jn, pluginRenderElementStatic as jo, PlateError as jr, ParagraphConfig as jt, ApplyDeepToNodesOptions as k, MarkInputRuleConfig as ka, createSlatePlugin as ki, isHtmlTable as kn, pipeRenderElementStatic as ko, DebugPlugin as kr, WithRequiredKey as kt, Hotkeys as l, TransformInitialValue as la, isElementStateEmpty as li, TrimEndRule as ln, StyledSlateLeafProps as lo, TAB as lr, BreakRules as lt, getNodeDataAttributeKeys as m, BlockFenceInputRuleMatch as ma, InsertExitBreakOptions as mi, traverseHtmlNode as mn, SlateRenderLeafProps as mo, CorePluginApi as mr, GetInjectNodePropsReturnType as mt, pipeOnNodeChange as n, SlatePlugin as na, DOMPlugin as ni, collapseWhiteSpaceText as nn, SlateHTMLProps as no, cleanHtmlBrElements as nr, BaseHtmlDeserializer as nt, normalizeDescendantsToDocumentFragment as o, SlatePlugins as oa, withScrolling as oi, collapseWhiteSpace as on, SlateText as oo, LINE_FEED as or, BasePluginNode as ot, getPluginNodeProps as p, BlockFenceInputRuleConfig as pa, liftBlock as pi, traverseHtmlTexts as pn, SlateRenderElementProps as po, CorePlugin as pr, GetInjectNodePropsOptions as pt, withSlate as q, getNodeDataAttributes as qa, NodeStaticWrapperComponentReturnType as qi, deserializeHtmlNode as qn, NavigationFeedbackActiveTarget as qr, createMarkInputRule as qt, pipeInsertDataQuery as r, SlatePluginConfig$1 as ra, DomConfig as ri, collapseWhiteSpaceNode as rn, SlateLeaf as ro, DeserializeHtmlChildren as rr, BaseInjectProps as rt, mergeDeepToNodes as s, SlateShortcut as sa, SlateExtensionConfig as si, collapseString as sn, SlateTextProps as so, NO_BREAK_SPACE as sr, BaseSerializer as st, pipeOnTextChange as t, Serializer as ta, AutoScrollOperationsMap as ti, inferWhiteSpaceRule as tn, SlateElementProps as to, cleanHtmlCrLf as tr, BaseDeserializer as tt, createHotkey as u, TransformOptions as ua, setValue as ui, TrimStartRule as un, StyledSlateTextProps as uo, ZERO_WIDTH_SPACE as ur, DeleteRules as ut, defaultsDeepToNodes as v, InputRuleBuilder as va, ParserPlugin as vi, removeHtmlSurroundings as vn, serializeHtml as vo, LengthConfig as vr, InferSelectors as vt, isSlatePluginElement as w, InsertBreakInputRuleContext as wa, getPluginKeys as wi, pipeDeserializeHtmlElement as wn, pipeRenderTextStatic as wo, NodeIdPlugin as wr, NormalizeRules as wt, isSlateElement as x, InputRulesDefinition as xa, getContainerTypes as xi, postCleanHtml as xn, PlateStatic as xo, ChunkingPlugin as xr, MergeRules as xt, getSlateElements as y, InputRuleTarget as ya, HistoryPlugin as yi, removeHtmlNodesBetweenComments as yn, ElementStatic as yo, getCorePlugins as yr, InferTransforms as yt, RenderChunkProps as z, stripSlateDataAttributes as za, HtmlDeserializer as zi, htmlElementToElement as zn, AffinityPlugin as zr, NormalizeStaticValueOptions as zt };