docxmlater 1.3.0 → 1.3.1

package/dist/core/DocumentParser.js

@@ -42,6 +42,9 @@ const Hyperlink_1 = require("../elements/Hyperlink");
 const Table_1 = require("../elements/Table");
 const TableRow_1 = require("../elements/TableRow");
 const TableCell_1 = require("../elements/TableCell");
+const TableOfContentsElement_1 = require("../elements/TableOfContentsElement");
+const TableOfContents_1 = require("../elements/TableOfContents");
+const StructuredDocumentTag_1 = require("../elements/StructuredDocumentTag");
 const ImageRun_1 = require("../elements/ImageRun");
 const Section_1 = require("../elements/Section");
 const XMLBuilder_1 = require("../xml/XMLBuilder");
@@ -50,6 +53,7 @@ const RelationshipManager_1 = require("./RelationshipManager");
 const Style_1 = require("../formatting/Style");
 const AbstractNumbering_1 = require("../formatting/AbstractNumbering");
 const NumberingInstance_1 = require("../formatting/NumberingInstance");
+const diagnostics_1 = require("../utils/diagnostics");
 class DocumentParser {
     parseErrors = [];
     strictParsing;
@@ -111,8 +115,7 @@ class DocumentParser {
                 if (next.type === "p") {
                     const elementXml = this.extractSingleElement(bodyContent, "w:p", next.pos);
                     if (elementXml) {
-                        const parsed = XMLParser_1.XMLParser.parseToObject(elementXml, { trimValues: false });
-                        const paragraph = await this.parseParagraphFromObject(parsed["w:p"], relationshipManager, zipHandler, imageManager);
+                        const paragraph = await this.parseParagraphWithOrder(elementXml, relationshipManager, zipHandler, imageManager);
                         if (paragraph)
                             bodyElements.push(paragraph);
                         pos = next.pos + elementXml.length;
@@ -193,51 +196,10 @@ class DocumentParser {
         return openTableTags > closeTableTags;
     }
     extractSingleElement(content, tagName, startPos) {
-        const openTag = `<${tagName}`;
-        const closeTag = `</${tagName}>`;
-        const selfClosingEnd = "/>";
-        if (!content.substring(startPos).startsWith(openTag)) {
-            return "";
-        }
-        const openEnd = content.indexOf(">", startPos);
-        if (openEnd === -1) {
-            return "";
-        }
-        if (content.substring(openEnd - 1, openEnd + 1) === selfClosingEnd) {
-            return content.substring(startPos, openEnd + 1);
-        }
-        let depth = 1;
-        let pos = openEnd + 1;
-        while (pos < content.length && depth > 0) {
-            const nextOpen = content.indexOf(openTag, pos);
-            const nextClose = content.indexOf(closeTag, pos);
-            if (nextClose === -1) {
-                return "";
-            }
-            if (nextOpen !== -1 && nextOpen < nextClose) {
-                const charAfter = content[nextOpen + openTag.length];
-                if (charAfter === ">" ||
-                    charAfter === "/" ||
-                    charAfter === " " ||
-                    charAfter === "\t" ||
-                    charAfter === "\n" ||
-                    charAfter === "\r") {
-                    depth++;
-                    pos = nextOpen + openTag.length;
-                }
-                else {
-                    pos = nextOpen + openTag.length;
-                }
-            }
-            else {
-                depth--;
-                pos = nextClose + closeTag.length;
-                if (depth === 0) {
-                    return content.substring(startPos, pos);
-                }
-            }
-        }
-        return "";
+        const remainingContent = content.substring(startPos);
+        const elements = XMLParser_1.XMLParser.extractElements(remainingContent, tagName);
+        const extracted = elements.length > 0 ? elements[0] : "";
+        return extracted;
     }
     validateLoadedContent(bodyElements) {
         const paragraphs = bodyElements.filter((el) => el instanceof Paragraph_1.Paragraph);
@@ -287,6 +249,124 @@ class DocumentParser {
             }
         }
     }
+    async parseParagraphWithOrder(paraXml, relationshipManager, zipHandler, imageManager) {
+        try {
+            const paragraph = new Paragraph_1.Paragraph();
+            const paraObj = XMLParser_1.XMLParser.parseToObject(paraXml, { trimValues: false });
+            const pElement = paraObj["w:p"];
+            if (!pElement) {
+                return null;
+            }
+            this.parseParagraphPropertiesFromObject(pElement["w:pPr"], paragraph);
+            const paraId = pElement["w14:paraId"];
+            if (paraId) {
+                paragraph.formatting.paraId = paraId;
+            }
+            const orderedChildren = pElement["_orderedChildren"];
+            if (orderedChildren && orderedChildren.length > 0) {
+                for (const childInfo of orderedChildren) {
+                    const elementType = childInfo.type;
+                    const elementIndex = childInfo.index;
+                    if (elementType === "w:r") {
+                        const runs = pElement["w:r"];
+                        const runArray = Array.isArray(runs) ? runs : (runs ? [runs] : []);
+                        if (elementIndex < runArray.length) {
+                            const child = runArray[elementIndex];
+                            if (child["w:drawing"]) {
+                                if (zipHandler && imageManager) {
+                                    const imageRun = await this.parseDrawingFromObject(child["w:drawing"], zipHandler, relationshipManager, imageManager);
+                                    if (imageRun) {
+                                        paragraph.addRun(imageRun);
+                                    }
+                                }
+                            }
+                            else {
+                                const run = this.parseRunFromObject(child);
+                                if (run) {
+                                    paragraph.addRun(run);
+                                }
+                            }
+                        }
+                    }
+                    else if (elementType === "w:hyperlink") {
+                        const hyperlinks = pElement["w:hyperlink"];
+                        const hyperlinkArray = Array.isArray(hyperlinks) ? hyperlinks : (hyperlinks ? [hyperlinks] : []);
+                        if (elementIndex < hyperlinkArray.length) {
+                            const hyperlink = this.parseHyperlinkFromObject(hyperlinkArray[elementIndex], relationshipManager);
+                            if (hyperlink) {
+                                paragraph.addHyperlink(hyperlink);
+                            }
+                        }
+                    }
+                    else if (elementType === "w:fldSimple") {
+                        const fields = pElement["w:fldSimple"];
+                        const fieldArray = Array.isArray(fields) ? fields : (fields ? [fields] : []);
+                        if (elementIndex < fieldArray.length) {
+                            const field = this.parseSimpleFieldFromObject(fieldArray[elementIndex]);
+                            if (field) {
+                                paragraph.addField(field);
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                const runs = pElement["w:r"];
+                const runChildren = Array.isArray(runs) ? runs : (runs ? [runs] : []);
+                for (const child of runChildren) {
+                    if (child["w:drawing"]) {
+                        if (zipHandler && imageManager) {
+                            const imageRun = await this.parseDrawingFromObject(child["w:drawing"], zipHandler, relationshipManager, imageManager);
+                            if (imageRun) {
+                                paragraph.addRun(imageRun);
+                            }
+                        }
+                    }
+                    else {
+                        const run = this.parseRunFromObject(child);
+                        if (run) {
+                            paragraph.addRun(run);
+                        }
+                    }
+                }
+                const hyperlinks = pElement["w:hyperlink"];
+                const hyperlinkChildren = Array.isArray(hyperlinks) ? hyperlinks : (hyperlinks ? [hyperlinks] : []);
+                for (const hyperlinkObj of hyperlinkChildren) {
+                    const hyperlink = this.parseHyperlinkFromObject(hyperlinkObj, relationshipManager);
+                    if (hyperlink) {
+                        paragraph.addHyperlink(hyperlink);
+                    }
+                }
+                const fields = pElement["w:fldSimple"];
+                const fieldChildren = Array.isArray(fields) ? fields : (fields ? [fields] : []);
+                for (const fieldObj of fieldChildren) {
+                    const field = this.parseSimpleFieldFromObject(fieldObj);
+                    if (field) {
+                        paragraph.addField(field);
+                    }
+                }
+            }
+            const runs = paragraph.getRuns();
+            const runData = runs.map(run => ({
+                text: run.getText(),
+                rtl: run.getFormatting().rtl,
+            }));
+            const bidi = paragraph.getFormatting().bidi;
+            (0, diagnostics_1.logParagraphContent)('parsing', -1, runData, bidi);
+            if (bidi) {
+                (0, diagnostics_1.logTextDirection)(`Paragraph has BiDi enabled`);
+            }
+            return paragraph;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.parseErrors.push({ element: "paragraph", error: err });
+            if (this.strictParsing) {
+                throw new Error(`Failed to parse paragraph: ${err.message}`);
+            }
+            return null;
+        }
+    }
     async parseParagraphFromObject(paraObj, relationshipManager, zipHandler, imageManager) {
         try {
             const paragraph = new Paragraph_1.Paragraph();
@@ -295,38 +375,88 @@ class DocumentParser {
                 paragraph.formatting.paraId = paraId;
             }
             this.parseParagraphPropertiesFromObject(paraObj["w:pPr"], paragraph);
-            const runs = paraObj["w:r"];
-            const runChildren = Array.isArray(runs) ? runs : (runs ? [runs] : []);
-            for (const child of runChildren) {
-                if (child["w:drawing"]) {
-                    if (zipHandler && imageManager) {
-                        const imageRun = await this.parseDrawingFromObject(child["w:drawing"], zipHandler, relationshipManager, imageManager);
-                        if (imageRun) {
-                            paragraph.addRun(imageRun);
+            const orderedChildren = paraObj["_orderedChildren"];
+            if (orderedChildren && orderedChildren.length > 0) {
+                for (const childInfo of orderedChildren) {
+                    const elementType = childInfo.type;
+                    const elementIndex = childInfo.index;
+                    if (elementType === "w:r") {
+                        const runs = paraObj["w:r"];
+                        const runArray = Array.isArray(runs) ? runs : (runs ? [runs] : []);
+                        if (elementIndex < runArray.length) {
+                            const child = runArray[elementIndex];
+                            if (child["w:drawing"]) {
+                                if (zipHandler && imageManager) {
+                                    const imageRun = await this.parseDrawingFromObject(child["w:drawing"], zipHandler, relationshipManager, imageManager);
+                                    if (imageRun) {
+                                        paragraph.addRun(imageRun);
+                                    }
+                                }
+                            }
+                            else {
+                                const run = this.parseRunFromObject(child);
+                                if (run) {
+                                    paragraph.addRun(run);
+                                }
+                            }
                         }
                     }
-                }
-                else {
-                    const run = this.parseRunFromObject(child);
-                    if (run) {
-                        paragraph.addRun(run);
+                    else if (elementType === "w:hyperlink") {
+                        const hyperlinks = paraObj["w:hyperlink"];
+                        const hyperlinkArray = Array.isArray(hyperlinks) ? hyperlinks : (hyperlinks ? [hyperlinks] : []);
+                        if (elementIndex < hyperlinkArray.length) {
+                            const hyperlink = this.parseHyperlinkFromObject(hyperlinkArray[elementIndex], relationshipManager);
+                            if (hyperlink) {
+                                paragraph.addHyperlink(hyperlink);
+                            }
+                        }
+                    }
+                    else if (elementType === "w:fldSimple") {
+                        const fields = paraObj["w:fldSimple"];
+                        const fieldArray = Array.isArray(fields) ? fields : (fields ? [fields] : []);
+                        if (elementIndex < fieldArray.length) {
+                            const field = this.parseSimpleFieldFromObject(fieldArray[elementIndex]);
+                            if (field) {
+                                paragraph.addField(field);
+                            }
+                        }
                     }
                 }
             }
-            const hyperlinks = paraObj["w:hyperlink"];
-            const hyperlinkChildren = Array.isArray(hyperlinks) ? hyperlinks : (hyperlinks ? [hyperlinks] : []);
-            for (const hyperlinkObj of hyperlinkChildren) {
-                const hyperlink = this.parseHyperlinkFromObject(hyperlinkObj, relationshipManager);
-                if (hyperlink) {
-                    paragraph.addHyperlink(hyperlink);
+            else {
+                const runs = paraObj["w:r"];
+                const runChildren = Array.isArray(runs) ? runs : (runs ? [runs] : []);
+                for (const child of runChildren) {
+                    if (child["w:drawing"]) {
+                        if (zipHandler && imageManager) {
+                            const imageRun = await this.parseDrawingFromObject(child["w:drawing"], zipHandler, relationshipManager, imageManager);
+                            if (imageRun) {
+                                paragraph.addRun(imageRun);
+                            }
+                        }
+                    }
+                    else {
+                        const run = this.parseRunFromObject(child);
+                        if (run) {
+                            paragraph.addRun(run);
+                        }
+                    }
                 }
-            }
-            const fields = paraObj["w:fldSimple"];
-            const fieldChildren = Array.isArray(fields) ? fields : (fields ? [fields] : []);
-            for (const fieldObj of fieldChildren) {
-                const field = this.parseSimpleFieldFromObject(fieldObj);
-                if (field) {
-                    paragraph.addField(field);
+                const hyperlinks = paraObj["w:hyperlink"];
+                const hyperlinkChildren = Array.isArray(hyperlinks) ? hyperlinks : (hyperlinks ? [hyperlinks] : []);
+                for (const hyperlinkObj of hyperlinkChildren) {
+                    const hyperlink = this.parseHyperlinkFromObject(hyperlinkObj, relationshipManager);
+                    if (hyperlink) {
+                        paragraph.addHyperlink(hyperlink);
+                    }
+                }
+                const fields = paraObj["w:fldSimple"];
+                const fieldChildren = Array.isArray(fields) ? fields : (fields ? [fields] : []);
+                for (const fieldObj of fieldChildren) {
+                    const field = this.parseSimpleFieldFromObject(fieldObj);
+                    if (field) {
+                        paragraph.addField(field);
+                    }
                 }
             }
             return paragraph;
@@ -585,13 +715,89 @@ class DocumentParser {
     }
     parseRunFromObject(runObj) {
         try {
-            const textElement = runObj["w:t"];
-            let text = (typeof textElement === 'object' && textElement !== null)
-                ? (textElement["#text"] || "")
-                : (textElement || "");
-            text = XMLBuilder_1.XMLBuilder.unescapeXml(text);
-            const run = new Run_1.Run(text, { cleanXmlFromText: false });
+            const content = [];
+            if (runObj["_orderedChildren"]) {
+                for (const child of runObj["_orderedChildren"]) {
+                    const elementType = child.type;
+                    const elementIndex = child.index;
+                    switch (elementType) {
+                        case 'w:t': {
+                            const textElements = Array.isArray(runObj["w:t"]) ? runObj["w:t"] : [runObj["w:t"]];
+                            const te = textElements[elementIndex];
+                            if (te !== undefined && te !== null) {
+                                let text = (typeof te === 'object' && te !== null)
+                                    ? (te["#text"] || "")
+                                    : (te || "");
+                                text = XMLBuilder_1.XMLBuilder.unescapeXml(text);
+                                if (text) {
+                                    content.push({ type: 'text', value: text });
+                                }
+                            }
+                            break;
+                        }
+                        case 'w:tab':
+                            content.push({ type: 'tab' });
+                            break;
+                        case 'w:br': {
+                            const brElement = runObj["w:br"];
+                            const breakType = brElement?.['@_w:type'];
+                            content.push({ type: 'break', breakType });
+                            break;
+                        }
+                        case 'w:cr':
+                            content.push({ type: 'carriageReturn' });
+                            break;
+                        case 'w:softHyphen':
+                            content.push({ type: 'softHyphen' });
+                            break;
+                        case 'w:noBreakHyphen':
+                            content.push({ type: 'noBreakHyphen' });
+                            break;
+                        case 'w:rPr':
+                            break;
+                    }
+                }
+            }
+            else {
+                const textElement = runObj["w:t"];
+                if (textElement !== undefined && textElement !== null) {
+                    const textElements = Array.isArray(textElement) ? textElement : [textElement];
+                    for (const te of textElements) {
+                        let text = (typeof te === 'object' && te !== null)
+                            ? (te["#text"] || "")
+                            : (te || "");
+                        text = XMLBuilder_1.XMLBuilder.unescapeXml(text);
+                        if (text) {
+                            content.push({ type: 'text', value: text });
+                        }
+                    }
+                }
+                if (runObj["w:tab"] !== undefined) {
+                    content.push({ type: 'tab' });
+                }
+                if (runObj["w:br"] !== undefined) {
+                    const brElement = runObj["w:br"];
+                    const breakType = brElement?.['@_w:type'];
+                    content.push({ type: 'break', breakType });
+                }
+                if (runObj["w:cr"] !== undefined) {
+                    content.push({ type: 'carriageReturn' });
+                }
+                if (runObj["w:softHyphen"] !== undefined) {
+                    content.push({ type: 'softHyphen' });
+                }
+                if (runObj["w:noBreakHyphen"] !== undefined) {
+                    content.push({ type: 'noBreakHyphen' });
+                }
+            }
+            const run = Run_1.Run.createFromContent(content, { cleanXmlFromText: false });
             this.parseRunPropertiesFromObject(runObj["w:rPr"], run);
+            const text = run.getText();
+            const formatting = run.getFormatting();
+            if (formatting.rtl) {
+                (0, diagnostics_1.logTextDirection)(`Run with RTL: "${text}"`);
+            }
+            (0, diagnostics_1.logParsing)(`Parsed run: "${text}" (${content.length} content element(s))`, { rtl: formatting.rtl || false });
             return run;
         }
         catch (error) {
@@ -605,20 +811,15 @@ class DocumentParser {
             const tooltip = hyperlinkObj["@_w:tooltip"];
             const runs = hyperlinkObj["w:r"];
             const runChildren = Array.isArray(runs) ? runs : (runs ? [runs] : []);
-            const text = runChildren
-                .map((runObj) => {
-                const textElement = runObj["w:t"];
-                let runText = (typeof textElement === 'object' && textElement !== null)
-                    ? (textElement["#text"] || "")
-                    : (textElement || "");
-                return XMLBuilder_1.XMLBuilder.unescapeXml(runText);
-            })
-                .join('');
+            let parsedRun = null;
+            let text = '';
             let formatting = {};
-            if (runChildren.length > 0 && runChildren[0]["w:rPr"]) {
-                const tempRun = new Run_1.Run('');
-                this.parseRunPropertiesFromObject(runChildren[0]["w:rPr"], tempRun);
-                formatting = tempRun.getFormatting();
+            if (runChildren.length > 0) {
+                parsedRun = this.parseRunFromObject(runChildren[0]);
+                if (parsedRun) {
+                    text = parsedRun.getText();
+                    formatting = parsedRun.getFormatting();
+                }
             }
             let url;
             if (relationshipId) {
@@ -627,14 +828,23 @@ class DocumentParser {
                     url = relationship.getTarget();
                 }
             }
+            let displayText = text || url || '[Link]';
+            if (!text && anchor) {
+                console.warn(`[DocumentParser] Hyperlink to anchor "${anchor}" has no display text. ` +
+                    `Using placeholder "[Link]" to prevent bookmark ID from appearing as visible text. ` +
+                    `This may indicate a corrupted TOC or malformed hyperlink in the source document.`);
+            }
             const hyperlink = new Hyperlink_1.Hyperlink({
                 url,
                 anchor,
-                text: text || url || anchor || 'Link',
+                text: displayText,
                 formatting,
                 tooltip,
                 relationshipId,
             });
+            if (parsedRun && parsedRun.getContent().length > 1) {
+                hyperlink.setRun(parsedRun);
+            }
             return hyperlink;
         }
         catch (error) {
@@ -726,21 +936,29 @@ class DocumentParser {
             run.setVanish(true);
         if (rPrObj["w:specVanish"])
             run.setSpecVanish(true);
-        if (rPrObj["w:rtl"])
+        const checkBooleanProp = (prop) => {
+            if (!prop)
+                return false;
+            const val = prop["@_w:val"];
+            if (val === undefined)
+                return true;
+            return val === "1" || val === 1 || val === "true" || val === true;
+        };
+        if (checkBooleanProp(rPrObj["w:rtl"]))
             run.setRTL(true);
-        if (rPrObj["w:b"])
+        if (checkBooleanProp(rPrObj["w:b"]))
             run.setBold(true);
-        if (rPrObj["w:bCs"])
+        if (checkBooleanProp(rPrObj["w:bCs"]))
             run.setComplexScriptBold(true);
-        if (rPrObj["w:i"])
+        if (checkBooleanProp(rPrObj["w:i"]))
             run.setItalic(true);
-        if (rPrObj["w:iCs"])
+        if (checkBooleanProp(rPrObj["w:iCs"]))
             run.setComplexScriptItalic(true);
-        if (rPrObj["w:strike"])
+        if (checkBooleanProp(rPrObj["w:strike"]))
             run.setStrike(true);
-        if (rPrObj["w:smallCaps"])
+        if (checkBooleanProp(rPrObj["w:smallCaps"]))
             run.setSmallCaps(true);
-        if (rPrObj["w:caps"])
+        if (checkBooleanProp(rPrObj["w:caps"]))
             run.setAllCaps(true);
         if (rPrObj["w:u"]) {
             const uVal = rPrObj["w:u"]["@_w:val"];
@@ -1125,6 +1343,12 @@ class DocumentParser {
                 table.setCellSpacingType(spacingType);
             }
         }
+        if (tblPrObj["w:jc"]) {
+            const alignment = tblPrObj["w:jc"]["@_w:val"];
+            if (alignment) {
+                table.setAlignment(alignment);
+            }
+        }
     }
     async parseTableRowFromObject(rowObj, relationshipManager, zipHandler, imageManager) {
         try {
@@ -1382,8 +1606,330 @@ class DocumentParser {
             return null;
         }
     }
-    async parseSDTFromObject(_sdtObj, _relationshipManager, _zipHandler, _imageManager) {
-        return null;
+    async parseSDTFromObject(sdtObj, relationshipManager, zipHandler, imageManager) {
+        try {
+            if (!sdtObj)
+                return null;
+            const properties = {};
+            const sdtPr = sdtObj['w:sdtPr'];
+            if (sdtPr) {
+                const idElement = sdtPr['w:id'];
+                if (idElement && idElement['@_w:val']) {
+                    properties.id = parseInt(idElement['@_w:val'], 10);
+                }
+                const tagElement = sdtPr['w:tag'];
+                if (tagElement && tagElement['@_w:val']) {
+                    properties.tag = tagElement['@_w:val'];
+                }
+                const lockElement = sdtPr['w:lock'];
+                if (lockElement && lockElement['@_w:val']) {
+                    properties.lock = lockElement['@_w:val'];
+                }
+                const aliasElement = sdtPr['w:alias'];
+                if (aliasElement && aliasElement['@_w:val']) {
+                    properties.alias = aliasElement['@_w:val'];
+                }
+                if (sdtPr['w:richText']) {
+                    properties.controlType = 'richText';
+                }
+                else if (sdtPr['w:text']) {
+                    properties.controlType = 'plainText';
+                    const textElement = sdtPr['w:text'];
+                    properties.plainText = {
+                        multiLine: textElement?.['@_w:multiLine'] === '1' || textElement?.['@_w:multiLine'] === 'true'
+                    };
+                }
+                else if (sdtPr['w:comboBox']) {
+                    properties.controlType = 'comboBox';
+                    const comboBoxElement = sdtPr['w:comboBox'];
+                    properties.comboBox = this.parseListItems(comboBoxElement);
+                }
+                else if (sdtPr['w:dropDownList']) {
+                    properties.controlType = 'dropDownList';
+                    const dropDownElement = sdtPr['w:dropDownList'];
+                    properties.dropDownList = this.parseListItems(dropDownElement);
+                }
+                else if (sdtPr['w:date']) {
+                    properties.controlType = 'datePicker';
+                    const dateElement = sdtPr['w:date'];
+                    properties.datePicker = {
+                        dateFormat: dateElement?.['w:dateFormat']?.['@_w:val'],
+                        fullDate: dateElement?.['w:fullDate']?.['@_w:val'] ? new Date(dateElement['w:fullDate']['@_w:val']) : undefined,
+                        lid: dateElement?.['w:lid']?.['@_w:val'],
+                        calendar: dateElement?.['w:calendar']?.['@_w:val']
+                    };
+                }
+                else if (sdtPr['w14:checkbox']) {
+                    properties.controlType = 'checkbox';
+                    const checkboxElement = sdtPr['w14:checkbox'];
+                    properties.checkbox = {
+                        checked: checkboxElement?.['w14:checked']?.['@_w14:val'] === '1' || checkboxElement?.['w14:checked']?.['@_w14:val'] === 'true',
+                        checkedState: checkboxElement?.['w14:checkedState']?.['@_w14:val'],
+                        uncheckedState: checkboxElement?.['w14:uncheckedState']?.['@_w14:val']
+                    };
+                }
+                else if (sdtPr['w:picture']) {
+                    properties.controlType = 'picture';
+                }
+                else if (sdtPr['w:docPartObj']) {
+                    properties.controlType = 'buildingBlock';
+                    const docPartObj = sdtPr['w:docPartObj'];
+                    properties.buildingBlock = {
+                        gallery: docPartObj?.['w:docPartGallery']?.['@_w:val'],
+                        category: docPartObj?.['w:docPartCategory']?.['@_w:val']
+                    };
+                }
+                else if (sdtPr['w:group']) {
+                    properties.controlType = 'group';
+                }
+            }
+            const content = [];
+            const sdtContent = sdtObj['w:sdtContent'];
+            if (sdtContent) {
+                const orderedChildren = sdtContent['_orderedChildren'];
+                if (orderedChildren && orderedChildren.length > 0) {
+                    for (const childInfo of orderedChildren) {
+                        const elementType = childInfo.type;
+                        const elementIndex = childInfo.index;
+                        if (elementType === 'w:p') {
+                            const paragraphs = sdtContent['w:p'];
+                            const paraArray = Array.isArray(paragraphs) ? paragraphs : (paragraphs ? [paragraphs] : []);
+                            if (elementIndex < paraArray.length) {
+                                const paraXml = this.objectToXml({ 'w:p': paraArray[elementIndex] });
+                                const para = await this.parseParagraphWithOrder(paraXml, relationshipManager, zipHandler, imageManager);
+                                if (para)
+                                    content.push(para);
+                            }
+                        }
+                        else if (elementType === 'w:tbl') {
+                            const tables = sdtContent['w:tbl'];
+                            const tableArray = Array.isArray(tables) ? tables : (tables ? [tables] : []);
+                            if (elementIndex < tableArray.length) {
+                                const tableObj = tableArray[elementIndex];
+                                const table = await this.parseTableFromObject(tableObj, relationshipManager, zipHandler, imageManager);
+                                if (table)
+                                    content.push(table);
+                            }
+                        }
+                        else if (elementType === 'w:sdt') {
+                            const sdts = sdtContent['w:sdt'];
+                            const sdtArray = Array.isArray(sdts) ? sdts : (sdts ? [sdts] : []);
+                            if (elementIndex < sdtArray.length) {
+                                const nestedSdt = await this.parseSDTFromObject(sdtArray[elementIndex], relationshipManager, zipHandler, imageManager);
+                                if (nestedSdt)
+                                    content.push(nestedSdt);
+                            }
+                        }
+                    }
+                }
+                else {
+                    const paragraphs = sdtContent['w:p'];
+                    const paraArray = Array.isArray(paragraphs) ? paragraphs : (paragraphs ? [paragraphs] : []);
+                    for (const paraObj of paraArray) {
+                        const paraXml = this.objectToXml({ 'w:p': paraObj });
+                        const para = await this.parseParagraphWithOrder(paraXml, relationshipManager, zipHandler, imageManager);
+                        if (para)
+                            content.push(para);
+                    }
+                    const tables = sdtContent['w:tbl'];
+                    const tableArray = Array.isArray(tables) ? tables : (tables ? [tables] : []);
+                    for (const tableObj of tableArray) {
+                        const table = await this.parseTableFromObject(tableObj, relationshipManager, zipHandler, imageManager);
+                        if (table)
+                            content.push(table);
+                    }
+                    const nestedSdts = sdtContent['w:sdt'];
+                    const sdtArray = Array.isArray(nestedSdts) ? nestedSdts : (nestedSdts ? [nestedSdts] : []);
+                    for (const nestedSdtObj of sdtArray) {
+                        const nestedSdt = await this.parseSDTFromObject(nestedSdtObj, relationshipManager, zipHandler, imageManager);
+                        if (nestedSdt)
+                            content.push(nestedSdt);
+                    }
+                }
+            }
+            if (properties.buildingBlock?.gallery === 'Table of Contents') {
+                const toc = this.parseTOCFromSDTContent(content, properties, sdtContent);
+                if (toc) {
+                    return new TableOfContentsElement_1.TableOfContentsElement(toc);
+                }
+            }
+            return new StructuredDocumentTag_1.StructuredDocumentTag(properties, content);
+        }
+        catch (error) {
+            console.warn('[DocumentParser] Failed to parse SDT:', error);
+            return null;
+        }
+    }
+    parseTOCFromSDTContent(content, properties, sdtContent) {
+        try {
+            let title;
+            let fieldInstruction;
+            for (const element of content) {
+                if (element instanceof Paragraph_1.Paragraph) {
+                    const style = element.getStyle();
+                    if (style === 'TOCHeading') {
+                        const runs = element.getRuns();
+                        title = runs.map(r => r.getText()).join('');
+                    }
+                }
+            }
+            const paragraphs = sdtContent['w:p'];
+            const paraArray = Array.isArray(paragraphs) ? paragraphs : (paragraphs ? [paragraphs] : []);
+            for (const paraObj of paraArray) {
+                const runs = paraObj['w:r'];
+                const runArray = Array.isArray(runs) ? runs : (runs ? [runs] : []);
+                for (const runObj of runArray) {
+                    const instrText = runObj['w:instrText'];
+                    if (instrText) {
+                        if (typeof instrText === 'string') {
+                            fieldInstruction = instrText.trim();
+                        }
+                        else if (instrText['#text']) {
+                            fieldInstruction = instrText['#text'].trim();
+                        }
+                        if (fieldInstruction)
+                            break;
+                    }
+                }
+                if (fieldInstruction)
+                    break;
+            }
+            if (!fieldInstruction) {
+                console.warn('[DocumentParser] No TOC field instruction found in SDT content');
+                return null;
+            }
+            const tocOptions = { title };
+            if (fieldInstruction.includes('\\h')) {
+                tocOptions.useHyperlinks = true;
+            }
+            if (fieldInstruction.includes('\\n')) {
+                tocOptions.showPageNumbers = false;
+            }
+            if (fieldInstruction.includes('\\z')) {
+                tocOptions.hideInWebLayout = true;
+            }
+            const outlineMatch = fieldInstruction.match(/\\o\s+"(\d+)-(\d+)"/);
+            if (outlineMatch && outlineMatch[1] && outlineMatch[2]) {
+                tocOptions.minLevel = parseInt(outlineMatch[1], 10);
+                tocOptions.maxLevel = parseInt(outlineMatch[2], 10);
+            }
+            const stylesMatch = fieldInstruction.match(/\\t\s+"([^"]+)"/);
+            if (stylesMatch && stylesMatch[1]) {
+                const stylesStr = stylesMatch[1];
+                const styles = [];
+                const parts = stylesStr.split(',').filter(p => p.trim());
+                for (let i = 0; i < parts.length; i += 2) {
+                    const styleName = parts[i];
+                    const levelStr = parts[i + 1];
+                    if (styleName && levelStr) {
+                        styles.push({
+                            styleName: styleName.trim(),
+                            level: parseInt(levelStr.trim(), 10)
+                        });
+                    }
+                }
+                if (styles.length > 0) {
+                    tocOptions.includeStyles = styles;
+                }
+            }
+            return new TableOfContents_1.TableOfContents(tocOptions);
+        }
+        catch (error) {
+            console.warn('[DocumentParser] Failed to parse TOC from SDT content:', error);
+            return null;
+        }
+    }
+    parseListItems(element) {
+        const items = [];
+        const listItems = element?.['w:listItem'];
+        const itemArray = Array.isArray(listItems) ? listItems : (listItems ? [listItems] : []);
+        for (const item of itemArray) {
+            if (item['@_w:displayText'] && item['@_w:value']) {
+                items.push({
+                    displayText: item['@_w:displayText'],
+                    value: item['@_w:value']
+                });
+            }
+        }
+        return {
+            items,
+            lastValue: element?.['@_w:lastValue']
+        };
+    }
+    objectToXml(obj) {
+        const buildXml = (o, name) => {
+            if (typeof o === 'string')
+                return o;
+            if (typeof o !== 'object')
+                return String(o);
+            const keys = Object.keys(o);
+            if (keys.length === 0 && !name)
+                return '';
+            const tagName = name || keys[0];
+            const element = name ? o : o[tagName];
+            let xml = `<${tagName}`;
+            if (element && typeof element === 'object') {
+                for (const key of Object.keys(element)) {
+                    if (key.startsWith('@_')) {
+                        const attrName = key.substring(2);
+                        xml += ` ${attrName}="${element[key]}"`;
+                    }
+                }
+            }
+            const hasChildren = element && typeof element === 'object' &&
+                Object.keys(element).some(k => !k.startsWith('@_') && k !== '#text' && k !== '_orderedChildren');
+            if (!hasChildren && (!element || !element['#text'])) {
+                xml += '/>';
+            }
+            else {
+                xml += '>';
+                if (element && element['#text']) {
+                    xml += element['#text'];
+                }
+                if (element && typeof element === 'object') {
+                    const orderedChildren = element['_orderedChildren'];
+                    if (orderedChildren && orderedChildren.length > 0) {
+                        for (const childInfo of orderedChildren) {
+                            const childType = childInfo.type;
+                            const childIndex = childInfo.index;
+                            if (element[childType] !== undefined) {
+                                const children = element[childType];
+                                if (Array.isArray(children)) {
+                                    if (childIndex < children.length) {
+                                        const childXml = buildXml(children[childIndex], childType);
+                                        xml += childXml;
+                                    }
+                                }
+                                else {
+                                    if (childIndex === 0) {
+                                        const childXml = buildXml(children, childType);
+                                        xml += childXml;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        for (const key of Object.keys(element)) {
+                            if (!key.startsWith('@_') && key !== '#text' && key !== '_orderedChildren') {
+                                const children = element[key];
+                                if (Array.isArray(children)) {
+                                    for (const child of children) {
+                                        xml += buildXml(child, key);
+                                    }
+                                }
+                                else {
+                                    xml += buildXml(children, key);
+                                }
+                            }
+                        }
+                    }
+                }
+                xml += `</${tagName}>`;
+            }
+            return xml;
+        };
+        return buildXml(obj);
     }
     parseRelationships(zipHandler, relationshipManager) {
         const relsPath = "word/_rels/document.xml.rels";