@domternal/core 0.14.0 → 1.0.0

package/dist/index.js

@@ -2,10 +2,10 @@ import { PluginKey, Plugin, TextSelection, Selection, NodeSelection, AllSelectio
 export { PluginKey } from '@domternal/pm/state';
 import { DecorationSet, Decoration, EditorView } from '@domternal/pm/view';
 import { Slice, Fragment, Schema, Node as Node$1, DOMSerializer, DOMParser } from '@domternal/pm/model';
+import { canJoin, canSplit, findWrapping, liftTarget, Transform } from '@domternal/pm/transform';
 import { keymap } from '@domternal/pm/keymap';
 import { splitBlock, chainCommands, newlineInCode, createParagraphNear, liftEmptyBlock, baseKeymap, selectNodeBackward as selectNodeBackward$1 } from '@domternal/pm/commands';
 import { InputRule } from '@domternal/pm/inputrules';
-import { canJoin, canSplit, findWrapping, liftTarget } from '@domternal/pm/transform';
 import { liftListItem, sinkListItem, splitListItem, wrapRangeInList } from '@domternal/pm/schema-list';
 import { autoUpdate, hide, offset, size, flip, shift, computePosition } from '@floating-ui/dom';
 import { find } from 'linkifyjs';
@@ -224,6 +224,90 @@ var ExtensionConfigurationError = class extends Error {
   }
 };
 
