officeparser 7.2.3 → 7.4.0

package/dist/parsers/HtmlParser.js

@@ -1,11 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseHtml = void 0;
+const types_js_1 = require("../types.js");
 const astUtils_js_1 = require("../utils/astUtils.js");
 const errorUtils_js_1 = require("../utils/errorUtils.js");
+const sanitize_js_1 = require("../utils/sanitize.js");
+/**
+ * Maximum element nesting depth accepted from an HTML/XHTML source before the parser gives up
+ * with a typed error rather than letting the recursion overflow the call stack. See the guard in
+ * `parseNode` for why this value and not a larger one.
+ */
+const MAX_HTML_NESTING_DEPTH = 256;
 const parseAttributes = (attrString) => {
     const attrs = {};
-    const regex = /([a-zA-Z0-9\-:]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
+    // Attribute names follow the HTML5 rule - any character except whitespace and
+    // " ' > / = - rather than a hand-picked allowlist. The previous class
+    // ([a-zA-Z0-9\-:]) silently split a legal name on any character outside it, so
+    // `data_foo="x"` produced TWO attributes: `data` (empty) and an invented
+    // `foo="x"` that was never in the source. Harmless while nothing read unknown
+    // attributes; not harmless once they can be replayed into generated output.
+    const regex = /([^\s"'>/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
     let match;
     while ((match = regex.exec(attrString)) !== null) {
         const name = match[1].toLowerCase();
@@ -14,6 +28,101 @@ const parseAttributes = (attrString) => {
     }
     return attrs;
 };
+/**
+ * Splits an inline `style` attribute into a property -> value map.
+ *
+ * Replaces substring matching (`styleAttr.includes('font-weight: bold')`) and unanchored regexes
+ * (`/color:\s*([^;]+)/`), which were wrong in both directions:
+ *   - false positives: `color:` matched inside `background-color:`, so
+ *     `"background-color: red; color: blue"` yielded color=red - the *wrong* value, not merely a
+ *     spurious one - and `width:` matched inside `max-width:`, so the ubiquitous responsive-image
+ *     style `max-width: 100%` was read as an explicit width.
+ *   - false negatives: `font-weight:bold` without a space, `font-weight: 700`, and `bolder` were
+ *     all missed, as was `line-through` inside `text-decoration: underline line-through`.
+ *
+ * Splitting is quote- and paren-aware so a semicolon inside `url(data:image/png;base64,...)` or a
+ * quoted font stack doesn't shatter the declaration. `!important` is stripped from values, since
+ * substring matching used to tolerate it and exact comparison otherwise would not - dropping it
+ * would be a silent regression rather than the intended fix.
+ */
+const parseStyleDeclarations = (styleAttr) => {
+    const decls = new Map();
+    if (!styleAttr)
+        return decls;
+    let depth = 0;
+    let quote = null;
+    let current = '';
+    const chunks = [];
+    for (const ch of styleAttr) {
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+        }
+        else if (ch === '"' || ch === '\'') {
+            quote = ch;
+        }
+        else if (ch === '(') {
+            depth++;
+        }
+        else if (ch === ')') {
+            if (depth > 0)
+                depth--;
+        }
+        else if (ch === ';' && depth === 0) {
+            chunks.push(current);
+            current = '';
+            continue;
+        }
+        current += ch;
+    }
+    chunks.push(current);
+    for (const chunk of chunks) {
+        const idx = chunk.indexOf(':');
+        if (idx === -1)
+            continue;
+        const prop = chunk.slice(0, idx).trim().toLowerCase();
+        if (!prop)
+            continue;
+        const value = chunk.slice(idx + 1).trim().replace(/\s*!\s*important\s*$/i, '').trim();
+        if (value)
+            decls.set(prop, value);
+    }
+    return decls;
+};
+/**
+ * Reads a declaration, also accepting the `-webkit-`/`-moz-`/`-ms-`/`-o-` prefixed spelling so a
+ * vendor-prefixed property keeps matching (substring matching used to catch those by accident).
+ */
+const getDeclaration = (decls, prop) => decls.get(prop)
+    ?? decls.get(`-webkit-${prop}`)
+    ?? decls.get(`-moz-${prop}`)
+    ?? decls.get(`-ms-${prop}`)
+    ?? decls.get(`-o-${prop}`);
+/**
+ * Returns the first family from a `font-family` stack, respecting quotes so a quoted family name
+ * containing a comma (`'Fira, A', serif`) isn't split through the middle of its own name.
+ */
+const firstFontFamily = (fontFamily) => {
+    let quote = null;
+    let first = '';
+    for (const ch of fontFamily) {
+        if (quote) {
+            if (ch === quote) {
+                quote = null;
+                continue;
+            }
+        }
+        else if (ch === '"' || ch === '\'') {
+            quote = ch;
+            continue;
+        }
+        else if (ch === ',') {
+            break;
+        }
+        first += ch;
+    }
+    return first.trim();
+};
 const parseHtmlTree = (html) => {
     const root = { type: 'element', tagName: 'root', children: [], attributes: {} };
     let current = root;
@@ -36,14 +145,16 @@ const parseHtmlTree = (html) => {
             cursor = commentEnd !== -1 ? commentEnd + 3 : html.length;
             continue;
         }
-        const tagEndMatch = html.substring(tagStart).match(/>/);
-        if (!tagEndMatch) {
+        // 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);
+        if (tagEndIdx === -1) {
             const text = html.substring(tagStart);
             current.children.push({ type: 'text', text, children: [], parent: current });
             break;
         }
-        const tagContent = html.substring(tagStart + 1, tagStart + tagEndMatch.index);
-        cursor = tagStart + tagEndMatch.index + 1;
+        const tagContent = html.substring(tagStart + 1, tagEndIdx);
+        cursor = tagEndIdx + 1;
         const isClosing = tagContent.startsWith('/');
         const isSelfClosing = tagContent.endsWith('/');
         const tagCore = tagContent.replace(/^\/|\/$/g, '').trim();
@@ -77,16 +188,20 @@ const parseHtmlTree = (html) => {
             if (!isSelfClosing && !voidElements.has(tagName)) {
                 current = node;
                 if (tagName === 'script' || tagName === 'style') {
-                    const closeTag = `</${tagName}>`;
-                    const closeIdx = html.toLowerCase().indexOf(closeTag, cursor);
-                    if (closeIdx !== -1) {
+                    // Case-insensitive search from `cursor` via a sticky-ish regex, instead of
+                    // lower-casing the whole document on every <script>/<style> (was O(n^2)).
+                    // tagName is validated to /^[a-z0-9-]+$/ above, so it's safe to interpolate.
+                    const closeRe = new RegExp(`</${tagName}>`, 'gi');
+                    closeRe.lastIndex = cursor;
+                    const closeMatch = closeRe.exec(html);
+                    if (closeMatch) {
                         node.children.push({
                             type: 'text',
-                            text: html.substring(cursor, closeIdx),
+                            text: html.substring(cursor, closeMatch.index),
                             children: [],
                             parent: node
                         });
-                        cursor = closeIdx + closeTag.length;
+                        cursor = closeMatch.index + closeMatch[0].length;
                         current = node.parent;
                     }
                 }
@@ -183,7 +298,82 @@ const parseHtml = async (buffer, config) => {
     }
     const content = [];
     let htmlListIdCounter = 1;
-    const parseNode = (node, currentFormatting = {}, listContext) => {
+    // Finds the checked state from a nested <input type="checkbox"> (GFM task-list items
+    // nest it inside a <label>, so it isn't a direct child of the <li>).
+    const findNestedCheckboxChecked = (n) => {
+        if (n.tagName === 'input' && (n.attributes?.type || '').toLowerCase() === 'checkbox') {
+            return 'checked' in (n.attributes || {});
+        }
+        for (const child of n.children) {
+            const found = findNestedCheckboxChecked(child);
+            if (found !== undefined)
+                return found;
+        }
+        return undefined;
+    };
+    // Populated from a <section data-footnotes> block (found and parsed before the main
+    // 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();
+    // --- 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
+    // on the way out, because an AST can be built programmatically rather than parsed.
+    const preserveAttributes = config.htmlParserConfig?.preserveAttributes === true;
+    // `style` is already consumed wholesale into TextFormatting/metadata above, and `id` is
+    // consumed into anchorIds and re-emitted by the generator - carrying either would duplicate
+    // an attribute the generator composes itself. `class` is deliberately NOT excluded: the
+    // generator's class attribute is built purely from style-mapping and never from a parsed
+    // `class`, so without this a plain `<p class="lead">` loses "lead" entirely. The generator
+    // merges it into that attribute rather than emitting a second one.
+    const GENERATOR_OWNED_ATTRS = new Set(['id', 'style']);
+    /**
+     * Captures the attributes of `node` that `consumed` didn't claim.
+     * Returns undefined when nothing survives, so the field stays absent rather than `{}`.
+     */
+    const collectHtmlAttributes = (node, consumed) => {
+        if (!preserveAttributes || !node.attributes)
+            return undefined;
+        const consumedSet = new Set(consumed.map(c => c.toLowerCase()));
+        const bag = {};
+        for (const [rawKey, value] of Object.entries(node.attributes)) {
+            const key = rawKey.toLowerCase();
+            if (consumedSet.has(key) || GENERATOR_OWNED_ATTRS.has(key))
+                continue;
+            // Event handlers are never carried, at any layer, with no opt-in.
+            if (/^on/i.test(key))
+                continue;
+            // srcdoc holds a whole HTML document; it cannot be safely escaped into an attribute.
+            if (key === 'srcdoc')
+                continue;
+            // Reject anything that isn't a plain attribute name outright - a key containing a
+            // quote or '=' is the shape an attribute-injection payload takes.
+            if (!(0, sanitize_js_1.isSafeHtmlAttributeName)(key))
+                continue;
+            bag[key] = value;
+        }
+        return Object.keys(bag).length > 0 ? bag : undefined;
+    };
+    const parseNode = (node, currentFormatting = {}, listContext, depth = 0) => {
+        // Guard against a maliciously deep element tree (e.g. tens of thousands of nested
+        // <div>) recursing until the call stack overflows.
+        //
+        // The previous limit of 1000 could never fire: measured overflow is around 800 and
+        // varies run to run (796/862/796 on three identical runs), so the RangeError always
+        // arrived first and the typed error this guard exists to produce never did. Failure was
+        // still graceful - it surfaces as a wrapped Error, not a crash - which is why this was a
+        // dead guard rather than a denial of service.
+        //
+        // 256 is chosen to hold across engines rather than tuned to one. It is far below the
+        // lowest overflow observed here and leaves room for a smaller frame budget on older V8
+        // (the supported floor is Node 18), while sitting orders of magnitude above real
+        // content: the bundled HTML and EPUB fixtures reach an AST depth of 8.
+        // Per node, alongside the depth guard: the two together are what make a hostile
+        // document both bounded and cancellable rather than only bounded.
+        (0, errorUtils_js_1.checkAbortSignal)(config.abortSignal);
+        if (depth > MAX_HTML_NESTING_DEPTH) {
+            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, ' ')
@@ -229,29 +419,43 @@ const parseHtml = async (buffer, config) => {
             const styleAttr = node.attributes?.style || '';
             const alignAttr = node.attributes?.align || '';
             if (styleAttr || alignAttr) {
-                if (styleAttr.includes('font-weight: bold'))
-                    newFormatting.bold = true;
-                if (styleAttr.includes('font-style: italic'))
+                const decls = parseStyleDeclarations(styleAttr);
+                // `bold`, `bolder`, and any weight >= 600 are all bold; the old substring check
+                // only ever saw the literal "font-weight: bold".
+                const weight = getDeclaration(decls, 'font-weight');
+                if (weight) {
+                    const numericWeight = parseInt(weight, 10);
+                    if (weight === 'bold' || weight === 'bolder' || (!isNaN(numericWeight) && numericWeight >= 600)) {
+                        newFormatting.bold = true;
+                    }
+                }
+                if (getDeclaration(decls, 'font-style') === 'italic')
                     newFormatting.italic = true;
-                if (styleAttr.includes('text-decoration: underline'))
-                    newFormatting.underline = true;
-                if (styleAttr.includes('text-decoration: line-through'))
-                    newFormatting.strikethrough = true;
-                const colorMatch = styleAttr.match(/color:\s*([^;]+)/);
-                if (colorMatch)
-                    newFormatting.color = colorMatch[1].trim();
-                const bgMatch = styleAttr.match(/background-color:\s*([^;]+)/);
-                if (bgMatch)
-                    newFormatting.backgroundColor = bgMatch[1].trim();
-                const sizeMatch = styleAttr.match(/font-size:\s*([^;]+)/);
-                if (sizeMatch)
-                    newFormatting.size = sizeMatch[1].trim();
-                const fontMatch = styleAttr.match(/font-family:\s*([^;]+)/);
-                if (fontMatch)
-                    newFormatting.font = fontMatch[1].trim().split(',')[0].replace(/['"]/g, '');
-                const alignmentMatch = styleAttr.match(/text-align:\s*(left|center|right|justify)/);
-                if (alignmentMatch) {
-                    newFormatting.alignment = alignmentMatch[1].toLowerCase();
+                // text-decoration is a shorthand that can carry several keywords at once, so
+                // "underline line-through" has to set both flags rather than only the first.
+                const decoration = getDeclaration(decls, 'text-decoration') ?? getDeclaration(decls, 'text-decoration-line');
+                if (decoration) {
+                    const parts = decoration.split(/\s+/);
+                    if (parts.includes('underline'))
+                        newFormatting.underline = true;
+                    if (parts.includes('line-through'))
+                        newFormatting.strikethrough = true;
+                }
+                const color = decls.get('color');
+                if (color)
+                    newFormatting.color = color;
+                const background = getDeclaration(decls, 'background-color');
+                if (background)
+                    newFormatting.backgroundColor = background;
+                const size = getDeclaration(decls, 'font-size');
+                if (size)
+                    newFormatting.size = size;
+                const fontFamily = getDeclaration(decls, 'font-family');
+                if (fontFamily)
+                    newFormatting.font = firstFontFamily(fontFamily);
+                const textAlign = getDeclaration(decls, 'text-align')?.toLowerCase();
+                if (textAlign && ['left', 'center', 'right', 'justify'].includes(textAlign)) {
+                    newFormatting.alignment = textAlign;
                 }
                 else if (alignAttr) {
                     const align = alignAttr.toLowerCase();
@@ -264,7 +468,29 @@ const parseHtml = async (buffer, config) => {
             const parseChildren = (n, fmt, lCtx) => {
                 const kids = [];
                 for (const child of n.children) {
-                    const parsed = parseNode(child, fmt, lCtx);
+                    // Footnote/endnote reference: attach as .notes on the preceding node
+                    // 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'];
+                        const definition = footnoteDefinitions.get(key);
+                        const noteNode = {
+                            type: 'note',
+                            text: (definition || []).map(d => d.text || '').join(''),
+                            children: definition || [],
+                            metadata: { noteType: 'footnote', noteId: key }
+                        };
+                        if (kids.length > 0) {
+                            const target = kids[kids.length - 1];
+                            if (!target.notes)
+                                target.notes = [];
+                            target.notes.push(noteNode);
+                        }
+                        else {
+                            kids.push({ type: 'text', text: '', notes: [noteNode] });
+                        }
+                        continue;
+                    }
+                    const parsed = parseNode(child, fmt, lCtx, depth + 1);
                     if (parsed) {
                         if (Array.isArray(parsed))
                             kids.push(...parsed);
@@ -274,6 +500,94 @@ const parseHtml = async (buffer, config) => {
                 }
                 return kids;
             };
+            // YouTube embeds: inscript-editor's Youtube node renders
+            // <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.
+            if (tagName === 'div' && node.attributes?.['data-youtube-video'] !== undefined) {
+                const videoId = node.attributes['data-youtube-video'] || '';
+                const width = node.attributes?.['data-width'];
+                const embedAlignAttr = node.attributes?.['data-align'];
+                const embedAlign = ['left', 'center', 'right'].includes(embedAlignAttr) ? embedAlignAttr : undefined;
+                const embedUrl = videoId ? `https://www.youtube.com/watch?v=${videoId}` : undefined;
+                const embedNode = {
+                    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,
+                        align: embedAlign
+                    }
+                };
+                if (config.includeRawContent)
+                    embedNode.rawContent = '<div data-youtube-video>...</div>';
+                return embedNode;
+            }
+            if (tagName === 'iframe') {
+                const src = node.attributes?.src || '';
+                const ytMatch = /youtube(?:-nocookie)?\.com/.test(src) ? src.match(/(?:embed\/|v=)([^&?/\s]+)/) : null;
+                if (ytMatch) {
+                    const embedUrl = `https://www.youtube.com/watch?v=${ytMatch[1]}`;
+                    const embedNode = {
+                        type: 'embed',
+                        text: embedUrl,
+                        metadata: { embedType: 'youtube', videoId: ytMatch[1], url: embedUrl }
+                    };
+                    if (config.includeRawContent)
+                        embedNode.rawContent = '<iframe>...</iframe>';
+                    return embedNode;
+                }
+                return null;
+            }
+            // Footnotes section: its definitions were already extracted up front (see
+            // footnoteDefinitions below), so skip it here wherever it appears in the tree -
+            // it isn't necessarily a direct child of <body> (e.g. it may be nested inside
+            // a non-standalone HtmlGenerator output's wrapping <div>).
+            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.
+            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;
+                return {
+                    type: 'code',
+                    text: latex,
+                    metadata: { math: mathMode }
+                };
+            }
+            // Admonition: inscript-editor's Admonition node renders
+            // <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'];
+                const admonitionType = ['note', 'tip', 'important', 'warning', 'caution'].includes(admonitionTypeAttr)
+                    ? admonitionTypeAttr
+                    : 'note';
+                const admonitionNode = {
+                    type: 'admonition',
+                    metadata: { admonitionType },
+                    children: parseChildren(node, newFormatting, listContext)
+                };
+                if (config.includeRawContent)
+                    admonitionNode.rawContent = '<div class="admonition">...</div>';
+                return admonitionNode;
+            }
             // Skip structural containers produced by HtmlGenerator to avoid deep AST nesting
             if (tagName === 'div' && (node.attributes?.class === 'container' ||
                 node.attributes?.class === 'spreadsheet-container' ||
@@ -296,7 +610,7 @@ const parseHtml = async (buffer, config) => {
             if (tagName === 'p' || tagName === 'div') {
                 const children = parseChildren(node, newFormatting, listContext);
                 // If it's a div and contains block elements, return children directly
-                const hasBlockElements = children.some(c => ['paragraph', 'table', 'heading', 'list', 'image', 'chart', 'code'].includes(c.type));
+                const hasBlockElements = children.some(c => ['paragraph', 'table', 'heading', 'list', 'image', 'chart', 'code', 'embed', 'admonition', 'definitionList'].includes(c.type));
                 if (tagName === 'div' && hasBlockElements) {
                     return children;
                 }
@@ -313,7 +627,8 @@ const parseHtml = async (buffer, config) => {
                 const pNode = {
                     type: 'paragraph',
                     metadata: { alignment: newFormatting.alignment, anchorIds: anchorIds.length > 0 ? anchorIds : undefined },
-                    children: flattenedChildren
+                    children: flattenedChildren,
+                    htmlAttributes: collectHtmlAttributes(node, ['align'])
                 };
                 if (config.includeRawContent) {
                     // Note: Since this is a manual parser without locators, we can't easily get the original source slice.
@@ -326,17 +641,58 @@ const parseHtml = async (buffer, config) => {
                 const hNode = {
                     type: 'heading',
                     metadata: { level, alignment: newFormatting.alignment, anchorIds: anchorIds.length > 0 ? anchorIds : undefined },
-                    children: parseChildren(node, newFormatting, listContext)
+                    children: parseChildren(node, newFormatting, listContext),
+                    htmlAttributes: collectHtmlAttributes(node, ['align'])
                 };
                 return hNode;
             }
+            if (tagName === 'dl') {
+                return {
+                    type: 'definitionList',
+                    children: parseChildren(node, newFormatting, listContext)
+                };
+            }
+            if (tagName === 'dt') {
+                return {
+                    type: 'definitionTerm',
+                    children: parseChildren(node, newFormatting, listContext)
+                };
+            }
+            if (tagName === 'dd') {
+                return {
+                    type: 'definitionDescription',
+                    children: parseChildren(node, newFormatting, listContext)
+                };
+            }
+            if (tagName === 'abbr') {
+                const title = node.attributes?.title;
+                const children = parseChildren(node, newFormatting, listContext);
+                if (title) {
+                    children.forEach(c => {
+                        if (c.type === 'text') {
+                            c.metadata = { ...c.metadata, abbreviationTitle: title };
+                        }
+                    });
+                }
+                return children;
+            }
+            if (tagName === 'cite' && node.attributes?.['data-citation-key'] !== undefined) {
+                const citationKey = node.attributes['data-citation-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 = {
                     listId: isNewTopLevel ? `html-list-${htmlListIdCounter++}` : listContext.listId,
                     type: tagName === 'ol' ? 'ordered' : 'unordered',
                     level: isNewTopLevel ? 0 : listContext.level + 1,
-                    counters: isNewTopLevel ? {} : { ...listContext.counters } // Clone to avoid side effects on parent levels
+                    counters: isNewTopLevel ? {} : { ...listContext.counters }, // Clone to avoid side effects on parent levels
+                    isTask: node.attributes?.['data-type'] === 'taskList'
                 };
                 // Initialize counter for this level
                 if (tagName === 'ol' && node.attributes?.start) {
@@ -362,6 +718,13 @@ const parseHtml = async (buffer, config) => {
                 const children = parseChildren(node, newFormatting, listContext);
                 const nestedLists = children.filter(c => c.type === 'list');
                 const selfChildren = children.filter(c => c.type !== 'list');
+                let isTask;
+                let checked;
+                if (listContext?.isTask) {
+                    isTask = true;
+                    const dataChecked = node.attributes?.['data-checked'];
+                    checked = dataChecked !== undefined ? dataChecked === 'true' : (findNestedCheckboxChecked(node) ?? false);
+                }
                 const selfNode = {
                     type: 'list',
                     text: selfChildren.map(c => c.text || '').join(''),
@@ -371,17 +734,23 @@ const parseHtml = async (buffer, config) => {
                         alignment: newFormatting.alignment || 'left',
                         listId: listContext?.listId || 'html-list-none',
                         itemIndex: (listContext?.counters[listContext.level] ?? 1) - 1,
-                        anchorIds: anchorIds.length > 0 ? anchorIds : undefined
+                        anchorIds: anchorIds.length > 0 ? anchorIds : undefined,
+                        isTask,
+                        checked
                     },
                     children: selfChildren
                 };
                 return [selfNode, ...nestedLists];
             }
             if (tagName === 'table') {
+                // CustomTable (inscript-editor) renders data-align on the <table> itself.
+                const tableAlignAttr = node.attributes?.['data-align'];
+                const tableAlign = ['left', 'center', 'right'].includes(tableAlignAttr) ? tableAlignAttr : undefined;
                 const tableNode = {
                     type: 'table',
-                    metadata: { anchorIds: anchorIds.length > 0 ? anchorIds : undefined },
-                    children: parseChildren(node, newFormatting, listContext)
+                    metadata: { anchorIds: anchorIds.length > 0 ? anchorIds : undefined, align: tableAlign },
+                    children: parseChildren(node, newFormatting, listContext),
+                    htmlAttributes: collectHtmlAttributes(node, ['data-align', 'align'])
                 };
                 if (config.includeRawContent) {
                     tableNode.rawContent = '<table>...</table>';
@@ -391,7 +760,8 @@ const parseHtml = async (buffer, config) => {
             if (tagName === 'tr') {
                 const rowNode = {
                     type: 'row',
-                    children: parseChildren(node, newFormatting, listContext)
+                    children: parseChildren(node, newFormatting, listContext),
+                    htmlAttributes: collectHtmlAttributes(node, [])
                 };
                 if (config.includeRawContent) {
                     rowNode.rawContent = '<tr>...</tr>';
@@ -399,9 +769,20 @@ const parseHtml = async (buffer, config) => {
                 return rowNode;
             }
             if (tagName === 'td' || tagName === 'th') {
+                // Merged cells: mirrors the colspan/rowspan reading already done in
+                // MarkdownParser's inline HTML-table handler.
+                const colSpanAttr = node.attributes?.colspan;
+                const rowSpanAttr = node.attributes?.rowspan;
+                const colSpan = colSpanAttr ? parseInt(colSpanAttr, 10) : undefined;
+                const rowSpan = rowSpanAttr ? parseInt(rowSpanAttr, 10) : undefined;
                 const cellNode = {
                     type: 'cell',
-                    children: parseChildren(node, newFormatting, listContext)
+                    metadata: {
+                        colSpan: colSpan && !isNaN(colSpan) ? colSpan : undefined,
+                        rowSpan: rowSpan && !isNaN(rowSpan) ? rowSpan : undefined
+                    },
+                    children: parseChildren(node, newFormatting, listContext),
+                    htmlAttributes: collectHtmlAttributes(node, ['colspan', 'rowspan', 'align'])
                 };
                 if (config.includeRawContent) {
                     cellNode.rawContent = '<td>...</td>';
@@ -411,6 +792,30 @@ 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
+                // 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
+                // far the most common inline style on an <img> - is no longer read as a declared
+                // width. It constrains the rendered size; it is not an author-specified width.
+                const width = node.attributes?.['data-width'] || getDeclaration(imgDecls, 'width');
+                // Alignment is inferred from which auto margin is present. Comparing the parsed
+                // value rather than substring-matching "margin-left: 0" stops `margin-left: 0.5rem`
+                // from being read as left-aligned, and lets the `margin: 0 auto` centering
+                // shorthand be recognised at all.
+                const marginLeft = getDeclaration(imgDecls, 'margin-left');
+                const marginRight = getDeclaration(imgDecls, 'margin-right');
+                const marginShorthand = getDeclaration(imgDecls, 'margin');
+                const isZero = (v) => v !== undefined && /^0(?:[a-z%]*)$/.test(v);
+                const shorthandParts = marginShorthand ? marginShorthand.split(/\s+/) : [];
+                const shorthandCentres = shorthandParts.length > 1
+                    && shorthandParts[shorthandParts.length - 1] === 'auto'
+                    && shorthandParts[1] === 'auto';
+                const alignAttr = node.attributes?.['data-align']
+                    ?? (shorthandCentres ? 'center'
+                        : (isZero(marginLeft) && !isZero(marginRight) ? 'left'
+                            : (isZero(marginRight) && !isZero(marginLeft) ? 'right' : undefined)));
+                const align = ['left', 'center', 'right'].includes(alignAttr) ? alignAttr : undefined;
                 let imageNode;
                 if (src?.startsWith('data:')) {
                     const match = src.match(/^data:([^;]+);base64,(.*)$/);
@@ -429,7 +834,9 @@ const parseHtml = async (buffer, config) => {
                             type: 'image',
                             metadata: {
                                 attachmentName: name,
-                                altText: alt
+                                altText: alt,
+                                width,
+                                align
                             }
                         };
                     }
@@ -438,7 +845,9 @@ const parseHtml = async (buffer, config) => {
                             type: 'image',
                             metadata: {
                                 url: src,
-                                altText: alt
+                                altText: alt,
+                                width,
+                                align
                             }
                         };
                     }
@@ -449,7 +858,9 @@ const parseHtml = async (buffer, config) => {
                         metadata: {
                             url: src,
                             altText: alt,
-                            anchorIds: anchorIds.length > 0 ? anchorIds : undefined
+                            anchorIds: anchorIds.length > 0 ? anchorIds : undefined,
+                            width,
+                            align
                         }
                     };
                 }
@@ -460,8 +871,16 @@ const parseHtml = async (buffer, config) => {
             }
             if (tagName === 'a') {
                 const href = node.attributes?.href;
+                const wikilinkPage = node.attributes?.['data-wikilink-page'];
                 const children = parseChildren(node, newFormatting, listContext);
-                if (href) {
+                if (wikilinkPage !== undefined) {
+                    children.forEach(c => {
+                        if (c.type === 'text') {
+                            c.metadata = { ...c.metadata, link: wikilinkPage, linkType: 'internal', wikilink: true };
+                        }
+                    });
+                }
+                else if (href) {
                     const linkType = href.startsWith('#') ? 'internal' : 'external';
                     children.forEach(c => {
                         if (c.type === 'text') {
@@ -509,6 +928,42 @@ const parseHtml = async (buffer, config) => {
         }
         return null;
     };
+    // Extract <section data-footnotes> up front so its definitions are available to
+    // <sup data-footnote-ref> references encountered anywhere earlier in the body.
+    const findFootnotesSection = (n) => {
+        if (n.tagName === 'section' && n.attributes?.['data-footnotes'] !== undefined)
+            return n;
+        for (const child of n.children) {
+            const found = findFootnotesSection(child);
+            if (found)
+                return found;
+        }
+        return undefined;
+    };
+    const footnotesSectionNode = findFootnotesSection(body);
+    if (footnotesSectionNode) {
+        for (const item of footnotesSectionNode.children) {
+            if (item.type !== 'element')
+                continue;
+            const key = item.attributes?.['data-footnote-id'];
+            if (!key)
+                continue;
+            // Strip the generated back-reference link ("↩") - it's round-trip plumbing,
+            // not part of the footnote's actual content.
+            const filteredChildren = item.children.filter(c => !(c.tagName === 'a' && (c.attributes?.href || '').startsWith('#footnote-ref-')));
+            const contentNodes = [];
+            for (const child of filteredChildren) {
+                const parsed = parseNode(child);
+                if (parsed) {
+                    if (Array.isArray(parsed))
+                        contentNodes.push(...parsed);
+                    else
+                        contentNodes.push(parsed);
+                }
+            }
+            footnoteDefinitions.set(key, contentNodes);
+        }
+    }
     for (const child of body.children) {
         const parsed = parseNode(child);
         if (parsed) {
@@ -539,8 +994,12 @@ const parseHtml = async (buffer, config) => {
                 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 '';