@domternal/core 0.14.0 → 1.0.0

package/dist/index.d.ts

@@ -134,6 +134,16 @@ interface EditorEvents {
     notionColorOpen: {
         anchorElement?: HTMLElement | null;
     };
+    /**
+     * Fired after the document has been marked for printing and before the
+     * browser's print dialog opens. Listeners run synchronously: this is the
+     * last moment to add page rules or set `document.title`.
+     */
+    beforePrint: {
+        root: HTMLElement;
+    };
+    /** Fired once the print dialog is done and the print marks are removed. */
+    afterPrint: undefined;
 }
 /**
  * Event names as a type
@@ -172,6 +182,19 @@ interface AnyExtension {
  * - number: Focus at specific position
  */
 type FocusPosition = boolean | 'start' | 'end' | 'all' | number | null;
+/**
+ * The editing experience the editor is assembled for.
+ *
+ * - 'classic': the default toolbar-driven experience
+ * - 'notion': the block-based Notion-style experience; the editor paints
+ *   `dm-notion-mode` on its `.dm-editor` host, and preset-aware extensions
+ *   (the bubble menu contexts, the image placement controls) adapt
+ *
+ * Read the resolved value via `editor.preset`, never this option directly:
+ * consumers that predate the option declare Notion mode with the theme
+ * class alone, and the getter honors that.
+ */
+type EditorPreset = 'classic' | 'notion';
 /**
  * Configuration options for creating an Editor instance
  */
@@ -203,6 +226,15 @@ interface EditorOptions {
      * @default true
      */
     editable?: boolean;
+    /**
+     * Editing experience preset. `'notion'` paints `dm-notion-mode` on the
+     * `.dm-editor` host and switches preset-aware extensions to their Notion
+     * behavior, so one option replaces setting the class by hand. When omitted,
+     * a `dm-notion-mode` class already on the host still counts as Notion;
+     * an explicit `'classic'` overrides even that.
+     * @default undefined (resolved from the host class, else 'classic')
+     */
+    preset?: EditorPreset;
     /**
      * Accessible label for the editor.
      * Sets aria-label on the contenteditable element.
@@ -774,12 +806,25 @@ declare class ExtensionManager {
     /**
      * Recursively flattens extensions by expanding addExtensions()
      * This allows extension bundles like StarterKit to work
+     *
+     * `autoIncluded` collects everything that arrived through an
+     * `addExtensions()` rather than from the caller's own list, which is what
+     * lets deduplication tell a default apart from a choice.
      */
     private flattenExtensions;
     /**
-     * Removes duplicate extensions by name, keeping the last occurrence.
-     * This allows parent extensions to auto-include children via addExtensions()
-     * while letting users override with explicitly configured versions.
+     * Removes duplicate extensions by name.
+     *
+     * A version the caller listed themselves always wins over one a bundle
+     * included on their behalf, and position does not enter into it. Keeping
+     * the last occurrence alone said the same thing only while every bundle was
+     * listed first, which is the habit for StarterKit and no rule at all: an
+     * extension that includes a default and is written LOWER in the list, as
+     * `Export` and its `Print` are, silently replaced the configured copy
+     * above it and the caller's options went missing with it.
+     *
+     * Between two of the same kind the later one still wins, so two bundles
+     * offering the same default resolve as they always have.
      */
     private deduplicateExtensions;
     /**
@@ -1085,6 +1130,12 @@ declare class Editor extends EventEmitter<EditorEvents> {
      * True while EditorView's constructor runs; see buildViewDispatch.
      */
     private _isViewConstructing;
+    /**
+     * The `.dm-editor` host this editor painted `dm-notion-mode` onto because
+     * of `preset: 'notion'`. Tracked so destroy() removes only a class the
+     * editor itself added, never one the consumer wrote.
+     */
+    private _presetClassHost;
     /**
      * Creates a new Editor instance
      *
@@ -1105,6 +1156,26 @@ declare class Editor extends EventEmitter<EditorEvents> {
      * Checks if the editor is editable
      */
     get isEditable(): boolean;
+    /**
+     * The resolved editing-experience preset.
+     *
+     * The `preset` option wins when provided (so an explicit 'classic' can
+     * opt out of everything). Otherwise a `dm-notion-mode` class on or above
+     * the view counts as 'notion': consumers that predate the option declare
+     * Notion mode with the theme class alone, and behavior must follow what
+     * the user actually sees. Resolved on every read, not cached, so a class
+     * toggled at runtime is picked up.
+     */
+    get preset(): EditorPreset;
+    /**
+     * Paints `dm-notion-mode` on the `.dm-editor` host when the editor was
+     * created with `preset: 'notion'`. Runs during creation, and framework
+     * wrappers call it again after adopting the view's DOM: they construct
+     * the editor in a detached element, so the creation-time run cannot see
+     * the host yet. Idempotent; a no-op for any other preset. Only a class
+     * added here is removed again on destroy.
+     */
+    adoptPresetClass(): void;
     /**
      * Checks if the editor content is empty
      */
@@ -1381,6 +1452,11 @@ interface ExtensionEditor {
     readonly schema: unknown;
     readonly commands: SingleCommands;
     readonly isEditable: boolean;
+    /**
+     * Resolved editing-experience preset; see Editor.preset. Optional so
+     * minimal editor mocks keep compiling; treat undefined as 'classic'.
+     */
+    readonly preset?: EditorPreset;
 }
 /**
  * Any extension type (forward declaration)
@@ -1749,6 +1825,11 @@ interface NodeEditorContext {
         nodes: Record<string, NodeType>;
     };
     readonly commands: Record<string, (...args: unknown[]) => boolean>;
+    /**
+     * Resolved editing-experience preset; see Editor.preset. Optional so
+     * minimal editor mocks keep compiling; treat undefined as 'classic'.
+     */
+    readonly preset?: EditorPreset;
 }
 /**
  * Context interface for Node config methods.
@@ -2089,11 +2170,21 @@ interface MarkSchemaProperties {
      * Marks that this mark excludes (cannot coexist with)
      *
      * - '_' excludes all marks
-     * - Space-separated mark names exclude specific marks
+     * - Space-separated mark names or group names exclude those marks
      * - Empty string or undefined means no exclusions
      *
+     * Note: mark NAMES listed here must exist in the schema or schema
+     * compilation throws, so extensions meant to work in minimal setups
+     * should exclude by group. The core formatting marks (bold, italic,
+     * underline, strike, code, sub/superscript, textStyle) all declare
+     * group 'formatting', and Code excludes that group: a third-party
+     * formatting mark joins the exclusion by declaring the same group,
+     * while semantic marks (link, comment anchors) stay combinable with
+     * code by staying out of it.
+     *
      * @example 'code' - excludes code mark
      * @example 'bold italic' - excludes bold and italic
+     * @example 'formatting' - excludes the formatting group
      * @example '_' - excludes all other marks
      */
     excludes?: string;
