@pixerate/editor 0.23.0 → 0.24.0

package/dist/chunk-XNORY7M6.cjs

@@ -0,0 +1,685 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkD27YFC46cjs = require('./chunk-D27YFC46.cjs');
+
+// src/serializers/plain-text.ts
+var _model = require('@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(_model.Node.fromJSON(schema, nodeJson));
+    } catch (e2) {
+    }
+  });
+  return _model.Slice.maxOpen(_model.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 ? _nullishCoalesce(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,
+    _nullishCoalesce(options.trackedChanges, () => ( "accepted"))
+  );
+  const mentionNormalized = replaceTagSpans(trackedResolved, "span", MENTION_TYPE_ATTRIBUTE, (match, attrs) => {
+    const label = getHtmlAttribute(attrs, "data-label") || getHtmlAttribute(attrs, "data-id");
+    return label ? `@${label}` : 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 = _nullishCoalesce(node.nodeValue, () => ( ""));
+        if (current === null && value.trim() === "") return;
+        current = (_nullishCoalesce(current, () => ( ""))) + value;
+        return;
+      }
+      if (node.nodeType !== 1) return;
+      const tag = node.tagName.toUpperCase();
+      if (tag === "BR") {
+        current = (_nullishCoalesce(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 = _optionalChain([editor, 'optionalAccess', _ => _.state, 'optionalAccess', _2 => _2.doc]);
+  if (!doc || view === "all" || typeof document === "undefined") return null;
+  let found = false;
+  doc.descendants((node) => {
+    if (found) return false;
+    if (node.isTextblock) {
+      if (_optionalChain([node, 'access', _3 => _3.attrs, 'optionalAccess', _4 => _4[_chunkD27YFC46cjs.BLOCK_CHANGE_ATTRIBUTE], 'optionalAccess', _5 => _5.operation])) found = true;
+      return false;
+    }
+    return true;
+  });
+  if (!found) return null;
+  const resolved = _chunkD27YFC46cjs.resolveTrackedChanges.call(void 0, doc, view);
+  const container = document.createElement("div");
+  container.appendChild(_model.DOMSerializer.fromSchema(doc.type.schema).serializeFragment(resolved.content));
+  return container.innerHTML;
+}
+function getEditorText(editor, options = {}) {
+  if (!editor) return "";
+  const html = _nullishCoalesce(resolvedBlockOperationsHtml(editor, _nullishCoalesce(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 (e3) {
+      return editor.getText();
+    }
+  }
+  return "";
+}
+function extractMentionsFromDoc(docOrEditor) {
+  if (!docOrEditor) return [];
+  const mentions = [];
+  const doc = _optionalChain([docOrEditor, 'optionalAccess', _6 => _6.state, 'optionalAccess', _7 => _7.doc]) || (typeof _optionalChain([docOrEditor, 'optionalAccess', _8 => _8.descendants]) === "function" ? docOrEditor : null);
+  if (doc && typeof doc.descendants === "function") {
+    doc.descendants((node) => {
+      if (_optionalChain([node, 'access', _9 => _9.type, 'optionalAccess', _10 => _10.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
+        });
+      }
+    });
+    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
+          });
+        }
+        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
+        });
+      });
+    } 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")
+        });
+      }
+    }
+    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 MENTION_REGEX = /(?:^|[\s>(*_"';\\/[\]{}~`:]|&quot;|&gt;|&lt;|&amp;)@(?:"([^"]+)"|&quot;([^&]+)&quot;|([a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)*))/g;
+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) {
+  if (!content || typeof content !== "string") return [];
+  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);
+    const replacement = labelMatch ? ` @${labelMatch[1]} ` : idMatch ? ` @${idMatch[1]} ` : ` ${inner} `;
+    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 seen = /* @__PURE__ */ new Set();
+  const regex = new RegExp(MENTION_REGEX.source, "g");
+  let match;
+  while ((match = regex.exec(textOnly)) !== null) {
+    const handle = (_nullishCoalesce(_nullishCoalesce(_nullishCoalesce(match[1], () => ( match[2])), () => ( match[3])), () => ( ""))).trim();
+    if (handle && !seen.has(handle)) {
+      seen.add(handle);
+      mentions.push(handle);
+    }
+  }
+  return mentions;
+}
+function parseMentionSegments(content) {
+  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) : "";
+    const mentionToken = fullMatch.slice(atIndex);
+    const handle = _nullishCoalesce(_nullishCoalesce(match[1], () => ( match[2])), () => ( match[3]));
+    const matchStart = match.index + prefix.length;
+    if (matchStart > lastIndex) {
+      segments.push({
+        type: "text",
+        value: content.slice(lastIndex, matchStart)
+      });
+    }
+    segments.push({
+      type: "mention",
+      value: mentionToken,
+      handle
+    });
+    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");
+    return part.replace(regex, (match, quotedHandle, escapedQuotedHandle, standardHandle) => {
+      const atIndex = match.indexOf("@");
+      const prefix = atIndex > 0 ? match.slice(0, atIndex) : "";
+      const rawHandle = (quotedHandle || escapedQuotedHandle || standardHandle || "").trim();
+      if (!rawHandle) return match;
+      const lowerHandle = rawHandle.toLowerCase();
+      const entity = allMentionables.find((e) => {
+        if (_optionalChain([e, 'access', _11 => _11.label, 'optionalAccess', _12 => _12.toLowerCase, 'call', _13 => _13()]) === lowerHandle) return true;
+        if (_optionalChain([e, 'access', _14 => _14.handle, 'optionalAccess', _15 => _15.toLowerCase, 'call', _16 => _16()]) === lowerHandle) return true;
+        if (_optionalChain([e, 'access', _17 => _17.name, 'optionalAccess', _18 => _18.toLowerCase, 'call', _19 => _19()]) === lowerHandle) return true;
+        if (_optionalChain([e, 'access', _20 => _20.id, 'optionalAccess', _21 => _21.toLowerCase, 'call', _22 => _22()]) === lowerHandle) return true;
+        if (e.type === "agent" && `agent${(e.handle || e.label || "").toLowerCase()}` === lowerHandle) return true;
+        if (_optionalChain([e, 'access', _23 => _23.aliases, 'optionalAccess', _24 => _24.some, 'call', _25 => _25(
+          (a) => a.toLowerCase() === lowerHandle || e.type === "agent" && `agent${a.toLowerCase()}` === lowerHandle
+        )])) {
+          return true;
+        }
+        return false;
+      });
+      let id = _optionalChain([entity, 'optionalAccess', _26 => _26.id]);
+      let label = _optionalChain([entity, 'optionalAccess', _27 => _27.label]) || _optionalChain([entity, 'optionalAccess', _28 => _28.handle]) || rawHandle;
+      let type = _optionalChain([entity, 'optionalAccess', _29 => _29.type]);
+      let avatarUrl = _optionalChain([entity, 'optionalAccess', _30 => _30.avatarUrl]);
+      let color = _optionalChain([entity, 'optionalAccess', _31 => _31.color]) || _optionalChain([entity, 'optionalAccess', _32 => _32.hexColor]);
+      if (!entity) {
+        const customResolved = _optionalChain([resolveMention, 'optionalCall', _33 => _33(rawHandle)]);
+        if (customResolved) {
+          id = _nullishCoalesce(customResolved.id, () => ( id));
+          label = _nullishCoalesce(_nullishCoalesce(customResolved.label, () => ( customResolved.handle)), () => ( label));
+          type = _nullishCoalesce(customResolved.type, () => ( type));
+          avatarUrl = _nullishCoalesce(customResolved.avatarUrl, () => ( avatarUrl));
+          color = _nullishCoalesce(_nullishCoalesce(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}>@${escapeHtml(label)}</span>`;
+    });
+  }).join("");
+}
+
+// src/serializers/markdown.ts
+var _markdownit = require('markdown-it'); var _markdownit2 = _interopRequireDefault(_markdownit);
+var _markdownittasklists = require('markdown-it-task-lists'); var _markdownittasklists2 = _interopRequireDefault(_markdownittasklists);
+var md = new (0, _markdownit2.default)({
+  html: true,
+  linkify: true,
+  breaks: true
+}).use(_markdownittasklists2.default);
+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 = _nullishCoalesce(_nullishCoalesce(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) => _optionalChain([env, 'optionalAccess', _34 => _34.allowUnsafeHtml]) ? defaultHtmlInline(tokens, idx, options, env, self) : sanitizeEmbeddedHtml(tokens[idx].content);
+md.renderer.rules.html_block = (tokens, idx, options, env, self) => _optionalChain([env, 'optionalAccess', _35 => _35.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 (_optionalChain([options, 'optionalAccess', _36 => _36.preprocessFileLinks])) {
+    content = preprocessMarkdownFileLinks(content);
+  }
+  if (_optionalChain([options, 'optionalAccess', _37 => _37.preprocessMentions]) || _optionalChain([options, 'optionalAccess', _38 => _38.mentionables]) || _optionalChain([options, 'optionalAccess', _39 => _39.preprocessOptions])) {
+    const mentionOpts = options.preprocessOptions || {
+      mentionables: options.mentionables
+    };
+    content = preprocessMarkdownMentions(content, mentionOpts);
+  }
+  return md.render(content, { allowUnsafeHtml: _optionalChain([options, 'optionalAccess', _40 => _40.allowUnsafeHtml]) });
+}
+function getEditorMarkdown(editor, options = {}) {
+  if (!editor) return "";
+  const markdown = _optionalChain([editor, 'access', _41 => _41.storage, 'optionalAccess', _42 => _42.markdown]);
+  if (typeof _optionalChain([markdown, 'optionalAccess', _43 => _43.getMarkdown]) === "function") {
+    const doc = _optionalChain([editor, 'access', _44 => _44.state, 'optionalAccess', _45 => _45.doc]);
+    if (doc && typeof _optionalChain([markdown, 'access', _46 => _46.serializer, 'optionalAccess', _47 => _47.serialize]) === "function") {
+      const resolved = _chunkD27YFC46cjs.resolveTrackedChanges.call(void 0, doc, _nullishCoalesce(options.trackedChanges, () => ( "accepted")));
+      if (resolved !== doc) return markdown.serializer.serialize(resolved);
+    }
+    return markdown.getMarkdown();
+  }
+  return getEditorText(editor, options);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.MENTION_REGEX = MENTION_REGEX; exports.MARKDOWN_MENTION_SPLIT_REGEX = MARKDOWN_MENTION_SPLIT_REGEX; exports.stripMarkdownCode = stripMarkdownCode; exports.extractMentions = extractMentions; exports.parseMentionSegments = parseMentionSegments; exports.preprocessMarkdownMentions = preprocessMarkdownMentions; exports.escapeHtml = escapeHtml; exports.plainTextToTipTapHtml = plainTextToTipTapHtml; exports.plainTextToSlice = plainTextToSlice; exports.htmlToPlainText = htmlToPlainText; exports.getEditorText = getEditorText; exports.extractMentionsFromDoc = extractMentionsFromDoc; exports.sanitizeHtml = sanitizeHtml; exports.preprocessMarkdownFileLinks = preprocessMarkdownFileLinks; exports.markdownToTipTapHtml = markdownToTipTapHtml; exports.getEditorMarkdown = getEditorMarkdown;
+//# sourceMappingURL=chunk-XNORY7M6.cjs.map