officeparser 7.6.2 → 7.8.0

package/dist/parsers/HtmlParser.js

@@ -558,6 +558,32 @@ const parseHtml = async (buffer, config) => {
                 }
                 return kids;
             };
+            // Gated generic-iframe embed (HtmlGenerator's `gatedEmbeds` shape): an inert
+            // click-to-load placeholder that never auto-loads its src. Read it back to the same
+            // `embed` node unconditionally - capturing metadata is safe (the src is scheme-checked
+            // again on any re-emit); it is the trusted, already-gated counterpart to a raw <iframe>.
+            if (tagName === 'div' && node.attributes?.['data-embed-gated'] !== undefined) {
+                const gatedSrc = decodeEntities(node.attributes?.['data-embed-src'] || '');
+                if (!gatedSrc)
+                    return null;
+                const gatedAlignAttr = node.attributes?.['data-embed-align'];
+                const gatedAlign = ['left', 'center', 'right'].includes(gatedAlignAttr) ? gatedAlignAttr : undefined;
+                const gatedNode = {
+                    type: 'embed',
+                    text: gatedSrc,
+                    metadata: {
+                        embedType: 'iframe',
+                        url: gatedSrc,
+                        width: node.attributes?.['data-embed-width'],
+                        height: node.attributes?.['data-embed-height'],
+                        align: gatedAlign,
+                        label: node.attributes?.['data-embed-label']
+                    }
+                };
+                if (config.includeRawContent)
+                    gatedNode.rawContent = '<div data-embed-gated>...</div>';
+                return gatedNode;
+            }
             // YouTube embeds: attribute-driven editors render
             // <div data-youtube-video="ID" data-width="…" data-align="…">…<iframe…></div>.
             // Recognise both the wrapper div and a bare iframe so externally-authored HTML
@@ -578,7 +604,8 @@ const parseHtml = async (buffer, config) => {
                         videoId,
                         url: embedUrl,
                         width,
-                        align: embedAlign
+                        align: embedAlign,
+                        label: node.attributes?.['data-embed-label']
                     }
                 };
                 if (config.includeRawContent)
