@aquera/nile-elements 1.9.6 → 1.9.7

package/src/nile-wysiwyg-editor/engine/markdown-parse.ts

@@ -0,0 +1,337 @@
+/**
+ * Markdown → HTML conversion, the import counterpart of ./markdown
+ * (docToMarkdown). Dependency-free and scoped to the same structural subset
+ * the serializer emits: headings, blockquotes, bullet/ordered/task lists
+ * (nested), fenced code blocks, GFM tables, horizontal rules, and the inline
+ * marks (**bold**, *italic*, ~~strike~~, `code`, [links](…), images).
+ *
+ * The output is intentionally plain HTML that the schema's parseDOM rules
+ * understand (e.g. <pre data-language>, <ul data-task-list>), and every
+ * consumer feeds it through htmlToDoc/htmlToSlice — so the schema and the
+ * sanitizer stay the single source of truth for what lands in the document.
+ */
+
+const BULLET_RE = /^(\s*)([-*+])\s+(.*)$/;
+const ORDERED_RE = /^(\s*)(\d+)[.)]\s+(.*)$/;
+const TASK_RE = /^\[([ xX])\]\s+(.*)$/;
+const FENCE_RE = /^\s{0,3}(```+|~~~+)\s*(\S*)\s*$/;
+const HEADING_RE = /^\s{0,3}(#{1,6})\s+(.*)$/;
+const HR_RE = /^\s{0,3}(?:-{3,}|\*{3,}|_{3,})\s*$/;
+const QUOTE_RE = /^\s{0,3}>\s?/;
+const TABLE_DIVIDER_RE = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)*\|?\s*$/;
+
+function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;');
+}
+
+/**
+ * Swaps backslash-escaped Markdown characters for placeholders so the inline
+ * formatter never reads them as syntax; restoreEscapes() puts them back.
+ */
+function protectEscapes(text: string): string {
+  return text.replace(
+    /\\([\\`*_[\]()#+\-.!~|])/g,
+    (_, ch: string) => `\u0000${ch.charCodeAt(0)}\u0000`
+  );
+}
+
+function restoreEscapes(text: string): string {
+  return text.replace(/\u0000(\d+)\u0000/g, (_, code: string) =>
+    String.fromCharCode(Number(code))
+  );
+}
+
+/** Inline formatting for one already-HTML-escaped, code-span-free segment. */
+function formatSpans(escaped: string): string {
+  let out = escaped;
+  // Images before links so ![…](…) is never read as a link.
+  out = out.replace(
+    /!\[([^\]]*)\]\(([^()\s]+)(?:\s+[^)]*)?\)/g,
+    (_, alt: string, src: string) => `<img src="${src}" alt="${alt}">`
+  );
+  out = out.replace(
+    /\[([^\]]+)\]\(([^()\s]+)(?:\s+[^)]*)?\)/g,
+    (_, label: string, href: string) => `<a href="${href}">${label}</a>`
+  );
+  // Bold before italic so '**' is never read as two italics.
+  out = out.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');
+  out = out.replace(/__([^_]+)__/g, '<strong>$1</strong>');
+  out = out.replace(/(^|[^*\w])\*([^*\s](?:[^*]*[^*\s])?)\*/g, '$1<em>$2</em>');
+  out = out.replace(/(^|[^_\w])_([^_\s](?:[^_]*[^_\s])?)_(?![\w])/g, '$1<em>$2</em>');
+  out = out.replace(/~~([^~]+)~~/g, '<s>$1</s>');
+  // Newlines inside one paragraph become hard breaks.
+  out = out.replace(/ *\n/g, '<br>');
+  return out;
+}
+
+/** Inline Markdown → HTML. Code spans are lifted out first to stay literal. */
+export function inlineToHtml(source: string): string {
+  const protectedSrc = protectEscapes(source);
+  const codeRe = /(`+)([^`]|[^`][\s\S]*?[^`])\1(?!`)/;
+  let rest = protectedSrc;
+  let out = '';
+  for (;;) {
+    const match = codeRe.exec(rest);
+    if (!match) {
+      out += formatSpans(escapeHtml(rest));
+      break;
+    }
+    out += formatSpans(escapeHtml(rest.slice(0, match.index)));
+    out += `<code>${escapeHtml(match[2])}</code>`;
+    rest = rest.slice(match.index + match[0].length);
+  }
+  return restoreEscapes(out);
+}
+
+/** True when a line begins a new block construct (ends a paragraph). */
+function isBlockStart(line: string): boolean {
+  return (
+    HEADING_RE.test(line) ||
+    FENCE_RE.test(line) ||
+    HR_RE.test(line) ||
+    QUOTE_RE.test(line) ||
+    BULLET_RE.test(line) ||
+    ORDERED_RE.test(line)
+  );
+}
+
+interface ListItem {
+  lines: string[];
+  checked: boolean | null;
+}
+
+/**
+ * One list region → <ul>/<ol>/task <ul>. Items deeper than the base indent
+ * are re-parsed recursively, so nested and mixed lists come out right. A
+ * base-indent item of the other marker type (bullet vs ordered) ends the
+ * list and starts a sibling one, matching GFM.
+ */
+function parseListRegion(lines: string[]): string {
+  const firstMatch = BULLET_RE.exec(lines[0]) ?? ORDERED_RE.exec(lines[0])!;
+  const baseIndent = firstMatch[1].length;
+  const ordered = ORDERED_RE.test(lines[0]) && !BULLET_RE.test(lines[0]);
+  const startOrder = ordered ? Number(firstMatch[2]) : 1;
+
+  const items: ListItem[] = [];
+  let rest: string[] | null = null;
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const match = ordered ? ORDERED_RE.exec(line) : BULLET_RE.exec(line);
+    const other = ordered ? BULLET_RE.exec(line) : ORDERED_RE.exec(line);
+    if (match && match[1].length <= baseIndent) {
+      let text = match[3];
+      let checked: boolean | null = null;
+      if (!ordered) {
+        const task = TASK_RE.exec(text);
+        if (task) {
+          checked = task[1].toLowerCase() === 'x';
+          text = task[2];
+        }
+      }
+      items.push({ lines: [text], checked });
+    } else if (other && other[1].length <= baseIndent) {
+      // Marker type switched at base level: a sibling list starts here.
+      rest = lines.slice(index);
+      break;
+    } else if (items.length > 0) {
+      // Continuation or nested content: drop the base marker's indent and
+      // keep the relative indent so recursion sees the nesting.
+      items[items.length - 1].lines.push(
+        line.replace(new RegExp(`^\\s{0,${baseIndent + 2}}`), '')
+      );
+    }
+  }
+
+  // Consecutive runs of task/non-task items become separate lists, so a
+  // checklist after a plain list never converts its neighbours.
+  const runs: { task: boolean; items: ListItem[] }[] = [];
+  for (const item of items) {
+    const task = item.checked !== null;
+    const lastRun = runs[runs.length - 1];
+    if (lastRun && lastRun.task === task) lastRun.items.push(item);
+    else runs.push({ task, items: [item] });
+  }
+
+  const rendered = runs
+    .map(run => {
+      const body = run.items
+        .map(item => {
+          const content = parseBlocks(item.lines);
+          return run.task
+            ? `<li data-task-item="true" data-checked="${item.checked === true}">${content}</li>`
+            : `<li>${content}</li>`;
+        })
+        .join('');
+      if (run.task) return `<ul data-task-list="true">${body}</ul>`;
+      if (ordered) {
+        const startAttr = startOrder !== 1 ? ` start="${startOrder}"` : '';
+        return `<ol${startAttr}>${body}</ol>`;
+      }
+      return `<ul>${body}</ul>`;
+    })
+    .join('');
+
+  return rest ? rendered + parseListRegion(rest) : rendered;
+}
+
+/** A GFM table region (header, divider, body rows) → <table>. */
+function parseTableRegion(lines: string[]): string {
+  const splitRow = (line: string): string[] =>
+    line
+      .trim()
+      .replace(/^\|/, '')
+      .replace(/\|$/, '')
+      .split(/(?<!\\)\|/)
+      .map(cell => cell.trim().replace(/\\\|/g, '|'));
+
+  const header = splitRow(lines[0]);
+  const rows = lines.slice(2).map(splitRow);
+  const renderRow = (cells: string[], tag: 'th' | 'td'): string =>
+    `<tr>${header
+      .map((_, index) => `<${tag}><p>${inlineToHtml(cells[index] ?? '')}</p></${tag}>`)
+      .join('')}</tr>`;
+
+  return `<table>${renderRow(header, 'th')}${rows
+    .map(row => renderRow(row, 'td'))
+    .join('')}</table>`;
+}
+
+function parseBlocks(lines: string[]): string {
+  const out: string[] = [];
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line.trim()) {
+      i += 1;
+      continue;
+    }
+
+    // Fenced code block.
+    const fence = FENCE_RE.exec(line);
+    if (fence) {
+      const closing = new RegExp(`^\\s{0,3}${fence[1]}\\s*$`);
+      const buffer: string[] = [];
+      i += 1;
+      while (i < lines.length && !closing.test(lines[i])) {
+        buffer.push(lines[i]);
+        i += 1;
+      }
+      i += 1; // Skip the closing fence.
+      const langAttr = fence[2] ? ` data-language="${escapeHtml(fence[2])}"` : '';
+      out.push(`<pre${langAttr}><code>${escapeHtml(buffer.join('\n'))}</code></pre>`);
+      continue;
+    }
+
+    // Heading (with optional trailing #'s, per CommonMark).
+    const heading = HEADING_RE.exec(line);
+    if (heading) {
+      const level = heading[1].length;
+      const text = heading[2].replace(/\s+#+\s*$/, '');
+      out.push(`<h${level}>${inlineToHtml(text)}</h${level}>`);
+      i += 1;
+      continue;
+    }
+
+    // Horizontal rule (checked before lists: "---" vs "- item").
+    if (HR_RE.test(line)) {
+      out.push('<hr>');
+      i += 1;
+      continue;
+    }
+
+    // Blockquote: consecutive quoted lines, including lazy continuations.
+    if (QUOTE_RE.test(line)) {
+      const buffer: string[] = [];
+      while (
+        i < lines.length &&
+        (QUOTE_RE.test(lines[i]) ||
+          (buffer.length > 0 && lines[i].trim() !== '' && !isBlockStart(lines[i])))
+      ) {
+        buffer.push(lines[i].replace(QUOTE_RE, ''));
+        i += 1;
+      }
+      out.push(`<blockquote>${parseBlocks(buffer)}</blockquote>`);
+      continue;
+    }
+
+    // List: the region runs until a blank line not followed by more list
+    // content, or a non-indented non-list line.
+    if (BULLET_RE.test(line) || ORDERED_RE.test(line)) {
+      const buffer: string[] = [];
+      while (i < lines.length) {
+        const current = lines[i];
+        if (current.trim() === '') {
+          const next = lines[i + 1];
+          if (next !== undefined && (BULLET_RE.test(next) || ORDERED_RE.test(next) || /^\s{2,}\S/.test(next))) {
+            i += 1;
+            continue;
+          }
+          break;
+        }
+        if (
+          !BULLET_RE.test(current) &&
+          !ORDERED_RE.test(current) &&
+          !/^\s{2,}\S/.test(current)
+        ) {
+          break;
+        }
+        buffer.push(current);
+        i += 1;
+      }
+      out.push(parseListRegion(buffer));
+      continue;
+    }
+
+    // GFM table: a pipe row followed by a divider row.
+    if (
+      line.includes('|') &&
+      i + 1 < lines.length &&
+      TABLE_DIVIDER_RE.test(lines[i + 1]) &&
+      lines[i + 1].includes('|')
+    ) {
+      const buffer: string[] = [lines[i], lines[i + 1]];
+      i += 2;
+      while (i < lines.length && lines[i].includes('|') && lines[i].trim() !== '') {
+        buffer.push(lines[i]);
+        i += 1;
+      }
+      out.push(parseTableRegion(buffer));
+      continue;
+    }
+
+    // Paragraph: collect until a blank line or the start of another block.
+    const buffer: string[] = [line];
+    i += 1;
+    while (i < lines.length && lines[i].trim() !== '' && !isBlockStart(lines[i])) {
+      buffer.push(lines[i]);
+      i += 1;
+    }
+    out.push(`<p>${inlineToHtml(buffer.join('\n'))}</p>`);
+  }
+
+  return out.join('');
+}
+
+/** Parses a Markdown string into schema-compatible HTML. */
+export function markdownToHtml(markdown: string): string {
+  return parseBlocks(markdown.replace(/\r\n?/g, '\n').split('\n'));
+}
+
+/**
+ * Conservative sniff for "this plain text is probably Markdown": one block
+ * construct or one unambiguous inline construct is required. HTML-looking
+ * text is never treated as Markdown.
+ */
+export function looksLikeMarkdown(text: string): boolean {
+  if (/<\/?[a-z][^>]*>/i.test(text)) return false;
+  const block =
+    /^\s{0,3}(#{1,6}\s+\S|```|(?:[-*+]|\d+[.)])\s+\S|>\s?\S|\|.+\|)/m;
+  const inline =
+    /\*\*[^*\n]+\*\*|~~[^~\n]+~~|\[[^\]\n]+\]\([^)\n]+\)|`[^`\n]+`/;
+  return block.test(text) || inline.test(text);
+}

package/src/nile-wysiwyg-editor/engine/markdown.ts

@@ -0,0 +1,165 @@
+/**
+ * Document → Markdown projection. A best-effort, dependency-free serializer
+ * covering the structural nodes and the marks Markdown can represent. Styling
+ * marks with no Markdown equivalent (color, background, font family/size) are
+ * dropped to plain text; underline/sub/sup fall back to inline HTML, which
+ * GitHub-flavored Markdown renders. For loss-free round-trips use getHTML().
+ */
+import { Node as PMNode, Mark } from 'prosemirror-model';
+
+/** Escapes the inline characters that would otherwise be read as Markdown. */
+function escapeText(text: string): string {
+  return text.replace(/([\\`*_[\]<>])/g, '\\$1');
+}
+
+/** Wraps a text run in its marks, innermost (code) to outermost (link). */
+function serializeMarks(text: string, marks: readonly Mark[]): string {
+  const has = (name: string): boolean => marks.some(m => m.type.name === name);
+  let out: string;
+  if (has('code')) {
+    const ticks = text.includes('`') ? '``' : '`';
+    out = `${ticks}${text}${ticks}`;
+  } else {
+    out = escapeText(text);
+  }
+  if (has('subscript')) out = `<sub>${out}</sub>`;
+  if (has('superscript')) out = `<sup>${out}</sup>`;
+  if (has('underline')) out = `<u>${out}</u>`;
+  if (has('strike')) out = `~~${out}~~`;
+  if (has('italic')) out = `*${out}*`;
+  if (has('bold')) out = `**${out}**`;
+  const link = marks.find(m => m.type.name === 'link');
+  if (link) out = `[${out}](${link.attrs.href})`;
+  return out;
+}
+
+/** Inline content of a textblock (text runs, breaks, images, mentions). */
+function serializeInline(node: PMNode): string {
+  let result = '';
+  node.forEach(child => {
+    if (child.isText) {
+      result += serializeMarks(child.text ?? '', child.marks);
+    } else if (child.type.name === 'hard_break') {
+      result += '  \n';
+    } else if (child.type.name === 'image') {
+      result += `![${child.attrs.alt ?? ''}](${child.attrs.src})`;
+    } else if (child.type.name === 'mention') {
+      result += `${child.attrs.trigger}${child.attrs.label}`;
+    }
+  });
+  return result;
+}
+
+function serializeChildren(node: PMNode): string {
+  const parts: string[] = [];
+  node.forEach(child => parts.push(serializeBlock(child)));
+  return parts.join('\n\n');
+}
+
+/** One list item: first paragraph on the marker line, the rest indented. */
+function serializeListItem(item: PMNode, marker: string, indent: string): string {
+  const contPad = indent + ' '.repeat(marker.length);
+  const parts: string[] = [];
+  item.forEach(child => {
+    const name = child.type.name;
+    if (name === 'bullet_list') {
+      parts.push(serializeList(child, contPad, null));
+    } else if (name === 'ordered_list') {
+      parts.push(serializeList(child, contPad, child.attrs.order ?? 1));
+    } else if (name === 'task_list') {
+      parts.push(serializeTaskList(child, contPad));
+    } else {
+      parts.push(
+        serializeBlock(child)
+          .split('\n')
+          .map(line => contPad + line)
+          .join('\n')
+      );
+    }
+  });
+  // The first line was padded like a continuation; swap that pad for the
+  // marker (same width, so nested content stays aligned).
+  const body = parts.join('\n');
+  return indent + marker + body.slice(contPad.length);
+}
+
+function serializeList(list: PMNode, indent: string, startOrder: number | null): string {
+  const lines: string[] = [];
+  let order = startOrder ?? 1;
+  list.forEach(item => {
+    lines.push(serializeListItem(item, startOrder === null ? '- ' : `${order}. `, indent));
+    order += 1;
+  });
+  return lines.join('\n');
+}
+
+function serializeTaskList(list: PMNode, indent: string): string {
+  const lines: string[] = [];
+  list.forEach(item => {
+    const box = item.attrs.checked ? '[x] ' : '[ ] ';
+    lines.push(serializeListItem(item, `- ${box}`, indent));
+  });
+  return lines.join('\n');
+}
+
+/** GitHub-flavored table. Cells use the first paragraph's inline text. */
+function serializeTable(table: PMNode): string {
+  const rows: string[][] = [];
+  table.forEach(row => {
+    const cells: string[] = [];
+    row.forEach(cell => {
+      const text = cell.firstChild ? serializeInline(cell.firstChild) : '';
+      cells.push(text.replace(/\n/g, ' ').replace(/\|/g, '\\|').trim());
+    });
+    rows.push(cells);
+  });
+  if (rows.length === 0) return '';
+  const cols = Math.max(...rows.map(r => r.length));
+  const pad = (r: string[]): string[] => {
+    const copy = r.slice();
+    while (copy.length < cols) copy.push('');
+    return copy;
+  };
+  const fmt = (r: string[]): string => `| ${pad(r).join(' | ')} |`;
+  return [
+    fmt(rows[0]),
+    fmt(new Array(cols).fill('---')),
+    ...rows.slice(1).map(fmt),
+  ].join('\n');
+}
+
+function serializeBlock(node: PMNode): string {
+  switch (node.type.name) {
+    case 'paragraph':
+      return serializeInline(node);
+    case 'heading':
+      return `${'#'.repeat(node.attrs.level as number)} ${serializeInline(node)}`;
+    case 'blockquote':
+      return serializeChildren(node)
+        .split('\n')
+        .map(line => (line ? `> ${line}` : '>'))
+        .join('\n');
+    case 'code_block':
+      return `\`\`\`${node.attrs.language ?? ''}\n${node.textContent}\n\`\`\``;
+    case 'horizontal_rule':
+      return '---';
+    case 'bullet_list':
+      return serializeList(node, '', null);
+    case 'ordered_list':
+      return serializeList(node, '', (node.attrs.order as number) ?? 1);
+    case 'task_list':
+      return serializeTaskList(node, '');
+    case 'table':
+      return serializeTable(node);
+    case 'embed':
+      return node.attrs.src as string;
+    default:
+      return node.isTextblock ? serializeInline(node) : serializeChildren(node);
+  }
+}
+
+/** Serializes a document node to a Markdown string. */
+export function docToMarkdown(doc: PMNode): string {
+  const body = serializeChildren(doc).replace(/\n{3,}/g, '\n\n').trim();
+  return body ? `${body}\n` : '';
+}

