@domternal/core 0.14.0 → 0.15.0

package/README.md

@@ -78,6 +78,47 @@ const editor = new Editor({
 });
 ```
 
+## Presets
+
+`preset: 'notion'` switches the editor to the Notion-style experience in one option. It paints
+the `dm-notion-mode` class on the `.dm-editor` host for you, and preset-aware code follows it:
+the bubble menu serves the Notion text context, and images offer align controls instead of
+float. `'classic'` is the default.
+
+```ts
+const editor = new Editor({
+  element: document.getElementById('editor')!,
+  extensions: [StarterKit],
+  preset: 'notion',
+});
+```
+
+`editor.preset` reports the resolved value, and still reports `'notion'` for a host that carries
+the theme class alone, so setups that predate the option are unaffected.
+
+## Printing
+
+`Print` is not part of `StarterKit`, so add it explicitly. `printDocument()` isolates the
+document from the host page before the browser's dialog opens, leaving your application's
+sidebar, header, and everything else beside the document off the page, and it emits
+`beforePrint` and `afterPrint` so you can set `document.title` or add page rules first.
+
+```ts
+import { Editor, StarterKit, Print } from '@domternal/core';
+
+const editor = new Editor({
+  element: document.getElementById('editor')!,
+  extensions: [StarterKit, Print],
+});
+
+editor.commands.printDocument();
+```
+
+The hiding itself is CSS, and it lives in
+[`@domternal/theme`](https://www.npmjs.com/package/@domternal/theme), whose paper layer also
+applies to the reader's own Ctrl/Cmd+P with no code involved. Set `isolateNativePrint: true` to
+give that shortcut the same isolation as the command.
+
 ## SSR
 
 The `generateHTML`, `generateJSON`, and `generateText` helpers render content

package/dist/index.cjs

@@ -1140,7 +1140,8 @@ function markInputRule(options) {
         return null;
       }
       const { tr } = state;
-      tr.replaceWith(start, end, state.schema.text(textContent));
+      const marks = tr.storedMarks ?? tr.doc.resolve(start).marksAcross(tr.doc.resolve(end));
+      tr.replaceWith(start, end, state.schema.text(textContent, marks));
       tr.addMark(start, start + textContent.length, type.create(attributes ?? void 0));
       tr.removeStoredMark(type);
       return tr;
@@ -1232,7 +1233,10 @@ function textInputRule(options) {
   const { find: find2, replace, undoable } = options;
   return new inputrules.InputRule(
     find2,
-    (state, _match, start, end) => state.tr.replaceWith(start, end, state.schema.text(replace)),
+    // insertText inherits the replaced range's marks (stored marks first,
+    // then marksAcross), so a replacement inside marked text keeps the
+    // marks instead of punching an unmarked hole into them.
+    (state, _match, start, end) => state.tr.insertText(replace, start, end),
     undoable !== void 0 ? { undoable } : {}
   );
 }
@@ -1811,6 +1815,8 @@ var Mark = class _Mark extends Extension {
     if (this.config.group !== void 0) spec.group = this.config.group;
     if (this.config.spanning !== void 0)
       spec.spanning = this.config.spanning;
+    if (this.config.keepOnDuplicate !== void 0)
+      spec["keepOnDuplicate"] = this.config.keepOnDuplicate;
     const attributeSpecs = callOrReturn(this.config.addAttributes, this);
     if (attributeSpecs) {
       spec.attrs = buildProseMirrorAttrs(attributeSpecs);
@@ -1848,9 +1854,9 @@ var Mark = class _Mark extends Extension {
       const renderFn = this.config.renderHTML;
       const attrSpecs = attributeSpecs;
       const markInstance = this;
-      spec.toDOM = (mark, _inline) => {
-        const htmlAttrs = attrSpecs ? buildHTMLAttributes(mark.attrs, attrSpecs) : {};
-        return renderFn.call(markInstance, { mark, HTMLAttributes: htmlAttrs });
+      spec.toDOM = (mark2, _inline) => {
+        const htmlAttrs = attrSpecs ? buildHTMLAttributes(mark2.attrs, attrSpecs) : {};
+        return renderFn.call(markInstance, { mark: mark2, HTMLAttributes: htmlAttrs });
       };
     }
     return spec;
@@ -1943,8 +1949,8 @@ var setMark = (markName, attributes) => ({ state, tr, dispatch }) => {
     const from = firstRange.$from.pos;
     const existingMark = tr.storedMarks?.find((m) => m.type === markType) ?? state.storedMarks?.find((m) => m.type === markType) ?? tr.doc.resolve(from).marks().find((m) => m.type === markType) ?? null;
     const mergedAttrs = existingMark ? { ...existingMark.attrs, ...attributes } : attributes;
-    const mark = markType.create(mergedAttrs);
-    tr.addStoredMark(mark);
+    const mark2 = markType.create(mergedAttrs);
+    tr.addStoredMark(mark2);
     dispatch(tr);
     return true;
   }
@@ -2571,12 +2577,12 @@ var updateAttributes = (typeOrName, attributes) => ({ state, tr, dispatch }) =>
     const markType = state.schema.marks[typeOrName];
     tr.doc.nodesBetween(from, to, (node, pos) => {
       if (!node.isInline) return;
-      const mark = markType.isInSet(node.marks);
-      if (mark) {
+      const mark2 = markType.isInSet(node.marks);
+      if (mark2) {
         markChanges.push({
           pos,
           nodeSize: node.nodeSize,
-          attrs: { ...mark.attrs, ...attributes }
+          attrs: { ...mark2.attrs, ...attributes }
         });
       }
     });
@@ -2622,12 +2628,12 @@ var resetAttributes = (typeOrName, attributeName) => ({ state, tr, dispatch }) =
     const defaultValue = markType.spec.attrs?.[attributeName]?.default;
     tr.doc.nodesBetween(from, to, (node, pos) => {
       if (!node.isInline) return;
-      const mark = markType.isInSet(node.marks);
-      if (mark) {
+      const mark2 = markType.isInSet(node.marks);
+      if (mark2) {
         markChanges.push({
           pos,
           nodeSize: node.nodeSize,
-          attrs: { ...mark.attrs, [attributeName]: defaultValue }
+          attrs: { ...mark2.attrs, [attributeName]: defaultValue }
         });
       }
     });
@@ -3510,6 +3516,12 @@ var Editor = class _Editor extends EventEmitter {
    * True while EditorView's constructor runs; see buildViewDispatch.
    */
   _isViewConstructing = false;
+  /**
+   * 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.
+   */
+  _presetClassHost = null;
   /**
    * Creates a new Editor instance
    *
@@ -3554,6 +3566,43 @@ var Editor = class _Editor extends EventEmitter {
   get isEditable() {
     return this.view ? this.view.editable : this.options.editable ?? true;
   }
+  /**
+   * 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() {
+    if (this.options.preset) {
+      return this.options.preset;
+    }
+    if (this.view?.dom.closest(".dm-notion-mode")) {
+      return "notion";
+    }
+    return "classic";
+  }
+  /**
+   * 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() {
+    if (this.options.preset !== "notion" || this._presetClassHost) {
+      return;
+    }
+    const host = this.view.dom.closest(".dm-editor");
+    if (host && !host.classList.contains("dm-notion-mode")) {
+      host.classList.add("dm-notion-mode");
+      this._presetClassHost = host;
+    }
+  }
   /**
    * Checks if the editor content is empty
    */
@@ -3639,11 +3688,11 @@ var Editor = class _Editor extends EventEmitter {
     if (markType) {
       if (selection.empty) {
         const storedMarks = state.storedMarks ?? $from.marks();
-        const hasMark = storedMarks.some((mark) => mark.type === markType);
+        const hasMark = storedMarks.some((mark2) => mark2.type === markType);
         if (!hasMark) return false;
         if (attrs) {
-          const mark = storedMarks.find((m) => m.type === markType);
-          return mark ? this.matchAttributes(mark.attrs, attrs) : false;
+          const mark2 = storedMarks.find((m) => m.type === markType);
+          return mark2 ? this.matchAttributes(mark2.attrs, attrs) : false;
         }
         return true;
       }
@@ -3718,8 +3767,8 @@ var Editor = class _Editor extends EventEmitter {
     const markType = schema.marks[name];
     if (markType) {
       const marks = state.storedMarks ?? $from.marks();
-      const mark = marks.find((m) => m.type === markType);
-      return mark ? { ...mark.attrs } : {};
+      const mark2 = marks.find((m) => m.type === markType);
+      return mark2 ? { ...mark2.attrs } : {};
     }
     const nodeType = schema.nodes[name];
     if (nodeType) {
@@ -3900,6 +3949,10 @@ var Editor = class _Editor extends EventEmitter {
     }
     this.emit("destroy");
     this.options.onDestroy?.();
+    if (this._presetClassHost) {
+      this._presetClassHost.classList.remove("dm-notion-mode");
+      this._presetClassHost = null;
+    }
     this.view.destroy();
     this._extensionManager.destroy();
     this.removeAllListeners();
@@ -4002,6 +4055,7 @@ var Editor = class _Editor extends EventEmitter {
       }
     });
     this._isViewConstructing = false;
+    this.adoptPresetClass();
     this.emit("mount", { editor: this, view: this.view });
     this.options.onMount?.({ editor: this, view: this.view });
     this.commandManager = new CommandManager(this);
@@ -4238,7 +4292,6 @@ function refocusEditorAfterCommand(view) {
 }
 
 // src/utils/defaultBubbleContexts.ts
-var NOTION_MODE_CLASS = "dm-notion-mode";
 var NOTION_TEXT_CONTEXT = Object.freeze([
   // `ai` leads (Notion's "Ask AI"); skipped with its leading separator when
   // the pro extension is absent, exactly like `mathInline`.
@@ -4266,8 +4319,7 @@ var STANDARD_TEXT_CONTEXT = Object.freeze([
   "link"
 ]);
 function defaultBubbleContexts(editor) {
-  const inNotionMode = editor.view.dom.closest("." + NOTION_MODE_CLASS) !== null;
-  const text = inNotionMode ? NOTION_TEXT_CONTEXT : STANDARD_TEXT_CONTEXT;
+  const text = editor.preset === "notion" ? NOTION_TEXT_CONTEXT : STANDARD_TEXT_CONTEXT;
   return { text: [...text] };
 }
 
@@ -5026,7 +5078,8 @@ function groupFloatingMenuItems(items) {
     if (!list) {
       list = [];
       map.set(name, list);
-      order.push(name);
+      if (name === "") order.unshift(name);
+      else order.push(name);
     }
     list.push(item);
   }
@@ -5560,7 +5613,8 @@ var defaultIcons = {
   plus: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor"><path d="M224,128a8,8,0,0,1-8,8H136v80a8,8,0,0,1-16,0V136H40a8,8,0,0,1,0-16h80V40a8,8,0,0,1,16,0v80h80A8,8,0,0,1,224,128Z"/></svg>',
   dotsSixVertical: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor"><path d="M108,60A16,16,0,1,1,92,44,16,16,0,0,1,108,60Zm56,16A16,16,0,1,0,148,60,16,16,0,0,0,164,76ZM92,112a16,16,0,1,0,16,16A16,16,0,0,0,92,112Zm72,0a16,16,0,1,0,16,16A16,16,0,0,0,164,112ZM92,180a16,16,0,1,0,16,16A16,16,0,0,0,92,180Zm72,0a16,16,0,1,0,16,16A16,16,0,0,0,164,180Z"/></svg>',
   dotsThree: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor"><path d="M140,128a12,12,0,1,1-12-12A12,12,0,0,1,140,128ZM64,116a12,12,0,1,0,12,12A12,12,0,0,0,64,116Zm128,0a12,12,0,1,0,12,12A12,12,0,0,0,192,116Z"/></svg>',
-  copy: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor"><path d="M216,32H88a8,8,0,0,0-8,8V80H40a8,8,0,0,0-8,8V216a8,8,0,0,0,8,8H168a8,8,0,0,0,8-8V176h40a8,8,0,0,0,8-8V40A8,8,0,0,0,216,32ZM160,208H48V96H160Zm48-48H176V88a8,8,0,0,0-8-8H96V48H208Z"/></svg>'
+  copy: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor"><path d="M216,32H88a8,8,0,0,0-8,8V80H40a8,8,0,0,0-8,8V216a8,8,0,0,0,8,8H168a8,8,0,0,0,8-8V176h40a8,8,0,0,0,8-8V40A8,8,0,0,0,216,32ZM160,208H48V96H160Zm48-48H176V88a8,8,0,0,0-8-8H96V48H208Z"/></svg>',
+  printer: '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 256 256" fill="currentColor"><path d="M214.67,72H200V40a8,8,0,0,0-8-8H64a8,8,0,0,0-8,8V72H41.33C27.36,72,16,82.77,16,96v80a8,8,0,0,0,8,8H56v32a8,8,0,0,0,8,8H192a8,8,0,0,0,8-8V184h32a8,8,0,0,0,8-8V96C240,82.77,228.64,72,214.67,72ZM72,48H184V72H72ZM184,208H72V160H184Zm40-40H200V152a8,8,0,0,0-8-8H64a8,8,0,0,0-8,8v16H32V96c0-4.34,4.28-8,9.33-8H214.67c5.05,0,9.33,3.66,9.33,8Zm-24-52a12,12,0,1,1-12-12A12,12,0,0,1,200,116Z"/></svg>'
 };
 
 // src/nodes/Document.ts
@@ -7092,6 +7146,7 @@ var TaskList = Node2.create({
 // src/marks/Bold.ts
 var Bold = Mark.create({
   name: "bold",
+  group: "formatting",
   addOptions() {
     return {
       HTMLAttributes: {}
@@ -7169,6 +7224,7 @@ var Bold = Mark.create({
 // src/marks/Italic.ts
 var Italic = Mark.create({
   name: "italic",
+  group: "formatting",
   addOptions() {
     return {
       HTMLAttributes: {}
@@ -7248,6 +7304,7 @@ var Italic = Mark.create({
 // src/marks/Underline.ts
 var Underline = Mark.create({
   name: "underline",
+  group: "formatting",
   addOptions() {
     return {
       HTMLAttributes: {}
@@ -7300,6 +7357,7 @@ var Underline = Mark.create({
 // src/marks/Strike.ts
 var Strike = Mark.create({
   name: "strike",
+  group: "formatting",
   addOptions() {
     return {
       HTMLAttributes: {}
@@ -7371,9 +7429,14 @@ var Code = Mark.create({
       HTMLAttributes: {}
     };
   },
-  // Code mark is exclusive - it cannot be combined with other marks
-  // ProseMirror uses '_' to mean "exclude all marks"
-  excludes: "_",
+  // Code cannot be combined with other FORMATTING marks (bold, italic,
+  // color...), but semantic marks outside the group (link, a comment
+  // thread anchor) survive: code excludes the 'formatting' group instead
+  // of '_' (everything). Third-party formatting marks opt into the same
+  // exclusion by declaring group: 'formatting'. Code is in the group
+  // itself, which also keeps it self-exclusive.
+  group: "formatting",
+  excludes: "formatting",
   // Code should not span across multiple nodes
   spanning: false,
   parseHTML() {
@@ -7861,6 +7924,7 @@ var Link = Mark.create({
 // src/marks/Subscript.ts
 var Subscript = Mark.create({
   name: "subscript",
+  group: "formatting",
   // Mutual exclusion handled in toggle commands (not schema)
   // so can() dry-run works correctly for toolbar disabled state
   excludes: "",
@@ -7922,6 +7986,7 @@ var Subscript = Mark.create({
 // src/marks/Superscript.ts
 var Superscript = Mark.create({
   name: "superscript",
+  group: "formatting",
   // Mutual exclusion handled in toggle commands (not schema)
   // so can() dry-run works correctly for toolbar disabled state
   excludes: "",
@@ -7983,6 +8048,7 @@ var Superscript = Mark.create({
 // src/marks/TextStyle.ts
 var TextStyle = Mark.create({
   name: "textStyle",
+  group: "formatting",
   // Lower priority so it renders after other marks
   priority: 101,
   addOptions() {
@@ -8039,7 +8105,7 @@ var TextStyle = Mark.create({
         let hasEmptyTextStyle = false;
         tr.doc.nodesBetween(from, to, (node) => {
           const textStyleMark = node.marks.find(
-            (mark) => mark.type.name === this.name
+            (mark2) => mark2.type.name === this.name
           );
           if (textStyleMark) {
             const hasNonNullAttr = Object.values(textStyleMark.attrs).some(
@@ -8053,9 +8119,9 @@ var TextStyle = Mark.create({
         if (!hasEmptyTextStyle) return false;
         if (dispatch) {
           tr.doc.nodesBetween(from, to, (node, pos) => {
-            const mark = node.marks.find((m) => m.type === markType);
-            if (mark) {
-              const hasActiveAttr = Object.values(mark.attrs).some(
+            const mark2 = node.marks.find((m) => m.type === markType);
+            if (mark2) {
+              const hasActiveAttr = Object.values(mark2.attrs).some(
                 (v) => v !== null && v !== void 0
               );
               if (!hasActiveAttr) {
@@ -8560,11 +8626,7 @@ var Typography = Extension.create({
       rules.push(
         new inputrules.InputRule(/"([^"]+)"$/, (state, match, start, end) => {
           const text = match[1] ?? "";
-          return state.tr.replaceWith(
-            start,
-            end,
-            state.schema.text(openDoubleQuote + text + closeDoubleQuote)
-          );
+          return state.tr.insertText(openDoubleQuote + text + closeDoubleQuote, start, end);
         })
       );
       rules.push(
@@ -8572,12 +8634,10 @@ var Typography = Extension.create({
           const text = match[1] ?? "";
           const prefix = match[0].charAt(0);
           const hasPrefix = prefix !== "'";
-          return state.tr.replaceWith(
+          return state.tr.insertText(
+            hasPrefix ? prefix + openSingleQuote + text + closeSingleQuote : openSingleQuote + text + closeSingleQuote,
             start,
-            end,
-            state.schema.text(
-              hasPrefix ? prefix + openSingleQuote + text + closeSingleQuote : openSingleQuote + text + closeSingleQuote
-            )
+            end
           );
         })
       );
@@ -8842,6 +8902,9 @@ function generateUUID() {
   });
 }
 var uniqueIDPluginKey = new state.PluginKey("uniqueID");
+function isWithin(from, to, ranges) {
+  return ranges.some((range) => from >= range.from && to <= range.to);
+}
 var UniqueID = Extension.create({
   name: "uniqueID",
   addOptions() {
@@ -8891,12 +8954,27 @@ var UniqueID = Extension.create({
   addProseMirrorPlugins() {
     const { types, attributeName, generateID, filterDuplicates } = this.options;
     const editor = this.editor;
+    const replacedRanges = (view) => {
+      if (view?.dragging) return [];
+      const ranges = view?.state?.selection?.ranges;
+      if (ranges === void 0) return [];
+      const replaced = [];
+      for (const range of ranges) {
+        if (range.$to.pos > range.$from.pos) {
+          replaced.push({ from: range.$from.pos, to: range.$to.pos });
+        }
+      }
+      return replaced;
+    };
     const transformPastedSlice = (slice, view) => {
       if (view?.dragging?.move === true) return slice;
       const existingIDs = /* @__PURE__ */ new Set();
-      editor?.state.doc.descendants((node) => {
+      const replaced = replacedRanges(view);
+      editor?.state.doc.descendants((node, pos) => {
+        if (isWithin(pos, pos + node.nodeSize, replaced)) return false;
         const id = node.attrs[attributeName];
         if (id) existingIDs.add(id);
+        return true;
       });
       const transformNode = (node) => {
         if (!types.includes(node.type.name)) {
@@ -9746,13 +9824,13 @@ var Highlight = Extension.create({
         let hasHighlight = false;
         if (empty) {
           const marks = state.storedMarks ?? state.doc.resolve(from).marks();
-          const mark = markType.isInSet(marks);
-          hasHighlight = !!mark?.attrs["backgroundColor"] || !!mark?.attrs["backgroundColorToken"];
+          const mark2 = markType.isInSet(marks);
+          hasHighlight = !!mark2?.attrs["backgroundColor"] || !!mark2?.attrs["backgroundColorToken"];
         } else {
           state.doc.nodesBetween(from, to, (node) => {
             if (hasHighlight) return false;
-            const mark = markType.isInSet(node.marks);
-            if (mark?.attrs["backgroundColor"] || mark?.attrs["backgroundColorToken"]) {
+            const mark2 = markType.isInSet(node.marks);
+            if (mark2?.attrs["backgroundColor"] || mark2?.attrs["backgroundColorToken"]) {
               hasHighlight = true;
               return false;
             }
@@ -9799,7 +9877,8 @@ var Highlight = Extension.create({
           const content = match[1];
           if (!content) return null;
           const { tr } = state;
-          tr.replaceWith(start, end, state.schema.text(content));
+          const marks = tr.storedMarks ?? tr.doc.resolve(start).marksAcross(tr.doc.resolve(end));
+          tr.replaceWith(start, end, state.schema.text(content, marks));
           tr.addMark(
             start,
             start + content.length,
@@ -10095,6 +10174,153 @@ var ClearFormatting = Extension.create({
     ];
   }
 });
+
+// src/extensions/Print.ts
+var ROOT_CLASS = "dm-print-root";
+var ANCESTOR_CLASS = "dm-print-ancestor";
+var PRINTING_CLASS = "dm-printing";
+var marked = /* @__PURE__ */ new Set();
+var printing = false;
+var Print = Extension.create({
+  name: "print",
+  addOptions() {
+    return {
+      toolbar: true,
+      root: null,
+      isolateNativePrint: false
+    };
+  },
+  addStorage() {
+    return { cleanup: null };
+  },
+  addCommands() {
+    return {
+      printDocument: () => ({ dispatch }) => {
+        if (!dispatch) return true;
+        const editor = this.editor;
+        if (!editor || typeof window === "undefined") return false;
+        const root = resolveRoot(editor, this.options.root);
+        if (!root) return false;
+        mark(root);
+        try {
+          emit(editor, "beforePrint", { root });
+          window.print();
+        } finally {
+          unmark();
+          emit(editor, "afterPrint", void 0);
+        }
+        return true;
+      }
+    };
+  },
+  addToolbarItems() {
+    if (!this.options.toolbar) return [];
+    return [
+      {
+        type: "button",
+        name: "print",
+        command: "printDocument",
+        icon: "printer",
+        label: "Print",
+        shortcut: "Mod-P",
+        group: "document",
+        priority: 100,
+        // Reading a document out to paper is not editing it, so the button
+        // stays live in a read-only editor.
+        allowReadOnly: true
+      }
+    ];
+  },
+  addKeyboardShortcuts() {
+    return {
+      // Only bound while the caret is in the editor, which is exactly when
+      // the reader means "print this document" rather than "print this
+      // page". Everywhere else the browser's own Ctrl/Cmd+P is untouched.
+      "Mod-p": () => this.editor?.commands.printDocument() ?? false
+    };
+  },
+  onCreate() {
+    if (!this.options.isolateNativePrint) return;
+    if (typeof window === "undefined") return;
+    const editor = this.editor;
+    if (!editor) return;
+    const resolve = this.options.root;
+    const before = () => {
+      if (printing) return;
+      const root = resolveRoot(editor, resolve);
+      if (!root) return;
+      mark(root);
+      emit(editor, "beforePrint", { root });
+    };
+    const after = () => {
+      if (!printing) return;
+      unmark();
+      emit(editor, "afterPrint", void 0);
+    };
+    window.addEventListener("beforeprint", before);
+    window.addEventListener("afterprint", after);
+    let detachMedia = null;
+    const onMediaChange = (event) => {
+      if (event.matches) before();
+      else after();
+    };
+    if (typeof window.matchMedia === "function") {
+      const media = window.matchMedia("print");
+      if (typeof media.addEventListener === "function") {
+        media.addEventListener("change", onMediaChange);
+        detachMedia = () => {
+          media.removeEventListener("change", onMediaChange);
+        };
+      }
+    }
+    this.storage.cleanup = () => {
+      window.removeEventListener("beforeprint", before);
+      window.removeEventListener("afterprint", after);
+      detachMedia?.();
+    };
+  },
+  onDestroy() {
+    this.storage.cleanup?.();
+    this.storage.cleanup = null;
+    unmark();
+  }
+});
+function resolveRoot(editor, resolve) {
+  if (resolve) return resolve(editor);
+  const dom = editor.view.dom;
+  return dom.closest(".dm-editor") ?? dom;
+}
+function mark(root) {
+  root.classList.add(ROOT_CLASS);
+  marked.add(root);
+  let node = parentOf(root);
+  while (node) {
+    node.classList.add(ANCESTOR_CLASS);
+    marked.add(node);
+    node = parentOf(node);
+  }
+  document.body.classList.add(PRINTING_CLASS);
+  printing = true;
+}
+function parentOf(node) {
+  if (node.parentElement) return node.parentElement;
+  if (typeof ShadowRoot === "undefined") return null;
+  const root = node.getRootNode();
+  return root instanceof ShadowRoot ? root.host : null;
+}
+function unmark() {
+  printing = false;
+  if (typeof document === "undefined") return;
+  document.body.classList.remove(PRINTING_CLASS);
+  for (const el of marked) {
+    el.classList.remove(ROOT_CLASS, ANCESTOR_CLASS);
+  }
+  marked.clear();
+}
+function emit(editor, name, payload) {
+  const bus = editor;
+  bus.emit?.(name, payload);
+}
 var linkPopoverPluginKey = new state.PluginKey("linkPopover");
 function linkPopoverPlugin({ editor, markType, protocols }) {
   const el = document.createElement("div");
@@ -10432,9 +10658,10 @@ function createBubbleMenuPlugin(options) {
   const onDocumentMousedown = (e) => {
     const target = e.target;
     if (!target) return;
+    if (!target.isConnected) return;
     if (element.contains(target)) return;
     if (editor.view.dom.contains(target)) return;
-    if (target instanceof HTMLElement && target.closest("[data-dm-editor-ui]")) return;
+    if (target instanceof Element && target.closest("[data-dm-editor-ui]")) return;
     hideMenu();
     suppressed = true;
   };
@@ -10668,7 +10895,7 @@ var StarterKit = Extension.create({
 });
 
 // src/index.ts
-var VERSION = "0.14.0";
+var VERSION = "0.15.0";
 
 Object.defineProperty(exports, "PluginKey", {
   enumerable: true,
@@ -10726,6 +10953,7 @@ exports.NotionColorPicker = NotionColorPicker;
 exports.OrderedList = OrderedList;
 exports.Paragraph = Paragraph;
 exports.Placeholder = Placeholder;
+exports.Print = Print;
 exports.Selection = Selection5;
 exports.SelectionDecoration = SelectionDecoration;
 exports.StarterKit = StarterKit;