@@ -593,7 +620,15 @@ const parseHtml = async (buffer, config) => {
                     const embedNode = {
                         type: 'embed',
                         text: embedUrl,
-                        metadata: { embedType: 'youtube', videoId: ytMatch[1], url: embedUrl }
+                        // Carry the iframe's own width/height so a YouTube iframe's dimensions are not
+                        // dropped (metadata is unified across embedTypes; align has no source here).
+                        metadata: {
+                            embedType: 'youtube',
+                            videoId: ytMatch[1],
+                            url: embedUrl,
+                            width: node.attributes?.width,
+                            height: node.attributes?.height
+                        }
                     };
                     if (config.includeRawContent)
                         embedNode.rawContent = '<iframe>...</iframe>';
@@ -706,6 +741,22 @@ const parseHtml = async (buffer, config) => {
                     admonitionNode.rawContent = '<div class="admonition">...</div>';
                 return admonitionNode;
             }
+            // Blockquote. Previously dropped entirely (its children were lifted out unquoted), so a
+            // <blockquote> lost its `> ` on the Markdown hop. Mark each block child with the 'Quote'
+            // style the styleMapper maps back to a blockquote; loose inline content is wrapped in one
+            // Quote-styled paragraph so it isn't emitted as an ordinary line.
+            if (tagName === 'blockquote') {
+                const kids = parseChildren(node, newFormatting, listContext);
+                const isBlock = (t) => t === 'paragraph' || t === 'heading' || t === 'list';
+                if (!kids.some(k => isBlock(k.type))) {
+                    return { type: 'paragraph', metadata: { style: 'Quote' }, children: kids };
+                }
+                kids.forEach(k => {
+                    if (isBlock(k.type))
+                        k.metadata = { ...k.metadata, style: 'Quote' };
+                });
+                return kids;
+            }
             // Mermaid diagrams. Attribute-driven producers render a
             // <div class="mermaid" data-mermaid="<code>"> with the code also as text content.
             // Map either shape to a fenced code node with language `mermaid`, so it round-trips as
@@ -931,11 +982,21 @@ const parseHtml = async (buffer, config) => {
                 const rowSpanAttr = node.attributes?.rowspan;
                 const colSpan = colSpanAttr ? parseInt(colSpanAttr, 10) : undefined;
                 const rowSpan = rowSpanAttr ? parseInt(rowSpanAttr, 10) : undefined;
+                // Per-column GFM alignment: read the cell's own `text-align` (or a legacy `align=`
+                // attribute) into `CellMetadata.align`, so the `:---`/`:---:`/`---:` markers survive
+                // AST -> HTML -> AST. `justify` has no pipe-table marker, so it is not a cell align.
+                // The table-level `<table data-align>` form is read separately in the `table` branch.
+                const cellTextAlign = (getDeclaration(parseStyleDeclarations(node.attributes?.style || ''), 'text-align')
+                    || node.attributes?.align || '').toLowerCase();
+                const cellAlign = ['left', 'center', 'right'].includes(cellTextAlign)
+                    ? cellTextAlign
+                    : undefined;
                 const cellNode = {
                     type: 'cell',
                     metadata: {
                         colSpan: colSpan && !isNaN(colSpan) ? colSpan : undefined,
-                        rowSpan: rowSpan && !isNaN(rowSpan) ? rowSpan : undefined
+                        rowSpan: rowSpan && !isNaN(rowSpan) ? rowSpan : undefined,
+                        align: cellAlign
                     },
                     children: parseChildren(node, newFormatting, listContext),
                     htmlAttributes: collectHtmlAttributes(node, ['colspan', 'rowspan', 'align'])
@@ -991,6 +1052,7 @@ const parseHtml = async (buffer, config) => {
                             metadata: {
                                 attachmentName: name,
                                 altText: alt,
+                                title: node.attributes?.title,
                                 width,
                                 align
                             }
@@ -1002,6 +1064,7 @@ const parseHtml = async (buffer, config) => {
                             metadata: {
                                 url: src,
                                 altText: alt,
+                                title: node.attributes?.title,
                                 width,
                                 align
                             }
@@ -1014,6 +1077,7 @@ const parseHtml = async (buffer, config) => {
                         metadata: {
                             url: src,
                             altText: alt,
+                            title: node.attributes?.title,
                             anchorIds: anchorIds.length > 0 ? anchorIds : undefined,
                             width,
                             align
@@ -1055,16 +1119,20 @@ const parseHtml = async (buffer, config) => {
                 }
                 else if (href) {
                     const linkType = href.startsWith('#') ? 'internal' : 'external';
+                    const linkTitle = node.attributes?.title;
                     children.forEach(c => {
                         if (c.type === 'text') {
-                            c.metadata = { ...c.metadata, link: href, linkType };
+                            c.metadata = { ...c.metadata, link: href, linkType, title: linkTitle };
                         }
                     });
                 }
                 return children;
             }
             if (tagName === 'br') {
-                const brNode = { type: 'break', metadata: { breakType: 'textWrapping' } };
+                // A <br> is a hard line break: `carriageReturn` so the Markdown generator emits a
+                // hard break (`  \n`, or a `<br>` inside a table cell) that re-imports as a <br>.
+                // `textWrapping` emitted a bare `\n` in a paragraph, which re-imports as a space.
+                const brNode = { type: 'break', metadata: { breakType: 'carriageReturn' } };
                 if (config.includeRawContent) {
                     brNode.rawContent = '<br/>';
                 }

package/dist/parsers/MarkdownParser.js

@@ -166,6 +166,15 @@ const parseMarkdown = async (buffer, config) => {
         mathBlocks.push(latex);
         return `\n\n${id}\n\n`;
     });
+    // Single-line `$$...$$` occupying its own line is display (block) math too. Without this it
+    // falls through to the inline `$...$` tokenizer, which matches the INNER `$\int$` and leaks
+    // the outer pair as two stray literal `$`. Runs after the multi-line pass, whose placeholders
+    // carry no `$$` and so can't be re-matched. `(?!\$)` rejects `$$$...`/empty `$$$$`.
+    textStr = textStr.replace(/^\$\$(?!\$)([^\n]+?)\$\$[ \t]*$/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
@@ -253,13 +262,52 @@ const parseMarkdown = async (buffer, config) => {
         }
         return result;
     };
+    // Attribute list for an embed leaf directive `{id=... src=... width=... height=... align=...}`.
+    // Superset of parseAttributeList (adds id/src/height); space-separated `k=v` tokens.
+    const parseEmbedDirectiveAttrs = (attrStr) => {
+        const result = {};
+        for (const token of attrStr.trim().split(/\s+/).filter(Boolean)) {
+            const kv = token.match(/^([a-zA-Z-]+)=(.+)$/);
+            if (!kv)
+                continue;
+            const [, key, val] = kv;
+            if (key === 'id')
+                result.id = val;
+            else if (key === 'src')
+                result.src = val;
+            else if (key === 'width')
+                result.width = val;
+            else if (key === 'height')
+                result.height = val;
+            else if (key === 'align' && ['left', 'center', 'right'].includes(val))
+                result.align = val;
+        }
+        return result;
+    };
+    // Extracts a YouTube video id from any of its URL shapes (watch?v=, youtu.be/, /embed/,
+    // img.youtube.com/vi/). Returns undefined for a non-YouTube URL. Used only by the opt-in
+    // folk-form import (embedFolkForms).
+    const extractYoutubeId = (url) => {
+        if (!url || !/(?:youtu\.be|youtube(?:-nocookie)?\.com)/.test(url))
+            return undefined;
+        const m = url.match(/(?:youtu\.be\/|\/embed\/|[?&]v=|\/vi\/)([A-Za-z0-9_-]+)/);
+        return m ? m[1] : undefined;
+    };
     const parseInline = (text, currentFormatting = {}) => {
         const nodes = [];
         const plainText = (t) => ({ type: 'text', text: t, formatting: Object.keys(currentFormatting).length > 0 ? { ...currentFormatting } : undefined });
         // Builds the same image/link node shape regardless of whether the URL came from
         // an inline `(url)` or a resolved reference definition - shared by the inline
         // image/link branch and the two reference-style branches below.
-        const buildLinkOrImageNodes = (isImage, altText, url, attrsStr) => {
+        // Split a Markdown inline destination `url "title"` (also `'title'` / `(title)`) into its
+        // URL and optional title. The inline parser previously kept the whole thing as the URL, so
+        // `[t](u "T")` produced href `u "T"`; reference-style `[t][id]` already split it correctly.
+        const splitUrlTitle = (raw) => {
+            const m = raw.trim().match(/^(.*?)\s+(?:"([^"]*)"|'([^']*)'|\(([^)]*)\))\s*$/);
+            return m ? { url: m[1].trim(), title: m[2] ?? m[3] ?? m[4] } : { url: raw };
+        };
+        const buildLinkOrImageNodes = (isImage, altText, rawUrl, attrsStr) => {
+            const { url, title } = splitUrlTitle(rawUrl);
             if (isImage) {
                 // Pandoc-style attribute list immediately after an image, e.g. {width=50% .centered}
                 const attrs = attrsStr !== undefined ? parseAttributeList(attrsStr) : undefined;
@@ -276,15 +324,15 @@ const parseMarkdown = async (buffer, config) => {
                             name,
                             extension: mimeType.split('/')[1]
                         });
-                        return [{ type: 'image', metadata: { attachmentName: name, altText, ...attrs } }];
+                        return [{ type: 'image', metadata: { attachmentName: name, altText, title, ...attrs } }];
                     }
                 }
-                return [{ type: 'image', metadata: { url, altText, ...attrs } }];
+                return [{ type: 'image', metadata: { url, altText, title, ...attrs } }];
             }
             const linkNodes = parseInline(altText, currentFormatting);
             linkNodes.forEach(n => {
                 if (n.type === 'text') {
-                    n.metadata = { link: url, linkType: 'external' };
+                    n.metadata = { link: url, linkType: 'external', title };
                 }
             });
             return linkNodes;
@@ -314,7 +362,7 @@ const parseMarkdown = async (buffer, config) => {
         // 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 = /\\(?<esc>[!-\/:-@\[-`{-~])|(?<imgBang>!?)\[(?<imgAlt>.*?)\]\((?<imgUrl>.*?)\)(?:\{(?<imgAttrs>[^}]*)\})?|\*\*(?<boldStar>.+?)\*\*|__(?<boldUnderscore>.+?)__|\*(?<italicStar>.+?)\*|_(?<italicUnderscore>.+?)_|~~(?<strike>.+?)~~|(?<codeFence>`+)(?<codeContent>(?:(?!\k<codeFence>)[\s\S])+?)\k<codeFence>(?!`)|<u>(?<underline>.+?)<\/u>|<sub>(?<subscript>.+?)<\/sub>|<sup>(?<superscript>.+?)<\/sup>|(?<lineBreak><br\s*\/?>)|<span\s+style="(?<spanStyle>[^"]*)">(?<spanContent>.+?)<\/span>|\[\^(?<footnoteId>[^\]]+)\]|\[@(?<citationKey>[a-zA-Z0-9_:.-]+)\]|\[\[(?<wikiPage>[^\]|]+)(?:\|(?<wikiAlias>[^\]]+))?\]\]|(?<refBang>!?)\[(?<refText>[^\]]*)\]\[(?<refId>[^\]]*)\]|(?<shortBang>!?)\[(?<shortText>[^\]]+)\]|<(?<autolinkUrl>(?:https?|mailto):[^\s<>]+)>|\$(?!\s)(?<mathInline>[^$\n]+?)(?<!\s)\$/g;
+        const regex = /\\(?<esc>[!-\/:-@\[-`{-~])|(?<imgBang>!?)\[(?<imgAlt>.*?)\]\((?<imgUrl>.*?)\)(?:\{(?<imgAttrs>[^}]*)\})?|\*\*(?<boldStar>.+?)\*\*|__(?<boldUnderscore>.+?)__|\*(?<italicStar>.+?)\*|_(?<italicUnderscore>.+?)_|~~(?<strike>.+?)~~|==(?<highlight>.+?)==|(?<codeFence>`+)(?<codeContent>(?:(?!\k<codeFence>)[\s\S])+?)\k<codeFence>(?!`)|<u>(?<underline>.+?)<\/u>|<sub>(?<subscript>.+?)<\/sub>|<sup>(?<superscript>.+?)<\/sup>|(?<lineBreak><br\s*\/?>)|<span\s+style="(?<spanStyle>[^"]*)">(?<spanContent>.+?)<\/span>|\[\^(?<footnoteId>[^\]]+)\]|\[@(?<citationKey>[a-zA-Z0-9_:.-]+)\]|\[\[(?<wikiPage>[^\]|]+)(?:\|(?<wikiAlias>[^\]]+))?\]\]|(?<refBang>!?)\[(?<refText>[^\]]*)\]\[(?<refId>[^\]]*)\]|(?<shortBang>!?)\[(?<shortText>[^\]]+)\]|<(?<autolinkUrl>(?:https?|mailto):[^\s<>]+)>|\$(?!\s)(?<mathInline>[^$\n]+?)(?<!\s)\$/g;
         let lastIndex = 0;
         let match;
         while ((match = regex.exec(text)) !== null) {
@@ -343,6 +391,9 @@ const parseMarkdown = async (buffer, config) => {
             else if (g.strike !== undefined) { // Strikethrough
                 nodes.push(...parseInline(g.strike, { ...currentFormatting, strikethrough: true }));
             }
+            else if (g.highlight !== undefined) { // ==highlight== (Obsidian/extended); additive on import
+                nodes.push(...parseInline(g.highlight, { ...currentFormatting, backgroundColor: '#ffff00' }));
+            }
             else if (g.codeContent !== undefined) { // Inline code (any matching backtick-run length)
                 nodes.push({ type: 'text', text: g.codeContent, formatting: { ...currentFormatting, font: 'monospace' } });
             }
@@ -610,6 +661,31 @@ const parseMarkdown = async (buffer, config) => {
             blocks.push(currentSubBlock.join('\n'));
         }
     }
+    // Re-join a list block that a blank line tore away from its parent. The generator's older
+    // loose output (`- a\n\n\n    - a1`) and foreign editors both split a nested item into its
+    // own block; left apart, the child's leading indent is stripped by the per-block `trim()`
+    // below and it reparses as a flat top-level item under a fresh listId. Merge a block back
+    // into the preceding one only when the previous block is itself a list (its FIRST line is a
+    // marker - the sub-splitter guarantees such a block holds only marker/continuation lines) and
+    // the current block OPENS with an INDENTED marker. An unindented `- b` after a blank line is
+    // deliberately left split (a flat loose list keeps its own listId), and anything that is not
+    // an indented marker (continuation text, indented code, placeholders) never triggers a merge.
+    const listMarkerStart = /^(\s*)([-*+]|\d+[.)])\s+/;
+    const indentedMarkerStart = /^(?: {2,}|\t)\s*(?:[-*+]|\d+[.)])\s+/;
+    const mergedBlocks = [];
+    for (const block of blocks) {
+        const prev = mergedBlocks[mergedBlocks.length - 1];
+        if (prev !== undefined
+            && listMarkerStart.test(prev.split('\n', 1)[0])
+            && indentedMarkerStart.test(block.split('\n', 1)[0])) {
+            mergedBlocks[mergedBlocks.length - 1] = `${prev}\n${block}`;
+        }
+        else {
+            mergedBlocks.push(block);
+        }
+    }
+    blocks.length = 0;
+    blocks.push(...mergedBlocks);
     let listIdCounter = 1;
     let currentAlignment = undefined;
     for (let block of blocks) {
@@ -652,6 +728,63 @@ const parseMarkdown = async (buffer, config) => {
             alignment = (alignMatch[1] || alignMatch[2]).toLowerCase();
             block = alignMatch[3];
         }
+        // Embed leaf directive (remark-directive family): `::youtube[Label]{id=... width=... align=...}`
+        // or `::embed[Label]{src=... width=... height=... align=...}`. Only these two names are
+        // recognised; any other `::name` stays literal text (no catch-all). `::youtube` renders from
+        // a validated id via a fixed template, so it is unconditional; `::embed` carries an arbitrary
+        // src, so it is gated behind `preserveIframes` (the trust input) exactly like a raw <iframe>,
+        // and stays literal text otherwise. New input only; nothing that parsed before changes.
+        const embedDirectiveMatch = block.match(/^::(youtube|embed)(?:\[([^\]]*)\])?\{([^}]*)\}$/);
+        if (embedDirectiveMatch) {
+            const kind = embedDirectiveMatch[1];
+            const label = (embedDirectiveMatch[2] || '').trim() || undefined;
+            const attrs = parseEmbedDirectiveAttrs(embedDirectiveMatch[3]);
+            if (kind === 'youtube' && attrs.id) {
+                const embedUrl = `https://www.youtube.com/watch?v=${attrs.id}`;
+                content.push({
+                    type: 'embed',
+                    text: embedUrl,
+                    metadata: { embedType: 'youtube', videoId: attrs.id, url: embedUrl, width: attrs.width, align: attrs.align, label }
+                });
+                continue;
+            }
+            if (kind === 'embed' && attrs.src && (0, sanitize_js_1.iframeAllowed)(attrs.src, config.htmlParserConfig?.preserveIframes)) {
+                content.push({
+                    type: 'embed',
+                    text: attrs.src,
+                    metadata: { embedType: 'iframe', url: attrs.src, width: attrs.width, height: attrs.height, align: attrs.align, label }
+                });
+                continue;
+            }
+            // Recognised name but not a usable/allowed directive: fall through so the line becomes
+            // ordinary text rather than being dropped.
+        }
+        // Ambiguous "folk" embed forms, imported only under the opt-in (embedFolkForms), since
+        // auto-upgrading an image/link to an embed is a heuristic that could mangle a genuine image
+        // link. Both become a safe youtube embed (rendered from the validated id). A standalone line
+        // only; anything not matching falls through to ordinary image/link parsing.
+        if (config.htmlParserConfig?.embedFolkForms) {
+            // Clickable thumbnail: [![alt](thumb)](watch), youtube when either URL is a youtube link.
+            const thumbMatch = block.match(/^\[!\[([^\]]*)\]\(([^)\s]+)\)\]\(([^)\s]+)\)$/);
+            if (thumbMatch) {
+                const fid = extractYoutubeId(thumbMatch[2]) || extractYoutubeId(thumbMatch[3]);
+                if (fid) {
+                    const embedUrl = `https://www.youtube.com/watch?v=${fid}`;
+                    content.push({ type: 'embed', text: embedUrl, metadata: { embedType: 'youtube', videoId: fid, url: embedUrl, label: thumbMatch[1].trim() || undefined } });
+                    continue;
+                }
+            }
+            // Obsidian-style: a standalone image whose URL is a youtube link.
+            const obsMatch = block.match(/^!\[([^\]]*)\]\(([^)\s]+)\)$/);
+            if (obsMatch) {
+                const fid = extractYoutubeId(obsMatch[2]);
+                if (fid) {
+                    const embedUrl = `https://www.youtube.com/watch?v=${fid}`;
+                    content.push({ type: 'embed', text: embedUrl, metadata: { embedType: 'youtube', videoId: fid, url: embedUrl, label: obsMatch[1].trim() || undefined } });
+                    continue;
+                }
+            }
+        }
         // 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.
@@ -661,6 +794,7 @@ const parseMarkdown = async (buffer, config) => {
             const attrsStr = youtubeMatch[2];
             const widthMatch = attrsStr.match(/data-width="([^"]*)"/i);
             const youtubeAlignMatch = attrsStr.match(/data-align="([^"]*)"/i);
+            const youtubeLabelMatch = attrsStr.match(/data-embed-label="([^"]*)"/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({
@@ -673,7 +807,8 @@ const parseMarkdown = async (buffer, config) => {
                     videoId,
                     url: embedUrl,
                     width: widthMatch?.[1],
-                    align: embedAlign
+                    align: embedAlign,
+                    label: youtubeLabelMatch?.[1]
                 }
             });
             continue;
