officeparser 7.5.1 → 7.6.2

package/dist/parsers/HtmlParser.js

@@ -12,6 +12,19 @@ const sanitize_js_1 = require("../utils/sanitize.js");
  * `parseNode` for why this value and not a larger one.
  */
 const MAX_HTML_NESTING_DEPTH = 256;
+/**
+ * Decode the handful of HTML entities this parser leaves intact. Text nodes and attribute
+ * values are kept in their raw escaped form during parsing (see `parseAttributes`), so any
+ * branch that lifts text or an attribute into AST content has to decode first - `<` inside
+ * a code/math body is a less-than operator, not markup.
+ */
+const decodeEntities = (s) => s
+    .replace(/ /g, ' ')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&')
+    .replace(/&quot;/g, '"')
+    .replace(/&#39;/g, "'");
 /**
  * Presents an `HtmlNode` as a `MathNode` for the shared MathML converter.
  *
@@ -22,13 +35,7 @@ const MAX_HTML_NESTING_DEPTH = 256;
 const toMathNode = (node) => ({
     tagName: node.tagName,
     attributes: node.attributes,
-    text: node.text === undefined ? undefined : node.text
-        .replace(/&nbsp;/g, ' ')
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/&amp;/g, '&')
-        .replace(/&quot;/g, '"')
-        .replace(/&#39;/g, "'"),
+    text: node.text === undefined ? undefined : decodeEntities(node.text),
     children: (node.children || []).map(toMathNode),
 });
 const parseAttributes = (attrString) => {
@@ -165,9 +172,36 @@ const parseHtmlTree = (html) => {
             cursor = commentEnd !== -1 ? commentEnd + 3 : html.length;
             continue;
         }
-        // indexOf (not substring().match) so scanning for the tag end is O(1) in
-        // allocation — a document with many "<" chars would otherwise be O(n^2).
-        const tagEndIdx = html.indexOf('>', tagStart);
+        // Scan for the tag's closing '>', skipping any that appear inside a quoted attribute value.
+        // Browsers do NOT escape '>' inside attribute values on serialization, so a literal '>' there
+        // (e.g. a mermaid diagram's `-->` in data-mermaid) must not be read as the tag end. The scan
+        // is linear in the tag's length and the cursor never rewinds, so the parse stays O(n) overall
+        // (no substring().match allocation per '<').
+        let tagEndIdx = -1;
+        let attrQuote = '';
+        for (let i = tagStart + 1; i < html.length; i++) {
+            const ch = html[i];
+            if (attrQuote) {
+                if (ch === attrQuote)
+                    attrQuote = '';
+            }
+            else if (ch === '"' || ch === '\'') {
+                attrQuote = ch;
+            }
+            else if (ch === '>') {
+                tagEndIdx = i;
+                break;
+            }
+        }
+        if (tagEndIdx === -1) {
+            // The quote-aware scan ran to the end without closing the tag. That is almost always an
+            // unbalanced quote from a stray unescaped '<' in prose (e.g. "a < b's weight"), not a
+            // genuinely truncated tag. Retry naively for the next literal '>': the resulting
+            // pseudo-tag is then dropped, so a malformed run degrades exactly as it did before the
+            // quote-aware scan existed instead of swallowing the rest of the document into one text
+            // node. Well-formed input with balanced quotes never reaches here.
+            tagEndIdx = html.indexOf('>', tagStart);
+        }
         if (tagEndIdx === -1) {
             const text = html.substring(tagStart);
             current.children.push({ type: 'text', text, children: [], parent: current });
@@ -335,6 +369,9 @@ const parseHtml = async (buffer, config) => {
     // body loop, since references can appear anywhere earlier in the document) and
     // consulted by parseChildren's <sup data-footnote-ref> handling below.
     const footnoteDefinitions = new Map();
+    // Keys a `<sup data-footnote-ref>` actually consumed, so definitions in the section that no
+    // reference points at (orphans) can be recovered at the end instead of silently dropped.
+    const referencedFootnoteKeys = new Set();
     // --- Generic attribute pass-through (htmlParserConfig.preserveAttributes) ---------------
     // Captures attributes no typed metadata field consumed, so they can be replayed on
     // generation. Everything here is a *defence-in-depth* filter: HtmlGenerator sanitizes again
@@ -395,13 +432,7 @@ const parseHtml = async (buffer, config) => {
             throw (0, errorUtils_js_1.getOfficeError)(types_js_1.OfficeErrorType.MAX_NESTING_DEPTH_EXCEEDED);
         }
         if (node.type === 'text') {
-            let decodedText = (node.text || '')
-                .replace(/&nbsp;/g, ' ')
-                .replace(/&lt;/g, '<')
-                .replace(/&gt;/g, '>')
-                .replace(/&amp;/g, '&')
-                .replace(/&quot;/g, '"')
-                .replace(/&#39;/g, "'");
+            let decodedText = decodeEntities(node.text || '');
             if (!config.preserveXmlWhitespace) {
                 decodedText = decodedText.replace(/\s+/g, ' ');
             }
@@ -436,6 +467,12 @@ const parseHtml = async (buffer, config) => {
                 newFormatting.superscript = true;
             if (tagName === 'code')
                 newFormatting.font = 'monospace';
+            if (tagName === 'mark') {
+                // <mark> is a highlight. Use its data-color when present (an inline
+                // background-color style, read below, still wins); a bare <mark> falls back to the
+                // conventional yellow so it round-trips as a highlight rather than plain text.
+                newFormatting.backgroundColor = node.attributes?.['data-color'] || '#ffff00';
+            }
             const styleAttr = node.attributes?.style || '';
             const alignAttr = node.attributes?.align || '';
             if (styleAttr || alignAttr) {
@@ -492,6 +529,7 @@ const parseHtml = async (buffer, config) => {
                     // instead of inserting a visible node, matching WordParser's convention.
                     if (child.type === 'element' && child.tagName === 'sup' && child.attributes?.['data-footnote-ref'] !== undefined) {
                         const key = child.attributes['data-footnote-ref'];
+                        referencedFootnoteKeys.add(key);
                         const definition = footnoteDefinitions.get(key);
                         const noteNode = {
                             type: 'note',
@@ -520,7 +558,7 @@ const parseHtml = async (buffer, config) => {
                 }
                 return kids;
             };
-            // YouTube embeds: inscript-editor's Youtube node renders
+            // 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
             // (and a saved-then-reopened .md that fell back to raw HTML) both round-trip.
@@ -561,6 +599,27 @@ const parseHtml = async (buffer, config) => {
                         embedNode.rawContent = '<iframe>...</iframe>';
                     return embedNode;
                 }
+                // Non-YouTube iframes are dropped by default (a deliberate security posture).
+                // preserveIframes opts back in, keeping the src as a generic 'iframe' embed; the
+                // src is scheme-checked again on generation, so this only widens what is retained.
+                // Decode the src (attribute values are stored entity-encoded) so it isn't
+                // double-escaped when the generator re-escapes it, which would corrupt query strings.
+                const decodedSrc = decodeEntities(src);
+                if ((0, sanitize_js_1.iframeAllowed)(decodedSrc, config.htmlParserConfig?.preserveIframes)) {
+                    const iframeNode = {
+                        type: 'embed',
+                        text: decodedSrc,
+                        metadata: {
+                            embedType: 'iframe',
+                            url: decodedSrc,
+                            width: node.attributes?.width,
+                            height: node.attributes?.height
+                        }
+                    };
+                    if (config.includeRawContent)
+                        iframeNode.rawContent = '<iframe>...</iframe>';
+                    return iframeNode;
+                }
                 return null;
             }
             // Footnotes section: its definitions were already extracted up front (see
@@ -570,22 +629,42 @@ const parseHtml = async (buffer, config) => {
             if (tagName === 'section' && node.attributes?.['data-footnotes'] !== undefined) {
                 return null;
             }
-            // Math: proposed contract (no editor node built yet) - HtmlGenerator emits
-            // <span/div class="math math-inline|math-block" data-math="inline|block">
-            // with the $-delimited LaTeX as the visible (escaped) text content.
+            // Math. Two accepted shapes, disambiguated by the `data-math` value:
+            //   1. This library's own output - `data-math="inline|block"` names the mode, and the
+            //      LaTeX is the visible ($-delimited, escaped) text content.
+            //   2. Attribute-driven producers that put the raw LaTeX in `data-math` and signal the
+            //      mode through the class (`math-inline`/`math-block`) or the tag.
+            // Anything whose `data-math` is exactly `inline`/`block` takes path 1 unchanged; every
+            // other value is treated as LaTeX (path 2). LaTeX literally equal to `inline`/`block`
+            // is the only ambiguous input, and its text content wins there anyway.
             if ((tagName === 'div' || tagName === 'span') && node.attributes?.['data-math'] !== undefined) {
-                const mathMode = node.attributes['data-math'] === 'block' ? 'block' : 'inline';
-                const rawText = node.children.map(c => c.text || '').join('')
-                    .replace(/&nbsp;/g, ' ')
-                    .replace(/&lt;/g, '<')
-                    .replace(/&gt;/g, '>')
-                    .replace(/&amp;/g, '&')
-                    .replace(/&quot;/g, '"')
-                    .replace(/&#39;/g, '\'');
-                const delimiter = mathMode === 'block' ? '$$' : '$';
-                const latex = rawText.startsWith(delimiter) && rawText.endsWith(delimiter)
-                    ? rawText.slice(delimiter.length, -delimiter.length)
-                    : rawText;
+                const dataMath = node.attributes['data-math'];
+                const modeIsExplicit = dataMath === 'inline' || dataMath === 'block';
+                const classTokens = (node.attributes?.class || '').split(/\s+/);
+                const rawText = decodeEntities(node.children.map(c => c.text || '').join(''));
+                // Prefer the text content; fall back to the attribute value (path 2 producers may
+                // emit an empty body).
+                const source = rawText || (modeIsExplicit ? '' : decodeEntities(dataMath));
+                // Strip whichever `$`/`$$` delimiters are actually present, independent of the
+                // resolved mode - a `$`-delimited body inside a <div> must not keep its delimiters.
+                // The delimiter also disambiguates the mode when neither an explicit `data-math` nor
+                // a `math-inline`/`math-block` class settles it (so `<div data-math="x">$x$</div>`
+                // reads as inline, not block-via-tag).
+                let latex = source;
+                let delimiterMode;
+                if (source.length >= 4 && source.startsWith('$$') && source.endsWith('$$')) {
+                    latex = source.slice(2, -2);
+                    delimiterMode = 'block';
+                }
+                else if (source.length >= 2 && source.startsWith('$') && source.endsWith('$')) {
+                    latex = source.slice(1, -1);
+                    delimiterMode = 'inline';
+                }
+                const mathMode = modeIsExplicit
+                    ? dataMath
+                    : classTokens.includes('math-block') ? 'block'
+                        : classTokens.includes('math-inline') ? 'inline'
+                            : delimiterMode ?? (tagName === 'div' ? 'block' : 'inline');
                 return {
                     type: 'code',
                     text: latex,
@@ -611,7 +690,7 @@ const parseHtml = async (buffer, config) => {
                     metadata: { math: isBlock ? 'block' : 'inline' }
                 };
             }
-            // Admonition: inscript-editor's Admonition node renders
+            // Admonition: attribute-driven editors render
             // <div class="admonition admonition-note" data-type="note">…children…</div>.
             if (tagName === 'div' && (node.attributes?.class || '').split(/\s+/).includes('admonition')) {
                 const admonitionTypeAttr = node.attributes?.['data-type'];
@@ -627,6 +706,29 @@ const parseHtml = async (buffer, config) => {
                     admonitionNode.rawContent = '<div class="admonition">...</div>';
                 return admonitionNode;
             }
+            // 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
+            // a ```mermaid block. Previously this div fell through to generic handling and its
+            // code flattened to paragraph text.
+            if (tagName === 'div' && (node.attributes?.['data-mermaid'] !== undefined || (node.attributes?.class || '').split(/\s+/).includes('mermaid'))) {
+                const code = decodeEntities(node.children.map(c => c.text || '').join('')).trim()
+                    || decodeEntities(node.attributes?.['data-mermaid'] || '');
+                // Only claim this as a mermaid code node when there is actual diagram source.
+                // A bare `class="mermaid"` div with nested elements (a mermaid.js-rendered <svg>,
+                // or a div merely reusing the class for styling) has no direct text and no
+                // data-mermaid; fall through to generic handling so its content is not dropped.
+                if (code) {
+                    const mermaidNode = {
+                        type: 'code',
+                        text: code,
+                        metadata: { language: 'mermaid' }
+                    };
+                    if (config.includeRawContent)
+                        mermaidNode.rawContent = '<div data-mermaid>...</div>';
+                    return mermaidNode;
+                }
+            }
             // Skip structural containers produced by HtmlGenerator to avoid deep AST nesting
             if (tagName === 'div' && (node.attributes?.class === 'container' ||
                 node.attributes?.class === 'spreadsheet-container' ||
@@ -724,6 +826,21 @@ const parseHtml = async (buffer, config) => {
                     metadata: { citationKey }
                 };
             }
+            // Attribute-driven citation shape: a <span> carrying the `citation` class token (among
+            // any others) and a non-empty data-key. Produces the same bare-key text node as the
+            // <cite> form above. An empty/absent data-key falls through to generic span handling,
+            // so the span's visible text still survives.
+            if (tagName === 'span'
+                && (node.attributes?.class || '').split(/\s+/).includes('citation')
+                && node.attributes?.['data-key']) {
+                const citationKey = decodeEntities(node.attributes['data-key']);
+                return {
+                    type: 'text',
+                    text: citationKey,
+                    formatting: Object.keys(newFormatting).length > 0 ? { ...newFormatting } : undefined,
+                    metadata: { citationKey }
+                };
+            }
             if (tagName === 'ul' || tagName === 'ol') {
                 const isNewTopLevel = !listContext;
                 const newListContext = {
@@ -782,7 +899,7 @@ const parseHtml = async (buffer, config) => {
                 return [selfNode, ...nestedLists];
             }
             if (tagName === 'table') {
-                // CustomTable (inscript-editor) renders data-align on the <table> itself.
+                // Attribute-driven editors render data-align on the <table> itself.
                 const tableAlignAttr = node.attributes?.['data-align'];
                 const tableAlign = ['left', 'center', 'right'].includes(tableAlignAttr) ? tableAlignAttr : undefined;
                 const tableNode = {
@@ -831,7 +948,7 @@ const parseHtml = async (buffer, config) => {
             if (tagName === 'img') {
                 const src = node.attributes?.src;
                 const alt = node.attributes?.alt;
-                // CustomImage (inscript-editor) renders data-width/data-align, falling back to
+                // Attribute-driven editors render data-width/data-align, falling back to
                 // parsing the inline style for consumers that only emit the CSS.
                 const imgDecls = parseStyleDeclarations(node.attributes?.style || '');
                 // Exact lookup, so `max-width: 100%` - the standard responsive-image style, and by
@@ -919,6 +1036,23 @@ const parseHtml = async (buffer, config) => {
                         }
                     });
                 }
+                else if (node.attributes?.['data-wikilink'] !== undefined) {
+                    // Attribute-driven wikilink shape: the page lives in data-target, the display
+                    // text is the anchor's own content (or data-alias/data-target when the anchor
+                    // is empty). data-wikilink-page above keeps precedence over this form.
+                    const page = decodeEntities(node.attributes['data-target'] || '');
+                    if (!children.some(c => c.type === 'text')) {
+                        children.push({
+                            type: 'text',
+                            text: decodeEntities(node.attributes['data-alias'] || node.attributes['data-target'] || ''),
+                        });
+                    }
+                    children.forEach(c => {
+                        if (c.type === 'text') {
+                            c.metadata = { ...c.metadata, link: page, linkType: 'internal', wikilink: true };
+                        }
+                    });
+                }
                 else if (href) {
                     const linkType = href.startsWith('#') ? 'internal' : 'external';
                     children.forEach(c => {
@@ -936,6 +1070,17 @@ const parseHtml = async (buffer, config) => {
                 }
                 return brNode;
             }
+            if (tagName === 'hr') {
+                // A horizontal rule is a thematic break. This library tags an office page break
+                // as <hr class="page-break"> on emission, so that variant round-trips back to a
+                // page break; every other <hr> is thematic. Previously <hr> was dropped entirely.
+                const isPageBreak = (node.attributes?.class || '').split(/\s+/).includes('page-break');
+                const hrNode = { type: 'break', metadata: { breakType: isPageBreak ? 'page' : 'thematic' } };
+                if (config.includeRawContent) {
+                    hrNode.rawContent = '<hr/>';
+                }
+                return hrNode;
+            }
             if (tagName === 'pre') {
                 const codeNode = node.children.find(c => c.tagName === 'code');
                 let language;
@@ -945,10 +1090,18 @@ const parseHtml = async (buffer, config) => {
                     const langMatch = classAttr.split(' ').find((c) => c.startsWith('language-'));
                     if (langMatch)
                         language = langMatch.replace('language-', '');
-                    codeText = codeNode.children.map(c => c.text || '').join('');
+                    // Decode entities: the code body is stored raw, so `&lt;`/`&gt;`/`&amp;` (e.g. a
+                    // mermaid `-->` arrow, or `a < b` in a snippet) must be turned back into text.
+                    codeText = decodeEntities(codeNode.children.map(c => c.text || '').join(''));
                 }
                 else {
-                    codeText = node.children.map(c => c.text || '').join('');
+                    codeText = decodeEntities(node.children.map(c => c.text || '').join(''));
+                }
+                // A `mermaid` class token (on the <pre> or its <code>) names the language when no
+                // explicit language-* class is present - some producers emit <pre class="mermaid">.
+                if (!language && ((node.attributes?.class || '').split(/\s+/).includes('mermaid') ||
+                    (codeNode?.attributes?.class || '').split(/\s+/).includes('mermaid'))) {
+                    language = 'mermaid';
                 }
                 const preNode = {
                     type: 'code',
@@ -1027,6 +1180,21 @@ const parseHtml = async (buffer, config) => {
             }
         }
     }
+    // Orphan footnote definitions: a `<section data-footnotes>` entry that no `<sup
+    // data-footnote-ref>` consumed would otherwise be dropped (it is skipped in the body walk and
+    // only materialised via a reference). Recover them as trailing `unreferenced` note nodes, the
+    // same shape MarkdownParser produces, so md -> html -> md preserves the definition instead of
+    // turning it into junk text with a dead back-link.
+    for (const [key, definition] of footnoteDefinitions) {
+        if (referencedFootnoteKeys.has(key))
+            continue;
+        content.push({
+            type: 'note',
+            text: (definition || []).map(d => d.text || '').join(''),
+            children: definition || [],
+            metadata: { noteType: 'footnote', noteId: key, unreferenced: true },
+        });
+    }
     const toTextSync = () => content.map(n => {
         const getText = (node) => {
             if (node.type === 'text' || node.type === 'code')

package/dist/parsers/MarkdownParser.js

@@ -3,6 +3,7 @@ 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");
+const sanitize_js_1 = require("../utils/sanitize.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.
@@ -61,7 +62,12 @@ const parseMarkdown = async (buffer, config) => {
     const metadata = {};
     const attachments = [];
     // Parse YAML Front Matter
-    if (textStr.startsWith('---\n')) {
+    if (/^---\n---[ \t]*(?:\n|$)/.test(textStr)) {
+        // Empty frontmatter block: strip it so `---\n---` isn't misread as a setext `## ---`
+        // heading (empty metadata used to emit exactly this shape, and other producers do too).
+        textStr = textStr.replace(/^---\n---[ \t]*(?:\n|$)/, '');
+    }
+    else if (textStr.startsWith('---\n')) {
         const endIdx = textStr.indexOf('\n---\n', 4);
         if (endIdx !== -1) {
             const frontMatter = textStr.substring(4, endIdx);
@@ -74,9 +80,15 @@ const parseMarkdown = async (buffer, config) => {
                 if (match) {
                     const key = match[1].trim();
                     const rawVal = match[2].trim();
-                    const val = rawVal.replace(/^"(.*)"$/, '$1');
+                    // A quoted scalar is explicitly a string in YAML: strip the quotes but never
+                    // coerce it, so `version: "123"` / `flag: "true"` keep their string-ness across
+                    // a save/reload cycle instead of silently degrading to a number/boolean on the
+                    // next parse (which the generator would then re-emit unquoted, losing the type
+                    // permanently). Only bare, unquoted scalars coerce.
+                    const isQuoted = /^"(.*)"$/.test(rawVal) || /^'(.*)'$/.test(rawVal);
+                    const val = rawVal.replace(/^"(.*)"$/, '$1').replace(/^'(.*)'$/, '$1');
                     let parsedVal = val;
-                    if (rawVal.startsWith('[') && rawVal.endsWith(']')) {
+                    if (!isQuoted && 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.
@@ -89,6 +101,8 @@ const parseMarkdown = async (buffer, config) => {
                             parsedVal = inner === '' ? [] : splitFlowArrayItems(inner).map(item => item.replace(/^['"](.*)['"]$/, '$1'));
                         }
                     }
+                    else if (isQuoted)
+                        parsedVal = val;
                     else if (val === 'true')
                         parsedVal = true;
                     else if (val === 'false')
@@ -167,11 +181,32 @@ const parseMarkdown = async (buffer, config) => {
     });
     // 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).
+    // they're referenced - inline parsing below needs the full map upfront. The first line
+    // may be followed by continuation lines indented one level (4 spaces or a tab), which are
+    // dedented and joined onto the definition (Pandoc/GFM). A 4-space-indented block right after
+    // a definition is therefore read as its continuation rather than as a standalone code block.
+    // Supported (lossless) shape: contiguous continuation - the indented lines follow the
+    // definition with no blank line between them. Known limitation (6.E.1): a continuation
+    // separated from the definition by a BLANK line is not folded in - the regex below stops at
+    // the blank line, and the indented block after it re-parses as a fenced/indented code block on
+    // save. Multi-paragraph footnotes should therefore use the contiguous form.
     const footnoteDefinitions = new Map();
-    textStr = textStr.replace(/^\[\^([^\]]+)\]:[ \t]*(.*)$/gm, (_match, id, definition) => {
-        footnoteDefinitions.set(id, definition.trim());
+    // Every id a `[^id]` reference consumes, so definitions that are never referenced can be
+    // detected at the end and preserved rather than silently dropped (see the orphan sweep below).
+    const referencedFootnoteIds = new Set();
+    // One reused note node per referenced id. Repeated `[^id]` references are a single shared
+    // footnote in Markdown, so they must not each materialise a full copy of the body - the
+    // generators would otherwise renumber them to [^1]/[^2] and duplicate the definition. Office
+    // notes reach the generators as distinct objects even when they share a numeric id, so those
+    // stay separate; only genuinely shared Markdown references collapse.
+    const footnoteNodesById = new Map();
+    textStr = textStr.replace(/^\[\^([^\]]+)\]:[ \t]*(.*(?:\n(?: {4}|\t).*)*)$/gm, (_match, id, definition) => {
+        const dedented = String(definition)
+            .split('\n')
+            .map((line, i) => i === 0 ? line : line.replace(/^(?: {4}|\t)/, ''))
+            .join('\n')
+            .trim();
+        footnoteDefinitions.set(id, dedented);
         return '';
     });
     // Extract Markdown Extra abbreviation definitions (`*[HTML]: Hypertext Markup Language`)
@@ -279,7 +314,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>|\[\^(?<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>.+?)~~|(?<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) {
@@ -320,16 +355,50 @@ 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 };
+                // Anchor each property to a declaration boundary so `color` doesn't match inside
+                // `background-color`.
+                const prop = (name) => {
+                    const m = style.match(new RegExp(`(?:^|;)\\s*${name}\\s*:\\s*([^;]+)`, 'i'));
+                    return m ? m[1].trim() : undefined;
+                };
+                const color = prop('color');
+                if (color)
+                    styled.color = color;
+                const background = prop('background-color');
+                if (background)
+                    styled.backgroundColor = background;
+                const size = prop('font-size');
+                if (size)
+                    styled.size = size;
+                nodes.push(...parseInline(g.spanContent, styled));
+            }
             else if (g.footnoteId !== undefined) { // Footnote reference
                 const noteId = g.footnoteId;
-                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 }
-                };
+                referencedFootnoteIds.add(noteId);
+                // Reuse the same note object across every reference to this id (see the map's
+                // declaration): the first reference builds the body, the rest share it, so the
+                // generators assign one key and emit one definition.
+                let noteNode = footnoteNodesById.get(noteId);
+                if (!noteNode) {
+                    const definition = footnoteDefinitions.get(noteId);
+                    const noteChildren = definition !== undefined ? parseInline(definition) : [];
+                    noteNode = {
+                        type: 'note',
+                        text: noteChildren.map(c => c.text || '').join(''),
+                        children: noteChildren,
+                        metadata: { noteType: 'footnote', noteId }
+                    };
+                    footnoteNodesById.set(noteId, noteNode);
+                }
                 // 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) {
@@ -609,6 +678,36 @@ const parseMarkdown = async (buffer, config) => {
             });
             continue;
         }
+        // Generic iframe fallback: MarkdownGenerator's 'embed' case emits a single-line
+        // <iframe src="…"></iframe> for a preserved iframe when fallbackToHtml is on. Recognise
+        // it only when the caller opted into iframe preservation, so default parsing is unchanged.
+        const iframeMatch = block.match(/^<iframe\s+([^>]*?)\/?>(?:\s*<\/iframe>)?$/i);
+        if (iframeMatch) {
+            const attrsStr = iframeMatch[1];
+            // The emitted <iframe> HTML-escapes its attribute values (sanitizeUrl -> escapeHtml), so
+            // decode them back; otherwise the src double-escapes (`&amp;` -> `&amp;amp;`) and its
+            // query string is corrupted a little more on every save/reload cycle. `&amp;` is decoded
+            // last so a genuinely double-escaped value only unwinds one level per parse.
+            const decodeAttr = (s) => (s || '')
+                .replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&quot;/g, '"')
+                .replace(/&#39;/g, '\'').replace(/&amp;/g, '&');
+            const src = decodeAttr(attrsStr.match(/\bsrc="([^"]*)"/i)?.[1]);
+            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,
+                    metadata: {
+                        embedType: 'iframe',
+                        url: src,
+                        width: width !== undefined ? decodeAttr(width) : undefined,
+                        height: height !== undefined ? decodeAttr(height) : undefined
+                    }
+                });
+                continue;
+            }
+        }
         // Code Block
         const codeMatch = block.match(/^__CODE_BLOCK_(\d+)__$/);
         if (codeMatch) {
@@ -918,9 +1017,10 @@ const parseMarkdown = async (buffer, config) => {
                 continue;
             }
         }
-        // Hr
+        // Hr - a thematic break (horizontal rule), not a page break, so it survives a save as
+        // `---` rather than collapsing to a bare newline.
         if (block.match(/^---+$|^\*\*\*+$|^___+$/)) {
-            content.push({ type: 'break', metadata: { breakType: 'page' } });
+            content.push({ type: 'break', metadata: { breakType: 'thematic' } });
             continue;
         }
         // Paragraph
@@ -956,6 +1056,23 @@ const parseMarkdown = async (buffer, config) => {
         content.length = 0;
         content.push(...merged);
     }
+    // Orphan footnote definitions (defined but never referenced) would otherwise vanish entirely -
+    // a user who deletes a `[^x]` reference but keeps its `[^x]: ...` definition loses the
+    // definition on the next save. Preserve them as trailing note nodes, marked `unreferenced` so
+    // the generators route them into their footnotes section (not inline) and emit no citation
+    // marker or dangling back-link. Both generators still emit the definition (md: a `[^x]:` line;
+    // html: a `div[data-footnote-id]` inside `section[data-footnotes]`, which re-parses on import).
+    for (const [id, definition] of footnoteDefinitions) {
+        if (referencedFootnoteIds.has(id))
+            continue;
+        const noteChildren = parseInline(definition);
+        content.push({
+            type: 'note',
+            text: noteChildren.map(c => c.text || '').join(''),
+            children: noteChildren,
+            metadata: { noteType: 'footnote', noteId: id, unreferenced: true },
+        });
+    }
     const toTextSync = () => content.map(n => {
         const getText = (node) => {
             if (node.type === 'text' || node.type === 'code')

package/dist/parsers/WordParser.js

@@ -458,23 +458,13 @@ const parseWord = async (buffer, config) => {
                 }
             }
         }
-        // Extract paragraph-level run properties
-        let paragraphRunFormatting = { ...styleProps.formatting };
-        if (pPr) {
-            const pPrRPr = (0, xmlUtils_js_1.getFirstElementByTagName)(pPr, "w:rPr");
-            if (pPrRPr) {
-                const pPrFormatting = extractFormattingFromXml(pPrRPr);
-                for (const key in pPrFormatting) {
-                    const value = pPrFormatting[key];
-                    if (value === false) {
-                        delete paragraphRunFormatting[key];
-                    }
-                    else if (value !== undefined) {
-                        paragraphRunFormatting[key] = value;
-                    }
-                }
-            }
-        }
+        // Runs inherit their base formatting from the style chain: the paragraph style (seeded
+        // here, and re-applied via the run-style path below), then any character style, then the
+        // run's own properties. The paragraph-mark run properties (`<w:pPr><w:rPr>`) format only
+        // the paragraph mark glyph itself per OOXML ISO 29500 §17.3.1.29, so they are deliberately
+        // NOT folded into the run base - doing so bled the paragraph mark's bold/italic/color/etc.
+        // onto every run in the paragraph (issue #109).
+        const paragraphRunFormatting = { ...styleProps.formatting };
         // Extract text and children
         let text = '';
         const children = [];