@@ -2104,6 +2195,17 @@ interface MarkSchemaProperties {
      * @example 'formatting', 'inline'
      */
     group?: string;
+    /**
+     * Whether block duplication keeps this mark on the copied content
+     *
+     * Set false for marks that reference identity-bearing external state
+     * (a comment thread anchor, a suggestion id): duplicating such a mark
+     * would make one identity point at two unrelated places, so block
+     * duplicate strips it from the copy instead.
+     *
+     * @default true
+     */
+    keepOnDuplicate?: boolean;
     /**
      * Whether this mark can span multiple nodes
      *
@@ -2696,33 +2798,499 @@ declare function announce(view: {
  * UNLESS the command moved focus into a popover input the user is meant to type
  * into (currently the math LaTeX field).
  *
- * The refocus exists so keyboard (Enter / Space) activation of a plain command
- * button returns the caret to the document and keeps the native `::selection`
- * highlight. Mouse clicks already keep focus via `mousedown.preventDefault()`.
+ * The refocus exists so keyboard (Enter / Space) activation of a plain command
+ * button returns the caret to the document and keeps the native `::selection`
+ * highlight. Mouse clicks already keep focus via `mousedown.preventDefault()`.
+ *
+ * A focused element is treated as such a popover when it sits inside a
+ * `[data-dm-editor-ui]` element that is NOT the toolbar / bubble-menu / floating-
+ * menu chrome and is not inside the contenteditable. To opt in, a popover must
+ * render outside those surfaces, carry `data-dm-editor-ui`, and focus itself
+ * synchronously while the opening command dispatches (so `activeElement` reflects
+ * it before this frame runs).
+ */
+declare function refocusEditorAfterCommand(view: {
+    dom: Element;
+    focus: () => void;
+}): void;
+
+/**
+ * Default `contexts` map for a bubble menu when the consumer has not
+ * supplied one. Returns a richer item set when the editor resolves to the
+ * Notion preset (the `preset` option, or the `.dm-notion-mode` class the
+ * getter also honors), so the bubble menu mirrors the Notion UX by leading
+ * with the `ai` and `comment` selection actions, then offering the block-type
+ * dropdown and `link` ahead of the formatting marks.
+ *
+ * Consumers can always override by passing their own `contexts` prop.
+ */
+declare function defaultBubbleContexts(editor: Editor): Record<string, string[]>;
+
+/**
+ * Drop the separators that ended up with nothing to separate.
+ *
+ * A menu built from a flat list of names (`['ai', '|', 'bold', ...]`) resolves
+ * each name against the extensions the editor actually loaded, and silently
+ * skips the ones it cannot find. That is what lets one default list serve every
+ * build: an editor without the AI extension simply does not show `ai`. The
+ * separators do not take part in that, because a `|` always resolves. So the
+ * list shrinks around them and they stay, and a bar that was drawn between two
+ * groups is left leading the menu, trailing it, or standing next to another
+ * bar with nothing in between.
+ *
+ * This is the pass that finishes the job. Run it after everything that can
+ * remove an item, which includes schema filtering as well as name resolution:
+ * a separator can be orphaned by a selection whose node type does not allow
+ * the marks on one side of it, and that is decided per transaction rather than
+ * once at construction.
+ *
+ * The trailing buttons a menu appends afterwards are not visible here, so a
+ * caller that appends its own leading separator has to ask whether anything
+ * came before it. What this guarantees is the half it can: the list is empty,
+ * or it begins and ends with something that is not a separator.
+ *
+ * Written against `{ type: string }` rather than a menu's item union because
+ * every surface spells its item type differently and none of the differences
+ * matter here.
+ *
+ * A list with nothing to drop comes back as the SAME array, not a copy. React
+ * and Vue hand this straight to their state, and a fresh array every time is a
+ * re-render every time: this runs once per transaction, and pointer motion
+ * alone dispatches those. Most lists never need collapsing, so most passes
+ * cost nothing.
+ */
+declare function collapseSeparators<T extends {
+    type: string;
+}>(items: readonly T[]): T[];
+
+/**
+ * Extension - Base class for all extensions
+ *
+ * Extensions provide functionality without contributing to the schema.
+ * For schema contributions, use Node (for block/inline nodes) or Mark (for inline formatting).
+ *
+ * Three-tier model:
+ * - Extension (type: 'extension') → Pure functionality (History, Placeholder, etc.)
+ * - Node (type: 'node') → Schema nodes (Paragraph, Heading, etc.)
+ * - Mark (type: 'mark') → Schema marks (Bold, Italic, etc.)
+ *
+ * @example
+ * const History = Extension.create({
+ *   name: 'history',
+ *   addOptions() {
+ *     return { depth: 100 };
+ *   },
+ *   addKeyboardShortcuts() {
+ *     return {
+ *       'Mod-z': () => this.editor.commands.undo(),
+ *       'Mod-Shift-z': () => this.editor.commands.redo(),
+ *     };
+ *   },
+ * });
+ */
+
+/**
+ * Editor interface for Extension
+ * Forward declaration to avoid circular dependency
+ */
+interface ExtensionEditorInterface {
+    readonly state: EditorState;
+    readonly view: EditorView;
+    readonly schema: unknown;
+    readonly commands: SingleCommands;
+}
+/**
+ * Marks an object as a Domternal extension, recognisably across copies.
+ *
+ * `Symbol.for` rather than `Symbol()`: the whole point is that an extension
+ * built by a SECOND physical copy of this module still carries a mark the
+ * first copy can read. A copy-local symbol would be a different key and every
+ * foreign extension would look like a hand-written object instead.
+ *
+ * The value is deliberately `true` rather than a per-copy token. Which copy an
+ * extension came from is answered by `instanceof Extension`, and that answer is
+ * exact; this only separates "a Domternal extension from somewhere" from "a
+ * plain object somebody passed in", which must keep working as it always has.
+ */
+declare const EXTENSION_BRAND: unique symbol;
+/**
+ * Base class for all extensions
+ *
+ * @typeParam Options - Extension options type
+ * @typeParam Storage - Extension storage type
+ */
+declare class Extension<Options = unknown, Storage = unknown> {
+    /**
+     * Brand read by `ExtensionManager` to tell an extension built by another
+     * copy of `@domternal/core` from a plain object. See `EXTENSION_BRAND`.
+     */
+    readonly [EXTENSION_BRAND] = true;
+    /**
+     * Extension type identifier
+     * Used to distinguish between Extension, Node, and Mark
+     * Subclasses override this to 'node' or 'mark'
+     */
+    readonly type: 'extension' | 'node' | 'mark';
+    /**
+     * Unique extension name
+     */
+    readonly name: string;
+    /**
+     * Extension options (immutable after creation)
+     */
+    readonly options: Options;
+    /**
+     * Extension storage (mutable state)
+     * Accessible via editor.storage[extensionName]
+     */
+    storage: Storage;
+    /**
+     * The original configuration object
+     */
+    readonly config: ExtensionConfig<Options, Storage>;
+    /**
+     * Editor instance (set by ExtensionManager after creation)
+     * null until ExtensionManager binds it
+     */
+    editor: ExtensionEditorInterface | null;
+    /**
+     * Reference to the parent config method when using extend().
+     * Set temporarily during config method execution so overridden
+     * methods can call `this.parent?.()` to invoke the original.
+     */
+    parent?: ((...args: unknown[]) => unknown) | undefined;
+    /**
+     * Protected constructor - use Extension.create() instead
+     */
+    protected constructor(config: ExtensionConfig<Options, Storage>);
+    /**
+     * Creates a new extension instance
+     *
+     * @param config - Extension configuration
+     * @returns New extension instance
+     *
+     * @example
+     * const MyExtension = Extension.create({
+     *   name: 'myExtension',
+     *   addOptions() {
+     *     return { enabled: true };
+     *   },
+     * });
+     */
+    static create<O = unknown, S = unknown>(config: ExtensionConfig<O, S>): Extension<O, S>;
+    /**
+     * Creates a new extension with merged options
+     * Original extension is not modified
+     *
+     * **Note:** Options are merged shallowly using object spread (`...`).
+     * Nested objects are replaced entirely, not deeply merged.
+     *
+     * @param options - Options to merge with existing options
+     * @returns New extension instance with merged options
+     *
+     * @example
+     * const configured = MyExtension.configure({ enabled: false });
+     *
+     * @example
+     * // Shallow merge behavior with nested objects:
+     * // Given: options = { nested: { a: 1, b: 2 } }
+     * // configure({ nested: { b: 3 } })
+     * // Result: { nested: { b: 3 } } - 'a' is lost!
+     * // To preserve nested values, spread manually:
+     * // configure({ nested: { ...original.options.nested, b: 3 } })
+     */
+    configure(options: Partial<Options>): Extension<Options, Storage>;
+    /**
+     * Returns a fresh, unbound copy built from the same `config`: `editor` reset to
+     * null and `options`/`storage` re-derived, while `configure()`/`extend()`
+     * results are preserved (they live in `config`). Polymorphic: a `Node`/`Mark`
+     * clones to its own subclass.
+     *
+     * `ExtensionManager` clones every extension so each editor owns its instances
+     * and binding one editor can't mutate extensions shared with another.
+     */
+    clone(): Extension<Options, Storage>;
+    /**
+     * Creates a new extension with extended configuration
+     * Original extension is not modified
+     *
+     * **Note:** Config is merged shallowly using object spread (`...`).
+     * Config properties (like `addCommands`, `addKeyboardShortcuts`) are
+     * replaced entirely, not combined with the base extension's config.
+     *
+     * @param extendedConfig - Configuration to extend/override
+     * @returns New extension instance with extended config
+     *
+     * @example
+     * const Extended = MyExtension.extend({
+     *   name: 'extendedExtension',
+     *   addCommands() {
+     *     return { customCommand: () => ({ tr }) => true };
+     *   },
+     * });
+     *
+     * @example
+     * // To preserve base extension's commands while adding new ones:
+     * const Extended = BaseExtension.extend({
+     *   addCommands() {
+     *     const baseCommands = BaseExtension.config.addCommands?.call(this) ?? {};
+     *     return {
+     *       ...baseCommands,
+     *       newCommand: () => ({ tr }) => true,
+     *     };
+     *   },
+     * });
+     */
+    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig: Partial<ExtensionConfigBase<ExtendedOptions, ExtendedStorage>> & ThisType<ExtensionContext<ExtendedOptions, ExtendedStorage>>): Extension<ExtendedOptions, ExtendedStorage>;
+}
+
+/**
+ * Floating menu shown when text is selected. Contextual formatting toolbar.
+ */
+
+declare const bubbleMenuPluginKey: PluginKey<any>;
+interface BubbleMenuOptions {
+    /**
+     * The HTML element that contains the menu.
+     * Must be provided by the user.
+     */
+    element: HTMLElement | null;
+    /**
+     * Duration in ms to wait before showing the menu.
+     * @default 0
+     */
+    updateDelay: number;
+    /**
+     * Function to determine if the menu should be shown.
+     * By default, shows for text selections with actual content in an editable editor.
+     */
+    shouldShow: (props: {
+        editor: Editor;
+        view: EditorView;
+        state: EditorState;
+        from: number;
+        to: number;
+    }) => boolean;
+    /**
+     * Placement of the menu relative to the selection.
+     * @default 'top'
+     */
+    placement: 'top' | 'bottom';
+    /**
+     * Offset in pixels from the selection.
+     * @default 8
+     */
+    offset: number;
+}
+interface CreateBubbleMenuPluginOptions {
+    pluginKey: PluginKey;
+    editor: Editor;
+    element: HTMLElement;
+    shouldShow?: BubbleMenuOptions['shouldShow'];
+    placement?: 'top' | 'bottom';
+    offset?: number;
+    updateDelay?: number;
+}
+/**
+ * Creates a standalone BubbleMenu ProseMirror plugin.
+ * Can be used by framework wrappers (Angular, React, Vue) to create the plugin
+ * independently of the extension system.
+ */
+declare function createBubbleMenuPlugin(options: CreateBubbleMenuPluginOptions): Plugin;
+declare const BubbleMenu: Extension<BubbleMenuOptions, unknown>;
+
+/**
+ * The bubble menu's item pipeline: what the editor registered, what the
+ * selection is, and what the consumer asked for, resolved into the finished
+ * list a menu renders.
+ *
+ * It lives in core because four surfaces need it and each of them is only a
+ * renderer. Vanilla, React, Vue and Angular each carried their own copy of
+ * every function below, four transcriptions of one algorithm kept in step by
+ * hand. They did not stay in step: the separator cleanup that this module now
+ * ends with had to be written four times to fix one defect, which is the
+ * clearest argument that the algorithm was never theirs to hold.
+ *
+ * ProseMirror shapes are duck-typed here rather than imported. A selection or
+ * a schema can arrive from a different copy of prosemirror-state, and
+ * `instanceof` across two copies is false for objects that are otherwise
+ * identical; reading the fields is the check that survives it.
+ */
+
+interface ResolvedPosShape {
+    parent: {
+        type: {
+            name: string;
+            spec: {
+                marks?: string;
+            };
+        };
+    };
+    depth: number;
+    node: (depth: number) => {
+        type: {
+            name: string;
+        };
+    };
+}
+interface SelectionShape {
+    empty: boolean;
+    $from: ResolvedPosShape;
+    $to: ResolvedPosShape;
+    node?: {
+        type: {
+            name: string;
+        };
+    };
+}
+interface BubbleMenuSeparator {
+    type: 'separator';
+    name: string;
+}
+type BubbleMenuItem = ToolbarButton | ToolbarDropdown | BubbleMenuSeparator;
+/**
+ * What a consumer may say about one context: an explicit name list, `true`
+ * for every formatting mark the schema allows there, or `null` for no menu.
+ */
+type BubbleContexts = Record<string, string[] | true | null>;
+interface BubbleItemMaps {
+    itemMap: Map<string, ToolbarButton>;
+    dropdownMap: Map<string, ToolbarDropdown>;
+    /** Bubble defaults indexed by context name (e.g. 'text', 'codeBlock'). */
+    bubbleDefaults: Map<string, BubbleMenuItem[]>;
+}
+/**
+ * Walks `editor.toolbarItems` and indexes them by name. Dropdowns are kept
+ * separately so the bubble menu can resolve them by name (e.g. text-align).
+ *
+ * A dropdown's children are indexed as buttons as well, which is what lets a
+ * consumer name one alignment directly instead of the whole dropdown.
+ */
+declare function buildBubbleItemMaps(editor: Editor): BubbleItemMaps;
+/**
+ * Resolve a name array to BubbleMenuItems via the item/dropdown maps.
+ * Dropdowns take priority over buttons sharing the same name. Pipe `|`
+ * tokens become separator entries.
+ *
+ * A name the editor does not carry is skipped, which is what lets one list
+ * serve every build: a default naming `ai` shows it where the Pro extension
+ * is installed and says nothing where it is not. The separator beside such a
+ * name is not skipped with it, because a `|` always resolves; that is what
+ * `collapseSeparators` is for, and why it has to run after this rather than
+ * inside it.
+ */
+declare function resolveBubbleNames(names: string[], itemMap: Map<string, ToolbarButton>, dropdownMap: Map<string, ToolbarDropdown>): BubbleMenuItem[];
+/**
+ * All `format`-group buttons sorted by priority (used by the `true` shorthand
+ * to show "all format marks for this context").
+ */
+declare function getBubbleFormatItems(itemMap: Map<string, ToolbarButton>): ToolbarButton[];
+/**
+ * Determine the active bubble-menu context based on the selection. Returns
+ * `null` when no context matches (menu should not show).
+ *
+ * Resolution order:
+ * 1. CellSelection (`$anchorCell`) - no menu inside table cell selections
+ * 2. NodeSelection (image, HR, etc.) - return the node's type name
+ * 3. Empty selection - no context (caret-only)
+ * 4. Inside a table cell - return 'table' (when from/to share a cell)
+ * 5. `$from.parent.type.name` if listed in contexts
+ * 6. 'text' if the parent allows marks
+ */
+declare function detectBubbleContext(selection: SelectionShape, ctxs: BubbleContexts): string | null;
+/**
+ * Filter items by what the schema actually allows in the given context.
+ * E.g. inside a `codeBlock` node, marks like Bold/Italic aren't permitted.
+ *
+ * Pass-through for 'text' and 'table' contexts (schema check would be
+ * lossy there because marks are allowed but some items still apply).
+ */
+declare function filterBubbleItemsBySchema(editor: Editor, contextName: string, schemaItems: ToolbarButton[]): ToolbarButton[];
+/** Detect whether `$pos` is inside a table cell (cell or header). */
+declare function isInsideTableCell($pos: ResolvedPosShape): boolean;
+interface ResolveBubbleMenuItemsOptions {
+    editor: Editor;
+    maps: BubbleItemMaps;
+    /** The consumer's `contexts`, or undefined for the fixed-list path. */
+    contexts?: BubbleContexts | undefined;
+    /**
+     * The list to show when `contexts` is absent and the selection is not a
+     * node the editor registered a default for. Already resolved, because it
+     * never changes with the selection.
+     */
+    fallbackItems: BubbleMenuItem[];
+}
+/**
+ * The whole decision, in one place: which list this selection gets, filtered
+ * by what the schema allows, with the orphaned separators removed.
+ *
+ * The cleanup is the last step rather than a step inside name resolution
+ * because filtering removes items too: a selection inside a node type that
+ * refuses a mark strands a separator exactly the way a missing extension
+ * does, and only decides it per transaction.
+ */
+declare function resolveBubbleMenuItems(options: ResolveBubbleMenuItemsOptions): BubbleMenuItem[];
+/**
+ * The default `shouldShow`, which has to agree with the resolution above:
+ * a menu that opens on a selection resolving to nothing is an empty box, and
+ * one that stays shut on a selection with items is a feature nobody can
+ * reach.
+ */
+declare function createBubbleShouldShow(maps: BubbleItemMaps, contexts?: BubbleContexts): BubbleMenuOptions['shouldShow'];
+
+/**
+ * Two packages disagreeing about which copy of `module` they use.
+ *
+ * `message` is the whole story, already formatted: what broke, why it cannot
+ * work, and the one-line fix for each package manager and bundler. Callers
+ * decide only whether to warn or throw.
+ */
+interface ProseMirrorCopyConflict {
+    /** Package whose copies disagree, e.g. `prosemirror-model`. */
+    module: string;
+    /** Package that registered the copy the page settled on. */
+    firstConsumer: string;
+    /** Package that arrived with a different one. */
+    secondConsumer: string;
+    /** Ready-to-print explanation and fix. */
+    message: string;
+}
+/**
+ * Records which copy of `module` a package is using, and reports a conflict
+ * when that disagrees with the copy already registered.
+ *
+ * Returns `null` on the first registration and on every later one that
+ * matches, so the happy path costs one `Map` lookup. Registering a conflicting
+ * copy does NOT replace the recorded one: the first registration wins, which
+ * keeps `firstConsumer` stable no matter how many latecomers arrive.
+ *
+ * @param module Package name, e.g. `prosemirror-model`.
+ * @param copy An export of that package, the same one for every caller. See
+ *   the contract in this file's header.
+ * @param consumer Package doing the registering, used in the message.
+ */
+declare function registerProseMirrorCopy(module: string, copy: object, consumer: string): ProseMirrorCopyConflict | null;
+/**
+ * Registers a copy and throws when it conflicts.
+ *
+ * For the call sites where a duplicate is already fatal and the only question
+ * is which error the developer reads: the collaboration binding, for one,
+ * throws `Can not convert <> to a Fragment` from inside y-prosemirror one call
+ * later, naming neither package involved.
  *
- * A focused element is treated as such a popover when it sits inside a
- * `[data-dm-editor-ui]` element that is NOT the toolbar / bubble-menu / floating-
- * menu chrome and is not inside the contenteditable. To opt in, a popover must
- * render outside those surfaces, carry `data-dm-editor-ui`, and focus itself
- * synchronously while the opening command dispatches (so `activeElement` reflects
- * it before this frame runs).
+ * @throws ExtensionConfigurationError so `new Editor(...)` fails loudly rather
+ *   than being swallowed by the per-extension error isolation.
  */
