@domternal/core 0.14.0 → 1.0.0

package/dist/index.cjs

@@ -3,10 +3,10 @@
 var state = require('@domternal/pm/state');
 var view = require('@domternal/pm/view');
 var model = require('@domternal/pm/model');
+var transform = require('@domternal/pm/transform');
 var keymap = require('@domternal/pm/keymap');
 var commands = require('@domternal/pm/commands');
 var inputrules = require('@domternal/pm/inputrules');
-var transform = require('@domternal/pm/transform');
 var schemaList = require('@domternal/pm/schema-list');
 var dom = require('@floating-ui/dom');
 var linkifyjs = require('linkifyjs');
@@ -225,6 +225,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") {
@@ -233,6 +317,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 };
@@ -247,6 +508,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)
@@ -306,8 +574,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();
@@ -389,33 +658,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
@@ -1140,7 +1433,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 +1526,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 } : {}
   );
 }
@@ -1470,177 +1767,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 = {};
@@ -1811,6 +1937,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 +1976,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 +2071,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 +2699,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 +2750,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 }
         });
       }
     });
@@ -2676,8 +2804,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,
@@ -3105,8 +3232,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,
@@ -3258,6 +3384,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) {
@@ -3339,16 +3476,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;";
@@ -3510,6 +3658,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
    *
@@ -3529,6 +3683,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", model.Fragment, "@domternal/core");
+    warnOnDuplicateProseMirrorCopy("prosemirror-state", state.Plugin, "@domternal/core");
+    warnOnDuplicateProseMirrorCopy("prosemirror-view", view.EditorView, "@domternal/core");
+    warnOnDuplicateProseMirrorCopy("prosemirror-transform", transform.Transform, "@domternal/core");
+    warnOnDuplicateProseMirrorCopy(
+      "@domternal/core",
+      ExtensionConfigurationError,
+      "@domternal/core"
+    );
     this.options = {
       editable: true,
       ...options
@@ -3554,6 +3717,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 +3839,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 +3918,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) {
@@ -3786,11 +3986,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
@@ -3900,6 +4096,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();
@@ -3945,10 +4145,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", {
@@ -3984,7 +4181,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) => {
@@ -4002,6 +4202,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,22 +4439,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",
@@ -4266,11 +4465,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"]);
@@ -5026,7 +5424,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);
   }
