@domternal/core 0.15.0 → 1.0.1

package/dist/index.js

@@ -2,10 +2,10 @@ import { PluginKey, Plugin, TextSelection, Selection, NodeSelection, AllSelectio
 export { PluginKey } from '@domternal/pm/state';
 import { DecorationSet, Decoration, EditorView } from '@domternal/pm/view';
 import { Slice, Fragment, Schema, Node as Node$1, DOMSerializer, DOMParser } from '@domternal/pm/model';
+import { canJoin, canSplit, findWrapping, liftTarget, Transform } from '@domternal/pm/transform';
 import { keymap } from '@domternal/pm/keymap';
 import { splitBlock, chainCommands, newlineInCode, createParagraphNear, liftEmptyBlock, baseKeymap, selectNodeBackward as selectNodeBackward$1 } from '@domternal/pm/commands';
 import { InputRule } from '@domternal/pm/inputrules';
-import { canJoin, canSplit, findWrapping, liftTarget } from '@domternal/pm/transform';
 import { liftListItem, sinkListItem, splitListItem, wrapRangeInList } from '@domternal/pm/schema-list';
 import { autoUpdate, hide, offset, size, flip, shift, computePosition } from '@floating-ui/dom';
 import { find } from 'linkifyjs';
@@ -224,6 +224,90 @@ var ExtensionConfigurationError = class extends Error {
   }
 };
 
