autumnnote 1.8.3 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autumnnote",
-  "version": "1.8.3",
+  "version": "1.10.0",
   "description": "WYSIWYG rich-text editor built with vanilla JavaScript — zero dependencies, no jQuery. Dark mode, @mention, markdown shortcuts, bubble toolbar. React and Vue 3 wrappers included.",
   "main": "dist/autumnnote.umd.js",
   "module": "dist/autumnnote.es.js",
@@ -14,7 +14,6 @@
     },
     "./dist/autumnnote.css": "./dist/autumnnote.css"
   },
-  "sideEffects": ["./dist/autumnnote.css", "**/*.css"],
   "files": [
     "dist",
     "src",

package/src/js/core/markdown.js

@@ -139,7 +139,11 @@ function _domToMd(node, depth = 0) {
  * @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);
+  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);
 }
 
 /**
@@ -148,7 +152,12 @@ export function isMarkdown(text) {
  * @returns {string}
  */
 export function markdownToHTML(text) {
-  const lines = text.replaceAll('\r\n', '\n').replaceAll('\r', '\n').split('\n');
+  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;
   const out = [];
   let i = 0;
 
@@ -171,6 +180,20 @@ export function markdownToHTML(text) {
       continue;
     }
 
+    // ---- Setext headings (Title\n=== or Title\n---) -------------------------
+    if (line.trim() && !/^(-{3,}|\*{3,}|_{3,})\s*$/.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 (/^(-{3,}|\*{3,}|_{3,})\s*$/.test(line)) {
       out.push('<hr>');
@@ -200,41 +223,14 @@ export function markdownToHTML(text) {
 
     // ---- Checklist or Unordered list  - / * / + item  ----------------------
     if (/^[-*+] /.test(line)) {
-      const items = [];
-      const isChecklist = /^[-*+]\s+\[[ xX]\]\s+/.test(line);
-      const listTag = isChecklist ? 'ul class="an-checklist"' : 'ul';
-      while (i < lines.length && /^[-*+] /.test(lines[i])) {
-        const nextLineIsChecklist = /^[-*+]\s+\[[ xX]\]\s+/.test(lines[i]);
-        if (nextLineIsChecklist !== isChecklist) {
-          break;
-        }
-        const itemLine = lines[i];
-        const content = itemLine.slice(2);
-        if (isChecklist) {
-          const cbMatch = /^\[([ xX])\][ \t]+/.exec(content);
-          const checked = cbMatch?.[1]?.toLowerCase() === 'x';
-          const checkedAttr = checked ? ' checked' : '';
-          const cbHtml = `<input type="checkbox" contenteditable="false"${checkedAttr}>`;
-          const textContent = cbMatch ? content.slice(cbMatch[0].length) : content;
-          items.push(`<li>${cbHtml}${_inline(textContent)}</li>`);
-        } else {
-          items.push(`<li>${_inline(content)}</li>`);
-        }
-        i++;
-      }
-      out.push(`<${listTag}>${items.join('')}</${listTag.split(' ')[0]}>`);
-      continue;
+      const { html: listHtml, endIdx } = _parseListBlock(lines, i);
+      out.push(listHtml); i = endIdx; continue;
     }
 
     // ---- Ordered list  1. item  ----------------------------------------------
     if (/^\d+\. /.test(line)) {
-      const items = [];
-      while (i < lines.length && /^\d+\. /.test(lines[i])) {
-        items.push(`<li>${_inline(lines[i].replace(/^\d+\. /, ''))}</li>`);
-        i++;
-      }
-      out.push(`<ol>${items.join('')}</ol>`);
-      continue;
+      const { html: listHtml, endIdx } = _parseListBlock(lines, i);
+      out.push(listHtml); i = endIdx; continue;
     }
 
     // ---- Blank line ----------------------------------------------------------
@@ -248,15 +244,25 @@ export function markdownToHTML(text) {
     // 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 thCells = headerCells.map((c) => `<th>${_inline(c)}</th>`).join('');
+      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) => `<td>${_inline(c)}</td>`).join('')}</tr>`;
+      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;
@@ -268,7 +274,9 @@ export function markdownToHTML(text) {
       i < lines.length &&
       lines[i].trim() !== '' &&
       !/^(#{1,6} |> |[-*+] |\d+\. |```|---\s*$|\*{3}\s*$|_{3}\s*$)/.test(lines[i]) &&
-      !/^\|.+\|/.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++;
@@ -285,6 +293,68 @@ export function markdownToHTML(text) {
 // 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 };
+}
+
 /**
  * Splits a GFM table row string into trimmed cell strings.
  * '| a | b | c |' → ['a', 'b', 'c']
@@ -299,6 +369,55 @@ function _parseTableRow(row) {
     .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 i = startIdx;
+
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === '') break;
+    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*[-*+] /, '');
+      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({ text, isCB, checked, sub: '' });
+      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;
+      } else {
+        items[items.length - 1].text += ' ' + line.trim();
+        i++;
+      }
+    }
+  }
+
+  const hasCB = !isOL && (firstIsCB === true);
+  const open = isOL ? '<ol>' : hasCB ? '<ul class="an-checklist">' : '<ul>';
+  const close = isOL ? '</ol>' : '</ul>';
+  const liHTML = items.map(({ text, isCB, checked, sub }) => {
+    const cbHTML = isCB
+      ? `<input type="checkbox" contenteditable="false"${checked ? ' checked' : ''}>`
+      : '';
+    return `<li>${cbHTML}${_inline(text)}${sub}</li>`;
+  }).join('');
+  return { html: `${open}${liHTML}${close}`, endIdx: i };
+}
+
 function _inline(text) {
   // Images before links (they share [] syntax)
   text = text.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, (_, alt, src) =>
@@ -306,6 +425,22 @@ function _inline(text) {
   // Links
   text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, label, href) =>
     `<a href="${_escAttr(href)}">${_esc(label)}</a>`);
+  // Reference-style links  [text][ref]  and shortcut  [text][]
+  text = text.replace(/\[([^\]]+)\]\[([^\]]*)\]/g, (m, label, ref) => {
+    const def = _linkDefs.get((ref || label).trim().toLowerCase());
+    if (!def) return m;
+    const titleAttr = def.title ? ` title="${_escAttr(def.title)}"` : '';
+    return `<a href="${_escAttr(def.href)}"${titleAttr}>${_esc(label)}</a>`;
+  });
+  // Bare/implicit reference link  [text]  — only when a definition exists
+  text = text.replace(/\[([^\]]+)\]/g, (m, label) => {
+    const def = _linkDefs.get(label.trim().toLowerCase());
+    if (!def) return m;
+    const titleAttr = def.title ? ` title="${_escAttr(def.title)}"` : '';
+    return `<a href="${_escAttr(def.href)}"${titleAttr}>${_esc(label)}</a>`;
+  });
+  // Footnote reference marker  [^id]  — run last
+  text = text.replace(/\[\^([^\]]+)\]/g, (m, id) => (_footnoteIds.has(id) ? `<sup>[${_esc(id)}]</sup>` : m));
   // Bold + italic  ***text***
   text = text.replace(/\*{3}([^*\n]+?)\*{3}/g, (_, c) => `<strong><em>${_esc(c)}</em></strong>`);
   text = text.replace(/_{3}([^_\n]+?)_{3}/g,   (_, c) => `<strong><em>${_esc(c)}</em></strong>`);

package/src/js/index.js

@@ -144,7 +144,7 @@ const AutumnNote = {
   buttons,
 
   /** Library version */
-  version: '1.8.3',
+  version: '1.10.0',
 };
 
 // ---------------------------------------------------------------------------

