npm - autumnnote - Versions diffs - 2.0.0 → 2.2.0 - Mend

autumnnote 2.0.0 → 2.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (64) hide show

package/README.md +72 -5
package/dist/autumnnote.cjs +20 -20
package/dist/autumnnote.css +1 -1
package/dist/autumnnote.es.js +661 -798
package/dist/autumnnote.es.js.map +1 -1
package/dist/autumnnote.min.js +20 -20
package/dist/autumnnote.umd.js +20 -20
package/dist/autumnnote.umd.js.map +1 -1
package/dist/icon-data-V0Xqv-wX.js +255 -0
package/dist/icon-data-V0Xqv-wX.js.map +1 -0
package/package.json +13 -4
package/types/index.d.ts +8 -0
package/src/js/Context.js +0 -854
package/src/js/core/detectLang.js +0 -98
package/src/js/core/dom.js +0 -372
package/src/js/core/env.js +0 -25
package/src/js/core/key.js +0 -66
package/src/js/core/lists.js +0 -121
package/src/js/core/markdown.js +0 -695
package/src/js/core/range.js +0 -194
package/src/js/core/sanitise.js +0 -231
package/src/js/editing/History.js +0 -266
package/src/js/editing/Style.js +0 -812
package/src/js/editing/Table.js +0 -105
package/src/js/editing/Typing.js +0 -397
package/src/js/index.js +0 -193
package/src/js/index.umd.js +0 -17
package/src/js/module/AutoSaveRestore.js +0 -125
package/src/js/module/BaseDialog.js +0 -133
package/src/js/module/BaseMediaTooltip.js +0 -142
package/src/js/module/BaseResizer.js +0 -312
package/src/js/module/BubbleToolbar.js +0 -483
package/src/js/module/Buttons.js +0 -399
package/src/js/module/Clipboard.js +0 -579
package/src/js/module/CodeTooltip.js +0 -493
package/src/js/module/Codeview.js +0 -125
package/src/js/module/ContextMenu.js +0 -621
package/src/js/module/Editor.js +0 -747
package/src/js/module/EmojiDialog.js +0 -254
package/src/js/module/FindReplace.js +0 -512
package/src/js/module/Fullscreen.js +0 -80
package/src/js/module/IconDialog.js +0 -618
package/src/js/module/ImageCropOverlay.js +0 -586
package/src/js/module/ImageDialog.js +0 -193
package/src/js/module/ImageResizer.js +0 -42
package/src/js/module/ImageTooltip.js +0 -285
package/src/js/module/LinkDialog.js +0 -145
package/src/js/module/LinkTooltip.js +0 -250
package/src/js/module/MarkdownShortcuts.js +0 -250
package/src/js/module/Mention.js +0 -365
package/src/js/module/Placeholder.js +0 -51
package/src/js/module/ShortcutsDialog.js +0 -111
package/src/js/module/SlashMenu.js +0 -376
package/src/js/module/Statusbar.js +0 -246
package/src/js/module/TableTooltip.js +0 -1521
package/src/js/module/Toolbar.js +0 -750
package/src/js/module/VideoDialog.js +0 -193
package/src/js/module/VideoResizer.js +0 -66
package/src/js/module/VideoTooltip.js +0 -248
package/src/js/module/emoji-data.js +0 -496
package/src/js/renderer.js +0 -120
package/src/js/settings.js +0 -214
package/src/styles/_variables.scss +0 -48
package/src/styles/autumnnote.scss +0 -2866

package/src/js/core/markdown.js DELETED Viewed

