@tiptap/core 3.9.1 → 3.10.1

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Transaction, EditorState, Plugin, Selection, NodeSelection, TextSelection, PluginKey } from '@tiptap/pm/state';
 import { Node as Node$1, MarkType as MarkType$1, MarkSpec, Mark as Mark$1, DOMOutputSpec, NodeType as NodeType$1, NodeSpec, Slice, ParseOptions, Fragment as Fragment$1, Schema, ContentMatch, ResolvedPos, ParseRule } from '@tiptap/pm/model';
-import { EditorProps, EditorView, Decoration, DecorationAttrs, ViewMutationRecord, NodeViewConstructor, NodeView as NodeView$1, MarkViewConstructor, MarkView as MarkView$1 } from '@tiptap/pm/view';
+import { EditorProps, EditorView, Decoration, DecorationAttrs, ViewMutationRecord, NodeViewConstructor, NodeView as NodeView$1, MarkViewConstructor, MarkView as MarkView$1, DecorationSource } from '@tiptap/pm/view';
 import { Transform, Mappable } from '@tiptap/pm/transform';
 
 type StringKeyOf<T> = Extract<keyof T, string>;
@@ -215,7 +215,7 @@ interface NodeConfig<Options = any, Storage = any> extends ExtendableConfig<Opti
         editor: Editor;
         type: NodeType$1;
         parent: ParentConfig<NodeConfig<Options, Storage>>['addNodeView'];