@@ -5238,12 +5637,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;
@@ -5560,7 +5960,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 +7493,7 @@ var TaskList = Node2.create({
 // src/marks/Bold.ts
 var Bold = Mark.create({
   name: "bold",
+  group: "formatting",
   addOptions() {
     return {
       HTMLAttributes: {}
@@ -7169,6 +7571,7 @@ var Bold = Mark.create({
 // src/marks/Italic.ts
 var Italic = Mark.create({
   name: "italic",
+  group: "formatting",
   addOptions() {
     return {
       HTMLAttributes: {}
@@ -7248,6 +7651,7 @@ var Italic = Mark.create({
 // src/marks/Underline.ts
 var Underline = Mark.create({
   name: "underline",
+  group: "formatting",
   addOptions() {
     return {
       HTMLAttributes: {}
@@ -7300,6 +7704,7 @@ var Underline = Mark.create({
 // src/marks/Strike.ts
 var Strike = Mark.create({
   name: "strike",
+  group: "formatting",
   addOptions() {
     return {
       HTMLAttributes: {}
@@ -7371,9 +7776,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() {
@@ -7434,7 +7844,7 @@ function linkClickPlugin(options) {
         if (!view.editable) {
           return false;
         }
-        let link = null;
+        let link;
         if (event.target instanceof HTMLAnchorElement) {
           link = event.target;
         } else {
@@ -7861,6 +8271,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 +8333,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 +8395,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 +8452,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 +8466,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 +8973,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 +8981,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 +9249,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 +9301,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 +10171,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 +10224,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 +10521,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 +11005,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 +11242,7 @@ var StarterKit = Extension.create({
 });
 
 // src/index.ts
-var VERSION = "0.14.0";
+var VERSION = "1.0.0";
 
 Object.defineProperty(exports, "PluginKey", {
   enumerable: true,
@@ -10726,6 +11300,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;
@@ -10746,18 +11321,22 @@ exports.UniqueID = UniqueID;
 exports.VERSION = VERSION;
 exports.announce = announce;
 exports.applyInlineStyles = applyInlineStyles;
+exports.assertSingleProseMirrorCopy = assertSingleProseMirrorCopy;
 exports.autolinkPlugin = autolinkPlugin;
 exports.autolinkPluginKey = autolinkPluginKey;
 exports.blur = blur;
 exports.bubbleMenuPluginKey = bubbleMenuPluginKey;
+exports.buildBubbleItemMaps = buildBubbleItemMaps;
 exports.buildCommandProps = buildCommandProps;
 exports.builtInCommands = builtInCommands;
 exports.callOrReturn = callOrReturn;
 exports.characterCountPluginKey = characterCountPluginKey;
 exports.clearContent = clearContent;
+exports.collapseSeparators = collapseSeparators;
 exports.copyThemeClass = copyThemeClass;
 exports.createAccumulatingDispatch = createAccumulatingDispatch;
 exports.createBubbleMenuPlugin = createBubbleMenuPlugin;
+exports.createBubbleShouldShow = createBubbleShouldShow;
 exports.createCanChecker = createCanChecker;
 exports.createChainBuilder = createChainBuilder;
 exports.createDocument = createDocument;
@@ -10767,6 +11346,8 @@ exports.defaultBubbleContexts = defaultBubbleContexts;
 exports.defaultFloatingMenuShouldShow = defaultFloatingMenuShouldShow;
 exports.defaultIcons = defaultIcons;
 exports.deleteSelection = deleteSelection;
+exports.detectBubbleContext = detectBubbleContext;
+exports.filterBubbleItemsBySchema = filterBubbleItemsBySchema;
 exports.findChildren = findChildren;
 exports.findListItemAncestorDepth = findListItemAncestorDepth;
 exports.findParentNode = findParentNode;
@@ -10776,6 +11357,7 @@ exports.focusPluginKey = focusPluginKey;
 exports.generateHTML = generateHTML;
 exports.generateJSON = generateJSON;
 exports.generateText = generateText;
+exports.getBubbleFormatItems = getBubbleFormatItems;
 exports.getListItemCursorContext = getListItemCursorContext;
 exports.getMarkRange = getMarkRange;
 exports.groupFloatingMenuItems = groupFloatingMenuItems;
@@ -10790,6 +11372,7 @@ exports.invisibleCharsPluginKey = invisibleCharsPluginKey;
 exports.isDocumentEmpty = isDocumentEmpty;
 exports.isInListItemLabel = isInListItemLabel;
 exports.isInsideListItem = isInsideListItem;
+exports.isInsideTableCell = isInsideTableCell;
 exports.isNodeEmpty = isNodeEmpty;
 exports.isValidUrl = isValidUrl;
 exports.lift = lift;
@@ -10809,7 +11392,10 @@ exports.placeholderPluginKey = placeholderPluginKey;
 exports.positionFloating = positionFloating;
 exports.positionFloatingOnce = positionFloatingOnce;
 exports.refocusEditorAfterCommand = refocusEditorAfterCommand;
+exports.registerProseMirrorCopy = registerProseMirrorCopy;
 exports.resetAttributes = resetAttributes;
+exports.resolveBubbleMenuItems = resolveBubbleMenuItems;
+exports.resolveBubbleNames = resolveBubbleNames;
 exports.selectAll = selectAll;
 exports.selectNodeBackward = selectNodeBackward;
 exports.selectionDecorationPluginKey = selectionDecorationPluginKey;
@@ -10829,6 +11415,7 @@ exports.uniqueIDPluginKey = uniqueIDPluginKey;
 exports.unsetAllMarks = unsetAllMarks;
 exports.unsetMark = unsetMark;
 exports.updateAttributes = updateAttributes;
+exports.warnOnDuplicateProseMirrorCopy = warnOnDuplicateProseMirrorCopy;
 exports.wrapIn = wrapIn;
 exports.wrappingInputRule = wrappingInputRule;
 exports.writeToClipboard = writeToClipboard;