@pixerate/editor 0.24.0 → 0.25.0

package/dist/{chunk-ITBSKI26.js → chunk-IXHSYOVY.js}

@@ -1,6 +1,6 @@
 import {
   compareDocuments
-} from "./chunk-FODNLX5N.js";
+} from "./chunk-NAXVVS5I.js";
 import {
   INSTRUCTION_REGEX,
   TEMPLATE_REGEX,
@@ -16,20 +16,20 @@ import {
   rtfToPlainText,
   sanitizeImportedHtml,
   serializeRichClipboardPayload
-} from "./chunk-3LV6RRPH.js";
+} from "./chunk-QGYDWPRM.js";
 import {
   escapeHtml,
   htmlToPlainText,
   markdownToTipTapHtml,
   plainTextToSlice
-} from "./chunk-PGNZKFQS.js";
+} from "./chunk-ECCCYKGL.js";
 import {
   CommentStore,
   TRACK_CHANGES_SKIP_META,
   TrackChanges,
   createReviewId,
   trackChangesPluginKey
-} from "./chunk-5S3Z4PPF.js";
+} from "./chunk-UAKDG62Z.js";
 
 // src/extensions/gradient-text.ts
 import { Mark } from "@tiptap/core";
@@ -601,10 +601,47 @@ var Mention = BaseMention.extend({
           if (!attributes.color) return {};
           return { "data-color": attributes.color };
         }
+      },
+      // Role of an asset mention (`reference`, `style`, `start_frame`, …). The
+      // node attribute is `assetRole` so entities that already carry a `role`
+      // (e.g. a user's job title) passed as suggestion props do not set it.
+      assetRole: {
+        default: null,
+        parseHTML: (element) => {
+          const role = element.getAttribute("data-role");
+          return role && MENTION_ROLE_PATTERN.test(role) ? role : null;
+        },
+        renderHTML: (attributes) => {
+          if (!attributes.assetRole) return {};
+          return { "data-role": attributes.assetRole };
+        }
       }
     };
   }
 });