+// src/utils/prosemirrorSingleton.ts
+var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("domternal.prosemirror.copies");
+var REPORTED_KEY = /* @__PURE__ */ Symbol.for("domternal.prosemirror.copies.reported");
+function registry() {
+  const host = globalThis;
+  const existing = host[REGISTRY_KEY];
+  if (existing instanceof Map) return existing;
+  const fresh = /* @__PURE__ */ new Map();
+  host[REGISTRY_KEY] = fresh;
+  return fresh;
+}
+function reported() {
+  const host = globalThis;
+  const existing = host[REPORTED_KEY];
+  if (existing instanceof Set) return existing;
+  const fresh = /* @__PURE__ */ new Set();
+  host[REPORTED_KEY] = fresh;
+  return fresh;
+}
+var FIXES = [
+  'pnpm:    add the package to "pnpm.overrides" in package.json, then run `pnpm dedupe`',
+  'npm:     add the package to "overrides" in package.json, then reinstall',
+  'yarn:    add the package to "resolutions" in package.json, then reinstall',
+  "Vite:    depend on '<module>' in the app, then resolve.dedupe: ['<module>']",
+  "webpack: depend on '<module>' in the app, then resolve.alias it to that one copy"
+];
+var DOCS_URL = "https://domternal.dev/v1/guides/single-prosemirror-copy/";
+function describeConflict(module, first, second) {
+  return [
+    `Two different copies of "${module}" are loaded on this page.`,
+    `"${first}" registered one, "${second}" arrived with another.`,
+    "ProseMirror compares classes by identity, so objects made by one copy are",
+    "rejected by the other and the editor fails as soon as the two meet.",
+    "",
+    "Force a single copy:",
+    ...FIXES.map((line) => `  ${line.replaceAll("<module>", module)}`),
+    "",
+    DOCS_URL
+  ].join("\n");
+}
+function describeForeignExtension(name) {
+  return [
+    `The extension "${name}" was built by a different copy of "@domternal/core"`,
+    "than the one building this editor.",
+    "Extensions are bound to the core that created them: their base class, schema",
+    "and plugin keys all belong to that copy, so an editor cannot use one built",
+    "elsewhere. Two copies usually mean a linked or nested install.",
+    "",
+    "Force a single copy:",
+    ...FIXES.map((line) => `  ${line.replaceAll("<module>", "@domternal/core")}`),
+    "",
+    DOCS_URL
+  ].join("\n");
+}
+function registerProseMirrorCopy(module, copy, consumer) {
+  const entries = registry();
+  const existing = entries.get(module);
+  if (!existing) {
+    entries.set(module, { copy, consumer });
+    return null;
+  }
+  if (existing.copy === copy) return null;
+  return {
+    module,
+    firstConsumer: existing.consumer,
+    secondConsumer: consumer,
+    message: describeConflict(module, existing.consumer, consumer)
+  };
+}
+function assertSingleProseMirrorCopy(module, copy, consumer) {
+  const conflict = registerProseMirrorCopy(module, copy, consumer);
+  if (conflict) throw new ExtensionConfigurationError(conflict.message);
+}
+function warnOnDuplicateProseMirrorCopy(module, copy, consumer) {
+  const conflict = registerProseMirrorCopy(module, copy, consumer);
+  if (!conflict) return null;
+  const seen = reported();
+  if (!seen.has(module)) {
+    seen.add(module);
+    console.warn(conflict.message);
+  }
+  return conflict;
+}
+
 // src/helpers/callOrReturn.ts
 function callOrReturn(value, context, ...args) {
   if (typeof value === "function") {
@@ -232,6 +316,183 @@ function callOrReturn(value, context, ...args) {
   return value;
 }
 
+// src/Extension.ts
+function mergeConfigWithParentBinding(parentConfig, extendedConfig) {
+  const parent = parentConfig;
+  const merged = { ...parent };
+  for (const [key, value] of Object.entries(extendedConfig)) {
+    if (typeof value === "function" && typeof parent[key] === "function") {
+      const parentFn = parent[key];
+      const childFn = value;
+      merged[key] = function(...args) {
+        const previousParent = this.parent;
+        this.parent = (...pArgs) => parentFn.call(this, ...pArgs);
+        const result = childFn.call(this, ...args);
+        this.parent = previousParent;
+        return result;
+      };
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+var EXTENSION_BRAND = /* @__PURE__ */ Symbol.for("domternal.core.extension");
+var Extension = class _Extension {
+  /**
+   * Brand read by `ExtensionManager` to tell an extension built by another
+   * copy of `@domternal/core` from a plain object. See `EXTENSION_BRAND`.
+   */
+  [EXTENSION_BRAND] = true;
+  /**
+   * Extension type identifier
+   * Used to distinguish between Extension, Node, and Mark
+   * Subclasses override this to 'node' or 'mark'
+   */
+  type = "extension";
+  /**
+   * Unique extension name
+   */
+  name;
+  /**
+   * Extension options (immutable after creation)
+   */
+  options;
+  /**
+   * Extension storage (mutable state)
+   * Accessible via editor.storage[extensionName]
+   */
+  storage;
+  /**
+   * The original configuration object
+   */
+  config;
+  /**
+   * Editor instance (set by ExtensionManager after creation)
+   * null until ExtensionManager binds it
+   */
+  editor = 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;
+  /**
+   * Protected constructor - use Extension.create() instead
+   */
+  constructor(config) {
+    if (!/^[a-z][a-zA-Z0-9]*$/.test(config.name)) {
+      throw new Error(
+        `Extension name '${config.name}' is invalid. Names must be camelCase starting with a lowercase letter (e.g., 'myExtension').`
+      );
+    }
+    this.config = config;
+    this.name = config.name;
+    const defaultOptions = callOrReturn(config.addOptions, this);
+    this.options = defaultOptions ?? {};
+    const defaultStorage = callOrReturn(config.addStorage, this);
+    this.storage = defaultStorage ?? {};
+  }
+  /**
+   * 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(config) {
+    return new _Extension(config);
+  }
+  /**
+   * 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) {
+    const newConfig = {
+      ...this.config,
+      // Override addOptions to return merged options
+      addOptions: () => ({
+        ...this.options,
+        ...options
+      })
+    };
+    return new _Extension(newConfig);
+  }
+  /**
+   * 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() {
+    const Ctor = this.constructor;
+    return new Ctor(this.config);
+  }
+  /**
+   * 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(extendedConfig) {
+    const newConfig = mergeConfigWithParentBinding(this.config, extendedConfig);
+    return new _Extension(newConfig);
+  }
+};
+
 // src/ExtensionManager.ts
 function mergeHTMLAttrs(target, source) {
   const result = { ...target };
@@ -246,6 +507,13 @@ function mergeHTMLAttrs(target, source) {
   }
   return result;
 }
+function assertOwnExtension(ext) {
+  if (ext instanceof Extension) return;
+  const foreign = ext?.[EXTENSION_BRAND];
+  if (foreign !== true) return;
+  const name = typeof ext.name === "string" ? ext.name : "unknown";
+  throw new ExtensionConfigurationError(describeForeignExtension(name));
+}
 var ExtensionManager = class {
   /**
    * Processed extensions (flattened, sorted by priority)
@@ -305,8 +573,9 @@ var ExtensionManager = class {
         "ExtensionManager requires either extensions or schema. Provide at least Document, Text, and Paragraph extensions."
       );
     }
-    const flattened = this.flattenExtensions(options.extensions);
-    const deduped = this.deduplicateExtensions(flattened);
+    const autoIncluded = /* @__PURE__ */ new Set();
+    const flattened = this.flattenExtensions(options.extensions, autoIncluded);
+    const deduped = this.deduplicateExtensions(flattened, autoIncluded);
     const cloned = this.cloneExtensions(deduped);
     this._extensions = this.resolveExtensions(cloned);
     this.detectConflicts();
@@ -388,33 +657,57 @@ var ExtensionManager = class {
   /**
    * 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.
    */
-  flattenExtensions(extensions) {
+  flattenExtensions(extensions, autoIncluded, fromBundle = false) {
     const result = [];
     for (const ext of extensions) {
+      assertOwnExtension(ext);
+      if (fromBundle) autoIncluded.add(ext);
       result.push(ext);
       const nested = callOrReturn(
         ext.config.addExtensions,
         ext
       );
       if (nested && nested.length > 0) {
-        result.push(...this.flattenExtensions(nested));
+        result.push(...this.flattenExtensions(nested, autoIncluded, true));
       }
     }
     return result;
   }
   /**
-   * 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.
    */
-  deduplicateExtensions(extensions) {
-    const seen = /* @__PURE__ */ new Map();
+  deduplicateExtensions(extensions, autoIncluded) {
+    const winners = /* @__PURE__ */ new Map();
     for (let i = 0; i < extensions.length; i++) {
       const ext = extensions[i];
-      if (ext) seen.set(ext.name, i);
+      if (!ext) continue;
+      const held = winners.get(ext.name);
+      if (held === void 0) {
+        winners.set(ext.name, i);
+        continue;
+      }
+      const heldIsAuto = autoIncluded.has(extensions[held]);
+      const nextIsAuto = autoIncluded.has(ext);
+      if (nextIsAuto && !heldIsAuto) continue;
+      winners.set(ext.name, i);
     }
-    return extensions.filter((ext, i) => seen.get(ext.name) === i);
+    return extensions.filter((ext, i) => winners.get(ext.name) === i);
   }
   /**
    * Clone every extension so this editor owns its instances. Extensions hold
@@ -1139,7 +1432,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;
@@ -1231,7 +1525,10 @@ function textInputRule(options) {
   const { find: find2, replace, undoable } = options;
   return new 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 } : {}
   );
 }
@@ -1469,177 +1766,6 @@ var insertContent = (content) => ({ state, tr, dispatch }) => {
   return true;
 };
 
-// src/Extension.ts
-function mergeConfigWithParentBinding(parentConfig, extendedConfig) {
-  const parent = parentConfig;
-  const merged = { ...parent };
-  for (const [key, value] of Object.entries(extendedConfig)) {
-    if (typeof value === "function" && typeof parent[key] === "function") {
-      const parentFn = parent[key];
-      const childFn = value;
-      merged[key] = function(...args) {
-        const previousParent = this.parent;
-        this.parent = (...pArgs) => parentFn.call(this, ...pArgs);
-        const result = childFn.call(this, ...args);
-        this.parent = previousParent;
-        return result;
-      };
-    } else {
-      merged[key] = value;
-    }
-  }
-  return merged;
-}
-var Extension = class _Extension {
-  /**
-   * Extension type identifier
-   * Used to distinguish between Extension, Node, and Mark
-   * Subclasses override this to 'node' or 'mark'
-   */
-  type = "extension";
-  /**
-   * Unique extension name
-   */
-  name;
-  /**
-   * Extension options (immutable after creation)
-   */
-  options;
-  /**
-   * Extension storage (mutable state)
-   * Accessible via editor.storage[extensionName]
-   */
-  storage;
-  /**
-   * The original configuration object
-   */
-  config;
-  /**
-   * Editor instance (set by ExtensionManager after creation)
-   * null until ExtensionManager binds it
-   */
-  editor = 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;
-  /**
-   * Protected constructor - use Extension.create() instead
-   */
-  constructor(config) {
-    if (!/^[a-z][a-zA-Z0-9]*$/.test(config.name)) {
-      throw new Error(
-        `Extension name '${config.name}' is invalid. Names must be camelCase starting with a lowercase letter (e.g., 'myExtension').`
-      );
-    }
-    this.config = config;
-    this.name = config.name;
-    const defaultOptions = callOrReturn(config.addOptions, this);
-    this.options = defaultOptions ?? {};
-    const defaultStorage = callOrReturn(config.addStorage, this);
-    this.storage = defaultStorage ?? {};
-  }
-  /**
-   * 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(config) {
-    return new _Extension(config);
-  }
-  /**
-   * 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) {
-    const newConfig = {
-      ...this.config,
-      // Override addOptions to return merged options
-      addOptions: () => ({
-        ...this.options,
-        ...options
-      })
-    };
-    return new _Extension(newConfig);
-  }
-  /**
-   * 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() {
-    const Ctor = this.constructor;
-    return new Ctor(this.config);
-  }
-  /**
-   * 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(extendedConfig) {
-    const newConfig = mergeConfigWithParentBinding(this.config, extendedConfig);
-    return new _Extension(newConfig);
-  }
-};
-
 // src/helpers/specBuilder.ts
 function buildProseMirrorAttrs(attributeSpecs) {
   const attrs = {};
@@ -1810,6 +1936,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);
@@ -1847,9 +1975,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;
@@ -1942,8 +2070,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;
   }
@@ -2570,12 +2698,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 }
         });
       }
     });
@@ -2621,12 +2749,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 }
         });
       }
     });
@@ -2675,8 +2803,7 @@ var builtInCommands = {
 function buildCommandProps(options) {
   const { editor, tr, dispatch, chain, can, commands } = options;
   return {
-    // Cast required: CommandPropsEditor is a minimal interface, but CommandProps
-    // expects full Editor. Callers ensure the actual editor instance is passed.
+    // CommandPropsEditor is intentionally the minimal shape CommandProps consumes here.
     editor,
     state: editor.view.state,
     tr,
@@ -3104,8 +3231,7 @@ var CommandManager = class {
   buildCommandProps(tr, dispatch) {
     const { editor } = this;
     return {
-      // Cast needed: CommandManagerEditor is a minimal interface for dependency injection,
-      // but CommandProps expects the full Editor type. Callers pass the actual Editor instance.
+      // CommandManagerEditor is intentionally the minimal shape CommandProps consumes here.
       editor,
       state: editor.state,
       tr,
@@ -3257,6 +3383,17 @@ function resolveOverrides(overrides) {
   if (!overrides) return DEFAULTS;
   return { ...DEFAULTS, ...overrides };
 }
+var BULLET_MARKERS = ["disc", "circle", "square"];
+var ORDERED_MARKERS = ["decimal", "lower-alpha", "lower-roman"];
+function listMarkerDepth(el, container) {
+  let depth = 0;
+  for (let parent = el.parentElement; parent !== null && parent !== container; parent = parent.parentElement) {
+    const tag = parent.tagName;
+    if (tag === "TD" || tag === "TH") break;
+    if (tag === "UL" || tag === "OL") depth += 1;
+  }
+  return depth;
+}
 function applyInlineStyles(container, overrides) {
   const v = resolveOverrides(overrides);
   if (overrides?.codeHighlighter) {
@@ -3338,16 +3475,27 @@ function applyInlineStyles(container, overrides) {
       case "H6":
         styles = "font-size: 0.9em; font-weight: 700; line-height: 1.25; margin: 1.5em 0 0.5em;";
         break;
+      // `type` is not a schema attribute on either list node, so no document
+      // this editor produced carries one.
       case "UL":
         if (el.getAttribute("data-type") === "taskList") {
           styles = "list-style: none; padding-left: 0; margin: 0.75em 0;";
-        } else {
+        } else if (el.hasAttribute("type")) {
           styles = "margin: 0.75em 0; padding-left: 1.5em;";
+        } else {
+          const bullet = BULLET_MARKERS[listMarkerDepth(el, container) % 3] ?? "disc";
+          styles = `margin: 0.75em 0; padding-left: 1.5em; list-style-type: ${bullet};`;
         }
         break;
-      case "OL":
-        styles = "margin: 0.75em 0; padding-left: 1.5em;";
+      case "OL": {
+        if (el.hasAttribute("type")) {
+          styles = "margin: 0.75em 0; padding-left: 1.5em;";
+          break;
+        }
+        const number = ORDERED_MARKERS[listMarkerDepth(el, container) % 3] ?? "decimal";
+        styles = `margin: 0.75em 0; padding-left: 1.5em; list-style-type: ${number};`;
         break;
+      }
       case "LI":
         if (el.getAttribute("data-type") === "taskItem") {
           styles = "display: flex; align-items: flex-start; gap: 0.5em; margin: 0.25em 0;";
@@ -3509,6 +3657,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
    *
@@ -3528,6 +3682,15 @@ var Editor = class _Editor extends EventEmitter {
         "Editor requires either schema or extensions. Provide a ProseMirror schema directly, or use extensions like [Document, Paragraph, Text]."
       );
     }
+    warnOnDuplicateProseMirrorCopy("prosemirror-model", Fragment, "@domternal/core");
+    warnOnDuplicateProseMirrorCopy("prosemirror-state", Plugin, "@domternal/core");
+    warnOnDuplicateProseMirrorCopy("prosemirror-view", EditorView, "@domternal/core");
+    warnOnDuplicateProseMirrorCopy("prosemirror-transform", Transform, "@domternal/core");
+    warnOnDuplicateProseMirrorCopy(
+      "@domternal/core",
+      ExtensionConfigurationError,
+      "@domternal/core"
+    );
     this.options = {
       editable: true,
       ...options
@@ -3553,6 +3716,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
    */
@@ -3638,11 +3838,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;
       }
@@ -3717,8 +3917,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) {
@@ -3785,11 +3985,7 @@ var Editor = class _Editor extends EventEmitter {
    */
   getText(options = {}) {
     const { blockSeparator = "\n\n" } = options;
-    return this.state.doc.textBetween(
-      0,
-      this.state.doc.content.size,
-      blockSeparator
-    );
+    return this.state.doc.textBetween(0, this.state.doc.content.size, blockSeparator);
   }
   /**
    * Executes a command with proper CommandProps
@@ -3899,6 +4095,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();
@@ -3944,10 +4144,7 @@ var Editor = class _Editor extends EventEmitter {
     this._extensionManager.validateSchema();
     let doc;
     try {
-      doc = createDocument(
-        this.options.content ?? null,
-        this._extensionManager.schema
-      );
+      doc = createDocument(this.options.content ?? null, this._extensionManager.schema);
     } catch (error) {
       const contentError = error instanceof Error ? error : new Error(String(error));
       this.emit("contentError", {
@@ -3983,7 +4180,10 @@ var Editor = class _Editor extends EventEmitter {
       }),
       ...Object.keys(nodeViews).length > 0 ? { nodeViews } : {},
       // Clipboard transform - apply user-provided transform (e.g. inlineStyles) on copy/cut
-      ...this.options.clipboardHTMLTransform ? this.buildClipboardSerializer(this.options.clipboardHTMLTransform, this._extensionManager.schema) : {},
+      ...this.options.clipboardHTMLTransform ? this.buildClipboardSerializer(
+        this.options.clipboardHTMLTransform,
+        this._extensionManager.schema
+      ) : {},
       // Handle focus/blur events
       handleDOMEvents: {
         focus: (_view, event) => {
@@ -4001,6 +4201,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);
@@ -4237,22 +4438,20 @@ 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`.
   "ai",
+  "comment",
+  "|",
+  "heading",
+  "|",
+  "link",
   "|",
   "bold",
   "italic",
   "underline",
   "strike",
   "code",
-  "mathInline",
-  "|",
-  "link",
-  "|",
-  "textAlign"
+  "mathInline"
 ]);
 var STANDARD_TEXT_CONTEXT = Object.freeze([
   "bold",
@@ -4265,11 +4464,210 @@ 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] };
 }
 
+// src/utils/collapseSeparators.ts
+function collapseSeparators(items) {
+  const out = [];
+  for (const item of items) {
+    if (item.type !== "separator") {
+      out.push(item);
+      continue;
+    }
+    if (out.length === 0) continue;
+    if (out[out.length - 1]?.type === "separator") continue;
+    out.push(item);
+  }
+  while (out.length > 0 && out[out.length - 1]?.type === "separator") out.pop();
+  return out.length === items.length ? items : out;
+}
+
+// src/utils/bubbleMenuResolver.ts
+function buildBubbleItemMaps(editor) {
+  const itemMap = /* @__PURE__ */ new Map();
+  const dropdownMap = /* @__PURE__ */ new Map();
+  for (const item of editor.toolbarItems) {
+    if (item.type === "button") {
+      itemMap.set(item.name, item);
+    } else if (item.type === "dropdown") {
+      dropdownMap.set(item.name, item);
+      for (const sub of item.items) {
+        itemMap.set(sub.name, sub);
+      }
+    }
+  }
+  return {
+    itemMap,
+    dropdownMap,
+    bubbleDefaults: buildBubbleDefaults(editor)
+  };
+}
+function buildBubbleDefaults(editor) {
+  const byCtx = /* @__PURE__ */ new Map();
+  const addItem = (btn) => {
+    const ctx = btn["bubbleMenu"];
+    if (!ctx) return;
+    let arr = byCtx.get(ctx);
+    if (!arr) {
+      arr = [];
+      byCtx.set(ctx, arr);
+    }
+    arr.push(btn);
+  };
+  for (const item of editor.toolbarItems) {
+    if (item.type === "button") addItem(item);
+    else if (item.type === "dropdown") {
+      for (const sub of item.items) addItem(sub);
+    }
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const [ctx, ctxItems] of byCtx) {
+    ctxItems.sort((a, b) => (b.priority ?? 100) - (a.priority ?? 100));
+    const list = [];
+    let lastGroup;
+    let sepIdx = 0;
+    for (const item of ctxItems) {
+      if (lastGroup !== void 0 && item.group !== lastGroup) {
+        list.push({ type: "separator", name: `bsep-${String(sepIdx++)}` });
+      }
+      list.push(item);
+      lastGroup = item.group;
+    }
+    result.set(ctx, list);
+  }
+  return result;
+}
+function resolveBubbleNames(names, itemMap, dropdownMap) {
+  const result = [];
+  let sepIdx = 0;
+  for (const name of names) {
+    if (name === "|") {
+      result.push({ type: "separator", name: `sep-${String(sepIdx++)}` });
+      continue;
+    }
+    const dropdown = dropdownMap.get(name);
+    if (dropdown) {
+      result.push(dropdown);
+      continue;
+    }
+    const item = itemMap.get(name);
+    if (item) result.push(item);
+  }
+  return result;
+}
+function getBubbleFormatItems(itemMap) {
+  return Array.from(itemMap.values()).filter((item) => item.group === "format").sort((a, b) => (b.priority ?? 100) - (a.priority ?? 100));
+}
+function detectBubbleContext(selection, ctxs) {
+  if ("$anchorCell" in selection) return null;
+  if (selection.node) return selection.node.type.name;
+  if (selection.empty) return null;
+  const fromCell = findCellNode(selection.$from);
+  if (fromCell) {
+    const toCell = findCellNode(selection.$to);
+    if (toCell && fromCell !== toCell) return null;
+    return "table";
+  }
+  const fromName = selection.$from.parent.type.name;
+  if (fromName in ctxs) return fromName;
+  if ("text" in ctxs && selection.$from.parent.type.spec.marks !== "") return "text";
+  const toName = selection.$to.parent.type.name;
+  if (toName in ctxs) return toName;
+  if ("text" in ctxs && selection.$to.parent.type.spec.marks !== "") return "text";
+  return null;
+}
+function filterBubbleItemsBySchema(editor, contextName, schemaItems) {
+  if (contextName === "text" || contextName === "table") return schemaItems;
+  const schema = editor.state.schema;
+  if (!schema) return schemaItems;
+  const nodeType = schema.nodes[contextName];
+  if (!nodeType) return schemaItems;
+  return schemaItems.filter((item) => {
+    const markName = typeof item.isActive === "string" ? item.isActive : null;
+    if (!markName) return true;
+    const markType = schema.marks[markName];
+    if (!markType) return true;
+    return nodeType.allowsMarkType(markType);
+  });
+}
+function isInsideTableCell($pos) {
+  for (let d = $pos.depth; d > 0; d--) {
+    const name = $pos.node(d).type.name;
+    if (name === "tableCell" || name === "tableHeader") return true;
+  }
+  return false;
+}
+function findCellNode(pos) {
+  for (let d = pos.depth; d > 0; d--) {
+    const node = pos.node(d);
+    if (node.type.name === "tableCell" || node.type.name === "tableHeader") return node;
+  }
+  return null;
+}
+function resolveBubbleMenuItems(options) {
+  return collapseSeparators(pickBubbleMenuItems(options));
+}
+function pickBubbleMenuItems({
+  editor,
+  maps,
+  contexts,
+  fallbackItems
+}) {
+  const selection = editor.state.selection;
+  if (contexts) {
+    const ctx = detectBubbleContext(selection, contexts);
+    if (!ctx) return [];
+    if (ctx in contexts) {
+      const val = contexts[ctx];
+      if (val === null || Array.isArray(val) && val.length === 0) return [];
+      if (val === true) {
+        return filterBubbleItemsBySchema(editor, ctx, getBubbleFormatItems(maps.itemMap));
+      }
+      if (Array.isArray(val)) {
+        const resolved = resolveBubbleNames(val, maps.itemMap, maps.dropdownMap);
+        const buttons = resolved.filter(
+          (item) => item.type !== "separator"
+        );
+        const allowed = new Set(
+          filterBubbleItemsBySchema(editor, ctx, buttons).map((item) => item.name)
+        );
+        return resolved.filter(
+          (item) => item.type === "separator" || allowed.has(item.name)
+        );
+      }
+    }
+    return maps.bubbleDefaults.get(ctx) ?? [];
+  }
+  if (selection.node && maps.bubbleDefaults.has(selection.node.type.name)) {
+    return maps.bubbleDefaults.get(selection.node.type.name) ?? [];
+  }
+  return fallbackItems;
+}
+function createBubbleShouldShow(maps, contexts) {
+  if (contexts) {
+    return ({ state }) => {
+      const selection = state.selection;
+      const ctx = detectBubbleContext(selection, contexts);
+      if (!ctx) return false;
+      if (ctx in contexts) {
+        const val = contexts[ctx];
+        if (val === null) return false;
+        return val === true || Array.isArray(val) && val.length > 0;
+      }
+      return maps.bubbleDefaults.has(ctx);
+    };
+  }
+  return ({ state }) => {
+    const selection = state.selection;
+    if (selection.empty) return false;
+    if (selection.node) return maps.bubbleDefaults.has(selection.node.type.name);
+    if (isInsideTableCell(selection.$from)) return false;
+    return selection.$from.parent.type.spec.marks !== "" || selection.$to.parent.type.spec.marks !== "";
+  };
+}
+
 // src/utils/insertAsListItemChild.ts
 var LIST_ITEM_TYPES3 = /* @__PURE__ */ new Set(["listItem", "taskItem"]);
 var LIST_WRAPPER_TYPES2 = /* @__PURE__ */ new Set(["bulletList", "orderedList", "taskList"]);
@@ -5025,7 +5423,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);
   }
@@ -5237,12 +5636,13 @@ var FloatingMenuController = class _FloatingMenuController {
    */
   updateDisabledStates() {
     let changed = false;
-    let canProxy = null;
-    try {
-      canProxy = this.editor.can();
-    } catch {
-      canProxy = null;
-    }
+    const canProxy = (() => {
+      try {
+        return this.editor.can();
+      } catch {
+        return null;
+      }
+    })();
     for (const item of this._flatItems) {
       const was = this._disabledMap.get(item.name) ?? false;
       let now = false;
@@ -5559,7 +5959,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
@@ -7091,6 +7492,7 @@ var TaskList = Node2.create({
 // src/marks/Bold.ts
 var Bold = Mark.create({
   name: "bold",
+  group: "formatting",
   addOptions() {
     return {
       HTMLAttributes: {}
@@ -7168,6 +7570,7 @@ var Bold = Mark.create({
 // src/marks/Italic.ts
 var Italic = Mark.create({
   name: "italic",
+  group: "formatting",
   addOptions() {
     return {
       HTMLAttributes: {}
@@ -7247,6 +7650,7 @@ var Italic = Mark.create({
 // src/marks/Underline.ts
 var Underline = Mark.create({
   name: "underline",
+  group: "formatting",
   addOptions() {
     return {
       HTMLAttributes: {}
@@ -7299,6 +7703,7 @@ var Underline = Mark.create({
 // src/marks/Strike.ts
 var Strike = Mark.create({
   name: "strike",
+  group: "formatting",
   addOptions() {
     return {
       HTMLAttributes: {}
@@ -7370,9 +7775,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() {
@@ -7433,7 +7843,7 @@ function linkClickPlugin(options) {
         if (!view.editable) {
           return false;
         }
-        let link = null;
+        let link;
         if (event.target instanceof HTMLAnchorElement) {
           link = event.target;
         } else {
@@ -7860,6 +8270,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: "",
@@ -7921,6 +8332,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: "",
@@ -7982,6 +8394,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() {
@@ -8038,7 +8451,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(
@@ -8052,9 +8465,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) {
@@ -8559,11 +8972,7 @@ var Typography = Extension.create({
       rules.push(
         new 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(
@@ -8571,12 +8980,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
           );
         })
       );
@@ -8841,6 +9248,9 @@ function generateUUID() {
   });
 }
 var uniqueIDPluginKey = new PluginKey("uniqueID");
+function isWithin(from, to, ranges) {
+  return ranges.some((range) => from >= range.from && to <= range.to);
+}
 var UniqueID = Extension.create({
   name: "uniqueID",
   addOptions() {
@@ -8890,12 +9300,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)) {
@@ -9745,13 +10170,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;
             }
@@ -9798,7 +10223,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,
@@ -10094,6 +10520,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 PluginKey("linkPopover");
 function linkPopoverPlugin({ editor, markType, protocols }) {
   const el = document.createElement("div");
@@ -10431,9 +11004,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;
   };
@@ -10667,8 +11241,8 @@ var StarterKit = Extension.create({
 });
 
 // src/index.ts
-var VERSION = "0.14.0";
+var VERSION = "1.0.0";
 
-export { BaseKeymap, BlockColor, Blockquote, Bold, BubbleMenu, BulletList, CanChecker, ChainBuilder, CharacterCount, ClearFormatting, Code, CodeBlock, CommandManager, DEFAULT_BLOCK_COLORS, DEFAULT_BLOCK_COLOR_TYPES, DEFAULT_HIGHLIGHT_COLORS, DEFAULT_NOTION_COLOR_PALETTE, DEFAULT_TEXT_COLORS, Document, Dropcursor, Editor, EventEmitter, Extension, ExtensionConfigurationError, ExtensionManager, FLOATING_MENU_META, FLOATING_MENU_NO_FOCUS, FloatingMenuController, Focus, FontFamily, FontSize, Gapcursor, HardBreak, Heading, Highlight, History, HorizontalRule, InvisibleChars, Italic, LIST_ITEM_TYPE_NAMES, LineHeight, Link, LinkPopover, ListIndent, ListItem, ListKeymap, Mark, Node2 as Node, NotionColorPicker, OrderedList, Paragraph, Placeholder, Selection5 as Selection, SelectionDecoration, StarterKit, Strike, Subscript, Superscript, TaskItem, TaskList, Text, TextAlign, TextColor, TextStyle, ToolbarController, TrailingNode, Typography, Underline, UniqueID, VERSION, 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 { BaseKeymap, BlockColor, Blockquote, Bold, BubbleMenu, BulletList, CanChecker, ChainBuilder, CharacterCount, ClearFormatting, Code, CodeBlock, CommandManager, DEFAULT_BLOCK_COLORS, DEFAULT_BLOCK_COLOR_TYPES, DEFAULT_HIGHLIGHT_COLORS, DEFAULT_NOTION_COLOR_PALETTE, DEFAULT_TEXT_COLORS, Document, Dropcursor, Editor, EventEmitter, Extension, ExtensionConfigurationError, ExtensionManager, FLOATING_MENU_META, FLOATING_MENU_NO_FOCUS, FloatingMenuController, Focus, FontFamily, FontSize, Gapcursor, HardBreak, Heading, Highlight, History, HorizontalRule, InvisibleChars, Italic, LIST_ITEM_TYPE_NAMES, LineHeight, Link, LinkPopover, ListIndent, ListItem, ListKeymap, Mark, Node2 as Node, NotionColorPicker, OrderedList, Paragraph, Placeholder, Print, Selection5 as Selection, SelectionDecoration, StarterKit, Strike, Subscript, Superscript, TaskItem, TaskList, Text, TextAlign, TextColor, TextStyle, ToolbarController, TrailingNode, Typography, Underline, UniqueID, VERSION, 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 };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map