officeparser 6.1.0 → 7.0.0

package/dist/parsers/RtfParser.js

@@ -42,6 +42,8 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseRtf = exports.SimpleRtfParser = 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 ocrUtils_js_1 = require("../utils/ocrUtils.js");
 /**
@@ -92,6 +94,12 @@ class SimpleRtfParser {
     index = 0;
     /** The RTF content as a Buffer */
     buffer;
+    /** Current code page for character decoding (default is Windows-1252) */
+    codePage = 1252;
+    /** Cached TextDecoders for different code pages */
+    decoders = {};
+    /** Buffer for consecutive text bytes to handle multi-byte encodings and UTF-8 detection */
+    pendingBytes = [];
     /** Total length of the buffer */
     length;
     /**
@@ -110,12 +118,14 @@ class SimpleRtfParser {
             const currentGroup = stack[stack.length - 1];
             if (char === 0x7B) { // '{'
                 this.index++;
+                this.flushPendingText(currentGroup);
                 const newGroup = { type: 'group', content: [] };
                 currentGroup.content.push(newGroup);
                 stack.push(newGroup);
             }
             else if (char === 0x7D) { // '}'
                 this.index++;
+                this.flushPendingText(currentGroup);
                 if (stack.length > 1) {
                     stack.pop();
                 }
@@ -133,6 +143,7 @@ class SimpleRtfParser {
                 this.parseText(currentGroup);
             }
         }
+        this.flushPendingText(root);
         return root;
     }
     parseControl(group) {
@@ -141,55 +152,23 @@ class SimpleRtfParser {
         const char = this.buffer[this.index];
         // Special control symbols
         if (char === 0x7B || char === 0x7D || char === 0x5C) { // \{ \} \\
-            group.content.push({ type: 'text', value: String.fromCharCode(char) });
+            this.pendingBytes.push(char);
             this.index++;
             return;
         }
         if (char === 0x27) { // \'xx (hex)
             this.index++;
             if (this.index + 1 < this.length) {
-                const hex = this.buffer.toString('utf8', this.index, this.index + 2);
+                const hex = String.fromCharCode(this.buffer[this.index], this.buffer[this.index + 1]);
                 const code = parseInt(hex, 16);
                 if (!isNaN(code)) {
-                    // RTF hex escapes represent bytes in the document's code page (usually Windows-1252)
-                    // Characters 0x80-0x9F in Windows-1252 don't map directly to Unicode
-                    // We need to convert them properly
-                    const windows1252ToUnicode = {
-                        0x80: 0x20AC, // €
-                        0x82: 0x201A, // ‚
-                        0x83: 0x0192, // ƒ
-                        0x84: 0x201E, // „
-                        0x85: 0x2026, // …
-                        0x86: 0x2020, // †
-                        0x87: 0x2021, // ‡
-                        0x88: 0x02C6, // ˆ
-                        0x89: 0x2030, // ‰
-                        0x8A: 0x0160, // Š
-                        0x8B: 0x2039, // ‹
-                        0x8C: 0x0152, // Œ
-                        0x8E: 0x017D, // Ž
-                        0x91: 0x2018, // '
-                        0x92: 0x2019, // '
-                        0x93: 0x201C, // "
-                        0x94: 0x201D, // "
-                        0x95: 0x2022, // •
-                        0x96: 0x2013, // –
-                        0x97: 0x2014, // —
-                        0x98: 0x02DC, // ˜
-                        0x99: 0x2122, // ™
-                        0x9A: 0x0161, // š
-                        0x9B: 0x203A, // ›
-                        0x9C: 0x0153, // œ
-                        0x9E: 0x017E, // ž
-                        0x9F: 0x0178 // Ÿ
-                    };
-                    const unicodeCode = windows1252ToUnicode[code] || code;
-                    group.content.push({ type: 'text', value: String.fromCharCode(unicodeCode) });
+                    this.pendingBytes.push(code);
                 }
                 this.index += 2;
             }
             return;
         }
+        this.flushPendingText(group);
         if (char === 0x2A) { // \* (ignorable destination)
             // We treat this as a control word named '*'
             group.content.push({ type: 'control', value: '*' });
@@ -231,7 +210,7 @@ class SimpleRtfParser {
             param = parseInt(paramStr, 10);
         }
         // Space after control word is consumed
-        if (this.index < this.length && this.buffer[this.index] === 0x20) {
+        if (name !== '' && this.index < this.length && this.buffer[this.index] === 0x20) {
             this.index++;
         }
         // Handle \binN
@@ -241,6 +220,22 @@ class SimpleRtfParser {
             // \binN is not added to content as we want to ignore it
             return;
         }
+        // Handle encoding control words
+        if (name === 'ansicpg' && param !== undefined) {
+            this.codePage = param;
+        }
+        else if (name === 'ansi') {
+            this.codePage = 1252;
+        }
+        else if (name === 'mac') {
+            this.codePage = 10000;
+        }
+        else if (name === 'pc') {
+            this.codePage = 437;
+        }
+        else if (name === 'pca') {
+            this.codePage = 850;
+        }
         group.content.push({ type: 'control', value: name, param });
         // If this is the first control word in the group, it might be the destination
         if (group.content.length === 1 && group.type === 'group') {
@@ -252,20 +247,92 @@ class SimpleRtfParser {
         }
     }
     parseText(group) {
-        let text = '';
         while (this.index < this.length) {
             const char = this.buffer[this.index];
+            if (char === undefined)
+                break;
             if (char === 0x7B || char === 0x7D || char === 0x5C || char === 0x0D || char === 0x0A) {
                 break;
             }
-            // Basic ASCII text.
-            text += String.fromCharCode(char);
+            this.pendingBytes.push(char);
             this.index++;
         }
-        if (text.length > 0) {
-            group.content.push({ type: 'text', value: text });
+    }
+    /**
+     * Flushes the pending bytes buffer as a text node to the current group.
+     * @param group The group to append the text node to
+     */
+    flushPendingText(group) {
+        if (this.pendingBytes.length > 0) {
+            group.content.push({ type: 'text', value: this.decodeBytes(this.pendingBytes, this.codePage) });
+            this.pendingBytes = [];
         }
     }
