docxmlater 0.28.1 → 0.30.0

package/dist/core/DocumentParser.js

@@ -4,12 +4,17 @@ exports.DocumentParser = void 0;
 const types_1 = require("../zip/types");
 const Paragraph_1 = require("../elements/Paragraph");
 const Run_1 = require("../elements/Run");
+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 Hyperlink_1 = require("../elements/Hyperlink");
+const Section_1 = require("../elements/Section");
 const XMLBuilder_1 = require("../xml/XMLBuilder");
 const XMLParser_1 = require("../xml/XMLParser");
 const RelationshipManager_1 = require("./RelationshipManager");
+const Style_1 = require("../formatting/Style");
+const AbstractNumbering_1 = require("../formatting/AbstractNumbering");
+const NumberingInstance_1 = require("../formatting/NumberingInstance");
 class DocumentParser {
     parseErrors = [];
     strictParsing;
@@ -22,60 +27,182 @@ class DocumentParser {
     clearParseErrors() {
         this.parseErrors = [];
     }
-    async parseDocument(zipHandler, relationshipManager) {
+    async parseDocument(zipHandler, relationshipManager, imageManager) {
         const docXml = zipHandler.getFileAsString(types_1.DOCX_PATHS.DOCUMENT);
         if (!docXml) {
-            throw new Error('Invalid document: word/document.xml not found');
+            throw new Error("Invalid document: word/document.xml not found");
         }
         const parsedRelationshipManager = this.parseRelationships(zipHandler, relationshipManager);
         const properties = this.parseProperties(zipHandler);
-        const bodyElements = this.parseBodyElements(docXml, parsedRelationshipManager);
-        return { bodyElements, properties, relationshipManager: parsedRelationshipManager };
+        const bodyElements = await this.parseBodyElements(docXml, parsedRelationshipManager, zipHandler, imageManager);
+        const styles = this.parseStyles(zipHandler);
+        const numbering = this.parseNumbering(zipHandler);
+        const section = this.parseSectionProperties(docXml);
+        const namespaces = this.parseNamespaces(docXml);
+        return {
+            bodyElements,
+            properties,
+            relationshipManager: parsedRelationshipManager,
+            styles,
+            abstractNumberings: numbering.abstractNumberings,
+            numberingInstances: numbering.numberingInstances,
+            section,
+            namespaces,
+        };
     }
-    parseBodyElements(docXml, relationshipManager) {
+    async parseBodyElements(docXml, relationshipManager, zipHandler, imageManager) {
         const bodyElements = [];
-        try {
-            XMLParser_1.XMLParser.validateSize(docXml);
-        }
-        catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            this.parseErrors.push({ element: 'document', error: err });
-            if (this.strictParsing) {
-                throw err;
-            }
-            return bodyElements;
-        }
         const bodyContent = XMLParser_1.XMLParser.extractBody(docXml);
         if (!bodyContent) {
             return bodyElements;
         }
-        const paragraphXmls = XMLParser_1.XMLParser.extractElements(bodyContent, 'w:p');
-        for (const paraXml of paragraphXmls) {
-            const paragraph = this.parseParagraph(paraXml, relationshipManager);
-            if (paragraph) {
-                bodyElements.push(paragraph);
+        let pos = 0;
+        while (pos < bodyContent.length) {
+            const nextP = this.findNextTopLevelTag(bodyContent, "w:p", pos);
+            const nextTbl = this.findNextTopLevelTag(bodyContent, "w:tbl", pos);
+            const nextSdt = this.findNextTopLevelTag(bodyContent, "w:sdt", pos);
+            const candidates = [];
+            if (nextP !== -1)
+                candidates.push({ type: "p", pos: nextP });
+            if (nextTbl !== -1)
+                candidates.push({ type: "tbl", pos: nextTbl });
+            if (nextSdt !== -1)
+                candidates.push({ type: "sdt", pos: nextSdt });
+            if (candidates.length === 0)
+                break;
+            candidates.sort((a, b) => a.pos - b.pos);
+            const next = candidates[0];
+            if (next) {
+                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);
+                        if (paragraph)
+                            bodyElements.push(paragraph);
+                        pos = next.pos + elementXml.length;
+                    }
+                    else {
+                        pos = next.pos + 1;
+                    }
+                }
+                else if (next.type === "tbl") {
+                    const elementXml = this.extractSingleElement(bodyContent, "w:tbl", next.pos);
+                    if (elementXml) {
+                        const parsed = XMLParser_1.XMLParser.parseToObject(elementXml, { trimValues: false });
+                        const table = await this.parseTableFromObject(parsed["w:tbl"], relationshipManager, zipHandler, imageManager);
+                        if (table)
+                            bodyElements.push(table);
+                        pos = next.pos + elementXml.length;
+                    }
+                    else {
+                        pos = next.pos + 1;
+                    }
+                }
+                else if (next.type === "sdt") {
+                    const elementXml = this.extractSingleElement(bodyContent, "w:sdt", next.pos);
+                    if (elementXml) {
+                        const parsed = XMLParser_1.XMLParser.parseToObject(elementXml, { trimValues: false });
+                        const sdt = await this.parseSDTFromObject(parsed["w:sdt"], relationshipManager, zipHandler, imageManager);
+                        if (sdt)
+                            bodyElements.push(sdt);
+                        pos = next.pos + elementXml.length;
+                    }
+                    else {
+                        pos = next.pos + 1;
+                    }
+                }
+            }
+        }
+        this.validateLoadedContent(bodyElements);
+        return bodyElements;
+    }
+    findNextTag(content, tagName, startPos) {
+        const tag = `<${tagName}`;
+        let pos = content.indexOf(tag, startPos);
+        while (pos !== -1) {
+            const charAfterTag = content[pos + tag.length];
+            if (charAfterTag &&
+                charAfterTag !== ">" &&
+                charAfterTag !== "/" &&
+                charAfterTag !== " " &&
+                charAfterTag !== "\t" &&
+                charAfterTag !== "\n" &&
+                charAfterTag !== "\r") {
+                pos = content.indexOf(tag, pos + tag.length);
+                continue;
             }
+            return pos;
+        }
+        return -1;
+    }
+    findNextTopLevelTag(content, tagName, startPos) {
+        let pos = startPos;
+        while (pos < content.length) {
+            const tagPos = this.findNextTag(content, tagName, pos);
+            if (tagPos === -1) {
+                return -1;
+            }
+            const isInsideTable = this.isPositionInsideTable(content, tagPos);
+            if (!isInsideTable) {
+                return tagPos;
+            }
+            pos = tagPos + 1;
+        }
+        return -1;
+    }
+    isPositionInsideTable(content, position) {
+        const beforeContent = content.substring(0, position);
+        const openTableTags = (beforeContent.match(/<w:tbl[\s>]/g) || []).length;
+        const closeTableTags = (beforeContent.match(/<\/w:tbl>/g) || []).length;
+        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 "";
         }
-        const tableElements = XMLParser_1.XMLParser.extractElements(bodyContent, 'w:tbl');
-        for (const tableElement of tableElements) {
-            try {
-                const table = this.parseTable(tableElement, relationshipManager);
-                if (table) {
-                    bodyElements.push(table);
+        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;
                 }
             }
-            catch (error) {
-                this.parseErrors.push({
-                    element: 'table',
-                    error: error instanceof Error ? error : new Error(String(error))
-                });
-                if (this.strictParsing) {
-                    throw error;
+            else {
+                depth--;
+                pos = nextClose + closeTag.length;
+                if (depth === 0) {
+                    return content.substring(startPos, pos);
                 }
             }
         }
-        this.validateLoadedContent(bodyElements);
-        return bodyElements;
+        return "";
     }
     validateLoadedContent(bodyElements) {
         const paragraphs = bodyElements.filter((el) => el instanceof Paragraph_1.Paragraph);
@@ -108,271 +235,158 @@ class DocumentParser {
                     `  - Text content was stripped by another application\n` +
                     `  - Encoding issues during document creation\n` +
                     `Original document structure is preserved, but text may be lost.`);
-                this.parseErrors.push({ element: 'document-validation', error: warning });
+                this.parseErrors.push({
+                    element: "document-validation",
+                    error: warning,
+                });
                 console.warn(`\nDocXML Load Warning:\n${warning.message}\n`);
             }
             else if (emptyPercentage > 50 && emptyRuns > 5) {
                 const warning = new Error(`Document has ${emptyRuns} out of ${totalRuns} runs (${emptyPercentage.toFixed(1)}%) with no text. ` +
                     `This is higher than normal and may indicate partial data loss.`);
-                this.parseErrors.push({ element: 'document-validation', error: warning });
+                this.parseErrors.push({
+                    element: "document-validation",
+                    error: warning,
+                });
                 console.warn(`\nDocXML Load Warning:\n${warning.message}\n`);
             }
         }
     }
-    parseParagraph(paraXml, relationshipManager) {
+    async parseParagraphFromObject(paraObj, relationshipManager, zipHandler, imageManager) {
         try {
             const paragraph = new Paragraph_1.Paragraph();
-            this.parseParagraphProperties(paraXml, paragraph);
-            const hyperlinkXmls = XMLParser_1.XMLParser.extractElements(paraXml, 'w:hyperlink');
-            for (const hyperlinkXml of hyperlinkXmls) {
-                const hyperlink = this.parseHyperlink(hyperlinkXml, relationshipManager);
-                if (hyperlink) {
-                    paragraph.addHyperlink(hyperlink);
-                }
+            const paraId = paraObj["w14:paraId"];
+            if (paraId) {
+                paragraph.formatting.paraId = paraId;
             }
-            let paraXmlWithoutHyperlinks = paraXml;
-            for (const hyperlinkXml of hyperlinkXmls) {
-                paraXmlWithoutHyperlinks = paraXmlWithoutHyperlinks.replace(hyperlinkXml, '');
+            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);
+                        }
+                    }
+                }
+                else {
+                    const run = this.parseRunFromObject(child);
+                    if (run) {
+                        paragraph.addRun(run);
+                    }
+                }
             }
-            const runXmls = XMLParser_1.XMLParser.extractElements(paraXmlWithoutHyperlinks, 'w:r');
-            for (const runXml of runXmls) {
-                const run = this.parseRun(runXml);
-                if (run) {
-                    paragraph.addRun(run);
+            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);
                 }
             }
             return paragraph;
         }
         catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));
