@tiptap/core 3.6.7 → 3.7.1

package/dist/index.d.cts

@@ -737,6 +737,38 @@ interface ExtendableConfig<Options = any, Storage = any, Config extends Extensio
         storage: Storage;
         parent: ParentConfig<Config>['addExtensions'];
     }) => Extensions;
+    /**
+     * The markdown token name
+     *
+     * This is the name of the token that this extension uses to parse and render markdown and comes from the Marked Lexer.
+     *
+     * @see https://github.com/markedjs/marked/blob/master/src/Tokens.ts
+     *
+     */
+    markdownTokenName?: string;
+    /**
+     * The parse function used by the markdown parser to convert markdown tokens to ProseMirror nodes.
+     */
+    parseMarkdown?: (token: MarkdownToken, helpers: MarkdownParseHelpers) => MarkdownParseResult;
+    /**
+     * The serializer function used by the markdown serializer to convert ProseMirror nodes to markdown tokens.
+     */
+    renderMarkdown?: (node: JSONContent, helpers: MarkdownRendererHelpers, ctx: RenderContext) => string;
+    /**
+     * The markdown tokenizer responsible for turning a markdown string into tokens
+     *
+     * Custom tokenizers are only needed when you want to parse non-standard markdown token.
+     */
+    markdownTokenizer?: MarkdownTokenizer;
+    /**
+     * Optional markdown options for indentation
+     */
+    markdownOptions?: {
+        /**
+         * Defines if this markdown element should indent it's child elements
+         */
+        indentsContent?: boolean;
+    };
     /**
      * This function extends the schema of the node.
      * @example
@@ -1529,6 +1561,144 @@ type ExtendedRegExpMatchArray = RegExpMatchArray & {
     data?: Record<string, any>;
 };
 type Dispatch = ((args?: any) => any) | undefined;
+/** Markdown related types */
+type MarkdownToken = {
+    type?: string;
+    raw?: string;
+    text?: string;
+    tokens?: MarkdownToken[];
+    depth?: number;
+    items?: MarkdownToken[];
+    [key: string]: any;
+};
+type MarkdownHelpers = {
+    parseInline: (tokens: MarkdownToken[]) => any[];
+    /**
+     * Render children. The second argument may be a legacy separator string
+     * or a RenderContext (preferred).
+     */
+    renderChildren: (node: Node[] | Node, ctxOrSeparator?: RenderContext | string) => string;
+    text: (token: MarkdownToken) => any;
+};
+/**
+ * Helpers specifically for parsing markdown tokens into Tiptap JSON.
+ * These are provided to extension parse handlers.
+ */
+type MarkdownParseHelpers = {
+    /** Parse an array of inline tokens into text nodes with marks */
+    parseInline: (tokens: MarkdownToken[]) => JSONContent[];
+    /** Parse an array of block-level tokens */
+    parseChildren: (tokens: MarkdownToken[]) => JSONContent[];
+    /** Create a text node with optional marks */
+    createTextNode: (text: string, marks?: Array<{
+        type: string;
+        attrs?: any;
+    }>) => JSONContent;
+    /** Create any node type with attributes and content */
+    createNode: (type: string, attrs?: any, content?: JSONContent[]) => JSONContent;
+    /** Apply a mark to content (used for inline marks like bold, italic) */
+    applyMark: (markType: string, content: JSONContent[], attrs?: any) => {
+        mark: string;
+        content: JSONContent[];
+        attrs?: any;
+    };
+};
+/**
+ * Full runtime helpers object provided by MarkdownManager to handlers.
+ * This includes the small author-facing helpers plus internal helpers
+ * that can be useful for advanced handlers.
+ */
+type FullMarkdownHelpers = MarkdownHelpers & {
+    parseChildren: (tokens: MarkdownToken[]) => any[];
+    getExtension: (name: string) => any;
+    createNode: (type: string, attrs?: any, content?: any[]) => any;
+    /** Current render context when calling renderers; undefined during parse. */
+    currentContext?: RenderContext;
+    /** Indent a multi-line string according to the provided RenderContext. */
+    indent: (text: string, ctx?: RenderContext) => string;
+    /** Return the indent string for a given level (e.g. '  ' or '\t'). */
+    getIndentString: (level?: number) => string;
+};
+
+/**
+ * Return shape for parser-level `parse` handlers.
+ * - a single JSON-like node
+ * - an array of JSON-like nodes
+ * - or a `{ mark: string, content: JSONLike[] }` shape to apply a mark
+ */
+type MarkdownParseResult = JSONContent | JSONContent[] | {
+    mark: string;
+    content: JSONContent[];
+    attrs?: any;
+};
+type RenderContext = {
+    index: number;
+    level: number;
+    meta?: Record<string, any>;
+    parentType?: string | null;
+};
+/** Extension contract for markdown parsing/serialization. */
+interface MarkdownExtensionSpec {
+    /** Token name used for parsing (e.g., 'codespan', 'code', 'strong') */
+    tokenName?: string;
+    /** Node/mark name used for rendering (typically the extension name) */
+    nodeName?: string;
+    parseMarkdown?: (token: MarkdownToken, helpers: MarkdownParseHelpers) => MarkdownParseResult;
+    renderMarkdown?: (node: any, helpers: MarkdownRendererHelpers, ctx: RenderContext) => string;
+    isIndenting?: boolean;
+    /** Custom tokenizer for marked.js to handle non-standard markdown syntax */
+    tokenizer?: MarkdownTokenizer;
+}
+/**
+ * Configuration object passed to custom marked.js tokenizers
+ */
+type MarkdownLexerConfiguration = {
+    /**
+     * Can be used to transform source text into inline tokens - useful while tokenizing child tokens.
+     * @param src
+     * @returns Array of inline tokens
+     */
+    inlineTokens: (src: string) => MarkdownToken[];
+    /**
+     * Can be used to transform source text into block-level tokens - useful while tokenizing child tokens.
+     * @param src
+     * @returns Array of block-level tokens
+     */
+    blockTokens: (src: string) => MarkdownToken[];
+};
+/** Custom tokenizer function for marked.js extensions */
+type MarkdownTokenizer = {
+    /** Token name this tokenizer creates */
+    name: string;
+    /** Priority level for tokenizer ordering (higher = earlier) */
+    level?: 'block' | 'inline';
+    /** A string to look for or a function that returns the start index of the token in the source string */
+    start?: string | ((src: string) => number);
+    /** Function that attempts to parse custom syntax from start of text */
+    tokenize: (src: string, tokens: MarkdownToken[], lexer: MarkdownLexerConfiguration) => MarkdownToken | undefined | void;
+};
+type MarkdownRendererHelpers = {
+    /**
+     * Render children nodes to a markdown string, optionally separated by a string.
+     * @param nodes The node or array of nodes to render
+     * @param separator An optional separator string (legacy) or RenderContext
+     * @returns The rendered markdown string
+     */
+    renderChildren: (nodes: JSONContent | JSONContent[], separator?: string) => string;
+    /**
+     * Render a text token to a markdown string
+     * @param prefix The prefix to add before the content
+     * @param content The content to wrap
+     * @returns The wrapped content
+     */
+    wrapInBlock: (prefix: string, content: string) => string;
+    /**
+     * Indent a markdown string according to the provided RenderContext
+     * @param content The content to indent
+     * @returns The indented content
+     */
+    indent: (content: string) => string;
+};
 
 /**
  * Create a new Prosemirror document node from content.
@@ -1934,7 +2104,14 @@ declare function splitExtensions(extensions: Extensions): {
 declare class ExtensionManager {
     editor: Editor;
     schema: Schema;
+    /**
+     * A flattened and sorted array of all extensions
+     */
     extensions: Extensions;
