@pixerate/editor 0.23.0 → 0.25.0

package/dist/chunk-ECCCYKGL.js

@@ -0,0 +1,740 @@
+import {
+  MENTION_REGEX,
+  NODE_ROLE_MARK,
+  formatMentionHandle,
+  readRoleSuffix
+} from "./chunk-O5RYH2PG.js";
+import {
+  BLOCK_CHANGE_ATTRIBUTE,
+  MOVE_ID_ATTRIBUTE,
+  resolveTrackedChanges
+} from "./chunk-UAKDG62Z.js";
+
+// src/serializers/plain-text.ts
+import { DOMSerializer, Slice, Fragment, Node as ProsemirrorNode } from "@tiptap/pm/model";
+
+// src/serializers/html-scan.ts
+function findTagSpans(html, tag, attrTest, requireClose) {
+  const matches = typeof attrTest === "function" ? attrTest : (attrs) => attrTest.test(attrs);
+  const spans = [];
+  const openTag = new RegExp(`<${tag}\\b`, "gi");
+  const closeTag = new RegExp(`</${tag}>`, "gi");
+  const closeLength = tag.length + 3;
+  let nextGt = -1;
+  let nextClose = -1;
+  let from = 0;
+  for (; ; ) {
+    openTag.lastIndex = from;
+    const open = openTag.exec(html);
+    if (!open) break;
+    const start = open.index;
+    const attrsStart = start + open[0].length;
+    if (nextGt < attrsStart) {
+      nextGt = html.indexOf(">", attrsStart);
+      if (nextGt === -1) break;
+    }
+    const attrs = html.slice(attrsStart, nextGt);
+    const openEnd = nextGt + 1;
+    if (!matches(attrs)) {
+      from = attrsStart;
+      continue;
+    }
+    if (!requireClose) {
+      spans.push({ start, openEnd, end: openEnd, attrs });
+      from = openEnd;
+      continue;
+    }
+    if (nextClose < openEnd) {
+      closeTag.lastIndex = openEnd;
+      const close = closeTag.exec(html);
+      if (!close) break;
+      nextClose = close.index;
+    }
+    const end = nextClose + closeLength;
+    spans.push({ start, openEnd, end, attrs });
+    from = end;
+  }
+  return spans;
+}
+function replaceTagSpans(html, tag, attrTest, replace) {
+  const spans = findTagSpans(html, tag, attrTest, true);
+  if (spans.length === 0) return html;
+  let out = "";
+  let last = 0;
+  for (const span of spans) {
+    out += html.slice(last, span.start) + replace(html.slice(span.start, span.end), span.attrs);
+    last = span.end;
+  }
+  return out + html.slice(last);
+}
+function stripTags(html, replacement = "") {
+  let out = "";
+  let from = 0;
+  for (; ; ) {
+    const lt = html.indexOf("<", from);
+    if (lt === -1) break;
+    const gt = html.indexOf(">", lt + 1);
+    if (gt === -1) break;
+    if (gt === lt + 1) {
+      out += html.slice(from, gt + 1);
+    } else {
+      out += html.slice(from, lt) + replacement;
+    }
+    from = gt + 1;
+  }
+  return out + html.slice(from);
+}
+function replaceDelimited(text, open, close, replace = () => "", caseInsensitiveClose = false) {
+  const haystack = caseInsensitiveClose ? asciiLower(text) : text;
+  const needle = caseInsensitiveClose ? close.toLowerCase() : close;
+  let out = "";
+  let last = 0;
+  let from = 0;
+  let nextClose = -1;
+  for (; ; ) {
+    open.lastIndex = from;
+    const opened = open.exec(text);
+    if (!opened) break;
+    const afterOpen = opened.index + Math.max(opened[0].length, 1);
+    if (nextClose < afterOpen) {
+      nextClose = haystack.indexOf(needle, afterOpen);
+      if (nextClose === -1) break;
+    }
+    const end = nextClose + close.length;
+    out += text.slice(last, opened.index) + replace(text.slice(opened.index, end));
+    last = from = end;
+  }
+  return out + text.slice(last);
+}
+function asciiLower(text) {
+  return text.replace(/[A-Z]+/g, (m) => m.toLowerCase());
+}
+
+// src/serializers/plain-text.ts
+var TRACKED_DELETION_ATTRIBUTE = /\bdata-change-type=["']deletion["']/i;
+var TRACKED_INSERTION_ATTRIBUTE = /\bdata-change-type=["']insertion["']/i;
+function stripTrackedChanges(html, view) {
+  if (view === "all" || !html.includes("data-change-type")) return html;
+  return view === "accepted" ? replaceTagSpans(html, "del", TRACKED_DELETION_ATTRIBUTE, () => "") : replaceTagSpans(html, "ins", TRACKED_INSERTION_ATTRIBUTE, () => "");
+}
+function escapeHtml(text) {
+  if (!text) return "";
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+var PARAGRAPH_HTML_REGEX = /^\s*<p[\s>][\s\S]*<\/p>\s*$/i;
+function plainTextToTipTapHtml(text) {
+  if (!text) return "<p></p>";
+  if (PARAGRAPH_HTML_REGEX.test(text)) {
+    return text;
+  }
+  return text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n").map((line) => `<p>${escapeHtml(line)}</p>`).join("");
+}
+function plainTextToSlice(text, schema) {
+  const nodes = [];
+  text.replace(/\r\n?/g, "\n").split("\n").forEach((line) => {
+    const nodeJson = { type: "paragraph" };
+    if (line.length > 0) {
+      nodeJson.content = [{ type: "text", text: line }];
+    }
+    try {
+      nodes.push(ProsemirrorNode.fromJSON(schema, nodeJson));
+    } catch {
+    }
+  });
+  return Slice.maxOpen(Fragment.fromArray(nodes));
+}
+var BLOCK_TAGS = /* @__PURE__ */ new Set([
+  "P",
+  "DIV",
+  "LI",
+  "UL",
+  "OL",
+  "PRE",
+  "BLOCKQUOTE",
+  "TABLE",
+  "TR",
+  "H1",
+  "H2",
+  "H3",
+  "H4",
+  "H5",
+  "H6",
+  "HR"
+]);
+var MENTION_TYPE_ATTRIBUTE = /\bdata-type=["']mention["']/i;
+function getHtmlAttribute(attrs, name) {
+  const match = new RegExp(`\\b${name}=(?:"([^"]*)"|'([^']*)')`, "i").exec(
+    attrs
+  );
+  return match ? match[1] ?? match[2] : void 0;
+}
+function parseHtmlFragment(html) {
+  const template = document.createElement("template");
+  template.innerHTML = html;
+  return template.content;
+}
+function decodeHtmlEntities(text) {
+  return text.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#0*39;/g, "'").replace(/&nbsp;/g, "\xA0").replace(/&amp;/g, "&");
+}
+function htmlToPlainText(html, options = {}) {
+  if (!html) return "";
+  const trackedResolved = stripTrackedChanges(
+    html,
+    options.trackedChanges ?? "accepted"
+  );
+  const mentionNormalized = replaceTagSpans(trackedResolved, "span", MENTION_TYPE_ATTRIBUTE, (match, attrs) => {
+    const label = getHtmlAttribute(attrs, "data-label") || getHtmlAttribute(attrs, "data-id");
+    const role = getHtmlAttribute(attrs, "data-role");
+    const validRole = role && /^[A-Za-z](?:[A-Za-z0-9_-]*[A-Za-z0-9])?$/.test(role) ? role : "";
+    return label ? `@${label}${validRole ? `:${validRole}` : ""}` : match;
+  });
+  if (typeof document !== "undefined") {
+    const fragment = parseHtmlFragment(mentionNormalized);
+    fragment.querySelectorAll("br.ProseMirror-trailingBreak").forEach((br) => br.remove());
+    const lines = [];
+    let current = null;
+    const flush = () => {
+      if (current !== null) {
+        lines.push(current);
+        current = null;
+      }
+    };
+    const visit = (node) => {
+      if (node.nodeType === 3) {
+        const value = node.nodeValue ?? "";
+        if (current === null && value.trim() === "") return;
+        current = (current ?? "") + value;
+        return;
+      }
+      if (node.nodeType !== 1) return;
+      const tag = node.tagName.toUpperCase();
+      if (tag === "BR") {
+        current = (current ?? "") + "\n";
+        return;
+      }
+      if (!BLOCK_TAGS.has(tag)) {
+        node.childNodes.forEach(visit);
+        return;
+      }
+      flush();
+      const linesBefore = lines.length;
+      node.childNodes.forEach(visit);
+      flush();
+      if (lines.length === linesBefore && tag !== "HR") {
+        lines.push("");
+      }
+    };
+    fragment.childNodes.forEach(visit);
+    flush();
+    return lines.join("\n");
+  }
+  const text = mentionNormalized.replace(/<br\s*\/?>/gi, "\n").replace(
+    /<\/(?:p|div|li|pre|blockquote|h[1-6])>(?:\s*<\/(?:li|ul|ol|blockquote|div)>)*/gi,
+    "\n"
+  );
+  return decodeHtmlEntities(stripTags(text)).replace(/\n$/, "");
+}
+function resolvedBlockOperationsHtml(editor, view) {
+  const doc = editor?.state?.doc;
+  if (!doc || view === "all" || typeof document === "undefined") return null;
+  let found = false;
+  doc.descendants((node) => {
+    if (found) return false;
+    if (node.isTextblock) {
+      if (node.attrs?.[BLOCK_CHANGE_ATTRIBUTE]?.operation) found = true;
+      else node.forEach((child) => {
+        if (child.marks.some((mark) => mark.attrs?.[MOVE_ID_ATTRIBUTE])) found = true;
+      });
+      return false;
+    }
+    return true;
+  });
+  if (!found) return null;
+  const resolved = resolveTrackedChanges(doc, view);
+  const container = document.createElement("div");
+  container.appendChild(DOMSerializer.fromSchema(doc.type.schema).serializeFragment(resolved.content));
+  return container.innerHTML;
+}
+function getEditorText(editor, options = {}) {
+  if (!editor) return "";
+  const html = resolvedBlockOperationsHtml(editor, options.trackedChanges ?? "accepted") ?? (typeof editor.getHTML === "function" ? editor.getHTML() : "");
+  if (html) {
+    return htmlToPlainText(html, options);
+  }
+  if (typeof editor.getText === "function") {
+    try {
+      return editor.getText({ blockSeparator: "\n" });
+    } catch {
+      return editor.getText();
+    }
+  }
+  return "";
+}
+function extractMentionsFromDoc(docOrEditor) {
+  if (!docOrEditor) return [];
+  const mentions = [];
+  const doc = docOrEditor?.state?.doc || (typeof docOrEditor?.descendants === "function" ? docOrEditor : null);
+  if (doc && typeof doc.descendants === "function") {
+    doc.descendants((node) => {
+      if (node.type?.name === "mention" && node.attrs) {
+        mentions.push({
+          id: node.attrs.id || "",
+          label: node.attrs.label || "",
+          type: node.attrs.type,
+          avatarUrl: node.attrs.avatarUrl,
+          color: node.attrs.color,
+          ...node.attrs,
+          ...node.attrs.assetRole ? { role: node.attrs.assetRole } : {}
+        });
+      }
+    });
+    return mentions;
+  }
+  if (typeof docOrEditor === "object" && docOrEditor.content) {
+    const walk = (nodes) => {
+      for (const node of nodes) {
+        if (node.type === "mention" && node.attrs) {
+          mentions.push({
+            id: node.attrs.id || "",
+            label: node.attrs.label || "",
+            type: node.attrs.type,
+            avatarUrl: node.attrs.avatarUrl,
+            color: node.attrs.color,
+            ...node.attrs,
+            ...node.attrs.assetRole ? { role: node.attrs.assetRole } : {}
+          });
+        }
+        if (Array.isArray(node.content)) {
+          walk(node.content);
+        }
+      }
+    };
+    walk(docOrEditor.content);
+    return mentions;
+  }
+  if (typeof docOrEditor === "string") {
+    if (typeof document !== "undefined") {
+      parseHtmlFragment(docOrEditor).querySelectorAll('span[data-type="mention"]').forEach((el) => {
+        mentions.push({
+          id: el.getAttribute("data-id") || "",
+          label: el.getAttribute("data-label") || "",
+          type: el.getAttribute("data-type-name") || void 0,
+          avatarUrl: el.getAttribute("data-avatar-url") || void 0,
+          color: el.getAttribute("data-color") || void 0,
+          ...el.getAttribute("data-role") ? { role: el.getAttribute("data-role") } : {}
+        });
+      });
+    } else {
+      for (const span of findTagSpans(docOrEditor, "span", MENTION_TYPE_ATTRIBUTE, false)) {
+        const attrStr = span.attrs;
+        const getAttr = (name) => {
+          const m = new RegExp(`${name}=["']([^"']*)["']`, "i").exec(attrStr);
+          return m ? m[1] : void 0;
+        };
+        mentions.push({
+          id: getAttr("data-id") || "",
+          label: getAttr("data-label") || "",
+          type: getAttr("data-type-name") || getAttr("data-entity-type"),
+          avatarUrl: getAttr("data-avatar-url"),
+          color: getAttr("data-color"),
+          ...getAttr("data-role") ? { role: getAttr("data-role") } : {}
+        });
+      }
+    }
+    if (mentions.length === 0) {
+      const rawHandles = extractMentions(docOrEditor);
+      for (const handle of rawHandles) {
+        mentions.push({
+          id: handle,
+          label: handle,
+          type: "user"
+        });
+      }
+    }
+  }
+  return mentions;
+}
+
+// src/serializers/mentions.ts
+var MARKDOWN_MENTION_SPLIT_REGEX = /(```[\s\S]*?```|~~~[\s\S]*?~~~|<pre[\s\S]*?<\/pre>|<code[\s\S]*?<\/code>|`[^`\n]+`|<span\b[^>]*\b(?:data-type=["']mention["']|class=["'][^"']*pixerate-mention-node[^"']*["']|data-mention=["'][^"']*["'])[^>]*>[\s\S]*?<\/span>|<[^>]+>|\]\([^)]+\)|(?:https?|file|vscode|cursor|mailto):\/\/[^\s<)]+)/gi;
+function stripMarkdownCode(content) {
+  if (!content || typeof content !== "string") return "";
+  let text = replaceDelimited(content, /```/g, "```");
+  text = replaceDelimited(text, /~~~/g, "~~~");
+  text = replaceDelimited(text, /<pre/gi, "</pre>", void 0, true);
+  text = replaceDelimited(text, /<code/gi, "</code>", void 0, true);
+  return text.replace(/`[^`\n]*`/g, "");
+}
+function isMentionNodeAttributes(attrs) {
+  if (/\bdata-type=["']mention["']/i.test(attrs)) return true;
+  const classAttr = /\bclass=(["'])/i.exec(attrs);
+  if (!classAttr) return false;
+  const valueStart = classAttr.index + classAttr[0].length;
+  const valueEnd = attrs.indexOf(classAttr[1], valueStart);
+  return valueEnd !== -1 && attrs.slice(valueStart, valueEnd).includes("pixerate-mention-node");
+}
+function extractMentions(content, options = {}) {
+  if (!content || typeof content !== "string") return [];
+  const details = options.details === true;
+  let normalizedMentionNodes = "";
+  let last = 0;
+  for (const span of findTagSpans(content, "span", isMentionNodeAttributes, true)) {
+    const labelMatch = /\bdata-label=["']([^"']+)["']/i.exec(span.attrs);
+    const idMatch = labelMatch ? null : /\bdata-id=["']([^"']+)["']/i.exec(span.attrs);
+    const inner = content.slice(span.openEnd, span.end - "</span>".length);
+    let replacement = labelMatch ? ` @${labelMatch[1]} ` : idMatch ? ` @${idMatch[1]} ` : ` ${inner} `;
+    if (details && (labelMatch || idMatch)) {
+      const roleMatch = /\bdata-role=["']([^"']+)["']/i.exec(span.attrs);
+      const role = roleMatch && /^[A-Za-z](?:[A-Za-z0-9_-]*[A-Za-z0-9])?$/.test(roleMatch[1]) ? roleMatch[1] : null;
+      const label = (labelMatch ?? idMatch)[1];
+      replacement = ` ${formatMentionHandle(label)}${role ? NODE_ROLE_MARK + role : ""} `;
+    }
+    normalizedMentionNodes += content.slice(last, span.start) + replacement;
+    last = span.end;
+  }
+  normalizedMentionNodes += content.slice(last);
+  const cleanContent = stripMarkdownCode(normalizedMentionNodes);
+  const withoutUrls = cleanContent.replace(/(?:https?|ftp|file|vscode|cursor|mailto):\/\/[^\s<>()]+/gi, "");
+  const withoutLinks = replaceDelimited(withoutUrls, /\]\(/g, ")", () => "]");
+  const textOnly = stripTags(withoutLinks, " ");
+  const mentions = [];
+  const detailed = [];
+  const seen = /* @__PURE__ */ new Set();
+  const regex = new RegExp(MENTION_REGEX.source, "g");
+  let match;
+  while ((match = regex.exec(textOnly)) !== null) {
+    const handle = (match[1] ?? match[2] ?? match[3] ?? "").trim();
+    if (details) {
+      const suffix = readRoleSuffix(textOnly, regex.lastIndex, options.roles);
+      if (suffix) regex.lastIndex = suffix.end;
+      const key = `${handle}\0${suffix?.role ?? ""}`;
+      if (handle && !seen.has(key)) {
+        seen.add(key);
+        detailed.push(suffix ? { handle, role: suffix.role } : { handle });
+      }
+      continue;
+    }
+    if (handle && !seen.has(handle)) {
+      seen.add(handle);
+      mentions.push(handle);
+    }
+  }
+  return details ? detailed : mentions;
+}
+function parseMentionSegments(content, options = {}) {
+  if (!content) return [];
+  const segments = [];
+  const regex = new RegExp(MENTION_REGEX.source, "g");
+  let lastIndex = 0;
+  let match;
+  while ((match = regex.exec(content)) !== null) {
+    const fullMatch = match[0];
+    const atIndex = fullMatch.indexOf("@");
+    const prefix = atIndex > 0 ? fullMatch.slice(0, atIndex) : "";
+    let mentionToken = fullMatch.slice(atIndex);
+    const handle = match[1] ?? match[2] ?? match[3];
+    const matchStart = match.index + prefix.length;
+    const suffix = options.roles && content.charAt(regex.lastIndex) === ":" ? readRoleSuffix(content, regex.lastIndex, options.roles) : null;
+    if (suffix) {
+      mentionToken = content.slice(matchStart, suffix.end);
+      regex.lastIndex = suffix.end;
+    }
+    if (matchStart > lastIndex) {
+      segments.push({
+        type: "text",
+        value: content.slice(lastIndex, matchStart)
+      });
+    }
+    segments.push({
+      type: "mention",
+      value: mentionToken,
+      handle,
+      ...suffix ? { role: suffix.role } : {}
+    });
+    lastIndex = matchStart + mentionToken.length;
+  }
+  if (lastIndex < content.length) {
+    segments.push({
+      type: "text",
+      value: content.slice(lastIndex)
+    });
+  }
+  return segments;
+}
+function preprocessMarkdownMentions(content, optionsOrMentionables = []) {
+  if (!content || typeof content !== "string") return "";
+  const options = Array.isArray(optionsOrMentionables) ? { mentionables: optionsOrMentionables } : optionsOrMentionables;
+  const allMentionables = options.mentionables || [];
+  const defaultType = options.defaultType || "user";
+  const resolveMention = options.resolveMention;
+  const parts = content.split(MARKDOWN_MENTION_SPLIT_REGEX);
+  return parts.map((part) => {
+    if (!part) return "";
+    if (part.startsWith("```") || part.startsWith("~~~") || part.startsWith("`") || part.startsWith("](") || /^(?:https?|file|vscode|cursor|mailto):\/\//i.test(part) || /^<pre[\s>]/i.test(part) || /^<code[\s>]/i.test(part) || /^<[^>]+>$/i.test(part) || /^<span\b[^>]*\b(?:data-type=["']mention["']|class=["'][^"']*pixerate-mention-node[^"']*["']|data-mention=["'][^"']*["'])/i.test(
+      part
+    )) {
+      return part;
+    }
+    const regex = new RegExp(MENTION_REGEX.source, "g");
+    const render = (match2, quotedHandle, escapedQuotedHandle, standardHandle, role) => {
+      const atIndex = match2.indexOf("@");
+      const prefix = atIndex > 0 ? match2.slice(0, atIndex) : "";
+      const rawHandle = (quotedHandle || escapedQuotedHandle || standardHandle || "").trim();
+      if (!rawHandle) return match2;
+      const lowerHandle = rawHandle.toLowerCase();
+      const entity = allMentionables.find((e) => {
+        if (e.label?.toLowerCase() === lowerHandle) return true;
+        if (e.handle?.toLowerCase() === lowerHandle) return true;
+        if (e.name?.toLowerCase() === lowerHandle) return true;
+        if (e.id?.toLowerCase() === lowerHandle) return true;
+        if (e.type === "agent" && `agent${(e.handle || e.label || "").toLowerCase()}` === lowerHandle) return true;
+        if (e.aliases?.some(
+          (a) => a.toLowerCase() === lowerHandle || e.type === "agent" && `agent${a.toLowerCase()}` === lowerHandle
+        )) {
+          return true;
+        }
+        return false;
+      });
+      let id = entity?.id;
+      let label = entity?.label || entity?.handle || rawHandle;
+      let type = entity?.type;
+      let avatarUrl = entity?.avatarUrl;
+      let color = entity?.color || entity?.hexColor;
+      if (!entity) {
+        const customResolved = resolveMention?.(rawHandle);
+        if (customResolved) {
+          id = customResolved.id ?? id;
+          label = customResolved.label ?? customResolved.handle ?? label;
+          type = customResolved.type ?? type;
+          avatarUrl = customResolved.avatarUrl ?? avatarUrl;
+          color = customResolved.color ?? customResolved.hexColor ?? color;
+        } else {
+          const stripped = lowerHandle.replace(/^agent[\s\-_]*/i, "");
+          if (["supervisor", "coordinator", "planner", "validator", "executor"].includes(stripped)) {
+            type = "agent";
+            id = stripped;
+            label = stripped;
+          } else if (lowerHandle === "agents") {
+            type = "team";
+            id = "agents";
+            label = "agents";
+          } else {
+            type = defaultType;
+            id = rawHandle;
+            label = rawHandle;
+          }
+        }
+      }
+      const avatarAttr = avatarUrl ? ` data-avatar-url="${escapeHtml(avatarUrl)}"` : "";
+      const colorAttr = color ? ` data-color="${escapeHtml(color)}"` : "";
+      return `${prefix}<span class="pixerate-mention-node" data-type="mention" data-id="${escapeHtml(
+        id || label
+      )}" data-label="${escapeHtml(label)}" data-mention-suggestion-char="@" data-type-name="${escapeHtml(
+        type || defaultType
+      )}"${avatarAttr}${colorAttr}${role ? ` data-role="${escapeHtml(role)}"` : ""}>@${escapeHtml(label)}</span>`;
+    };
+    if (!options.roles) {
+      return part.replace(
+        regex,
+        (match2, quotedHandle, escapedQuotedHandle, standardHandle) => render(match2, quotedHandle, escapedQuotedHandle, standardHandle)
+      );
+    }
+    let out = "";
+    let last = 0;
+    let match;
+    while ((match = regex.exec(part)) !== null) {
+      const suffix = readRoleSuffix(part, regex.lastIndex, options.roles);
+      const rendered = render(match[0], match[1], match[2], match[3], suffix?.role);
+      if (suffix && rendered !== match[0]) regex.lastIndex = suffix.end;
+      out += part.slice(last, match.index) + rendered;
+      last = regex.lastIndex;
+    }
+    return out + part.slice(last);
+  }).join("");
+}
+
+// src/serializers/markdown.ts
+import MarkdownIt from "markdown-it";
+import taskLists from "markdown-it-task-lists";
+var md = new MarkdownIt({
+  html: true,
+  linkify: true,
+  breaks: true
+}).use(taskLists);
+var defaultValidateLink = md.validateLink;
+md.validateLink = (url) => {
+  if (url.startsWith("file://") || url.startsWith("vscode://") || url.startsWith("cursor://")) {
+    return true;
+  }
+  return defaultValidateLink.call(md, url);
+};
+var ALLOWED_HTML_TAGS = /* @__PURE__ */ new Set([
+  "a",
+  "abbr",
+  "b",
+  "blockquote",
+  "br",
+  "code",
+  "del",
+  "details",
+  "div",
+  "em",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "hr",
+  "i",
+  "img",
+  "input",
+  "kbd",
+  "li",
+  "mark",
+  "ol",
+  "p",
+  "pre",
+  "s",
+  "span",
+  "strong",
+  "sub",
+  "summary",
+  "sup",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "tr",
+  "u",
+  "ul"
+]);
+var ALLOWED_HTML_ATTRS = /* @__PURE__ */ new Set([
+  "alt",
+  "align",
+  "checked",
+  "class",
+  "colspan",
+  "disabled",
+  "height",
+  "href",
+  "rel",
+  "rowspan",
+  "src",
+  "start",
+  "target",
+  "title",
+  "type",
+  "width"
+]);
+var HTML_TAG_REGEX = /<(\/?)([a-zA-Z][a-zA-Z0-9-]*)((?:\s+[^\s"'>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s"'=<>`]+))?)*)\s*\/?>/g;
+var HTML_ATTR_REGEX = /([^\s"'>\/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+function sanitizeTag(tagText, isClosing, rawTagName, rawAttrs, stripDisallowed) {
+  const tagName = rawTagName.toLowerCase();
+  const reject = () => stripDisallowed ? "" : escapeHtml(tagText);
+  if (!ALLOWED_HTML_TAGS.has(tagName)) return reject();
+  if (isClosing) return `</${tagName}>`;
+  if (tagName === "input" && !/\stype\s*=\s*["']?checkbox["']?[\s>/]/i.test(tagText)) {
+    return reject();
+  }
+  let attrs = "";
+  let attrMatch;
+  HTML_ATTR_REGEX.lastIndex = 0;
+  while ((attrMatch = HTML_ATTR_REGEX.exec(rawAttrs)) !== null) {
+    const name = attrMatch[1].toLowerCase();
+    if (!ALLOWED_HTML_ATTRS.has(name) && !/^data-[a-z0-9_.-]+$/.test(name)) {
+      continue;
+    }
+    const rawValue = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4];
+    if (rawValue === void 0) {
+      attrs += ` ${name}`;
+      continue;
+    }
+    const value = md.utils.unescapeAll(rawValue);
+    if ((name === "href" || name === "src") && // Browsers ignore control characters and whitespace inside schemes.
+    !md.validateLink(value.replace(/[\u0000-\u0020\u007f]/g, ""))) {
+      continue;
+    }
+    attrs += ` ${name}="${escapeHtml(value)}"`;
+  }
+  return `<${tagName}${attrs}>`;
+}
+function sanitizeHtml(html, options = {}) {
+  return sanitizeEmbeddedHtml(html, options.disallowedTags === "strip");
+}
+function sanitizeEmbeddedHtml(html, stripDisallowed = false) {
+  let result = "";
+  let lastIndex = 0;
+  let match;
+  HTML_TAG_REGEX.lastIndex = 0;
+  while ((match = HTML_TAG_REGEX.exec(html)) !== null) {
+    result += html.slice(lastIndex, match.index).replace(/</g, "&lt;");
+    result += sanitizeTag(match[0], match[1], match[2], match[3], stripDisallowed);
+    lastIndex = match.index + match[0].length;
+  }
+  return result + html.slice(lastIndex).replace(/</g, "&lt;");
+}
+var defaultHtmlInline = md.renderer.rules.html_inline;
+var defaultHtmlBlock = md.renderer.rules.html_block;
+md.renderer.rules.html_inline = (tokens, idx, options, env, self) => env?.allowUnsafeHtml ? defaultHtmlInline(tokens, idx, options, env, self) : sanitizeEmbeddedHtml(tokens[idx].content);
+md.renderer.rules.html_block = (tokens, idx, options, env, self) => env?.allowUnsafeHtml ? defaultHtmlBlock(tokens, idx, options, env, self) : sanitizeEmbeddedHtml(tokens[idx].content);
+function preprocessMarkdownFileLinks(content) {
+  if (!content) return "";
+  return content.replace(
+    /\[([^\]]+)\]\(((?:file|vscode|cursor):\/\/[^)]+)\)/g,
+    (_match, rawLabel, href) => {
+      const trimmed = rawLabel.trim();
+      const codeMatch = trimmed.match(/^`([^`]+)`$/);
+      const labelContent = codeMatch ? `<code>${escapeHtml(codeMatch[1])}</code>` : escapeHtml(trimmed);
+      return `<a href="${escapeHtml(href)}" data-file-link="true" title="Click to copy file path">${labelContent}</a>`;
+    }
+  );
+}
+function markdownToTipTapHtml(markdown, options) {
+  if (!markdown) return "<p></p>";
+  let content = markdown;
+  if (options?.preprocessFileLinks) {
+    content = preprocessMarkdownFileLinks(content);
+  }
+  if (options?.preprocessMentions || options?.mentionables || options?.preprocessOptions) {
+    const mentionOpts = options.preprocessOptions || {
+      mentionables: options.mentionables
+    };
+    content = preprocessMarkdownMentions(content, mentionOpts);
+  }
+  return md.render(content, { allowUnsafeHtml: options?.allowUnsafeHtml });
+}
+function getEditorMarkdown(editor, options = {}) {
+  if (!editor) return "";
+  const markdown = editor.storage?.markdown;
+  if (typeof markdown?.getMarkdown === "function") {
+    const doc = editor.state?.doc;
+    if (doc && typeof markdown.serializer?.serialize === "function") {
+      const resolved = resolveTrackedChanges(doc, options.trackedChanges ?? "accepted");
+      if (resolved !== doc) return markdown.serializer.serialize(resolved);
+    }
+    return markdown.getMarkdown();
+  }
+  return getEditorText(editor, options);
+}
+
+export {
+  MARKDOWN_MENTION_SPLIT_REGEX,
+  stripMarkdownCode,
+  extractMentions,
+  parseMentionSegments,
+  preprocessMarkdownMentions,
+  escapeHtml,
+  plainTextToTipTapHtml,
+  plainTextToSlice,
+  htmlToPlainText,
+  getEditorText,
+  extractMentionsFromDoc,
+  sanitizeHtml,
+  preprocessMarkdownFileLinks,
+  markdownToTipTapHtml,
+  getEditorMarkdown
+};
+//# sourceMappingURL=chunk-ECCCYKGL.js.map