-declare function refocusEditorAfterCommand(view: {
-    dom: Element;
-    focus: () => void;
-}): void;
-
+declare function assertSingleProseMirrorCopy(module: string, copy: object, consumer: string): void;
 /**
- * Default `contexts` map for a bubble menu when the consumer has not
- * supplied one. Returns a richer item set when the editor (or any
- * ancestor) carries the `.dm-notion-mode` class - that class is the
- * project-wide signal that the host is rendering Notion-style UX, so
- * the bubble menu mirrors it by leading with `ai` and including `link`
- * and `textAlign`.
+ * Registers a copy and warns once per module, for call sites where a duplicate
+ * is a strong signal but not necessarily fatal yet: two editors built from two
+ * copies of the core work fine until a node crosses between them.
  *
- * Consumers can always override by passing their own `contexts` prop.
+ * Deduped through `globalThis` as well, so a page holding two copies of this
+ * module still prints one warning rather than one per editor per copy.
  */
-declare function defaultBubbleContexts(editor: Editor): Record<string, string[]>;
+declare function warnOnDuplicateProseMirrorCopy(module: string, copy: object, consumer: string): ProseMirrorCopyConflict | null;
 
 interface InsertAsListItemChildArgs {
     /** Existing transaction to mutate. Caller dispatches. */
@@ -3440,168 +4008,6 @@ declare const findChildren: (node: Node$1, predicate: (node: Node$1) => boolean)
 
 declare const defaultBlockAt: (match: ContentMatch) => NodeType | null;
 
-/**
- * Extension - Base class for all extensions
- *
- * Extensions provide functionality without contributing to the schema.
- * For schema contributions, use Node (for block/inline nodes) or Mark (for inline formatting).
- *
- * Three-tier model:
- * - Extension (type: 'extension') → Pure functionality (History, Placeholder, etc.)
- * - Node (type: 'node') → Schema nodes (Paragraph, Heading, etc.)
- * - Mark (type: 'mark') → Schema marks (Bold, Italic, etc.)
- *
- * @example
- * const History = Extension.create({
- *   name: 'history',
- *   addOptions() {
- *     return { depth: 100 };
- *   },
- *   addKeyboardShortcuts() {
- *     return {
- *       'Mod-z': () => this.editor.commands.undo(),
- *       'Mod-Shift-z': () => this.editor.commands.redo(),
- *     };
- *   },
- * });
- */
-
-/**
- * Editor interface for Extension
- * Forward declaration to avoid circular dependency
- */
-interface ExtensionEditorInterface {
-    readonly state: EditorState;
-    readonly view: EditorView;
-    readonly schema: unknown;
-    readonly commands: SingleCommands;
-}
-/**
- * Base class for all extensions
- *
- * @typeParam Options - Extension options type
- * @typeParam Storage - Extension storage type
- */
-declare class Extension<Options = unknown, Storage = unknown> {
-    /**
-     * Extension type identifier
-     * Used to distinguish between Extension, Node, and Mark
-     * Subclasses override this to 'node' or 'mark'
-     */
-    readonly type: 'extension' | 'node' | 'mark';
-    /**
-     * Unique extension name
-     */
-    readonly name: string;
-    /**
-     * Extension options (immutable after creation)
-     */
-    readonly options: Options;
-    /**
-     * Extension storage (mutable state)
-     * Accessible via editor.storage[extensionName]
-     */
-    storage: Storage;
-    /**
-     * The original configuration object
-     */
-    readonly config: ExtensionConfig<Options, Storage>;
-    /**
-     * Editor instance (set by ExtensionManager after creation)
-     * null until ExtensionManager binds it
-     */
-    editor: ExtensionEditorInterface | null;
-    /**
-     * Reference to the parent config method when using extend().
-     * Set temporarily during config method execution so overridden
-     * methods can call `this.parent?.()` to invoke the original.
-     */
-    parent?: ((...args: unknown[]) => unknown) | undefined;
-    /**
-     * Protected constructor - use Extension.create() instead
-     */
-    protected constructor(config: ExtensionConfig<Options, Storage>);
-    /**
-     * Creates a new extension instance
-     *
-     * @param config - Extension configuration
-     * @returns New extension instance
-     *
-     * @example
-     * const MyExtension = Extension.create({
-     *   name: 'myExtension',
-     *   addOptions() {
-     *     return { enabled: true };
-     *   },
-     * });
-     */
-    static create<O = unknown, S = unknown>(config: ExtensionConfig<O, S>): Extension<O, S>;
-    /**
-     * Creates a new extension with merged options
-     * Original extension is not modified
-     *
-     * **Note:** Options are merged shallowly using object spread (`...`).
-     * Nested objects are replaced entirely, not deeply merged.
-     *
-     * @param options - Options to merge with existing options
-     * @returns New extension instance with merged options
-     *
-     * @example
-     * const configured = MyExtension.configure({ enabled: false });
-     *
-     * @example
-     * // Shallow merge behavior with nested objects:
-     * // Given: options = { nested: { a: 1, b: 2 } }
-     * // configure({ nested: { b: 3 } })
-     * // Result: { nested: { b: 3 } } - 'a' is lost!
-     * // To preserve nested values, spread manually:
-     * // configure({ nested: { ...original.options.nested, b: 3 } })
-     */
-    configure(options: Partial<Options>): Extension<Options, Storage>;
-    /**
-     * Returns a fresh, unbound copy built from the same `config`: `editor` reset to
-     * null and `options`/`storage` re-derived, while `configure()`/`extend()`
-     * results are preserved (they live in `config`). Polymorphic: a `Node`/`Mark`
-     * clones to its own subclass.
-     *
-     * `ExtensionManager` clones every extension so each editor owns its instances
-     * and binding one editor can't mutate extensions shared with another.
-     */
-    clone(): Extension<Options, Storage>;
-    /**
-     * Creates a new extension with extended configuration
-     * Original extension is not modified
-     *
-     * **Note:** Config is merged shallowly using object spread (`...`).
-     * Config properties (like `addCommands`, `addKeyboardShortcuts`) are
-     * replaced entirely, not combined with the base extension's config.
-     *
-     * @param extendedConfig - Configuration to extend/override
-     * @returns New extension instance with extended config
-     *
-     * @example
-     * const Extended = MyExtension.extend({
-     *   name: 'extendedExtension',
-     *   addCommands() {
-     *     return { customCommand: () => ({ tr }) => true };
-     *   },
-     * });
-     *
-     * @example
-     * // To preserve base extension's commands while adding new ones:
-     * const Extended = BaseExtension.extend({
-     *   addCommands() {
-     *     const baseCommands = BaseExtension.config.addCommands?.call(this) ?? {};
-     *     return {
-     *       ...baseCommands,
-     *       newCommand: () => ({ tr }) => true,
-     *     };
-     *   },
-     * });
-     */
-    extend<ExtendedOptions = Options, ExtendedStorage = Storage>(extendedConfig: Partial<ExtensionConfigBase<ExtendedOptions, ExtendedStorage>> & ThisType<ExtensionContext<ExtendedOptions, ExtendedStorage>>): Extension<ExtendedOptions, ExtendedStorage>;
-}
-
 /**
  * Node - Base class for node extensions
  *
@@ -3922,6 +4328,10 @@ interface FloatingMenuGroup {
  * order of groups. Within each group, items are sorted by `priority`
  * descending (higher first, default 100).
  *
+ * An item with NO group leads: declining a category marks a primary action,
+ * and insertion order would file it last, since whatever adds one loads after
+ * the extensions defining the categories. Renderers give it no heading.
+ *
  * Shared between `FloatingMenuController` (which renders grouped item lists
  * for FloatingMenu + framework wrappers) and `createSlashSuggestionRenderer`
  * (the popup shown by SlashCommand). Having one implementation keeps visual
@@ -6303,69 +6713,70 @@ declare const NotionColorPicker: Extension<NotionColorPickerOptions, NotionColor
 
 declare const ClearFormatting: Extension<unknown, unknown>;
 
-interface LinkPopoverOptions {
-    /**
-     * List of allowed URL protocols (should match Link mark's protocols)
-     * @default ['http:', 'https:', 'mailto:', 'tel:']
-     */
-    protocols: string[];
-}
-declare const LinkPopover: Extension<LinkPopoverOptions, unknown>;
-
 /**
- * Floating menu shown when text is selected. Contextual formatting toolbar.
+ * Print Extension
+ *
+ * Sends the document to the browser's own print dialog, which is also the
+ * one place a reader can save a PDF that looks exactly like the editor:
+ * the same engine paints both, so floats, columns and fonts survive
+ * untouched. What it cannot do is hand a file back to code, so it
+ * complements a file exporter rather than replacing one.
+ *
+ * The paper styling itself lives in `@domternal/theme` (`_print.scss`) and
+ * applies to the reader's own Ctrl/Cmd+P with no code involved. This
+ * extension adds the two things CSS cannot do on its own: a button, and
+ * isolating the document from the host application's chrome.
+ *
+ * @example
+ * ```ts
+ * import { Print } from '@domternal/core';
+ *
+ * const editor = new Editor({ extensions: [Print] });
+ * editor.commands.printDocument();
+ * ```
  */
 
