officeparser 7.6.1 → 7.7.0

package/dist/parsers/HtmlParser.js

@@ -706,6 +706,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 +947,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 +1017,7 @@ const parseHtml = async (buffer, config) => {
                             metadata: {
                                 attachmentName: name,
                                 altText: alt,
+                                title: node.attributes?.title,
                                 width,
                                 align
                             }
@@ -1002,6 +1029,7 @@ const parseHtml = async (buffer, config) => {
                             metadata: {
                                 url: src,
                                 altText: alt,
+                                title: node.attributes?.title,
                                 width,
                                 align
                             }
@@ -1014,6 +1042,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 +1084,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
@@ -259,7 +268,15 @@ const parseMarkdown = async (buffer, config) => {
         // 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 +293,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 +331,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>|<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 +360,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' } });
             }
@@ -355,6 +375,12 @@ const parseMarkdown = async (buffer, config) => {
             else if (g.superscript !== undefined) { // Superscript
                 nodes.push(...parseInline(g.superscript, { ...currentFormatting, superscript: true }));
             }
+            else if (g.lineBreak !== undefined) { // Raw inline <br>/<br/>/<br /> - a hard line break.
+                // MarkdownGenerator emits a raw <br> for a line break inside a table cell (a GFM pipe
+                // cell can't hold a newline), so the parser must read it back symmetrically as a break
+                // node instead of escaping it to literal `&lt;br&gt;` text and destroying it.
+                nodes.push({ type: 'break', metadata: { breakType: 'carriageReturn' } });
+            }
             else if (g.spanContent !== undefined) { // Inline styled span: color / highlight / font-size
                 const style = g.spanStyle || '';
                 const styled = { ...currentFormatting };
@@ -604,6 +630,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) {
@@ -968,11 +1019,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
@@ -981,17 +1044,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;
             }
         }