+    /**
+     * A non-flattened array of base extensions (no sub-extensions)
+     */
+    baseExtensions: Extensions;
     splittableMarks: string[];
     constructor(extensions: Extensions, editor: Editor);
     static resolve: typeof resolveExtensions;
@@ -2026,6 +2203,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const blur: RawCommands['blur'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2043,6 +2221,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const clearContent: RawCommands['clearContent'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2055,6 +2234,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const clearNodes: RawCommands['clearNodes'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2072,6 +2252,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const command: RawCommands['command'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2084,6 +2265,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const createParagraphNear: RawCommands['createParagraphNear'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2103,6 +2285,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const cut: RawCommands['cut'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2115,6 +2298,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const deleteCurrentNode: RawCommands['deleteCurrentNode'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2128,6 +2312,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const deleteNode: RawCommands['deleteNode'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2141,6 +2326,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const deleteRange: RawCommands['deleteRange'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2153,6 +2339,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const deleteSelection: RawCommands['deleteSelection'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2165,6 +2352,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const enter: RawCommands['enter'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2177,6 +2365,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const exitCode: RawCommands['exitCode'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2200,6 +2389,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const extendMarkRange: RawCommands['extendMarkRange'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2213,6 +2403,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const first: RawCommands['first'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2239,6 +2430,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const focus: RawCommands['focus'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2252,7 +2444,20 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const forEach: RawCommands['forEach'];
 
+interface InsertContentOptions {
+    /**
+     * Options for parsing the content.
+     */
+    parseOptions?: ParseOptions;
+    /**
+     * Whether to update the selection after inserting the content.
+     */
+    updateSelection?: boolean;
+    applyInputRules?: boolean;
+    applyPasteRules?: boolean;
+}
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
         insertContent: {
@@ -2269,22 +2474,34 @@ declare module '@tiptap/core' {
             /**
              * Optional options
              */
-            options?: {
-                /**
-                 * Options for parsing the content.
-                 */
-                parseOptions?: ParseOptions;
-                /**
-                 * Whether to update the selection after inserting the content.
-                 */
-                updateSelection?: boolean;
-                applyInputRules?: boolean;
-                applyPasteRules?: boolean;
-            }) => ReturnType;
+            options?: InsertContentOptions) => ReturnType;
         };
     }
 }
+declare const insertContent: RawCommands['insertContent'];
 
+interface InsertContentAtOptions {
+    /**
+     * Options for parsing the content.
+     */
+    parseOptions?: ParseOptions;
+    /**
+     * Whether to update the selection after inserting the content.
+     */
+    updateSelection?: boolean;
+    /**
+     * Whether to apply input rules after inserting the content.
+     */
+    applyInputRules?: boolean;
+    /**
+     * Whether to apply paste rules after inserting the content.
+     */
+    applyPasteRules?: boolean;
+    /**
+     * Whether to throw an error if the content is invalid.
+     */
+    errorOnInvalidContent?: boolean;
+}
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
         insertContentAt: {
@@ -2304,31 +2521,11 @@ declare module '@tiptap/core' {
             /**
              * Optional options
              */
-            options?: {
-                /**
-                 * Options for parsing the content.
-                 */
-                parseOptions?: ParseOptions;
-                /**
-                 * Whether to update the selection after inserting the content.
-                 */
-                updateSelection?: boolean;
-                /**
-                 * Whether to apply input rules after inserting the content.
-                 */
-                applyInputRules?: boolean;
-                /**
-                 * Whether to apply paste rules after inserting the content.
-                 */
-                applyPasteRules?: boolean;
-                /**
-                 * Whether to throw an error if the content is invalid.
-                 */
-                errorOnInvalidContent?: boolean;
-            }) => ReturnType;
+            options?: InsertContentAtOptions) => ReturnType;
         };
     }
 }
+declare const insertContentAt: RawCommands['insertContentAt'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2366,6 +2563,10 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const joinUp: RawCommands['joinUp'];
+declare const joinDown: RawCommands['joinDown'];
+declare const joinBackward: RawCommands['joinBackward'];
+declare const joinForward: RawCommands['joinForward'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2378,6 +2579,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const joinItemBackward: RawCommands['joinItemBackward'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2390,6 +2592,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const joinItemForward: RawCommands['joinItemForward'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2401,6 +2604,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const joinTextblockBackward: RawCommands['joinTextblockBackward'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2412,6 +2616,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const joinTextblockForward: RawCommands['joinTextblockForward'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2425,6 +2630,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const keyboardShortcut: RawCommands['keyboardShortcut'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2440,6 +2646,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const lift: RawCommands['lift'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2452,6 +2659,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const liftEmptyBlock: RawCommands['liftEmptyBlock'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2465,6 +2673,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const liftListItem: RawCommands['liftListItem'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2477,6 +2686,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const newlineInCode: RawCommands['newlineInCode'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2491,6 +2701,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const resetAttributes: RawCommands['resetAttributes'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2503,6 +2714,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const scrollIntoView: RawCommands['scrollIntoView'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2515,6 +2727,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const selectAll: RawCommands['selectAll'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2527,6 +2740,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const selectNodeBackward: RawCommands['selectNodeBackward'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2539,6 +2753,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const selectNodeForward: RawCommands['selectNodeForward'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2551,6 +2766,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const selectParentNode: RawCommands['selectParentNode'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2563,6 +2779,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const selectTextblockEnd: RawCommands['selectTextblockEnd'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2575,7 +2792,24 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const selectTextblockStart: RawCommands['selectTextblockStart'];
 
+interface SetContentOptions {
+    /**
+     * Options for parsing the content.
+     * @default {}
+     */
+    parseOptions?: ParseOptions;
+    /**
+     * Whether to throw an error if the content is invalid.
+     */
+    errorOnInvalidContent?: boolean;
+    /**
+     * Whether to emit an update event.
+     * @default true
+     */
+    emitUpdate?: boolean;
+}
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
         setContent: {
@@ -2594,25 +2828,11 @@ declare module '@tiptap/core' {
             /**
              * Options for `setContent`.
              */
-            options?: {
-                /**
-                 * Options for parsing the content.
-                 * @default {}
-                 */
-                parseOptions?: ParseOptions;
-                /**
-                 * Whether to throw an error if the content is invalid.
-                 */
-                errorOnInvalidContent?: boolean;
-                /**
-                 * Whether to emit an update event.
-                 * @default true
-                 */
-                emitUpdate?: boolean;
-            }) => ReturnType;
+            options?: SetContentOptions) => ReturnType;
         };
     }
 }
+declare const setContent: RawCommands['setContent'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2626,6 +2846,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const setMark: RawCommands['setMark'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2640,6 +2861,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const setMeta: RawCommands['setMeta'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2654,6 +2876,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const setNode: RawCommands['setNode'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2667,6 +2890,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const setNodeSelection: RawCommands['setNodeSelection'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2680,6 +2904,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const setTextSelection: RawCommands['setTextSelection'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2693,6 +2918,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const sinkListItem: RawCommands['sinkListItem'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2709,6 +2935,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const splitBlock: RawCommands['splitBlock'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2723,6 +2950,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const splitListItem: RawCommands['splitListItem'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2739,6 +2967,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const toggleList: RawCommands['toggleList'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2767,6 +2996,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const toggleMark: RawCommands['toggleMark'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2782,6 +3012,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const toggleNode: RawCommands['toggleNode'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2796,6 +3027,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const toggleWrap: RawCommands['toggleWrap'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2808,6 +3040,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const undoInputRule: RawCommands['undoInputRule'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2820,6 +3053,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const unsetAllMarks: RawCommands['unsetAllMarks'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2843,6 +3077,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const unsetMark: RawCommands['unsetMark'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2865,6 +3100,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const updateAttributes: RawCommands['updateAttributes'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2879,6 +3115,7 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const wrapIn: RawCommands['wrapIn'];
 
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
@@ -2893,6 +3130,72 @@ declare module '@tiptap/core' {
         };
     }
 }
+declare const wrapInList: RawCommands['wrapInList'];
+
+type index$2_InsertContentAtOptions = InsertContentAtOptions;
+type index$2_InsertContentOptions = InsertContentOptions;
+type index$2_SetContentOptions = SetContentOptions;
+declare const index$2_blur: typeof blur;
+declare const index$2_clearContent: typeof clearContent;
+declare const index$2_clearNodes: typeof clearNodes;
+declare const index$2_command: typeof command;
+declare const index$2_createParagraphNear: typeof createParagraphNear;
+declare const index$2_cut: typeof cut;
+declare const index$2_deleteCurrentNode: typeof deleteCurrentNode;
+declare const index$2_deleteNode: typeof deleteNode;
+declare const index$2_deleteRange: typeof deleteRange;
+declare const index$2_deleteSelection: typeof deleteSelection;
+declare const index$2_enter: typeof enter;
+declare const index$2_exitCode: typeof exitCode;
+declare const index$2_extendMarkRange: typeof extendMarkRange;
+declare const index$2_first: typeof first;
+declare const index$2_focus: typeof focus;
+declare const index$2_forEach: typeof forEach;
+declare const index$2_insertContent: typeof insertContent;
+declare const index$2_insertContentAt: typeof insertContentAt;
+declare const index$2_joinBackward: typeof joinBackward;
+declare const index$2_joinDown: typeof joinDown;
+declare const index$2_joinForward: typeof joinForward;
+declare const index$2_joinItemBackward: typeof joinItemBackward;
+declare const index$2_joinItemForward: typeof joinItemForward;
+declare const index$2_joinTextblockBackward: typeof joinTextblockBackward;
+declare const index$2_joinTextblockForward: typeof joinTextblockForward;
+declare const index$2_joinUp: typeof joinUp;
+declare const index$2_keyboardShortcut: typeof keyboardShortcut;
+declare const index$2_lift: typeof lift;
+declare const index$2_liftEmptyBlock: typeof liftEmptyBlock;
+declare const index$2_liftListItem: typeof liftListItem;
+declare const index$2_newlineInCode: typeof newlineInCode;
+declare const index$2_resetAttributes: typeof resetAttributes;
+declare const index$2_scrollIntoView: typeof scrollIntoView;
+declare const index$2_selectAll: typeof selectAll;
+declare const index$2_selectNodeBackward: typeof selectNodeBackward;
+declare const index$2_selectNodeForward: typeof selectNodeForward;
+declare const index$2_selectParentNode: typeof selectParentNode;
+declare const index$2_selectTextblockEnd: typeof selectTextblockEnd;
+declare const index$2_selectTextblockStart: typeof selectTextblockStart;
+declare const index$2_setContent: typeof setContent;
+declare const index$2_setMark: typeof setMark;
+declare const index$2_setMeta: typeof setMeta;
+declare const index$2_setNode: typeof setNode;
+declare const index$2_setNodeSelection: typeof setNodeSelection;
+declare const index$2_setTextSelection: typeof setTextSelection;
+declare const index$2_sinkListItem: typeof sinkListItem;
+declare const index$2_splitBlock: typeof splitBlock;
+declare const index$2_splitListItem: typeof splitListItem;
+declare const index$2_toggleList: typeof toggleList;
+declare const index$2_toggleMark: typeof toggleMark;
+declare const index$2_toggleNode: typeof toggleNode;
+declare const index$2_toggleWrap: typeof toggleWrap;
+declare const index$2_undoInputRule: typeof undoInputRule;
+declare const index$2_unsetAllMarks: typeof unsetAllMarks;
+declare const index$2_unsetMark: typeof unsetMark;
+declare const index$2_updateAttributes: typeof updateAttributes;
+declare const index$2_wrapIn: typeof wrapIn;
+declare const index$2_wrapInList: typeof wrapInList;
+declare namespace index$2 {
+  export { type index$2_InsertContentAtOptions as InsertContentAtOptions, type index$2_InsertContentOptions as InsertContentOptions, type index$2_SetContentOptions as SetContentOptions, index$2_blur as blur, index$2_clearContent as clearContent, index$2_clearNodes as clearNodes, index$2_command as command, index$2_createParagraphNear as createParagraphNear, index$2_cut as cut, index$2_deleteCurrentNode as deleteCurrentNode, index$2_deleteNode as deleteNode, index$2_deleteRange as deleteRange, index$2_deleteSelection as deleteSelection, index$2_enter as enter, index$2_exitCode as exitCode, index$2_extendMarkRange as extendMarkRange, index$2_first as first, index$2_focus as focus, index$2_forEach as forEach, index$2_insertContent as insertContent, index$2_insertContentAt as insertContentAt, index$2_joinBackward as joinBackward, index$2_joinDown as joinDown, index$2_joinForward as joinForward, index$2_joinItemBackward as joinItemBackward, index$2_joinItemForward as joinItemForward, index$2_joinTextblockBackward as joinTextblockBackward, index$2_joinTextblockForward as joinTextblockForward, index$2_joinUp as joinUp, index$2_keyboardShortcut as keyboardShortcut, index$2_lift as lift, index$2_liftEmptyBlock as liftEmptyBlock, index$2_liftListItem as liftListItem, index$2_newlineInCode as newlineInCode, index$2_resetAttributes as resetAttributes, index$2_scrollIntoView as scrollIntoView, index$2_selectAll as selectAll, index$2_selectNodeBackward as selectNodeBackward, index$2_selectNodeForward as selectNodeForward, index$2_selectParentNode as selectParentNode, index$2_selectTextblockEnd as selectTextblockEnd, index$2_selectTextblockStart as selectTextblockStart, index$2_setContent as setContent, index$2_setMark as setMark, index$2_setMeta as setMeta, index$2_setNode as setNode, index$2_setNodeSelection as setNodeSelection, index$2_setTextSelection as setTextSelection, index$2_sinkListItem as sinkListItem, index$2_splitBlock as splitBlock, index$2_splitListItem as splitListItem, index$2_toggleList as toggleList, index$2_toggleMark as toggleMark, index$2_toggleNode as toggleNode, index$2_toggleWrap as toggleWrap, index$2_undoInputRule as undoInputRule, index$2_unsetAllMarks as unsetAllMarks, index$2_unsetMark as unsetMark, index$2_updateAttributes as updateAttributes, index$2_wrapIn as wrapIn, index$2_wrapInList as wrapInList };
+}
 
 declare const Commands$1: Extension<any, any>;
 
@@ -2914,17 +3217,17 @@ declare const Paste: Extension<any, any>;
 
 declare const Tabindex: Extension<any, any>;
 
-declare const index_ClipboardTextSerializer: typeof ClipboardTextSerializer;
-declare const index_Delete: typeof Delete;
-declare const index_Drop: typeof Drop;
-declare const index_Editable: typeof Editable;
-declare const index_FocusEvents: typeof FocusEvents;
-declare const index_Keymap: typeof Keymap;
-declare const index_Paste: typeof Paste;
-declare const index_Tabindex: typeof Tabindex;
-declare const index_focusEventsPluginKey: typeof focusEventsPluginKey;
-declare namespace index {
-  export { index_ClipboardTextSerializer as ClipboardTextSerializer, Commands$1 as Commands, index_Delete as Delete, index_Drop as Drop, index_Editable as Editable, index_FocusEvents as FocusEvents, index_Keymap as Keymap, index_Paste as Paste, index_Tabindex as Tabindex, index_focusEventsPluginKey as focusEventsPluginKey };
+declare const index$1_ClipboardTextSerializer: typeof ClipboardTextSerializer;
+declare const index$1_Delete: typeof Delete;
+declare const index$1_Drop: typeof Drop;
+declare const index$1_Editable: typeof Editable;
+declare const index$1_FocusEvents: typeof FocusEvents;
+declare const index$1_Keymap: typeof Keymap;
+declare const index$1_Paste: typeof Paste;
+declare const index$1_Tabindex: typeof Tabindex;
+declare const index$1_focusEventsPluginKey: typeof focusEventsPluginKey;
+declare namespace index$1 {
+  export { index$1_ClipboardTextSerializer as ClipboardTextSerializer, Commands$1 as Commands, index$1_Delete as Delete, index$1_Drop as Drop, index$1_Editable as Editable, index$1_FocusEvents as FocusEvents, index$1_Keymap as Keymap, index$1_Paste as Paste, index$1_Tabindex as Tabindex, index$1_focusEventsPluginKey as focusEventsPluginKey };
 }
 
 interface TiptapEditorHTMLElement extends HTMLElement {
@@ -3290,7 +3593,7 @@ declare function markPasteRule(config: {
 /**
  * Build an paste rule that adds a node when the
  * matched text is pasted into it.
- * @see https://tiptap.dev/docs/editor/extensions/custom-extensions/extend-existing#paste-rules
+ * @see https://tiptap.dev/docs/editor/api/paste-rules
  */
 declare function nodePasteRule(config: {
     find: PasteRuleFinder;
@@ -3369,6 +3672,376 @@ declare function isRegExp(value: any): value is RegExp;
 
 declare function isString(value: any): value is string;
 
+/**
+ * @fileoverview Utility functions for parsing and serializing markdown attributes.
+ *
+ * These utilities handle the common patterns for parsing attribute strings
+ * in various markdown syntaxes like Pandoc attributes.
+ */
+/**
+ * Parses a Pandoc-style attribute string into an object.
+ *
+ * Supports the following patterns:
+ * - Classes: `.className` → `{ class: 'className' }`
+ * - IDs: `#myId` → `{ id: 'myId' }`
+ * - Key-value pairs: `key="value"` → `{ key: 'value' }`
+ * - Boolean attributes: `disabled` → `{ disabled: true }`
+ *
+ * @param attrString - The attribute string to parse
+ * @returns Parsed attributes object
+ *
+ * @example
+ * ```ts
+ * parseAttributes('.btn #submit disabled type="button"')
+ * // → { class: 'btn', id: 'submit', disabled: true, type: 'button' }
+ * ```
+ */
+declare function parseAttributes(attrString: string): Record<string, any>;
+/**
+ * Serializes an attributes object back to a Pandoc-style attribute string.
+ *
+ * @param attributes - The attributes object to serialize
+ * @returns Serialized attribute string
+ *
+ * @example
+ * ```ts
+ * serializeAttributes({ class: 'btn primary', id: 'submit', disabled: true, type: 'button' })
+ * // → '.btn.primary #submit disabled type="button"'
+ * ```
+ */
+declare function serializeAttributes(attributes: Record<string, any>): string;
+
+interface AtomBlockMarkdownSpecOptions {
+    /** The Tiptap node name this spec is for */
+    nodeName: string;
+    /** The markdown syntax name (defaults to nodeName if not provided) */
+    name?: string;
+    /** Function to parse attributes from token attribute string */
+    parseAttributes?: (attrString: string) => Record<string, any>;
+    /** Function to serialize attributes back to string for rendering */
+    serializeAttributes?: (attrs: Record<string, any>) => string;
+    /** Default attributes to apply when parsing */
+    defaultAttributes?: Record<string, any>;
+    /** Required attributes that must be present for successful parsing */
+    requiredAttributes?: string[];
+    /** Attributes that are allowed to be rendered back to markdown (whitelist) */
+    allowedAttributes?: string[];
+}
+/**
+ * Creates a complete markdown spec for atomic block nodes using Pandoc syntax.
+ *
+ * The generated spec handles:
+ * - Parsing self-closing blocks with `:::blockName {attributes}`
+ * - Extracting and parsing attributes
+ * - Validating required attributes
+ * - Rendering blocks back to markdown
+ *
+ * @param options - Configuration for the atomic block markdown spec
+ * @returns Complete markdown specification object
+ *
+ * @example
+ * ```ts
+ * const youtubeSpec = createAtomBlockMarkdownSpec({
+ *   nodeName: 'youtube',
+ *   requiredAttributes: ['src'],
+ *   defaultAttributes: { start: 0 },
+ *   allowedAttributes: ['src', 'start', 'width', 'height'] // Only these get rendered to markdown
+ * })
+ *
+ * // Usage in extension:
+ * export const Youtube = Node.create({
+ *   // ... other config
+ *   markdown: youtubeSpec
+ * })
+ * ```
+ */
+declare function createAtomBlockMarkdownSpec(options: AtomBlockMarkdownSpecOptions): {
+    parseMarkdown: (token: MarkdownToken, h: MarkdownParseHelpers) => MarkdownParseResult;
+    markdownTokenizer: MarkdownTokenizer;
+    renderMarkdown: (node: JSONContent) => string;
+};
+
+interface BlockMarkdownSpecOptions {
+    /** The Tiptap node name this spec is for */
+    nodeName: string;
+    /** The markdown syntax name (defaults to nodeName if not provided) */
+    name?: string;
+    /** Function to extract content from the node for serialization */
+    getContent?: (token: MarkdownToken) => string;
+    /** Function to parse attributes from the attribute string */
+    parseAttributes?: (attrString: string) => Record<string, any>;
+    /** Function to serialize attributes to string */
+    serializeAttributes?: (attrs: Record<string, any>) => string;
+    /** Default attributes to apply when parsing */
+    defaultAttributes?: Record<string, any>;
+    /** Content type: 'block' allows paragraphs/lists/etc, 'inline' only allows bold/italic/links/etc */
+    content?: 'block' | 'inline';
+    /** Allowlist of attributes to include in markdown (if not provided, all attributes are included) */
+    allowedAttributes?: string[];
+}
+/**
+ * Creates a complete markdown spec for block-level nodes using Pandoc syntax.
+ *
+ * The generated spec handles:
+ * - Parsing blocks with `:::blockName {attributes}` syntax
+ * - Extracting and parsing attributes
+ * - Rendering blocks back to markdown with proper formatting
+ * - Nested content support
+ *
+ * @param options - Configuration for the block markdown spec
+ * @returns Complete markdown specification object
+ *
+ * @example
+ * ```ts
+ * const calloutSpec = createBlockMarkdownSpec({
+ *   nodeName: 'callout',
+ *   defaultAttributes: { type: 'info' },
+ *   allowedAttributes: ['type', 'title'] // Only these get rendered to markdown
+ * })
+ *
+ * // Usage in extension:
+ * export const Callout = Node.create({
+ *   // ... other config
+ *   markdown: calloutSpec
+ * })
+ * ```
+ */
+declare function createBlockMarkdownSpec(options: BlockMarkdownSpecOptions): {
+    parseMarkdown: (token: MarkdownToken, h: MarkdownParseHelpers) => MarkdownParseResult;
+    markdownTokenizer: MarkdownTokenizer;
+    renderMarkdown: (node: JSONContent, h: MarkdownRendererHelpers) => string;
+};
+
+interface InlineMarkdownSpecOptions {
+    /** The Tiptap node name this spec is for */
+    nodeName: string;
+    /** The shortcode name (defaults to nodeName if not provided) */
+    name?: string;
+    /** Function to extract content from the node for serialization */
+    getContent?: (node: any) => string;
+    /** Function to parse attributes from the attribute string */
+    parseAttributes?: (attrString: string) => Record<string, any>;
+    /** Function to serialize attributes to string */
+    serializeAttributes?: (attrs: Record<string, any>) => string;
+    /** Default attributes to apply when parsing */
+    defaultAttributes?: Record<string, any>;
+    /** Whether this is a self-closing shortcode (no content, like [emoji name=party]) */
+    selfClosing?: boolean;
+    /** Allowlist of attributes to include in markdown (if not provided, all attributes are included) */
+    allowedAttributes?: string[];
+}
+/**
+ * Creates a complete markdown spec for inline nodes using attribute syntax.
+ *
+ * The generated spec handles:
+ * - Parsing shortcode syntax with `[nodeName attributes]content[/nodeName]` format
+ * - Self-closing shortcodes like `[emoji name=party_popper]`
+ * - Extracting and parsing attributes from the opening tag
+ * - Rendering inline elements back to shortcode markdown
+ * - Supporting both content-based and self-closing inline elements
+ *
+ * @param options - Configuration for the inline markdown spec
+ * @returns Complete markdown specification object
+ *
+ * @example
+ * ```ts
+ * // Self-closing mention: [mention id="madonna" label="Madonna"]
+ * const mentionSpec = createInlineMarkdownSpec({
+ *   nodeName: 'mention',
+ *   selfClosing: true,
+ *   defaultAttributes: { type: 'user' },
+ *   allowedAttributes: ['id', 'label'] // Only these get rendered to markdown
+ * })
+ *
+ * // Self-closing emoji: [emoji name="party_popper"]
+ * const emojiSpec = createInlineMarkdownSpec({
+ *   nodeName: 'emoji',
+ *   selfClosing: true,
+ *   allowedAttributes: ['name']
+ * })
+ *
+ * // With content: [highlight color="yellow"]text[/highlight]
+ * const highlightSpec = createInlineMarkdownSpec({
+ *   nodeName: 'highlight',
+ *   selfClosing: false,
+ *   allowedAttributes: ['color', 'style']
+ * })
+ *
+ * // Usage in extension:
+ * export const Mention = Node.create({
+ *   name: 'mention', // Must match nodeName
+ *   // ... other config
+ *   markdown: mentionSpec
+ * })
+ * ```
+ */
+declare function createInlineMarkdownSpec(options: InlineMarkdownSpecOptions): {
+    parseMarkdown: (token: MarkdownToken, h: MarkdownParseHelpers) => MarkdownParseResult;
+    markdownTokenizer: MarkdownTokenizer;
+    renderMarkdown: (node: JSONContent) => string;
+};
+
+/**
+ * @fileoverview Utility for parsing indented markdown blocks with hierarchical nesting.
+ *
+ * This utility handles the complex logic of parsing markdown blocks that can contain
+ * nested content based on indentation levels, maintaining proper hierarchical structure
+ * for lists, task lists, and other indented block types.
+ */
+interface ParsedBlock {
+    type: string;
+    raw: string;
+    mainContent: string;
+    indentLevel: number;
+    nestedContent?: string;
+    nestedTokens?: any[];
+    [key: string]: any;
+}
+interface BlockParserConfig {
+    /** Regex pattern to match block items */
+    itemPattern: RegExp;
+    /** Function to extract data from regex match */
+    extractItemData: (match: RegExpMatchArray) => {
+        mainContent: string;
+        indentLevel: number;
+        [key: string]: any;
+    };
+    /** Function to create the final token */
+    createToken: (data: any, nestedTokens?: any[]) => ParsedBlock;
+    /** Base indentation to remove from nested content (default: 2 spaces) */
+    baseIndentSize?: number;
+    /**
+     * Custom parser for nested content. If provided, this will be called instead
+     * of the default lexer.blockTokens() for parsing nested content.
+     * This allows recursive parsing of the same block type.
+     */
+    customNestedParser?: (dedentedContent: string) => any[] | undefined;
+}
+/**
+ * Parses markdown text into hierarchical indented blocks with proper nesting.
+ *
+ * This utility handles:
+ * - Line-by-line parsing with pattern matching
+ * - Hierarchical nesting based on indentation levels
+ * - Nested content collection and parsing
+ * - Empty line handling
+ * - Content dedenting for nested blocks
+ *
+ * The key difference from flat parsing is that this maintains the hierarchical
+ * structure where nested items become `nestedTokens` of their parent items,
+ * rather than being flattened into a single array.
+ *
+ * @param src - The markdown source text to parse
+ * @param config - Configuration object defining how to parse and create tokens
+ * @param lexer - Markdown lexer for parsing nested content
+ * @returns Parsed result with hierarchical items, or undefined if no matches
+ *
+ * @example
+ * ```ts
+ * const result = parseIndentedBlocks(src, {
+ *   itemPattern: /^(\s*)([-+*])\s+\[([ xX])\]\s+(.*)$/,
+ *   extractItemData: (match) => ({
+ *     indentLevel: match[1].length,
+ *     mainContent: match[4],
+ *     checked: match[3].toLowerCase() === 'x'
+ *   }),
+ *   createToken: (data, nestedTokens) => ({
+ *     type: 'taskItem',
+ *     checked: data.checked,
+ *     text: data.mainContent,
+ *     nestedTokens
+ *   })
+ * }, lexer)
+ * ```
+ */
+declare function parseIndentedBlocks(src: string, config: BlockParserConfig, lexer: {
+    inlineTokens: (src: string) => any[];
+    blockTokens: (src: string) => any[];
+}): {
+    items: ParsedBlock[];
+    raw: string;
+} | undefined;
+
+/**
+ * @fileoverview Utility functions for rendering nested content in markdown.
+ *
+ * This module provides reusable utilities for extensions that need to render
+ * content with a prefix on the main line and properly indented nested content.
+ */
+/**
+ * Utility function for rendering content with a main line prefix and nested indented content.
+ *
+ * This function handles the common pattern of rendering content with:
+ * 1. A main line with a prefix (like "- " for lists, "> " for blockquotes, etc.)
+ * 2. Nested content that gets indented properly
+ *
+ * @param node - The ProseMirror node representing the content
+ * @param h - The markdown renderer helper
+ * @param prefixOrGenerator - Either a string prefix or a function that generates the prefix from context
+ * @param ctx - Optional context object (used when prefixOrGenerator is a function)
+ * @returns The rendered markdown string
+ *
+ * @example
+ * ```ts
+ * // For a bullet list item with static prefix
+ * return renderNestedMarkdownContent(node, h, '- ')
+ *
+ * // For a task item with static prefix
+ * const prefix = `- [${node.attrs?.checked ? 'x' : ' '}] `
+ * return renderNestedMarkdownContent(node, h, prefix)
+ *
+ * // For a blockquote with static prefix
+ * return renderNestedMarkdownContent(node, h, '> ')
+ *
+ * // For content with dynamic prefix based on context
+ * return renderNestedMarkdownContent(node, h, ctx => {
+ *   if (ctx.parentType === 'orderedList') {
+ *     return `${ctx.index + 1}. `
+ *   }
+ *   return '- '
+ * }, ctx)
+ *
+ * // Custom extension example
+ * const CustomContainer = Node.create({
+ *   name: 'customContainer',
+ *   // ... other config
+ *   markdown: {
+ *     render: (node, h) => {
+ *       const type = node.attrs?.type || 'info'
+ *       return renderNestedMarkdownContent(node, h, `[${type}] `)
+ *     }
+ *   }
+ * })
+ * ```
+ */
+declare function renderNestedMarkdownContent(node: JSONContent, h: {
+    renderChildren: (nodes: JSONContent[]) => string;
+    indent: (text: string) => string;
+}, prefixOrGenerator: string | ((ctx: any) => string), ctx?: any): string;
+
+/**
+ * @fileoverview Markdown utilities for creating standardized markdown specs.
+ *
+ * This module provides utilities for creating complete markdown specifications
+ * for different types of nodes using unified syntax patterns.
+ */
+
+type index_AtomBlockMarkdownSpecOptions = AtomBlockMarkdownSpecOptions;
+type index_BlockMarkdownSpecOptions = BlockMarkdownSpecOptions;
+type index_BlockParserConfig = BlockParserConfig;
+type index_InlineMarkdownSpecOptions = InlineMarkdownSpecOptions;
+type index_ParsedBlock = ParsedBlock;
+declare const index_createAtomBlockMarkdownSpec: typeof createAtomBlockMarkdownSpec;
+declare const index_createBlockMarkdownSpec: typeof createBlockMarkdownSpec;
+declare const index_createInlineMarkdownSpec: typeof createInlineMarkdownSpec;
+declare const index_parseAttributes: typeof parseAttributes;
+declare const index_parseIndentedBlocks: typeof parseIndentedBlocks;
+declare const index_renderNestedMarkdownContent: typeof renderNestedMarkdownContent;
+declare const index_serializeAttributes: typeof serializeAttributes;
+declare namespace index {
+  export { type index_AtomBlockMarkdownSpecOptions as AtomBlockMarkdownSpecOptions, type index_BlockMarkdownSpecOptions as BlockMarkdownSpecOptions, type index_BlockParserConfig as BlockParserConfig, type index_InlineMarkdownSpecOptions as InlineMarkdownSpecOptions, type index_ParsedBlock as ParsedBlock, index_createAtomBlockMarkdownSpec as createAtomBlockMarkdownSpec, index_createBlockMarkdownSpec as createBlockMarkdownSpec, index_createInlineMarkdownSpec as createInlineMarkdownSpec, index_parseAttributes as parseAttributes, index_parseIndentedBlocks as parseIndentedBlocks, index_renderNestedMarkdownContent as renderNestedMarkdownContent, index_serializeAttributes as serializeAttributes };
+}
+
 declare function mergeAttributes(...objects: Record<string, any>[]): Record<string, any>;
 
 declare function mergeDeep(target: Record<string, any>, source: Record<string, any>): Record<string, any>;
@@ -3398,4 +4071,4 @@ interface Commands<ReturnType = any> {
 interface Storage {
 }
 
-export { type AnyCommands, type AnyConfig, type AnyExtension, type Attribute, type Attributes$1 as Attributes, type CanCommands, type ChainedCommands, type ChangedRange, type Command, CommandManager, type CommandProps, type CommandSpec, type Commands, type Content, type CreateNodeFromContentOptions, type DOMNode, type DOMOutputSpecArray$1 as DOMOutputSpecArray, type DecorationType, type DecorationWithType, type Diff, type Dispatch, type DocumentType, Editor, type EditorEvents, type EditorOptions, type EnableRules, type ExtendedRegExpMatchArray, Extension, type ExtensionAttribute, type ExtensionConfig, type Extensions, type FocusPosition, Fragment, type GlobalAttributes, type HTMLContent, InputRule, type InputRuleFinder, type InputRuleMatch, type JSONContent, type KeyboardShortcutCommand, type KeysWithTypeOf, Mark, type MarkConfig, type MarkRange, type MarkType, MarkView, type MarkViewProps, type MarkViewRenderer, type MarkViewRendererOptions, type MarkViewRendererProps, type MaybeReturnType, type MaybeThisParameterType, Node, type NodeConfig, NodePos, type NodeRange, type NodeType, NodeView, type NodeViewProps, type NodeViewRenderer, type NodeViewRendererOptions, type NodeViewRendererProps, type NodeWithPos, type Overwrite, type ParentConfig, PasteRule, type PasteRuleFinder, type PasteRuleMatch, type PickValue, type Predicate, type Primitive, type Range, type RawCommands, type RemoveThis, type SingleCommands, type Storage, type TextSerializer, type TextType, type TiptapEditorHTMLElement, Tracker, type TrackerResult, type UnionCommands, type UnionToIntersection, type ValuesOf, callOrReturn, canInsertNode, combineTransactionSteps, createChainableState, createDocument, h as createElement, createNodeFromContent, createStyleTag, defaultBlockAt, deleteProps, elementFromString, escapeForRegEx, index as extensions, findChildren, findChildrenInRange, findDuplicates, findParentNode, findParentNodeClosestToPos, flattenExtensions, fromString, generateHTML, generateJSON, generateText, getAttributes, getAttributesFromExtensions, getChangedRanges, getDebugJSON, getExtensionField, getHTMLFromFragment, getMarkAttributes, getMarkRange, getMarkType, getMarksBetween, getNodeAtPosition, getNodeAttributes, getNodeType, getRenderedAttributes, getSchema, getSchemaByResolvedExtensions, getSchemaTypeByName, getSchemaTypeNameByName, getSplittedAttributes, getText, getTextBetween, getTextContentFromNodes, getTextSerializersFromSchema, h, injectExtensionAttributesToParseRule, inputRulesPlugin, isActive, isAndroid, isAtEndOfNode, isAtStartOfNode, isEmptyObject, isExtensionRulesEnabled, isFunction, isList, isMacOS, isMarkActive, isNodeActive, isNodeEmpty, isNodeSelection, isNumber, isPlainObject, isRegExp, isString, isTextSelection, isiOS, markInputRule, markPasteRule, mergeAttributes, mergeDeep, minMax, nodeInputRule, nodePasteRule, objectIncludes, pasteRulesPlugin, posToDOMRect, removeDuplicates, resolveExtensions, resolveFocusPosition, rewriteUnknownContent, selectionToInsertionEnd, sortExtensions, splitExtensions, textInputRule, textPasteRule, textblockTypeInputRule, updateMarkViewAttributes, wrappingInputRule };
+export { type AnyCommands, type AnyConfig, type AnyExtension, type AtomBlockMarkdownSpecOptions, type Attribute, type Attributes$1 as Attributes, type BlockMarkdownSpecOptions, type BlockParserConfig, type CanCommands, type ChainedCommands, type ChangedRange, type Command, CommandManager, type CommandProps, type CommandSpec, type Commands, type Content, type CreateNodeFromContentOptions, type DOMNode, type DOMOutputSpecArray$1 as DOMOutputSpecArray, type DecorationType, type DecorationWithType, type Diff, type Dispatch, type DocumentType, Editor, type EditorEvents, type EditorOptions, type EnableRules, Extendable, type ExtendableConfig, type ExtendedRegExpMatchArray, Extension, type ExtensionAttribute, type ExtensionConfig, type Extensions, type FocusPosition, Fragment, type FullMarkdownHelpers, type GlobalAttributes, type HTMLContent, type InlineMarkdownSpecOptions, InputRule, type InputRuleFinder, type InputRuleMatch, type InsertContentAtOptions, type InsertContentOptions, type JSONContent, type KeyboardShortcutCommand, type KeysWithTypeOf, Mark, type MarkConfig, type MarkRange, type MarkType, MarkView, type MarkViewProps, type MarkViewRenderer, type MarkViewRendererOptions, type MarkViewRendererProps, type MarkdownExtensionSpec, type MarkdownHelpers, type MarkdownLexerConfiguration, type MarkdownParseHelpers, type MarkdownParseResult, type MarkdownRendererHelpers, type MarkdownToken, type MarkdownTokenizer, type MaybeReturnType, type MaybeThisParameterType, Node, type NodeConfig, NodePos, type NodeRange, type NodeType, NodeView, type NodeViewProps, type NodeViewRenderer, type NodeViewRendererOptions, type NodeViewRendererProps, type NodeWithPos, type Overwrite, type ParentConfig, type ParsedBlock, PasteRule, type PasteRuleFinder, type PasteRuleMatch, type PickValue, type Predicate, type Primitive, type Range, type RawCommands, type RemoveThis, type RenderContext, type SetContentOptions, type SingleCommands, type Storage, type TextSerializer, type TextType, type TiptapEditorHTMLElement, Tracker, type TrackerResult, type UnionCommands, type UnionToIntersection, type ValuesOf, blur, callOrReturn, canInsertNode, clearContent, clearNodes, combineTransactionSteps, command, index$2 as commands, createAtomBlockMarkdownSpec, createBlockMarkdownSpec, createChainableState, createDocument, h as createElement, createInlineMarkdownSpec, createNodeFromContent, createParagraphNear, createStyleTag, cut, defaultBlockAt, deleteCurrentNode, deleteNode, deleteProps, deleteRange, deleteSelection, elementFromString, enter, escapeForRegEx, exitCode, extendMarkRange, index$1 as extensions, findChildren, findChildrenInRange, findDuplicates, findParentNode, findParentNodeClosestToPos, first, flattenExtensions, focus, forEach, fromString, generateHTML, generateJSON, generateText, getAttributes, getAttributesFromExtensions, getChangedRanges, getDebugJSON, getExtensionField, getHTMLFromFragment, getMarkAttributes, getMarkRange, getMarkType, getMarksBetween, getNodeAtPosition, getNodeAttributes, getNodeType, getRenderedAttributes, getSchema, getSchemaByResolvedExtensions, getSchemaTypeByName, getSchemaTypeNameByName, getSplittedAttributes, getText, getTextBetween, getTextContentFromNodes, getTextSerializersFromSchema, h, injectExtensionAttributesToParseRule, inputRulesPlugin, insertContent, insertContentAt, isActive, isAndroid, isAtEndOfNode, isAtStartOfNode, isEmptyObject, isExtensionRulesEnabled, isFunction, isList, isMacOS, isMarkActive, isNodeActive, isNodeEmpty, isNodeSelection, isNumber, isPlainObject, isRegExp, isString, isTextSelection, isiOS, joinBackward, joinDown, joinForward, joinItemBackward, joinItemForward, joinTextblockBackward, joinTextblockForward, joinUp, keyboardShortcut, lift, liftEmptyBlock, liftListItem, markInputRule, markPasteRule, index as markdown, mergeAttributes, mergeDeep, minMax, newlineInCode, nodeInputRule, nodePasteRule, objectIncludes, parseAttributes, parseIndentedBlocks, pasteRulesPlugin, posToDOMRect, removeDuplicates, renderNestedMarkdownContent, resetAttributes, resolveExtensions, resolveFocusPosition, rewriteUnknownContent, scrollIntoView, selectAll, selectNodeBackward, selectNodeForward, selectParentNode, selectTextblockEnd, selectTextblockStart, selectionToInsertionEnd, serializeAttributes, setContent, setMark, setMeta, setNode, setNodeSelection, setTextSelection, sinkListItem, sortExtensions, splitBlock, splitExtensions, splitListItem, textInputRule, textPasteRule, textblockTypeInputRule, toggleList, toggleMark, toggleNode, toggleWrap, undoInputRule, unsetAllMarks, unsetMark, updateAttributes, updateMarkViewAttributes, wrapIn, wrapInList, wrappingInputRule };