@@ -1,695 +0,0 @@
-/**
- * markdown.js - Lightweight Markdown → HTML converter for paste handling.
- *
- * Handles: headings H1–H6, bold/italic/strikethrough/inline-code, fenced code
- * blocks (with language), blockquotes, unordered/ordered lists, horizontal
- * rules, links, images, and plain paragraphs.
- *
- * The HTML output MUST be passed through sanitiseHTML() before insertion.
- */
-/**
- * Converts an HTML string to Markdown.
- * Handles: headings, paragraphs, bold/italic/del/code, links, images,
- * unordered/ordered lists, blockquote, pre/code blocks, tables, hr.
- * @param {string} html
- * @returns {string}
- */
-export function htmlToMarkdown(html) {
-  const doc = new DOMParser().parseFromString(`<body>${html || ''}</body>`, 'text/html');
-  return _domToMd(doc.body).replace(/\n{3,}/g, '\n\n').trim();
-}
-/**
- * Convert a DOM node subtree into Markdown.
- *
- * Recursively produces a Markdown string representing the given DOM node and its descendants,
- * handling common HTML constructs such as paragraphs, headings, lists (with nested indentation),
- * blockquotes, fenced and inline code, links, images, tables, horizontal rules, and basic inline emphasis.
- *
- * @param {Node} node - The DOM node to convert.
- * @param {number} [depth=0] - Current nesting depth used to indent nested list items.
- * @returns {string} The Markdown representation of the node subtree.
- */
-/**
- * Direct child elements matching a tag name. Used instead of the CSS
- * `:scope > tag` combinator, which this project's jsdom version resolves
- * incorrectly (matches descendants at any depth, not just direct children).
- * @param {Element} el
- * @param {string} tagName
- * @returns {Element[]}
- */
-function _directChildren(el, tagName) {
-  return Array.from(el.children).filter((c) => c.tagName === tagName.toUpperCase());
-}
-function _domToMd(node, depth = 0) {
-  if (node.nodeType === 3) {
-    return node.textContent.replace(/\s+/g, ' ');
-  }
-  if (node.nodeType !== 1) return '';
-  const el = /** @type {Element} */ (node);
-  const tag = el.nodeName.toLowerCase();
-  const inner = () => Array.from(el.childNodes).map(n => _domToMd(n, depth)).join('');
-  switch (tag) {
-    case 'p':
-    case 'div':      return `\n\n${inner()}\n\n`;
-    case 'br':       return '  \n';
-    case 'h1':       return `\n\n# ${inner()}\n\n`;
-    case 'h2':       return `\n\n## ${inner()}\n\n`;
-    case 'h3':       return `\n\n### ${inner()}\n\n`;
-    case 'h4':       return `\n\n#### ${inner()}\n\n`;
-    case 'h5':       return `\n\n##### ${inner()}\n\n`;
-    case 'h6':       return `\n\n###### ${inner()}\n\n`;
-    case 'strong':
-    case 'b':        return `**${inner()}**`;
-    case 'em':
-    case 'i':        return `*${inner()}*`;
-    case 'del':
-    case 's':
-    case 'strike':   return `~~${inner()}~~`;
-    case 'sup':      return `^${inner()}^`;
-    case 'sub':      return `~${inner()}~`;
-    case 'u':        return `<u>${inner()}</u>`;
-    case 'span': {
-      // Markdown has no native underline/color/size syntax; pass through as
-      // raw inline HTML for the specific styles the editor's own toolbar
-      // creates (foreColor/backColor/fontSize) — other noise spans (e.g. from
-      // pasted content) are unwrapped to plain text as before.
-      const style = el.getAttribute('style') || '';
-      if (/\b(color|background-color|font-size)\s*:/.test(style)) {
-        return `<span style="${_escAttr(style)}">${inner()}</span>`;
-      }
-      return inner();
-    }
-    case 'code': {
-      // Inside <pre> we emit raw text; outside we wrap in backticks
-      if (el.closest('pre')) return inner();
-      return `\`${inner()}\``;
-    }
-    case 'pre': {
-      const codeEl = el.querySelector('code');
-      const langMatch = /language-(\S+)/.exec(codeEl?.className || '');
-      const lang = langMatch ? langMatch[1] : '';
-      const content = (codeEl || el).textContent || '';
-      return `\n\n\`\`\`${lang}\n${content}\n\`\`\`\n\n`;
-    }
-    case 'blockquote': {
-      const rawLines = inner().trim().split('\n');
-      // Collapse consecutive blank lines (from adjacent <p> blocks) into one.
-      const lines = rawLines.filter((l, idx) => l.trim() !== '' || (rawLines[idx - 1] ?? '').trim() !== '');
-      return `\n\n${lines.map((l) => (l.trim() === '' ? '>' : `> ${l}`)).join('\n')}\n\n`;
-    }
-    case 'a': {
-      const href = el.getAttribute('href') || '';
-      return `[${inner()}](${href})`;
-    }
-    case 'img': {
-      const src = el.getAttribute('src') || '';
-      const alt = el.getAttribute('alt') || '';
-      return `![${alt}](${src})`;
-    }
-    case 'ul': {
-      const items = _directChildren(el, 'li');
-      if (!items.length) return inner();
-      const indent = '  '.repeat(depth);
-      const isChecklist = el.classList.contains('an-checklist');
-      const lines = items.map((li) => {
-        const cb = /** @type {HTMLInputElement | undefined} */ (
-          _directChildren(li, 'input').find((c) => c.getAttribute('type') === 'checkbox')
-        );
-        let prefix = '- ';
-        if (isChecklist || cb) {
-          const checked = cb ? cb.checked : false;
-          prefix = checked ? '- [x] ' : '- [ ] ';
-        }
-        return `${indent}${prefix}${_domToMd(li, depth + 1).trim()}`;
-      }).join('\n');
-      return depth === 0 ? `\n\n${lines}\n\n` : `\n${lines}`;
-    }
-    case 'ol': {
-      const items = _directChildren(el, 'li');
-      if (!items.length) return inner();
-      const indent = '  '.repeat(depth);
-      const lines = items.map((li, i) => `${indent}${i + 1}. ${_domToMd(li, depth + 1).trim()}`).join('\n');
-      return depth === 0 ? `\n\n${lines}\n\n` : `\n${lines}`;
-    }
-    case 'li':  return inner();
-    case 'hr':  return '\n\n---\n\n';
-    case 'table': {
-      const allRows = Array.from(el.querySelectorAll('tr'));
-      if (!allRows.length) return inner();
-      const theadEl = _directChildren(el, 'thead')[0];
-      const firstRowIsHeader = !!theadEl || (
-        allRows[0].children.length > 0 &&
-        Array.from(allRows[0].children).every((c) => c.tagName === 'TH')
-      );
-      const cellTexts = allRows.map((tr) =>
-        Array.from(tr.querySelectorAll('th, td')).map((c) => c.textContent.trim().replaceAll('|', String.raw`\|`)),
-      );
-      const cols = Math.max(...cellTexts.map((r) => r.length));
-      const padRow = (row) => { const r = [...row]; while (r.length < cols) r.push(''); return r; };
-      const bodyStart = firstRowIsHeader ? 1 : 0;
-      const headerCells = firstRowIsHeader ? padRow(cellTexts[0]) : new Array(cols).fill('');
-      let md = '\n\n';
-      md += `| ${headerCells.join(' | ')} |\n`;
-      md += `| ${new Array(cols).fill('---').join(' | ')} |\n`;
-      for (let r = bodyStart; r < cellTexts.length; r++) {
-        md += `| ${padRow(cellTexts[r]).join(' | ')} |\n`;
-      }
-      return md + '\n';
-    }
-    default: return inner();
-  }
-}
-/**
- * Detects whether a string likely contains Markdown syntax.
- *
- * Checks for common Markdown constructs such as ATX headings, unordered or
- * ordered list items, blockquotes, fenced code blocks, and bold emphasis.
- * @param {string} text - Input text to inspect for Markdown patterns.
- * @returns {boolean} `true` if any Markdown-like pattern is present, `false` otherwise.
- */
-export function isMarkdown(text) {
-  return /^#{1,6} [^\s]|^[ \t]*[-*+] [^\s]|^[ \t]*\d+\. [^\s]|^> ?[^\s]|^```|^\*{2}[^*\n]+\*{2}/m.test(text)
-    || /^.+\n=+\s*$/m.test(text)
-    || /^.+\n-{2,}\s*$/m.test(text)
-    || /^---\s*\n(?:[\s\S]*?\n)?(?:---|\.\.\.)\s*(?:\n|$)/.test(text)
-    || /^\|.+\|[ \t]*\n\|[ \t:|-]+\|/m.test(text);
-}
-// Blockquote line: optional up-to-3 leading spaces, '>', optional single space, rest of line.
-const BQ_RE = /^ {0,3}>( ?)(.*)$/;
-// Horizontal rule: 3+ of the same character (-, * or _), optionally space-separated.
-const HR_RE = /^ {0,3}([-*_])( *\1){2,}\s*$/;
-// Hard-break marker — placed between paragraph lines that end in a
-// CommonMark hard-break (trailing 2+ spaces or a trailing backslash),
-// restored to <br> after _inline() runs. Distinct from _inline()'s own MARK.
-const HARD_BREAK = String.fromCharCode(1);
-/**
- * Converts a Markdown string to an HTML string.
- * @param {string} text
- * @returns {string}
- */
-export function markdownToHTML(text) {
-  let lines = text.replaceAll('\r\n', '\n').replaceAll('\r', '\n').split('\n');
-  lines = _stripFrontmatter(lines);
-  const refs = _extractReferenceDefinitions(lines);
-  lines = refs.clean;
-  _linkDefs = refs.linkDefs;
-  _footnoteIds = refs.footnoteIds;
-  return _parseBlocks(lines);
-}
-/**
- * Parses a line array into block-level HTML. Called recursively for content
- * nested inside a blockquote so nested quotes and block content (lists,
- * headings, etc.) inside `>` are parsed the same as top-level content.
- * @param {string[]} lines
- * @returns {string}
- */
-function _parseBlocks(lines) {
-  const out = [];
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i];
-    // ---- Fenced code block ``` lang ... ``` -----------------------------------
-    const fenceMatch = /^```(\S*)$/.exec(line);
-    if (fenceMatch) {
-      const lang = fenceMatch[1];
-      const codeLines = [];
-      i++;
-      while (i < lines.length && !lines[i].startsWith('```')) {
-        codeLines.push(_esc(lines[i]));
-        i++;
-      }
-      const langAttr = lang ? ` class="language-${_escAttr(lang)}"` : '';
-      out.push(`<pre><code${langAttr}>${codeLines.join('\n')}</code></pre>`);
-      i++; // skip closing ```
-      continue;
-    }
-    // ---- Setext headings (Title\n=== or Title\n---) -------------------------
-    if (line.trim() && !HR_RE.test(line) && !/^#{1,6} /.test(line) && i + 1 < lines.length) {
-      if (/^=+\s*$/.test(lines[i + 1])) {
-        out.push(`<h1>${_inline(line.trim())}</h1>`);
-        i += 2;
-        continue;
-      }
-      if (/^-{2,}\s*$/.test(lines[i + 1])) {
-        out.push(`<h2>${_inline(line.trim())}</h2>`);
-        i += 2;
-        continue;
-      }
-    }
-    // ---- Horizontal rule --- / *** / ___ / - - - / * * * ----------------------
-    if (HR_RE.test(line)) {
-      out.push('<hr>');
-      i++;
-      continue;
-    }
-    // ---- ATX Headings # – ######  -------------------------------------------
-    const hMatch = /^(#{1,6})\s+(.+)$/.exec(line);
-    if (hMatch) {
-      const level = hMatch[1].length;
-      // Strip an optional closing sequence of #'s (e.g. "## Heading ##"),
-      // only when preceded by whitespace — "Heading#" (no space) is untouched.
-      const content = hMatch[2].replace(/(?:^|\s)#+\s*$/, '');
-      out.push(`<h${level}>${_inline(content)}</h${level}>`);
-      i++;
-      continue;
-    }
-    // ---- Blockquote  > text --------------------------------------------------
-    if (BQ_RE.test(line)) {
-      const bqLines = [];
-      while (i < lines.length && BQ_RE.test(lines[i])) {
-        bqLines.push(BQ_RE.exec(lines[i])[2]);
-        i++;
-      }
-      out.push(`<blockquote>${_parseBlocks(bqLines)}</blockquote>`);
-      continue;
-    }
-    // ---- Checklist or Unordered list  - / * / + item  ----------------------
-    if (/^[-*+] /.test(line)) {
-      const { html: listHtml, endIdx } = _parseListBlock(lines, i);
-      out.push(listHtml); i = endIdx; continue;
-    }
-    // ---- Ordered list  1. item  ----------------------------------------------
-    if (/^\d+\. /.test(line)) {
-      const { html: listHtml, endIdx } = _parseListBlock(lines, i);
-      out.push(listHtml); i = endIdx; continue;
-    }
-    // ---- Blank line ----------------------------------------------------------
-    if (line.trim() === '') {
-      i++;
-      continue;
-    }
-    // ---- GFM Table  | col | col | -------------------------------------------
-    // A table starts with a pipe-prefixed or pipe-containing line followed by
-    // a separator row (| --- | --- |). We detect and collect all rows.
-    if (/^\|.+\|/.test(line) && i + 1 < lines.length && /^\|[\s|:-]+\|/.test(lines[i + 1])) {
-      const headerCells = _parseTableRow(line);
-      const alignments = _parseTableRow(lines[i + 1]).map((c) => {
-        if (c.startsWith(':') && c.endsWith(':')) return 'center';
-        if (c.endsWith(':')) return 'right';
-        if (c.startsWith(':')) return 'left';
-        return null;
-      });
-      i += 2; // skip header + separator
-      const bodyRows = [];
-      while (i < lines.length && /^\|.+\|/.test(lines[i])) {
-        bodyRows.push(_parseTableRow(lines[i]));
-        i++;
-      }
-      const _cell = (tag, content, align) => {
-        const s = align ? ` style="text-align:${align}"` : '';
-        return `<${tag}${s}>${_inline(content)}</${tag}>`;
-      };
-      const thCells = headerCells.map((c, idx) => _cell('th', c, alignments[idx])).join('');
-      const thead = `<thead><tr>${thCells}</tr></thead>`;
-      const renderRow = (row) => `<tr>${row.map((c, idx) => _cell('td', c, alignments[idx])).join('')}</tr>`;
-      const tbody = bodyRows.length ? `<tbody>${bodyRows.map(renderRow).join('')}</tbody>` : '';
-      out.push(`<table>${thead}${tbody}</table>`);
-      continue;
-    }
-    // ---- Paragraph: collect consecutive non-block lines ---------------------
-    const paraLines = [];
-    while (
-      i < lines.length &&
-      lines[i].trim() !== '' &&
-      !/^(#{1,6} |[-*+] |\d+\. |```)/.test(lines[i]) &&
-      !BQ_RE.test(lines[i]) &&
-      !HR_RE.test(lines[i]) &&
-      !/^\|.+\|/.test(lines[i]) &&
-      !(i + 1 < lines.length && /^=+\s*$/.test(lines[i + 1])) &&
-      !(i + 1 < lines.length && /^-{2,}\s*$/.test(lines[i + 1]))
-    ) {
-      paraLines.push(lines[i]);
-      i++;
-    }
-    if (paraLines.length) {
-      out.push(`<p>${_inline(_joinParagraphLines(paraLines)).replaceAll(HARD_BREAK, '<br>')}</p>`);
-    }
-  }
-  return out.join('');
-}
-// ---------------------------------------------------------------------------
-// Inline formatting
-// ---------------------------------------------------------------------------
-/** Reference-link and footnote definitions collected per markdownToHTML() call. */
-let _linkDefs = new Map();
-let _footnoteIds = new Set();
-/**
- * Strips a leading YAML frontmatter block (--- ... --- or --- ... ...) from
- * the line array, only when it is the very first line and the enclosed body
- * looks like YAML (key: value / list items / indented continuations) — this
- * disambiguates real frontmatter from a horizontal rule followed by prose.
- * @param {string[]} lines
- * @returns {string[]}
- */
-function _stripFrontmatter(lines) {
-  if ((lines[0] || '').trim() !== '---') return lines;
-  let closeIdx = -1;
-  for (let j = 1; j < lines.length; j++) {
-    const t = lines[j].trim();
-    if (t === '---' || t === '...') { closeIdx = j; break; }
-  }
-  if (closeIdx === -1) return lines;
-  const body = lines.slice(1, closeIdx);
-  const looksLikeYAML = body.every((l) =>
-    l.trim() === '' ||
-    /^[ \t]*[\w$.-]+\s*:(\s|$)/.test(l) ||
-    /^[ \t]*-\s+\S/.test(l) ||
-    /^[ \t]+\S/.test(l));
-  if (!looksLikeYAML) return lines;
-  let start = closeIdx + 1;
-  if (lines[start] !== undefined && lines[start].trim() === '') start++;
-  return lines.slice(start);
-}
-/**
- * Extracts GFM reference-link definitions (`[ref]: url "title"`) and footnote
- * definitions (`[^id]: text`) from the line array, skipping fenced code
- * regions. Returns the definition-free line array plus lookup maps.
- * @param {string[]} lines
- * @returns {{ clean: string[], linkDefs: Map<string, {href: string, title?: string}>, footnoteIds: Set<string> }}
- */
-function _extractReferenceDefinitions(lines) {
-  const linkDefs = new Map();
-  const footnoteIds = new Set();
-  const clean = [];
-  let inFence = false;
-  const linkDefRe = /^\[([^\]]+)\]:\s*(\S+)(?:\s+"([^"]*)")?\s*$/;
-  const footnoteDefRe = /^\[\^([^\]]+)\]:\s*(.+)$/;
-  for (const line of lines) {
-    if (/^```/.test(line)) { inFence = !inFence; clean.push(line); continue; }
-    if (!inFence) {
-      const fm = footnoteDefRe.exec(line);
-      if (fm) { footnoteIds.add(fm[1]); continue; }
-      const lm = linkDefRe.exec(line);
-      if (lm) { linkDefs.set(lm[1].trim().toLowerCase(), { href: lm[2], title: lm[3] }); continue; }
-    }
-    clean.push(line);
-  }
-  return { clean, linkDefs, footnoteIds };
-}
-/**
- * Joins a paragraph's source lines into one string, converting CommonMark
- * hard-break markers (a trailing backslash, or 2+ trailing spaces) on all
- * but the last line into a HARD_BREAK placeholder instead of a plain space.
- * @param {string[]} paraLines
- * @returns {string}
- */
-function _joinParagraphLines(paraLines) {
-  let joined = '';
-  for (let idx = 0; idx < paraLines.length; idx++) {
-    const isLast = idx === paraLines.length - 1;
-    const ln = paraLines[idx];
-    if (!isLast && /\\$/.test(ln)) { joined += ln.replace(/\\$/, '') + HARD_BREAK; continue; }
-    if (!isLast && / {2,}$/.test(ln)) { joined += ln.replace(/ {2,}$/, '') + HARD_BREAK; continue; }
-    joined += ln + (isLast ? '' : ' ');
-  }
-  return joined;
-}
-/**
- * Splits a GFM table row string into trimmed cell strings, treating an
- * escaped pipe (`\|`) as a literal character rather than a cell separator.
- * '| a | b | c |' → ['a', 'b', 'c']; '| a\|b | c |' → ['a|b', 'c']
- * @param {string} row
- * @returns {string[]}
- */
-function _parseTableRow(row) {
-  const trimmed = row.replace(/^\|/, '').replace(/\|$/, '');
-  const cells = [];
-  let cur = '';
-  for (let i = 0; i < trimmed.length; i++) {
-    if (trimmed[i] === '\\' && trimmed[i + 1] === '|') { cur += '|'; i++; continue; }
-    if (trimmed[i] === '|') { cells.push(cur); cur = ''; continue; }
-    cur += trimmed[i];
-  }
-  cells.push(cur);
-  return cells.map((c) => c.trim());
-}
-function _parseListBlock(lines, startIdx) {
-  const baseIndent = (lines[startIdx].match(/^(\s*)/)[1]).length;
-  const isOL = /^\s*\d+\. /.test(lines[startIdx]);
-  const items = [];
-  let firstIsCB = null;
-  let loose = false;
-  let pendingBlank = false;
-  let i = startIdx;
-  while (i < lines.length) {
-    const line = lines[i];
-    if (line.trim() === '') {
-      // A blank line only ends the list if what follows isn't a continuation
-      // of it (another item at the same marker/indent, or indented text
-      // belonging to the current item) — otherwise it marks a "loose" list.
-      const next = lines[i + 1];
-      const nextIndent = next !== undefined ? (next.match(/^(\s*)/)[1]).length : -1;
-      const nextIsSameItem = next !== undefined &&
-        /^\s*(?:[-*+]|\d+\.) /.test(next) &&
-        (/^\s*\d+\. /.test(next) === isOL) &&
-        nextIndent === baseIndent;
-      const nextIsContinuation = next !== undefined && next.trim() !== '' && nextIndent > baseIndent;
-      if (!items.length || (!nextIsSameItem && !nextIsContinuation)) break;
-      loose = true;
-      pendingBlank = true;
-      i++;
-      continue;
-    }
-    const indent = (line.match(/^(\s*)/)[1]).length;
-    if (indent < baseIndent) break;
-    if (indent === baseIndent) {
-      if (!/^\s*(?:[-*+]|\d+\.) /.test(line)) break;
-      if (/^\s*\d+\. /.test(line) !== isOL) break;
-      const raw = isOL ? line.replace(/^\s*\d+\. /, '') : line.replace(/^\s*[-*+] /, '');
-      // Checklists are intentionally UL-only: sanitise.js's checkbox guard,
-      // the injected checklist CSS, and every checklist-toggle command are
-      // all hardcoded to `ul.an-checklist` with no `ol` equivalent, so an
-      // ordered-list checkbox would be stripped by the sanitiser and get no
-      // styling even if parsed here — "1. [ ] item" intentionally stays plain.
-      const isCB = !isOL && /^\[[ xX]\]\s+/.test(raw);
-      if (firstIsCB === null) firstIsCB = isCB;
-      if (isCB !== firstIsCB) break;
-      const checked = isCB && raw[1].toLowerCase() === 'x';
-      const text = isCB ? raw.replace(/^\[[ xX]\]\s+/, '') : raw;
-      items.push({ paras: [text], isCB, checked, sub: '' });
-      pendingBlank = false;
-      i++;
-    } else {
-      if (!items.length) { i++; continue; }
-      if (/^\s*(?:[-*+]|\d+\.) /.test(line)) {
-        const nested = _parseListBlock(lines, i);
-        items[items.length - 1].sub += nested.html;
-        i = nested.endIdx;
-        pendingBlank = false;
-      } else if (pendingBlank) {
-        items[items.length - 1].paras.push(line.trim());
-        pendingBlank = false;
-        i++;
-      } else {
-        const paras = items[items.length - 1].paras;
-        paras[paras.length - 1] += ' ' + line.trim();
-        i++;
-      }
-    }
-  }
-  const hasCB = !isOL && (firstIsCB === true);
-  const startMatch = isOL ? /^\s*(\d+)\. /.exec(lines[startIdx]) : null;
-  const startNum = startMatch ? Number.parseInt(startMatch[1], 10) : 1;
-  const open = isOL
-    ? (startNum !== 1 ? `<ol start="${startNum}">` : '<ol>')
-    : (hasCB ? '<ul class="an-checklist">' : '<ul>');
-  const close = isOL ? '</ol>' : '</ul>';
-  const liHTML = items.map(({ paras, isCB, checked, sub }) => {
-    const cbHTML = isCB
-      ? `<input type="checkbox" contenteditable="false"${checked ? ' checked' : ''}>`
-      : '';
-    const body = loose
-      ? paras.map((p, idx) => `<p>${idx === 0 ? cbHTML : ''}${_inline(p)}</p>`).join('')
-      : `${cbHTML}${_inline(paras[0])}`;
-    return `<li>${body}${sub}</li>`;
-  }).join('');
-  return { html: `${open}${liHTML}${close}`, endIdx: i };
-}
-// Backslash-escapable inline punctuation (CommonMark-ish, narrowed to the
-// syntax characters this converter actually uses).
-const ESCAPABLE_RE = /\\([*_`#[\]()>\\~|])/g;
-// Placeholder marker for escaped literals — a NUL character can't appear in
-// real markdown text, so it's safe as a delimiter. Built at runtime (not
-// written as a literal escape) to avoid embedding a raw NUL byte in this file.
-const MARK = String.fromCharCode(0);
-/**
- * Step 0 of _inline(): replaces backslash-escaped punctuation with inert
- * placeholders so later syntax regexes can't match them.
- * @param {string} text
- * @returns {{ text: string, literals: string[] }}
- */
-function _extractBackslashEscapes(text) {
-  const literals = [];
-  const replaced = text.replace(ESCAPABLE_RE, (_, ch) => {
-    literals.push(ch);
-    return `${MARK}${literals.length - 1}${MARK}`;
-  });
-  return { text: replaced, literals };
-}
-/**
- * Restores placeholders from _extractBackslashEscapes(), HTML-escaping each
- * literal since it's inserted directly into the output.
- * @param {string} text
- * @param {string[]} literals
- * @returns {string}
- */
-function _restoreBackslashEscapes(text, literals) {
-  return text.replace(new RegExp(`${MARK}(\\d+)${MARK}`, 'g'), (_, idx) => _esc(literals[Number(idx)]));
-}
-/**
- * Resolves images, inline links, GFM reference-style links (explicit,
- * shortcut, and bare/implicit forms), and footnote markers. Must run on text
- * already passed through _esc() — see _inline()'s Step 1 comment.
- * @param {string} text
- * @returns {string}
- */
-function _resolveLinksAndFootnotes(text) {
-  text = text.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (_, alt, src) =>
-    `<img src="${_escAttrQuotes(src)}" alt="${_escAttrQuotes(alt)}" class="an-image">`);
-  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, href) =>
-    `<a href="${_escAttrQuotes(href)}">${label}</a>`);
-  text = text.replace(/\[([^\]]+)\]\[([^\]]*)\]/g, (m, label, ref) => {
-    const def = _linkDefs.get(_unescAmpLtGt(ref || label).trim().toLowerCase());
-    if (!def) return m;
-    const titleAttr = def.title ? ` title="${_escAttr(def.title)}"` : '';
-    return `<a href="${_escAttr(def.href)}"${titleAttr}>${label}</a>`;
-  });
-  text = text.replace(/\[([^\]]+)\]/g, (m, label) => {
-    const def = _linkDefs.get(_unescAmpLtGt(label).trim().toLowerCase());
-    if (!def) return m;
-    const titleAttr = def.title ? ` title="${_escAttr(def.title)}"` : '';
-    return `<a href="${_escAttr(def.href)}"${titleAttr}>${label}</a>`;
-  });
-  text = text.replace(/\[\^([^\]]+)\]/g, (m, id) => (_footnoteIds.has(_unescAmpLtGt(id)) ? `<sup>[${id}]</sup>` : m));
-  return text;
-}
-/**
- * Converts angle-bracket (`<https://...>`) and bare (`https://...`)
- * autolinks. Runs after _resolveLinksAndFootnotes() so an already-linked URL
- * isn't reprocessed, and on already-_esc()'d text (see _inline()).
- * @param {string} text
- * @returns {string}
- */
-function _applyAutolinks(text) {
-  text = text.replace(/&lt;(https?:\/\/[^\s&]+?)&gt;/g, (_, url) => `<a href="${_escAttrQuotes(url)}">${url}</a>`);
-  text = text.replace(/(^|[\s(])(https?:\/\/[^\s()]+)/g, (m, pre, rawUrl) => {
-    const trail = /[.,;:!?)]+$/.exec(rawUrl);
-    const url = trail ? rawUrl.slice(0, -trail[0].length) : rawUrl;
-    if (!url) return m;
-    const suffix = trail ? trail[0] : '';
-    return `${pre}<a href="${_escAttrQuotes(url)}">${url}</a>${suffix}`;
-  });
-  return text;
-}
-/**
- * Applies bold/italic/bold-italic (asterisk and underscore forms — underscore
- * requires a non-word-character boundary per CommonMark), strikethrough, and
- * inline code.
- * @param {string} text
- * @returns {string}
- */
-function _applyEmphasisAndCode(text) {
-  text = text.replace(/\*{3}([^*\n]+?)\*{3}/g, (_, c) => `<strong><em>${c}</em></strong>`);
-  text = text.replace(/(?<!\w)_{3}([^_\n]+?)_{3}(?!\w)/g, (_, c) => `<strong><em>${c}</em></strong>`);
-  text = text.replace(/\*{2}([^*\n]+?)\*{2}/g, (_, c) => `<strong>${c}</strong>`);
-  text = text.replace(/(?<!\w)_{2}([^_\n]+?)_{2}(?!\w)/g, (_, c) => `<strong>${c}</strong>`);
-  text = text.replace(/\*([^*\n]+?)\*/g, (_, c) => `<em>${c}</em>`);
-  text = text.replace(/(?<!\w)_([^_\n]+?)_(?!\w)/g, (_, c) => `<em>${c}</em>`);
-  text = text.replace(/~~([^~\n]+?)~~/g, (_, c) => `<del>${c}</del>`);
-  // Double-backtick code spans first (tolerates a single literal ` inside),
-  // then single-backtick spans.
-  text = text.replace(/``([\s\S]*?)``/g, (_, c) => `<code>${c}</code>`);
-  text = text.replace(/`([^`]+)`/g, (_, c) => `<code>${c}</code>`);
-  return text;
-}
-function _inline(text) {
-  // Step 0: backslash escapes (\* \_ \` \# \[ \] \( \) \> \\ \~ \|) — replaced
-  // with inert placeholders before any syntax regex below can match them, so
-  // e.g. \*not bold\* never gets treated as emphasis. Restored at the end.
-  const { text: withoutEscapes, literals } = _extractBackslashEscapes(text);
-  // Step 1: escape raw &/</> in the plain-text parts of the string exactly
-  // once, up front — none of these are markdown-syntax characters used below,
-  // so this doesn't interfere with matching. Capture-group content in the
-  // steps below is therefore ALREADY escaped and must NOT be re-escaped;
-  // attribute values captured from `text` only need quotes escaped
-  // (_escAttrQuotes), since & < > are already entities. Values that come from
-  // _linkDefs (sourced from the raw, unescaped line array) still need the
-  // full _escAttr/_esc treatment.
-  let result = _esc(withoutEscapes);
-  result = _resolveLinksAndFootnotes(result);
-  result = _applyAutolinks(result);
-  result = _applyEmphasisAndCode(result);
-  return _restoreBackslashEscapes(result, literals);
-}
-function _esc(v) {
-  return String(v)
-    .replaceAll('&', '&amp;')
-    .replaceAll('<', '&lt;')
-    .replaceAll('>', '&gt;');
-}
-function _escAttr(v) {
-  return String(v)
-    .replaceAll('&', '&amp;')
-    .replaceAll('"', '&quot;')
-    .replaceAll("'", '&#39;')
-    .replaceAll('<', '&lt;')
-    .replaceAll('>', '&gt;');
-}
-/** Escapes only quote characters — for attribute values already run through _esc(). */
-function _escAttrQuotes(v) {
-  return String(v).replaceAll('"', '&quot;').replaceAll("'", '&#39;');
-}
-/** Reverses _esc()'s &amp;/&lt;/&gt; substitutions, for matching against un-escaped _linkDefs/_footnoteIds keys. */
-function _unescAmpLtGt(v) {
-  return String(v).replaceAll('&lt;', '<').replaceAll('&gt;', '>').replaceAll('&amp;', '&');
-}