+// src/utils/prosemirrorSingleton.ts
+var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("domternal.prosemirror.copies");
+var REPORTED_KEY = /* @__PURE__ */ Symbol.for("domternal.prosemirror.copies.reported");
+function registry() {
+  const host = globalThis;
+  const existing = host[REGISTRY_KEY];
+  if (existing instanceof Map) return existing;
+  const fresh = /* @__PURE__ */ new Map();
+  host[REGISTRY_KEY] = fresh;
+  return fresh;
+}
+function reported() {
+  const host = globalThis;
+  const existing = host[REPORTED_KEY];
+  if (existing instanceof Set) return existing;
+  const fresh = /* @__PURE__ */ new Set();
+  host[REPORTED_KEY] = fresh;
+  return fresh;
+}
+var FIXES = [
+  'pnpm:    add the package to "pnpm.overrides" in package.json, then run `pnpm dedupe`',
+  'npm:     add the package to "overrides" in package.json, then reinstall',
+  'yarn:    add the package to "resolutions" in package.json, then reinstall',
+  "Vite:    depend on '<module>' in the app, then resolve.dedupe: ['<module>']",
+  "webpack: depend on '<module>' in the app, then resolve.alias it to that one copy"
+];
+var DOCS_URL = "https://domternal.dev/v1/guides/single-prosemirror-copy/";
+function describeConflict(module, first, second) {
+  return [
+    `Two different copies of "${module}" are loaded on this page.`,
+    `"${first}" registered one, "${second}" arrived with another.`,
+    "ProseMirror compares classes by identity, so objects made by one copy are",
+    "rejected by the other and the editor fails as soon as the two meet.",
+    "",
+    "Force a single copy:",
+    ...FIXES.map((line) => `  ${line.replaceAll("<module>", module)}`),
+    "",
+    DOCS_URL
+  ].join("\n");
+}
+function describeForeignExtension(name) {
+  return [
+    `The extension "${name}" was built by a different copy of "@domternal/core"`,
+    "than the one building this editor.",
+    "Extensions are bound to the core that created them: their base class, schema",
+    "and plugin keys all belong to that copy, so an editor cannot use one built",
+    "elsewhere. Two copies usually mean a linked or nested install.",
+    "",
+    "Force a single copy:",
+    ...FIXES.map((line) => `  ${line.replaceAll("<module>", "@domternal/core")}`),
+    "",
+    DOCS_URL
+  ].join("\n");
+}
+function registerProseMirrorCopy(module, copy, consumer) {
+  const entries = registry();
+  const existing = entries.get(module);
+  if (!existing) {
+    entries.set(module, { copy, consumer });
+    return null;
+  }
+  if (existing.copy === copy) return null;
+  return {
+    module,
+    firstConsumer: existing.consumer,
+    secondConsumer: consumer,
+    message: describeConflict(module, existing.consumer, consumer)
+  };
+}
+function assertSingleProseMirrorCopy(module, copy, consumer) {
+  const conflict = registerProseMirrorCopy(module, copy, consumer);
+  if (conflict) throw new ExtensionConfigurationError(conflict.message);
+}
+function warnOnDuplicateProseMirrorCopy(module, copy, consumer) {
+  const conflict = registerProseMirrorCopy(module, copy, consumer);
+  if (!conflict) return null;
+  const seen = reported();
+  if (!seen.has(module)) {
+    seen.add(module);
+    console.warn(conflict.message);
+  }
+  return conflict;
+}
+
 // src/helpers/callOrReturn.ts
 function callOrReturn(value, context, ...args) {
   if (typeof value === "function") {
@@ -232,6 +316,183 @@ function callOrReturn(value, context, ...args) {
   return value;
 }
 
+// src/Extension.ts
+function mergeConfigWithParentBinding(parentConfig, extendedConfig) {
+  const parent = parentConfig;
+  const merged = { ...parent };
+  for (const [key, value] of Object.entries(extendedConfig)) {
+    if (typeof value === "function" && typeof parent[key] === "function") {
+      const parentFn = parent[key];
+      const childFn = value;
+      merged[key] = function(...args) {
+        const previousParent = this.parent;
+        this.parent = (...pArgs) => parentFn.call(this, ...pArgs);
+        const result = childFn.call(this, ...args);
+        this.parent = previousParent;
+        return result;
+      };
+    } else {
+      merged[key] = value;
+    }
+  }
+  return merged;
+}
+var EXTENSION_BRAND = /* @__PURE__ */ Symbol.for("domternal.core.extension");
+var Extension = class _Extension {
+  /**
+   * Brand read by `ExtensionManager` to tell an extension built by another
+   * copy of `@domternal/core` from a plain object. See `EXTENSION_BRAND`.
+   */
+  [EXTENSION_BRAND] = true;
+  /**
+   * Extension type identifier
+   * Used to distinguish between Extension, Node, and Mark
+   * Subclasses override this to 'node' or 'mark'
+   */
+  type = "extension";
+  /**
+   * Unique extension name
+   */
+  name;
+  /**
+   * Extension options (immutable after creation)
+   */
+  options;
+  /**
+   * Extension storage (mutable state)
+   * Accessible via editor.storage[extensionName]
+   */
+  storage;
+  /**
+   * The original configuration object
+   */
+  config;
+  /**
+   * Editor instance (set by ExtensionManager after creation)
+   * null until ExtensionManager binds it
+   */
+  editor = null;
+  /**
+   * Reference to the parent config method when using extend().
+   * Set temporarily during config method execution so overridden
+   * methods can call `this.parent?.()` to invoke the original.
+   */
+  parent;
+  /**
+   * Protected constructor - use Extension.create() instead
+   */
+  constructor(config) {
+    if (!/^[a-z][a-zA-Z0-9]*$/.test(config.name)) {
+      throw new Error(
+        `Extension name '${config.name}' is invalid. Names must be camelCase starting with a lowercase letter (e.g., 'myExtension').`
+      );
+    }
+    this.config = config;
+    this.name = config.name;
+    const defaultOptions = callOrReturn(config.addOptions, this);
+    this.options = defaultOptions ?? {};
+    const defaultStorage = callOrReturn(config.addStorage, this);
+    this.storage = defaultStorage ?? {};
+  }
+  /**
+   * Creates a new extension instance
+   *
+   * @param config - Extension configuration
+   * @returns New extension instance
+   *
+   * @example
+   * const MyExtension = Extension.create({
+   *   name: 'myExtension',
+   *   addOptions() {
+   *     return { enabled: true };
+   *   },
+   * });
+   */
+  static create(config) {
+    return new _Extension(config);
+  }
+  /**
+   * Creates a new extension with merged options
+   * Original extension is not modified
+   *
+   * **Note:** Options are merged shallowly using object spread (`...`).
+   * Nested objects are replaced entirely, not deeply merged.
+   *
+   * @param options - Options to merge with existing options
+   * @returns New extension instance with merged options
+   *
+   * @example
+   * const configured = MyExtension.configure({ enabled: false });
+   *
+   * @example
+   * // Shallow merge behavior with nested objects:
+   * // Given: options = { nested: { a: 1, b: 2 } }
+   * // configure({ nested: { b: 3 } })
+   * // Result: { nested: { b: 3 } } - 'a' is lost!
+   * // To preserve nested values, spread manually:
+   * // configure({ nested: { ...original.options.nested, b: 3 } })
+   */
+  configure(options) {
+    const newConfig = {
+      ...this.config,
+      // Override addOptions to return merged options
+      addOptions: () => ({
+        ...this.options,
+        ...options
+      })
+    };
+    return new _Extension(newConfig);
+  }
+  /**
+   * Returns a fresh, unbound copy built from the same `config`: `editor` reset to
+   * null and `options`/`storage` re-derived, while `configure()`/`extend()`
+   * results are preserved (they live in `config`). Polymorphic: a `Node`/`Mark`
+   * clones to its own subclass.
+   *
+   * `ExtensionManager` clones every extension so each editor owns its instances
+   * and binding one editor can't mutate extensions shared with another.
+   */
+  clone() {
+    const Ctor = this.constructor;
+    return new Ctor(this.config);
+  }
+  /**
+   * Creates a new extension with extended configuration
+   * Original extension is not modified
+   *
+   * **Note:** Config is merged shallowly using object spread (`...`).
+   * Config properties (like `addCommands`, `addKeyboardShortcuts`) are
+   * replaced entirely, not combined with the base extension's config.
+   *
+   * @param extendedConfig - Configuration to extend/override
+   * @returns New extension instance with extended config
+   *
+   * @example
+   * const Extended = MyExtension.extend({
+   *   name: 'extendedExtension',
+   *   addCommands() {
+   *     return { customCommand: () => ({ tr }) => true };
+   *   },
+   * });
+   *
+   * @example
+   * // To preserve base extension's commands while adding new ones:
+   * const Extended = BaseExtension.extend({
+   *   addCommands() {
+   *     const baseCommands = BaseExtension.config.addCommands?.call(this) ?? {};
+   *     return {
+   *       ...baseCommands,
+   *       newCommand: () => ({ tr }) => true,
+   *     };
+   *   },
+   * });
+   */
+  extend(extendedConfig) {
+    const newConfig = mergeConfigWithParentBinding(this.config, extendedConfig);
+    return new _Extension(newConfig);
+  }
+};
+
 // src/ExtensionManager.ts
 function mergeHTMLAttrs(target, source) {
   const result = { ...target };
@@ -246,6 +507,13 @@ function mergeHTMLAttrs(target, source) {
   }
   return result;
 }
+function assertOwnExtension(ext) {
+  if (ext instanceof Extension) return;
+  const foreign = ext?.[EXTENSION_BRAND];
+  if (foreign !== true) return;
+  const name = typeof ext.name === "string" ? ext.name : "unknown";
+  throw new ExtensionConfigurationError(describeForeignExtension(name));
+}
 var ExtensionManager = class {
   /**
    * Processed extensions (flattened, sorted by priority)
@@ -305,8 +573,9 @@ var ExtensionManager = class {
         "ExtensionManager requires either extensions or schema. Provide at least Document, Text, and Paragraph extensions."
       );
     }
-    const flattened = this.flattenExtensions(options.extensions);
-    const deduped = this.deduplicateExtensions(flattened);
+    const autoIncluded = /* @__PURE__ */ new Set();
+    const flattened = this.flattenExtensions(options.extensions, autoIncluded);
+    const deduped = this.deduplicateExtensions(flattened, autoIncluded);
     const cloned = this.cloneExtensions(deduped);
     this._extensions = this.resolveExtensions(cloned);
     this.detectConflicts();
@@ -388,33 +657,57 @@ var ExtensionManager = class {
   /**
    * Recursively flattens extensions by expanding addExtensions()
    * This allows extension bundles like StarterKit to work
+   *
+   * `autoIncluded` collects everything that arrived through an
+   * `addExtensions()` rather than from the caller's own list, which is what
+   * lets deduplication tell a default apart from a choice.
    */
-  flattenExtensions(extensions) {
+  flattenExtensions(extensions, autoIncluded, fromBundle = false) {
     const result = [];
     for (const ext of extensions) {
+      assertOwnExtension(ext);
+      if (fromBundle) autoIncluded.add(ext);
       result.push(ext);
       const nested = callOrReturn(
         ext.config.addExtensions,
         ext
       );
       if (nested && nested.length > 0) {
-        result.push(...this.flattenExtensions(nested));
+        result.push(...this.flattenExtensions(nested, autoIncluded, true));
       }
     }
     return result;
   }
   /**
-   * Removes duplicate extensions by name, keeping the last occurrence.
-   * This allows parent extensions to auto-include children via addExtensions()
-   * while letting users override with explicitly configured versions.
+   * Removes duplicate extensions by name.
+   *
+   * A version the caller listed themselves always wins over one a bundle
+   * included on their behalf, and position does not enter into it. Keeping
+   * the last occurrence alone said the same thing only while every bundle was
+   * listed first, which is the habit for StarterKit and no rule at all: an
+   * extension that includes a default and is written LOWER in the list, as
+   * `Export` and its `Print` are, silently replaced the configured copy
+   * above it and the caller's options went missing with it.
+   *
+   * Between two of the same kind the later one still wins, so two bundles
+   * offering the same default resolve as they always have.
    */
-  deduplicateExtensions(extensions) {
-    const seen = /* @__PURE__ */ new Map();
+  deduplicateExtensions(extensions, autoIncluded) {
+    const winners = /* @__PURE__ */ new Map();
     for (let i = 0; i < extensions.length; i++) {
       const ext = extensions[i];
-      if (ext) seen.set(ext.name, i);
+      if (!ext) continue;
+      const held = winners.get(ext.name);
+      if (held === void 0) {
+        winners.set(ext.name, i);
+        continue;
+      }
+      const heldIsAuto = autoIncluded.has(extensions[held]);
+      const nextIsAuto = autoIncluded.has(ext);
+      if (nextIsAuto && !heldIsAuto) continue;
+      winners.set(ext.name, i);
     }
-    return extensions.filter((ext, i) => seen.get(ext.name) === i);
+    return extensions.filter((ext, i) => winners.get(ext.name) === i);
   }
   /**
    * Clone every extension so this editor owns its instances. Extensions hold
@@ -1473,177 +1766,6 @@ var insertContent = (content) => ({ state, tr, dispatch }) => {
   return true;
 };
 
-// src/Extension.ts
-function mergeConfigWithParentBinding(parentConfig, extendedConfig) {
-  const parent = parentConfig;
-  const merged = { ...parent };
-  for (const [key, value] of Object.entries(extendedConfig)) {
-    if (typeof value === "function" && typeof parent[key] === "function") {
-      const parentFn = parent[key];
-      const childFn = value;
-      merged[key] = function(...args) {
-        const previousParent = this.parent;
-        this.parent = (...pArgs) => parentFn.call(this, ...pArgs);
-        const result = childFn.call(this, ...args);
-        this.parent = previousParent;
-        return result;
-      };
-    } else {
-      merged[key] = value;
-    }
-  }
-  return merged;
-}
-var Extension = class _Extension {
-  /**
-   * Extension type identifier
-   * Used to distinguish between Extension, Node, and Mark
-   * Subclasses override this to 'node' or 'mark'
-   */
-  type = "extension";
-  /**
-   * Unique extension name
-   */
-  name;
-  /**
-   * Extension options (immutable after creation)
-   */
-  options;
-  /**
-   * Extension storage (mutable state)
-   * Accessible via editor.storage[extensionName]
-   */
-  storage;
-  /**
-   * The original configuration object
-   */
-  config;
-  /**
-   * Editor instance (set by ExtensionManager after creation)
-   * null until ExtensionManager binds it
-   */
-  editor = null;
-  /**
-   * Reference to the parent config method when using extend().
-   * Set temporarily during config method execution so overridden
-   * methods can call `this.parent?.()` to invoke the original.
-   */
-  parent;
-  /**
-   * Protected constructor - use Extension.create() instead
-   */
-  constructor(config) {
-    if (!/^[a-z][a-zA-Z0-9]*$/.test(config.name)) {
-      throw new Error(
-        `Extension name '${config.name}' is invalid. Names must be camelCase starting with a lowercase letter (e.g., 'myExtension').`
-      );
-    }
-    this.config = config;
-    this.name = config.name;
-    const defaultOptions = callOrReturn(config.addOptions, this);
-    this.options = defaultOptions ?? {};
-    const defaultStorage = callOrReturn(config.addStorage, this);
-    this.storage = defaultStorage ?? {};
-  }
-  /**
-   * Creates a new extension instance
-   *
-   * @param config - Extension configuration
-   * @returns New extension instance
-   *
-   * @example
-   * const MyExtension = Extension.create({
-   *   name: 'myExtension',
-   *   addOptions() {
-   *     return { enabled: true };
-   *   },
-   * });
-   */
-  static create(config) {
-    return new _Extension(config);
-  }
-  /**
-   * Creates a new extension with merged options
-   * Original extension is not modified
-   *
-   * **Note:** Options are merged shallowly using object spread (`...`).
-   * Nested objects are replaced entirely, not deeply merged.
-   *
-   * @param options - Options to merge with existing options
-   * @returns New extension instance with merged options
-   *
-   * @example
-   * const configured = MyExtension.configure({ enabled: false });
-   *
-   * @example
-   * // Shallow merge behavior with nested objects:
-   * // Given: options = { nested: { a: 1, b: 2 } }
-   * // configure({ nested: { b: 3 } })
-   * // Result: { nested: { b: 3 } } - 'a' is lost!
-   * // To preserve nested values, spread manually:
-   * // configure({ nested: { ...original.options.nested, b: 3 } })
-   */
-  configure(options) {
-    const newConfig = {
-      ...this.config,
-      // Override addOptions to return merged options
-      addOptions: () => ({
-        ...this.options,
-        ...options
-      })
-    };
-    return new _Extension(newConfig);
-  }
-  /**
-   * Returns a fresh, unbound copy built from the same `config`: `editor` reset to
-   * null and `options`/`storage` re-derived, while `configure()`/`extend()`
-   * results are preserved (they live in `config`). Polymorphic: a `Node`/`Mark`
-   * clones to its own subclass.
-   *
-   * `ExtensionManager` clones every extension so each editor owns its instances
-   * and binding one editor can't mutate extensions shared with another.
-   */
-  clone() {
-    const Ctor = this.constructor;
-    return new Ctor(this.config);
-  }
-  /**
-   * Creates a new extension with extended configuration
-   * Original extension is not modified
-   *
-   * **Note:** Config is merged shallowly using object spread (`...`).
-   * Config properties (like `addCommands`, `addKeyboardShortcuts`) are
-   * replaced entirely, not combined with the base extension's config.
-   *
-   * @param extendedConfig - Configuration to extend/override
-   * @returns New extension instance with extended config
-   *
-   * @example
-   * const Extended = MyExtension.extend({
-   *   name: 'extendedExtension',
-   *   addCommands() {
-   *     return { customCommand: () => ({ tr }) => true };
-   *   },
-   * });
-   *
-   * @example
-   * // To preserve base extension's commands while adding new ones:
-   * const Extended = BaseExtension.extend({
-   *   addCommands() {
-   *     const baseCommands = BaseExtension.config.addCommands?.call(this) ?? {};
-   *     return {
-   *       ...baseCommands,
-   *       newCommand: () => ({ tr }) => true,
-   *     };
-   *   },
-   * });
-   */
-  extend(extendedConfig) {
-    const newConfig = mergeConfigWithParentBinding(this.config, extendedConfig);
-    return new _Extension(newConfig);
-  }
-};
-
 // src/helpers/specBuilder.ts
 function buildProseMirrorAttrs(attributeSpecs) {
   const attrs = {};
@@ -2681,8 +2803,7 @@ var builtInCommands = {
 function buildCommandProps(options) {
   const { editor, tr, dispatch, chain, can, commands } = options;
   return {
-    // Cast required: CommandPropsEditor is a minimal interface, but CommandProps
-    // expects full Editor. Callers ensure the actual editor instance is passed.
+    // CommandPropsEditor is intentionally the minimal shape CommandProps consumes here.
     editor,
     state: editor.view.state,
     tr,
@@ -3110,8 +3231,7 @@ var CommandManager = class {
   buildCommandProps(tr, dispatch) {
     const { editor } = this;
     return {
-      // Cast needed: CommandManagerEditor is a minimal interface for dependency injection,
-      // but CommandProps expects the full Editor type. Callers pass the actual Editor instance.
+      // CommandManagerEditor is intentionally the minimal shape CommandProps consumes here.
       editor,
       state: editor.state,
       tr,
@@ -3263,6 +3383,17 @@ function resolveOverrides(overrides) {
   if (!overrides) return DEFAULTS;
   return { ...DEFAULTS, ...overrides };
 }
+var BULLET_MARKERS = ["disc", "circle", "square"];
+var ORDERED_MARKERS = ["decimal", "lower-alpha", "lower-roman"];
+function listMarkerDepth(el, container) {
+  let depth = 0;
+  for (let parent = el.parentElement; parent !== null && parent !== container; parent = parent.parentElement) {
+    const tag = parent.tagName;
+    if (tag === "TD" || tag === "TH") break;
+    if (tag === "UL" || tag === "OL") depth += 1;
+  }
+  return depth;
+}
 function applyInlineStyles(container, overrides) {
   const v = resolveOverrides(overrides);
   if (overrides?.codeHighlighter) {
@@ -3344,16 +3475,27 @@ function applyInlineStyles(container, overrides) {
       case "H6":
         styles = "font-size: 0.9em; font-weight: 700; line-height: 1.25; margin: 1.5em 0 0.5em;";
         break;
+      // `type` is not a schema attribute on either list node, so no document
+      // this editor produced carries one.
       case "UL":
         if (el.getAttribute("data-type") === "taskList") {
           styles = "list-style: none; padding-left: 0; margin: 0.75em 0;";
-        } else {
+        } else if (el.hasAttribute("type")) {
           styles = "margin: 0.75em 0; padding-left: 1.5em;";
+        } else {
+          const bullet = BULLET_MARKERS[listMarkerDepth(el, container) % 3] ?? "disc";
+          styles = `margin: 0.75em 0; padding-left: 1.5em; list-style-type: ${bullet};`;
         }
         break;
-      case "OL":
-        styles = "margin: 0.75em 0; padding-left: 1.5em;";
+      case "OL": {
+        if (el.hasAttribute("type")) {
+          styles = "margin: 0.75em 0; padding-left: 1.5em;";
+          break;
+        }
+        const number = ORDERED_MARKERS[listMarkerDepth(el, container) % 3] ?? "decimal";
+        styles = `margin: 0.75em 0; padding-left: 1.5em; list-style-type: ${number};`;
         break;
+      }
       case "LI":
         if (el.getAttribute("data-type") === "taskItem") {
           styles = "display: flex; align-items: flex-start; gap: 0.5em; margin: 0.25em 0;";
@@ -3540,6 +3682,15 @@ var Editor = class _Editor extends EventEmitter {
         "Editor requires either schema or extensions. Provide a ProseMirror schema directly, or use extensions like [Document, Paragraph, Text]."
       );
     }
+    warnOnDuplicateProseMirrorCopy("prosemirror-model", Fragment, "@domternal/core");
+    warnOnDuplicateProseMirrorCopy("prosemirror-state", Plugin, "@domternal/core");
+    warnOnDuplicateProseMirrorCopy("prosemirror-view", EditorView, "@domternal/core");
+    warnOnDuplicateProseMirrorCopy("prosemirror-transform", Transform, "@domternal/core");
+    warnOnDuplicateProseMirrorCopy(
+      "@domternal/core",
+      ExtensionConfigurationError,
+      "@domternal/core"
+    );
     this.options = {
       editable: true,
       ...options
@@ -3834,11 +3985,7 @@ var Editor = class _Editor extends EventEmitter {
    */
   getText(options = {}) {
     const { blockSeparator = "\n\n" } = options;
-    return this.state.doc.textBetween(
-      0,
-      this.state.doc.content.size,
-      blockSeparator
-    );
+    return this.state.doc.textBetween(0, this.state.doc.content.size, blockSeparator);
   }
   /**
    * Executes a command with proper CommandProps
@@ -3997,10 +4144,7 @@ var Editor = class _Editor extends EventEmitter {
     this._extensionManager.validateSchema();
     let doc;
     try {
-      doc = createDocument(
-        this.options.content ?? null,
-        this._extensionManager.schema
-      );
+      doc = createDocument(this.options.content ?? null, this._extensionManager.schema);
     } catch (error) {
       const contentError = error instanceof Error ? error : new Error(String(error));
       this.emit("contentError", {
@@ -4036,7 +4180,10 @@ var Editor = class _Editor extends EventEmitter {
       }),
       ...Object.keys(nodeViews).length > 0 ? { nodeViews } : {},
       // Clipboard transform - apply user-provided transform (e.g. inlineStyles) on copy/cut
-      ...this.options.clipboardHTMLTransform ? this.buildClipboardSerializer(this.options.clipboardHTMLTransform, this._extensionManager.schema) : {},
+      ...this.options.clipboardHTMLTransform ? this.buildClipboardSerializer(
+        this.options.clipboardHTMLTransform,
+        this._extensionManager.schema
+      ) : {},
       // Handle focus/blur events
       handleDOMEvents: {
         focus: (_view, event) => {
@@ -4292,20 +4439,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",
@@ -4322,6 +4468,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"]);
@@ -5290,12 +5636,13 @@ var FloatingMenuController = class _FloatingMenuController {
    */
   updateDisabledStates() {
     let changed = false;
-    let canProxy = null;
-    try {
-      canProxy = this.editor.can();
-    } catch {
-      canProxy = null;
-    }
+    const canProxy = (() => {
+      try {
+        return this.editor.can();
+      } catch {
+        return null;
+      }
+    })();
     for (const item of this._flatItems) {
       const was = this._disabledMap.get(item.name) ?? false;
       let now = false;
@@ -7496,7 +7843,7 @@ function linkClickPlugin(options) {
         if (!view.editable) {
           return false;
         }
-        let link = null;
+        let link;
         if (event.target instanceof HTMLAnchorElement) {
           link = event.target;
         } else {
@@ -10676,10 +11023,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({
@@ -10764,10 +11111,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) {
@@ -10894,8 +11239,8 @@ var StarterKit = Extension.create({
 });
 
 // src/index.ts
-var VERSION = "0.15.0";
+var VERSION = "1.0.1";
 
-export { BaseKeymap, BlockColor, Blockquote, Bold, BubbleMenu, BulletList, CanChecker, ChainBuilder, CharacterCount, ClearFormatting, Code, CodeBlock, CommandManager, DEFAULT_BLOCK_COLORS, DEFAULT_BLOCK_COLOR_TYPES, DEFAULT_HIGHLIGHT_COLORS, DEFAULT_NOTION_COLOR_PALETTE, DEFAULT_TEXT_COLORS, Document, Dropcursor, Editor, EventEmitter, Extension, ExtensionConfigurationError, ExtensionManager, FLOATING_MENU_META, FLOATING_MENU_NO_FOCUS, FloatingMenuController, Focus, FontFamily, FontSize, Gapcursor, HardBreak, Heading, Highlight, History, HorizontalRule, InvisibleChars, Italic, LIST_ITEM_TYPE_NAMES, LineHeight, Link, LinkPopover, ListIndent, ListItem, ListKeymap, Mark, Node2 as Node, NotionColorPicker, OrderedList, Paragraph, Placeholder, Print, Selection5 as Selection, SelectionDecoration, StarterKit, Strike, Subscript, Superscript, TaskItem, TaskList, Text, TextAlign, TextColor, TextStyle, ToolbarController, TrailingNode, Typography, Underline, UniqueID, VERSION, announce, applyInlineStyles, autolinkPlugin, autolinkPluginKey, blur, bubbleMenuPluginKey, buildCommandProps, builtInCommands, callOrReturn, characterCountPluginKey, clearContent, copyThemeClass, createAccumulatingDispatch, createBubbleMenuPlugin, createCanChecker, createChainBuilder, createDocument, createFloatingMenuPlugin, defaultBlockAt, defaultBubbleContexts, defaultFloatingMenuShouldShow, defaultIcons, deleteSelection, findChildren, findListItemAncestorDepth, findParentNode, floatingMenuPluginKey, focus, focusPluginKey, generateHTML, generateJSON, generateText, getListItemCursorContext, getMarkRange, groupFloatingMenuItems, hideFloatingMenu, indentBlockAsListChild, inlineStyles, insertAsListItemChild, insertChildrenZoneSibling, insertContent, insertText, invisibleCharsPluginKey, isDocumentEmpty, isInListItemLabel, isInsideListItem, isNodeEmpty, isValidUrl, lift, liftCurrentListItem, liftEmptyChildrenZoneParagraph, linkClickPlugin, linkClickPluginKey, linkExitPlugin, linkExitPluginKey, linkPastePlugin, linkPastePluginKey, markInputRule, markInputRulePatterns, nodeInputRule, outdentBlockFromListItem, placeholderPluginKey, positionFloating, positionFloatingOnce, refocusEditorAfterCommand, resetAttributes, selectAll, selectNodeBackward, selectionDecorationPluginKey, setBlockType, setContent, setMark, showFloatingMenu, splitListForInsert, stripInlineColorConflicts, textInputRule, textblockTypeInputRule, toggleBlockType, toggleList, toggleMark, toggleWrap, uniqueIDPluginKey, unsetAllMarks, unsetMark, updateAttributes, wrapIn, wrappingInputRule, writeToClipboard };
+export { BaseKeymap, BlockColor, Blockquote, Bold, BubbleMenu, BulletList, CanChecker, ChainBuilder, CharacterCount, ClearFormatting, Code, CodeBlock, CommandManager, DEFAULT_BLOCK_COLORS, DEFAULT_BLOCK_COLOR_TYPES, DEFAULT_HIGHLIGHT_COLORS, DEFAULT_NOTION_COLOR_PALETTE, DEFAULT_TEXT_COLORS, Document, Dropcursor, Editor, EventEmitter, Extension, ExtensionConfigurationError, ExtensionManager, FLOATING_MENU_META, FLOATING_MENU_NO_FOCUS, FloatingMenuController, Focus, FontFamily, FontSize, Gapcursor, HardBreak, Heading, Highlight, History, HorizontalRule, InvisibleChars, Italic, LIST_ITEM_TYPE_NAMES, LineHeight, Link, LinkPopover, ListIndent, ListItem, ListKeymap, Mark, Node2 as Node, NotionColorPicker, OrderedList, Paragraph, Placeholder, Print, Selection5 as Selection, SelectionDecoration, StarterKit, Strike, Subscript, Superscript, TaskItem, TaskList, Text, TextAlign, TextColor, TextStyle, ToolbarController, TrailingNode, Typography, Underline, UniqueID, VERSION, announce, applyInlineStyles, assertSingleProseMirrorCopy, autolinkPlugin, autolinkPluginKey, blur, bubbleMenuPluginKey, buildBubbleItemMaps, buildCommandProps, builtInCommands, callOrReturn, characterCountPluginKey, clearContent, collapseSeparators, copyThemeClass, createAccumulatingDispatch, createBubbleMenuPlugin, createBubbleShouldShow, createCanChecker, createChainBuilder, createDocument, createFloatingMenuPlugin, defaultBlockAt, defaultBubbleContexts, defaultFloatingMenuShouldShow, defaultIcons, deleteSelection, detectBubbleContext, filterBubbleItemsBySchema, findChildren, findListItemAncestorDepth, findParentNode, floatingMenuPluginKey, focus, focusPluginKey, generateHTML, generateJSON, generateText, getBubbleFormatItems, getListItemCursorContext, getMarkRange, groupFloatingMenuItems, hideFloatingMenu, indentBlockAsListChild, inlineStyles, insertAsListItemChild, insertChildrenZoneSibling, insertContent, insertText, invisibleCharsPluginKey, isDocumentEmpty, isInListItemLabel, isInsideListItem, isInsideTableCell, isNodeEmpty, isValidUrl, lift, liftCurrentListItem, liftEmptyChildrenZoneParagraph, linkClickPlugin, linkClickPluginKey, linkExitPlugin, linkExitPluginKey, linkPastePlugin, linkPastePluginKey, markInputRule, markInputRulePatterns, nodeInputRule, outdentBlockFromListItem, placeholderPluginKey, positionFloating, positionFloatingOnce, refocusEditorAfterCommand, registerProseMirrorCopy, resetAttributes, resolveBubbleMenuItems, resolveBubbleNames, selectAll, selectNodeBackward, selectionDecorationPluginKey, setBlockType, setContent, setMark, showFloatingMenu, splitListForInsert, stripInlineColorConflicts, textInputRule, textblockTypeInputRule, toggleBlockType, toggleList, toggleMark, toggleWrap, uniqueIDPluginKey, unsetAllMarks, unsetMark, updateAttributes, warnOnDuplicateProseMirrorCopy, wrapIn, wrappingInputRule, writeToClipboard };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map