-    }) => NodeViewRenderer) | null;
+    }) => NodeViewRenderer | null) | null;
     /**
      * Defines if this node should be a top level node (doc)
      * @default false
@@ -3524,6 +3524,466 @@ declare function Fragment(props: {
 }): JSXRenderer[];
 declare const h: JSXRenderer;
 
+/**
+ * Directions where resize handles can be placed
+ *
+ * @example
+ * - `'top'` - Top edge handle
+ * - `'bottom-right'` - Bottom-right corner handle
+ */
+type ResizableNodeViewDirection = 'top' | 'right' | 'bottom' | 'left' | 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+/**
+ * Dimensions for the resizable node in pixels
+ */
+type ResizableNodeDimensions = {
+    /** Width in pixels */
+    width: number;
+    /** Height in pixels */
+    height: number;
+};
+/**
+ * Configuration options for creating a ResizableNodeView
+ *
+ * @example
+ * ```ts
+ * new ResizableNodeView({
+ *   element: imgElement,
+ *   node,
+ *   getPos,
+ *   onResize: (width, height) => {
+ *     imgElement.style.width = `${width}px`
+ *     imgElement.style.height = `${height}px`
+ *   },
+ *   onCommit: (width, height) => {
+ *     editor.commands.updateAttributes('image', { width, height })
+ *   },
+ *   onUpdate: (node) => true,
+ *   options: {
+ *     directions: ['bottom-right', 'bottom-left'],
+ *     min: { width: 100, height: 100 },
+ *     preserveAspectRatio: true
+ *   }
+ * })
+ * ```
+ */
+type ResizableNodeViewOptions = {
+    /**
+     * The DOM element to make resizable (e.g., an img, video, or iframe element)
+     */
+    element: HTMLElement;
+    /**
+     * The DOM element that will hold the editable content element
+     */
+    contentElement?: HTMLElement;
+    /**
+     * The ProseMirror node instance
+     */
+    node: Node$1;
+    /**
+     * Function that returns the current position of the node in the document
+     */
+    getPos: () => number | undefined;
+    /**
+     * Callback fired continuously during resize with current dimensions.
+     * Use this to update the element's visual size in real-time.
+     *
+     * @param width - Current width in pixels
+     * @param height - Current height in pixels
+     *
+     * @example
+     * ```ts
+     * onResize: (width, height) => {
+     *   element.style.width = `${width}px`
+     *   element.style.height = `${height}px`
+     * }
+     * ```
+     */
+    onResize?: (width: number, height: number) => void;
+    /**
+     * Callback fired once when resize completes with final dimensions.
+     * Use this to persist the new size to the node's attributes.
+     *
+     * @param width - Final width in pixels
+     * @param height - Final height in pixels
+     *
+     * @example
+     * ```ts
+     * onCommit: (width, height) => {
+     *   const pos = getPos()
+     *   if (pos !== undefined) {
+     *     editor.commands.updateAttributes('image', { width, height })
+     *   }
+     * }
+     * ```
+     */
+    onCommit: (width: number, height: number) => void;
+    /**
+     * Callback for handling node updates.
+     * Return `true` to accept the update, `false` to reject it.
+     *
+     * @example
+     * ```ts
+     * onUpdate: (node, decorations, innerDecorations) => {
+     *   if (node.type !== this.node.type) return false
+     *   return true
+     * }
+     * ```
+     */
+    onUpdate: NodeView$1['update'];
+    /**
+     * Optional configuration for resize behavior and styling
+     */
+    options?: {
+        /**
+         * Which resize handles to display.
+         * @default ['bottom-left', 'bottom-right', 'top-left', 'top-right']
+         *
+         * @example
+         * ```ts
+         * // Only show corner handles
+         * directions: ['top-left', 'top-right', 'bottom-left', 'bottom-right']
+         *
+         * // Only show right edge handle
+         * directions: ['right']
+         * ```
+         */
+        directions?: ResizableNodeViewDirection[];
+        /**
+         * Minimum dimensions in pixels
+         * @default { width: 8, height: 8 }
+         *
+         * @example
+         * ```ts
+         * min: { width: 100, height: 50 }
+         * ```
+         */
+        min?: Partial<ResizableNodeDimensions>;
+        /**
+         * Maximum dimensions in pixels
+         * @default undefined (no maximum)
+         *
+         * @example
+         * ```ts
+         * max: { width: 1000, height: 800 }
+         * ```
+         */
+        max?: Partial<ResizableNodeDimensions>;
+        /**
+         * Always preserve aspect ratio when resizing.
+         * When `false`, aspect ratio is preserved only when Shift key is pressed.
+         * @default false
+         *
+         * @example
+         * ```ts
+         * preserveAspectRatio: true // Always lock aspect ratio
+         * ```
+         */
+        preserveAspectRatio?: boolean;
+        /**
+         * Custom CSS class names for styling
+         *
+         * @example
+         * ```ts
+         * className: {
+         *   container: 'resize-container',
+         *   wrapper: 'resize-wrapper',
+         *   handle: 'resize-handle',
+         *   resizing: 'is-resizing'
+         * }
+         * ```
+         */
+        className?: {
+            /** Class for the outer container element */
+            container?: string;
+            /** Class for the wrapper element that contains the resizable element */
+            wrapper?: string;
+            /** Class applied to all resize handles */
+            handle?: string;
+            /** Class added to container while actively resizing */
+            resizing?: string;
+        };
+    };
+};
+/**
+ * A NodeView implementation that adds resize handles to any DOM element.
+ *
+ * This class creates a resizable node view for Tiptap/ProseMirror editors.
+ * It wraps your element with resize handles and manages the resize interaction,
+ * including aspect ratio preservation, min/max constraints, and keyboard modifiers.
+ *
+ * @example
+ * ```ts
+ * // Basic usage in a Tiptap extension
+ * addNodeView() {
+ *   return ({ node, getPos }) => {
+ *     const img = document.createElement('img')
+ *     img.src = node.attrs.src
+ *
+ *     return new ResizableNodeView({
+ *       element: img,
+ *       node,
+ *       getPos,
+ *       onResize: (width, height) => {
+ *         img.style.width = `${width}px`
+ *         img.style.height = `${height}px`
+ *       },
+ *       onCommit: (width, height) => {
+ *         this.editor.commands.updateAttributes('image', { width, height })
+ *       },
+ *       onUpdate: () => true,
+ *       options: {
+ *         min: { width: 100, height: 100 },
+ *         preserveAspectRatio: true
+ *       }
+ *     })
+ *   }
+ * }
+ * ```
+ */
+declare class ResizableNodeView {
+    /** The ProseMirror node instance */
+    node: Node$1;
+    /** The DOM element being made resizable */
+    element: HTMLElement;
+    /** The editable DOM element inside the DOM */
+    contentElement?: HTMLElement;
+    /** The outer container element (returned as NodeView.dom) */
+    container: HTMLElement;
+    /** The wrapper element that contains the element and handles */
+    wrapper: HTMLElement;
+    /** Function to get the current node position */
+    getPos: () => number | undefined;
+    /** Callback fired during resize */
+    onResize?: (width: number, height: number) => void;
+    /** Callback fired when resize completes */
+    onCommit: (width: number, height: number) => void;
+    /** Callback for node updates */
+    onUpdate?: NodeView$1['update'];
+    /** Active resize handle directions */
+    directions: ResizableNodeViewDirection[];
+    /** Minimum allowed dimensions */
+    minSize: ResizableNodeDimensions;
+    /** Maximum allowed dimensions (optional) */
+    maxSize?: Partial<ResizableNodeDimensions>;
+    /** Whether to always preserve aspect ratio */
+    preserveAspectRatio: boolean;
+    /** CSS class names for elements */
+    classNames: {
+        container: string;
+        wrapper: string;
+        handle: string;
+        resizing: string;
+    };
+    /** Initial width of the element (for aspect ratio calculation) */
+    private initialWidth;
+    /** Initial height of the element (for aspect ratio calculation) */
+    private initialHeight;
+    /** Calculated aspect ratio (width / height) */
+    private aspectRatio;
+    /** Whether a resize operation is currently active */
+    private isResizing;
+    /** The handle currently being dragged */
+    private activeHandle;
+    /** Starting mouse X position when resize began */
+    private startX;
+    /** Starting mouse Y position when resize began */
+    private startY;
+    /** Element width when resize began */
+    private startWidth;
+    /** Element height when resize began */
+    private startHeight;
+    /** Whether Shift key is currently pressed (for temporary aspect ratio lock) */
+    private isShiftKeyPressed;
+    /**
+     * Creates a new ResizableNodeView instance.
+     *
+     * The constructor sets up the resize handles, applies initial sizing from
+     * node attributes, and configures all resize behavior options.
+     *
+     * @param options - Configuration options for the resizable node view
+     */
+    constructor(options: ResizableNodeViewOptions);
+    /**
+     * Returns the top-level DOM node that should be placed in the editor.
+     *
+     * This is required by the ProseMirror NodeView interface. The container
+     * includes the wrapper, handles, and the actual content element.
+     *
+     * @returns The container element to be inserted into the editor
+     */
+    get dom(): HTMLElement;
+    get contentDOM(): HTMLElement | undefined;
+    /**
+     * Called when the node's content or attributes change.
+     *
+     * Updates the internal node reference. If a custom `onUpdate` callback
+     * was provided, it will be called to handle additional update logic.
+     *
+     * @param node - The new/updated node
+     * @param decorations - Node decorations
+     * @param innerDecorations - Inner decorations
+     * @returns `false` if the node type has changed (requires full rebuild), otherwise the result of `onUpdate` or `true`
+     */
+    update(node: Node$1, decorations: readonly Decoration[], innerDecorations: DecorationSource): boolean;
+    /**
+     * Cleanup method called when the node view is being removed.
+     *
+     * Removes all event listeners to prevent memory leaks. This is required
+     * by the ProseMirror NodeView interface. If a resize is active when
+     * destroy is called, it will be properly cancelled.
+     */
+    destroy(): void;
+    /**
+     * Creates the outer container element.
+     *
+     * The container is the top-level element returned by the NodeView and
+     * wraps the entire resizable node. It's set up with flexbox to handle
+     * alignment and includes data attributes for styling and identification.
+     *
+     * @returns The container element
+     */
+    createContainer(): HTMLDivElement;
+    /**
+     * Creates the wrapper element that contains the content and handles.
+     *
+     * The wrapper uses relative positioning so that resize handles can be
+     * positioned absolutely within it. This is the direct parent of the
+     * content element being made resizable.
+     *
+     * @returns The wrapper element
+     */
+    createWrapper(): HTMLDivElement;
+    /**
+     * Creates a resize handle element for a specific direction.
+     *
+     * Each handle is absolutely positioned and includes a data attribute
+     * identifying its direction for styling purposes.
+     *
+     * @param direction - The resize direction for this handle
+     * @returns The handle element
+     */
+    private createHandle;
+    /**
+     * Positions a handle element according to its direction.
+     *
+     * Corner handles (e.g., 'top-left') are positioned at the intersection
+     * of two edges. Edge handles (e.g., 'top') span the full width or height.
+     *
+     * @param handle - The handle element to position
+     * @param direction - The direction determining the position
+     */
+    private positionHandle;
+    /**
+     * Creates and attaches all resize handles to the wrapper.
+     *
+     * Iterates through the configured directions, creates a handle for each,
+     * positions it, attaches the mousedown listener, and appends it to the DOM.
+     */
+    private attachHandles;
+    /**
+     * Applies initial sizing from node attributes to the element.
+     *
+     * If width/height attributes exist on the node, they're applied to the element.
+     * Otherwise, the element's natural/current dimensions are measured. The aspect
+     * ratio is calculated for later use in aspect-ratio-preserving resizes.
+     */
+    private applyInitialSize;
+    /**
+     * Initiates a resize operation when a handle is clicked.
+     *
+     * Captures the starting mouse position and element dimensions, sets up
+     * the resize state, adds the resizing class and state attribute, and
+     * attaches document-level listeners for mouse movement and keyboard input.
+     *
+     * @param event - The mouse down event
+     * @param direction - The direction of the handle being dragged
+     */
+    private handleResizeStart;
+    /**
+     * Handles mouse movement during an active resize.
+     *
+     * Calculates the delta from the starting position, computes new dimensions
+     * based on the active handle direction, applies constraints and aspect ratio,
+     * then updates the element's style and calls the onResize callback.
+     *
+     * @param event - The mouse move event
+     */
+    private handleMouseMove;
+    private handleTouchMove;
+    private handleResize;
+    /**
+     * Completes the resize operation when the mouse button is released.
+     *
+     * Captures final dimensions, calls the onCommit callback to persist changes,
+     * removes the resizing state and class, and cleans up document-level listeners.
+     */
+    private handleMouseUp;
+    /**
+     * Tracks Shift key state to enable temporary aspect ratio locking.
+     *
+     * When Shift is pressed during resize, aspect ratio is preserved even if
+     * preserveAspectRatio is false.
+     *
+     * @param event - The keyboard event
+     */
+    private handleKeyDown;
+    /**
+     * Tracks Shift key release to disable temporary aspect ratio locking.
+     *
+     * @param event - The keyboard event
+     */
+    private handleKeyUp;
+    /**
+     * Calculates new dimensions based on mouse delta and resize direction.
+     *
+     * Takes the starting dimensions and applies the mouse movement delta
+     * according to the handle direction. For corner handles, both dimensions
+     * are affected. For edge handles, only one dimension changes. If aspect
+     * ratio should be preserved, delegates to applyAspectRatio.
+     *
+     * @param direction - The active resize handle direction
+     * @param deltaX - Horizontal mouse movement since resize start
+     * @param deltaY - Vertical mouse movement since resize start
+     * @returns The calculated width and height
+     */
+    private calculateNewDimensions;
+    /**
+     * Applies min/max constraints to dimensions.
+     *
+     * When aspect ratio is NOT preserved, constraints are applied independently
+     * to width and height. When aspect ratio IS preserved, constraints are
+     * applied while maintaining the aspect ratio—if one dimension hits a limit,
+     * the other is recalculated proportionally.
+     *
+     * This ensures that aspect ratio is never broken when constrained.
+     *
+     * @param width - The unconstrained width
+     * @param height - The unconstrained height
+     * @param preserveAspectRatio - Whether to maintain aspect ratio while constraining
+     * @returns The constrained dimensions
+     */
+    private applyConstraints;
+    /**
+     * Adjusts dimensions to maintain the original aspect ratio.
+     *
+     * For horizontal handles (left/right), uses width as the primary dimension
+     * and calculates height from it. For vertical handles (top/bottom), uses
+     * height as primary and calculates width. For corner handles, uses width
+     * as the primary dimension.
+     *
+     * @param width - The new width
+     * @param height - The new height
+     * @param direction - The active resize direction
+     * @returns Dimensions adjusted to preserve aspect ratio
+     */
+    private applyAspectRatio;
+}
+/**
+ * Alias for ResizableNodeView to maintain consistent naming.
+ * @deprecated Use ResizableNodeView instead - will be removed in future versions.
+ */
+declare const ResizableNodeview: typeof ResizableNodeView;
+
 declare function updateMarkViewAttributes(checkMark: Mark$1, editor: Editor, attrs?: Record<string, any>): void;
 declare class MarkView<Component, Options extends MarkViewRendererOptions = MarkViewRendererOptions> {
     component: Component;
@@ -4072,4 +4532,4 @@ interface Commands<ReturnType = any> {
 interface Storage {
 }
 
-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 };
+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 ResizableNodeDimensions, ResizableNodeView, type ResizableNodeViewDirection, type ResizableNodeViewOptions, ResizableNodeview, 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 };