package/src/js/module/Clipboard.js

@@ -170,6 +170,30 @@ export class Clipboard {
     return doc.body.innerHTML;
   }
 
+  /**
+   * Normalizes task lists from external sources (GitHub, GitLab, etc.) so they
+   * pass the sanitiser's `ul.an-checklist` guard. Runs before sanitiseHTML().
+   * @param {string} html
+   * @returns {string}
+   */
+  _normalizeExternalTaskLists(html) {
+    const doc = new DOMParser().parseFromString(`<body>${html}</body>`, 'text/html');
+    for (const cb of doc.querySelectorAll('input[type="checkbox"]')) {
+      const li = cb.closest('li');
+      const ul = li?.closest('ul');
+      if (!li || !ul || ul.classList.contains('an-checklist')) continue;
+      ul.classList.add('an-checklist');
+      cb.removeAttribute('disabled');
+      cb.setAttribute('contenteditable', 'false');
+      for (const attr of Array.from(cb.attributes)) {
+        if (!['type', 'checked', 'contenteditable'].includes(attr.name)) {
+          cb.removeAttribute(attr.name);
+        }
+      }
+    }
+    return doc.body.innerHTML;
+  }
+
   /**
    * Forces the next paste operation to strip all HTML formatting.
    * Called by Editor when Ctrl+Shift+V is pressed.
@@ -255,6 +279,7 @@ export class Clipboard {
       let html = raw;
       if (isWordContent) html = this._cleanWordHtml(html);
       else if (isSocialContent) html = this._cleanSocialHtml(html);
+      html = this._normalizeExternalTaskLists(html);
       html = sanitiseHTML(html);
       if (this.options.pasteStripAttributes) html = this._stripAttributes(html);
       execCommand('insertHTML', html);

package/types/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * AutumnNote – TypeScript declarations
- * @version 1.8.3
+ * @version 1.10.0
  */
 
 // ---------------------------------------------------------------------------