+var MENTION_ROLE_PATTERN = /^[A-Za-z](?:[A-Za-z0-9_-]*[A-Za-z0-9])?$/;
+function getMentionNodes(editor) {
+  const result = [];
+  editor.state.doc.descendants((node, pos) => {
+    if (node.type?.name !== "mention") return;
+    result.push({
+      pos,
+      id: node.attrs.id ?? "",
+      label: node.attrs.label ?? "",
+      ...node.attrs.type ? { type: node.attrs.type } : {},
+      ...node.attrs.assetRole ? { role: node.attrs.assetRole } : {}
+    });
+  });
+  return result;
+}
+function setMentionRoleAt(editor, pos, role) {
+  const node = editor?.state?.doc?.nodeAt(pos);
+  if (!node || node.type.name !== "mention") return false;
+  if (role !== null && !MENTION_ROLE_PATTERN.test(role)) return false;
+  const tr = editor.state.tr.setNodeMarkup(pos, void 0, { ...node.attrs, assetRole: role });
+  editor.view.dispatch(tr);
+  return true;
+}
 function createMentionExtension(options = {}) {
   const { HTMLAttributes = {}, ...rest } = options;
   return Mention.configure({
@@ -2249,7 +2286,13 @@ var ImportAdapterRegistry = class {
         { fileName }
       );
     }
-    const context = createImportContext(input, { fileName, mimeType, target: adapter.target, registry: this });
+    const context = createImportContext(input, {
+      fileName,
+      mimeType,
+      target: adapter.target,
+      registry: this,
+      options: options.adapterOptions?.[adapter.id]
+    });
     try {
       const result = await adapter.import(input, context);
       return { adapterId: adapter.id, target: adapter.target, fileName, mimeType, result };
@@ -3348,7 +3391,10 @@ async function importFilesIntoEditor(target, files, options = {}) {
   let at = options.at;
   for (const file of Array.from(files)) {
     try {
-      const outcome = await registry.importFile(file, { target: "document" });
+      const outcome = await registry.importFile(file, {
+        target: "document",
+        adapterOptions: options.adapterOptions
+      });
       const view = toView(target);
       if (view.isDestroyed) break;
       at = insertImportedDocument(view, outcome.result, { at, asPlainText: options.asPlainText });
@@ -3382,6 +3428,7 @@ var FileImport = Extension8.create({
   addOptions() {
     return {
       registry: void 0,
+      adapterOptions: void 0,
       asPlainText: false,
       enableDrop: true,
       enablePaste: true,
@@ -3397,6 +3444,7 @@ var FileImport = Extension8.create({
         registry: registry(),
         at,
         asPlainText: options.asPlainText,
+        adapterOptions: options.adapterOptions,
         onImport: options.onImport,
         onError: options.onImportError
       });
@@ -6469,6 +6517,869 @@ function safeClipboard(get) {
   }
 }
 
+// src/extensions/paragraph-styles/extension.ts
+import { Extension as Extension13, Mark as Mark5, mergeAttributes as mergeAttributes7 } from "@tiptap/core";
+import { Plugin as Plugin15, PluginKey as PluginKey12 } from "@tiptap/pm/state";
+
+// src/extensions/paragraph-styles/registry.ts
+var MAX_CHAIN = 32;
+var STYLE_ID = /^[A-Za-z][A-Za-z0-9_-]{0,63}$/;
+var UNSAFE_CSS = /[;{}<>\\]|\/\*|url\s*\(|expression\s*\(|@import|javascript:/i;
+var NORMAL_STYLE_ID = "Normal";
+var PREVIEW_PROPERTIES = /* @__PURE__ */ new Set([
+  "font-family",
+  "font-weight",
+  "font-style",
+  "color",
+  "text-decoration-line",
+  "text-transform",
+  "letter-spacing",
+  "font-variant-caps"
+]);
+function isValidStyleId(id) {
+  return typeof id === "string" && STYLE_ID.test(id);
+}
+var MUTED = "var(--pixerate-style-muted, #6b7280)";
+var HEADING_SIZES = ["2em", "1.5em", "1.25em", "1.1em", "1em", "0.9em"];
+function builtinStyles() {
+  const styles = [
+    {
+      id: NORMAL_STYLE_ID,
+      name: "Normal",
+      kind: "paragraph",
+      block: { type: "paragraph" },
+      priority: 0,
+      quick: true,
+      builtin: true
+    },
+    {
+      id: "Title",
+      name: "Title",
+      kind: "paragraph",
+      basedOn: NORMAL_STYLE_ID,
+      next: NORMAL_STYLE_ID,
+      linked: "TitleChar",
+      paragraph: { spaceAfter: "0.25em", lineHeight: "1.15" },
+      character: { fontSize: "2.5em", bold: true, letterSpacing: "-0.01em" },
+      priority: 10,
+      quick: true,
+      builtin: true
+    },
+    {
+      id: "Subtitle",
+      name: "Subtitle",
+      kind: "paragraph",
+      basedOn: NORMAL_STYLE_ID,
+      next: NORMAL_STYLE_ID,
+      linked: "SubtitleChar",
+      paragraph: { spaceAfter: "0.75em" },
+      character: { fontSize: "1.25em", color: MUTED },
+      priority: 11,
+      quick: true,
+      builtin: true
+    }
+  ];
+  HEADING_SIZES.forEach((fontSize, i) => {
+    const level = i + 1;
+    styles.push({
+      id: `Heading${level}`,
+      name: `Heading ${level}`,
+      kind: "paragraph",
+      basedOn: NORMAL_STYLE_ID,
+      next: NORMAL_STYLE_ID,
+      linked: `Heading${level}Char`,
+      block: { type: "heading", attrs: { level } },
+      paragraph: { spaceBefore: level <= 2 ? "1em" : "0.75em", spaceAfter: "0.25em" },
+      character: { fontSize, bold: true },
+      priority: 11 + level,
+      quick: level <= 3,
+      builtin: true
+    });
+  });
+  styles.push(
+    {
+      id: "Quote",
+      name: "Quote",
+      kind: "paragraph",
+      basedOn: NORMAL_STYLE_ID,
+      next: NORMAL_STYLE_ID,
+      linked: "QuoteChar",
+      paragraph: { indentLeft: "1em", paddingLeft: "0.75em", borderLeft: "3px solid currentColor" },
+      character: { italic: true, color: MUTED },
+      priority: 29,
+      quick: true,
+      builtin: true
+    },
+    {
+      id: "Code",
+      name: "Code",
+      kind: "paragraph",
+      basedOn: NORMAL_STYLE_ID,
+      next: NORMAL_STYLE_ID,
+      block: { type: "codeBlock" },
+      character: {
+        fontFamily: "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace",
+        fontSize: "0.9em"
+      },
+      priority: 30,
+      quick: true,
+      builtin: true
+    },
+    {
+      id: "ListParagraph",
+      name: "List Paragraph",
+      kind: "paragraph",
+      basedOn: NORMAL_STYLE_ID,
+      paragraph: { indentLeft: "2em" },
+      priority: 34,
+      quick: true,
+      builtin: true
+    }
+  );
+  const linked = ["Title", "Subtitle", "Quote", ...HEADING_SIZES.map((_, i) => `Heading${i + 1}`)];
+  linked.forEach((paragraphId) => {
+    const name = styles.find((s) => s.id === paragraphId).name;
+    styles.push({
+      id: `${paragraphId}Char`,
+      name: `${name} Char`,
+      kind: "character",
+      linked: paragraphId,
+      priority: 99,
+      hidden: true,
+      builtin: true
+    });
+  });
+  styles.push(
+    {
+      id: "Emphasis",
+      name: "Emphasis",
+      kind: "character",
+      character: { italic: true },
+      priority: 20,
+      quick: true,
+      builtin: true
+    },
+    {
+      id: "Strong",
+      name: "Strong",
+      kind: "character",
+      character: { bold: true },
+      priority: 22,
+      quick: true,
+      builtin: true
+    }
+  );
+  return styles;
+}
+var DEFAULT_STYLES = Object.freeze(builtinStyles());
+var clone = (value) => value === void 0 ? value : JSON.parse(JSON.stringify(value));
+function overlay(base, patch) {
+  if (!patch) return base;
+  const out = { ...base };
+  Object.entries(patch).forEach(([key, value]) => {
+    if (value !== void 0 && value !== null) out[key] = value;
+  });
+  return out;
+}
+function sameBlock(a, type, attrs) {
+  if (a.type !== type) return false;
+  return Object.entries(a.attrs ?? {}).every(([key, value]) => attrs[key] === value);
+}
+var StyleRegistry = class {
+  styles = /* @__PURE__ */ new Map();
+  defaults;
+  version = 0;
+  snapshot = null;
+  listeners = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    this.defaults = clone(options.defaults ?? {});
+    if (options.builtins !== false) DEFAULT_STYLES.forEach((style) => this.styles.set(style.id, clone(style)));
+    (options.styles ?? []).forEach((style) => this.put(style));
+  }
+  // -- Reading --------------------------------------------------------------
+  get(id) {
+    return id ? this.styles.get(id) : void 0;
+  }
+  /** Finds a style by id or display name (case-insensitive). */
+  find(nameOrId) {
+    const direct = this.styles.get(nameOrId);
+    if (direct) return direct;
+    const lower = nameOrId.toLowerCase();
+    return this.list().find((style) => style.name.toLowerCase() === lower);
+  }
+  /** All styles (optionally of one kind) in gallery order. */
+  list(kind) {
+    return Array.from(this.styles.values()).filter((style) => !kind || style.kind === kind).sort((a, b) => (a.priority ?? 99) - (b.priority ?? 99) || a.name.localeCompare(b.name));
+  }
+  /** Styles shown in the gallery (`quick`, not hidden), paragraph styles by default. */
+  gallery(kind = "paragraph") {
+    return this.list(kind).filter((style) => style.quick && !style.hidden);
+  }
+  /** The `basedOn` chain from the root style down to `id` (cycle-safe, bounded). */
+  chain(id) {
+    const out = [];
+    let current = this.styles.get(id);
+    while (current && out.length < MAX_CHAIN && !out.includes(current)) {
+      out.push(current);
+      current = current.basedOn ? this.styles.get(current.basedOn) : void 0;
+    }
+    return out.reverse();
+  }
+  /**
+   * Resolves a paragraph style: defaults, then each style of the chain (base
+   * first). Unknown ids resolve to the defaults in a `paragraph` block.
+   */
+  resolve(id) {
+    let paragraph = overlay({}, this.defaults.paragraph);
+    let character = overlay({}, this.defaults.character);
+    let block = { type: "paragraph" };
+    this.chain(id).forEach((style) => {
+      if (style.kind !== "paragraph") return;
+      paragraph = overlay(paragraph, style.paragraph);
+      character = overlay(character, style.character);
+      if (style.block) block = clone(style.block);
+    });
+    return { id, paragraph, character, block, next: this.nextStyleId(id) };
+  }
+  /** Character formatting a paragraph style's chain sets (without defaults). */
+  paragraphCharacter(id) {
+    let character = {};
+    this.chain(id).forEach((style) => {
+      if (style.kind === "paragraph") character = overlay(character, style.character);
+    });
+    return character;
+  }
+  /**
+   * Character formatting of a character style's chain. A style linked to a
+   * paragraph style takes that style's character formatting first.
+   */
+  resolveCharacterStyle(id) {
+    let character = {};
+    this.chain(id).forEach((style) => {
+      if (style.kind === "character" && style.linked && this.get(style.linked)?.kind === "paragraph") {
+        character = overlay(character, this.paragraphCharacter(style.linked));
+      }
+      character = overlay(character, style.character);
+    });
+    return character;
+  }
+  /**
+   * Character formatting of text: defaults → paragraph style chain →
+   * character style chain → direct formatting.
+   */
+  resolveText(input) {
+    let character = this.resolve(input.paragraphStyle || NORMAL_STYLE_ID).character;
+    if (input.characterStyle) character = overlay(character, this.resolveCharacterStyle(input.characterStyle));
+    return overlay(character, input.direct);
+  }
+  /** The style after Enter at the end of a paragraph of `id` (itself when unset or unknown). */
+  nextStyleId(id) {
+    const next = this.styles.get(id)?.next;
+    return next && this.styles.get(next)?.kind === "paragraph" ? next : id;
+  }
+  /** The linked character style of a paragraph style, if any. */
+  linkedCharacterStyle(id) {
+    const style = this.styles.get(id);
+    const linked = style?.linked ? this.styles.get(style.linked) : void 0;
+    return style?.kind === "paragraph" && linked?.kind === "character" ? linked : void 0;
+  }
+  /**
+   * The style a block uses when it names none: Normal for paragraphs,
+   * Heading N for headings of level N, Code for code blocks (the built-in
+   * style whose own `block` matches).
+   */
+  defaultStyleFor(type, attrs = {}) {
+    if (type === "paragraph" && this.styles.get(NORMAL_STYLE_ID)) return NORMAL_STYLE_ID;
+    const candidates = this.list("paragraph").filter(
+      (style) => style.block && sameBlock(style.block, type, attrs)
+    );
+    return (candidates.find((s) => s.builtin) ?? candidates[0])?.id ?? null;
+  }
+  /** The style of a block: its `styleId` when known, otherwise the block's default style. */
+  styleOfBlock(type, attrs = {}) {
+    const id = attrs.styleId;
+    if (id && this.styles.get(id)?.kind === "paragraph") return id;
+    return this.defaultStyleFor(type, attrs);
+  }
+  getSnapshot = () => {
+    if (!this.snapshot) {
+      this.snapshot = Object.freeze({
+        styles: Object.freeze(this.list()),
+        defaults: this.defaults,
+        version: this.version
+      });
+    }
+    return this.snapshot;
+  };
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    listener(this.getSnapshot());
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  toJSON() {
+    return { styles: clone(Array.from(this.styles.values())), defaults: clone(this.defaults) };
+  }
+  // -- Writing --------------------------------------------------------------
+  /** Adds or replaces a style. Throws on an invalid id. */
+  upsert(style) {
+    const stored = this.put(style);
+    this.changed();
+    return stored;
+  }
+  /** Merges `patch` into a style (formats are merged key by key). Returns `undefined` for unknown ids. */
+  update(id, patch) {
+    const current = this.styles.get(id);
+    if (!current) return void 0;
+    const next = {
+      ...current,
+      ...patch,
+      id,
+      paragraph: patch.paragraph ? { ...current.paragraph, ...patch.paragraph } : current.paragraph,
+      character: patch.character ? { ...current.character, ...patch.character } : current.character
+    };
+    return this.upsert(next);
+  }
+  /**
+   * Removes a style and returns it. Built-in styles cannot be removed. Styles
+   * based on it are rebased onto its own base, and `next`/`linked`
+   * references to it are dropped.
+   */
+  remove(id) {
+    const gone = this.styles.get(id);
+    if (!gone || gone.builtin) return void 0;
+    this.styles.delete(id);
+    this.styles.forEach((style, key) => {
+      let changed = style;
+      if (style.basedOn === id) {
+        changed = { ...changed, basedOn: gone.basedOn && gone.basedOn !== key ? gone.basedOn : null };
+      }
+      if (style.next === id) changed = { ...changed, next: null };
+      if (style.linked === id) changed = { ...changed, linked: null };
+      if (changed !== style) this.styles.set(key, changed);
+    });
+    this.changed();
+    return gone;
+  }
+  /** Replaces the document defaults. */
+  setDefaults(defaults) {
+    this.defaults = clone(defaults);
+    this.changed();
+  }
+  /** An unused id derived from a display name (`My Style` → `MyStyle`, then `MyStyle1`, …). */
+  newId(name) {
+    let base = name.replace(/[^A-Za-z0-9_-]+/g, "").replace(/^[^A-Za-z]+/, "").slice(0, 56);
+    if (!base) base = "Style";
+    if (!this.styles.has(base)) return base;
+    for (let i = 1; i < 1e5; i++) {
+      const id = `${base}${i}`;
+      if (!this.styles.has(id)) return id;
+    }
+    return `${base}${Date.now()}`;
+  }
+  // -- CSS --------------------------------------------------------------------
+  /** CSS declarations (`property: value`) of a resolved paragraph or character style. */
+  cssDeclarations(id) {
+    const style = this.styles.get(id);
+    if (style?.kind === "character") return characterCSS(this.resolveCharacterStyle(id));
+    const resolved = this.resolve(id);
+    return { ...paragraphCSS(resolved.paragraph), ...characterCSS(resolved.character) };
+  }
+  /**
+   * Declarations for previewing a style in a menu or gallery: font family,
+   * weight, style, color, decoration, case and letter spacing (no sizes,
+   * margins or borders).
+   */
+  previewDeclarations(id) {
+    return Object.fromEntries(
+      Object.entries(this.cssDeclarations(id)).filter(([property]) => PREVIEW_PROPERTIES.has(property))
+    );
+  }
+  /**
+   * A stylesheet for the styles: `[data-style="Id"]` rules for paragraph
+   * styles (plus the plain element of blocks that use their default style,
+   * e.g. `h2:not([data-style])`), `[data-char-style="Id"]` for character
+   * styles and the defaults on the scope element.
+   */
+  toCSS(options = {}) {
+    const scope = options.scope ?? ".ProseMirror";
+    const tagFor = options.tagFor ?? defaultTagFor;
+    const rules = [];
+    const rule = (selectors, declarations) => {
+      const body = Object.entries(declarations).map(([property, value]) => `${property}: ${value};`).join(" ");
+      if (body) rules.push(`${selectors.join(", ")} { ${body} }`);
+    };
+    rule([scope], {
+      ...paragraphCSS(this.defaults.paragraph ?? {}),
+      ...characterCSS(this.defaults.character ?? {})
+    });
+    this.list().forEach((style) => {
+      if (style.kind === "character") {
+        rule([`${scope} [data-char-style="${style.id}"]`], this.cssDeclarations(style.id));
+        return;
+      }
+      const selectors = [`${scope} [data-style="${style.id}"]`];
+      const block = this.resolve(style.id).block;
+      if (this.defaultStyleFor(block.type, block.attrs ?? {}) === style.id) {
+        const tag = tagFor(block);
+        if (tag) selectors.push(`${scope} ${tag}:not([data-style])`);
+      }
+      const resolved = this.resolve(style.id);
+      const own = {
+        ...paragraphCSS(withoutDefaults(resolved.paragraph, this.defaults.paragraph)),
+        ...characterCSS(withoutDefaults(resolved.character, this.defaults.character))
+      };
+      rule(selectors, own);
+    });
+    return rules.join("\n");
+  }
+  // -- Internals --------------------------------------------------------------
+  put(style) {
+    if (!isValidStyleId(style.id)) throw new Error(`Invalid style id: ${String(style.id)}`);
+    if (style.kind !== "paragraph" && style.kind !== "character") {
+      throw new Error(`Invalid style kind: ${String(style.kind)}`);
+    }
+    const stored = clone({ ...style, name: style.name || style.id });
+    this.styles.set(style.id, stored);
+    return stored;
+  }
+  changed() {
+    this.version++;
+    this.snapshot = null;
+    const snapshot = this.getSnapshot();
+    this.listeners.forEach((listener) => {
+      try {
+        listener(snapshot);
+      } catch (err) {
+        console.error("[StyleRegistry] Error in listener:", err);
+      }
+    });
+  }
+};
+function withoutDefaults(format, defaults) {
+  if (!defaults) return format;
+  const out = {};
+  Object.entries(format).forEach(([key, value]) => {
+    if (defaults[key] !== value) out[key] = value;
+  });
+  return out;
+}
+function defaultTagFor(block) {
+  if (block.type === "paragraph") return "p";
+  if (block.type === "heading") {
+    const level = Number(block.attrs?.level);
+    return level >= 1 && level <= 6 ? `h${level}` : null;
+  }
+  if (block.type === "codeBlock") return "pre";
+  return null;
+}
+function safeCSSValue(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > 200 || UNSAFE_CSS.test(trimmed)) return void 0;
+  return trimmed;
+}
+function paragraphCSS(format) {
+  const out = {};
+  const set = (property, value) => {
+    const safe = safeCSSValue(value);
+    if (safe) out[property] = safe;
+  };
+  set("text-align", format.textAlign);
+  set("line-height", format.lineHeight);
+  set("margin-top", format.spaceBefore);
+  set("margin-bottom", format.spaceAfter);
+  set("margin-left", format.indentLeft);
+  set("margin-right", format.indentRight);
+  set("text-indent", format.indentFirstLine);
+  set("border-left", format.borderLeft);
+  set("padding-left", format.paddingLeft);
+  set("background-color", format.backgroundColor);
+  return out;
+}
+function characterCSS(format) {
+  const out = {};
+  const set = (property, value) => {
+    const safe = safeCSSValue(value);
+    if (safe) out[property] = safe;
+  };
+  set("font-family", format.fontFamily);
+  set("font-size", format.fontSize);
+  if (format.bold !== void 0) out["font-weight"] = format.bold ? "700" : "400";
+  if (format.italic !== void 0) out["font-style"] = format.italic ? "italic" : "normal";
+  const lines = [format.underline && "underline", format.strike && "line-through"].filter(Boolean);
+  if (format.underline !== void 0 || format.strike !== void 0) {
+    out["text-decoration-line"] = lines.length ? lines.join(" ") : "none";
+  }
+  set("color", format.color);
+  set("background-color", format.backgroundColor);
+  set("letter-spacing", format.letterSpacing);
+  set("text-transform", format.textTransform);
+  if (format.smallCaps !== void 0) out["font-variant-caps"] = format.smallCaps ? "small-caps" : "normal";
+  return out;
+}
+function createStyleRegistry(options = {}) {
+  return new StyleRegistry(options);
+}
+
+// src/extensions/paragraph-styles/extension.ts
+var STYLE_ID_ATTRIBUTE = "styleId";
+var CHARACTER_STYLE_MARK_NAME = "characterStyle";
+var paragraphStylesPluginKey = new PluginKey12("paragraphStyles");
+function getStyleRegistry(editor) {
+  return editor?.storage?.paragraphStyles?.registry ?? null;
+}
+function headingLevels(editor) {
+  const heading = editor?.extensionManager?.extensions.find((e) => e.name === "heading");
+  const levels = heading?.options?.levels;
+  return Array.isArray(levels) ? levels : null;
+}
+function isParagraphStyleAvailable(editor, registry, id) {
+  const style = registry.get(id);
+  if (!style || style.kind !== "paragraph") return false;
+  const block = registry.resolve(id).block;
+  if (!editor.schema.nodes[block.type]) return false;
+  if (block.type === "heading") {
+    const levels = headingLevels(editor);
+    if (levels && !levels.includes(Number(block.attrs?.level))) return false;
+  }
+  return true;
+}
+function getParagraphStyleAt(state, registry, pos = state.selection.from) {
+  const $pos = state.doc.resolve(Math.max(0, Math.min(pos, state.doc.content.size)));
+  const block = $pos.parent;
+  if (!block.isTextblock) return null;
+  return registry.styleOfBlock(block.type.name, block.attrs);
+}
+var MARK_FORMAT = {
+  bold: "bold",
+  italic: "italic",
+  underline: "underline",
+  strike: "strike"
+};
+function selectionMarks(state) {
+  const { from, to, empty, $from } = state.selection;
+  if (empty) return state.storedMarks ?? $from.marks();
+  let common = null;
+  state.doc.nodesBetween(from, to, (node) => {
+    if (!node.isText) return true;
+    common = common === null ? node.marks : common.filter((m) => m.isInSet(node.marks));
+    return false;
+  });
+  return common ?? $from.marks();
+}
+function captureSelectionFormat(state) {
+  const character = {};
+  selectionMarks(state).forEach((mark) => {
+    const name = mark.type.name;
+    if (MARK_FORMAT[name]) character[MARK_FORMAT[name]] = true;
+    if (name === "textStyle") {
+      if (mark.attrs.fontFamily) character.fontFamily = mark.attrs.fontFamily;
+      if (mark.attrs.fontSize) character.fontSize = mark.attrs.fontSize;
+      if (mark.attrs.color) character.color = mark.attrs.color;
+    }
+    if (name === "highlight") character.backgroundColor = mark.attrs.color || "#fef08a";
+  });
+  const paragraph = {};
+  const align = state.selection.$from.parent.attrs?.textAlign;
+  if (align && align !== "left") paragraph.textAlign = align;
+  return { paragraph, character };
+}
+function carriedAttributes(node, type) {
+  const spec = type.spec.attrs ?? {};
+  return Object.fromEntries(Object.entries(node.attrs).filter(([key]) => key in spec));
+}
+function applyStyleToBlock(tr, pos, id, registry) {
+  const node = tr.doc.nodeAt(pos);
+  if (!node || !node.isTextblock) return false;
+  const resolved = registry.resolve(id);
+  const type = tr.doc.type.schema.nodes[resolved.block.type];
+  if (!type) return false;
+  const blockAttrs = resolved.block.attrs ?? {};
+  const isDefault = registry.defaultStyleFor(resolved.block.type, blockAttrs) === id;
+  const attrs = { ...carriedAttributes(node, type), ...blockAttrs };
+  if (STYLE_ID_ATTRIBUTE in (type.spec.attrs ?? {})) attrs[STYLE_ID_ATTRIBUTE] = isDefault ? null : id;
+  if ("textAlign" in (type.spec.attrs ?? {})) {
+    const fallback = type.spec.attrs.textAlign.default ?? null;
+    attrs.textAlign = fallback === null ? null : resolved.paragraph.textAlign ?? fallback;
+  }
+  if (node.type === type && Object.entries(attrs).every(([k, v]) => node.attrs[k] === v)) return false;
+  try {
+    tr.setNodeMarkup(pos, type, attrs);
+  } catch {
+    try {
+      tr.setBlockType(pos + 1, pos + 1, type, attrs);
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function selectedBlocks(state) {
+  const { from, to } = state.selection;
+  const positions = [];
+  state.doc.nodesBetween(from, to, (node, pos) => {
+    if (node.isTextblock) {
+      positions.push(pos);
+      return false;
+    }
+    return true;
+  });
+  if (positions.length === 0 && state.selection.$from.parent.isTextblock) {
+    positions.push(state.selection.$from.before());
+  }
+  return positions;
+}
+function setParagraphStyle(tr, state, id, registry) {
+  const start2 = tr.steps.length;
+  selectedBlocks(state).forEach((pos) => {
+    applyStyleToBlock(tr, tr.mapping.slice(start2).map(pos), id, registry);
+  });
+}
+function nextStyleTransaction(transactions, oldState, newState, registry) {
+  if (transactions.length !== 1) return null;
+  const [tr] = transactions;
+  if (!tr.docChanged || tr.getMeta("uiEvent") || tr.getMeta("history$") || tr.getMeta("y-sync$")) {
+    return null;
+  }
+  const old = oldState.selection;
+  const $old = old.$from;
+  if (!old.empty || !$old.parent.isTextblock || $old.parent.type.spec.code) return null;
+  if ($old.parentOffset !== $old.parent.content.size) return null;
+  if (newState.doc.content.size !== oldState.doc.content.size + 2) return null;
+  const $new = newState.selection.$from;
+  if (!newState.selection.empty || !$new.parent.isTextblock || $new.parent.content.size !== 0) return null;
+  const depth = $new.depth;
+  const index = $new.index(depth - 1);
+  if (index === 0 || $new.depth !== $old.depth) return null;
+  const previous = $new.node(depth - 1).child(index - 1);
+  if (!previous.isTextblock || !previous.eq($old.parent)) return null;
+  const style = registry.styleOfBlock($old.parent.type.name, $old.parent.attrs);
+  if (!style) return null;
+  const next = registry.nextStyleId(style);
+  const current = registry.styleOfBlock($new.parent.type.name, $new.parent.attrs);
+  const target = registry.resolve(next).block;
+  const typeMatches = $new.parent.type.name === target.type && Object.entries(target.attrs ?? {}).every(([k, v]) => $new.parent.attrs[k] === v);
+  if (current === next && typeMatches) return null;
+  const out = newState.tr;
+  if (!applyStyleToBlock(out, $new.before(), next, registry)) return null;
+  return out;
+}
+var CharacterStyle = Mark5.create({
+  name: CHARACTER_STYLE_MARK_NAME,
+  addAttributes() {
+    return {
+      [STYLE_ID_ATTRIBUTE]: {
+        default: null,
+        parseHTML: (el) => {
+          const id = el.getAttribute("data-char-style");
+          return isValidStyleId(id) ? id : null;
+        },
+        renderHTML: (attrs) => attrs[STYLE_ID_ATTRIBUTE] ? { "data-char-style": attrs[STYLE_ID_ATTRIBUTE] } : {}
+      }
+    };
+  },
+  parseHTML() {
+    return [{ tag: "span[data-char-style]" }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes7(HTMLAttributes), 0];
+  }
+});
+var ParagraphStyles = Extension13.create({
+  name: "paragraphStyles",
+  addOptions() {
+    return {
+      registry: null,
+      types: ["paragraph", "heading", "codeBlock"],
+      injectCSS: true,
+      cssScope: ".ProseMirror",
+      cssNonce: void 0,
+      linkedCharacterStyles: true
+    };
+  },
+  addStorage() {
+    return { registry: this.options.registry ?? createStyleRegistry() };
+  },
+  addExtensions() {
+    return [CharacterStyle];
+  },
+  addGlobalAttributes() {
+    return [
+      {
+        types: this.options.types,
+        attributes: {
+          [STYLE_ID_ATTRIBUTE]: {
+            default: null,
+            keepOnSplit: true,
+            parseHTML: (el) => {
+              const id = el.getAttribute("data-style");
+              return isValidStyleId(id) ? id : null;
+            },
+            renderHTML: (attrs) => {
+              const id = attrs[STYLE_ID_ATTRIBUTE];
+              return isValidStyleId(id) ? { "data-style": id, class: `pixerate-style-${id}` } : {};
+            }
+          }
+        }
+      }
+    ];
+  },
+  addCommands() {
+    const registry = () => this.storage.registry;
+    const editor = () => this.editor;
+    return {
+      setParagraphStyle: (id) => ({ state, tr, dispatch }) => {
+        const reg = registry();
+        if (!isParagraphStyleAvailable(editor(), reg, id)) return false;
+        const { $from, $to, empty } = state.selection;
+        const linked = this.options.linkedCharacterStyles ? reg.linkedCharacterStyle(id) : void 0;
+        const partial = !empty && $from.sameParent($to) && $from.parent.isTextblock && ($from.parentOffset > 0 || $to.parentOffset < $from.parent.content.size);
+        const markType = state.schema.marks[CHARACTER_STYLE_MARK_NAME];
+        if (partial && linked && markType) {
+          if (dispatch) {
+            tr.addMark($from.pos, $to.pos, markType.create({ [STYLE_ID_ATTRIBUTE]: linked.id }));
+          }
+          return true;
+        }
+        if (dispatch) setParagraphStyle(tr, state, id, reg);
+        return true;
+      },
+      clearParagraphStyle: () => ({ commands }) => commands.setParagraphStyle(NORMAL_STYLE_ID),
+      setCharacterStyle: (id) => ({ commands }) => {
+        if (registry().get(id)?.kind !== "character") return false;
+        return commands.setMark(CHARACTER_STYLE_MARK_NAME, { [STYLE_ID_ATTRIBUTE]: id });
+      },
+      unsetCharacterStyle: () => ({ commands }) => commands.unsetMark(CHARACTER_STYLE_MARK_NAME),
+      updateParagraphStyleFromSelection: (id) => ({ state, dispatch }) => {
+        const reg = registry();
+        const target = id ?? getParagraphStyleAt(state, reg);
+        const style = target ? reg.get(target) : void 0;
+        if (!style || style.kind !== "paragraph") return false;
+        if (dispatch) {
+          const captured = captureSelectionFormat(state);
+          reg.update(style.id, captured);
+        }
+        return true;
+      },
+      createParagraphStyleFromSelection: (name, options = {}) => ({ state, tr, dispatch }) => {
+        const reg = registry();
+        const trimmed = name.trim();
+        if (!trimmed) return false;
+        const id = options.id ?? reg.newId(trimmed);
+        if (!isValidStyleId(id) || reg.get(id)) return false;
+        const basedOn = options.basedOn === void 0 ? getParagraphStyleAt(state, reg) : options.basedOn;
+        if (dispatch) {
+          const captured = captureSelectionFormat(state);
+          const definition = {
+            id,
+            name: trimmed,
+            kind: "paragraph",
+            basedOn: basedOn ?? NORMAL_STYLE_ID,
+            paragraph: captured.paragraph,
+            character: captured.character,
+            priority: 50,
+            quick: true
+          };
+          reg.upsert(definition);
+          if (options.apply !== false) setParagraphStyle(tr, state, id, reg);
+        }
+        return true;
+      }
+    };
+  },
+  addProseMirrorPlugins() {
+    const registry = this.storage.registry;
+    return [
+      new Plugin15({
+        key: paragraphStylesPluginKey,
+        appendTransaction: (transactions, oldState, newState) => nextStyleTransaction(transactions, oldState, newState, registry)
+      })
+    ];
+  },
+  onBeforeCreate() {
+    if (!this.options.injectCSS || typeof document === "undefined") return;
+    const element = document.createElement("style");
+    element.setAttribute("data-pixerate-paragraph-styles", "");
+    if (this.options.cssNonce) element.nonce = this.options.cssNonce;
+    document.head.appendChild(element);
+    const scope = this.options.cssScope;
+    const unsubscribe = this.storage.registry.subscribe(() => {
+      element.textContent = this.storage.registry.toCSS({ scope });
+    });
+    this.storage.cleanup = () => {
+      unsubscribe();
+      element.remove();
+    };
+  },
+  onDestroy() {
+    this.storage.cleanup?.();
+  }
+});
+var EMPTY_STYLES = Object.freeze({
+  gallery: [],
+  styles: [],
+  characterStyles: [],
+  currentStyleId: null,
+  version: -1
+});
+function createParagraphStylesStore(editor) {
+  const registry = getStyleRegistry(editor);
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = EMPTY_STYLES;
+  let unsubscribeRegistry = null;
+  const compute = () => {
+    if (!editor || editor.isDestroyed || !registry) return EMPTY_STYLES;
+    const { version } = registry.getSnapshot();
+    const currentStyleId = getParagraphStyleAt(editor.state, registry);
+    if (snapshot.version === version && snapshot.currentStyleId === currentStyleId) return snapshot;
+    if (snapshot.version === version) return { ...snapshot, currentStyleId };
+    const styles = registry.list("paragraph").filter((style) => !style.hidden && isParagraphStyleAvailable(editor, registry, style.id));
+    return {
+      gallery: styles.filter((style) => style.quick),
+      styles,
+      characterStyles: registry.list("character").filter((style) => !style.hidden),
+      currentStyleId,
+      version
+    };
+  };
+  const update = () => {
+    const next = compute();
+    if (next !== snapshot) {
+      snapshot = next;
+      listeners.forEach((listener) => listener());
+    }
+  };
+  const detach = () => {
+    editor?.off("transaction", update);
+    unsubscribeRegistry?.();
+    unsubscribeRegistry = null;
+  };
+  return {
+    getSnapshot: () => {
+      if (!listeners.size) snapshot = compute();
+      return snapshot;
+    },
+    subscribe(listener) {
+      if (!listeners.size) {
+        snapshot = compute();
+        editor?.on("transaction", update);
+        unsubscribeRegistry = registry ? registry.subscribe(update) : null;
+      }
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+        if (!listeners.size) detach();
+      };
+    },
+    destroy() {
+      detach();
+      listeners.clear();
+    }
+  };
+}
+
 // src/extensions/rich-text-preset.ts
 var resolveExt3 = (mod, name) => mod?.[name] || mod?.default?.[name] || mod?.default?.default || mod?.default || mod;
 var StarterKit = resolveExt3(_StarterKit, "StarterKit");
@@ -6491,7 +7402,7 @@ function createRichTextPreset(options = {}) {
     openLinksOnClick = false,
     enableSmilies = true,
     enableColorHighlighter = true,
-    headingLevels = [1, 2, 3, 4]
+    headingLevels: headingLevels2 = [1, 2, 3, 4]
   } = options;
   const extensions2 = [
     StarterKit.configure({
@@ -6506,7 +7417,7 @@ function createRichTextPreset(options = {}) {
         }
       },
       heading: {
-        levels: headingLevels,
+        levels: headingLevels2,
         HTMLAttributes: {
           class: "font-bold tracking-tight"
         }
@@ -6668,6 +7579,9 @@ function createRichTextPreset(options = {}) {
   if (options.findReplace) {
     extensions2.push(FindReplace.configure(optionObject(options.findReplace)));
   }
+  if (options.paragraphStyles) {
+    extensions2.push(ParagraphStyles.configure(optionObject(options.paragraphStyles)));
+  }
   return extensions2;
 }
 
@@ -6820,6 +7734,8 @@ export {
   ColorHighlighter,
   FontSize,
   Mention,
+  getMentionNodes,
+  setMentionRoleAt,
   createMentionExtension,
   Markdown2 as Markdown,
   imagePastePluginKey,
@@ -6929,8 +7845,24 @@ export {
   FIND_OPTION_TOGGLES,
   formatFindStatus,
   FindReplace,
+  NORMAL_STYLE_ID,
+  isValidStyleId,
+  DEFAULT_STYLES,
+  StyleRegistry,
+  safeCSSValue,
+  createStyleRegistry,
+  STYLE_ID_ATTRIBUTE,
+  CHARACTER_STYLE_MARK_NAME,
+  paragraphStylesPluginKey,
+  getStyleRegistry,
+  isParagraphStyleAvailable,
+  getParagraphStyleAt,
+  captureSelectionFormat,
+  CharacterStyle,
+  ParagraphStyles,
+  createParagraphStylesStore,
   createRichTextPreset,
   createFindReplaceCommands,
   validateFindPattern
 };
-//# sourceMappingURL=chunk-ITBSKI26.js.map
+//# sourceMappingURL=chunk-IXHSYOVY.js.map