+    /**
+     * Decodes a byte array using a "UTF-8 first" strategy.
+     * If the bytes form valid UTF-8 and contain non-ASCII characters, UTF-8 is preferred.
+     * Otherwise, falls back to the specified code page.
+     * @param bytes The bytes to decode
+     * @param codePage The RTF code page ID
+     * @returns The decoded string
+     */
+    decodeBytes(bytes, codePage) {
+        const uint8 = new Uint8Array(bytes);
+        // Try UTF-8 first if there are any non-ASCII bytes.
+        // Many modern RTF generators (like calibre or web-based tools) dump UTF-8 bytes 
+        // into the RTF even if the header claims a different code page.
+        if (bytes.some(b => b > 127)) {
+            try {
+                // Use fatal: true to ensure we fall back on invalid UTF-8 sequences
+                const utf8Decoder = new TextDecoder('utf-8', { fatal: true });
+                return utf8Decoder.decode(uint8);
+            }
+            catch (e) {
+                // Not valid UTF-8, continue to code page fallback
+            }
+        }
+        // Fallback to specified code page
+        if (!this.decoders[codePage]) {
+            let encoding = `windows-${codePage}`;
+            if (codePage === 10000)
+                encoding = 'macintosh';
+            else if (codePage === 437)
+                encoding = 'ibm437';
+            else if (codePage === 850)
+                encoding = 'ibm850';
+            try {
+                this.decoders[codePage] = new TextDecoder(encoding);
+            }
+            catch (e) {
+                if (codePage !== 1252) {
+                    try {
+                        this.decoders[codePage] = new TextDecoder('windows-1252');
+                    }
+                    catch (e2) {
+                        return String.fromCharCode(...bytes);
+                    }
+                }
+                else {
+                    return String.fromCharCode(...bytes);
+                }
+            }
+        }
+        let result = this.decoders[codePage].decode(uint8);
+        // Safety override for Windows-1252 0x80-0x9F range if TextDecoder behaves like Latin-1.
+        // We replace control characters in the decoded string with their proper 1252 equivalents.
+        if (codePage === 1252 && /[\u0080-\u009F]/.test(result)) {
+            const map = {
+                '\u0080': '€', '\u0082': '‚', '\u0083': 'ƒ', '\u0084': '„', '\u0085': '…',
+                '\u0086': '†', '\u0087': '‡', '\u0088': 'ˆ', '\u0089': '‰', '\u008A': 'Š',
+                '\u008B': '‹', '\u008C': 'Œ', '\u008E': 'Ž', '\u0091': '‘', '\u0092': '’',
+                '\u0093': '“', '\u0094': '”', '\u0095': '•', '\u0096': '–', '\u0097': '—',
+                '\u0098': '˜', '\u0099': '™', '\u009A': 'š', '\u009B': '›', '\u009C': 'œ',
+                '\u009E': 'ž', '\u009F': 'Ÿ'
+            };
+            return result.replace(/[\u0080-\u009F]/g, m => map[m] || m);
+        }
+        return result;
+    }
 }
 exports.SimpleRtfParser = SimpleRtfParser;
 /**
@@ -292,1388 +359,1437 @@ exports.SimpleRtfParser = SimpleRtfParser;
  * @returns The parsed AST.
  */
 const parseRtf = async (buffer, config) => {
-    try {
-        const parser = new SimpleRtfParser(buffer);
-        const doc = parser.parse();
-        // Extract font and color tables
-        const fontTable = extractFontTable(doc);
-        const colorTable = extractColorTable(doc);
-        const content = [];
-        const notes = [];
-        const attachments = [];
-        // State for paragraph construction
-        let currentParagraphText = '';
-        let currentParagraphChildren = [];
-        let currentParagraphRaw = '';
-        // State for text run construction
-        let currentRunText = '';
-        let currentFormatting = {};
-        // Target for content (main body or notes)
-        let currentTarget = content;
-        // Paragraph-level state
-        let paragraphIndent = 0;
-        let paragraphAlignment = 'left';
-        let isListItem = false;
-        let listType;
-        let headingLevel;
-        let currentListId;
-        // Persistent list state for listtext/pntext detection
-        // These persist across paragraphs to allow list items without explicit \ls
-        let lastKnownListId;
-        let lastKnownListType;
-        let tableStack = [];
-        let currentFootnoteId = 0;
-        // ═══════════════════════════════════════════════════════════════════
-        // Note type tracking (footnotes vs endnotes)
-        // ═══════════════════════════════════════════════════════════════════
-        // RTF uses \fet to distinguish note types:
-        // \fet0 = footnotes only (default)
-        // \fet1 = endnotes only
-        // \fet2 = both footnotes and endnotes
-        let fetValue = 0; // Default to footnotes only
-        // Helper to get current table context
-        const getCurrentTable = () => tableStack.length > 0 ? tableStack[tableStack.length - 1] : undefined;
-        // Helper to ensure a table context exists (for top-level tables)
-        const ensureTableContext = () => {
-            if (tableStack.length === 0) {
-                tableStack.push({
-                    rows: [],
-                    currentCells: [],
-                    currentCellContent: [],
-                    rowIndex: 0
-                });
-            }
-        };
-        let inTable = false;
-        let paragraphInTable = false;
-        let tableId = 0;
-        let rowCellProps = [];
-        let currentCellDefinitionProps = { isMergedContinuation: false };
-        let cellContentIndex = 0;
-        // ═══════════════════════════════════════════════════════════════════
-        // List state tracking (Word 97+ uses \ls for list style ID)
-        // ═══════════════════════════════════════════════════════════════════
-        let listIdCounter = 0;
-        const listStyleIdMap = {};
-        // List definition state for parsing \listtable
-        let parsingListTable = false;
-        let parsingListDefinition = false;
-        let currentDefinedListId;
-        let currentDefinedListType;
-        const listTypeMap = {};
-        // List override state for parsing \listoverridetable
-        let parsingListOverrideTable = false;
-        let currentListOverrideListId;
-        let currentListOverrideLs;
-        const listOverrideMap = {}; // Maps \ls ID to \listid
-        // List counters for itemIndex tracking
-        // Map: listId -> indentation level -> count
-        const listCounters = {};
-        // ═══════════════════════════════════════════════════════════════════
-        // Hyperlink state (RTF uses \field{\*\fldinst HYPERLINK "url"})
-        // ═══════════════════════════════════════════════════════════════════
-        let currentLinkUrl;
-        // Helper to check if formatting changed
-        const formattingChanged = (a, b) => {
-            return a.bold !== b.bold ||
-                a.italic !== b.italic ||
-                a.underline !== b.underline ||
-                a.strikethrough !== b.strikethrough ||
-                a.size !== b.size ||
-                a.font !== b.font ||
-                a.color !== b.color ||
-                a.backgroundColor !== b.backgroundColor ||
-                a.subscript !== b.subscript ||
-                a.superscript !== b.superscript;
-        };
-        // Helper to flush current run to paragraph children
-        const flushRun = () => {
-            if (currentRunText) {
-                const node = {
-                    type: 'text',
-                    text: currentRunText,
-                    formatting: { ...currentFormatting }
+    const parser = new SimpleRtfParser(buffer);
+    const doc = parser.parse();
+    // Extract font and color tables
+    const fontTable = extractFontTable(doc);
+    const colorTable = extractColorTable(doc);
+    const content = [];
+    const notes = [];
+    const attachments = [];
+    // State for paragraph construction
+    let currentParagraphTextChunks = [];
+    let currentParagraphChildren = [];
+    let currentParagraphRawChunks = [];
+    // State for text run construction
+    let currentRunTextChunks = [];
+    let currentFormatting = {};
+    // Target for content (main body or notes)
+    let currentTarget = content;
+    // Paragraph-level state
+    let paragraphIndent = 0;
+    let paragraphAlignment = 'left';
+    let isListItem = false;
+    let listType;
+    let headingLevel;
+    let currentListId;
+    let currentAnchorIds = [];
+    // Persistent list state for listtext/pntext detection
+    // These persist across paragraphs to allow list items without explicit \ls
+    let lastKnownListId;
+    let lastKnownListType;
+    let tableStack = [];
+    let currentFootnoteId = 0;
+    // ═══════════════════════════════════════════════════════════════════
+    // Note type tracking (footnotes vs endnotes)
+    // ═══════════════════════════════════════════════════════════════════
+    // RTF uses \fet to distinguish note types:
+    // \fet0 = footnotes only (default)
+    // \fet1 = endnotes only
+    // \fet2 = both footnotes and endnotes
+    let fetValue = 0; // Default to footnotes only
+    // Helper to get current table context
+    const getCurrentTable = () => tableStack.length > 0 ? tableStack[tableStack.length - 1] : undefined;
+    // Helper to ensure a table context exists (for top-level tables)
+    const ensureTableContext = () => {
+        if (tableStack.length === 0) {
+            tableStack.push({
+                rows: [],
+                currentCells: [],
+                currentCellContent: [],
+                rowIndex: 0
+            });
+        }
+    };
+    let inTable = false;
+    let paragraphInTable = false;
+    let tableId = 0;
+    let rowCellProps = [];
+    let currentCellDefinitionProps = { isMergedContinuation: false };
+    let cellContentIndex = 0;
+    // ═══════════════════════════════════════════════════════════════════
+    // List state tracking (Word 97+ uses \ls for list style ID)
+    // ═══════════════════════════════════════════════════════════════════
+    let listIdCounter = 0;
+    const listStyleIdMap = {};
+    // List definition state for parsing \listtable
+    let parsingListTable = false;
+    let parsingListDefinition = false;
+    let currentDefinedListId;
+    let currentDefinedListType;
+    const listTypeMap = {};
+    // List override state for parsing \listoverridetable
+    let parsingListOverrideTable = false;
+    let currentListOverrideListId;
+    let currentListOverrideLs;
+    const listOverrideMap = {}; // Maps \ls ID to \listid
+    // List counters for itemIndex tracking
+    // Map: listId -> indentation level -> count
+    const listCounters = {};
+    // ═══════════════════════════════════════════════════════════════════
+    // Hyperlink state (RTF uses \field{\*\fldinst HYPERLINK "url"})
+    // ═══════════════════════════════════════════════════════════════════
+    let currentLinkUrl;
+    // Helper to check if formatting changed
+    const formattingChanged = (a, b) => {
+        return a.bold !== b.bold ||
+            a.italic !== b.italic ||
+            a.underline !== b.underline ||
+            a.strikethrough !== b.strikethrough ||
+            a.size !== b.size ||
+            a.font !== b.font ||
+            a.color !== b.color ||
+            a.backgroundColor !== b.backgroundColor ||
+            a.subscript !== b.subscript ||
+            a.superscript !== b.superscript;
+    };
+    // Helper to flush current run to paragraph children
+    const flushRun = () => {
+        if (currentRunTextChunks.length > 0) {
+            const currentRunText = currentRunTextChunks.join('');
+            const node = {
+                type: 'text',
+                text: currentRunText,
+                formatting: { ...currentFormatting }
+            };
+            // Use TextMetadata.link for hyperlinks
+            if (currentLinkUrl) {
+                node.metadata = {
+                    link: currentLinkUrl,
+                    linkType: classifyLinkType(currentLinkUrl)
                 };
-                // Use TextMetadata.link for hyperlinks
-                if (currentLinkUrl) {
-                    node.metadata = {
-                        link: currentLinkUrl,
-                        linkType: classifyLinkType(currentLinkUrl)
-                    };
+            }
+            currentParagraphChildren.push(node);
+            currentParagraphTextChunks.push(currentRunText);
+            currentRunTextChunks = [];
+        }
+    };
+    let isFlushingTable = false;
+    // Helper to flush current paragraph
+    const flushParagraph = () => {
+        flushRun(); // Ensure last run is added
+        // Check if we need to end the table
+        // If we were in a table, but this paragraph is NOT marked as in-table, 
+        // and we have content, then the table has ended.
+        const hasContent = currentParagraphTextChunks.length > 0 || currentParagraphChildren.length > 0;
+        if (inTable && !paragraphInTable && !isFlushingTable && hasContent) {
+            // CRITICAL: Save current paragraph content before flushing table
+            // because flushTable() -> flushRow() -> flushCell() -> flushParagraph()
+            // would otherwise process this content during the table flush
+            const savedParagraphTextChunks = [...currentParagraphTextChunks];
+            const savedParagraphChildren = [...currentParagraphChildren];
+            const savedParagraphRawChunks = [...currentParagraphRawChunks];
+            // Clear buffers so nested flushParagraph() doesn't process them
+            currentParagraphTextChunks = [];
+            currentParagraphChildren = [];
+            currentParagraphRawChunks = [];
+            flushTable();
+            // Restore the saved content for processing after the table
+            currentParagraphTextChunks = savedParagraphTextChunks;
+            currentParagraphChildren = savedParagraphChildren;
+            currentParagraphRawChunks = savedParagraphRawChunks;
+        }
+        if (hasContent) {
+            const currentParagraphText = currentParagraphTextChunks.join('');
+            let nodeType = 'paragraph';
+            let metadata = undefined;
+            // Heuristic heading detection if no explicit \s style was found
+            if (headingLevel === undefined && currentParagraphChildren.length > 0) {
+                // Check if the first child is bold and larger than default (12pt)
+                const firstChild = currentParagraphChildren[0];
+                if (firstChild.type === 'text' && firstChild.formatting?.bold) {
+                    const size = parseInt(firstChild.formatting.size || '12');
+                    if (size >= 14 && currentParagraphText.length < 300) {
+                        if (size >= 22)
+                            headingLevel = 1;
+                        else if (size >= 18)
+                            headingLevel = 2;
+                        else if (size >= 16)
+                            headingLevel = 3;
+                        else
+                            headingLevel = 4;
+                    }
                 }
-                currentParagraphChildren.push(node);
-                currentParagraphText += currentRunText;
-                currentRunText = '';
             }
-        };
-        let isFlushingTable = false;
-        // Helper to flush current paragraph
-        const flushParagraph = () => {
-            flushRun(); // Ensure last run is added
-            // Check if we need to end the table
-            // If we were in a table, but this paragraph is NOT marked as in-table, 
-            // and we have content, then the table has ended.
-            const hasContent = currentParagraphText || currentParagraphChildren.length > 0;
-            if (inTable && !paragraphInTable && !isFlushingTable && hasContent) {
-                // CRITICAL: Save current paragraph content before flushing table
-                // because flushTable() -> flushRow() -> flushCell() -> flushParagraph()
-                // would otherwise process this content during the table flush
-                const savedParagraphText = currentParagraphText;
-                const savedParagraphChildren = [...currentParagraphChildren];
-                const savedParagraphRaw = currentParagraphRaw;
-                // Clear buffers so nested flushParagraph() doesn't process them
-                currentParagraphText = '';
-                currentParagraphChildren = [];
-                currentParagraphRaw = '';
-                flushTable();
-                // Restore the saved content for processing after the table
-                currentParagraphText = savedParagraphText;
-                currentParagraphChildren = savedParagraphChildren;
-                currentParagraphRaw = savedParagraphRaw;
-            }
-            if (hasContent) {
-                let nodeType = 'paragraph';
-                let metadata = undefined;
-                if (headingLevel !== undefined && headingLevel > 0) {
-                    nodeType = 'heading';
-                    metadata = { level: headingLevel };
-                    // Reset list context when we encounter a heading
-                    lastKnownListId = undefined;
-                    lastKnownListType = undefined;
-                }
-                else if (isListItem) {
-                    nodeType = 'list';
-                    // Use lastKnownListId if currentListId is not set
-                    // (happens when list item is detected via listtext/pntext)
-                    const effectiveListId = currentListId || lastKnownListId;
-                    const effectiveListType = listType || lastKnownListType || 'unordered';
-                    // Calculate itemIndex
-                    let itemIndex = 0;
-                    if (effectiveListId) {
-                        if (!listCounters[effectiveListId]) {
-                            listCounters[effectiveListId] = {};
-                        }
-                        if (listCounters[effectiveListId][paragraphIndent] === undefined) {
-                            listCounters[effectiveListId][paragraphIndent] = 0;
-                        }
-                        else {
-                            listCounters[effectiveListId][paragraphIndent]++;
+            // Heuristic list detection if no explicit list control words were found
+            if (!isListItem && paragraphIndent > 300) { // RTF indents are in twips (1440 = 1 inch)
+                const trimmed = currentParagraphText.trim();
+                // Check for bullet characters or digits followed by period
+                if (/^[\u2022\u00b7\-\u25cf\u25cb]/.test(trimmed) || /^\d+[.\)]/.test(trimmed)) {
+                    isListItem = true;
+                    listType = /^\d+[.\)]/.test(trimmed) ? 'ordered' : 'unordered';
+                }
+            }
+            if (headingLevel !== undefined && headingLevel > 0) {
+                nodeType = 'heading';
+                metadata = { level: headingLevel };
+                // Reset list context when we encounter a heading
+                lastKnownListId = undefined;
+                lastKnownListType = undefined;
+            }
+            else if (isListItem) {
+                nodeType = 'list';
+                // Use lastKnownListId if currentListId is not set
+                // (happens when list item is detected via listtext/pntext)
+                const effectiveListId = currentListId || lastKnownListId;
+                const effectiveListType = listType || lastKnownListType || 'unordered';
+                // Calculate itemIndex
+                let itemIndex = 0;
+                if (effectiveListId) {
+                    if (!listCounters[effectiveListId]) {
+                        listCounters[effectiveListId] = {};
+                    }
+                    // Reset all sub-level counters when returning to a shallower level
+                    // This ensures that if we go from level 2 to level 0 and back to level 2,
+                    // the new level 2 sequence starts from 0.
+                    const levels = Object.keys(listCounters[effectiveListId]).map(l => parseInt(l));
+                    for (const level of levels) {
+                        if (level > paragraphIndent) {
+                            delete listCounters[effectiveListId][level];
                         }
-                        itemIndex = listCounters[effectiveListId][paragraphIndent];
                     }
-                    metadata = {
-                        listType: effectiveListType,
-                        indentation: paragraphIndent,
-                        listId: effectiveListId || '',
-                        itemIndex: itemIndex,
-                        alignment: paragraphAlignment,
-                    };
-                    // Save for next listtext detection
-                    if (effectiveListId) {
-                        lastKnownListId = effectiveListId;
+                    if (listCounters[effectiveListId][paragraphIndent] === undefined) {
+                        listCounters[effectiveListId][paragraphIndent] = 0;
                     }
-                    if (effectiveListType) {
-                        lastKnownListType = effectiveListType;
+                    else {
+                        listCounters[effectiveListId][paragraphIndent]++;
                     }
-                }
-                const node = {
-                    type: nodeType,
-                    text: currentParagraphText,
-                    children: currentParagraphChildren,
-                    formatting: undefined,
-                    metadata: metadata
+                    itemIndex = listCounters[effectiveListId][paragraphIndent];
+                }
+                metadata = {
+                    listType: effectiveListType,
+                    indentation: paragraphIndent,
+                    listId: effectiveListId || '',
+                    itemIndex: itemIndex,
+                    alignment: paragraphAlignment,
                 };
-                if (config.includeRawContent && currentParagraphRaw) {
-                    node.rawContent = currentParagraphRaw;
+                // Save for next listtext detection
+                if (effectiveListId) {
+                    lastKnownListId = effectiveListId;
                 }
-                // If we're building a table, add to current cell 
-                // but ONLY if this paragraph was actually marked as in-table
-                if (inTable && paragraphInTable) {
-                    ensureTableContext();
-                    getCurrentTable().currentCellContent.push(node);
-                }
-                else {
-                    currentTarget.push(node);
+                if (effectiveListType) {
+                    lastKnownListType = effectiveListType;
                 }
-                currentParagraphText = '';
-                currentParagraphChildren = [];
-                currentParagraphRaw = '';
-                // Reset paragraph-level state
-                paragraphIndent = 0;
-                isListItem = false;
-                listType = undefined;
-                headingLevel = undefined;
-                currentListId = undefined;
             }
-        };
-        // Helper to flush current cell
-        const flushCell = (tableCtx) => {
-            flushParagraph();
-            const ctx = tableCtx || getCurrentTable();
-            if (!ctx)
-                return undefined;
-            // Always return a cell node, even if empty, to preserve table structure (grid)
-            const cellNode = {
-                type: 'cell',
-                text: ctx.currentCellContent.map(c => c.text).join('\n'),
-                children: [...ctx.currentCellContent],
+            const node = {
+                type: nodeType,
+                text: currentParagraphText,
+                children: currentParagraphChildren,
+                formatting: undefined,
                 metadata: {
-                    row: ctx.rowIndex,
-                    col: ctx.currentCells.length
+                    ...metadata,
+                    anchorIds: currentAnchorIds.length > 0 ? [...currentAnchorIds] : undefined
                 }
             };
-            ctx.currentCellContent = [];
-            return cellNode;
-        };
-        // Helper to flush current row - creates a row node from collected cells
-        const flushRow = (tableCtx) => {
-            const ctx = tableCtx || getCurrentTable();
-            if (!ctx)
-                return;
-            const cell = flushCell(ctx);
-            // Only add cell if it has content (prevents phantom empty cells during cleanup)
-            if (cell && (cell.children && cell.children.length > 0 || cell.text)) {
-                ctx.currentCells.push(cell);
-            }
-            if (ctx.currentCells.length > 0) {
-                const rowNode = {
-                    type: 'row',
-                    text: ctx.currentCells.map(c => c.text).filter(t => t !== '').join(config.newlineDelimiter ?? '\n'),
-                    children: [...ctx.currentCells]
-                };
-                ctx.rows.push(rowNode);
-                ctx.currentCells = [];
-                ctx.rowIndex++;
+            if (config.includeRawContent && currentParagraphRawChunks.length > 0) {
+                node.rawContent = currentParagraphRawChunks.join('');
             }
-        };
-        // Helper to flush table
-        const flushTable = () => {
-            if (isFlushingTable)
-                return;
-            isFlushingTable = true;
-            const ctx = getCurrentTable();
-            if (!ctx) {
-                isFlushingTable = false;
-                return;
+            // If we're building a table, add to current cell 
+            // but ONLY if this paragraph was actually marked as in-table
+            if (inTable && paragraphInTable) {
+                ensureTableContext();
+                getCurrentTable().currentCellContent.push(node);
             }
-            flushRow(ctx);
-            if (ctx.rows.length > 0) {
-                tableId++;
-                const tableNode = {
-                    type: 'table',
-                    text: ctx.rows.map(r => r.text).join('\n'), // Aggregate text from rows
-                    children: [...ctx.rows]
-                };
-                // If we have a parent table, add this table to the parent's current cell
-                if (tableStack.length > 1) {
-                    const parentCtx = tableStack[tableStack.length - 2];
-                    parentCtx.currentCellContent.push(tableNode);
-                }
-                else {
-                    currentTarget.push(tableNode);
-                }
+            else {
+                currentTarget.push(node);
             }
-            // Pop the table from stack
-            tableStack.pop();
-            // If stack is empty, we are out of table mode
-            if (tableStack.length === 0) {
-                inTable = false;
-                paragraphInTable = false;
+            currentParagraphTextChunks = [];
+            currentParagraphChildren = [];
+            currentParagraphRawChunks = [];
+            // Reset paragraph-level state that should NOT persist
+            // Note: list properties (\ls, \ilvl, \li) and alignment (\ql, etc.) 
+            // persist in RTF until \pard or a new value is set.
+            currentAnchorIds = []; // Reset anchors
+        }
+    };
+    // Helper to flush current cell
+    const flushCell = (tableCtx) => {
+        flushParagraph();
+        const ctx = tableCtx || getCurrentTable();
+        if (!ctx)
+            return undefined;
+        // Always return a cell node, even if empty, to preserve table structure (grid)
+        const cellNode = {
+            type: 'cell',
+            text: ctx.currentCellContent.map(c => c.text).join('\n'),
+            children: [...ctx.currentCellContent],
+            metadata: {
+                row: ctx.rowIndex,
+                col: ctx.currentCells.length
             }
-            isFlushingTable = false;
         };
-        // Extract hyperlink URL from field instruction group
-        // Recursively searches for HYPERLINK "url" pattern in nested groups
-        const extractHyperlinkUrl = (group) => {
-            let url;
-            // Helper to recursively find hyperlink URL
-            const findUrl = (node) => {
-                if (node.type === 'text') {
-                    // Check for HYPERLINK "url" pattern
-                    const text = node.value;
-                    const match = text.match(/HYPERLINK\s+"([^"]+)"/i);
-                    if (match) {
-                        return match[1];
-                    }
-                    // Also check for URL after HYPERLINK on same or separate text node
-                    const urlOnlyMatch = text.match(/"(https?:\/\/[^"]+|mailto:[^"]+|#[^"]+)"/);
-                    if (urlOnlyMatch) {
-                        return urlOnlyMatch[1];
-                    }
+        ctx.currentCellContent = [];
+        return cellNode;
+    };
+    // Helper to flush current row - creates a row node from collected cells
+    const flushRow = (tableCtx) => {
+        const ctx = tableCtx || getCurrentTable();
+        if (!ctx)
+            return;
+        const cell = flushCell(ctx);
+        // Only add cell if it has content (prevents phantom empty cells during cleanup)
+        if (cell && (cell.children && cell.children.length > 0 || cell.text)) {
+            ctx.currentCells.push(cell);
+        }
+        if (ctx.currentCells.length > 0) {
+            const rowNode = {
+                type: 'row',
+                text: ctx.currentCells.map(c => c.text).filter(t => t !== '').join(config.newlineDelimiter),
+                children: [...ctx.currentCells]
+            };
+            ctx.rows.push(rowNode);
+            ctx.currentCells = [];
+            ctx.rowIndex++;
+        }
+    };
+    // Helper to flush table
+    const flushTable = () => {
+        if (isFlushingTable)
+            return;
+        isFlushingTable = true;
+        const ctx = getCurrentTable();
+        if (!ctx) {
+            isFlushingTable = false;
+            return;
+        }
+        flushRow(ctx);
+        if (ctx.rows.length > 0) {
+            tableId++;
+            const tableNode = {
+                type: 'table',
+                text: ctx.rows.map(r => r.text).join('\n'), // Aggregate text from rows
+                children: [...ctx.rows]
+            };
+            // If we have a parent table, add this table to the parent's current cell
+            if (tableStack.length > 1) {
+                const parentCtx = tableStack[tableStack.length - 2];
+                parentCtx.currentCellContent.push(tableNode);
+            }
+            else {
+                currentTarget.push(tableNode);
+            }
+        }
+        // Pop the table from stack
+        tableStack.pop();
+        // If stack is empty, we are out of table mode
+        if (tableStack.length === 0) {
+            inTable = false;
+            paragraphInTable = false;
+        }
+        isFlushingTable = false;
+    };
+    // Extract hyperlink URL from field instruction group
+    // Recursively searches for HYPERLINK "url" pattern in nested groups
+    const extractHyperlinkUrl = (group) => {
+        let url;
+        // Helper to recursively find hyperlink URL
+        const findUrl = (node) => {
+            if (node.type === 'text') {
+                // Check for HYPERLINK "url" pattern
+                const text = node.value;
+                const match = text.match(/HYPERLINK\s+"([^"]+)"/i);
+                if (match) {
+                    return match[1];
+                }
+                // Also check for URL after HYPERLINK on same or separate text node
+                const urlOnlyMatch = text.match(/"(https?:\/\/[^"]+|mailto:[^"]+|#[^"]+)"/);
+                if (urlOnlyMatch) {
+                    return urlOnlyMatch[1];
                 }
-                else if (node.type === 'group') {
-                    // Check if this is a fldinst group (contains field instruction)
-                    let foundHyperlink = false;
-                    let foundUrl;
-                    for (const child of node.content) {
-                        if (child.type === 'text') {
-                            const text = child.value.toUpperCase();
-                            if (text.includes('HYPERLINK')) {
-                                foundHyperlink = true;
-                            }
-                            // Look for quoted URL
-                            const urlMatch = child.value.match(/"([^"]+)"/);
-                            if (urlMatch && foundHyperlink) {
-                                foundUrl = urlMatch[1];
-                            }
+            }
+            else if (node.type === 'group') {
+                // Check if this is a fldinst group (contains field instruction)
+                let foundHyperlink = false;
+                let foundUrl;
+                let isLocal = false;
+                for (const child of node.content) {
+                    if (child.type === 'text') {
+                        const text = child.value.toUpperCase();
+                        if (text.includes('HYPERLINK')) {
+                            foundHyperlink = true;
                         }
-                        else if (child.type === 'group') {
-                            const nestedUrl = findUrl(child);
-                            if (nestedUrl) {
-                                foundUrl = nestedUrl;
-                            }
+                        if (text.includes('\\L')) {
+                            isLocal = true;
+                        }
+                        // Look for quoted URL/Anchor
+                        const urlMatch = child.value.match(/"([^"]+)"/);
+                        if (urlMatch && foundHyperlink) {
+                            foundUrl = urlMatch[1];
+                        }
+                    }
+                    else if (child.type === 'group') {
+                        const nestedUrl = findUrl(child);
+                        if (nestedUrl) {
+                            foundUrl = nestedUrl;
                         }
                     }
-                    if (foundUrl)
-                        return foundUrl;
                 }
-                return undefined;
-            };
-            // Search the field group for fldinst
-            for (const child of group.content) {
-                if (child.type === 'group') {
-                    const foundUrl = findUrl(child);
-                    if (foundUrl)
-                        return foundUrl;
+                if (foundUrl) {
+                    if (isLocal && !foundUrl.startsWith('#')) {
+                        return '#' + foundUrl;
+                    }
+                    return foundUrl;
                 }
             }
-            return url;
+            return undefined;
         };
-        /**
-         * Determines whether a hyperlink URL is internal or external.
-         * Internal = bookmark references (no scheme or starts with "#").
-         * External = any scheme like http, https, mailto, ftp, file, etc.
-         */
-        const classifyLinkType = (url) => {
-            // Trim whitespace
-            const clean = url.trim();
-            // Internal pattern 1: starts with "#"
-            if (clean.startsWith('#')) {
-                return 'internal';
-            }
-            // Internal pattern 2: no scheme at all (pure bookmark)
-            // Detect schemes by checking "something:" prefix
-            if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(clean)) {
-                return 'internal';
-            }
-            // Everything else is external
-            return 'external';
-        };
-        // Helper to extract text content from a group (for list marker detection)
-        // Recursively collects all text content from a group
-        const extractTextFromGroup = (group) => {
-            let text = '';
-            const collectText = (node) => {
-                if (node.type === 'text') {
-                    text += node.value;
-                }
-                else if (node.type === 'group') {
-                    for (const child of node.content) {
-                        collectText(child);
-                    }
+        // Search the field group for fldinst
+        for (const child of group.content) {
+            if (child.type === 'group') {
+                const foundUrl = findUrl(child);
+                if (foundUrl)
+                    return foundUrl;
+            }
+        }
+        return url;
+    };
+    /**
+     * Determines whether a hyperlink URL is internal or external.
+     * Internal = bookmark references (no scheme or starts with "#").
+     * External = any scheme like http, https, mailto, ftp, file, etc.
+     */
+    const classifyLinkType = (url) => {
+        // Trim whitespace
+        const clean = url.trim();
+        // Internal pattern 1: starts with "#"
+        if (clean.startsWith('#')) {
+            return 'internal';
+        }
+        // Internal pattern 2: no scheme at all (pure bookmark)
+        // Detect schemes by checking "something:" prefix
+        if (!/^[a-zA-Z][a-zA-Z0-9+.-]*:/.test(clean)) {
+            return 'internal';
+        }
+        // Everything else is external
+        return 'external';
+    };
+    // Helper to extract text content from a group (for list marker detection)
+    // Recursively collects all text content from a group
+    const extractTextFromGroup = (group) => {
+        let text = '';
+        const collectText = (node) => {
+            if (node.type === 'text') {
+                text += node.value;
+            }
+            else if (node.type === 'group') {
+                for (const child of node.content) {
+                    collectText(child);
                 }
-            };
-            for (const child of group.content) {
-                collectText(child);
             }
-            return text;
         };
-        /**
-         * Extracts an image attachment from an RTF \pict group.
-         * Uses lookup tables for clean and safe handling of all formats.
-         *
-         * @param pictGroup The RtfGroup node that represents a \pict group.
-         * @returns An OfficeAttachment or undefined when unsupported or invalid.
-         */
-        const extractPictAttachment = (pictGroup) => {
-            /** Internal format detected from the RTF pict group */
-            let imageFormat;
-            /** Hexadecimal string extracted from the pict binary section */
-            let hexData = '';
-            // -------------------------------------------------------------
-            // Walk through pict group content to detect the blip type and gather hex data
-            // -------------------------------------------------------------
-            for (const child of pictGroup.content) {
-                // If the node is a control word, we try to resolve it from lookup map
-                if (child.type === 'control') {
-                    // Lookup directly instead of if/else
-                    const mapped = RTF_BLIP_MAP[child.value];
-                    if (mapped) {
-                        imageFormat = mapped;
-                    }
-                }
-                else if (child.type === 'text') {
-                    // Append only valid hex characters
-                    hexData += child.value.replace(/[^0-9a-fA-F]/g, '');
-                }
-                else if (child.type === 'group') {
-                    // Skip nested structures like picprop or blipuid
+        for (const child of group.content) {
+            collectText(child);
+        }
+        return text;
+    };
+    /**
+     * Extracts an image attachment from an RTF \pict group.
+     * Uses lookup tables for clean and safe handling of all formats.
+     *
+     * @param pictGroup The RtfGroup node that represents a \pict group.
+     * @returns An OfficeAttachment or undefined when unsupported or invalid.
+     */
+    const extractPictAttachment = (pictGroup) => {
+        /** Internal format detected from the RTF pict group */
+        let imageFormat;
+        /** Hexadecimal string chunks extracted from the pict binary section */
+        const hexDataChunks = [];
+        // -------------------------------------------------------------
+        // Walk through pict group content to detect the blip type and gather hex data
+        // -------------------------------------------------------------
+        for (const child of pictGroup.content) {
+            // If the node is a control word, we try to resolve it from lookup map
+            if (child.type === 'control') {
+                // Lookup directly instead of if/else
+                const mapped = RTF_BLIP_MAP[child.value];
+                if (mapped) {
+                    imageFormat = mapped;
                 }
             }
-            // Missing or unknown format → stop
-            if (!imageFormat || hexData.length === 0) {
-                return undefined;
+            else if (child.type === 'text') {
+                // Append only valid hex characters
+                hexDataChunks.push(child.value.replace(/[^0-9a-fA-F]/g, ''));
             }
-            // Map internal format to MIME
-            const mimeType = IMAGE_MIME_MAP[imageFormat];
-            if (!mimeType) {
-                return undefined;
+            else if (child.type === 'group') {
+                // Skip nested structures like picprop or blipuid
             }
-            // -------------------------------------------------------------
-            // Convert hex → binary and construct the attachment object
-            // -------------------------------------------------------------
-            try {
-                // Convert hex into a raw buffer
-                const buffer = Buffer.from(hexData, 'hex');
-                // Derive file extension directly from format
-                const extension = imageFormat;
-                // Generate a stable incremental filename
-                const name = `image_${attachments.length + 1}.${extension}`;
-                // Build and return final attachment
-                return {
-                    type: 'image',
-                    mimeType: mimeType,
-                    data: buffer.toString('base64'),
-                    name: name,
-                    extension: extension
-                };
+        }
+        // Missing or unknown format → stop
+        const hexData = hexDataChunks.join('');
+        if (!imageFormat || hexData.length === 0) {
+            return undefined;
+        }
+        // Map internal format to MIME
+        const mimeType = IMAGE_MIME_MAP[imageFormat];
+        if (!mimeType) {
+            return undefined;
+        }
+        // -------------------------------------------------------------
+        // Convert hex → binary and construct the attachment object
+        // -------------------------------------------------------------
+        try {
+            // Convert hex into a raw buffer
+            const buffer = Buffer.from(hexData, 'hex');
+            // Derive file extension directly from format
+            const extension = imageFormat;
+            // Generate a stable incremental filename
+            const name = `image_${attachments.length + 1}.${extension}`;
+            // Build and return final attachment
+            return {
+                type: 'image',
+                mimeType: mimeType,
+                data: buffer.toString('base64'),
+                name: name,
+                extension: extension
+            };
+        }
+        catch {
+            // If conversion fails, ignore this image
+            return undefined;
+        }
+    };
+    // Helper to serialize RTF control word
+    const serializeRtfControl = (node) => {
+        // Symbol control words (non-alpha)
+        if (!/^[a-zA-Z]/.test(node.value)) {
+            return `\\${node.value}`;
+        }
+        // Alpha control words
+        let res = `\\${node.value}`;
+        if (node.param !== undefined) {
+            res += node.param;
+        }
+        // Add space delimiter for safety
+        res += ' ';
+        return res;
+    };
+    // Helper to extract text from a group (for bookmark names, etc.)
+    const extractGroupText = (group) => {
+        let text = '';
+        for (const item of group.content) {
+            if (item.type === 'text') {
+                text += item.value;
             }
-            catch {
-                // If conversion fails, ignore this image
-                return undefined;
+            else if (item.type === 'group') {
+                text += extractGroupText(item);
             }
-        };
-        // Helper to serialize RTF control word
-        const serializeRtfControl = (node) => {
-            // Symbol control words (non-alpha)
-            if (!/^[a-zA-Z]/.test(node.value)) {
-                return `\\${node.value}`;
-            }
-            // Alpha control words
-            let res = `\\${node.value}`;
-            if (node.param !== undefined) {
-                res += node.param;
-            }
-            // Add space delimiter for safety
-            res += ' ';
-            return res;
-        };
-        // Helper to serialize RTF text
-        const serializeRtfText = (node) => {
-            // Escape special characters: \, {, }
-            return node.value.replace(/([\\{}])/g, '\\$1');
-        };
-        // Recursive function to traverse the RTF tree
-        const traverse = (node, formatting, depth = 0) => {
-            if (node.type === 'group') {
-                const ignoreList = [
-                    'fonttbl', 'colortbl', 'stylesheet', 'info', 'macpict',
-                    'pmmetafile', 'wmetafile', 'dibitmap', 'bitmap', 'object',
-                    'nextGenerator', 'header', 'footer', 'nonshppict', 'xml', 'private',
-                    'upnp', 'ud', 'filetbl', 'operator', 'author', 'creatim', 'revtim', 'printim', 'comment',
-                    'fldinst', 'listtext', 'pntext' // Ignore list marker text (handled separately)
-                ];
-                let isIgnored = false;
-                let isFootnote = false;
-                let isHyperlinkField = false;
-                let isPict = false;
-                // Add group start to raw content
-                // Note: We don't add ignored groups to rawContent to keep it clean
-                // But we might want to if we want full fidelity. 
-                // For now, let's include everything in rawContent except truly skipped stuff?
-                // The user asked for "raw content which is probably the rtf group".
-                // If we skip 'fonttbl', it's fine as it's not part of the content.
-                // But 'listtext' IS part of the content structure even if we parse it separately.
-                // Let's stick to the plan: if ignored, we might skip it in rawContent too, 
-                // OR we include it. 
-                // If I include it, `currentParagraphRaw` might get huge with font tables if they were inside the paragraph (unlikely).
-                // Usually font tables are at document root.
-                // `traverse` is called on `doc`.
-                // `currentParagraphRaw` is reset on `flushParagraph`.
-                // So if we are at root level, `currentParagraphRaw` accumulates everything until the first paragraph ends.
-                // This might include the header/fonttbl if they are before the first \par.
-                // That seems correct for "raw content" of the first node?
-                // Actually, `fonttbl` is usually before any text.
-                // If we include it, the first paragraph node will contain the entire font table in its rawContent.
-                // That might be annoying.
-                // Let's ONLY add to `currentParagraphRaw` if NOT ignored.
-                if (node.destination) {
-                    if (node.destination === 'footnote') {
-                        isFootnote = true;
-                    }
-                    else if (node.destination === 'field') {
-                        // Check if this is a hyperlink field
-                        const url = extractHyperlinkUrl(node);
-                        if (url) {
-                            // Flush any pending text before starting the link context
-                            // This prevents previous text from inheriting the link
-                            flushRun();
-                            isHyperlinkField = true;
-                            currentLinkUrl = url;
-                        }
-                    }
-                    else if (node.destination === 'listtable') {
-                        // We want to parse list definitions
-                        parsingListTable = true;
+        }
+        return text.trim();
+    };
+    // Helper to serialize RTF text
+    const serializeRtfText = (node) => {
+        // Escape special characters: \, {, }
+        return node.value.replace(/([\\{}])/g, '\\$1');
+    };
+    // Recursive function to traverse the RTF tree
+    const traverse = (node, formatting, depth = 0) => {
+        if (node.type === 'group') {
+            const ignoreList = [
+                'fonttbl', 'colortbl', 'stylesheet', 'info', 'macpict',
+                'pmmetafile', 'wmetafile', 'dibitmap', 'bitmap', 'object',
+                'nextGenerator', 'header', 'footer', 'nonshppict', 'xml', 'private',
+                'upnp', 'ud', 'filetbl', 'operator', 'author', 'creatim', 'revtim', 'printim', 'comment',
+                'fldinst', 'listtext', 'pntext' // Ignore list marker text (handled separately)
+            ];
+            let isIgnored = false;
+            let isFootnote = false;
+            let isHyperlinkField = false;
+            let isPict = false;
+            // Add group start to raw content
+            // Note: We don't add ignored groups to rawContent to keep it clean
+            // But we might want to if we want full fidelity. 
+            // For now, let's include everything in rawContent except truly skipped stuff?
+            // The user asked for "raw content which is probably the rtf group".
+            // If we skip 'fonttbl', it's fine as it's not part of the content.
+            // But 'listtext' IS part of the content structure even if we parse it separately.
+            // Let's stick to the plan: if ignored, we might skip it in rawContent too, 
+            // OR we include it. 
+            // If I include it, `currentParagraphRaw` might get huge with font tables if they were inside the paragraph (unlikely).
+            // Usually font tables are at document root.
+            // `traverse` is called on `doc`.
+            // `currentParagraphRaw` is reset on `flushParagraph`.
+            // So if we are at root level, `currentParagraphRaw` accumulates everything until the first paragraph ends.
+            // This might include the header/fonttbl if they are before the first \par.
+            // That seems correct for "raw content" of the first node?
+            // Actually, `fonttbl` is usually before any text.
+            // If we include it, the first paragraph node will contain the entire font table in its rawContent.
+            // That might be annoying.
+            // Let's ONLY add to `currentParagraphRaw` if NOT ignored.
+            if (node.destination) {
+                if (node.destination === 'footnote') {
+                    isFootnote = true;
+                }
+                else if (node.destination === 'field') {
+                    // Check if this is a hyperlink field
+                    const url = extractHyperlinkUrl(node);
+                    if (url) {
+                        // Flush any pending text before starting the link context
+                        // This prevents previous text from inheriting the link
+                        flushRun();
+                        isHyperlinkField = true;
+                        currentLinkUrl = url;
                     }
-                    else if (parsingListTable && node.destination === 'list') {
-                        parsingListDefinition = true;
-                        currentDefinedListId = undefined;
-                        currentDefinedListType = undefined;
+                }
+                else if (node.destination === 'listtable') {
+                    // We want to parse list definitions
+                    parsingListTable = true;
+                }
+                else if (parsingListTable && node.destination === 'list') {
+                    parsingListDefinition = true;
+                    currentDefinedListId = undefined;
+                    currentDefinedListType = undefined;
+                }
+                else if (node.destination === 'listoverridetable') {
+                    parsingListOverrideTable = true;
+                }
+                else if (parsingListOverrideTable && node.destination === 'listoverride') {
+                    // Reset per override group
+                    currentListOverrideListId = undefined;
+                    currentListOverrideLs = undefined;
+                }
+                else if (node.destination === 'pict') {
+                    // Handle picture extraction
+                    if (config.extractAttachments) {
+                        isPict = true;
                     }
-                    else if (node.destination === 'listoverridetable') {
-                        parsingListOverrideTable = true;
+                    else {
+                        isIgnored = true;
                     }
-                    else if (parsingListOverrideTable && node.destination === 'listoverride') {
-                        // Reset per override group
-                        currentListOverrideListId = undefined;
-                        currentListOverrideLs = undefined;
+                }
+                else if (ignoreList.includes(node.destination)) {
+                    isIgnored = true;
+                }
+                else if (node.content.length > 0 && node.content[0].type === 'control' && node.content[0].value === '*') {
+                    // Ignorable destination, but allow certain ones for:
+                    // - fldinst: hyperlinks
+                    // - nesttableprops: nested tables
+                    // - shppict: shape pictures (contain pict groups)
+                    const allowedIgnorable = ['fldinst', 'nesttableprops'];
+                    if (config.extractAttachments) {
+                        allowedIgnorable.push('shppict', 'listpicture');
                     }
-                    else if (node.destination === 'pict') {
-                        // Handle picture extraction
-                        if (config.extractAttachments) {
-                            isPict = true;
-                        }
-                        else {
+                    if (!allowedIgnorable.includes(node.destination || '')) {
+                        if (node.destination === 'bkmkstart') {
+                            const name = extractGroupText(node);
+                            if (name && !currentAnchorIds.includes(name)) {
+                                currentAnchorIds.push(name);
+                            }
                             isIgnored = true;
                         }
-                    }
-                    else if (ignoreList.includes(node.destination)) {
-                        isIgnored = true;
-                    }
-                    else if (node.content.length > 0 && node.content[0].type === 'control' && node.content[0].value === '*') {
-                        // Ignorable destination, but allow certain ones for:
-                        // - fldinst: hyperlinks
-                        // - nesttableprops: nested tables
-                        // - shppict: shape pictures (contain pict groups)
-                        const allowedIgnorable = ['fldinst', 'nesttableprops'];
-                        if (config.extractAttachments) {
-                            allowedIgnorable.push('shppict', 'listpicture');
-                        }
-                        if (!allowedIgnorable.includes(node.destination || '')) {
+                        else if (node.destination === 'bkmkend') {
                             isIgnored = true;
                         }
-                    }
-                }
-                // ═══════════════════════════════════════════════════════════
-                // Handle listtext and pntext: These indicate the current paragraph
-                // is a list item. We extract list type info before ignoring content.
-                // ═══════════════════════════════════════════════════════════
-                if (node.destination === 'listtext' || node.destination === 'pntext') {
-                    // If this is the first list item, reset the indent
-                    if (!isListItem)
-                        paragraphIndent = 0;
-                    isListItem = true;
-                    // Try to determine list type from the marker content
-                    // Bullets (unordered): '·', '•', 'o', '§', etc.
-                    // Numbers (ordered): '1.', '2.', 'i.', 'ii.', 'a.', 'A.', etc.
-                    const markerText = extractTextFromGroup(node);
-                    if (markerText) {
-                        const trimmed = markerText.trim();
-                        // Check for common bullet characters
-                        const bulletChars = ['·', '•', 'o', '§', '■', '□', '●', '○', '◆', '◇', '►', '▸', '\u00b7', '\u2022', '\u25cf', '\u25cb'];
-                        const isBullet = bulletChars.some(b => trimmed.includes(b)) ||
-                            // Font symbol bullets often use characters from Symbol font
-                            (trimmed.length === 1 && !/[0-9a-zA-Z]/.test(trimmed));
-                        if (isBullet) {
-                            listType = 'unordered';
-                        }
-                        else if (/^[0-9ivxlcdm]+[\.\)]/i.test(trimmed) || /^[a-z][\.\)]/i.test(trimmed)) {
-                            // Matches: 1., 2), i., ii., a., A), etc.
-                            listType = 'ordered';
+                        else {
+                            isIgnored = true;
                         }
-                        // If we can't determine, leave listType as is (might be set by \ls/\levelnfc)
                     }
-                    // Still mark as ignored to skip the marker text content
-                    isIgnored = true;
                 }
-                if (isIgnored)
-                    return;
-                // Append group start to raw content
-                currentParagraphRaw += '{';
-                // Handle pict group: extract image and add to content tree
-                if (isPict) {
-                    const attachment = extractPictAttachment(node);
-                    if (attachment) {
-                        attachments.push(attachment);
-                        // Only add image node to content if this is NOT a list definition picture
-                        // List pictures (bullets) should not appear in content, only as attachments
-                        if (!parsingListTable && !parsingListDefinition) {
-                            // Also add an image node to the content tree (like DOCX)
-                            flushParagraph();
-                            currentTarget.push({
-                                type: 'image',
-                                text: '',
-                                metadata: {
-                                    attachmentName: attachment.name || `image_${attachments.length}`
-                                }
-                            });
-                        }
-                    }
-                    // We still traverse pict content to reconstruct raw RTF?
-                    // No, extractPictAttachment consumes it.
-                    // But we want it in rawContent?
-                    // If we return here, we miss the closing '}'.
-                    // And we miss the content in rawContent.
-                    // Let's traverse it purely for rawContent if needed, but `extractPictAttachment` doesn't modify the tree.
-                    // But `extractPictAttachment` does not return the raw string.
-                    // So we should probably continue traversal but suppress text extraction?
-                    // The original code returned here: `return; // Don't traverse pict content as text`
-                    // So we should do the same, but we need to append the content to `currentParagraphRaw`.
-                    // We can manually serialize the group content here.
-                    for (const child of node.content) {
-                        if (child.type === 'control')
-                            currentParagraphRaw += serializeRtfControl(child);
-                        else if (child.type === 'text')
-                            currentParagraphRaw += serializeRtfText(child);
-                        else if (child.type === 'group') {
-                            // Recursive serialization for nested groups in pict (e.g. blipuid)
-                            // We can't easily recurse `traverse` because it has side effects (text extraction).
-                            // We need a pure serializer or just let `traverse` run but with a flag?
-                            // Or just ignore the raw content of the image binary data?
-                            // Image binary data can be huge.
-                            // Maybe we shouldn't include the full hex dump in `rawContent`?
-                            // The user said "raw content which is probably the rtf group".
-                            // Including 5MB of hex data in the JSON AST might be bad.
-                            // But for consistency, it is the raw content.
-                            // Let's include it for now.
-                            // To do this without side effects, we need a separate serialize function?
-                            // Or just call traverse and ensure `isPict` logic prevents text extraction.
-                            // Wait, `isPict` is true for this node.
-                            // If we recurse, `isPict` will be false for children (unless they are also pict).
-                            // But we want to suppress text extraction for children of pict.
-                            // The original code did `return`.
-                            // So we should manually serialize children here.
-                            // Let's define a simple recursive serializer.
-                            const serializeGroupContent = (g) => {
-                                for (const c of g.content) {
-                                    if (c.type === 'control')
-                                        currentParagraphRaw += serializeRtfControl(c);
-                                    else if (c.type === 'text')
-                                        currentParagraphRaw += serializeRtfText(c);
-                                    else if (c.type === 'group') {
-                                        currentParagraphRaw += '{';
-                                        serializeGroupContent(c);
-                                        currentParagraphRaw += '}';
-                                    }
-                                }
-                            };
-                            serializeGroupContent(node);
-                        }
-                    }
-                    currentParagraphRaw += '}';
-                    return;
-                }
-                // Handle footnote: switch target to notes
-                const previousTarget = currentTarget;
-                if (isFootnote) {
-                    if (config.ignoreNotes) {
-                        return; // Skip footnote content entirely
+            }
+            // ═══════════════════════════════════════════════════════════
+            // Handle listtext and pntext: These indicate the current paragraph
+            // is a list item. We extract list type info before ignoring content.
+            // ═══════════════════════════════════════════════════════════
+            if (node.destination === 'listtext' || node.destination === 'pntext') {
+                // If this is the first list item, reset the indent
+                if (!isListItem)
+                    paragraphIndent = 0;
+                isListItem = true;
+                // Try to determine list type from the marker content
+                // Bullets (unordered): '·', '•', 'o', '§', etc.
+                // Numbers (ordered): '1.', '2.', 'i.', 'ii.', 'a.', 'A.', etc.
+                const markerText = extractTextFromGroup(node);
+                if (markerText) {
+                    const trimmed = markerText.trim();
+                    // Check for common bullet characters
+                    const bulletChars = ['·', '•', 'o', '§', '■', '□', '●', '○', '◆', '◇', '►', '▸', '\u00b7', '\u2022', '\u25cf', '\u25cb'];
+                    const isBullet = bulletChars.some(b => trimmed.includes(b)) ||
+                        // Font symbol bullets often use characters from Symbol font
+                        (trimmed.length === 1 && !/[0-9a-zA-Z]/.test(trimmed));
+                    if (isBullet) {
+                        listType = 'unordered';
                     }
-                    flushParagraph();
-                    currentFootnoteId++;
-                    // Determine note type based on \fet value
-                    let noteType = 'footnote';
-                    if (fetValue === 1) {
-                        // \fet1 means all notes are endnotes
-                        noteType = 'endnote';
+                    else if (/^[0-9ivxlcdm]+[\.\)]/i.test(trimmed) || /^[a-z][\.\)]/i.test(trimmed)) {
+                        // Matches: 1., 2), i., ii., a., A), etc.
+                        listType = 'ordered';
                     }
-                    else if (fetValue === 2) {
-                        // \fet2 means both types exist
-                        // Check for \ftnalt marker to distinguish endnotes from footnotes
-                        // \footnote\ftnalt indicates an endnote
-                        const hasFtnalt = node.content.some(child => child.type === 'control' && child.value === 'ftnalt');
-                        noteType = hasFtnalt ? 'endnote' : 'footnote';
+                    // If we can't determine, leave listType as is (might be set by \ls/\levelnfc)
+                }
+                // Still mark as ignored to skip the marker text content
+                isIgnored = true;
+            }
+            if (isIgnored)
+                return;
+            // Append group start to raw content
+            currentParagraphRawChunks.push('{');
+            // Handle pict group: extract image and add to content tree
+            if (isPict) {
+                const attachment = extractPictAttachment(node);
+                if (attachment) {
+                    attachments.push(attachment);
+                    // Only add image node to content if this is NOT a list definition picture
+                    // List pictures (bullets) should not appear in content, only as attachments
+                    if (!parsingListTable && !parsingListDefinition) {
+                        // Also add an image node to the content tree (like DOCX)
+                        flushParagraph();
+                        currentTarget.push({
+                            type: 'image',
+                            text: '',
+                            metadata: {
+                                attachmentName: attachment.name || `image_${attachments.length}`
+                            }
+                        });
                     }
-                    // fetValue === 0 (default) means footnotes only
-                    const noteNode = {
-                        type: 'note',
-                        children: [],
-                        metadata: {
-                            noteId: currentFootnoteId.toString(),
-                            noteType: noteType
-                        }
-                    };
-                    notes.push(noteNode);
-                    currentTarget = noteNode.children;
                 }
-                // Create a new formatting context for the group
-                const groupFormatting = { ...formatting };
+                // We still traverse pict content to reconstruct raw RTF?
+                // No, extractPictAttachment consumes it.
+                // But we want it in rawContent?
+                // If we return here, we miss the closing '}'.
+                // And we miss the content in rawContent.
+                // Let's traverse it purely for rawContent if needed, but `extractPictAttachment` doesn't modify the tree.
+                // But `extractPictAttachment` does not return the raw string.
+                // So we should probably continue traversal but suppress text extraction?
+                // The original code returned here: `return; // Don't traverse pict content as text`
+                // So we should do the same, but we need to append the content to `currentParagraphRaw`.
+                // We can manually serialize the group content here.
                 for (const child of node.content) {
-                    // Skip fldinst groups (we already extracted the URL)
-                    if (child.type === 'group' && child.destination === 'fldinst') {
-                        // We still want it in rawContent!
-                        // So we should traverse it but suppress text extraction?
-                        // Or just serialize it?
-                        // `fldinst` contains the URL.
-                        // If we skip it in `traverse`, we miss it in `rawContent`.
-                        // Let's traverse it but maybe the `fldinst` logic inside `traverse` handles it?
-                        // The original code:
-                        // if (child.type === 'group' && child.destination === 'fldinst') { continue; }
-                        // This skips the child entirely.
-                        // So we need to manually serialize it if we want it in rawContent.
-                        currentParagraphRaw += '{';
-                        // We need to serialize the content of fldinst
+                    if (child.type === 'control')
+                        currentParagraphRawChunks.push(serializeRtfControl(child));
+                    else if (child.type === 'text')
+                        currentParagraphRawChunks.push(serializeRtfText(child));
+                    else if (child.type === 'group') {
+                        // Recursive serialization for nested groups in pict (e.g. blipuid)
+                        // We can't easily recurse `traverse` because it has side effects (text extraction).
+                        // We need a pure serializer or just let `traverse` run but with a flag?
+                        // Or just ignore the raw content of the image binary data?
+                        // Image binary data can be huge.
+                        // Maybe we shouldn't include the full hex dump in `rawContent`?
+                        // The user said "raw content which is probably the rtf group".
+                        // Including 5MB of hex data in the JSON AST might be bad.
+                        // But for consistency, it is the raw content.
+                        // Let's include it for now.
+                        // To do this without side effects, we need a separate serialize function?
+                        // Or just call traverse and ensure `isPict` logic prevents text extraction.
+                        // Wait, `isPict` is true for this node.
+                        // If we recurse, `isPict` will be false for children (unless they are also pict).
+                        // But we want to suppress text extraction for children of pict.
+                        // The original code did `return`.
+                        // So we should manually serialize children here.
+                        // Let's define a simple recursive serializer.
                         const serializeGroupContent = (g) => {
                             for (const c of g.content) {
                                 if (c.type === 'control')
-                                    currentParagraphRaw += serializeRtfControl(c);
+                                    currentParagraphRawChunks.push(serializeRtfControl(c));
                                 else if (c.type === 'text')
-                                    currentParagraphRaw += serializeRtfText(c);
+                                    currentParagraphRawChunks.push(serializeRtfText(c));
                                 else if (c.type === 'group') {
-                                    currentParagraphRaw += '{';
+                                    currentParagraphRawChunks.push('{');
                                     serializeGroupContent(c);
-                                    currentParagraphRaw += '}';
+                                    currentParagraphRawChunks.push('}');
                                 }
                             }
                         };
-                        serializeGroupContent(child);
-                        currentParagraphRaw += '}';
-                        continue;
+                        serializeGroupContent(node);
                     }
-                    traverse(child, groupFormatting, depth + 1);
-                }
-                if (node.destination === 'listtable') {
-                    parsingListTable = false;
                 }
-                else if (node.destination === 'list') {
-                    parsingListDefinition = false;
-                    if (currentDefinedListId !== undefined && currentDefinedListType !== undefined) {
-                        listTypeMap[currentDefinedListId] = currentDefinedListType;
+                currentParagraphRawChunks.push('}');
+                return;
+            }
+            // Handle footnote: switch target to notes
+            const previousTarget = currentTarget;
+            if (isFootnote) {
+                if (config.ignoreNotes) {
+                    return; // Skip footnote content entirely
+                }
+                flushParagraph();
+                currentFootnoteId++;
+                // Determine note type based on \fet value
+                let noteType = 'footnote';
+                if (fetValue === 1) {
+                    // \fet1 means all notes are endnotes
+                    noteType = 'endnote';
+                }
+                else if (fetValue === 2) {
+                    // \fet2 means both types exist
+                    // Check for \ftnalt marker to distinguish endnotes from footnotes
+                    // \footnote\ftnalt indicates an endnote
+                    const hasFtnalt = node.content.some(child => child.type === 'control' && child.value === 'ftnalt');
+                    noteType = hasFtnalt ? 'endnote' : 'footnote';
+                }
+                // fetValue === 0 (default) means footnotes only
+                const noteNode = {
+                    type: 'note',
+                    children: [],
+                    metadata: {
+                        noteId: currentFootnoteId.toString(),
+                        noteType: noteType
                     }
+                };
+                notes.push(noteNode);
+                currentTarget = noteNode.children;
+            }
+            // Create a new formatting context for the group
+            const groupFormatting = { ...formatting };
+            for (const child of node.content) {
+                // Skip fldinst groups (we already extracted the URL)
+                if (child.type === 'group' && child.destination === 'fldinst') {
+                    // We still want it in rawContent!
+                    // So we should traverse it but suppress text extraction?
+                    // Or just serialize it?
+                    // `fldinst` contains the URL.
+                    // If we skip it in `traverse`, we miss it in `rawContent`.
+                    // Let's traverse it but maybe the `fldinst` logic inside `traverse` handles it?
+                    // The original code:
+                    // if (child.type === 'group' && child.destination === 'fldinst') { continue; }
+                    // This skips the child entirely.
+                    // So we need to manually serialize it if we want it in rawContent.
+                    currentParagraphRawChunks.push('{');
+                    // We need to serialize the content of fldinst
+                    const serializeGroupContent = (g) => {
+                        for (const c of g.content) {
+                            if (c.type === 'control')
+                                currentParagraphRawChunks.push(serializeRtfControl(c));
+                            else if (c.type === 'text')
+                                currentParagraphRawChunks.push(serializeRtfText(c));
+                            else if (c.type === 'group') {
+                                currentParagraphRawChunks.push('{');
+                                serializeGroupContent(c);
+                                currentParagraphRawChunks.push('}');
+                            }
+                        }
+                    };
+                    serializeGroupContent(child);
+                    currentParagraphRawChunks.push('}');
+                    continue;
                 }
-                else if (node.destination === 'listoverridetable') {
-                    parsingListOverrideTable = false;
+                traverse(child, groupFormatting, depth + 1);
+            }
+            if (node.destination === 'listtable') {
+                parsingListTable = false;
+            }
+            else if (node.destination === 'list') {
+                parsingListDefinition = false;
+                if (currentDefinedListId !== undefined && currentDefinedListType !== undefined) {
+                    listTypeMap[currentDefinedListId] = currentDefinedListType;
                 }
-                else if (parsingListOverrideTable && node.destination === 'listoverride') {
-                    // End of listoverride group - populate map
-                    if (currentListOverrideLs !== undefined && currentListOverrideListId !== undefined) {
-                        listOverrideMap[currentListOverrideLs] = currentListOverrideListId;
+            }
+            else if (node.destination === 'listoverridetable') {
+                parsingListOverrideTable = false;
+            }
+            else if (parsingListOverrideTable && node.destination === 'listoverride') {
+                // End of listoverride group - populate map
+                if (currentListOverrideLs !== undefined && currentListOverrideListId !== undefined) {
+                    listOverrideMap[currentListOverrideLs] = currentListOverrideListId;
+                }
+            }
+            if (isFootnote) {
+                flushParagraph();
+                currentTarget = previousTarget;
+            }
+            // Clear link URL after processing the field group
+            if (isHyperlinkField) {
+                flushRun();
+                currentLinkUrl = undefined;
+            }
+            // Append group end to raw content
+            currentParagraphRawChunks.push('}');
+        }
+        else if (node.type === 'text') {
+            if (parsingListTable || parsingListOverrideTable) {
+                // Even if we don't extract text, we might want it in rawContent?
+                // Yes, rawContent should reflect the source.
+                currentParagraphRawChunks.push(serializeRtfText(node));
+                return;
+            }
+            if (formattingChanged(currentFormatting, formatting)) {
+                flushRun();
+                currentFormatting = { ...formatting };
+            }
+            currentRunTextChunks.push(node.value);
+            currentParagraphRawChunks.push(serializeRtfText(node));
+        }
+        else if (node.type === 'control') {
+            // Append control to raw content
+            currentParagraphRawChunks.push(serializeRtfControl(node));
+            // Handle list definition control words
+            if (parsingListTable) {
+                if (node.value === 'listid') {
+                    currentDefinedListId = node.param;
+                }
+                else if (node.value === 'levelnfc' || node.value === 'levelnfcn') {
+                    // 0 = Arabic, 1 = Upper Roman, 2 = Lower Roman, 3 = Upper Alpha, 4 = Lower Alpha -> Ordered
+                    // 23 = Bullet, 255 = None -> Unordered
+                    const isOrdered = node.param !== undefined && (node.param === 0 || (node.param >= 0 && node.param <= 4));
+                    // Only set if not already set (or prioritize ordered if mixed?)
+                    // We'll assume if any level is ordered, it's ordered.
+                    // Or if we haven't set it yet.
+                    if (!currentDefinedListType || (currentDefinedListType === 'unordered' && isOrdered)) {
+                        currentDefinedListType = isOrdered ? 'ordered' : 'unordered';
                     }
                 }
-                if (isFootnote) {
-                    flushParagraph();
-                    currentTarget = previousTarget;
+                return;
+            }
+            // Handle list override control words
+            if (parsingListOverrideTable) {
+                if (node.value === 'listid') {
+                    currentListOverrideListId = node.param;
                 }
-                // Clear link URL after processing the field group
-                if (isHyperlinkField) {
-                    flushRun();
-                    currentLinkUrl = undefined;
+                else if (node.value === 'ls') {
+                    currentListOverrideLs = node.param;
                 }
-                // Append group end to raw content
-                currentParagraphRaw += '}';
+                return;
             }
-            else if (node.type === 'text') {
-                if (parsingListTable || parsingListOverrideTable) {
-                    // Even if we don't extract text, we might want it in rawContent?
-                    // Yes, rawContent should reflect the source.
-                    currentParagraphRaw += serializeRtfText(node);
-                    return;
+            // Paragraph control words
+            if (node.value === 'par') {
+                flushParagraph();
+                currentFormatting = { ...formatting };
+            }
+            // Table control words
+            else if (node.value === 'trowd') {
+                // Table row definition - start of a new row
+                // Check if we are starting a nested table
+                // If we are already in a table, and we have content in the current cell, 
+                // then this trowd implies a nested table start.
+                const ctx = getCurrentTable();
+                if (inTable && ctx && ctx.currentCellContent.length > 0) {
+                    // Start nested table
+                    ensureTableContext(); // Should already exist if inTable is true
+                    // Push new table context
+                    tableStack.push({
+                        rows: [],
+                        currentCells: [],
+                        currentCellContent: [],
+                        rowIndex: 0
+                    });
                 }
-                if (formattingChanged(currentFormatting, formatting)) {
-                    flushRun();
-                    currentFormatting = { ...formatting };
+                else {
+                    if (!inTable) {
+                        inTable = true;
+                        ensureTableContext();
+                    }
                 }
-                currentRunText += node.value;
-                currentParagraphRaw += serializeRtfText(node);
+                // After \trowd we are inside a table row, so content should go to table cells.
+                // Many RTF files don't use \intbl, relying solely on \trowd...\cell...\row structure.
+                paragraphInTable = true;
+                // Reset cell properties for the new row definition
+                rowCellProps = [];
+                currentCellDefinitionProps = { isMergedContinuation: false };
+                cellContentIndex = 0;
             }
-            else if (node.type === 'control') {
-                // Append control to raw content
-                currentParagraphRaw += serializeRtfControl(node);
-                // Handle list definition control words
-                if (parsingListTable) {
-                    if (node.value === 'listid') {
-                        currentDefinedListId = node.param;
-                    }
-                    else if (node.value === 'levelnfc' || node.value === 'levelnfcn') {
-                        // 0 = Arabic, 1 = Upper Roman, 2 = Lower Roman, 3 = Upper Alpha, 4 = Lower Alpha -> Ordered
-                        // 23 = Bullet, 255 = None -> Unordered
-                        const isOrdered = node.param !== undefined && (node.param === 0 || (node.param >= 0 && node.param <= 4));
-                        // Only set if not already set (or prioritize ordered if mixed?)
-                        // We'll assume if any level is ordered, it's ordered.
-                        // Or if we haven't set it yet.
-                        if (!currentDefinedListType || (currentDefinedListType === 'unordered' && isOrdered)) {
-                            currentDefinedListType = isOrdered ? 'ordered' : 'unordered';
-                        }
+            else if (node.value === 'clvmrg') {
+                // Vertical merge continuation
+                currentCellDefinitionProps.isMergedContinuation = true;
+            }
+            else if (node.value === 'clmgf') {
+                // Vertical merge first cell (reset continuation flag if set, though usually mutually exclusive)
+                currentCellDefinitionProps.isMergedContinuation = false;
+            }
+            else if (node.value === 'cellx') {
+                // End of cell definition
+                rowCellProps.push({ ...currentCellDefinitionProps });
+                // Reset for next cell
+                currentCellDefinitionProps = { isMergedContinuation: false };
+            }
+            else if (node.value === 'cell') {
+                // End of cell - add it to current row
+                // Force paragraphInTable = true because \cell implies we are in a table cell
+                paragraphInTable = true;
+                // Check if this cell is a merged continuation
+                let isMergedContinuation = false;
+                if (cellContentIndex < rowCellProps.length) {
+                    isMergedContinuation = rowCellProps[cellContentIndex].isMergedContinuation;
+                }
+                cellContentIndex++;
+                const cell = flushCell();
+                // Only add if not a merged continuation
+                if (cell) {
+                    if (!isMergedContinuation) {
+                        const ctx = getCurrentTable();
+                        if (ctx)
+                            ctx.currentCells.push(cell);
                     }
-                    return;
                 }
-                // Handle list override control words
-                if (parsingListOverrideTable) {
-                    if (node.value === 'listid') {
-                        currentListOverrideListId = node.param;
-                    }
-                    else if (node.value === 'ls') {
-                        currentListOverrideLs = node.param;
+                currentFormatting = { ...formatting };
+            }
+            else if (node.value === 'nestcell') {
+                // End of cell in outer table (nested context)
+                // If we are in an inner table, we need to close it and return to outer
+                // First, flush the current cell of the inner table (if any pending)
+                // Actually, nestcell ends the OUTER cell.
+                // So the inner table should have been finished by now?
+                // Usually inner table ends with \row.
+                // If we are in a nested table (stack > 1), we should pop until we are at the outer table?
+                // Or maybe just pop one level?
+                if (tableStack.length > 1) {
+                    // Flush the inner table if it has pending rows
+                    const innerCtx = getCurrentTable();
+                    if (innerCtx && (innerCtx.rows.length > 0 || innerCtx.currentCells.length > 0)) {
+                        flushTable(); // This pops the stack
                     }
-                    return;
-                }
-                // Paragraph control words
-                if (node.value === 'par') {
-                    flushParagraph();
-                    currentFormatting = { ...formatting };
                 }
-                // Table control words
-                else if (node.value === 'trowd') {
-                    // Table row definition - start of a new row
-                    // Check if we are starting a nested table
-                    // If we are already in a table, and we have content in the current cell, 
-                    // then this trowd implies a nested table start.
+                // Now we are (hopefully) at the outer table level
+                // Treat as a regular cell end for the outer table
+                paragraphInTable = true;
+                const cell = flushCell();
+                if (cell) {
                     const ctx = getCurrentTable();
-                    if (inTable && ctx && ctx.currentCellContent.length > 0) {
-                        // Start nested table
-                        ensureTableContext(); // Should already exist if inTable is true
-                        // Push new table context
-                        tableStack.push({
-                            rows: [],
-                            currentCells: [],
-                            currentCellContent: [],
-                            rowIndex: 0
-                        });
-                    }
-                    else {
-                        if (!inTable) {
-                            inTable = true;
-                            ensureTableContext();
-                        }
-                    }
-                    // After \trowd we are inside a table row, so content should go to table cells.
-                    // Many RTF files don't use \intbl, relying solely on \trowd...\cell...\row structure.
-                    paragraphInTable = true;
-                    // Reset cell properties for the new row definition
-                    rowCellProps = [];
-                    currentCellDefinitionProps = { isMergedContinuation: false };
-                    cellContentIndex = 0;
-                }
-                else if (node.value === 'clvmrg') {
-                    // Vertical merge continuation
-                    currentCellDefinitionProps.isMergedContinuation = true;
-                }
-                else if (node.value === 'clmgf') {
-                    // Vertical merge first cell (reset continuation flag if set, though usually mutually exclusive)
-                    currentCellDefinitionProps.isMergedContinuation = false;
-                }
-                else if (node.value === 'cellx') {
-                    // End of cell definition
-                    rowCellProps.push({ ...currentCellDefinitionProps });
-                    // Reset for next cell
-                    currentCellDefinitionProps = { isMergedContinuation: false };
-                }
-                else if (node.value === 'cell') {
-                    // End of cell - add it to current row
-                    // Force paragraphInTable = true because \cell implies we are in a table cell
-                    paragraphInTable = true;
-                    // Check if this cell is a merged continuation
-                    let isMergedContinuation = false;
-                    if (cellContentIndex < rowCellProps.length) {
-                        isMergedContinuation = rowCellProps[cellContentIndex].isMergedContinuation;
-                    }
-                    cellContentIndex++;
-                    const cell = flushCell();
-                    // Only add if not a merged continuation
-                    if (cell) {
-                        if (!isMergedContinuation) {
-                            const ctx = getCurrentTable();
-                            if (ctx)
-                                ctx.currentCells.push(cell);
-                        }
-                    }
-                    currentFormatting = { ...formatting };
+                    if (ctx)
+                        ctx.currentCells.push(cell);
                 }
-                else if (node.value === 'nestcell') {
-                    // End of cell in outer table (nested context)
-                    // If we are in an inner table, we need to close it and return to outer
-                    // First, flush the current cell of the inner table (if any pending)
-                    // Actually, nestcell ends the OUTER cell.
-                    // So the inner table should have been finished by now?
-                    // Usually inner table ends with \row.
-                    // If we are in a nested table (stack > 1), we should pop until we are at the outer table?
-                    // Or maybe just pop one level?
-                    if (tableStack.length > 1) {
-                        // Flush the inner table if it has pending rows
-                        const innerCtx = getCurrentTable();
-                        if (innerCtx && (innerCtx.rows.length > 0 || innerCtx.currentCells.length > 0)) {
-                            flushTable(); // This pops the stack
-                        }
-                    }
-                    // Now we are (hopefully) at the outer table level
-                    // Treat as a regular cell end for the outer table
-                    paragraphInTable = true;
-                    const cell = flushCell();
-                    if (cell) {
-                        const ctx = getCurrentTable();
-                        if (ctx)
-                            ctx.currentCells.push(cell);
-                    }
-                    currentFormatting = { ...formatting };
+                currentFormatting = { ...formatting };
+            }
+            else if (node.value === 'row') {
+                // End of row
+                flushRow();
+                currentFormatting = { ...formatting };
+                // Reset content index for safety (though trowd usually does it)
+                cellContentIndex = 0;
+                // Critical: Reset paragraphInTable after row ends.
+                // Subsequent paragraphs must explicitly use \intbl to be part of the table.
+                // Without this, content after the last \row gets incorrectly merged.
+                paragraphInTable = false;
+            }
+            else if (node.value === 'nestrow') {
+                // End of row in outer table
+                // If we are still in inner table context, flush it
+                if (tableStack.length > 1) {
+                    flushTable();
                 }
-                else if (node.value === 'row') {
-                    // End of row
-                    flushRow();
+                flushRow();
+                currentFormatting = { ...formatting };
+                cellContentIndex = 0;
+            }
+            else if (node.value === 'intbl') {
+                // Paragraph is in a table
+                inTable = true;
+                paragraphInTable = true;
+                ensureTableContext();
+            }
+            else if (node.value === 'pard') {
+                // Reset paragraph properties
+                paragraphInTable = false;
+                // Reset other props...
+                paragraphIndent = 0;
+                paragraphAlignment = 'left';
+                isListItem = false;
+                listType = undefined;
+                headingLevel = undefined;
+                currentListId = undefined;
+                // Reset paragraph-level background (cbpat) to prevent leaking to next paragraph
+                formatting.backgroundColor = undefined;
+            }
+            // Text flow control
+            else if (node.value === 'tab') {
+                if (formattingChanged(currentFormatting, formatting)) {
+                    flushRun();
                     currentFormatting = { ...formatting };
-                    // Reset content index for safety (though trowd usually does it)
-                    cellContentIndex = 0;
-                    // Critical: Reset paragraphInTable after row ends.
-                    // Subsequent paragraphs must explicitly use \intbl to be part of the table.
-                    // Without this, content after the last \row gets incorrectly merged.
-                    paragraphInTable = false;
-                }
-                else if (node.value === 'nestrow') {
-                    // End of row in outer table
-                    // If we are still in inner table context, flush it
-                    if (tableStack.length > 1) {
-                        flushTable();
-                    }
-                    flushRow();
+                }
+                currentRunTextChunks.push('\t');
+            }
+            else if (node.value === 'line') {
+                if (formattingChanged(currentFormatting, formatting)) {
+                    flushRun();
                     currentFormatting = { ...formatting };
-                    cellContentIndex = 0;
-                }
-                else if (node.value === 'intbl') {
-                    // Paragraph is in a table
-                    inTable = true;
-                    paragraphInTable = true;
-                    ensureTableContext();
-                }
-                else if (node.value === 'pard') {
-                    // Reset paragraph properties
-                    paragraphInTable = false;
-                    // Reset other props...
-                    paragraphIndent = 0;
-                    paragraphAlignment = 'left';
-                    isListItem = false;
-                    listType = undefined;
-                    headingLevel = undefined;
-                    currentListId = undefined;
-                    // Reset paragraph-level background (cbpat) to prevent leaking to next paragraph
-                    formatting.backgroundColor = undefined;
-                }
-                // Text flow control
-                else if (node.value === 'tab') {
-                    if (formattingChanged(currentFormatting, formatting)) {
-                        flushRun();
-                        currentFormatting = { ...formatting };
-                    }
-                    currentRunText += '\t';
                 }
-                else if (node.value === 'line') {
-                    if (formattingChanged(currentFormatting, formatting)) {
-                        flushRun();
-                        currentFormatting = { ...formatting };
-                    }
-                    currentRunText += '\n';
+                currentRunTextChunks.push('\n');
+            }
+            // Quote characters
+            else if (node.value === 'lquote') {
+                // Left single quotation mark (U+2018)
+                if (formattingChanged(currentFormatting, formatting)) {
+                    flushRun();
+                    currentFormatting = { ...formatting };
                 }
-                // Quote characters
-                else if (node.value === 'lquote') {
-                    // Left single quotation mark (U+2018)
-                    if (formattingChanged(currentFormatting, formatting)) {
-                        flushRun();
-                        currentFormatting = { ...formatting };
-                    }
-                    currentRunText += '\u2018';
+                currentRunTextChunks.push('\u2018');
+            }
+            else if (node.value === 'rquote') {
+                // Right single quotation mark (U+2019)
+                if (formattingChanged(currentFormatting, formatting)) {
+                    flushRun();
+                    currentFormatting = { ...formatting };
                 }
-                else if (node.value === 'rquote') {
-                    // Right single quotation mark (U+2019)
-                    if (formattingChanged(currentFormatting, formatting)) {
-                        flushRun();
-                        currentFormatting = { ...formatting };
-                    }
-                    currentRunText += '\u2019';
+                currentRunTextChunks.push('\u2019');
+            }
+            else if (node.value === 'ldblquote') {
+                // Left double quotation mark (U+201C)
+                if (formattingChanged(currentFormatting, formatting)) {
+                    flushRun();
+                    currentFormatting = { ...formatting };
                 }
-                else if (node.value === 'ldblquote') {
-                    // Left double quotation mark (U+201C)
-                    if (formattingChanged(currentFormatting, formatting)) {
-                        flushRun();
-                        currentFormatting = { ...formatting };
-                    }
-                    currentRunText += '\u201C';
+                currentRunTextChunks.push('\u201C');
+            }
+            else if (node.value === 'rdblquote') {
+                // Right double quotation mark (U+201D)
+                if (formattingChanged(currentFormatting, formatting)) {
+                    flushRun();
+                    currentFormatting = { ...formatting };
                 }
-                else if (node.value === 'rdblquote') {
-                    // Right double quotation mark (U+201D)
+                currentRunTextChunks.push('\u201D');
+            }
+            // Unicode character
+            else if (node.value === 'u') {
+                if (node.param !== undefined) {
+                    let code = node.param;
+                    if (code < 0)
+                        code += 65536;
                     if (formattingChanged(currentFormatting, formatting)) {
                         flushRun();
                         currentFormatting = { ...formatting };
                     }
-                    currentRunText += '\u201D';
-                }
-                // Unicode character
-                else if (node.value === 'u') {
-                    if (node.param !== undefined) {
-                        let code = node.param;
-                        if (code < 0)
-                            code += 65536;
-                        if (formattingChanged(currentFormatting, formatting)) {
-                            flushRun();
-                            currentFormatting = { ...formatting };
-                        }
-                        currentRunText += String.fromCharCode(code);
-                    }
-                }
-                // Character formatting
-                else if (node.value === 'b') {
-                    formatting.bold = (node.param !== 0);
-                }
-                else if (node.value === 'i') {
-                    formatting.italic = (node.param !== 0);
-                }
-                else if (node.value === 'ul') {
-                    formatting.underline = (node.param !== 0);
-                }
-                else if (node.value === 'ulnone') {
-                    formatting.underline = false;
-                }
-                else if (node.value === 'strike') {
-                    formatting.strikethrough = (node.param !== 0);
-                }
-                else if (node.value === 'plain') {
-                    // Reset all character formatting
-                    formatting.bold = false;
-                    formatting.italic = false;
-                    formatting.underline = false;
-                    formatting.strikethrough = false;
-                    formatting.subscript = false;
-                    formatting.superscript = false;
-                    formatting.size = undefined;
-                    formatting.font = undefined;
-                    formatting.color = undefined;
-                    formatting.backgroundColor = undefined;
-                }
-                // Font size (\fs - in half-points)
-                else if (node.value === 'fs') {
-                    if (node.param !== undefined) {
-                        formatting.size = (node.param / 2).toString() + 'pt';
-                    }
-                }
-                // Font family (\f)
-                else if (node.value === 'f') {
-                    if (node.param !== undefined && fontTable[node.param]) {
-                        formatting.font = fontTable[node.param];
-                    }
-                }
-                // Text color (\cf)
-                else if (node.value === 'cf') {
-                    if (node.param !== undefined && colorTable[node.param]) {
-                        formatting.color = colorTable[node.param];
-                    }
-                }
-                // Note type (\fet)
-                else if (node.value === 'fet') {
-                    // \fet0 = footnotes only (default)
-                    // \fet1 = endnotes only
-                    // \fet2 = both footnotes and endnotes
-                    if (node.param !== undefined) {
-                        fetValue = node.param;
-                    }
+                    currentRunTextChunks.push(String.fromCharCode(code));
                 }
-                // Background/highlight color (\cb, \highlight, \chcbpat, \cbpat)
-                // \chcbpat = character background pattern color (used for shading)
-                // \cbpat = paragraph background pattern color
-                else if (node.value === 'cb' || node.value === 'highlight' || node.value === 'chcbpat' || node.value === 'cbpat') {
-                    if (node.param !== undefined && colorTable[node.param]) {
-                        formatting.backgroundColor = colorTable[node.param];
-                    }
+            }
+            // Character formatting
+            else if (node.value === 'b') {
+                formatting.bold = (node.param !== 0);
+            }
+            else if (node.value === 'i') {
+                formatting.italic = (node.param !== 0);
+            }
+            else if (node.value === 'ul') {
+                formatting.underline = (node.param !== 0);
+            }
+            else if (node.value === 'ulnone') {
+                formatting.underline = false;
+            }
+            else if (node.value === 'strike') {
+                formatting.strikethrough = (node.param !== 0);
+            }
+            else if (node.value === 'plain') {
+                // Reset all character formatting
+                formatting.bold = false;
+                formatting.italic = false;
+                formatting.underline = false;
+                formatting.strikethrough = false;
+                formatting.subscript = false;
+                formatting.superscript = false;
+                formatting.size = undefined;
+                formatting.font = undefined;
+                formatting.color = undefined;
+                formatting.backgroundColor = undefined;
+            }
+            // Font size (\fs - in half-points)
+            else if (node.value === 'fs') {
+                if (node.param !== undefined) {
+                    formatting.size = (node.param / 2).toString() + 'pt';
                 }
-                // Subscript
-                else if (node.value === 'sub') {
-                    formatting.subscript = true;
-                    formatting.superscript = false;
-                }
-                // Superscript
-                else if (node.value === 'super') {
-                    formatting.superscript = true;
-                    formatting.subscript = false;
-                }
-                // No subscript/superscript
-                else if (node.value === 'nosupersub') {
-                    formatting.subscript = false;
-                    formatting.superscript = false;
-                }
-                // ═══════════════════════════════════════════════════════════
-                // List control words
-                // ═══════════════════════════════════════════════════════════
-                // Paragraph indentation (\li - left indent in twips)
-                else if (node.value === 'li') {
-                    if (node.param !== undefined) {
-                        // Convert twips to a simpler unit (720 twips = 1 inch, ~0.5 inch per level)
-                        paragraphIndent = Math.floor(node.param / 360);
-                    }
+            }
+            // Font family (\f)
+            else if (node.value === 'f') {
+                if (node.param !== undefined && fontTable[node.param]) {
+                    formatting.font = fontTable[node.param];
                 }
-                // List style ID (Word 97+)
-                else if (node.value === 'ls') {
-                    if (node.param !== undefined) {
-                        // If this is the first list item, reset the indent
-                        if (!isListItem)
-                            paragraphIndent = 0;
-                        isListItem = true;
-                        // Generate or retrieve list ID
-                        if (!listStyleIdMap[node.param]) {
-                            listIdCounter++;
-                            listStyleIdMap[node.param] = `rtf-list-${listIdCounter}`;
-                        }
-                        currentListId = listStyleIdMap[node.param];
-                        // Look up type from list definition
-                        // First check override map to get real list ID
-                        const realListId = listOverrideMap[node.param] !== undefined ? listOverrideMap[node.param] : node.param;
-                        if (listTypeMap[realListId]) {
-                            listType = listTypeMap[realListId];
-                        }
-                    }
+            }
+            // Text color (\cf)
+            else if (node.value === 'cf') {
+                if (node.param !== undefined && colorTable[node.param]) {
+                    formatting.color = colorTable[node.param];
                 }
-                // List indent level (Word 97+)
-                else if (node.value === 'ilvl') {
-                    if (node.param !== undefined) {
-                        isListItem = true;
-                        paragraphIndent = node.param;
-                    }
+            }
+            // Note type (\fet)
+            else if (node.value === 'fet') {
+                // \fet0 = footnotes only (default)
+                // \fet1 = endnotes only
+                // \fet2 = both footnotes and endnotes
+                if (node.param !== undefined) {
+                    fetValue = node.param;
                 }
-                // List numbering level (\pnlvl)
-                else if (node.value === 'pnlvl') {
-                    isListItem = true;
-                    if (node.param !== undefined) {
-                        paragraphIndent = node.param;
-                    }
+            }
+            // Background/highlight color (\cb, \highlight, \chcbpat, \cbpat)
+            // \chcbpat = character background pattern color (used for shading)
+            // \cbpat = paragraph background pattern color
+            else if (node.value === 'cb' || node.value === 'highlight' || node.value === 'chcbpat' || node.value === 'cbpat') {
+                if (node.param !== undefined && colorTable[node.param]) {
+                    formatting.backgroundColor = colorTable[node.param];
                 }
-                // List numbering format
-                else if (node.value === 'levelnfc' || node.value === 'pnf') {
-                    // 0 = Arabic (1, 2, 3), 1 = Roman upper, 2 = Roman lower, 
-                    // 3 = Letter upper, 4 = Letter lower, 23 = Bullet
-                    if (node.param !== undefined) {
-                        isListItem = true;
-                        if (node.param === 23) {
-                            listType = 'unordered';
-                        }
-                        else {
-                            listType = 'ordered';
-                        }
+            }
+            // Subscript
+            else if (node.value === 'sub') {
+                formatting.subscript = true;
+                formatting.superscript = false;
+            }
+            // Superscript
+            else if (node.value === 'super') {
+                formatting.superscript = true;
+                formatting.subscript = false;
+            }
+            // No subscript/superscript
+            else if (node.value === 'nosupersub') {
+                formatting.subscript = false;
+                formatting.superscript = false;
+            }
+            // ═══════════════════════════════════════════════════════════
+            // List control words
+            // ═══════════════════════════════════════════════════════════
+            // Paragraph indentation (\li - left indent in twips)
+            else if (node.value === 'li') {
+                if (node.param !== undefined) {
+                    // Standard level indent is 720 twips (0.5 inch)
+                    // Using a slightly more flexible divisor to account for different generators
+                    const level = Math.round(node.param / 720);
+                    // Only update if not already explicitly set by ilvl (Word 97+)
+                    if (!isListItem) {
+                        paragraphIndent = level;
                     }
                 }
-                // Ordered list indicator
-                else if (node.value === 'pndec' || node.value === 'pnord' || node.value === 'pnlcltr' || node.value === 'pnucltr') {
-                    // If this is the first list item, reset the indent
-                    if (!isListItem)
-                        paragraphIndent = 0;
-                    isListItem = true;
-                    listType = 'ordered';
-                }
-                // Unordered list indicator
-                else if (node.value === 'pnbullet' || node.value === 'pncard') {
+            }
+            // List style ID (Word 97+)
+            else if (node.value === 'ls') {
+                if (node.param !== undefined) {
                     // If this is the first list item, reset the indent
                     if (!isListItem)
                         paragraphIndent = 0;
                     isListItem = true;
-                    listType = 'unordered';
-                }
-                // Style-based heading detection (\s)
-                else if (node.value === 's') {
-                    if (node.param !== undefined) {
-                        // Common heading styles: s1-s9 (though this varies by document)
-                        if (node.param >= 1 && node.param <= 9) {
-                            headingLevel = node.param;
-                        }
+                    // Generate or retrieve list ID
+                    if (!listStyleIdMap[node.param]) {
+                        listIdCounter++;
+                        listStyleIdMap[node.param] = `rtf-list-${listIdCounter}`;
+                    }
+                    currentListId = listStyleIdMap[node.param];
+                    // Look up type from list definition
+                    // First check override map to get real list ID
+                    const realListId = listOverrideMap[node.param] !== undefined ? listOverrideMap[node.param] : node.param;
+                    if (listTypeMap[realListId]) {
+                        listType = listTypeMap[realListId];
                     }
                 }
-                // Paragraph alignment
-                else if (node.value === 'ql') {
-                    paragraphAlignment = 'left';
-                }
-                else if (node.value === 'qc') {
-                    paragraphAlignment = 'center';
-                }
-                else if (node.value === 'qr') {
-                    paragraphAlignment = 'right';
+            }
+            // List indent level (Word 97+)
+            else if (node.value === 'ilvl') {
+                if (node.param !== undefined) {
+                    isListItem = true;
+                    paragraphIndent = node.param;
                 }
-                else if (node.value === 'qj') {
-                    paragraphAlignment = 'justify';
+            }
+            // List numbering level (\pnlvl)
+            else if (node.value === 'pnlvl') {
+                isListItem = true;
+                if (node.param !== undefined) {
+                    paragraphIndent = node.param;
                 }
             }
-        };
-        traverse(doc, {});
-        // Flush any remaining table
-        const finalCtx = getCurrentTable();
-        if (inTable || (finalCtx && (finalCtx.rows.length > 0 || finalCtx.currentCells.length > 0))) {
-            flushTable();
-        }
-        flushParagraph();
-        // Notes handling:
-        // - If putNotesAtLast is false, notes should be added inline during traversal
-        //   (currently they go to 'notes' array, then we append them here - this is wrong)
-        // - If putNotesAtLast is true, notes are appended at the very end (see below)
-        // 
-        // For now, when putNotesAtLast is false, we append notes immediately after content
-        // This isn't truly "inline" but it's better than at the end
-        // TODO: Implement true inline placement during traversal
-        if (!config.putNotesAtLast && notes.length > 0) {
-            content.push(...notes);
-            notes.length = 0; // Clear so they don't get appended again
-        }
-        // Perform OCR if enabled
-        if (config.ocr && config.extractAttachments) {
-            for (const attachment of attachments) {
-                if (attachment.mimeType.startsWith('image/')) {
-                    try {
-                        // Convert base64 data back to Buffer for Tesseract.js
-                        // Passing base64 string directly would be interpreted as a file path,
-                        // causing ENAMETOOLONG error for large images.
-                        const imageBuffer = Buffer.from(attachment.data, 'base64');
-                        attachment.ocrText = (await (0, ocrUtils_js_1.performOcr)(imageBuffer, { language: config.ocrLanguage, ...config.ocrConfig })).trim();
+            // List numbering format
+            else if (node.value === 'levelnfc' || node.value === 'pnf') {
+                // 0 = Arabic (1, 2, 3), 1 = Roman upper, 2 = Roman lower, 
+                // 3 = Letter upper, 4 = Letter lower, 23 = Bullet
+                if (node.param !== undefined) {
+                    isListItem = true;
+                    if (node.param === 23) {
+                        listType = 'unordered';
                     }
-                    catch (e) {
-                        (0, errorUtils_js_1.logWarning)(`OCR failed for ${attachment.name}:`, config, e);
+                    else {
+                        listType = 'ordered';
                     }
                 }
             }
-            // Link OCR text and altText to image nodes in content
-            const assignOcr = (nodes) => {
-                for (const node of nodes) {
-                    if (node.type === 'image' && node.metadata && 'attachmentName' in node.metadata) {
-                        const meta = node.metadata;
-                        const attachment = attachments.find(a => a.name === meta.attachmentName);
-                        if (attachment) {
-                            // Propagate OCR text to image node
-                            if (attachment.ocrText) {
-                                node.text = attachment.ocrText;
-                            }
-                            // Propagate altText if available
-                            if (attachment.altText) {
-                                meta.altText = attachment.altText;
-                            }
-                        }
-                    }
-                    if (node.children) {
-                        assignOcr(node.children);
+            // Ordered list indicator
+            else if (node.value === 'pndec' || node.value === 'pnord' || node.value === 'pnlcltr' || node.value === 'pnucltr') {
+                // If this is the first list item, reset the indent
+                if (!isListItem)
+                    paragraphIndent = 0;
+                isListItem = true;
+                listType = 'ordered';
+            }
+            // Unordered list indicator
+            else if (node.value === 'pnbullet' || node.value === 'pncard') {
+                // If this is the first list item, reset the indent
+                if (!isListItem)
+                    paragraphIndent = 0;
+                isListItem = true;
+                listType = 'unordered';
+            }
+            // Style-based heading detection (\s)
+            else if (node.value === 's') {
+                if (node.param !== undefined) {
+                    // Common heading styles: s1-s9 (though this varies by document)
+                    if (node.param >= 1 && node.param <= 9) {
+                        headingLevel = node.param;
                     }
                 }
-            };
-            assignOcr(content);
+            }
+            // Paragraph alignment
+            else if (node.value === 'ql') {
+                paragraphAlignment = 'left';
+            }
+            else if (node.value === 'qc') {
+                paragraphAlignment = 'center';
+            }
+            else if (node.value === 'qr') {
+                paragraphAlignment = 'right';
+            }
+            else if (node.value === 'qj') {
+                paragraphAlignment = 'justify';
+            }
         }
-        // Final pass to ensure all 'note' nodes have their 'text' property populated
-        // (This supports the simple toText implementation)
-        const populateNoteText = (nodes) => {
+    };
+    traverse(doc, {});
+    // Flush any remaining table
+    const finalCtx = getCurrentTable();
+    if (inTable || (finalCtx && (finalCtx.rows.length > 0 || finalCtx.currentCells.length > 0))) {
+        flushTable();
+    }
+    flushParagraph();
+    // Notes handling:
+    // - If putNotesAtLast is false, notes should be added inline during traversal
+    //   (currently they go to 'notes' array, then we append them here - this is wrong)
+    // - If putNotesAtLast is true, notes are appended at the very end (see below)
+    // 
+    // For now, when putNotesAtLast is false, we append notes immediately after content
+    // This isn't truly "inline" but it's better than at the end
+    // TODO: Implement true inline placement during traversal
+    if (!config.putNotesAtLast && notes.length > 0) {
+        content.push(...notes);
+        notes.length = 0; // Clear so they don't get appended again
+    }
+    // Perform OCR if enabled
+    if (config.ocr && config.extractAttachments) {
+        for (const attachment of attachments) {
+            if (attachment.mimeType.startsWith('image/')) {
+                try {
+                    // Convert base64 data back to Buffer for Tesseract.js
+                    // Passing base64 string directly would be interpreted as a file path,
+                    // causing ENAMETOOLONG error for large images.
+                    const imageBuffer = Buffer.from(attachment.data, 'base64');
+                    attachment.ocrText = (await (0, ocrUtils_js_1.performOcr)(imageBuffer, { ...config.ocrConfig })).trim();
+                }
+                catch (e) {
+                    (0, errorUtils_js_1.logWarning)(types_js_1.OfficeWarningType.OCR_FAILED, config, attachment.name, e);
+                }
+            }
+        }
+        // Link OCR text and altText to image nodes in content
+        const assignOcr = (nodes) => {
             for (const node of nodes) {
-                if (node.type === 'note' && node.children) {
-                    const getText = (n) => {
-                        if (n.children && n.children.length > 0)
-                            return n.children.map(getText).join('');
-                        return n.text || '';
-                    };
-                    node.text = node.children.map(getText).join('').trim();
+                if (node.type === 'image' && node.metadata && 'attachmentName' in node.metadata) {
+                    const meta = node.metadata;
+                    const attachment = attachments.find(a => a.name === meta.attachmentName);
+                    if (attachment) {
+                        // Propagate OCR text to image node
+                        if (attachment.ocrText) {
+                            node.text = attachment.ocrText;
+                        }
+                        // Propagate altText if available
+                        if (attachment.altText) {
+                            meta.altText = attachment.altText;
+                        }
+                    }
                 }
                 if (node.children) {
-                    populateNoteText(node.children);
+                    assignOcr(node.children);
                 }
             }
         };
-        populateNoteText(content);
-        populateNoteText(notes);
-        const result = {
-            type: 'rtf',
-            metadata: {
-            // RTF Limitation: No style map available (RTF uses inline styles)
-            },
-            content: content,
-            attachments: attachments, // PNG and JPEG images extracted from \\pict groups
-            toText: () => {
-                let text = content.map(c => c.text).join(config.newlineDelimiter ?? '\n');
-                if (config.putNotesAtLast && notes.length > 0) {
-                    text += (config.newlineDelimiter ?? '\n') + notes.map(c => c.text).join(config.newlineDelimiter ?? '\n');
-                }
-                return text;
+        assignOcr(content);
+    }
+    // Final pass to ensure all 'note' nodes have their 'text' property populated
+    // (This supports the simple toText implementation)
+    const populateNoteText = (nodes) => {
+        for (const node of nodes) {
+            if (node.type === 'note' && node.children) {
+                const getText = (n) => {
+                    if (n.children && n.children.length > 0)
+                        return n.children.map(getText).join('');
+                    return n.text || '';
+                };
+                node.text = node.children.map(getText).join('').trim();
             }
-        };
-        // If putNotesAtLast is true, append notes to the end of the content array
+            if (node.children) {
+                populateNoteText(node.children);
+            }
+        }
+    };
+    populateNoteText(content);
+    populateNoteText(notes);
+    const toTextSync = () => {
+        let text = content.map(c => c.text).join(config.newlineDelimiter);
         if (config.putNotesAtLast && notes.length > 0) {
-            content.push(...notes);
+            text += config.newlineDelimiter + notes.map(c => c.text).join(config.newlineDelimiter);
         }
-        return result;
-    }
-    catch (err) {
-        throw err;
+        return text;
+    };
+    const result = (0, astUtils_js_1.createAST)('rtf', {
+    // RTF Limitation: No style map available (RTF uses inline styles)
+    }, content, attachments, // PNG and JPEG images extracted from \\pict groups
+    config, toTextSync);
+    // If putNotesAtLast is true, append notes to the end of the content array
+    if (config.putNotesAtLast && notes.length > 0) {
+        content.push(...notes);
     }
+    return result;
 };
 exports.parseRtf = parseRtf;
+// Helper to find an RTF group by destination name
+function findRtfGroup(group, destination) {
+    for (const node of group.content) {
+        if (node.type === 'group') {
+            if (node.destination === destination)
+                return node;
+            const found = findRtfGroup(node, destination);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
 // Helper function to extract font table from RTF document
 function extractFontTable(doc) {
     const fontTable = {};
-    // Recursive helper to find the font table group at any depth
-    const findAndParseFontTable = (group) => {
-        for (const node of group.content) {
-            if (node.type === 'group') {
-                if (node.destination === 'fonttbl') {
-                    // Iterate through font definitions
-                    for (const fontNode of node.content) {
-                        if (fontNode.type === 'group') {
-                            let fontIndex;
-                            let fontName = '';
-                            for (const item of fontNode.content) {
-                                if (item.type === 'control' && item.value === 'f') {
-                                    fontIndex = item.param;
-                                }
-                                else if (item.type === 'text') {
-                                    // Font name (may have trailing semicolon)
-                                    fontName += item.value;
-                                }
-                            }
-                            if (fontIndex !== undefined && fontName) {
-                                // Remove trailing semicolon and whitespace
-                                fontName = fontName.replace(/;$/, '').trim();
-                                fontTable[fontIndex] = fontName;
-                            }
-                        }
+    const tableGroup = findRtfGroup(doc, 'fonttbl');
+    if (tableGroup) {
+        for (const fontNode of tableGroup.content) {
+            if (fontNode.type === 'group') {
+                let fontIndex;
+                let fontName = '';
+                for (const item of fontNode.content) {
+                    if (item.type === 'control' && item.value === 'f') {
+                        fontIndex = item.param;
+                    }
+                    else if (item.type === 'text') {
+                        fontName += item.value;
                     }
-                    return true; // Found and parsed
                 }
-                // Recurse into child groups
-                if (findAndParseFontTable(node)) {
-                    return true;
+                if (fontIndex !== undefined && fontName) {
+                    fontTable[fontIndex] = fontName.replace(/;$/, '').trim();
                 }
             }
         }
-        return false;
-    };
-    findAndParseFontTable(doc);
+    }
     return fontTable;
 }
 // Helper function to extract color table from RTF document
 function extractColorTable(doc) {
     const colorTable = {};
-    // Recursive helper to find the color table group at any depth
-    const findAndParseColorTable = (group) => {
-        for (const node of group.content) {
-            if (node.type === 'group') {
-                if (node.destination === 'colortbl') {
-                    let colorIndex = 0;
-                    let red = 0, green = 0, blue = 0;
-                    for (const item of node.content) {
-                        if (item.type === 'control') {
-                            if (item.value === 'red' && item.param !== undefined) {
-                                red = item.param;
-                            }
-                            else if (item.value === 'green' && item.param !== undefined) {
-                                green = item.param;
-                            }
-                            else if (item.value === 'blue' && item.param !== undefined) {
-                                blue = item.param;
-                            }
-                        }
-                        else if (item.type === 'text' && item.value === ';') {
-                            // Semicolon marks end of color definition
-                            const hex = `#${red.toString(16).padStart(2, '0')}${green.toString(16).padStart(2, '0')}${blue.toString(16).padStart(2, '0')}`;
-                            colorTable[colorIndex] = hex;
-                            colorIndex++;
-                            red = 0;
-                            green = 0;
-                            blue = 0;
-                        }
-                    }
-                    return true; // Found and parsed
-                }
-                // Recurse into child groups
-                if (findAndParseColorTable(node)) {
-                    return true;
-                }
+    const tableGroup = findRtfGroup(doc, 'colortbl');
+    if (tableGroup) {
+        let colorIndex = 0;
+        let red = 0, green = 0, blue = 0;
+        for (const item of tableGroup.content) {
+            if (item.type === 'control') {
+                if (item.value === 'red' && item.param !== undefined)
+                    red = item.param;
+                else if (item.value === 'green' && item.param !== undefined)
+                    green = item.param;
+                else if (item.value === 'blue' && item.param !== undefined)
+                    blue = item.param;
+            }
+            else if (item.type === 'text' && item.value === ';') {
+                const hex = `#${red.toString(16).padStart(2, '0')}${green.toString(16).padStart(2, '0')}${blue.toString(16).padStart(2, '0')}`;
+                colorTable[colorIndex] = hex;
+                colorIndex++;
+                red = 0;
+                green = 0;
+                blue = 0;
             }
         }
-        return false;
-    };
-    findAndParseColorTable(doc);
+    }
     return colorTable;
 }