@ai-matrx/rich-editor 0.0.0 → 0.1.1

package/dist/core/markdown-serialize.js

@@ -0,0 +1,394 @@
+import { assertTableReadsBack, freshRow, respliceRow, splitRowSegments } from "@ai-matrx/rich-content/utils/table-source";
+function createSerializeContext(adjacency = /* @__PURE__ */ new Map(), reuse) {
+  return { adjacency, claimed: /* @__PURE__ */ new Set(), reuse };
+}
+const DEFAULT_BULLET = "-";
+const DEFAULT_BOLD = "**";
+const DEFAULT_ITALIC = "*";
+const DEFAULT_STRIKE = "~~";
+function attr(node, key) {
+  const value = node.attrs[key];
+  return value === void 0 || value === null ? null : value;
+}
+function claim(node, ctx) {
+  const id = attr(node, "mdId");
+  if (!id || ctx.claimed.has(id)) return null;
+  ctx.claimed.add(id);
+  return id;
+}
+function separator(prevId, id, fallback, ctx) {
+  if (prevId && id) {
+    const adjacency = ctx.adjacency.get(prevId);
+    if (adjacency && adjacency.next === id) return adjacency.trail;
+  }
+  return fallback;
+}
+function isDroppableEmpty(node) {
+  return node.isTextblock && node.content.size === 0;
+}
+function serializeChildren(parent, kind, ctx) {
+  let out = "";
+  let prevId = null;
+  let first = true;
+  parent.forEach((child) => {
+    const id = claim(child, ctx);
+    const reused = id && ctx.reuse ? ctx.reuse(id, child) : null;
+    const body = reused ?? serializeBlock(child, ctx);
+    if (body === "" && isDroppableEmpty(child)) return;
+    if (!first) {
+      const fallback = kind === "listItem" && (child.type.name === "bulletList" || child.type.name === "orderedList") ? "\n" : "\n\n";
+      out += separator(prevId, id, fallback, ctx);
+    }
+    out += body;
+    first = false;
+    prevId = id;
+  });
+  if (kind === "wrapper" && prevId) {
+    const adjacency = ctx.adjacency.get(prevId);
+    if (adjacency && adjacency.next === null) out += adjacency.trail;
+  }
+  return out;
+}
+function serializeBlock(node, ctx) {
+  switch (node.type.name) {
+    case "paragraph":
+      return serializeInline(node);
+    case "heading":
+      return serializeHeading(node);
+    case "bulletList":
+    case "orderedList":
+      return serializeList(node, ctx);
+    case "listItem":
+      return serializeListItem(node, DEFAULT_BULLET, ctx);
+    case "blockquote":
+      return serializeBlockquote(node, ctx);
+    case "horizontalRule":
+      return attr(node, "mdRaw") ?? "---";
+    case "table":
+      return serializeTable(node);
+    case "sourceLocked":
+    case "islandBlock":
+      return String(node.attrs.raw ?? "");
+    case "sourceBlock":
+      return serializeChildren(node, "wrapper", ctx);
+    case "doc":
+      return serializeChildren(node, "doc", ctx);
+    default:
+      return node.textContent;
+  }
+}
+function serializeHeading(node) {
+  const level = Number(node.attrs.level) || 1;
+  const text = serializeInline(node);
+  let open = attr(node, "mdOpen");
+  let close = attr(node, "mdClose") ?? "";
+  if (open !== null) {
+    const setext = close.startsWith("\n");
+    if (setext) {
+      if (level > 2) open = null;
+      else {
+        const underline = level === 1 ? "=" : "-";
+        const lineLength = Math.max(3, close.length - 1);
+        const expected = close.slice(1).trimEnd();
+        if (!expected.split("").every((char) => char === underline)) {
+          close = "\n" + underline.repeat(lineLength);
+        }
+        return open + text + close;
+      }
+    } else {
+      const atx = /^ {0,3}(#{1,6})(?=[ \t]|$)/.exec(open);
+      if (!atx || (atx[1] ?? "").length !== level) open = null;
+    }
+  }
+  if (open === null) {
+    open = `${"#".repeat(level)} `;
+    close = "";
+  }
+  return open + text.replace(/\n/g, " ") + close;
+}
+function nextMarker(ordered, prev, start, index) {
+  if (!ordered) return prev && /^[-*+]$/.test(prev) ? prev : DEFAULT_BULLET;
+  if (prev) {
+    const match = /^(\d+)([.)])$/.exec(prev);
+    if (match) return `${Number(match[1]) + 1}${match[2]}`;
+  }
+  return `${start + index}.`;
+}
+function serializeList(list, ctx) {
+  const ordered = list.type.name === "orderedList";
+  const start = Number(list.attrs.start ?? 1) || 1;
+  let out = "";
+  let prevId = null;
+  let prevMarker = null;
+  let index = 0;
+  list.forEach((item) => {
+    const id = claim(item, ctx);
+    const stored = attr(item, "mdMarker");
+    const marker = stored && (ordered ? /^\d+[.)]$/.test(stored) : /^[-*+]$/.test(stored)) ? stored : nextMarker(ordered, prevMarker, start, index);
+    const body = serializeListItem(item, marker, ctx);
+    if (index > 0) out += separator(prevId, id, "\n", ctx);
+    out += body;
+    prevId = id;
+    prevMarker = marker;
+    index += 1;
+  });
+  return out;
+}
+function serializeListItem(item, marker, ctx) {
+  const lead = attr(item, "mdLead") ?? "";
+  const after = attr(item, "mdAfter") ?? " ";
+  const task = attr(item, "mdTask") ?? "";
+  const body = serializeChildren(item, "listItem", ctx);
+  const head = lead + marker;
+  if (body === "") return task ? `${head}${after || " "}${task}`.trimEnd() : head;
+  const indent = attr(item, "mdIndent") ?? (lead + marker + (after || " ")).length;
+  const pad = " ".repeat(indent);
+  const lines = body.split("\n");
+  let out = head + (after || " ") + task + (lines[0] ?? "");
+  for (const line of lines.slice(1)) out += `
+${line === "" ? "" : pad + line}`;
+  return out;
+}
+function serializeBlockquote(node, ctx) {
+  const prefix = attr(node, "mdPrefix") ?? "> ";
+  const alert = attr(node, "mdAlert");
+  const children = serializeChildren(node, "blockquote", ctx);
+  const body = alert ? children ? `${alert}
+${children}` : alert : children;
+  return body.split("\n").map((line) => line === "" ? prefix.trimEnd() : prefix + line).join("\n");
+}
+function cellText(cell) {
+  const paragraph = cell.firstChild;
+  return paragraph ? serializeInline(paragraph) : "";
+}
+function delimiterFor(align, width) {
+  if (width === void 0) {
+    if (align === "left") return ":---";
+    if (align === "right") return "---:";
+    if (align === "center") return ":---:";
+    return "---";
+  }
+  const n = Math.max(width, 3);
+  if (align === "left") return `:${"-".repeat(n - 1)}`;
+  if (align === "right") return `${"-".repeat(n - 1)}:`;
+  if (align === "center") return `:${"-".repeat(n - 2)}:`;
+  return "-".repeat(n);
+}
+function alignOfDelimiter(cell) {
+  const core = cell.trim();
+  const left = core.startsWith(":");
+  const right = core.endsWith(":");
+  if (left && right) return "center";
+  if (left) return "left";
+  if (right) return "right";
+  return null;
+}
+function respliceDelimiter(stored, aligns, lead, trail) {
+  const segments = splitRowSegments(stored);
+  const first = lead ? 1 : 0;
+  const last = trail ? segments.length - 1 : segments.length;
+  const cells = segments.slice(first, last);
+  if (cells.length !== aligns.length) return null;
+  const next = cells.map((cell, index) => {
+    const align = aligns[index] ?? null;
+    if (alignOfDelimiter(cell) === align) return cell;
+    const core = cell.trim();
+    const start = cell.indexOf(core);
+    return `${cell.slice(0, start)}${delimiterFor(align, core.length)}${cell.slice(start + core.length)}`;
+  });
+  return [...segments.slice(0, first), ...next, ...segments.slice(last)].join("|");
+}
+function parseJsonArray(value) {
+  if (!value) return null;
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function serializeTable(table) {
+  const pipes = attr(table, "mdPipes") ?? "both";
+  const lead = pipes === "both" || pipes === "lead";
+  const trail = pipes === "both" || pipes === "trail";
+  const lines = [];
+  let aligns = [];
+  table.forEach((row, _offset, index) => {
+    const cells = [];
+    row.forEach((cell) => cells.push(cell));
+    if (index === 0) {
+      aligns = cells.map((cell) => cell.attrs.align ?? null);
+    }
+    const texts = cells.map(cellText);
+    const stored = parseJsonArray(attr(row, "mdCells"));
+    const raw = attr(row, "mdRaw");
+    let line;
+    if (raw !== null && stored && JSON.stringify(stored) === JSON.stringify(texts)) {
+      line = raw;
+    } else {
+      line = respliceRow(parseJsonArray(attr(row, "mdSegs")), stored, texts) ?? freshRow(texts, lead, trail);
+    }
+    lines.push(line);
+    if (index === 0) {
+      const storedAligns = attr(table, "mdAligns");
+      const delim = attr(table, "mdDelim");
+      const fresh = () => freshRow(aligns.map((align) => delimiterFor(align)), lead, trail);
+      lines.push(
+        delim === null ? fresh() : storedAligns === JSON.stringify(aligns) ? delim : respliceDelimiter(delim, aligns, lead, trail) ?? fresh()
+      );
+    }
+  });
+  const written = lines.join("\n");
+  assertTableReadsBack(written);
+  return written;
+}
+const MARK_RANK = {
+  link: 0,
+  bold: 1,
+  italic: 2,
+  strike: 3,
+  code: 4
+};
+const ESCAPABLE = /[!-/:-@[-`{-~]/g;
+function leafText(node) {
+  if (node.isText) {
+    const text = node.text ?? "";
+    return node.marks.some((mark) => mark.type.name === "mdEscape") ? text.replace(ESCAPABLE, "\\$&") : text;
+  }
+  if (node.type.name === "inlineIsland") return String(node.attrs.raw ?? "");
+  if (node.type.name === "hardBreak") return attr(node, "mdRaw") ?? "\n";
+  return node.textContent;
+}
+function literalText(node, followed) {
+  const text = leafText(node);
+  if (!node.isText || node.marks.some((mark) => mark.type.name === "mdEscape" || mark.type.name === "code")) return text;
+  let out = text.replace(/\\(?=[!-/:-@[-`{-~])/g, "\\\\");
+  if (followed && /(^|[^\\])(\\\\)*\\$/.test(out)) out += "\\";
+  return out;
+}
+function longestBacktickRun(text) {
+  let longest = 0;
+  for (const match of text.matchAll(/`+/g)) {
+    longest = Math.max(longest, match[0].length);
+  }
+  return longest;
+}
+function markDelimiters(mark, runText) {
+  switch (mark.type.name) {
+    case "bold": {
+      const marker = attr(mark, "mdMarker") ?? DEFAULT_BOLD;
+      return [marker, marker];
+    }
+    case "italic": {
+      const marker = attr(mark, "mdMarker") ?? DEFAULT_ITALIC;
+      return [marker, marker];
+    }
+    case "strike": {
+      const marker = attr(mark, "mdMarker") ?? DEFAULT_STRIKE;
+      return [marker, marker];
+    }
+    case "code": {
+      const open = attr(mark, "mdOpen");
+      const close = attr(mark, "mdClose");
+      if (open !== null && close !== null) return [open, close];
+      const ticks = "`".repeat(longestBacktickRun(runText) + 1);
+      const pad = runText.startsWith("`") || runText.endsWith("`") ? " " : "";
+      return [ticks + pad, pad + ticks];
+    }
+    case "link": {
+      const href = String(mark.attrs.href ?? "");
+      const form = attr(mark, "mdForm");
+      const hrefUnchanged = href === attr(mark, "mdTailHref");
+      if ((form === "angle" || form === "bare") && hrefUnchanged && runText === attr(mark, "mdText")) {
+        return form === "angle" ? ["<", ">"] : ["", ""];
+      }
+      const storedTail = attr(mark, "mdTail");
+      const title = attr(mark, "title");
+      const tail = form === "inline" && storedTail !== null && hrefUnchanged ? storedTail : `(${href}${title ? ` "${title}"` : ""})`;
+      return ["[", `]${tail}`];
+    }
+    default:
+      return ["", ""];
+  }
+}
+const EDGE_SENSITIVE_MARKS = /* @__PURE__ */ new Set(["bold", "italic", "strike"]);
+function hoistEdgeWhitespace(items) {
+  const out = [...items];
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (let i = 0; i < out.length && !changed; i += 1) {
+      const node = out[i];
+      if (!node?.isText || !node.text) continue;
+      const text = node.text;
+      for (const mark of node.marks) {
+        if (!EDGE_SENSITIVE_MARKS.has(mark.type.name)) continue;
+        const startsRun = !mark.isInSet(out[i - 1]?.marks ?? []);
+        const endsRun = !mark.isInSet(out[i + 1]?.marks ?? []);
+        const lead = startsRun ? /^\s+/.exec(text)?.[0] ?? "" : "";
+        const trail = endsRun && lead.length < text.length ? /\s+$/.exec(text)?.[0] ?? "" : "";
+        if (!lead && !trail) continue;
+        const bare = mark.removeFromSet(node.marks);
+        const body = text.slice(lead.length, text.length - trail.length);
+        const pieces = [];
+        if (lead) pieces.push(node.type.schema.text(lead, bare));
+        if (body) pieces.push(node.type.schema.text(body, node.marks));
+        if (trail) pieces.push(node.type.schema.text(trail, bare));
+        out.splice(i, 1, ...pieces);
+        changed = true;
+        break;
+      }
+    }
+  }
+  return out;
+}
+function serializeInline(parent) {
+  const children = [];
+  parent.forEach((child) => children.push(child));
+  const items = hoistEdgeWhitespace(children);
+  const others = (node) => (node?.marks ?? []).filter((m) => m.type.name !== "code");
+  const sameOthers = (a, b) => {
+    const x = others(a);
+    const y = others(b);
+    return x.length === y.length && x.every((mark) => mark.isInSet(y));
+  };
+  const runEnd = (from, mark) => {
+    let end = from;
+    while (end < items.length && mark.isInSet(items[end]?.marks ?? []) && (mark.type.name !== "code" || sameOthers(items[from], items[end]))) {
+      end += 1;
+    }
+    return end;
+  };
+  const runText = (from, to) => items.slice(from, to).map((node) => leafText(node)).join("");
+  let out = "";
+  const stack = [];
+  items.forEach((node, index) => {
+    const marks = node.marks;
+    let keep = 0;
+    while (keep < stack.length && stack[keep]?.mark.isInSet(marks) && (stack[keep]?.end ?? 0) > index) keep += 1;
+    for (let k = stack.length - 1; k >= keep; k -= 1) out += stack[k]?.close ?? "";
+    stack.length = keep;
+    const toOpen = marks.filter((mark) => !stack.some((open) => open.mark.eq(mark))).map((mark) => ({ mark, end: runEnd(index, mark) }));
+    toOpen.sort((a, b) => {
+      if (a.end !== b.end) return b.end - a.end;
+      const da = attr(a.mark, "mdDepth") ?? Number.MAX_SAFE_INTEGER;
+      const db = attr(b.mark, "mdDepth") ?? Number.MAX_SAFE_INTEGER;
+      if (da !== db) return da - db;
+      return (MARK_RANK[a.mark.type.name] ?? 9) - (MARK_RANK[b.mark.type.name] ?? 9);
+    });
+    for (const { mark, end } of toOpen) {
+      const [open, close] = markDelimiters(mark, runText(index, end));
+      out += open;
+      stack.push({ mark, close, end });
+    }
+    out += literalText(node, index < items.length - 1 || node.marks.some((mark) => mark.type.name !== "mdEscape"));
+  });
+  for (let k = stack.length - 1; k >= 0; k -= 1) out += stack[k]?.close ?? "";
+  return out;
+}
+export {
+  createSerializeContext,
+  serializeBlock,
+  serializeChildren,
+  serializeInline
+};