@@ -692,9 +827,29 @@ const parseMarkdown = async (buffer, config) => {
                 .replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"')
                 .replace(/&#39;/g, '\'').replace(/&amp;/g, '&');
             const src = decodeAttr(attrsStr.match(/\bsrc="([^"]*)"/i)?.[1]);
+            const width = attrsStr.match(/\bwidth="([^"]*)"/i)?.[1];
+            const height = attrsStr.match(/\bheight="([^"]*)"/i)?.[1];
+            // A YouTube iframe is recognised the same way the HTML parser does it (host + id
+            // capture), BEFORE and INDEPENDENT of the preserveIframes gate, so the same iframe
+            // yields the same 'youtube' embed whichever parser sees it. Only a generic (non-YouTube)
+            // iframe is gated behind preserveIframes and kept as an 'iframe' embed.
+            const ytMatch = src && /youtube(?:-nocookie)?\.com/.test(src) ? src.match(/(?:embed\/|v=)([^&?/\s]+)/) : null;
+            if (ytMatch) {
+                const embedUrl = `https://www.youtube.com/watch?v=${ytMatch[1]}`;
+                content.push({
+                    type: 'embed',
+                    text: embedUrl,
+                    metadata: {
+                        embedType: 'youtube',
+                        videoId: ytMatch[1],
+                        url: embedUrl,
+                        width: width !== undefined ? decodeAttr(width) : undefined,
+                        height: height !== undefined ? decodeAttr(height) : undefined
+                    }
+                });
+                continue;
+            }
             if (src && (0, sanitize_js_1.iframeAllowed)(src, config.htmlParserConfig?.preserveIframes)) {
-                const width = attrsStr.match(/\bwidth="([^"]*)"/i)?.[1];
-                const height = attrsStr.match(/\bheight="([^"]*)"/i)?.[1];
                 content.push({
                     type: 'embed',
                     text: src,
@@ -974,11 +1129,23 @@ const parseMarkdown = async (buffer, config) => {
             else {
                 const lines = block.trim().split('\n');
                 const rows = [];
+                // Pre-scan the separator row for per-column GFM alignment (`:--` left, `:-:` center,
+                // `--:` right; a bare `--` column has none), so every cell can carry its column's
+                // alignment on CellMetadata.align (the header row precedes the separator, so a
+                // per-cell pass alone could not see it).
+                const sepLine = lines.find(l => l.match(/^\|?\s*:?-+:?\s*(?:\|\s*:?-+:?\s*)*\|?$/));
+                const columnAligns = sepLine
+                    ? sepLine.replace(/^\||\|$/g, '').split('|').map(c => {
+                        const t = c.trim();
+                        const l = t.startsWith(':'), r = t.endsWith(':');
+                        return (l && r) ? 'center' : r ? 'right' : l ? 'left' : null;
+                    })
+                    : [];
                 for (let i = 0; i < lines.length; i++) {
                     if (lines[i].match(/^\|?\s*:?-+:?\s*(?:\|\s*:?-+:?\s*)*\|?$/))
                         continue; // Separator row (per-cell `:?-+:?`, GFM-style; accepts short cells like `|-|-|`)
                     const cellsStr = lines[i].replace(/^\||\|$/g, '').split('|');
-                    const cells = cellsStr.map(c => {
+                    const cells = cellsStr.map((c, colIdx) => {
                         // 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
@@ -987,17 +1154,25 @@ const parseMarkdown = async (buffer, config) => {
                         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 } : {});
+                        const colAlign = columnAligns[colIdx] ?? undefined;
+                        const cellMeta = colAlign ? { col: colIdx, align: colAlign } : undefined;
                         if (cellAlign && cellAlign !== 'left') {
                             return {
                                 type: 'cell',
+                                metadata: cellMeta,
                                 children: [{ type: 'paragraph', metadata: { alignment: cellAlign }, children: inline }]
                             };
                         }
-                        return { type: 'cell', children: inline };
+                        return { type: 'cell', metadata: cellMeta, children: inline };
                     });
                     rows.push({ type: 'row', children: cells });
                 }
-                content.push({ type: 'table', metadata: tableAlign ? { align: tableAlign } : undefined, children: rows });
+                // If every explicitly-aligned column agrees, also expose it as the table-level align,
+                // so an editor that models one alignment per table (and HTML data-align) round-trips.
+                const explicitAligns = columnAligns.filter((a) => a !== null);
+                const uniformAlign = explicitAligns.length > 0 && explicitAligns.every(a => a === explicitAligns[0]) ? explicitAligns[0] : undefined;
+                const resolvedTableAlign = tableAlign || uniformAlign;
+                content.push({ type: 'table', metadata: resolvedTableAlign ? { align: resolvedTableAlign } : undefined, children: rows });
                 continue;
             }
         }