package/src/nile-wysiwyg-editor/engine/office-paste.ts

@@ -0,0 +1,199 @@
+/**
+ * Paste-from-Office cleanup. Word and Google Docs clipboard HTML carries
+ * heavy proprietary markup — conditional comments, o:/w:/v: namespaced tags,
+ * mso-* styles, and (in Word's case) lists faked as styled paragraphs. This
+ * pre-pass normalizes that into plain HTML *before* the sanitizer runs, so
+ * the schema receives real <ul>/<ol> structures instead of paragraph soup.
+ */
+
+/** Does this clipboard HTML come from Word, Outlook or Google Docs? */
+export function isOfficeHtml(html: string): boolean {
+  return (
+    /class="?Mso|style=["'][^"']*mso-|urn:schemas-microsoft-com|<o:p>|<w:WordDocument/i.test(
+      html
+    ) || /id="?docs-internal-guid/i.test(html)
+  );
+}
+
+/** Does this clipboard HTML come from Excel (or another spreadsheet)? */
+export function isExcelHtml(html: string): boolean {
+  return /urn:schemas-microsoft-com:office:excel|ProgId["']?[^>]*Excel\.Sheet|<x:ExcelWorkbook/i.test(
+    html
+  );
+}
+
+/**
+ * Excel clipboard tables carry cell formatting as `align`/`bgcolor` attributes
+ * and inline styles. The schema keeps a cell's background and a paragraph's
+ * alignment/fonts — so promote the cell's background to a style the cell node
+ * reads, and wrap bare cell text in a paragraph carrying the alignment.
+ */
+function convertExcelCells(body: HTMLElement): void {
+  const doc = body.ownerDocument;
+  for (const cell of Array.from(body.querySelectorAll<HTMLElement>('td, th'))) {
+    const bg = cell.getAttribute('bgcolor');
+    if (bg && !/background/i.test(cell.getAttribute('style') ?? '')) {
+      cell.style.backgroundColor = bg;
+    }
+    const align = cell.getAttribute('align') || cell.style.textAlign;
+    const hasBlock = cell.querySelector('p, div, ul, ol, table, h1, h2, h3, h4, h5, h6');
+    if (!hasBlock && cell.childNodes.length > 0) {
+      const p = doc.createElement('p');
+      if (align) p.style.textAlign = align;
+      while (cell.firstChild) p.appendChild(cell.firstChild);
+      cell.appendChild(p);
+    }
+  }
+}
+
+interface WordListItem {
+  level: number;
+  ordered: boolean;
+  paragraph: HTMLElement;
+}
+
+/** Word marks list paragraphs with an `mso-list: lX levelY` style. */
+function wordListInfo(el: HTMLElement): { level: number } | null {
+  const style = el.getAttribute('style') ?? '';
+  const match = /mso-list:[^;"]*\blevel(\d+)/i.exec(style);
+  if (match) return { level: Number(match[1]) };
+  // Some Word variants only set the class.
+  if (/\bMsoListParagraph/i.test(el.className) && /mso-list/i.test(style)) {
+    return { level: 1 };
+  }
+  return null;
+}
+
+/**
+ * The bullet/number marker Word renders as a literal span. Ordered markers
+ * look like "1." / "a)" / "iv."; bullets are symbol characters (·, o, §).
+ */
+function extractWordMarker(paragraph: HTMLElement): { ordered: boolean } {
+  let ordered = false;
+  // The marker lives in a span with mso-list:Ignore (or inside the
+  // conditional comment we already stripped, leaving the bare text).
+  const spans = paragraph.querySelectorAll('span');
+  for (const span of Array.from(spans)) {
+    if (/mso-list:\s*ignore/i.test(span.getAttribute('style') ?? '')) {
+      ordered = /^\s*(\d+|[a-z]{1,4}|[ivxlc]+)[.)]/i.test(span.textContent ?? '');
+      span.remove();
+      return { ordered };
+    }
+  }
+  // Fallback: leading "1." / "a)" text in the paragraph itself.
+  const text = paragraph.textContent ?? '';
+  const lead = /^\s*(\d+|[a-z])[.)]\s+/i.exec(text);
+  if (lead) {
+    ordered = true;
+    const first = paragraph.firstChild;
+    if (first?.nodeType === Node.TEXT_NODE) {
+      first.textContent = (first.textContent ?? '').replace(/^\s*\S+[.)]\s+/, '');
+    }
+  }
+  return { ordered };
+}
+
+/** Converts consecutive Word list paragraphs into real nested ul/ol lists. */
+function convertWordLists(body: HTMLElement): void {
+  const doc = body.ownerDocument;
+  const paragraphs = Array.from(body.querySelectorAll('p'));
+  let run: WordListItem[] = [];
+
+  const flush = (): void => {
+    if (run.length === 0) return;
+    const anchor = run[0].paragraph;
+    // Build nested lists by level (Word levels start at 1).
+    const roots: HTMLElement[] = [];
+    const stack: { level: number; list: HTMLElement }[] = [];
+    for (const item of run) {
+      while (stack.length > 0 && stack[stack.length - 1].level > item.level) {
+        stack.pop();
+      }
+      if (stack.length === 0 || stack[stack.length - 1].level < item.level) {
+        const list = doc.createElement(item.ordered ? 'ol' : 'ul');
+        if (stack.length === 0) {
+          roots.push(list);
+        } else {
+          const parentItems = stack[stack.length - 1].list.children;
+          const parentLi = parentItems[parentItems.length - 1] ?? null;
+          (parentLi ?? stack[stack.length - 1].list).appendChild(list);
+        }
+        stack.push({ level: item.level, list });
+      }
+      const li = doc.createElement('li');
+      const p = doc.createElement('p');
+      p.innerHTML = item.paragraph.innerHTML;
+      li.appendChild(p);
+      stack[stack.length - 1].list.appendChild(li);
+    }
+    anchor.before(...roots);
+    for (const item of run) item.paragraph.remove();
+    run = [];
+  };
+
+  for (const paragraph of paragraphs) {
+    const info = wordListInfo(paragraph);
+    if (info) {
+      const { ordered } = extractWordMarker(paragraph);
+      run.push({ level: info.level, ordered, paragraph });
+    } else {
+      flush();
+    }
+  }
+  flush();
+}
+
+/** Normalizes Word/Google Docs clipboard HTML into plain semantic HTML. */
+export function cleanOfficeHtml(html: string): string {
+  // Conditional comments carry list markers and VML — drop them first, while
+  // this is still a string ("<![if !supportLists]>…<![endif]>" variants too).
+  let cleaned = html
+    .replace(/<!--\[if[\s\S]*?<!\[endif\]-->/gi, '')
+    .replace(/<!\[if[\s\S]*?<!\[endif\]>/gi, '')
+    .replace(/<!--[\s\S]*?-->/g, '');
+
+  const doc = new DOMParser().parseFromString(cleaned, 'text/html');
+  const body = doc.body;
+
+  // Namespaced Office elements (<o:p>, <w:…>, <v:…>): unwrap, keeping text.
+  for (const el of Array.from(body.querySelectorAll('*'))) {
+    if (el.tagName.includes(':')) {
+      el.replaceWith(...Array.from(el.childNodes));
+    }
+  }
+
+  // Google Docs wraps the payload in <b id="docs-internal-guid-…"
+  // style="font-weight:normal"> — unwrap so nothing reads it as bold.
+  for (const el of Array.from(body.querySelectorAll('b[id^="docs-internal-guid"]'))) {
+    el.replaceWith(...Array.from(el.childNodes));
+  }
+
+  convertWordLists(body);
+
+  // Excel: preserve cell background and per-cell text alignment.
+  if (isExcelHtml(html)) convertExcelCells(body);
+
+  // Strip Mso classes and mso-* style declarations; the sanitizer would drop
+  // most of this anyway, but clearing it here keeps parsing predictable.
+  for (const el of Array.from(body.querySelectorAll<HTMLElement>('*'))) {
+    if (/\bMso/i.test(el.className)) el.removeAttribute('class');
+    const style = el.getAttribute('style');
+    if (style && /mso-/i.test(style)) {
+      const kept = style
+        .split(';')
+        .filter(decl => decl.trim() && !/^\s*mso-/i.test(decl))
+        .join(';');
+      if (kept.trim()) el.setAttribute('style', kept);
+      else el.removeAttribute('style');
+    }
+  }
+
+  // Empty paragraphs Word uses for spacing (only &nbsp; inside).
+  for (const p of Array.from(body.querySelectorAll('p'))) {
+    if ((p.textContent ?? '').replace(/ /g, '').trim() === '' && !p.querySelector('img')) {
+      p.remove();
+    }
+  }
+
+  return body.innerHTML;
+}