-            this.parseErrors.push({ element: 'paragraph', error: err });
+            this.parseErrors.push({ element: "paragraph", error: err });
             if (this.strictParsing) {
                 throw new Error(`Failed to parse paragraph: ${err.message}`);
             }
             return null;
         }
     }
-    parseParagraphProperties(paraXml, paragraph) {
-        const pPr = XMLParser_1.XMLParser.extractBetweenTags(paraXml, '<w:pPr', '</w:pPr>');
-        if (!pPr) {
+    parseParagraphPropertiesFromObject(pPrObj, paragraph) {
+        if (!pPrObj)
             return;
+        if (pPrObj["w:jc"]?.["@_w:val"]) {
+            paragraph.setAlignment(pPrObj["w:jc"]["@_w:val"]);
         }
-        const jcElements = XMLParser_1.XMLParser.extractElements(pPr, 'w:jc');
-        if (jcElements.length > 0) {
-            const value = XMLParser_1.XMLParser.extractAttribute(jcElements[0], 'w:val');
-            if (value) {
-                const validAlignments = ['left', 'center', 'right', 'justify'];
-                if (validAlignments.includes(value)) {
-                    paragraph.setAlignment(value);
-                }
-            }
+        if (pPrObj["w:pStyle"]?.["@_w:val"]) {
+            paragraph.setStyle(pPrObj["w:pStyle"]["@_w:val"]);
         }
-        const styleElements = XMLParser_1.XMLParser.extractElements(pPr, 'w:pStyle');
-        if (styleElements.length > 0) {
-            const styleId = XMLParser_1.XMLParser.extractAttribute(styleElements[0], 'w:val');
-            if (styleId) {
-                paragraph.setStyle(styleId);
-            }
-        }
-        const indElements = XMLParser_1.XMLParser.extractElements(pPr, 'w:ind');
-        if (indElements.length > 0) {
-            const indElement = indElements[0];
-            const left = XMLParser_1.XMLParser.extractAttribute(indElement, 'w:left');
-            const right = XMLParser_1.XMLParser.extractAttribute(indElement, 'w:right');
-            const firstLine = XMLParser_1.XMLParser.extractAttribute(indElement, 'w:firstLine');
-            if (left) {
-                paragraph.setLeftIndent(parseInt(left, 10));
-            }
-            if (right) {
-                paragraph.setRightIndent(parseInt(right, 10));
-            }
-            if (firstLine) {
-                paragraph.setFirstLineIndent(parseInt(firstLine, 10));
-            }
-        }
-        const spacingElements = XMLParser_1.XMLParser.extractElements(pPr, 'w:spacing');
-        if (spacingElements.length > 0) {
-            const spacingElement = spacingElements[0];
-            const before = XMLParser_1.XMLParser.extractAttribute(spacingElement, 'w:before');
-            const after = XMLParser_1.XMLParser.extractAttribute(spacingElement, 'w:after');
-            const line = XMLParser_1.XMLParser.extractAttribute(spacingElement, 'w:line');
-            const lineRule = XMLParser_1.XMLParser.extractAttribute(spacingElement, 'w:lineRule');
-            if (before) {
-                paragraph.setSpaceBefore(parseInt(before, 10));
-            }
-            if (after) {
-                paragraph.setSpaceAfter(parseInt(after, 10));
-            }
-            if (line) {
-                let validatedLineRule;
-                if (lineRule) {
-                    const validLineRules = ['auto', 'exact', 'atLeast'];
-                    if (validLineRules.includes(lineRule)) {
-                        validatedLineRule = lineRule;
-                    }
-                }
-                paragraph.setLineSpacing(parseInt(line, 10), validatedLineRule);
+        if (pPrObj["w:ind"]) {
+            const ind = pPrObj["w:ind"];
+            if (ind["@_w:left"])
+                paragraph.setLeftIndent(parseInt(ind["@_w:left"], 10));
+            if (ind["@_w:right"])
+                paragraph.setRightIndent(parseInt(ind["@_w:right"], 10));
+            if (ind["@_w:firstLine"])
+                paragraph.setFirstLineIndent(parseInt(ind["@_w:firstLine"], 10));
+        }
+        if (pPrObj["w:spacing"]) {
+            const spacing = pPrObj["w:spacing"];
+            if (spacing["@_w:before"])
+                paragraph.setSpaceBefore(parseInt(spacing["@_w:before"], 10));
+            if (spacing["@_w:after"])
+                paragraph.setSpaceAfter(parseInt(spacing["@_w:after"], 10));
+            if (spacing["@_w:line"]) {
+                paragraph.setLineSpacing(parseInt(spacing["@_w:line"], 10), spacing["@_w:lineRule"]);
             }
         }
-        if (XMLParser_1.XMLParser.hasSelfClosingTag(pPr, 'w:keepNext'))
+        if (pPrObj["w:pageBreakBefore"])
+            paragraph.formatting.pageBreakBefore = true;
+        if (pPrObj["w:keepNext"])
             paragraph.setKeepNext(true);
-        if (XMLParser_1.XMLParser.hasSelfClosingTag(pPr, 'w:keepLines'))
+        if (pPrObj["w:keepLines"])
             paragraph.setKeepLines(true);
-        if (XMLParser_1.XMLParser.hasSelfClosingTag(pPr, 'w:pageBreakBefore'))
-            paragraph.setPageBreakBefore(true);
-        if (XMLParser_1.XMLParser.hasSelfClosingTag(pPr, 'w:contextualSpacing')) {
+        if (pPrObj["w:contextualSpacing"])
             paragraph.setContextualSpacing(true);
+        if (pPrObj["w:numPr"]) {
+            const numPr = pPrObj["w:numPr"];
+            const numId = numPr["w:numId"]?.["@_w:val"];
+            const ilvl = numPr["w:ilvl"]?.["@_w:val"] || "0";
+            if (numId) {
+                paragraph.setNumbering(parseInt(numId, 10), parseInt(ilvl, 10));
+            }
         }
     }
-    parseRun(runXml) {
+    parseRunFromObject(runObj) {
         try {
-            const text = XMLBuilder_1.XMLBuilder.unescapeXml(XMLParser_1.XMLParser.extractText(runXml));
-            const run = new Run_1.Run(text);
-            this.parseRunProperties(runXml, run);
+            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 });
+            this.parseRunPropertiesFromObject(runObj["w:rPr"], run);
             return run;
         }
         catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            this.parseErrors.push({ element: 'run', error: err });
-            if (this.strictParsing) {
-                throw new Error(`Failed to parse run: ${err.message}`);
-            }
             return null;
         }
     }
-    parseRunProperties(runXml, run) {
-        const rPr = XMLParser_1.XMLParser.extractBetweenTags(runXml, '<w:rPr', '</w:rPr>');
-        if (!rPr) {
-            return;
-        }
-        if (XMLParser_1.XMLParser.hasSelfClosingTag(rPr, 'w:b')) {
-            run.setBold(true);
-        }
-        if (XMLParser_1.XMLParser.hasSelfClosingTag(rPr, 'w:i')) {
-            run.setItalic(true);
-        }
-        const underlineElements = XMLParser_1.XMLParser.extractElements(rPr, 'w:u');
-        if (underlineElements.length > 0) {
-            const value = XMLParser_1.XMLParser.extractAttribute(underlineElements[0], 'w:val');
-            if (value) {
-                const validUnderlineStyles = [
-                    'single',
-                    'double',
-                    'thick',
-                    'dotted',
-                    'dash',
-                    'dotDash',
-                    'dotDotDash',
-                    'wave',
-                ];
-                if (validUnderlineStyles.includes(value) ||
-                    value === 'true' ||
-                    value === 'false') {
-                    const underlineStyle = value;
-                    run.setUnderline(underlineStyle);
-                }
-            }
-            else {
-                run.setUnderline(true);
-            }
-        }
-        if (XMLParser_1.XMLParser.hasSelfClosingTag(rPr, 'w:strike')) {
-            run.setStrike(true);
-        }
-        const vertAlignElements = XMLParser_1.XMLParser.extractElements(rPr, 'w:vertAlign');
-        if (vertAlignElements.length > 0) {
-            const value = XMLParser_1.XMLParser.extractAttribute(vertAlignElements[0], 'w:val');
-            if (value === 'subscript') {
-                run.setSubscript(true);
-            }
-            else if (value === 'superscript') {
-                run.setSuperscript(true);
-            }
-        }
-        const fontElements = XMLParser_1.XMLParser.extractElements(rPr, 'w:rFonts');
-        if (fontElements.length > 0) {
-            const fontName = XMLParser_1.XMLParser.extractAttribute(fontElements[0], 'w:ascii');
-            if (fontName) {
-                run.setFont(fontName);
-            }
-        }
-        const sizeElements = XMLParser_1.XMLParser.extractElements(rPr, 'w:sz');
-        if (sizeElements.length > 0) {
-            const halfPoints = XMLParser_1.XMLParser.extractAttribute(sizeElements[0], 'w:val');
-            if (halfPoints) {
-                run.setSize(parseInt(halfPoints, 10) / 2);
-            }
-        }
-        const colorElements = XMLParser_1.XMLParser.extractElements(rPr, 'w:color');
-        if (colorElements.length > 0) {
-            const colorValue = XMLParser_1.XMLParser.extractAttribute(colorElements[0], 'w:val');
-            if (colorValue) {
-                run.setColor(colorValue);
-            }
-        }
-        const highlightElements = XMLParser_1.XMLParser.extractElements(rPr, 'w:highlight');
-        if (highlightElements.length > 0) {
-            const value = XMLParser_1.XMLParser.extractAttribute(highlightElements[0], 'w:val');
-            if (value) {
-                const validHighlightColors = [
-                    'yellow',
-                    'green',
-                    'cyan',
-                    'magenta',
-                    'blue',
-                    'red',
-                    'darkBlue',
-                    'darkCyan',
-                    'darkGreen',
-                    'darkMagenta',
-                    'darkRed',
-                    'darkYellow',
-                    'darkGray',
-                    'lightGray',
-                    'black',
-                    'white',
-                ];
-                if (validHighlightColors.includes(value)) {
-                    const highlightColor = value;
-                    run.setHighlight(highlightColor);
-                }
-            }
-        }
-        if (XMLParser_1.XMLParser.hasSelfClosingTag(rPr, 'w:smallCaps')) {
-            run.setSmallCaps(true);
-        }
-        if (XMLParser_1.XMLParser.hasSelfClosingTag(rPr, 'w:caps')) {
-            run.setAllCaps(true);
-        }
-    }
-    parseHyperlink(hyperlinkXml, relationshipManager) {
+    parseHyperlinkFromObject(hyperlinkObj, relationshipManager) {
         try {
-            const relationshipId = XMLParser_1.XMLParser.extractAttribute(hyperlinkXml, 'r:id');
-            const anchor = XMLParser_1.XMLParser.extractAttribute(hyperlinkXml, 'w:anchor');
-            const tooltip = XMLParser_1.XMLParser.extractAttribute(hyperlinkXml, 'w:tooltip');
-            if (!relationshipId && !anchor) {
-                return null;
-            }
-            const runXmls = XMLParser_1.XMLParser.extractElements(hyperlinkXml, 'w:r');
-            let text = '';
-            let formatting;
-            for (const runXml of runXmls) {
-                text += XMLBuilder_1.XMLBuilder.unescapeXml(XMLParser_1.XMLParser.extractText(runXml));
-                if (!formatting) {
-                    const run = this.parseRun(runXml);
-                    if (run) {
-                        formatting = run.getFormatting();
-                    }
-                }
+            const relationshipId = hyperlinkObj["@_r:id"];
+            const anchor = hyperlinkObj["@_w:anchor"];
+            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 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();
             }
             let url;
             if (relationshipId) {
                 const relationship = relationshipManager.getRelationship(relationshipId);
-                if (relationship && relationship.getType().includes('hyperlink')) {
+                if (relationship) {
                     url = relationship.getTarget();
                 }
             }
-            return new Hyperlink_1.Hyperlink({
+            const hyperlink = new Hyperlink_1.Hyperlink({
                 url,
                 anchor,
                 text: text || url || anchor || 'Link',
@@ -380,73 +394,112 @@ class DocumentParser {
                 tooltip,
                 relationshipId,
             });
+            return hyperlink;
         }
         catch (error) {
-            const err = error instanceof Error ? error : new Error(String(error));
-            this.parseErrors.push({ element: 'hyperlink', error: err });
-            if (this.strictParsing) {
-                throw new Error(`Failed to parse hyperlink: ${err.message}`);
-            }
+            console.warn('[DocumentParser] Failed to parse hyperlink:', error);
             return null;
         }
     }
-    parseTable(tableXml, relationshipManager) {
+    parseRunPropertiesFromObject(rPrObj, run) {
+        if (!rPrObj)
+            return;
+        if (rPrObj["w:b"])
+            run.setBold(true);
+        if (rPrObj["w:i"])
+            run.setItalic(true);
+        if (rPrObj["w:strike"])
+            run.setStrike(true);
+        if (rPrObj["w:smallCaps"])
+            run.setSmallCaps(true);
+        if (rPrObj["w:caps"])
+            run.setAllCaps(true);
+        if (rPrObj["w:u"]) {
+            const uVal = rPrObj["w:u"]["@_w:val"];
+            run.setUnderline(uVal || true);
+        }
+        if (rPrObj["w:vertAlign"]) {
+            const val = rPrObj["w:vertAlign"]["@_w:val"];
+            if (val === "subscript")
+                run.setSubscript(true);
+            if (val === "superscript")
+                run.setSuperscript(true);
+        }
+        if (rPrObj["w:rFonts"]) {
+            run.setFont(rPrObj["w:rFonts"]["@_w:ascii"]);
+        }
+        if (rPrObj["w:sz"]) {
+            run.setSize(parseInt(rPrObj["w:sz"]["@_w:val"], 10) / 2);
+        }
+        if (rPrObj["w:color"]) {
+            run.setColor(rPrObj["w:color"]["@_w:val"]);
+        }
+        if (rPrObj["w:highlight"]) {
+            run.setHighlight(rPrObj["w:highlight"]["@_w:val"]);
+        }
+    }
+    async parseDrawingFromObject(_drawingObj, _zipHandler, _relationshipManager, _imageManager) {
+        return null;
+    }
+    async parseTableFromObject(tableObj, relationshipManager, zipHandler, imageManager) {
         try {
-            const rowElements = XMLParser_1.XMLParser.extractElements(tableXml, 'w:tr');
-            const rows = [];
-            for (const rowElement of rowElements) {
-                const cellElements = XMLParser_1.XMLParser.extractElements(rowElement, 'w:tc');
-                const cells = [];
-                for (const cellElement of cellElements) {
-                    cells.push(cellElement);
+            const table = new Table_1.Table();
+            const rows = tableObj["w:tr"];
+            const rowChildren = Array.isArray(rows) ? rows : (rows ? [rows] : []);
+            for (const rowObj of rowChildren) {
+                const row = await this.parseTableRowFromObject(rowObj, relationshipManager, zipHandler, imageManager);
+                if (row) {
+                    table.addRow(row);
                 }
-                if (cells.length > 0) {
-                    rows.push(cells);
-                }
-            }
-            if (rows.length === 0) {
-                return null;
-            }
-            const firstRow = rows[0];
-            if (!firstRow || firstRow.length === 0) {
-                return null;
             }
-            const colCount = firstRow.length;
-            const rowCount = rows.length;
-            const table = new Table_1.Table(rowCount, colCount);
-            for (let rIdx = 0; rIdx < rows.length; rIdx++) {
-                const row = table.getRows()[rIdx];
-                if (!row)
-                    continue;
-                const cells = row.getCells();
-                const cellContents = rows[rIdx];
-                if (!cellContents)
-                    continue;
-                for (let cIdx = 0; cIdx < cellContents.length && cIdx < cells.length; cIdx++) {
-                    const cell = cells[cIdx];
-                    if (cell instanceof TableCell_1.TableCell) {
-                        const cellXml = cellContents[cIdx] || '';
-                        const paraElements = XMLParser_1.XMLParser.extractElements(cellXml, 'w:p');
-                        for (const paraElement of paraElements) {
-                            const para = this.parseParagraph(paraElement, relationshipManager);
-                            if (para) {
-                                cell.addParagraph(para);
-                            }
-                        }
-                    }
+            return table;
+        }
+        catch (error) {
+            console.warn('[DocumentParser] Failed to parse table:', error);
+            return null;
+        }
+    }
+    async parseTableRowFromObject(rowObj, relationshipManager, zipHandler, imageManager) {
+        try {
+            const row = new TableRow_1.TableRow();
+            const cells = rowObj["w:tc"];
+            const cellChildren = Array.isArray(cells) ? cells : (cells ? [cells] : []);
+            for (const cellObj of cellChildren) {
+                const cell = await this.parseTableCellFromObject(cellObj, relationshipManager, zipHandler, imageManager);
+                if (cell) {
+                    row.addCell(cell);
                 }
             }
-            return table;
+            return row;
         }
         catch (error) {
-            if (this.strictParsing) {
-                throw error;
+            console.warn('[DocumentParser] Failed to parse table row:', error);
+            return null;
+        }
+    }
+    async parseTableCellFromObject(cellObj, relationshipManager, zipHandler, imageManager) {
+        try {
+            const cell = new TableCell_1.TableCell();
+            const paragraphs = cellObj["w:p"];
+            const paraChildren = Array.isArray(paragraphs) ? paragraphs : (paragraphs ? [paragraphs] : []);
+            for (const paraObj of paraChildren) {
+                const paragraph = await this.parseParagraphFromObject(paraObj, relationshipManager, zipHandler, imageManager);
+                if (paragraph) {
+                    cell.addParagraph(paragraph);
+                }
             }
+            return cell;
+        }
+        catch (error) {
+            console.warn('[DocumentParser] Failed to parse table cell:', error);
             return null;
         }
     }
+    async parseSDTFromObject(_sdtObj, _relationshipManager, _zipHandler, _imageManager) {
+        return null;
+    }
     parseRelationships(zipHandler, relationshipManager) {
-        const relsPath = 'word/_rels/document.xml.rels';
+        const relsPath = "word/_rels/document.xml.rels";
         const relsXml = zipHandler.getFileAsString(relsPath);
         if (relsXml) {
             return RelationshipManager_1.RelationshipManager.fromXml(relsXml);
@@ -463,38 +516,448 @@ class DocumentParser {
             return tagContent ? XMLBuilder_1.XMLBuilder.unescapeXml(tagContent) : undefined;
         };
         const properties = {
-            title: extractTag(coreXml, 'dc:title'),
-            subject: extractTag(coreXml, 'dc:subject'),
-            creator: extractTag(coreXml, 'dc:creator'),
-            keywords: extractTag(coreXml, 'cp:keywords'),
-            description: extractTag(coreXml, 'dc:description'),
-            lastModifiedBy: extractTag(coreXml, 'cp:lastModifiedBy'),
+            title: extractTag(coreXml, "dc:title"),
+            subject: extractTag(coreXml, "dc:subject"),
+            creator: extractTag(coreXml, "dc:creator"),
+            keywords: extractTag(coreXml, "cp:keywords"),
+            description: extractTag(coreXml, "dc:description"),
+            lastModifiedBy: extractTag(coreXml, "cp:lastModifiedBy"),
         };
-        const revisionStr = extractTag(coreXml, 'cp:revision');
+        const revisionStr = extractTag(coreXml, "cp:revision");
         if (revisionStr) {
             properties.revision = parseInt(revisionStr, 10);
         }
-        const createdStr = extractTag(coreXml, 'dcterms:created');
+        const createdStr = extractTag(coreXml, "dcterms:created");
         if (createdStr) {
             properties.created = new Date(createdStr);
         }
-        const modifiedStr = extractTag(coreXml, 'dcterms:modified');
+        const modifiedStr = extractTag(coreXml, "dcterms:modified");
         if (modifiedStr) {
             properties.modified = new Date(modifiedStr);
         }
         return properties;
     }
+    parseStyles(zipHandler) {
+        const styles = [];
+        const stylesXml = zipHandler.getFileAsString(types_1.DOCX_PATHS.STYLES);
+        if (!stylesXml) {
+            return styles;
+        }
+        try {
+            const styleElements = XMLParser_1.XMLParser.extractElements(stylesXml, "w:style");
+            for (const styleXml of styleElements) {
+                try {
+                    const style = this.parseStyle(styleXml);
+                    if (style) {
+                        styles.push(style);
+                    }
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    this.parseErrors.push({ element: "style", error: err });
+                    if (this.strictParsing) {
+                        throw error;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.parseErrors.push({ element: "styles.xml", error: err });
+            if (this.strictParsing) {
+                throw new Error(`Failed to parse styles.xml: ${err.message}`);
+            }
+        }
+        return styles;
+    }
+    parseNumbering(zipHandler) {
+        const abstractNumberings = [];
+        const numberingInstances = [];
+        const numberingXml = zipHandler.getFileAsString(types_1.DOCX_PATHS.NUMBERING);
+        if (!numberingXml) {
+            return { abstractNumberings, numberingInstances };
+        }
+        try {
+            const abstractNumElements = XMLParser_1.XMLParser.extractElements(numberingXml, "w:abstractNum");
+            for (const abstractNumXml of abstractNumElements) {
+                try {
+                    const abstractNum = AbstractNumbering_1.AbstractNumbering.fromXML(abstractNumXml);
+                    abstractNumberings.push(abstractNum);
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    this.parseErrors.push({ element: "abstractNum", error: err });
+                    if (this.strictParsing) {
+                        throw error;
+                    }
+                }
+            }
+            const numElements = XMLParser_1.XMLParser.extractElements(numberingXml, "w:num");
+            for (const numXml of numElements) {
+                try {
+                    const instance = NumberingInstance_1.NumberingInstance.fromXML(numXml);
+                    numberingInstances.push(instance);
+                }
+                catch (error) {
+                    const err = error instanceof Error ? error : new Error(String(error));
+                    this.parseErrors.push({ element: "num", error: err });
+                    if (this.strictParsing) {
+                        throw error;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.parseErrors.push({ element: "numbering.xml", error: err });
+            if (this.strictParsing) {
+                throw new Error(`Failed to parse numbering.xml: ${err.message}`);
+            }
+        }
+        return { abstractNumberings, numberingInstances };
+    }
+    parseSectionProperties(docXml) {
+        try {
+            const bodyElements = XMLParser_1.XMLParser.extractElements(docXml, "w:body");
+            if (bodyElements.length === 0) {
+                return null;
+            }
+            const bodyContent = bodyElements[0];
+            if (!bodyContent) {
+                return null;
+            }
+            const sectPrElements = XMLParser_1.XMLParser.extractElements(bodyContent, "w:sectPr");
+            if (sectPrElements.length === 0) {
+                return null;
+            }
+            const sectPr = sectPrElements[sectPrElements.length - 1];
+            if (!sectPr) {
+                return null;
+            }
+            const sectionProps = {};
+            const pgSzElements = XMLParser_1.XMLParser.extractElements(sectPr, "w:pgSz");
+            if (pgSzElements.length > 0) {
+                const pgSz = pgSzElements[0];
+                if (pgSz) {
+                    const width = XMLParser_1.XMLParser.extractAttribute(pgSz, "w:w");
+                    const height = XMLParser_1.XMLParser.extractAttribute(pgSz, "w:h");
+                    const orient = XMLParser_1.XMLParser.extractAttribute(pgSz, "w:orient");
+                    if (width && height) {
+                        sectionProps.pageSize = {
+                            width: parseInt(width, 10),
+                            height: parseInt(height, 10),
+                            orientation: orient === "landscape" ? "landscape" : "portrait",
+                        };
+                    }
+                }
+            }
+            const pgMarElements = XMLParser_1.XMLParser.extractElements(sectPr, "w:pgMar");
+            if (pgMarElements.length > 0) {
+                const pgMar = pgMarElements[0];
+                if (pgMar) {
+                    const top = XMLParser_1.XMLParser.extractAttribute(pgMar, "w:top");
+                    const bottom = XMLParser_1.XMLParser.extractAttribute(pgMar, "w:bottom");
+                    const left = XMLParser_1.XMLParser.extractAttribute(pgMar, "w:left");
+                    const right = XMLParser_1.XMLParser.extractAttribute(pgMar, "w:right");
+                    const header = XMLParser_1.XMLParser.extractAttribute(pgMar, "w:header");
+                    const footer = XMLParser_1.XMLParser.extractAttribute(pgMar, "w:footer");
+                    const gutter = XMLParser_1.XMLParser.extractAttribute(pgMar, "w:gutter");
+                    if (top && bottom && left && right) {
+                        sectionProps.margins = {
+                            top: parseInt(top, 10),
+                            bottom: parseInt(bottom, 10),
+                            left: parseInt(left, 10),
+                            right: parseInt(right, 10),
+                            header: header ? parseInt(header, 10) : undefined,
+                            footer: footer ? parseInt(footer, 10) : undefined,
+                            gutter: gutter ? parseInt(gutter, 10) : undefined,
+                        };
+                    }
+                }
+            }
+            const colsElements = XMLParser_1.XMLParser.extractElements(sectPr, "w:cols");
+            if (colsElements.length > 0) {
+                const cols = colsElements[0];
+                if (cols) {
+                    const num = XMLParser_1.XMLParser.extractAttribute(cols, "w:num");
+                    const space = XMLParser_1.XMLParser.extractAttribute(cols, "w:space");
+                    const equalWidth = XMLParser_1.XMLParser.extractAttribute(cols, "w:equalWidth");
+                    if (num) {
+                        sectionProps.columns = {
+                            count: parseInt(num, 10),
+                            space: space ? parseInt(space, 10) : undefined,
+                            equalWidth: equalWidth === "1" || equalWidth === "true",
+                        };
+                    }
+                }
+            }
+            const typeElements = XMLParser_1.XMLParser.extractElements(sectPr, "w:type");
+            if (typeElements.length > 0) {
+                const type = typeElements[0];
+                if (type) {
+                    const typeVal = XMLParser_1.XMLParser.extractAttribute(type, "w:val");
+                    if (typeVal) {
+                        sectionProps.type = typeVal;
+                    }
+                }
+            }
+            const pgNumTypeElements = XMLParser_1.XMLParser.extractElements(sectPr, "w:pgNumType");
+            if (pgNumTypeElements.length > 0) {
+                const pgNumType = pgNumTypeElements[0];
+                if (pgNumType) {
+                    const start = XMLParser_1.XMLParser.extractAttribute(pgNumType, "w:start");
+                    const fmt = XMLParser_1.XMLParser.extractAttribute(pgNumType, "w:fmt");
+                    sectionProps.pageNumbering = {
+                        start: start ? parseInt(start, 10) : undefined,
+                        format: fmt,
+                    };
+                }
+            }
+            if (XMLParser_1.XMLParser.hasSelfClosingTag(sectPr, "w:titlePg")) {
+                sectionProps.titlePage = true;
+            }
+            const headerRefs = XMLParser_1.XMLParser.extractElements(sectPr, "w:headerReference");
+            if (headerRefs.length > 0) {
+                sectionProps.headers = {};
+                for (const headerRef of headerRefs) {
+                    const type = XMLParser_1.XMLParser.extractAttribute(headerRef, "w:type");
+                    const rId = XMLParser_1.XMLParser.extractAttribute(headerRef, "r:id");
+                    if (type && rId) {
+                        if (type === "default")
+                            sectionProps.headers.default = rId;
+                        else if (type === "first")
+                            sectionProps.headers.first = rId;
+                        else if (type === "even")
+                            sectionProps.headers.even = rId;
+                    }
+                }
+            }
+            const footerRefs = XMLParser_1.XMLParser.extractElements(sectPr, "w:footerReference");
+            if (footerRefs.length > 0) {
+                sectionProps.footers = {};
+                for (const footerRef of footerRefs) {
+                    const type = XMLParser_1.XMLParser.extractAttribute(footerRef, "w:type");
+                    const rId = XMLParser_1.XMLParser.extractAttribute(footerRef, "r:id");
+                    if (type && rId) {
+                        if (type === "default")
+                            sectionProps.footers.default = rId;
+                        else if (type === "first")
+                            sectionProps.footers.first = rId;
+                        else if (type === "even")
+                            sectionProps.footers.even = rId;
+                    }
+                }
+            }
+            return new Section_1.Section(sectionProps);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.parseErrors.push({ element: "sectPr", error: err });
+            if (this.strictParsing) {
+                throw new Error(`Failed to parse section properties: ${err.message}`);
+            }
+            return null;
+        }
+    }
+    parseStyle(styleXml) {
+        const typeAttr = XMLParser_1.XMLParser.extractAttribute(styleXml, "w:type");
+        const styleId = XMLParser_1.XMLParser.extractAttribute(styleXml, "w:styleId") || "";
+        const defaultAttr = XMLParser_1.XMLParser.extractAttribute(styleXml, "w:default");
+        const customStyleAttr = XMLParser_1.XMLParser.extractAttribute(styleXml, "w:customStyle");
+        if (!styleId || !typeAttr) {
+            return null;
+        }
+        const nameElement = XMLParser_1.XMLParser.extractBetweenTags(styleXml, "<w:name", "</w:name>");
+        const name = nameElement
+            ? XMLParser_1.XMLParser.extractAttribute(`<w:name${nameElement}`, "w:val") || styleId
+            : styleId;
+        const basedOnElement = XMLParser_1.XMLParser.extractBetweenTags(styleXml, "<w:basedOn", "</w:basedOn>");
+        const basedOn = basedOnElement
+            ? XMLParser_1.XMLParser.extractAttribute(`<w:basedOn${basedOnElement}`, "w:val")
+            : undefined;
+        const nextElement = XMLParser_1.XMLParser.extractBetweenTags(styleXml, "<w:next", "</w:next>");
+        const next = nextElement
+            ? XMLParser_1.XMLParser.extractAttribute(`<w:next${nextElement}`, "w:val")
+            : undefined;
+        let paragraphFormatting;
+        const pPrXml = XMLParser_1.XMLParser.extractBetweenTags(styleXml, "<w:pPr>", "</w:pPr>");
+        if (pPrXml) {
+            paragraphFormatting = this.parseParagraphFormattingFromXml(pPrXml);
+        }
+        let runFormatting;
+        const rPrXml = XMLParser_1.XMLParser.extractBetweenTags(styleXml, "<w:rPr>", "</w:rPr>");
+        if (rPrXml) {
+            runFormatting = this.parseRunFormattingFromXml(rPrXml);
+        }
+        const properties = {
+            styleId,
+            name,
+            type: typeAttr,
+            basedOn,
+            next,
+            isDefault: defaultAttr === "1" || defaultAttr === "true",
+            customStyle: customStyleAttr === "1" || customStyleAttr === "true",
+            paragraphFormatting,
+            runFormatting,
+        };
+        return Style_1.Style.create(properties);
+    }
+    parseParagraphFormattingFromXml(pPrXml) {
+        const formatting = {};
+        const jcElement = XMLParser_1.XMLParser.extractBetweenTags(pPrXml, "<w:jc", "/>");
+        if (jcElement) {
+            const alignment = XMLParser_1.XMLParser.extractAttribute(`<w:jc${jcElement}`, "w:val");
+            if (alignment) {
+                formatting.alignment = alignment;
+            }
+        }
+        const spacingElement = XMLParser_1.XMLParser.extractBetweenTags(pPrXml, "<w:spacing", "/>");
+        if (spacingElement) {
+            const before = XMLParser_1.XMLParser.extractAttribute(`<w:spacing${spacingElement}`, "w:before");
+            const after = XMLParser_1.XMLParser.extractAttribute(`<w:spacing${spacingElement}`, "w:after");
+            const line = XMLParser_1.XMLParser.extractAttribute(`<w:spacing${spacingElement}`, "w:line");
+            const lineRule = XMLParser_1.XMLParser.extractAttribute(`<w:spacing${spacingElement}`, "w:lineRule");
+            let validatedLineRule;
+            if (lineRule) {
+                const validLineRules = ["auto", "exact", "atLeast"];
+                if (validLineRules.includes(lineRule)) {
+                    validatedLineRule = lineRule;
+                }
+            }
+            formatting.spacing = {
+                before: before ? parseInt(before, 10) : undefined,
+                after: after ? parseInt(after, 10) : undefined,
+                line: line ? parseInt(line, 10) : validatedLineRule ? 240 : undefined,
+                lineRule: validatedLineRule,
+            };
+        }
+        const indElement = XMLParser_1.XMLParser.extractBetweenTags(pPrXml, "<w:ind", "/>");
+        if (indElement) {
+            const left = XMLParser_1.XMLParser.extractAttribute(`<w:ind${indElement}`, "w:left");
+            const right = XMLParser_1.XMLParser.extractAttribute(`<w:ind${indElement}`, "w:right");
+            const firstLine = XMLParser_1.XMLParser.extractAttribute(`<w:ind${indElement}`, "w:firstLine");
+            const hanging = XMLParser_1.XMLParser.extractAttribute(`<w:ind${indElement}`, "w:hanging");
+            formatting.indentation = {
+                left: left ? parseInt(left, 10) : undefined,
+                right: right ? parseInt(right, 10) : undefined,
+                firstLine: firstLine ? parseInt(firstLine, 10) : undefined,
+                hanging: hanging ? parseInt(hanging, 10) : undefined,
+            };
+        }
+        if (pPrXml.includes("<w:keepNext/>") || pPrXml.includes("<w:keepNext ")) {
+            formatting.keepNext = true;
+        }
+        if (pPrXml.includes("<w:keepLines/>") || pPrXml.includes("<w:keepLines ")) {
+            formatting.keepLines = true;
+        }
+        if (pPrXml.includes("<w:pageBreakBefore/>") ||
+            pPrXml.includes("<w:pageBreakBefore ")) {
+            formatting.pageBreakBefore = true;
+        }
+        return formatting;
+    }
+    parseRunFormattingFromXml(rPrXml) {
+        const formatting = {};
+        if (rPrXml.includes("<w:b/>") || rPrXml.includes("<w:b ")) {
+            formatting.bold = true;
+        }
+        if (rPrXml.includes("<w:i/>") || rPrXml.includes("<w:i ")) {
+            formatting.italic = true;
+        }
+        if (rPrXml.includes("<w:strike/>") || rPrXml.includes("<w:strike ")) {
+            formatting.strike = true;
+        }
+        if (rPrXml.includes("<w:smallCaps/>") || rPrXml.includes("<w:smallCaps ")) {
+            formatting.smallCaps = true;
+        }
+        if (rPrXml.includes("<w:caps/>") || rPrXml.includes("<w:caps ")) {
+            formatting.allCaps = true;
+        }
+        const uElement = XMLParser_1.XMLParser.extractBetweenTags(rPrXml, "<w:u", "/>");
+        if (uElement) {
+            const uVal = XMLParser_1.XMLParser.extractAttribute(`<w:u${uElement}`, "w:val");
+            if (uVal === "single" ||
+                uVal === "double" ||
+                uVal === "thick" ||
+                uVal === "dotted" ||
+                uVal === "dash") {
+                formatting.underline = uVal;
+            }
+            else {
+                formatting.underline = true;
+            }
+        }
+        const vertAlignElement = XMLParser_1.XMLParser.extractBetweenTags(rPrXml, "<w:vertAlign", "/>");
+        if (vertAlignElement) {
+            const val = XMLParser_1.XMLParser.extractAttribute(`<w:vertAlign${vertAlignElement}`, "w:val");
+            if (val === "subscript") {
+                formatting.subscript = true;
+            }
+            else if (val === "superscript") {
+                formatting.superscript = true;
+            }
+        }
+        const rFontsElement = XMLParser_1.XMLParser.extractBetweenTags(rPrXml, "<w:rFonts", "/>");
+        if (rFontsElement) {
+            const ascii = XMLParser_1.XMLParser.extractAttribute(`<w:rFonts${rFontsElement}`, "w:ascii");
+            if (ascii) {
+                formatting.font = ascii;
+            }
+        }
+        const szElement = XMLParser_1.XMLParser.extractBetweenTags(rPrXml, "<w:sz", "/>");
+        if (szElement) {
+            const val = XMLParser_1.XMLParser.extractAttribute(`<w:sz${szElement}`, "w:val");
+            if (val) {
+                formatting.size = parseInt(val, 10) / 2;
+            }
+        }
+        const colorElement = XMLParser_1.XMLParser.extractBetweenTags(rPrXml, "<w:color", "/>");
+        if (colorElement) {
+            const val = XMLParser_1.XMLParser.extractAttribute(`<w:color${colorElement}`, "w:val");
+            if (val && val !== "auto") {
+                formatting.color = val;
+            }
+        }
+        const highlightElement = XMLParser_1.XMLParser.extractBetweenTags(rPrXml, "<w:highlight", "/>");
+        if (highlightElement) {
+            const val = XMLParser_1.XMLParser.extractAttribute(`<w:highlight${highlightElement}`, "w:val");
+            if (val) {
+                const validHighlights = [
+                    "yellow",
+                    "green",
+                    "cyan",
+                    "magenta",
+                    "blue",
+                    "red",
+                    "darkBlue",
+                    "darkCyan",
+                    "darkGreen",
+                    "darkMagenta",
+                    "darkRed",
+                    "darkYellow",
+                    "darkGray",
+                    "lightGray",
+                    "black",
+                    "white",
+                ];
+                if (validHighlights.includes(val)) {
+                    formatting.highlight = val;
+                }
+            }
+        }
+        return formatting;
+    }
     static getRawXml(zipHandler, partName) {
         try {
             const file = zipHandler.getFile(partName);
             if (!file) {
                 return null;
             }
-            if (typeof file.content === 'string') {
+            if (typeof file.content === "string") {
                 return file.content;
             }
             if (Buffer.isBuffer(file.content)) {
-                return file.content.toString('utf8');
+                return file.content.toString("utf8");
             }
             return null;
         }
@@ -504,10 +967,12 @@ class DocumentParser {
     }
     static setRawXml(zipHandler, partName, xmlContent) {
         try {
-            if (typeof xmlContent !== 'string') {
+            if (typeof xmlContent !== "string") {
                 return false;
             }
-            zipHandler.addFile(partName, Buffer.from(xmlContent, 'utf8'), { binary: true });
+            zipHandler.addFile(partName, Buffer.from(xmlContent, "utf8"), {
+                binary: true,
+            });
             return true;
         }
         catch (error) {
@@ -516,7 +981,7 @@ class DocumentParser {
     }
     static getRelationships(zipHandler, partName) {
         try {
-            const lastSlash = partName.lastIndexOf('/');
+            const lastSlash = partName.lastIndexOf("/");
             const relsPath = lastSlash === -1
                 ? `_rels/${partName}.rels`
                 : `${partName.substring(0, lastSlash)}/_rels/${partName.substring(lastSlash + 1)}.rels`;
@@ -552,6 +1017,25 @@ class DocumentParser {
             return [];
         }
     }
+    parseNamespaces(docXml) {
+        const namespaces = {};
+        const docTagMatch = docXml.match(/<w:document([^>]+)>/);
+        if (docTagMatch && docTagMatch[1]) {
+            const attributes = docTagMatch[1];
+            const nsPattern = /xmlns:([^=]+)="([^"]+)"/g;
+            let match;
+            while ((match = nsPattern.exec(attributes)) !== null) {
+                if (match[1] && match[2]) {
+                    namespaces[match[1]] = match[2];
+                }
+            }
+            const defaultNsMatch = attributes.match(/xmlns="([^"]+)"/);
+            if (defaultNsMatch && defaultNsMatch[1]) {
+                namespaces["xmlns"] = defaultNsMatch[1];
+            }
+        }
+        return namespaces;
+    }
 }
 exports.DocumentParser = DocumentParser;
 //# sourceMappingURL=DocumentParser.js.map