-declare const bubbleMenuPluginKey: PluginKey<any>;
-interface BubbleMenuOptions {
-    /**
-     * The HTML element that contains the menu.
-     * Must be provided by the user.
-     */
-    element: HTMLElement | null;
-    /**
-     * Duration in ms to wait before showing the menu.
-     * @default 0
-     */
-    updateDelay: number;
+interface PrintOptions {
+    /** Show the toolbar button. @default true */
+    toolbar: boolean;
     /**
-     * Function to determine if the menu should be shown.
-     * By default, shows for text selections with actual content in an editable editor.
+     * Resolve the element to print. Defaults to the editor's `.dm-editor`
+     * wrapper, falling back to the ProseMirror element itself.
      */
-    shouldShow: (props: {
-        editor: Editor;
-        view: EditorView;
-        state: EditorState;
-        from: number;
-        to: number;
-    }) => boolean;
+    root: ((editor: ExtensionEditor) => HTMLElement | null) | null;
     /**
-     * Placement of the menu relative to the selection.
-     * @default 'top'
+     * Also isolate the document when the reader presses Ctrl/Cmd+P instead of
+     * using the command.
+     *
+     * Off by default, and deliberately: isolating means erasing everything
+     * else on the page. That is obviously right for an app that IS the
+     * editor, and obviously wrong for an article with an editor embedded in
+     * it, and only the host knows which one it is. With it off, a native
+     * print still gets the whole paper stylesheet, just not the erasure.
+     *
+     * @default false
      */
-    placement: 'top' | 'bottom';
+    isolateNativePrint: boolean;
+}
+interface PrintStorage {
+    /** Removes the native print listeners; set only when they were attached. */
+    cleanup: (() => void) | null;
+}
+declare const Print: Extension<PrintOptions, PrintStorage>;
+declare module '@domternal/core' {
+    interface RawCommands {
+        printDocument: CommandSpec;
+    }
+}
+
+interface LinkPopoverOptions {
     /**
-     * Offset in pixels from the selection.
-     * @default 8
+     * List of allowed URL protocols (should match Link mark's protocols)
+     * @default ['http:', 'https:', 'mailto:', 'tel:']
      */
-    offset: number;
-}
-interface CreateBubbleMenuPluginOptions {
-    pluginKey: PluginKey;
-    editor: Editor;
-    element: HTMLElement;
-    shouldShow?: BubbleMenuOptions['shouldShow'];
-    placement?: 'top' | 'bottom';
-    offset?: number;
-    updateDelay?: number;
+    protocols: string[];
 }
-/**
- * Creates a standalone BubbleMenu ProseMirror plugin.
- * Can be used by framework wrappers (Angular, React, Vue) to create the plugin
- * independently of the extension system.
- */
-declare function createBubbleMenuPlugin(options: CreateBubbleMenuPluginOptions): Plugin;
-declare const BubbleMenu: Extension<BubbleMenuOptions, unknown>;
+declare const LinkPopover: Extension<LinkPopoverOptions, unknown>;
 
 /**
  * StarterKit Extension
@@ -6502,6 +6913,6 @@ declare const StarterKit: Extension<StarterKitOptions, unknown>;
  * @domternal/core
  * Framework-agnostic ProseMirror editor engine
  */
-declare const VERSION = "0.14.0";
+declare const VERSION = "1.0.0";
 
-export { type AnyExtension, type AnyExtensionConfig, type AttributeSpec, type AttributeSpecs, type AutolinkPluginOptions, BaseKeymap, type BaseKeymapOptions, BlockColor, type BlockColorOptions, Blockquote, type BlockquoteOptions, Bold, type BoldOptions, BubbleMenu, type BubbleMenuOptions, type BuildCommandPropsOptions, BulletList, type BulletListOptions, type CanChainedCommands, CanChecker, type CanCheckerEditor, type CanCheckerOptions, type CanCommands, ChainBuilder, type ChainBuilderEditor, type ChainBuilderOptions, type ChainFailure, type ChainedCommands, CharacterCount, type CharacterCountOptions, type CharacterCountStorage, type ClearContentOptions, ClearFormatting, Code, CodeBlock, type CodeBlockOptions, type CodeOptions, type Command, type CommandEditor, CommandManager, type CommandManagerEditor, type CommandMap, type CommandProps, type CommandPropsEditor, type CommandSpec, type Content, type ContentErrorProps, type CreateBubbleMenuPluginOptions, type CreateDocumentOptions, type CreateEventProps, type CreateFloatingMenuPluginOptions, DEFAULT_BLOCK_COLORS, DEFAULT_BLOCK_COLOR_TYPES, DEFAULT_HIGHLIGHT_COLORS, DEFAULT_NOTION_COLOR_PALETTE, DEFAULT_TEXT_COLORS, Document$1 as Document, Dropcursor, type DropcursorOptions, Editor, type EditorEventName, type EditorEvents, type EditorInstance, type EditorOptions, EventEmitter, Extension, type ExtensionConfig, type ExtensionConfigBase, ExtensionConfigurationError, type ExtensionEditor, ExtensionManager, type ExtensionManagerEditor, type ExtensionManagerOptions, FLOATING_MENU_META, FLOATING_MENU_NO_FOCUS, type FindChildResult, type FindParentNodeResult, FloatingMenuController, type FloatingMenuGroup, type FloatingMenuItem, type FloatingMenuItemsOverride, type FloatingMenuKeymap, type FloatingMenuOptions, Focus, type FocusEventProps, type FocusOptions, type FocusPosition, FontFamily, type FontFamilyOptions, FontSize, type FontSizeOptions, Gapcursor, type GenerateHTMLOptions, type GenerateJSONOptions, type GenerateTextOptions, type GlobalAttributeSpec, type GlobalAttributes, HardBreak, type HardBreakOptions, Heading, type HeadingOptions, Highlight, type HighlightOptions, History, type HistoryOptions, HorizontalRule, type HorizontalRuleOptions, type IconSet, type InlineStyleOverrides, type InsertAsListItemChildArgs, type InsertAsListItemChildResult, InvisibleChars, type InvisibleCharsOptions, type InvisibleCharsStorage, type IsNodeEmptyOptions, type IsValidUrlOptions, Italic, type ItalicOptions, type JSONAttribute, type JSONContent, type JSONMark, type KeyboardShortcutCommand, LIST_ITEM_TYPE_NAMES, LineHeight, type LineHeightOptions, Link, type LinkAttributes, type LinkClickPluginOptions, type LinkExitPluginOptions, type LinkOptions, type LinkPastePluginOptions, LinkPopover, type LinkPopoverOptions, ListIndent, ListItem, type ListItemCursorContext, type ListItemOptions, ListKeymap, type ListKeymapOptions, Mark, type MarkConfig, type MarkInputRuleOptions, type MarkParseRule, type MarkRange, type MarkRenderHTMLProps, type MountEventProps, Node, type NodeConfig, type NodeInputRuleOptions, type NodeParseRule, type NodeRenderHTMLProps, type NodeViewContext, NotionColorPicker, type NotionColorPickerOptions, type NotionColorPickerStorage, OrderedList, type OrderedListOptions, Paragraph, type ParagraphOptions, Placeholder, type PlaceholderOptions, type PositionFloatingOptions, type Range, type RawCommands, Selection, SelectionDecoration, type SelectionDecorationOptions, type SelectionOptions, type SelectionStorage, type SetContentOptions, type SingleCommands, type SplitListForInsertRange, StarterKit, type StarterKitOptions, Strike, type StrikeOptions, Subscript, type SubscriptOptions, Superscript, type SuperscriptOptions, TaskItem, type TaskItemOptions, TaskList, type TaskListOptions, Text, TextAlign, type TextAlignOptions, TextColor, type TextColorOptions, type TextInputRuleOptions, TextStyle, type TextStyleOptions, type TextblockTypeInputRuleOptions, type ToolbarButton, ToolbarController, type ToolbarControllerEditor, type ToolbarDropdown, type ToolbarGroup, type ToolbarItem, type ToolbarLayoutDropdown, type ToolbarLayoutEntry, type ToolbarSeparator, TrailingNode, type TrailingNodeOptions, type TransactionEventProps, Typography, type TypographyOptions, Underline, type UnderlineOptions, UniqueID, type UniqueIDOptions, VERSION, type WrappingInputRuleOptions, announce, applyInlineStyles, autolinkPlugin, autolinkPluginKey, blur, bubbleMenuPluginKey, buildCommandProps, builtInCommands, callOrReturn, characterCountPluginKey, clearContent, copyThemeClass, createAccumulatingDispatch, createBubbleMenuPlugin, createCanChecker, createChainBuilder, createDocument, createFloatingMenuPlugin, defaultBlockAt, defaultBubbleContexts, defaultFloatingMenuShouldShow, defaultIcons, deleteSelection, findChildren, findListItemAncestorDepth, findParentNode, floatingMenuPluginKey, focus, focusPluginKey, generateHTML, generateJSON, generateText, getListItemCursorContext, getMarkRange, groupFloatingMenuItems, hideFloatingMenu, indentBlockAsListChild, inlineStyles, insertAsListItemChild, insertChildrenZoneSibling, insertContent, insertText, invisibleCharsPluginKey, isDocumentEmpty, isInListItemLabel, isInsideListItem, isNodeEmpty, isValidUrl, lift, liftCurrentListItem, liftEmptyChildrenZoneParagraph, linkClickPlugin, linkClickPluginKey, linkExitPlugin, linkExitPluginKey, linkPastePlugin, linkPastePluginKey, markInputRule, markInputRulePatterns, nodeInputRule, outdentBlockFromListItem, placeholderPluginKey, positionFloating, positionFloatingOnce, refocusEditorAfterCommand, resetAttributes, selectAll, selectNodeBackward, selectionDecorationPluginKey, setBlockType, setContent, setMark, showFloatingMenu, splitListForInsert, stripInlineColorConflicts, textInputRule, textblockTypeInputRule, toggleBlockType, toggleList, toggleMark, toggleWrap, uniqueIDPluginKey, unsetAllMarks, unsetMark, updateAttributes, wrapIn, wrappingInputRule, writeToClipboard };
+export { type AnyExtension, type AnyExtensionConfig, type AttributeSpec, type AttributeSpecs, type AutolinkPluginOptions, BaseKeymap, type BaseKeymapOptions, BlockColor, type BlockColorOptions, Blockquote, type BlockquoteOptions, Bold, type BoldOptions, type BubbleContexts, type BubbleItemMaps, BubbleMenu, type BubbleMenuItem, type BubbleMenuOptions, type BubbleMenuSeparator, type BuildCommandPropsOptions, BulletList, type BulletListOptions, type CanChainedCommands, CanChecker, type CanCheckerEditor, type CanCheckerOptions, type CanCommands, ChainBuilder, type ChainBuilderEditor, type ChainBuilderOptions, type ChainFailure, type ChainedCommands, CharacterCount, type CharacterCountOptions, type CharacterCountStorage, type ClearContentOptions, ClearFormatting, Code, CodeBlock, type CodeBlockOptions, type CodeOptions, type Command, type CommandEditor, CommandManager, type CommandManagerEditor, type CommandMap, type CommandProps, type CommandPropsEditor, type CommandSpec, type Content, type ContentErrorProps, type CreateBubbleMenuPluginOptions, type CreateDocumentOptions, type CreateEventProps, type CreateFloatingMenuPluginOptions, DEFAULT_BLOCK_COLORS, DEFAULT_BLOCK_COLOR_TYPES, DEFAULT_HIGHLIGHT_COLORS, DEFAULT_NOTION_COLOR_PALETTE, DEFAULT_TEXT_COLORS, Document$1 as Document, Dropcursor, type DropcursorOptions, Editor, type EditorEventName, type EditorEvents, type EditorInstance, type EditorOptions, type EditorPreset, EventEmitter, Extension, type ExtensionConfig, type ExtensionConfigBase, ExtensionConfigurationError, type ExtensionEditor, ExtensionManager, type ExtensionManagerEditor, type ExtensionManagerOptions, FLOATING_MENU_META, FLOATING_MENU_NO_FOCUS, type FindChildResult, type FindParentNodeResult, FloatingMenuController, type FloatingMenuGroup, type FloatingMenuItem, type FloatingMenuItemsOverride, type FloatingMenuKeymap, type FloatingMenuOptions, Focus, type FocusEventProps, type FocusOptions, type FocusPosition, FontFamily, type FontFamilyOptions, FontSize, type FontSizeOptions, Gapcursor, type GenerateHTMLOptions, type GenerateJSONOptions, type GenerateTextOptions, type GlobalAttributeSpec, type GlobalAttributes, HardBreak, type HardBreakOptions, Heading, type HeadingOptions, Highlight, type HighlightOptions, History, type HistoryOptions, HorizontalRule, type HorizontalRuleOptions, type IconSet, type InlineStyleOverrides, type InsertAsListItemChildArgs, type InsertAsListItemChildResult, InvisibleChars, type InvisibleCharsOptions, type InvisibleCharsStorage, type IsNodeEmptyOptions, type IsValidUrlOptions, Italic, type ItalicOptions, type JSONAttribute, type JSONContent, type JSONMark, type KeyboardShortcutCommand, LIST_ITEM_TYPE_NAMES, LineHeight, type LineHeightOptions, Link, type LinkAttributes, type LinkClickPluginOptions, type LinkExitPluginOptions, type LinkOptions, type LinkPastePluginOptions, LinkPopover, type LinkPopoverOptions, ListIndent, ListItem, type ListItemCursorContext, type ListItemOptions, ListKeymap, type ListKeymapOptions, Mark, type MarkConfig, type MarkInputRuleOptions, type MarkParseRule, type MarkRange, type MarkRenderHTMLProps, type MountEventProps, Node, type NodeConfig, type NodeInputRuleOptions, type NodeParseRule, type NodeRenderHTMLProps, type NodeViewContext, NotionColorPicker, type NotionColorPickerOptions, type NotionColorPickerStorage, OrderedList, type OrderedListOptions, Paragraph, type ParagraphOptions, Placeholder, type PlaceholderOptions, type PositionFloatingOptions, Print, type PrintOptions, type PrintStorage, type ProseMirrorCopyConflict, type Range, type RawCommands, type ResolveBubbleMenuItemsOptions, type ResolvedPosShape, Selection, SelectionDecoration, type SelectionDecorationOptions, type SelectionOptions, type SelectionShape, type SelectionStorage, type SetContentOptions, type SingleCommands, type SplitListForInsertRange, StarterKit, type StarterKitOptions, Strike, type StrikeOptions, Subscript, type SubscriptOptions, Superscript, type SuperscriptOptions, TaskItem, type TaskItemOptions, TaskList, type TaskListOptions, Text, TextAlign, type TextAlignOptions, TextColor, type TextColorOptions, type TextInputRuleOptions, TextStyle, type TextStyleOptions, type TextblockTypeInputRuleOptions, type ToolbarButton, ToolbarController, type ToolbarControllerEditor, type ToolbarDropdown, type ToolbarGroup, type ToolbarItem, type ToolbarLayoutDropdown, type ToolbarLayoutEntry, type ToolbarSeparator, TrailingNode, type TrailingNodeOptions, type TransactionEventProps, Typography, type TypographyOptions, Underline, type UnderlineOptions, UniqueID, type UniqueIDOptions, VERSION, type WrappingInputRuleOptions, announce, applyInlineStyles, assertSingleProseMirrorCopy, autolinkPlugin, autolinkPluginKey, blur, bubbleMenuPluginKey, buildBubbleItemMaps, buildCommandProps, builtInCommands, callOrReturn, characterCountPluginKey, clearContent, collapseSeparators, copyThemeClass, createAccumulatingDispatch, createBubbleMenuPlugin, createBubbleShouldShow, createCanChecker, createChainBuilder, createDocument, createFloatingMenuPlugin, defaultBlockAt, defaultBubbleContexts, defaultFloatingMenuShouldShow, defaultIcons, deleteSelection, detectBubbleContext, filterBubbleItemsBySchema, findChildren, findListItemAncestorDepth, findParentNode, floatingMenuPluginKey, focus, focusPluginKey, generateHTML, generateJSON, generateText, getBubbleFormatItems, getListItemCursorContext, getMarkRange, groupFloatingMenuItems, hideFloatingMenu, indentBlockAsListChild, inlineStyles, insertAsListItemChild, insertChildrenZoneSibling, insertContent, insertText, invisibleCharsPluginKey, isDocumentEmpty, isInListItemLabel, isInsideListItem, isInsideTableCell, isNodeEmpty, isValidUrl, lift, liftCurrentListItem, liftEmptyChildrenZoneParagraph, linkClickPlugin, linkClickPluginKey, linkExitPlugin, linkExitPluginKey, linkPastePlugin, linkPastePluginKey, markInputRule, markInputRulePatterns, nodeInputRule, outdentBlockFromListItem, placeholderPluginKey, positionFloating, positionFloatingOnce, refocusEditorAfterCommand, registerProseMirrorCopy, resetAttributes, resolveBubbleMenuItems, resolveBubbleNames, selectAll, selectNodeBackward, selectionDecorationPluginKey, setBlockType, setContent, setMark, showFloatingMenu, splitListForInsert, stripInlineColorConflicts, textInputRule, textblockTypeInputRule, toggleBlockType, toggleList, toggleMark, toggleWrap, uniqueIDPluginKey, unsetAllMarks, unsetMark, updateAttributes, warnOnDuplicateProseMirrorCopy, wrapIn, wrappingInputRule, writeToClipboard };