officeparser 7.2.3 → 7.3.0

package/dist/parsers/MarkdownParser.js

@@ -3,6 +3,53 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseMarkdown = void 0;
 const astUtils_js_1 = require("../utils/astUtils.js");
 const errorUtils_js_1 = require("../utils/errorUtils.js");
+// Sentinel node type for a standalone bookmark-anchor block (e.g. `<a id="x"></a>` on its
+// own line). A post-parse pass folds these into the following node's anchorIds so they
+// round-trip as real anchors rather than being escaped to visible text on regeneration.
+const ANCHOR_PLACEHOLDER = '__anchorPlaceholder__';
+/**
+ * Splits the inner content of a YAML flow array (`a, "b, c", d`) on top-level commas,
+ * ignoring commas inside single- or double-quoted items.
+ */
+const splitFlowArrayItems = (inner) => {
+    const items = [];
+    let current = '';
+    let quote = null;
+    for (const ch of inner) {
+        if (quote) {
+            current += ch;
+            if (ch === quote)
+                quote = null;
+        }
+        else if (ch === '"' || ch === '\'') {
+            quote = ch;
+            current += ch;
+        }
+        else if (ch === ',') {
+            items.push(current.trim());
+            current = '';
+        }
+        else {
+            current += ch;
+        }
+    }
+    if (current.trim() !== '')
+        items.push(current.trim());
+    return items;
+};
+/**
+ * Maps every accepted-on-import admonition type spelling (GitHub's five plus GLFM's
+ * `danger`) to the canonical AdmonitionMetadata type. Per MARKDOWN_DIALECT.md's
+ * Decisions, `danger` folds into `caution` - there is no separate danger type.
+ */
+const ADMONITION_TYPE_MAP = {
+    note: 'note',
+    tip: 'tip',
+    important: 'important',
+    warning: 'warning',
+    caution: 'caution',
+    danger: 'caution'
+};
 const parseMarkdown = async (buffer, config) => {
     // Honour cancellation requests before the line-by-line Markdown scanning loop begins.
     // Markdown parsing is entirely synchronous and CPU-bound, so failing fast avoids
@@ -26,9 +73,23 @@ const parseMarkdown = async (buffer, config) => {
                 const match = line.match(/^([^:]+):\s*(.*)$/);
                 if (match) {
                     const key = match[1].trim();
-                    let val = match[2].trim().replace(/^"(.*)"$/, '$1');
+                    const rawVal = match[2].trim();
+                    const val = rawVal.replace(/^"(.*)"$/, '$1');
                     let parsedVal = val;
-                    if (val === 'true')
+                    if (rawVal.startsWith('[') && rawVal.endsWith(']')) {
+                        // Flow-array (`tags: [a, b]`) or JSON-array (`tags: ["a","b"]`) value -
+                        // parse into a real array instead of storing the literal bracket string,
+                        // so it round-trips symmetrically with MarkdownGenerator's frontmatter output.
+                        try {
+                            const jsonParsed = JSON.parse(rawVal);
+                            parsedVal = Array.isArray(jsonParsed) ? jsonParsed : val;
+                        }
+                        catch {
+                            const inner = rawVal.slice(1, -1).trim();
+                            parsedVal = inner === '' ? [] : splitFlowArrayItems(inner).map(item => item.replace(/^['"](.*)['"]$/, '$1'));
+                        }
+                    }
+                    else if (val === 'true')
                         parsedVal = true;
                     else if (val === 'false')
                         parsedVal = false;
@@ -56,6 +117,22 @@ const parseMarkdown = async (buffer, config) => {
                 metadata.nativeProperties = nativeProps;
         }
     }
+    // Strip MDX/JSX component tags (parse-only - we never author MDX). Components are
+    // distinguished from plain HTML by an uppercase-leading tag name, matching React/MDX
+    // convention. Self-closing components are removed entirely; paired components keep
+    // their inner Markdown content. Iterate to a fixed point so nested components (of
+    // different names) are all unwrapped, not just the outermost one.
+    // Cap the passes: each iteration unwraps one nesting level, so a pathologically
+    // deep `<A><A>...</A></A>` input would otherwise be O(depth * n). Real documents
+    // nest only a handful of levels; anything past the cap is left as-is.
+    let previousTextStr;
+    let mdxPasses = 0;
+    const MAX_MDX_PASSES = 100;
+    do {
+        previousTextStr = textStr;
+        textStr = textStr.replace(/<[A-Z][A-Za-z0-9]*(?:\s+[^>]*?)?\/>/g, '');
+        textStr = textStr.replace(/<([A-Z][A-Za-z0-9]*)(?:\s+[^>]*?)?>([\s\S]*?)<\/\1>/g, (_m, _name, inner) => inner);
+    } while (textStr !== previousTextStr && ++mdxPasses < MAX_MDX_PASSES);
     // Extract code blocks first to protect their contents
     const codeBlocks = [];
     textStr = textStr.replace(/^```(\w*)\n([\s\S]*?)\n```/gm, (match, lang, code) => {
@@ -63,10 +140,79 @@ const parseMarkdown = async (buffer, config) => {
         codeBlocks.push(JSON.stringify({ lang, code }));
         return `\n\n${id}\n\n`;
     });
+    // Extract block math ($$\n...\n$$) before block splitting, mirroring the code-block
+    // pre-pass above - its body may contain blank lines that would otherwise fragment it.
+    // Inline math ($...$) is handled directly in parseInline below.
+    const mathBlocks = [];
+    textStr = textStr.replace(/^\$\$\n([\s\S]*?)\n\$\$$/gm, (_match, latex) => {
+        const id = `__MATH_BLOCK_${mathBlocks.length}__`;
+        mathBlocks.push(latex);
+        return `\n\n${id}\n\n`;
+    });
+    // Extract GLFM-style fenced-div admonitions (`:::note ... :::`) before block splitting,
+    // since their body may itself contain blank lines that would otherwise fragment them.
+    // The `> [!NOTE]` GitHub form doesn't need this - it's detected inline in the blockquote
+    // branch below, since a `>`-prefixed block never contains a real blank line.
+    const admonitionBlocks = [];
+    textStr = textStr.replace(/^:::(\w+)[ \t]*\n([\s\S]*?)\n:::[ \t]*$/gm, (match, type, body) => {
+        const admonitionType = ADMONITION_TYPE_MAP[type.toLowerCase()];
+        if (!admonitionType)
+            return match; // Unrecognised type - leave as literal text.
+        const id = `__ADMONITION_${admonitionBlocks.length}__`;
+        admonitionBlocks.push(JSON.stringify({ admonitionType, body }));
+        return `\n\n${id}\n\n`;
+    });
+    // Extract footnote definitions (`[^id]: text`) before block splitting, since
+    // definitions conventionally live at the end of the document, after every place
+    // they're referenced - inline parsing below needs the full map upfront. v1 only
+    // supports single-line definitions (MultiMarkdown/Pandoc/GLFM's common baseline).
+    const footnoteDefinitions = new Map();
+    textStr = textStr.replace(/^\[\^([^\]]+)\]:[ \t]*(.*)$/gm, (_match, id, definition) => {
+        footnoteDefinitions.set(id, definition.trim());
+        return '';
+    });
+    // Extract Markdown Extra abbreviation definitions (`*[HTML]: Hypertext Markup Language`)
+    // before block splitting, for the same reason as footnotes: they conventionally live
+    // at the end of the document.
+    const abbreviationDefinitions = new Map();
+    textStr = textStr.replace(/^\*\[([^\]]+)\]:[ \t]*(.*)$/gm, (_match, abbr, definition) => {
+        abbreviationDefinitions.set(abbr, definition.trim());
+        return '';
+    });
+    // Parses a Pandoc-style attribute list body (the part inside `{...}`), e.g.
+    // `width=50% .centered` or `align=right`. Per MARKDOWN_DIALECT.md §15's Decisions,
+    // the vocabulary matches ImageMetadata/TableMetadata's own width/align fields;
+    // several class-name spellings are accepted on import for compatibility with
+    // hand-written content, but the generator only ever emits canonical `align=value`.
+    const parseAttributeList = (attrStr) => {
+        const result = {};
+        for (const token of attrStr.trim().split(/\s+/).filter(Boolean)) {
+            const kv = token.match(/^([a-zA-Z-]+)=(.+)$/);
+            if (kv) {
+                if (kv[1] === 'width')
+                    result.width = kv[2];
+                else if (kv[1] === 'align' && ['left', 'center', 'right'].includes(kv[2]))
+                    result.align = kv[2];
+            }
+            else if (token.startsWith('.')) {
+                const cls = token.slice(1).toLowerCase();
+                if (cls === 'left' || cls === 'align-left')
+                    result.align = 'left';
+                else if (cls === 'center' || cls === 'centered' || cls === 'align-center')
+                    result.align = 'center';
+                else if (cls === 'right' || cls === 'align-right')
+                    result.align = 'right';
+            }
+        }
+        return result;
+    };
     const parseInline = (text, currentFormatting = {}) => {
         const nodes = [];
-        // Regex matches: 1=!, 2=alt, 3=url | 4=bold | 5=italic | 6=strike | 7=code | 8=underline | 9=subscript | 10=superscript
-        const regex = /(!?)\[(.*?)\]\((.*?)\)|\*\*(.+?)\*\*|\*(.+?)\*|~~(.+?)~~|`(.+?)`|<u>(.+?)<\/u>|<sub>(.+?)<\/sub>|<sup>(.+?)<\/sup>/g;
+        // Regex matches: 1=!, 2=alt, 3=url, 4=attrs | 5=bold | 6=italic | 7=strike | 8=code | 9=underline | 10=subscript | 11=superscript | 12=footnote id | 13=citekey | 14=wikilink page | 15=wikilink alias | 16=inline math
+        // Inline math requires no whitespace right after the opening $ or right before the
+        // closing $, the common heuristic (matching Pandoc/KaTeX) for avoiding false
+        // positives on currency like "$5 and $10".
+        const regex = /(!?)\[(.*?)\]\((.*?)\)(?:\{([^}]*)\})?|\*\*(.+?)\*\*|\*(.+?)\*|~~(.+?)~~|`(.+?)`|<u>(.+?)<\/u>|<sub>(.+?)<\/sub>|<sup>(.+?)<\/sup>|\[\^([^\]]+)\]|\[@([a-zA-Z0-9_:.-]+)\]|\[\[([^\]|]+)(?:\|([^\]]+))?\]\]|\$(?!\s)([^$\n]+?)(?<!\s)\$/g;
         let lastIndex = 0;
         let match;
         while ((match = regex.exec(text)) !== null) {
@@ -77,6 +223,8 @@ const parseMarkdown = async (buffer, config) => {
                 const isImage = match[1] === '!';
                 const altText = match[2];
                 const url = match[3];
+                // Pandoc-style attribute list immediately after an image, e.g. {width=50% .centered}
+                const attrs = isImage && match[4] !== undefined ? parseAttributeList(match[4]) : undefined;
                 if (isImage) {
                     if (url.startsWith('data:')) {
                         const dataMatch = url.match(/^data:([^;]+);base64,(.*)$/);
@@ -91,14 +239,14 @@ const parseMarkdown = async (buffer, config) => {
                                 name,
                                 extension: mimeType.split('/')[1]
                             });
-                            nodes.push({ type: 'image', metadata: { attachmentName: name, altText } });
+                            nodes.push({ type: 'image', metadata: { attachmentName: name, altText, ...attrs } });
                         }
                         else {
-                            nodes.push({ type: 'image', metadata: { url, altText } });
+                            nodes.push({ type: 'image', metadata: { url, altText, ...attrs } });
                         }
                     }
                     else {
-                        nodes.push({ type: 'image', metadata: { url, altText } });
+                        nodes.push({ type: 'image', metadata: { url, altText, ...attrs } });
                     }
                 }
                 else {
@@ -111,33 +259,121 @@ const parseMarkdown = async (buffer, config) => {
                     nodes.push(...linkNodes);
                 }
             }
-            else if (match[4]) { // Bold
-                nodes.push(...parseInline(match[4], { ...currentFormatting, bold: true }));
+            else if (match[5]) { // Bold
+                nodes.push(...parseInline(match[5], { ...currentFormatting, bold: true }));
+            }
+            else if (match[6]) { // Italic
+                nodes.push(...parseInline(match[6], { ...currentFormatting, italic: true }));
+            }
+            else if (match[7]) { // Strikethrough
+                nodes.push(...parseInline(match[7], { ...currentFormatting, strikethrough: true }));
+            }
+            else if (match[8]) { // Inline Code
+                nodes.push({ type: 'text', text: match[8], formatting: { ...currentFormatting, font: 'monospace' } });
+            }
+            else if (match[9]) { // Underline
+                nodes.push(...parseInline(match[9], { ...currentFormatting, underline: true }));
             }
-            else if (match[5]) { // Italic
-                nodes.push(...parseInline(match[5], { ...currentFormatting, italic: true }));
+            else if (match[10]) { // Subscript
+                nodes.push(...parseInline(match[10], { ...currentFormatting, subscript: true }));
             }
-            else if (match[6]) { // Strikethrough
-                nodes.push(...parseInline(match[6], { ...currentFormatting, strikethrough: true }));
+            else if (match[11]) { // Superscript
+                nodes.push(...parseInline(match[11], { ...currentFormatting, superscript: true }));
             }
-            else if (match[7]) { // Inline Code
-                nodes.push({ type: 'text', text: match[7], formatting: { ...currentFormatting, font: 'monospace' } });
+            else if (match[12]) { // Footnote reference
+                const noteId = match[12];
+                const definition = footnoteDefinitions.get(noteId);
+                const noteChildren = definition !== undefined ? parseInline(definition) : [];
+                const noteNode = {
+                    type: 'note',
+                    text: noteChildren.map(c => c.text || '').join(''),
+                    children: noteChildren,
+                    metadata: { noteType: 'footnote', noteId }
+                };
+                // Notes attach to the preceding text node (matches WordParser's convention);
+                // fall back to an empty text node if the reference opens the inline run.
+                if (nodes.length > 0) {
+                    const target = nodes[nodes.length - 1];
+                    if (!target.notes)
+                        target.notes = [];
+                    target.notes.push(noteNode);
+                }
+                else {
+                    nodes.push({ type: 'text', text: '', notes: [noteNode] });
+                }
             }
-            else if (match[8]) { // Underline
-                nodes.push(...parseInline(match[8], { ...currentFormatting, underline: true }));
+            else if (match[13]) { // Citation reference
+                nodes.push({ type: 'text', text: match[13], metadata: { citationKey: match[13] } });
             }
-            else if (match[9]) { // Subscript
-                nodes.push(...parseInline(match[9], { ...currentFormatting, subscript: true }));
+            else if (match[14]) { // Wikilink
+                const page = match[14].trim();
+                const alias = match[15]?.trim();
+                nodes.push({ type: 'text', text: alias || page, metadata: { link: page, linkType: 'internal', wikilink: true } });
             }
-            else if (match[10]) { // Superscript
-                nodes.push(...parseInline(match[10], { ...currentFormatting, superscript: true }));
+            else if (match[16] !== undefined) { // Inline math
+                nodes.push({ type: 'code', text: match[16], metadata: { math: 'inline' } });
             }
             lastIndex = regex.lastIndex;
         }
         if (lastIndex < text.length) {
             nodes.push({ type: 'text', text: text.substring(lastIndex), formatting: Object.keys(currentFormatting).length > 0 ? { ...currentFormatting } : undefined });
         }
-        return nodes;
+        return applyAbbreviations(nodes);
+    };
+    const escapeRegExpChars = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // Splits abbreviation occurrences out of plain text nodes so they carry
+    // TextMetadata.abbreviationTitle, rendered as <abbr title> in HTML/editor output.
+    const applyAbbreviations = (nodes) => {
+        if (abbreviationDefinitions.size === 0)
+            return nodes;
+        const pattern = new RegExp(`\\b(${[...abbreviationDefinitions.keys()].map(escapeRegExpChars).join('|')})\\b`, 'g');
+        const result = [];
+        for (const node of nodes) {
+            if (node.type !== 'text' || !node.text || node.metadata) {
+                result.push(node);
+                continue;
+            }
+            let lastIndex = 0;
+            let match;
+            let matched = false;
+            pattern.lastIndex = 0;
+            while ((match = pattern.exec(node.text)) !== null) {
+                matched = true;
+                if (match.index > lastIndex) {
+                    result.push({ type: 'text', text: node.text.substring(lastIndex, match.index), formatting: node.formatting });
+                }
+                result.push({
+                    type: 'text',
+                    text: match[0],
+                    formatting: node.formatting,
+                    metadata: { abbreviationTitle: abbreviationDefinitions.get(match[0]) }
+                });
+                lastIndex = pattern.lastIndex;
+            }
+            if (!matched) {
+                result.push(node);
+                continue;
+            }
+            if (lastIndex < node.text.length) {
+                result.push({ type: 'text', text: node.text.substring(lastIndex), formatting: node.formatting });
+            }
+        }
+        return result;
+    };
+    // Builds an admonition node from its raw body text, splitting on blank lines into
+    // paragraph children. v1 only supports inline content inside admonitions (no nested
+    // lists/headings/code) - acceptable per the roadmap's first cut.
+    const buildAdmonitionNode = (admonitionType, body) => {
+        const paragraphs = body.split(/\n\n+/).map(p => p.trim()).filter(Boolean);
+        const children = paragraphs.map(p => ({
+            type: 'paragraph',
+            children: parseInline(p.replace(/\n/g, ' '))
+        }));
+        return {
+            type: 'admonition',
+            metadata: { admonitionType },
+            children
+        };
     };
     const rawBlocks = textStr.split(/\n\n+/);
     const blocks = [];
@@ -179,6 +415,21 @@ const parseMarkdown = async (buffer, config) => {
         block = block.trim();
         if (!block)
             continue;
+        // Standalone anchor-only block: one or more empty `<a name|id="…"></a>` tags on their
+        // own line (bookmark targets the MarkdownGenerator emits just before a heading/paragraph).
+        // Capture them as a placeholder so the post-loop pass can re-attach them to the following
+        // node's anchorIds — otherwise the tag-opening `<` is escaped and they render as visible text.
+        if (/^(?:\s*<a\s[^>]*>\s*<\/a>\s*)+$/i.test(block)) {
+            const anchorIds = [];
+            for (const m of block.matchAll(/<a\s[^>]*\b(?:name|id)="([^"]*)"/gi)) {
+                if (m[1])
+                    anchorIds.push(m[1]);
+            }
+            if (anchorIds.length > 0) {
+                content.push({ type: ANCHOR_PLACEHOLDER, metadata: { anchorIds }, children: [] });
+                continue;
+            }
+        }
         // Check for alignment wrapper start/end
         const alignStartMatch = block.match(/^<div\s+(?:style="text-align:\s*(left|center|right|justify);?"|align="(left|center|right|justify)")>$/i);
         if (alignStartMatch) {
@@ -196,6 +447,32 @@ const parseMarkdown = async (buffer, config) => {
             alignment = (alignMatch[1] || alignMatch[2]).toLowerCase();
             block = alignMatch[3];
         }
+        // YouTube embed fallback: MarkdownGenerator's 'embed' case emits a single-line
+        // <div data-youtube-video="ID" data-width="…" data-align="…"></div> when fallbackToHtml
+        // is on; recognise it here so a saved-then-reopened .md keeps the video.
+        const youtubeMatch = block.match(/^<div\s+data-youtube-video="([^"]*)"([^>]*)>\s*<\/div>$/i);
+        if (youtubeMatch) {
+            const videoId = youtubeMatch[1];
+            const attrsStr = youtubeMatch[2];
+            const widthMatch = attrsStr.match(/data-width="([^"]*)"/i);
+            const youtubeAlignMatch = attrsStr.match(/data-align="([^"]*)"/i);
+            const embedAlign = youtubeAlignMatch && ['left', 'center', 'right'].includes(youtubeAlignMatch[1]) ? youtubeAlignMatch[1] : undefined;
+            const embedUrl = videoId ? `https://www.youtube.com/watch?v=${videoId}` : undefined;
+            content.push({
+                type: 'embed',
+                // Childless nodes need .text so generic AST consumers (toText, chunking)
+                // don't silently drop them.
+                text: embedUrl,
+                metadata: {
+                    embedType: 'youtube',
+                    videoId,
+                    url: embedUrl,
+                    width: widthMatch?.[1],
+                    align: embedAlign
+                }
+            });
+            continue;
+        }
         // Code Block
         const codeMatch = block.match(/^__CODE_BLOCK_(\d+)__$/);
         if (codeMatch) {
@@ -207,6 +484,23 @@ const parseMarkdown = async (buffer, config) => {
             });
             continue;
         }
+        // GLFM-style fenced-div admonition, extracted to a placeholder above
+        const admonitionBlockMatch = block.match(/^__ADMONITION_(\d+)__$/);
+        if (admonitionBlockMatch) {
+            const data = JSON.parse(admonitionBlocks[parseInt(admonitionBlockMatch[1])]);
+            content.push(buildAdmonitionNode(data.admonitionType, data.body));
+            continue;
+        }
+        // Block math ($$...$$), extracted to a placeholder above
+        const mathBlockMatch = block.match(/^__MATH_BLOCK_(\d+)__$/);
+        if (mathBlockMatch) {
+            content.push({
+                type: 'code',
+                text: mathBlocks[parseInt(mathBlockMatch[1])],
+                metadata: { math: 'block' }
+            });
+            continue;
+        }
         // Heading (allowing for leading HTML anchors and trailing {#anchor})
         const headingMatch = block.match(/^((?:<a[^>]*><\/a>)*)\s*(#{1,6})\s+(.*?)(?:\s+\{#([^}]+)\})?\s*$/s);
         if (headingMatch) {
@@ -215,7 +509,7 @@ const parseMarkdown = async (buffer, config) => {
             const explicitAnchor = headingMatch[4];
             const anchorIds = [];
             if (leadingAnchorsRaw) {
-                const idMatches = leadingAnchorsRaw.matchAll(/<a\s+name="([^"]+)"/gi);
+                const idMatches = leadingAnchorsRaw.matchAll(/<a\s[^>]*\b(?:name|id)="([^"]+)"/gi);
                 for (const m of idMatches)
                     anchorIds.push(m[1]);
             }
@@ -237,10 +531,37 @@ const parseMarkdown = async (buffer, config) => {
         // Blockquote
         const quoteMatch = block.match(/^>\s+(.*)$/s);
         if (quoteMatch) {
+            // [ \t]? (not \s+) so a bare ">" paragraph-separator line (used between
+            // multi-paragraph admonition bodies) also dequotes to an empty line.
+            const dequoted = quoteMatch[1].replace(/^>[ \t]?/gm, '');
+            // GitHub-style admonition: `> [!NOTE]` on the first quoted line.
+            const admonitionHeaderMatch = dequoted.match(/^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]\s*\n?([\s\S]*)$/i);
+            if (admonitionHeaderMatch) {
+                const admonitionType = admonitionHeaderMatch[1].toLowerCase();
+                content.push(buildAdmonitionNode(admonitionType, admonitionHeaderMatch[2]));
+                continue;
+            }
             content.push({
                 type: 'paragraph',
                 metadata: { style: 'Quote' },
-                children: parseInline(quoteMatch[1].replace(/^>\s+/gm, ''))
+                children: parseInline(dequoted)
+            });
+            continue;
+        }
+        // Definition list (Markdown Extra / Pandoc / Kramdown): a term line followed by
+        // one or more ": definition" lines, e.g.:
+        //   Term
+        //   : Definition of the term.
+        const definitionListMatch = block.match(/^([^\n:][^\n]*)\n((?::[ \t]+.+(?:\n:[ \t]+.+)*))$/);
+        if (definitionListMatch) {
+            const term = definitionListMatch[1];
+            const definitions = definitionListMatch[2].split('\n').map(line => line.replace(/^:[ \t]+/, ''));
+            content.push({
+                type: 'definitionList',
+                children: [
+                    { type: 'definitionTerm', children: parseInline(term) },
+                    ...definitions.map(def => ({ type: 'definitionDescription', children: parseInline(def) }))
+                ]
             });
             continue;
         }
@@ -269,7 +590,16 @@ const parseMarkdown = async (buffer, config) => {
                     else {
                         listCounters[level]++;
                     }
-                    const children = parseInline(match[3]);
+                    let itemText = match[3];
+                    let isTask;
+                    let checked;
+                    const taskMatch = itemText.match(/^\[([ xX])\]\s+(.*)$/);
+                    if (taskMatch) {
+                        isTask = true;
+                        checked = taskMatch[1].toLowerCase() === 'x';
+                        itemText = taskMatch[2];
+                    }
+                    const children = parseInline(itemText);
                     content.push({
                         type: 'list',
                         text: children.map(c => c.text || '').join(''),
@@ -278,7 +608,9 @@ const parseMarkdown = async (buffer, config) => {
                             indentation: level,
                             alignment: alignment || 'left',
                             listId,
-                            itemIndex: listCounters[level]
+                            itemIndex: listCounters[level],
+                            isTask,
+                            checked
                         },
                         children
                     });
@@ -288,8 +620,19 @@ const parseMarkdown = async (buffer, config) => {
         }
         // Table (Simple Pipe or HTML)
         if ((block.includes('|') && block.match(/\n\s*\|?[-:| ]+\|?\s*\n/)) || block.includes('<table')) {
+            // Pandoc-style trailing attribute list (`{align=right}`) immediately after the
+            // table, or Kramdown's `{: align=right}` on its own following line - both land
+            // in this same raw block since there's no blank line separating them.
+            let tableAlign;
+            const tableAttrLineMatch = block.match(/\n\{:?\s*([^}]*)\}\s*$/);
+            if (tableAttrLineMatch) {
+                tableAlign = parseAttributeList(tableAttrLineMatch[1]).align;
+                block = block.slice(0, tableAttrLineMatch.index);
+            }
             if (block.includes('<table')) {
                 // Basic HTML table recognition (extracting rows/cells)
+                const tableTagMatch = block.match(/<table([^>]*)>/i);
+                const tableAlignMatch = tableTagMatch?.[1]?.match(/data-align=["']?(left|center|right)["']?/i);
                 const rows = [];
                 const trRegex = /<tr[^>]*>([\s\S]*?)<\/tr>/gi;
                 let trMatch;
@@ -314,8 +657,13 @@ const parseMarkdown = async (buffer, config) => {
                     if (cells.length > 0)
                         rows.push({ type: 'row', children: cells });
                 }
+                const resolvedAlign = tableAlign || (tableAlignMatch ? tableAlignMatch[1].toLowerCase() : undefined);
                 if (rows.length > 0) {
-                    content.push({ type: 'table', children: rows });
+                    content.push({
+                        type: 'table',
+                        metadata: resolvedAlign ? { align: resolvedAlign } : undefined,
+                        children: rows
+                    });
                     continue;
                 }
             }
@@ -326,13 +674,26 @@ const parseMarkdown = async (buffer, config) => {
                     if (lines[i].match(/^\|?[-:| ]*---[-:| ]*\|?$/))
                         continue; // Separator row (requires at least one triple-hyphen)
                     const cellsStr = lines[i].replace(/^\||\|$/g, '').split('|');
-                    const cells = cellsStr.map(c => ({
-                        type: 'cell',
-                        children: parseInline(c.trim(), i === 0 ? { bold: true } : {})
-                    }));
+                    const cells = cellsStr.map(c => {
+                        // Recognize the MarkdownGenerator's own cell-alignment fallback,
+                        // `<div style="text-align: X">…</div>`, and lift it into an aligned
+                        // paragraph so it round-trips as alignment instead of being escaped to
+                        // visible text on regeneration. Unwrap wherever it sits (e.g. inside **…**).
+                        let cellText = c.trim();
+                        let cellAlign;
+                        cellText = cellText.replace(/<div\s+style="text-align:\s*(left|center|right|justify);?"\s*>([\s\S]*?)<\/div>/gi, (_m, a, inner) => { cellAlign = a.toLowerCase(); return inner; });
+                        const inline = parseInline(cellText, i === 0 ? { bold: true } : {});
+                        if (cellAlign && cellAlign !== 'left') {
+                            return {
+                                type: 'cell',
+                                children: [{ type: 'paragraph', metadata: { alignment: cellAlign }, children: inline }]
+                            };
+                        }
+                        return { type: 'cell', children: inline };
+                    });
                     rows.push({ type: 'row', children: cells });
                 }
-                content.push({ type: 'table', children: rows });
+                content.push({ type: 'table', metadata: tableAlign ? { align: tableAlign } : undefined, children: rows });
                 continue;
             }
         }
@@ -348,14 +709,44 @@ const parseMarkdown = async (buffer, config) => {
             children: parseInline(block.replace(/\n/g, ' '))
         });
     }
+    // Fold standalone anchor placeholders into the following content node's anchorIds so a
+    // bookmark target emitted on its own line round-trips as a real anchor. A trailing placeholder
+    // with no following node attaches to the previous node instead; if the document is nothing but
+    // anchors, they are dropped (there is no node to host them).
+    if (content.some(n => n.type === ANCHOR_PLACEHOLDER)) {
+        const merged = [];
+        let carried = [];
+        for (const node of content) {
+            if (node.type === ANCHOR_PLACEHOLDER) {
+                carried.push(...(node.metadata?.anchorIds || []));
+                continue;
+            }
+            if (carried.length > 0) {
+                const meta = node.metadata || (node.metadata = {});
+                meta.anchorIds = [...carried, ...(meta.anchorIds || [])];
+                carried = [];
+            }
+            merged.push(node);
+        }
+        if (carried.length > 0 && merged.length > 0) {
+            const last = merged[merged.length - 1].metadata || (merged[merged.length - 1].metadata = {});
+            last.anchorIds = [...(last.anchorIds || []), ...carried];
+        }
+        content.length = 0;
+        content.push(...merged);
+    }
     const toTextSync = () => content.map(n => {
         const getText = (node) => {
             if (node.type === 'text' || node.type === 'code')
                 return node.text || '';
             if (node.type === 'break')
                 return '\n';
+            // Childless nodes still carry meaningful text - fall back to it instead of
+            // silently vanishing from plain-text/RAG-chunk output.
+            if (node.type === 'embed')
+                return node.metadata?.url || '';
             if (node.children) {
-                const isBlock = ['table', 'row', 'list', 'sheet', 'slide'].includes(node.type);
+                const isBlock = ['table', 'row', 'list', 'sheet', 'slide', 'admonition', 'definitionList'].includes(node.type);
                 return node.children.map(getText).join(isBlock ? config.newlineDelimiter : '');
             }
             return '';

package/dist/parsers/PdfParser.js

@@ -308,7 +308,10 @@ const parsePdf = async (buffer, config) => {
     const uint8Array = new Uint8Array(buffer);
     const loadingTask = pdfjs.getDocument({
         data: uint8Array,
-        verbosity: 0 // ERRORS only, suppresses warnings
+        verbosity: 0, // ERRORS only, suppresses warnings
+        // Harden against untrusted PDFs: don't let pdf.js JIT font/CMap fast-paths
+        // compile via `new Function`.
+        isEvalSupported: false
     });
     // Handle loading errors, specifically missing worker in browser
     let pdfDocument;