@prosekit/extensions 0.0.0-next-20231120040948 → 0.0.0-next-20240427133255

package/dist/_tsup-dts-rollup.d.ts

@@ -1,19 +1,35 @@
+import { Attrs } from '@prosekit/pm/model';
+import { BundledLanguage } from 'shiki';
+import { BundledLanguageInfo } from 'shiki';
+import { bundledLanguagesInfo } from 'shiki';
+import { BundledTheme } from 'shiki';
+import { BundledThemeInfo } from 'shiki';
+import { bundledThemesInfo } from 'shiki';
+import { Command } from '@prosekit/pm/state';
 import { CommandArgs } from '@prosekit/core';
 import { DedentListOptions } from 'prosemirror-flat-list';
 import { EditorState } from '@prosekit/pm/state';
 import { Extension } from '@prosekit/core';
 import { ExtensionTyping } from '@prosekit/core';
-import type { HLJSApi } from 'highlight.js';
+import { getHighlighter } from 'shiki/bundle/full';
 import { IndentListOptions } from 'prosemirror-flat-list';
+import { InputRule } from '@prosekit/pm/inputrules';
 import { ListAttributes } from 'prosemirror-flat-list';
+import { ListDOMSerializer } from 'prosemirror-flat-list';
+import { MarkType } from '@prosekit/pm/model';
 import { NodeRange } from 'prosemirror-model';
+import { NodeType } from '@prosekit/pm/model';
 import { Options } from 'tsup';
+import { Parser } from 'prosemirror-highlight';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
 import { PluginKey } from '@prosekit/pm/state';
+import { ProseMirrorNode } from '@prosekit/pm/model';
+import type { ResolvedPos } from '@prosekit/pm/model';
+import type { Selection as Selection_2 } from '@prosekit/pm/state';
+import type { SpecialLanguage } from 'shiki';
 import { ToggleCollapsedOptions } from 'prosemirror-flat-list';
 import { Transaction } from '@prosekit/pm/state';
 import { UnwrapListOptions } from 'prosemirror-flat-list';