package/dist/core/outline.d.ts

@@ -0,0 +1,17 @@
+export interface OutlineEntry {
+    level: number;
+    text: string;
+    slug: string;
+    /** UTF-16 offset of the heading line in the source. */
+    offset: number;
+}
+/**
+ * Plain heading text: inline markdown markers and link targets dropped.
+ * `{{variables}}` stay exactly as written, and an underscore INSIDE a word
+ * (`site_name`, `file_name_here`) is text, not emphasis.
+ */
+export declare function headingPlainText(raw: string): string;
+/** Slugs for a list of heading texts, de-duplicated the way the renderer does (`-1`, `-2`). */
+export declare function slugsFor(texts: readonly string[]): string[];
+/** Outline of the source text: ATX and setext headings outside every island. */
+export declare function outlineOf(text: string): OutlineEntry[];

package/dist/core/outline.js

@@ -0,0 +1,41 @@
+import GithubSlugger from "github-slugger";
+import { tokenizeSource } from "@ai-matrx/content-ir/source";
+function headingPlainText(raw) {
+  const kept = [];
+  const hold = (text) => `\0${kept.push(text) - 1}\0`;
+  return raw.replace(/\{\{[^{}\n]*\}\}/g, hold).replace(/!\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/[*~`]+/g, "").replace(/(?<![\p{L}\p{N}])_+|_+(?![\p{L}\p{N}])/gu, "").replace(/\s+#+\s*$/, "").replace(/\u0000(\d+)\u0000/g, (_, index) => kept[Number(index)] ?? "").trim();
+}
+function slugsFor(texts) {
+  const slugger = new GithubSlugger();
+  return texts.map((text) => slugger.slug(text));
+}
+function outlineOf(text) {
+  const found = [];
+  for (const block of tokenizeSource(text)) {
+    if (block.kind !== "prose") continue;
+    const lines = block.raw.split("\n");
+    let offset = block.start;
+    lines.forEach((line, index) => {
+      const atx = /^ {0,3}(#{1,6})[ \t]+(.+?)\s*$/.exec(line) ?? /^ {0,3}(#{1,6})\s*$/.exec(line);
+      if (atx) {
+        found.push({ level: atx[1]?.length ?? 1, text: headingPlainText(atx[2] ?? ""), offset });
+      } else {
+        const next = lines[index + 1];
+        if (line.trim() && next !== void 0 && /^ {0,3}(=+|-+)[ \t]*$/.test(next) && !/^ {0,3}[-*+] /.test(line)) {
+          const level = next.trim().startsWith("=") ? 1 : 2;
+          if (level === 1 || next.trim().length >= 2) {
+            found.push({ level, text: headingPlainText(line), offset });
+          }
+        }
+      }
+      offset += line.length + 1;
+    });
+  }
+  const slugs = slugsFor(found.map((entry) => entry.text));
+  return found.map((entry, index) => ({ ...entry, slug: slugs[index] ?? "" }));
+}
+export {
+  headingPlainText,
+  outlineOf,
+  slugsFor
+};

package/dist/core/paste-html.d.ts

@@ -0,0 +1,10 @@
+export interface PastedHtmlResult {
+    html: string;
+    /** Merged cells split so every column lines up (colspan + rowspan extras). */
+    mergedCellsSplit: number;
+    tables: number;
+}
+/** Normalize pasted HTML (see header): literal markdown characters escaped, tables squared. */
+export declare function normalizePastedHtml(html: string): PastedHtmlResult;
+/** The one sentence a person sees when merged cells were split. */
+export declare function mergedCellsNotice(count: number): string | null;

package/dist/core/paste-html.js

@@ -0,0 +1,198 @@
+const BLOCK_TAGS = /* @__PURE__ */ new Set([
+  "P",
+  "DIV",
+  "SECTION",
+  "ARTICLE",
+  "HEADER",
+  "FOOTER",
+  "ASIDE",
+  "NAV",
+  "H1",
+  "H2",
+  "H3",
+  "H4",
+  "H5",
+  "H6",
+  "BLOCKQUOTE",
+  "PRE",
+  "FIGURE",
+  "FIGCAPTION",
+  "DL",
+  "DT",
+  "DD",
+  "HR",
+  "ADDRESS",
+  "DETAILS",
+  "SUMMARY"
+]);
+const LIST_TAGS = /* @__PURE__ */ new Set(["UL", "OL"]);
+function text(doc, value) {
+  return doc.createTextNode(value);
+}
+function flattenCell(cell) {
+  const doc = cell.ownerDocument;
+  for (const nested of Array.from(cell.querySelectorAll("table"))) {
+    nested.replaceWith(text(doc, (nested.textContent ?? "").replace(/\s+/g, " ").trim()));
+  }
+  for (const br of Array.from(cell.querySelectorAll("br"))) br.replaceWith(text(doc, " "));
+  for (const list of Array.from(cell.querySelectorAll("ul, ol")).reverse()) {
+    const fragment = doc.createDocumentFragment();
+    const items = Array.from(list.children).filter((child) => child.tagName === "LI");
+    items.forEach((item, index) => {
+      if (index > 0) fragment.append(text(doc, "; "));
+      fragment.append(...Array.from(item.childNodes));
+    });
+    fragment.append(text(doc, " "));
+    list.replaceWith(fragment);
+  }
+  for (const block of Array.from(cell.querySelectorAll("*")).reverse()) {
+    if (!BLOCK_TAGS.has(block.tagName) && !LIST_TAGS.has(block.tagName) && block.tagName !== "LI") continue;
+    if (block.tagName === "HR") {
+      block.replaceWith(text(doc, " "));
+      continue;
+    }
+    const fragment = doc.createDocumentFragment();
+    fragment.append(text(doc, " "), ...Array.from(block.childNodes), text(doc, " "));
+    block.replaceWith(fragment);
+  }
+  const walker = doc.createTreeWalker(cell, NodeFilter.SHOW_TEXT);
+  const nodes = [];
+  for (let node = walker.nextNode(); node; node = walker.nextNode()) nodes.push(node);
+  for (const node of nodes) node.data = node.data.replace(/\s+/g, " ");
+  const first = nodes[0];
+  const last = nodes[nodes.length - 1];
+  if (first) first.data = first.data.replace(/^ /, "");
+  if (last) last.data = last.data.replace(/ $/, "");
+}
+function rowsOf(table) {
+  return Array.from(table.rows);
+}
+function emptyCell(like) {
+  return like.ownerDocument.createElement(like.tagName === "TH" ? "th" : "td");
+}
+function span(cell, name) {
+  return Math.max(1, Math.min(Number(cell.getAttribute(name)) || 1, 1e3));
+}
+function squareTable(table) {
+  const rows = rowsOf(table);
+  let added = 0;
+  const pending = rows.map(() => []);
+  rows.forEach((row, r) => {
+    for (const cell of Array.from(row.cells)) {
+      const colspan = span(cell, "colspan");
+      const rowspan = span(cell, "rowspan");
+      cell.removeAttribute("colspan");
+      let anchor = cell;
+      for (let extra = 1; extra < colspan; extra += 1) {
+        const blank = emptyCell(cell);
+        if (rowspan > 1) blank.setAttribute("rowspan", String(rowspan));
+        anchor.after(blank);
+        anchor = blank;
+        added += 1;
+      }
+    }
+    for (const [column, like] of (pending[r] ?? []).sort((a, b) => a[0] - b[0])) {
+      const blank = emptyCell(like);
+      const before = row.cells[column];
+      if (before) row.insertBefore(blank, before);
+      else row.append(blank);
+      added += 1;
+    }
+    Array.from(row.cells).forEach((cell, column) => {
+      const rowspan = span(cell, "rowspan");
+      cell.removeAttribute("rowspan");
+      for (let down = 1; down < rowspan && r + down < rows.length; down += 1) pending[r + down]?.push([column, cell]);
+    });
+  });
+  const width = Math.max(0, ...rows.map((row) => row.cells.length));
+  for (const row of rows) {
+    while (row.cells.length < width) {
+      row.append(emptyCell(row.cells[0] ?? row.ownerDocument.createElement("td")));
+    }
+  }
+  return added;
+}
+const LITERAL_SKIP = /* @__PURE__ */ new Set(["CODE", "PRE", "KBD", "SAMP", "SCRIPT", "STYLE", "TEXTAREA"]);
+function literalAt(text2, index) {
+  const ch = text2[index];
+  const prev = text2[index - 1] ?? "";
+  const next = text2[index + 1] ?? "";
+  const loose = (/\s/.test(prev) || !prev) && (/\s/.test(next) || !next);
+  if (ch === "`" || ch === "\\") return true;
+  if (ch === "*") return !loose;
+  if (ch === "_") return !loose && !(/[\p{L}\p{N}]/u.test(prev) && /[\p{L}\p{N}]/u.test(next));
+  if (ch === "~") return prev === "~" || next === "~";
+  if (ch === "<") return /[A-Za-z/!?]/.test(next);
+  return false;
+}
+function escapeLiteralMarkdown(root) {
+  const doc = root.ownerDocument ?? document;
+  const walker = doc.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+  const texts = [];
+  for (let node = walker.nextNode(); node; node = walker.nextNode()) {
+    let parent = node.parentElement;
+    let skip = false;
+    while (parent) {
+      if (LITERAL_SKIP.has(parent.tagName) || parent.hasAttribute("data-md-escape")) {
+        skip = true;
+        break;
+      }
+      parent = parent.parentElement;
+    }
+    const textNode = node;
+    if (!skip && /[*`\\_~<]/.test(textNode.data)) texts.push(textNode);
+  }
+  for (const node of texts) {
+    const data = node.data;
+    const fragment = doc.createDocumentFragment();
+    let run = "";
+    for (let index = 0; index < data.length; index += 1) {
+      if (!literalAt(data, index)) {
+        run += data[index];
+        continue;
+      }
+      if (run) fragment.append(doc.createTextNode(run));
+      run = "";
+      const span2 = doc.createElement("span");
+      span2.setAttribute("data-md-escape", "");
+      span2.textContent = data[index] ?? "";
+      fragment.append(span2);
+    }
+    if (run) fragment.append(doc.createTextNode(run));
+    node.replaceWith(fragment);
+  }
+}
+function normalizePastedHtml(html) {
+  const hasTable = /<table[\s>]/i.test(html);
+  if (!hasTable && !/[*`\\_~<]/.test(html.replace(/<[^>]*>/g, ""))) return { html, mergedCellsSplit: 0, tables: 0 };
+  const template = document.createElement("template");
+  template.innerHTML = html;
+  escapeLiteralMarkdown(template.content);
+  if (!hasTable) return { html: template.innerHTML, mergedCellsSplit: 0, tables: 0 };
+  const tables = Array.from(template.content.querySelectorAll("table")).filter(
+    // Outermost tables only: a nested one is flattened into its parent's cell.
+    (table) => !table.parentElement?.closest("table")
+  );
+  let mergedCellsSplit = 0;
+  for (const table of tables) {
+    for (const caption of Array.from(table.querySelectorAll(":scope > caption"))) {
+      const line = template.ownerDocument.createElement("p");
+      line.append(...Array.from(caption.childNodes));
+      table.before(line);
+      caption.remove();
+    }
+    mergedCellsSplit += squareTable(table);
+    for (const row of rowsOf(table)) {
+      for (const cell of Array.from(row.cells)) flattenCell(cell);
+    }
+  }
+  return { html: template.innerHTML, mergedCellsSplit, tables: tables.length };
+}
+function mergedCellsNotice(count) {
+  if (count <= 0) return null;
+  return `${count} merged table ${count === 1 ? "cell was" : "cells were"} split into separate cells so every column lines up \u2014 check the pasted table.`;
+}
+export {
+  mergedCellsNotice,
+  normalizePastedHtml
+};

package/dist/core/paste-markdown.d.ts

@@ -0,0 +1,18 @@
+import { Extension } from "@tiptap/core";
+import { Slice, type Schema } from "@tiptap/pm/model";
+import { type Transaction } from "@tiptap/pm/state";
+/** Markdown text → the slice the visual editor inserts for it. */
+export declare function markdownToSlice(text: string, schema: Schema): Slice;
+/**
+ * Text a host inserts at the caret (the right-click menu's Insert reference…,
+ * a content block, an AI result's Replace, dictation) lands exactly as a paste
+ * of that text would: through the ONE parse path. Inserting it as literal
+ * characters turned a ```matrx fence into three paragraphs of raw JSON in the
+ * visual view (2026-10-02) — a fence must arrive as its island.
+ */
+export declare function replaceSelectionWithMarkdown(tr: Transaction, schema: Schema, text: string): void;
+export interface MarkdownTextPasteOptions {
+    /** Told when a paste changed shape on the way in (merged table cells split). */
+    onNotice: ((message: string) => void) | null;
+}
+export declare const MarkdownTextPaste: Extension<MarkdownTextPasteOptions, any>;