@domternal/core 0.15.0 → 1.0.1

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
@@ -1474,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 = {};
@@ -2682,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,
@@ -3111,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,
@@ -3264,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) {
@@ -3345,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;";
@@ -3541,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
@@ -3835,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
@@ -3998,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", {
@@ -4037,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) => {
@@ -4293,20 +4440,19 @@ function refocusEditorAfterCommand(view) {
 
 // src/utils/defaultBubbleContexts.ts
 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",
@@ -4323,6 +4469,206 @@ function defaultBubbleContexts(editor) {
   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"]);
@@ -5291,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;
@@ -7497,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 {
@@ -10677,10 +11024,10 @@ function createBubbleMenuPlugin(options) {
         from: 0,
         to: 0
       }),
-      apply: (_tr, prevValue, _oldState, newState) => {
+      apply: (tr, prevValue, _oldState, newState) => {
         const { selection } = newState;
         const { from, to } = selection;
-        if (from !== prevValue.from || to !== prevValue.to) {
+        if (tr.selectionSet || from !== prevValue.from || to !== prevValue.to) {
           suppressed = false;
         }
         const visible = !suppressed && !selection.empty && editor.isEditable && shouldShow({
@@ -10765,10 +11112,8 @@ function createBubbleMenuPlugin(options) {
           }
           const state = pluginKey.getState(view.state);
           const prevPluginState = pluginKey.getState(prevState);
-          if (state?.visible === prevPluginState?.visible && state?.from === prevPluginState?.from && state?.to === prevPluginState?.to && !(state?.visible && view.state.doc !== prevState.doc)) {
-            if (!state?.visible && element.hasAttribute("data-show")) {
-              hideMenu();
-            }
+          const domShown = element.hasAttribute("data-show") || updateTimeout !== null;
+          if (state?.visible === prevPluginState?.visible && state?.from === prevPluginState?.from && state?.to === prevPluginState?.to && !(state?.visible && view.state.doc !== prevState.doc) && domShown === Boolean(state?.visible)) {
             return;
           }
           if (updateTimeout) {
@@ -10895,7 +11240,7 @@ var StarterKit = Extension.create({
 });
 
 // src/index.ts
-var VERSION = "0.15.0";
+var VERSION = "1.0.1";
 
 Object.defineProperty(exports, "PluginKey", {
   enumerable: true,
@@ -10974,18 +11319,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;
@@ -10995,6 +11344,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;
@@ -11004,6 +11355,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;
@@ -11018,6 +11370,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;
@@ -11037,7 +11390,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;
@@ -11057,6 +11413,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;