-import { UserProjectConfigExport } from 'vitest/dist/config.js';
 
 declare class AutocompleteRule {
     readonly regex: RegExp;
@@ -34,30 +50,86 @@ declare class AutocompleteRule {
 export { AutocompleteRule }
 export { AutocompleteRule as AutocompleteRule_alias_1 }
 
+export { BundledLanguage as ShikiBundledLanguage }
+export { BundledLanguage as ShikiBundledLanguage_alias_1 }
+
+export { BundledLanguageInfo as ShikiBundledLanguageInfo }
+export { BundledLanguageInfo as ShikiBundledLanguageInfo_alias_1 }
+
+export { bundledLanguagesInfo as shikiBundledLanguagesInfo }
+export { bundledLanguagesInfo as shikiBundledLanguagesInfo_alias_1 }
+
+export { BundledTheme as ShikiBundledTheme }
+export { BundledTheme as ShikiBundledTheme_alias_1 }
+
+export { BundledThemeInfo as ShikiBundledThemeInfo }
+export { BundledThemeInfo as ShikiBundledThemeInfo_alias_1 }
+
+export { bundledThemesInfo as shikiBundledThemesInfo }
+export { bundledThemesInfo as shikiBundledThemesInfo_alias_1 }
+
+export declare interface CellAttrs {
+    colspan: number;
+    rowspan: number;
+    colwidth: number[] | null;
+}
+
+/**
+ * The attributes for the `codeBlock` node.
+ *
+ * @public
+ */
 declare interface CodeBlockAttrs {
     language?: string;
 }
 export { CodeBlockAttrs }
 export { CodeBlockAttrs as CodeBlockAttrs_alias_1 }
 
+/**
+ * @public
+ */
+export declare interface CodeBlockShikiOptions {
+    /**
+     * Theme registation
+     *
+     * @default ['one-dark-pro']
+     */
+    themes?: BundledTheme[];
+    /**
+     * Language registation
+     *
+     * @default ['text']
+     */
+    langs?: (BundledLanguage | SpecialLanguage)[];
+    /**
+     * Alias of languages
+     *
+     * @example { 'my-lang': 'javascript' }
+     */
+    langAlias?: Record<string, BundledLanguage>;
+}
+
 export declare function createAutocompletePlugin({ getRules, }: {
     getRules: () => AutocompleteRule[];
 }): Plugin_2;
 
-export declare function createPredictionPlugin(options: SuggestionOptions): Plugin_2;
+/**
+ * @internal
+ */
+export declare function createLazyParser(highlighterOptions: HighlighterOptions): Parser;
 
 export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
 
-export declare const default_alias_1: UserProjectConfigExport;
+export declare const default_alias_1: {
+    test: {
+        environment: "jsdom";
+    };
+};
 
 export declare function defaultCanMatch({ state }: {
     state: EditorState;
 }): boolean;
 
-export declare function defaultIsValid({ state }: {
-    state: EditorState;
-}): boolean;
-
 export declare function defineAutocomplete(rule: AutocompleteRule): Extension;
 
 /**
@@ -67,6 +139,12 @@ export declare function defineBlockquote(): Extension<    {
 NODES: "blockquote";
 }>;
 
+/**
+ * Wraps the text block in a blockquote when `>` is typed at the start of a new
+ * line followed by a space.
+ */
+export declare function defineBlockquoteInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
 export declare function defineBlockquoteSpec(): Extension<    {
 NODES: "blockquote";
 }>;
@@ -104,32 +182,100 @@ toggleCode: [];
 }>;
 
 /**
+ * Adds `codeBlock` nodes to the editor. This includes the following extensions:
+ *
+ * - {@link defineCodeBlockSpec}
+ * - {@link defineCodeBlockInputRule}
+ * - {@link defineCodeBlockEnterRule}
+ * - {@link defineCodeBlockKeymap}
+ * - {@link defineCodeBlockCommands}.
+ *
  * @public
  */
-export declare function defineCodeBlock(options?: {
-    hljs?: HLJSApi;
-}): Extension<    {
+declare function defineCodeBlock(): Extension<    {
 NODES: "codeBlock";
 COMMAND_ARGS: {
-setCodeBlockLanguage: [language: string];
+setCodeBlock: [attrs?: CodeBlockAttrs | undefined];
+insertCodeBlock: [attrs?: CodeBlockAttrs | undefined];
+toggleCodeBlock: [attrs?: CodeBlockAttrs | undefined];
+setCodeBlockAttrs: [attrs: CodeBlockAttrs];
 };
 }>;
+export { defineCodeBlock }
+export { defineCodeBlock as defineCodeBlock_alias_1 }
 
-export declare function defineCodeBlockCommands(): Extension<    {
+/**
+ * Adds commands for working with `codeBlock` nodes.
+ *
+ * @public
+ */
+declare function defineCodeBlockCommands(): Extension<    {
 COMMAND_ARGS: {
-setCodeBlockLanguage: [language: string];
+setCodeBlock: [attrs?: CodeBlockAttrs | undefined];
+insertCodeBlock: [attrs?: CodeBlockAttrs | undefined];
+toggleCodeBlock: [attrs?: CodeBlockAttrs | undefined];
+setCodeBlockAttrs: [attrs: CodeBlockAttrs];
 };
 }>;
+export { defineCodeBlockCommands }
+export { defineCodeBlockCommands as defineCodeBlockCommands_alias_1 }
+
+/**
+ * Adds enter rules for `codeBlock` nodes.
+ *
+ * @public
+ */
+declare function defineCodeBlockEnterRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineCodeBlockEnterRule }
+export { defineCodeBlockEnterRule as defineCodeBlockEnterRule_alias_1 }
+
+/**
+ * Adds syntax highlighting to code blocks. This function requires a `Parser`
+ * instance from the `prosemirror-highlight` package. See the
+ * [documentation](https://github.com/ocavue/prosemirror-highlight) for more
+ * information.
+ *
+ * @public
+ */
+declare function defineCodeBlockHighlight({ parser, }: {
+    parser: HighlightParser;
+}): Extension;
+export { defineCodeBlockHighlight }
+export { defineCodeBlockHighlight as defineCodeBlockHighlight_alias_1 }
 
-export declare function defineCodeBlockHighlight(options: {
-    hljs?: HLJSApi;
-}): Extension<ExtensionTyping<string, string, CommandArgs>>;
+/**
+ * Adds input rules for `codeBlock` nodes.
+ *
+ * @public
+ */
+declare function defineCodeBlockInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineCodeBlockInputRule }
+export { defineCodeBlockInputRule as defineCodeBlockInputRule_alias_1 }
 
-export declare function defineCodeBlockInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+/**
+ * Defines the keymap for code blocks.
+ */
+export declare function defineCodeBlockKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
-export declare function defineCodeBlockSpec(): Extension<    {
+/**
+ * Adds syntax highlighting to code blocks using the [shiki](https://github.com/shikijs/shiki) package.
+ *
+ * @public
+ */
+declare function defineCodeBlockShiki({ themes, langs, langAlias, }?: CodeBlockShikiOptions): Extension;
+export { defineCodeBlockShiki }
+export { defineCodeBlockShiki as defineCodeBlockShiki_alias_1 }
+
+/**
+ * Defines the `codeBlock` node spec.
+ *
+ * @public
+ */
+declare function defineCodeBlockSpec(): Extension<    {
 NODES: "codeBlock";
 }>;
+export { defineCodeBlockSpec }
+export { defineCodeBlockSpec as defineCodeBlockSpec_alias_1 }
 
 export declare function defineCodeCommands(): Extension<    {
 COMMAND_ARGS: {
@@ -144,6 +290,24 @@ export declare function defineCodeSpec(): Extension<    {
 MARKS: "code";
 }>;
 
+/**
+ * Show up a decoration at the drop position when something is dragged over the editor.
+ *
+ * See [prosemirror-dropcursor](https://github.com/ProseMirror/prosemirror-dropcursor) for more information.
+ *
+ * @public
+ */
+export declare function defineDropCursor(options?: DropCursorOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+/**
+ * Defines an enter rule. An enter rule applies when the text directly in front of
+ * the cursor matches `regex` and user presses Enter. The `regex` should end
+ * with `$`.
+ *
+ * @public
+ */
+export declare function defineEnterRule({ regex, handler, stop, }: EnterRuleOptions): Extension;
+
 /**
  * @public
  */
@@ -164,6 +328,10 @@ toggleHeading: [attrs?: HeadingAttrs | undefined];
 };
 }>;
 
+/**
+ * Converts the text block to a heading when `#` is typed at the start of a new
+ * line followed by a space.
+ */
 export declare function defineHeadingInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
 export declare function defineHeadingKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
@@ -192,6 +360,15 @@ export declare function defineImageSpec(): Extension<    {
 NODES: "image";
 }>;
 
+/**
+ * Defines an input rule extension.
+ *
+ * @param rule - The ProseMirror input rule to add.
+ *
+ * @public
+ */
+export declare function defineInputRule(rule: InputRule): Extension;
+
 /**
  * @public
  */
@@ -223,17 +400,25 @@ export declare function defineLink(): Extension<    {
 MARKS: "link";
 COMMAND_ARGS: {
 addLink: [attrs: LinkAttrs];
+removeLink: [];
 toggleLink: [attrs: LinkAttrs];
+expandLink: [];
 };
 }>;
 
 export declare function defineLinkCommands(): Extension<    {
 COMMAND_ARGS: {
 addLink: [attrs: LinkAttrs];
+removeLink: [];
 toggleLink: [attrs: LinkAttrs];
+expandLink: [];
 };
 }>;
 
+export declare function defineLinkEnterRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare function defineLinkInputRule(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
 export declare function defineLinkSpec(): Extension<    {
 MARKS: "link";
 }>;
@@ -241,36 +426,36 @@ MARKS: "link";
 /**
  * @public
  */
-export declare function defineList(): Extension<    {
-NODES: "list";
-COMMAND_ARGS: {
-dedentList: [options?: DedentListOptions | undefined];
-indentList: [options?: IndentListOptions | undefined];
-moveList: [direction: "up" | "down"];
-splitList: [];
-toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
-toggleList: [attrs: ListAttributes];
-unwrapList: [options?: UnwrapListOptions | undefined];
-wrapInList: [getAttrs: ListAttributes | ((range: NodeRange) => ListAttributes | null)];
-insertList: [attrs?: ListAttributes | undefined];
-};
-}>;
-
-export declare function defineListCommands(): Extension<    {
-COMMAND_ARGS: {
-dedentList: [options?: DedentListOptions | undefined];
-indentList: [options?: IndentListOptions | undefined];
-moveList: [direction: "up" | "down"];
-splitList: [];
-toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
-toggleList: [attrs: ListAttributes];
-unwrapList: [options?: UnwrapListOptions | undefined];
-wrapInList: [getAttrs: ListAttributes | ((range: NodeRange) => ListAttributes | null)];
-insertList: [attrs?: ListAttributes | undefined];
-};
-}>;
-
-export declare function defineListInputRules(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export declare function defineList(): Extension<{
+    NODES: "list";
+    COMMAND_ARGS: {
+        dedentList: [options?: DedentListOptions | undefined];
+        indentList: [options?: IndentListOptions | undefined];
+        moveList: [direction: "up" | "down"];
+        splitList: [];
+        toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
+        toggleList: [attrs: ListAttributes];
+        unwrapList: [options?: UnwrapListOptions | undefined];
+        wrapInList: [getAttrs: ListAttributes | ((range: NodeRange) => ListAttributes | null)];
+        insertList: [attrs?: ListAttributes | undefined];
+    };
+}>;
+
+export declare function defineListCommands(): Extension<{
+    COMMAND_ARGS: {
+        dedentList: [options?: DedentListOptions | undefined];
+        indentList: [options?: IndentListOptions | undefined];
+        moveList: [direction: "up" | "down"];
+        splitList: [];
+        toggleCollapsed: [(ToggleCollapsedOptions | undefined)?];
+        toggleList: [attrs: ListAttributes];
+        unwrapList: [options?: UnwrapListOptions | undefined];
+        wrapInList: [getAttrs: ListAttributes | ((range: NodeRange) => ListAttributes | null)];
+        insertList: [attrs?: ListAttributes | undefined];
+    };
+}>;
+
+export declare function defineListInputRules(): Extension;
 
 /**
  * Returns a extension that adds key bindings for list.
@@ -281,15 +466,33 @@ export declare function defineListKeymap(): Extension<ExtensionTyping<string, st
 
 export declare function defineListPlugins(): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
-export declare function defineListSpec(): Extension<    {
-NODES: "list";
+export declare function defineListSpec(): Extension<{
+    NODES: "list";
 }>;
 
+/**
+ * A mark rule is something that can automatically apply marks to text if it matches a certain pattern, and remove them if it doesn't match anymore.
+ *
+ * For every transaction that changes the document, the mark rule will be applied to the changed text.
+ *
+ *
+ */
+export declare function defineMarkRule(options: MarkRuleOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
 /**
  * @public
  */
 export declare function defineMention(): Extension<    {
 NODES: "mention";
+COMMAND_ARGS: {
+insertMention: [attrs: MentionAttrs];
+};
+}>;
+
+export declare function defineMentionCommands(): Extension<    {
+COMMAND_ARGS: {
+insertMention: [attrs: MentionAttrs];
+};
 }>;
 
 /**
@@ -305,6 +508,11 @@ NODES: "mention";
  */
 export declare function definePlaceholder(options: PlaceholderOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
 
+/**
+ * Make the editor read-only.
+ */
+export declare function defineReadonly(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
 /**
  * @public
  */
@@ -327,7 +535,102 @@ export declare function defineStrikeSpec(): Extension<    {
 MARKS: "strike";
 }>;
 
-export declare function defineSuggestion(options: SuggestionOptions): Extension<ExtensionTyping<string, string, CommandArgs>>;
+/**
+ * @public
+ */
+export declare function defineTable(): Extension<    {
+NODES: "table" | "tableRow" | "tableCell" | "tableHeaderCell";
+COMMAND_ARGS: {
+insertTable: [{
+row: number;
+col: number;
+header: boolean;
+}];
+exitTable: [];
+};
+}>;
+
+declare function defineTableCellSpec(): Extension<    {
+NODES: "tableCell";
+}>;
+export { defineTableCellSpec }
+export { defineTableCellSpec as defineTableCellSpec_alias_1 }
+
+/**
+ * Adds commands for working with `table` nodes.
+ *
+ * @public
+ */
+declare function defineTableCommands(): Extension<    {
+COMMAND_ARGS: {
+insertTable: [{
+row: number;
+col: number;
+header: boolean;
+}];
+exitTable: [];
+};
+}>;
+export { defineTableCommands }
+export { defineTableCommands as defineTableCommands_alias_1 }
+
+declare function defineTableHeaderCellSpec(): Extension<    {
+NODES: "tableHeaderCell";
+}>;
+export { defineTableHeaderCellSpec }
+export { defineTableHeaderCellSpec as defineTableHeaderCellSpec_alias_1 }
+
+/**
+ * @public
+ */
+declare function defineTablePlugins(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineTablePlugins }
+export { defineTablePlugins as defineTablePlugins_alias_1 }
+
+declare function defineTableRowSpec(): Extension<    {
+NODES: "tableRow";
+}>;
+export { defineTableRowSpec }
+export { defineTableRowSpec as defineTableRowSpec_alias_1 }
+
+declare function defineTableSpec(): Extension<    {
+NODES: "table";
+}>;
+export { defineTableSpec }
+export { defineTableSpec as defineTableSpec_alias_1 }
+
+/**
+ * Defines an enter rule that replaces the matched text with a block node.
+ *
+ * See also {@link defineEnterRule}.
+ *
+ * @public
+ */
+export declare function defineTextBlockEnterRule({ regex, type, attrs, stop, }: TextBlockEnterRuleOptions): Extension;
+
+/**
+ * Defines an input rule that changes the type of a textblock when the matched
+ * text is typed into it.
+ *
+ * See also [textblockTypeInputRule](https://prosemirror.net/docs/ref/#inputrules.textblockTypeInputRule)
+ *
+ * @public
+ */
+export declare function defineTextBlockInputRule({ regex, type, attrs, }: {
+    /**
+     * The regular expression to match against. You'll usually want to start it
+     * with `^` to that it is only matched at the start of a textblock.
+     */
+    regex: RegExp;
+    /**
+     * The node type to replace the matched text with.
+     */
+    type: string | NodeType;
+    /**
+     * Attributes to set on the node.
+     */
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+}): Extension;
 
 /**
  * @public
@@ -351,18 +654,177 @@ export declare function defineUnderlineSpec(): Extension<    {
 MARKS: "underline";
 }>;
 
+/**
+ * Shows a virtual selection when the editor is not focused. When the editor is
+ * not focused, the selected inline content will be wrapped in a `<span>`
+ * element with the class `prosekit-virtual-selection`.
+ *
+ * This is useful when you want to move the focus to an element outside the
+ * editor, but still want to show the selection.
+ *
+ * @public
+ */
+export declare function defineVirtualSelection(): Extension;
+
+/**
+ * Defines an input rule for automatically wrapping a textblock when a given
+ * string is typed.
+ *
+ * See also [wrappingInputRule](https://prosemirror.net/docs/ref/#inputrules.wrappingInputRule)
+ *
+ * @public
+ */
+export declare function defineWrappingInputRule({ regex, type, attrs, join, }: {
+    /**
+     * The regular expression to match against. You'll usually want to start it
+     * with `^` to that it is only matched at the start of a textblock.
+     */
+    regex: RegExp;
+    /**
+     * The type of node to wrap in.
+     */
+    type: string | NodeType;
+    /**
+     * Attributes to set on the node.
+     */
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+    /**
+     * By default, if there's a node with the same type above the newly wrapped
+     * node, the rule will try to
+     * [join](https://prosemirror.net/docs/ref/#transform.Transform.join) those
+     * two nodes. You can pass a join predicate, which takes a regular expression
+     * match and the node before the wrapped node, and can return a boolean to
+     * indicate whether a join should happen.
+     */
+    join?: (match: RegExpMatchArray, node: ProseMirrorNode) => boolean;
+}): Extension;
+
+export declare interface DropCursorOptions {
+    /**
+     * The color of the cursor.  Use `false` to apply no color and rely only on class.
+     *
+     * @default 'black'
+     */
+    color?: string | false;
+    /**
+     * The precise width of the cursor in pixels.
+     *
+     * @default 1
+     */
+    width?: number;
+    /**
+     * A CSS class name to add to the cursor element.
+     */
+    class?: string;
+}
+
+/**
+ * @public
+ */
+export declare type EnterRuleHandler = (options: {
+    /**
+     * The current editor state.
+     */
+    state: EditorState;
+    /**
+     * The start position of the matched text.
+     */
+    from: number;
+    /**
+     * The end position of the matched text.
+     */
+    to: number;
+    /**
+     * The matched result from the regular expression.
+     */
+    match: RegExpExecArray;
+}) => Transaction | null;
+
+/**
+ * Options for {@link defineEnterRule}.
+ *
+ * @public
+ */
+export declare type EnterRuleOptions = {
+    /**
+     * The regular expression to match against. It should end with `$`.
+     */
+    regex: RegExp;
+    /**
+     * A function to be called when an enter rule is triggered.
+     */
+    handler: EnterRuleHandler;
+    /**
+     * Whether to stop further handlers from being called if this rule is triggered.
+     *
+     * @default false
+     */
+    stop?: boolean;
+};
+
+/**
+ * When the selection is in a table node, create a default block after the table
+ * table, and move the cursor there.
+ *
+ * @public
+ */
+export declare const exitTable: Command;
+
+/**
+ * @internal
+ */
+export declare function findChangedTextRanges(selection: Selection_2): Array<[from: number, to: number]>;
+
+/** @internal */
+export declare function getAffectedRange(transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): readonly [number, number];
+
+export { getHighlighter }
+
 export declare function getPluginState(state: EditorState): PredictionPluginState | undefined;
 
+export declare function getSpanTextRanges($from: ResolvedPos, $to: ResolvedPos): [number, number][];
+
 export declare function getTrMeta(tr: Transaction): PredictionPluginState;
 
 export declare interface HeadingAttrs {
     level: number;
 }
 
+declare type HighlighterOptions = {
+    themes: BundledTheme[];
+    langs: (BundledLanguage | SpecialLanguage)[];
+    langAlias?: Record<string, BundledLanguage>;
+};
+
+/**
+ * @public
+ *
+ * An alias for the `Parser` type from the `prosemirror-highlight` package.
+ */
+declare type HighlightParser = Parser;
+export { HighlightParser }
+export { HighlightParser as HighlightParser_alias_1 }
+
 export declare interface ImageAttrs {
     src?: string | null;
 }
 
+/**
+ * Insert a table node with the given number of rows and columns, and optionally
+ * a header row.
+ *
+ * @public
+ */
+export declare function insertTable({ row, col, header, }: {
+    row: number;
+    col: number;
+    header: boolean;
+}): Command;
+
+export declare const LINK_RE: RegExp;
+
+export declare const LINK_SPACE_RE: RegExp;
+
 /**
  * @public
  */
@@ -370,6 +832,25 @@ export declare interface LinkAttrs {
     href: string;
 }
 
+export { ListDOMSerializer }
+
+export declare interface MarkRuleOptions {
+    /**
+     * The regular expression to match against. It should have a `g` flag to match
+     * all instances of the mark.
+     */
+    regex: RegExp;
+    /**
+     * The mark type to apply to the matched text.
+     */
+    type: string | MarkType;
+    /**
+     * Attributes to set on the mark. If a function is provided, it will be called
+     * with the matched result from the regular expression.
+     */
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+}
+
 declare type MatchHandler = (options: {
     state: EditorState;
     match: RegExpExecArray;
@@ -377,30 +858,16 @@ declare type MatchHandler = (options: {
     to: number;
     ignoreMatch: () => void;
     deleteMatch: () => void;
-}) => Transaction | null | void;
+}) => void;
 export { MatchHandler }
 export { MatchHandler as MatchHandler_alias_1 }
 
-/**
- * @returns Return a Transaction object if you want to append a transaction to current state (using )
- */
-declare type MatchHandler_2 = (options: {
-    rule: PredictionRule;
-    match: RegExpMatchArray;
-    matchAfter: RegExpMatchArray | null;
-    state: EditorState;
-    dismiss: VoidFunction;
-    deleteMatch: VoidFunction;
-}) => void;
-
 export declare interface MentionAttrs {
     id: string;
     kind: string;
     value: string;
 }
 
-export declare const OBJECT_REPLACEMENT = "\uFFFC";
-
 export declare interface PlaceholderOptions {
     /**
      * The placeholder text to use.
@@ -408,8 +875,8 @@ export declare interface PlaceholderOptions {
     placeholder: string;
     /**
      * By default, the placeholder text will be shown whenever the current text
-     * cursor is in an empty node. If you only want to show the placeholder when
-     * the whole doc is empty, you can set this option to 'doc'.
+     * cursor is in an empty text node. If you only want to show the placeholder
+     * when the whole doc is empty, you can set this option to 'doc'.
      *
      * @default 'block'
      */
@@ -429,31 +896,33 @@ export declare interface PredictionPluginState {
     } | null;
 }
 
-declare interface PredictionRule {
-    match: RegExp;
-    matchAfter?: RegExp;
-}
-export { PredictionRule }
-export { PredictionRule as PredictionRule_alias_1 }
-
 export declare function setTrMeta(tr: Transaction, meta: PredictionPluginState): Transaction;
 
-declare interface SuggestionOptions {
-    rules: PredictionRule[];
-    onMatch: MatchHandler_2;
-    onDeactivate: VoidFunction;
+/**
+ * Options for {@link defineTextBlockEnterRule}.
+ *
+ * @public
+ */
+export declare type TextBlockEnterRuleOptions = {
     /**
-     * You can pass this function if you want to skip the matching in some cases.
-     * By default, the plugin will only run the matching if the current selection
-     * is empty, and the selection is not inside a
-     * [code](https://prosemirror.net/docs/ref/#model.NodeSpec.code) node nor
-     * inside a mark with the name as `code`.
+     * The regular expression to match against. It should end with `$`.
      */
-    isValid?: (options: {
-        state: EditorState;
-    }) => boolean;
-}
-export { SuggestionOptions }
-export { SuggestionOptions as SuggestionOptions_alias_1 }
+    regex: RegExp;
+    /**
+     * The node type to replace the matched text with.
+     */
+    type: string | NodeType;
+    /**
+     * Attributes to set on the node. If a function is provided, it will be called
+     * with the matched result from the regular expression.
+     */
+    attrs?: Attrs | null | ((match: RegExpMatchArray) => Attrs | null);
+    /**
+     * Whether to stop further handlers from being called if this rule is triggered.
+     *
+     * @default true
+     */
+    stop?: boolean;
+};
 
 export { }