docxmlater 0.30.0 → 1.0.0

package/dist/core/DocumentParser.js

@@ -1,13 +1,48 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocumentParser = void 0;
 const types_1 = require("../zip/types");
 const Paragraph_1 = require("../elements/Paragraph");
 const Run_1 = require("../elements/Run");
+const Field_1 = require("../elements/Field");
 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 ImageRun_1 = require("../elements/ImageRun");
 const Section_1 = require("../elements/Section");
 const XMLBuilder_1 = require("../xml/XMLBuilder");
 const XMLParser_1 = require("../xml/XMLParser");
@@ -286,6 +321,14 @@ class DocumentParser {
                     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;
         }
         catch (error) {
@@ -300,6 +343,11 @@ class DocumentParser {
     parseParagraphPropertiesFromObject(pPrObj, paragraph) {
         if (!pPrObj)
             return;
+        if (pPrObj["w:rPr"]) {
+            const tempRun = new Run_1.Run("");
+            this.parseRunPropertiesFromObject(pPrObj["w:rPr"], tempRun);
+            paragraph.setParagraphMarkFormatting(tempRun.getFormatting());
+        }
         if (pPrObj["w:jc"]?.["@_w:val"]) {
             paragraph.setAlignment(pPrObj["w:jc"]["@_w:val"]);
         }
@@ -341,6 +389,199 @@ class DocumentParser {
                 paragraph.setNumbering(parseInt(numId, 10), parseInt(ilvl, 10));
             }
         }
+        if (pPrObj["w:pBdr"]) {
+            const pBdr = pPrObj["w:pBdr"];
+            const borders = {};
+            const parseBorder = (borderObj) => {
+                if (!borderObj)
+                    return undefined;
+                const border = {};
+                if (borderObj["@_w:val"])
+                    border.style = borderObj["@_w:val"];
+                if (borderObj["@_w:sz"])
+                    border.size = parseInt(borderObj["@_w:sz"], 10);
+                if (borderObj["@_w:color"])
+                    border.color = borderObj["@_w:color"];
+                if (borderObj["@_w:space"])
+                    border.space = parseInt(borderObj["@_w:space"], 10);
+                return Object.keys(border).length > 0 ? border : undefined;
+            };
+            if (pBdr["w:top"])
+                borders.top = parseBorder(pBdr["w:top"]);
+            if (pBdr["w:bottom"])
+                borders.bottom = parseBorder(pBdr["w:bottom"]);
+            if (pBdr["w:left"])
+                borders.left = parseBorder(pBdr["w:left"]);
+            if (pBdr["w:right"])
+                borders.right = parseBorder(pBdr["w:right"]);
+            if (pBdr["w:between"])
+                borders.between = parseBorder(pBdr["w:between"]);
+            if (pBdr["w:bar"])
+                borders.bar = parseBorder(pBdr["w:bar"]);
+            if (Object.keys(borders).length > 0) {
+                paragraph.setBorder(borders);
+            }
+        }
+        if (pPrObj["w:shd"]) {
+            const shd = pPrObj["w:shd"];
+            const shading = {};
+            if (shd["@_w:fill"])
+                shading.fill = shd["@_w:fill"];
+            if (shd["@_w:color"])
+                shading.color = shd["@_w:color"];
+            if (shd["@_w:val"])
+                shading.val = shd["@_w:val"];
+            if (Object.keys(shading).length > 0) {
+                paragraph.setShading(shading);
+            }
+        }
+        if (pPrObj["w:tabs"]) {
+            const tabsObj = pPrObj["w:tabs"];
+            const tabs = [];
+            const tabElements = Array.isArray(tabsObj["w:tab"])
+                ? tabsObj["w:tab"]
+                : tabsObj["w:tab"] ? [tabsObj["w:tab"]] : [];
+            for (const tabObj of tabElements) {
+                const tab = {};
+                if (tabObj["@_w:pos"])
+                    tab.position = parseInt(tabObj["@_w:pos"], 10);
+                if (tabObj["@_w:val"])
+                    tab.val = tabObj["@_w:val"];
+                if (tabObj["@_w:leader"])
+                    tab.leader = tabObj["@_w:leader"];
+                if (tab.position !== undefined) {
+                    tabs.push(tab);
+                }
+            }
+            if (tabs.length > 0) {
+                paragraph.setTabs(tabs);
+            }
+        }
+        if (pPrObj["w:widowControl"] !== undefined) {
+            const widowControlVal = pPrObj["w:widowControl"]?.["@_w:val"];
+            if (widowControlVal === "0" || widowControlVal === "false" || widowControlVal === false || widowControlVal === 0) {
+                paragraph.setWidowControl(false);
+            }
+            else {
+                paragraph.setWidowControl(true);
+            }
+        }
+        if (pPrObj["w:outlineLvl"] !== undefined && pPrObj["w:outlineLvl"]["@_w:val"] !== undefined) {
+            const level = parseInt(pPrObj["w:outlineLvl"]["@_w:val"], 10);
+            if (!isNaN(level) && level >= 0 && level <= 9) {
+                paragraph.setOutlineLevel(level);
+            }
+        }
+        if (pPrObj["w:suppressLineNumbers"]) {
+            paragraph.setSuppressLineNumbers(true);
+        }
+        if (pPrObj["w:bidi"] !== undefined) {
+            const bidiVal = pPrObj["w:bidi"]?.["@_w:val"];
+            if (bidiVal === "0" || bidiVal === "false" || bidiVal === false || bidiVal === 0) {
+                paragraph.setBidi(false);
+            }
+            else {
+                paragraph.setBidi(true);
+            }
+        }
+        if (pPrObj["w:textDirection"]?.["@_w:val"]) {
+            paragraph.setTextDirection(pPrObj["w:textDirection"]["@_w:val"]);
+        }
+        if (pPrObj["w:textAlignment"]?.["@_w:val"]) {
+            paragraph.setTextAlignment(pPrObj["w:textAlignment"]["@_w:val"]);
+        }
+        if (pPrObj["w:mirrorIndents"]) {
+            paragraph.setMirrorIndents(true);
+        }
+        if (pPrObj["w:adjustRightInd"] !== undefined) {
+            const adjustRightIndVal = pPrObj["w:adjustRightInd"]?.["@_w:val"];
+            if (adjustRightIndVal === "0" || adjustRightIndVal === "false" || adjustRightIndVal === false || adjustRightIndVal === 0) {
+                paragraph.setAdjustRightInd(false);
+            }
+            else {
+                paragraph.setAdjustRightInd(true);
+            }
+        }
+        if (pPrObj["w:framePr"]) {
+            const framePr = pPrObj["w:framePr"];
+            const frameProps = {};
+            if (framePr["@_w:w"])
+                frameProps.w = parseInt(framePr["@_w:w"], 10);
+            if (framePr["@_w:h"])
+                frameProps.h = parseInt(framePr["@_w:h"], 10);
+            if (framePr["@_w:hRule"])
+                frameProps.hRule = framePr["@_w:hRule"];
+            if (framePr["@_w:x"])
+                frameProps.x = parseInt(framePr["@_w:x"], 10);
+            if (framePr["@_w:y"])
+                frameProps.y = parseInt(framePr["@_w:y"], 10);
+            if (framePr["@_w:xAlign"])
+                frameProps.xAlign = framePr["@_w:xAlign"];
+            if (framePr["@_w:yAlign"])
+                frameProps.yAlign = framePr["@_w:yAlign"];
+            if (framePr["@_w:hAnchor"])
+                frameProps.hAnchor = framePr["@_w:hAnchor"];
+            if (framePr["@_w:vAnchor"])
+                frameProps.vAnchor = framePr["@_w:vAnchor"];
+            if (framePr["@_w:hSpace"])
+                frameProps.hSpace = parseInt(framePr["@_w:hSpace"], 10);
+            if (framePr["@_w:vSpace"])
+                frameProps.vSpace = parseInt(framePr["@_w:vSpace"], 10);
+            if (framePr["@_w:wrap"])
+                frameProps.wrap = framePr["@_w:wrap"];
+            if (framePr["@_w:dropCap"])
+                frameProps.dropCap = framePr["@_w:dropCap"];
+            if (framePr["@_w:lines"])
+                frameProps.lines = parseInt(framePr["@_w:lines"], 10);
+            if (framePr["@_w:anchorLock"] !== undefined) {
+                const anchorLockVal = framePr["@_w:anchorLock"];
+                frameProps.anchorLock = (anchorLockVal === "1" || anchorLockVal === "true" || anchorLockVal === true || anchorLockVal === 1);
+            }
+            if (Object.keys(frameProps).length > 0) {
+                paragraph.setFrameProperties(frameProps);
+            }
+        }
+        if (pPrObj["w:suppressAutoHyphens"]) {
+            paragraph.setSuppressAutoHyphens(true);
+        }
+        if (pPrObj["w:suppressOverlap"]) {
+            paragraph.setSuppressOverlap(true);
+        }
+        if (pPrObj["w:textboxTightWrap"]) {
+            const wrapVal = pPrObj["w:textboxTightWrap"]?.["@_w:val"];
+            if (wrapVal) {
+                paragraph.setTextboxTightWrap(wrapVal);
+            }
+        }
+        if (pPrObj["w:divId"]) {
+            const divIdVal = pPrObj["w:divId"]?.["@_w:val"];
+            if (divIdVal) {
+                paragraph.setDivId(parseInt(divIdVal, 10));
+            }
+        }
+        if (pPrObj["w:cnfStyle"]) {
+            const cnfStyleVal = pPrObj["w:cnfStyle"]?.["@_w:val"];
+            if (cnfStyleVal !== undefined) {
+                const bitmask = String(cnfStyleVal).padStart(12, '0');
+                paragraph.setConditionalFormatting(bitmask);
+            }
+        }
+        if (pPrObj["w:pPrChange"]) {
+            const changeObj = pPrObj["w:pPrChange"];
+            const change = {};
+            if (changeObj["@_w:author"])
+                change.author = String(changeObj["@_w:author"]);
+            if (changeObj["@_w:date"])
+                change.date = String(changeObj["@_w:date"]);
+            if (changeObj["@_w:id"])
+                change.id = String(changeObj["@_w:id"]);
+            if (Object.keys(change).length > 0) {
+                paragraph.setParagraphPropertiesChange(change);
+            }
+        }
+        if (pPrObj["w:sectPr"]) {
+            paragraph.setSectionProperties(pPrObj["w:sectPr"]);
+        }
     }
     parseRunFromObject(runObj) {
         try {
@@ -401,13 +642,100 @@ class DocumentParser {
             return null;
         }
     }
+    parseSimpleFieldFromObject(fieldObj) {
+        try {
+            const instruction = fieldObj["@_w:instr"];
+            if (!instruction) {
+                return null;
+            }
+            const typeMatch = instruction.trim().match(/^(\w+)/);
+            const type = (typeMatch?.[1] || 'PAGE');
+            let formatting;
+            if (fieldObj["w:rPr"]) {
+                const tempRun = new Run_1.Run("");
+                this.parseRunPropertiesFromObject(fieldObj["w:rPr"], tempRun);
+                formatting = tempRun.getFormatting();
+            }
+            const field = Field_1.Field.create({
+                type,
+                instruction,
+                formatting,
+            });
+            return field;
+        }
+        catch (error) {
+            console.warn('[DocumentParser] Failed to parse field:', error);
+            return null;
+        }
+    }
     parseRunPropertiesFromObject(rPrObj, run) {
         if (!rPrObj)
             return;
+        if (rPrObj["w:rStyle"]) {
+            const styleId = rPrObj["w:rStyle"]["@_w:val"];
+            if (styleId) {
+                run.setCharacterStyle(styleId);
+            }
+        }
+        if (rPrObj["w:bdr"]) {
+            const bdr = rPrObj["w:bdr"];
+            const border = {};
+            if (bdr["@_w:val"])
+                border.style = bdr["@_w:val"];
+            if (bdr["@_w:sz"])
+                border.size = parseInt(bdr["@_w:sz"], 10);
+            if (bdr["@_w:color"])
+                border.color = bdr["@_w:color"];
+            if (bdr["@_w:space"])
+                border.space = parseInt(bdr["@_w:space"], 10);
+            if (Object.keys(border).length > 0) {
+                run.setBorder(border);
+            }
+        }
+        if (rPrObj["w:shd"]) {
+            const shd = rPrObj["w:shd"];
+            const shading = {};
+            if (shd["@_w:val"])
+                shading.val = shd["@_w:val"];
+            if (shd["@_w:fill"])
+                shading.fill = shd["@_w:fill"];
+            if (shd["@_w:color"])
+                shading.color = shd["@_w:color"];
+            if (Object.keys(shading).length > 0) {
+                run.setShading(shading);
+            }
+        }
+        if (rPrObj["w:em"]) {
+            const val = rPrObj["w:em"]["@_w:val"];
+            if (val)
+                run.setEmphasis(val);
+        }
+        if (rPrObj["w:outline"])
+            run.setOutline(true);
+        if (rPrObj["w:shadow"])
+            run.setShadow(true);
+        if (rPrObj["w:emboss"])
+            run.setEmboss(true);
+        if (rPrObj["w:imprint"])
+            run.setImprint(true);
+        if (rPrObj["w:noProof"])
+            run.setNoProof(true);
+        if (rPrObj["w:snapToGrid"])
+            run.setSnapToGrid(true);
+        if (rPrObj["w:vanish"])
+            run.setVanish(true);
+        if (rPrObj["w:specVanish"])
+            run.setSpecVanish(true);
+        if (rPrObj["w:rtl"])
+            run.setRTL(true);
         if (rPrObj["w:b"])
             run.setBold(true);
+        if (rPrObj["w:bCs"])
+            run.setComplexScriptBold(true);
         if (rPrObj["w:i"])
             run.setItalic(true);
+        if (rPrObj["w:iCs"])
+            run.setComplexScriptItalic(true);
         if (rPrObj["w:strike"])
             run.setStrike(true);
         if (rPrObj["w:smallCaps"])
@@ -418,6 +746,58 @@ class DocumentParser {
             const uVal = rPrObj["w:u"]["@_w:val"];
             run.setUnderline(uVal || true);
         }
+        if (rPrObj["w:spacing"]) {
+            const val = rPrObj["w:spacing"]["@_w:val"];
+            if (val)
+                run.setCharacterSpacing(parseInt(val, 10));
+        }
+        if (rPrObj["w:w"]) {
+            const val = rPrObj["w:w"]["@_w:val"];
+            if (val)
+                run.setScaling(parseInt(val, 10));
+        }
+        if (rPrObj["w:position"]) {
+            const val = rPrObj["w:position"]["@_w:val"];
+            if (val)
+                run.setPosition(parseInt(val, 10));
+        }
+        if (rPrObj["w:kern"]) {
+            const val = rPrObj["w:kern"]["@_w:val"];
+            if (val)
+                run.setKerning(parseInt(val, 10));
+        }
+        if (rPrObj["w:lang"]) {
+            const val = rPrObj["w:lang"]["@_w:val"];
+            if (val)
+                run.setLanguage(val);
+        }
+        if (rPrObj["w:eastAsianLayout"]) {
+            const layoutObj = rPrObj["w:eastAsianLayout"];
+            const layout = {};
+            if (layoutObj["@_w:id"] !== undefined)
+                layout.id = Number(layoutObj["@_w:id"]);
+            if (layoutObj["@_w:vert"])
+                layout.vert = true;
+            if (layoutObj["@_w:vertCompress"])
+                layout.vertCompress = true;
+            if (layoutObj["@_w:combine"])
+                layout.combine = true;
+            if (layoutObj["@_w:combineBrackets"])
+                layout.combineBrackets = layoutObj["@_w:combineBrackets"];
+            if (Object.keys(layout).length > 0) {
+                run.setEastAsianLayout(layout);
+            }
+        }
+        if (rPrObj["w:fitText"]) {
+            const val = rPrObj["w:fitText"]["@_w:val"];
+            if (val !== undefined)
+                run.setFitText(Number(val));
+        }
+        if (rPrObj["w:effect"]) {
+            const val = rPrObj["w:effect"]["@_w:val"];
+            if (val)
+                run.setEffect(val);
+        }
         if (rPrObj["w:vertAlign"]) {
             const val = rPrObj["w:vertAlign"]["@_w:val"];
             if (val === "subscript")
@@ -438,12 +818,235 @@ class DocumentParser {
             run.setHighlight(rPrObj["w:highlight"]["@_w:val"]);
         }
     }
-    async parseDrawingFromObject(_drawingObj, _zipHandler, _relationshipManager, _imageManager) {
-        return null;
+    async parseDrawingFromObject(drawingObj, zipHandler, relationshipManager, imageManager) {
+        try {
+            const inlineObj = drawingObj["wp:inline"];
+            const anchorObj = drawingObj["wp:anchor"];
+            const imageObj = inlineObj || anchorObj;
+            if (!imageObj) {
+                return null;
+            }
+            const isFloating = !!anchorObj;
+            const extentObj = imageObj["wp:extent"];
+            let width = 0;
+            let height = 0;
+            if (extentObj) {
+                width = parseInt(extentObj["@_cx"] || "0", 10);
+                height = parseInt(extentObj["@_cy"] || "0", 10);
+            }
+            const effectExtentObj = imageObj["wp:effectExtent"];
+            let effectExtent = undefined;
+            if (effectExtentObj) {
+                effectExtent = {
+                    left: parseInt(effectExtentObj["@_l"] || "0", 10),
+                    top: parseInt(effectExtentObj["@_t"] || "0", 10),
+                    right: parseInt(effectExtentObj["@_r"] || "0", 10),
+                    bottom: parseInt(effectExtentObj["@_b"] || "0", 10),
+                };
+            }
+            const docPrObj = imageObj["wp:docPr"];
+            let name = "image";
+            let description = "Image";
+            if (docPrObj) {
+                name = docPrObj["@_name"] || "image";
+                description = docPrObj["@_descr"] || "Image";
+            }
+            let wrap = undefined;
+            if (isFloating) {
+                wrap = this.parseWrapSettings(anchorObj);
+            }
+            let position = undefined;
+            if (isFloating) {
+                position = this.parseImagePosition(anchorObj);
+            }
+            let anchor = undefined;
+            if (isFloating && anchorObj) {
+                const toBool = (val) => val === "1" || val === 1 || val === true;
+                anchor = {
+                    behindDoc: toBool(anchorObj["@_behindDoc"]),
+                    locked: toBool(anchorObj["@_locked"]),
+                    layoutInCell: toBool(anchorObj["@_layoutInCell"]),
+                    allowOverlap: toBool(anchorObj["@_allowOverlap"]),
+                    relativeHeight: parseInt(anchorObj["@_relativeHeight"] || "251658240", 10),
+                };
+            }
+            const graphicObj = imageObj["a:graphic"];
+            if (!graphicObj) {
+                return null;
+            }
+            const graphicDataObj = graphicObj["a:graphicData"];
+            if (!graphicDataObj) {
+                return null;
+            }
+            const picPicObj = graphicDataObj["pic:pic"];
+            if (!picPicObj) {
+                return null;
+            }
+            const blipFillObj = picPicObj["pic:blipFill"];
+            if (!blipFillObj) {
+                return null;
+            }
+            const blipObj = blipFillObj["a:blip"];
+            if (!blipObj) {
+                return null;
+            }
+            const crop = this.parseImageCrop(blipObj);
+            const effects = this.parseImageEffects(blipObj);
+            const relationshipId = blipObj["@_r:embed"];
+            if (!relationshipId) {
+                return null;
+            }
+            const relationship = relationshipManager.getRelationship(relationshipId);
+            if (!relationship) {
+                console.warn(`[DocumentParser] Image relationship not found: ${relationshipId}`);
+                return null;
+            }
+            const imageTarget = relationship.getTarget();
+            if (!imageTarget) {
+                console.warn(`[DocumentParser] Image relationship has no target: ${relationshipId}`);
+                return null;
+            }
+            const imagePath = `word/${imageTarget}`;
+            const imageData = zipHandler.getFileAsBuffer(imagePath);
+            if (!imageData) {
+                console.warn(`[DocumentParser] Image file not found: ${imagePath}`);
+                return null;
+            }
+            const extension = imagePath.split('.').pop()?.toLowerCase() || 'png';
+            const { Image: ImageClass } = await Promise.resolve().then(() => __importStar(require('../elements/Image')));
+            const image = await ImageClass.create({
+                source: imageData,
+                width,
+                height,
+                name,
+                description,
+                effectExtent,
+                wrap,
+                position,
+                anchor,
+                crop,
+                effects,
+            });
+            imageManager.registerImage(image, relationshipId);
+            image.setRelationshipId(relationshipId);
+            return new ImageRun_1.ImageRun(image);
+        }
+        catch (error) {
+            console.warn('[DocumentParser] Failed to parse drawing:', error);
+            return null;
+        }
+    }
+    parseWrapSettings(anchorObj) {
+        const wrapSquare = anchorObj["wp:wrapSquare"];
+        const wrapTight = anchorObj["wp:wrapTight"];
+        const wrapThrough = anchorObj["wp:wrapThrough"];
+        const wrapTopBottom = anchorObj["wp:wrapTopAndBottom"];
+        const wrapNone = anchorObj["wp:wrapNone"];
+        const wrapObj = wrapSquare || wrapTight || wrapThrough || wrapTopBottom || wrapNone;
+        if (!wrapObj) {
+            return undefined;
+        }
+        let type = 'square';
+        if (wrapTight)
+            type = 'tight';
+        else if (wrapThrough)
+            type = 'through';
+        else if (wrapTopBottom)
+            type = 'topAndBottom';
+        else if (wrapNone)
+            type = 'none';
+        return {
+            type,
+            side: wrapObj["@_wrapText"] || 'bothSides',
+            distanceTop: anchorObj["@_distT"] ? parseInt(anchorObj["@_distT"], 10) : undefined,
+            distanceBottom: anchorObj["@_distB"] ? parseInt(anchorObj["@_distB"], 10) : undefined,
+            distanceLeft: anchorObj["@_distL"] ? parseInt(anchorObj["@_distL"], 10) : undefined,
+            distanceRight: anchorObj["@_distR"] ? parseInt(anchorObj["@_distR"], 10) : undefined,
+        };
+    }
+    parseImagePosition(anchorObj) {
+        const posH = anchorObj["wp:positionH"];
+        const posV = anchorObj["wp:positionV"];
+        if (!posH || !posV) {
+            return undefined;
+        }
+        const horizontal = {
+            anchor: posH["@_relativeFrom"] || 'page',
+        };
+        if (posH["wp:posOffset"]) {
+            const offsetText = Array.isArray(posH["wp:posOffset"])
+                ? posH["wp:posOffset"][0]
+                : posH["wp:posOffset"];
+            horizontal.offset = parseInt(typeof offsetText === 'string' ? offsetText : offsetText?.["#text"] || "0", 10);
+        }
+        else if (posH["wp:align"]) {
+            const alignText = Array.isArray(posH["wp:align"])
+                ? posH["wp:align"][0]
+                : posH["wp:align"];
+            horizontal.alignment = typeof alignText === 'string' ? alignText : alignText?.["#text"];
+        }
+        const vertical = {
+            anchor: posV["@_relativeFrom"] || 'page',
+        };
+        if (posV["wp:posOffset"]) {
+            const offsetText = Array.isArray(posV["wp:posOffset"])
+                ? posV["wp:posOffset"][0]
+                : posV["wp:posOffset"];
+            vertical.offset = parseInt(typeof offsetText === 'string' ? offsetText : offsetText?.["#text"] || "0", 10);
+        }
+        else if (posV["wp:align"]) {
+            const alignText = Array.isArray(posV["wp:align"])
+                ? posV["wp:align"][0]
+                : posV["wp:align"];
+            vertical.alignment = typeof alignText === 'string' ? alignText : alignText?.["#text"];
+        }
+        return { horizontal, vertical };
+    }
+    parseImageCrop(blipObj) {
+        const srcRect = blipObj["a:srcRect"];
+        if (!srcRect) {
+            return undefined;
+        }
+        return {
+            left: parseInt(srcRect["@_l"] || "0", 10) / 1000,
+            top: parseInt(srcRect["@_t"] || "0", 10) / 1000,
+            right: parseInt(srcRect["@_r"] || "0", 10) / 1000,
+            bottom: parseInt(srcRect["@_b"] || "0", 10) / 1000,
+        };
+    }
+    parseImageEffects(blipObj) {
+        const effects = {};
+        const lum = blipObj["a:lum"];
+        if (lum) {
+            if (lum["@_bright"]) {
+                effects.brightness = parseInt(lum["@_bright"], 10) / 1000;
+            }
+            if (lum["@_contrast"]) {
+                effects.contrast = parseInt(lum["@_contrast"], 10) / 1000;
+            }
+        }
+        if (blipObj["a:grayscl"]) {
+            effects.grayscale = true;
+        }
+        return Object.keys(effects).length > 0 ? effects : undefined;
     }
     async parseTableFromObject(tableObj, relationshipManager, zipHandler, imageManager) {
         try {
             const table = new Table_1.Table();
+            if (tableObj["w:tblPr"]) {
+                this.parseTablePropertiesFromObject(tableObj["w:tblPr"], table);
+            }
+            if (tableObj["w:tblGrid"] && tableObj["w:tblGrid"]["w:gridCol"]) {
+                const gridCols = tableObj["w:tblGrid"]["w:gridCol"];
+                const gridColArray = Array.isArray(gridCols) ? gridCols : [gridCols];
+                const widths = gridColArray.map((col) => {
+                    const w = col["@_w:w"];
+                    return w ? parseInt(w, 10) : 2880;
+                });
+                if (widths.length > 0) {
+                    table.setTableGrid(widths);
+                }
+            }
             const rows = tableObj["w:tr"];
             const rowChildren = Array.isArray(rows) ? rows : (rows ? [rows] : []);
             for (const rowObj of rowChildren) {
@@ -459,9 +1062,84 @@ class DocumentParser {
             return null;
         }
     }
+    parseTablePropertiesFromObject(tblPrObj, table) {
+        if (!tblPrObj)
+            return;
+        if (tblPrObj["w:tblpPr"]) {
+            const tblpPr = tblPrObj["w:tblpPr"];
+            const position = {};
+            if (tblpPr["@_w:tblpX"])
+                position.x = parseInt(tblpPr["@_w:tblpX"], 10);
+            if (tblpPr["@_w:tblpY"])
+                position.y = parseInt(tblpPr["@_w:tblpY"], 10);
+            if (tblpPr["@_w:tblpXSpec"])
+                position.horizontalAnchor = tblpPr["@_w:tblpXSpec"];
+            if (tblpPr["@_w:tblpYSpec"])
+                position.verticalAnchor = tblpPr["@_w:tblpYSpec"];
+            if (tblpPr["@_w:tblpXAlign"])
+                position.horizontalAlignment = tblpPr["@_w:tblpXAlign"];
+            if (tblpPr["@_w:tblpYAlign"])
+                position.verticalAlignment = tblpPr["@_w:tblpYAlign"];
+            if (tblpPr["@_w:leftFromText"])
+                position.leftFromText = parseInt(tblpPr["@_w:leftFromText"], 10);
+            if (tblpPr["@_w:rightFromText"])
+                position.rightFromText = parseInt(tblpPr["@_w:rightFromText"], 10);
+            if (tblpPr["@_w:topFromText"])
+                position.topFromText = parseInt(tblpPr["@_w:topFromText"], 10);
+            if (tblpPr["@_w:bottomFromText"])
+                position.bottomFromText = parseInt(tblpPr["@_w:bottomFromText"], 10);
+            if (Object.keys(position).length > 0) {
+                table.setPosition(position);
+            }
+        }
+        if (tblPrObj["w:tblOverlap"]) {
+            const val = tblPrObj["w:tblOverlap"]["@_w:val"];
+            table.setOverlap(val === "overlap");
+        }
+        if (tblPrObj["w:bidiVisual"]) {
+            table.setBidiVisual(true);
+        }
+        if (tblPrObj["w:tblW"]) {
+            const width = parseInt(tblPrObj["w:tblW"]["@_w:w"] || "0", 10);
+            const widthType = tblPrObj["w:tblW"]["@_w:type"] || "dxa";
+            if (width > 0) {
+                table.setWidth(width);
+                table.setWidthType(widthType);
+            }
+        }
+        if (tblPrObj["w:tblCaption"]) {
+            const caption = tblPrObj["w:tblCaption"]["@_w:val"];
+            if (caption)
+                table.setCaption(caption);
+        }
+        if (tblPrObj["w:tblDescription"]) {
+            const description = tblPrObj["w:tblDescription"]["@_w:val"];
+            if (description)
+                table.setDescription(description);
+        }
+        if (tblPrObj["w:tblCellSpacing"]) {
+            const spacing = parseInt(tblPrObj["w:tblCellSpacing"]["@_w:w"] || "0", 10);
+            const spacingType = tblPrObj["w:tblCellSpacing"]["@_w:type"] || "dxa";
+            if (spacing > 0) {
+                table.setCellSpacing(spacing);
+                table.setCellSpacingType(spacingType);
+            }
+        }
+    }
     async parseTableRowFromObject(rowObj, relationshipManager, zipHandler, imageManager) {
         try {
             const row = new TableRow_1.TableRow();
+            const trPr = rowObj["w:trPr"];
+            if (trPr) {
+                this.parseTableRowPropertiesFromObject(trPr, row);
+            }
+            const tblPrEx = rowObj["w:tblPrEx"];
+            if (tblPrEx) {
+                const exceptions = this.parseTablePropertyExceptionsFromObject(tblPrEx);
+                if (exceptions) {
+                    row.setTablePropertyExceptions(exceptions);
+                }
+            }
             const cells = rowObj["w:tc"];
             const cellChildren = Array.isArray(cells) ? cells : (cells ? [cells] : []);
             for (const cellObj of cellChildren) {
@@ -477,9 +1155,218 @@ class DocumentParser {
             return null;
         }
     }
+    parseTableRowPropertiesFromObject(trPrObj, row) {
+        if (!trPrObj)
+            return;
+        if (trPrObj["w:trHeight"]) {
+            const heightVal = parseInt(trPrObj["w:trHeight"]["@_w:val"] || "0", 10);
+            const heightRule = trPrObj["w:trHeight"]["@_w:hRule"] || "atLeast";
+            if (heightVal > 0) {
+                row.setHeight(heightVal, heightRule);
+            }
+        }
+        if (trPrObj["w:tblHeader"]) {
+            row.setHeader(true);
+        }
+        if (trPrObj["w:cantSplit"]) {
+            row.setCantSplit(true);
+        }
+        if (trPrObj["w:jc"]) {
+            const val = trPrObj["w:jc"]["@_w:val"];
+            if (val) {
+                row.setJustification(val);
+            }
+        }
+        if (trPrObj["w:hidden"]) {
+            row.setHidden(true);
+        }
+        if (trPrObj["w:gridBefore"]) {
+            const val = parseInt(trPrObj["w:gridBefore"]["@_w:val"] || "0", 10);
+            if (val > 0) {
+                row.setGridBefore(val);
+            }
+        }
+        if (trPrObj["w:gridAfter"]) {
+            const val = parseInt(trPrObj["w:gridAfter"]["@_w:val"] || "0", 10);
+            if (val > 0) {
+                row.setGridAfter(val);
+            }
+        }
+    }
+    parseTablePropertyExceptionsFromObject(tblPrExObj) {
+        if (!tblPrExObj)
+            return undefined;
+        const exceptions = {};
+        if (tblPrExObj["w:tblW"]) {
+            const widthVal = parseInt(tblPrExObj["w:tblW"]["@_w:w"] || "0", 10);
+            if (widthVal > 0) {
+                exceptions.width = widthVal;
+            }
+        }
+        if (tblPrExObj["w:jc"]) {
+            const val = tblPrExObj["w:jc"]["@_w:val"];
+            if (val) {
+                exceptions.justification = val;
+            }
+        }
+        if (tblPrExObj["w:tblCellSpacing"]) {
+            const val = parseInt(tblPrExObj["w:tblCellSpacing"]["@_w:w"] || "0", 10);
+            if (val > 0) {
+                exceptions.cellSpacing = val;
+            }
+        }
+        if (tblPrExObj["w:tblInd"]) {
+            const val = parseInt(tblPrExObj["w:tblInd"]["@_w:w"] || "0", 10);
+            if (val > 0) {
+                exceptions.indentation = val;
+            }
+        }
+        if (tblPrExObj["w:tblBorders"]) {
+            exceptions.borders = this.parseTableBordersFromObject(tblPrExObj["w:tblBorders"]);
+        }
+        if (tblPrExObj["w:shd"]) {
+            const shdObj = tblPrExObj["w:shd"];
+            exceptions.shading = {};
+            if (shdObj["@_w:fill"])
+                exceptions.shading.fill = shdObj["@_w:fill"];
+            if (shdObj["@_w:color"])
+                exceptions.shading.color = shdObj["@_w:color"];
+            if (shdObj["@_w:val"])
+                exceptions.shading.pattern = shdObj["@_w:val"];
+        }
+        return Object.keys(exceptions).length > 0 ? exceptions : undefined;
+    }
+    parseTableBordersFromObject(bordersObj) {
+        if (!bordersObj)
+            return undefined;
+        const borders = {};
+        const borderNames = ['top', 'bottom', 'left', 'right', 'insideH', 'insideV'];
+        for (const name of borderNames) {
+            const borderKey = `w:${name}`;
+            if (bordersObj[borderKey]) {
+                const borderObj = bordersObj[borderKey];
+                borders[name] = {};
+                if (borderObj["@_w:val"])
+                    borders[name].style = borderObj["@_w:val"];
+                if (borderObj["@_w:sz"])
+                    borders[name].size = parseInt(borderObj["@_w:sz"], 10);
+                if (borderObj["@_w:space"])
+                    borders[name].space = parseInt(borderObj["@_w:space"], 10);
+                if (borderObj["@_w:color"])
+                    borders[name].color = borderObj["@_w:color"];
+            }
+        }
+        return Object.keys(borders).length > 0 ? borders : undefined;
+    }
     async parseTableCellFromObject(cellObj, relationshipManager, zipHandler, imageManager) {
         try {
             const cell = new TableCell_1.TableCell();
+            const tcPr = cellObj["w:tcPr"];
+            if (tcPr) {
+                if (tcPr["w:tcW"]) {
+                    const widthVal = parseInt(tcPr["w:tcW"]["@_w:w"] || "0", 10);
+                    const widthType = tcPr["w:tcW"]["@_w:type"] || "dxa";
+                    if (widthVal > 0 || widthType === "auto") {
+                        cell.setWidthType(widthVal, widthType);
+                    }
+                }
+                if (tcPr["w:cnfStyle"]) {
+                    const cnfStyle = tcPr["w:cnfStyle"]["@_w:val"];
+                    if (cnfStyle) {
+                        cell.setConditionalStyle(cnfStyle);
+                    }
+                }
+                if (tcPr["w:tcBorders"]) {
+                    const bordersObj = tcPr["w:tcBorders"];
+                    const borders = {};
+                    const parseBorder = (borderObj) => {
+                        if (!borderObj)
+                            return undefined;
+                        return {
+                            style: borderObj["@_w:val"] || "single",
+                            size: borderObj["@_w:sz"] ? parseInt(borderObj["@_w:sz"], 10) : undefined,
+                            color: borderObj["@_w:color"] || undefined,
+                        };
+                    };
+                    if (bordersObj["w:top"])
+                        borders.top = parseBorder(bordersObj["w:top"]);
+                    if (bordersObj["w:bottom"])
+                        borders.bottom = parseBorder(bordersObj["w:bottom"]);
+                    if (bordersObj["w:left"])
+                        borders.left = parseBorder(bordersObj["w:left"]);
+                    if (bordersObj["w:right"])
+                        borders.right = parseBorder(bordersObj["w:right"]);
+                    if (Object.keys(borders).length > 0) {
+                        cell.setBorders(borders);
+                    }
+                }
+                if (tcPr["w:shd"]) {
+                    const shd = tcPr["w:shd"];
+                    const shading = {};
+                    if (shd["@_w:fill"])
+                        shading.fill = shd["@_w:fill"];
+                    if (shd["@_w:color"])
+                        shading.color = shd["@_w:color"];
+                    if (Object.keys(shading).length > 0) {
+                        cell.setShading(shading);
+                    }
+                }
+                if (tcPr["w:tcMar"]) {
+                    const tcMar = tcPr["w:tcMar"];
+                    const margins = {};
+                    if (tcMar["w:top"]) {
+                        margins.top = parseInt(tcMar["w:top"]["@_w:w"] || "0", 10);
+                    }
+                    if (tcMar["w:bottom"]) {
+                        margins.bottom = parseInt(tcMar["w:bottom"]["@_w:w"] || "0", 10);
+                    }
+                    if (tcMar["w:left"]) {
+                        margins.left = parseInt(tcMar["w:left"]["@_w:w"] || "0", 10);
+                    }
+                    if (tcMar["w:right"]) {
+                        margins.right = parseInt(tcMar["w:right"]["@_w:w"] || "0", 10);
+                    }
+                    if (Object.keys(margins).length > 0) {
+                        cell.setMargins(margins);
+                    }
+                }
+                if (tcPr["w:vAlign"]) {
+                    const valign = tcPr["w:vAlign"]["@_w:val"];
+                    if (valign && (valign === "top" || valign === "center" || valign === "bottom")) {
+                        cell.setVerticalAlignment(valign);
+                    }
+                }
+                if (tcPr["w:gridSpan"]) {
+                    const span = parseInt(tcPr["w:gridSpan"]["@_w:val"] || "1", 10);
+                    if (span > 1) {
+                        cell.setColumnSpan(span);
+                    }
+                }
+                if (tcPr["w:textDirection"]) {
+                    const direction = tcPr["w:textDirection"]["@_w:val"];
+                    if (direction) {
+                        cell.setTextDirection(direction);
+                    }
+                }
+                if (tcPr["w:noWrap"]) {
+                    cell.setNoWrap(true);
+                }
+                if (tcPr["w:hideMark"]) {
+                    cell.setHideMark(true);
+                }
+                if (tcPr["w:tcFitText"]) {
+                    cell.setFitText(true);
+                }
+                if (tcPr["w:vMerge"]) {
+                    const vMergeVal = tcPr["w:vMerge"]["@_w:val"];
+                    if (vMergeVal === "restart") {
+                        cell.setVerticalMerge("restart");
+                    }
+                    else {
+                        cell.setVerticalMerge("continue");
+                    }
+                }
+            }
             const paragraphs = cellObj["w:p"];
             const paraChildren = Array.isArray(paragraphs) ? paragraphs : (paragraphs ? [paragraphs] : []);
             for (const paraObj of paraChildren) {
@@ -507,36 +1394,86 @@ class DocumentParser {
         return relationshipManager;
     }
     parseProperties(zipHandler) {
-        const coreXml = zipHandler.getFileAsString(types_1.DOCX_PATHS.CORE_PROPS);
-        if (!coreXml) {
-            return {};
-        }
         const extractTag = (xml, tag) => {
             const tagContent = XMLParser_1.XMLParser.extractBetweenTags(xml, `<${tag}`, `</${tag}>`);
             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"),
-        };
-        const revisionStr = extractTag(coreXml, "cp:revision");
-        if (revisionStr) {
-            properties.revision = parseInt(revisionStr, 10);
+        const properties = {};
+        const coreXml = zipHandler.getFileAsString(types_1.DOCX_PATHS.CORE_PROPS);
+        if (coreXml) {
+            properties.title = extractTag(coreXml, "dc:title");
+            properties.subject = extractTag(coreXml, "dc:subject");
+            properties.creator = extractTag(coreXml, "dc:creator");
+            properties.keywords = extractTag(coreXml, "cp:keywords");
+            properties.description = extractTag(coreXml, "dc:description");
+            properties.lastModifiedBy = extractTag(coreXml, "cp:lastModifiedBy");
+            properties.category = extractTag(coreXml, "cp:category");
+            properties.contentStatus = extractTag(coreXml, "cp:contentStatus");
+            properties.language = extractTag(coreXml, "dc:language");
+            const revisionStr = extractTag(coreXml, "cp:revision");
+            if (revisionStr) {
+                properties.revision = parseInt(revisionStr, 10);
+            }
+            const createdStr = extractTag(coreXml, "dcterms:created");
+            if (createdStr) {
+                properties.created = new Date(createdStr);
+            }
+            const modifiedStr = extractTag(coreXml, "dcterms:modified");
+            if (modifiedStr) {
+                properties.modified = new Date(modifiedStr);
+            }
         }
-        const createdStr = extractTag(coreXml, "dcterms:created");
-        if (createdStr) {
-            properties.created = new Date(createdStr);
+        const appXml = zipHandler.getFileAsString(types_1.DOCX_PATHS.APP_PROPS);
+        if (appXml) {
+            properties.application = extractTag(appXml, "Application");
+            properties.appVersion = extractTag(appXml, "AppVersion");
+            properties.company = extractTag(appXml, "Company");
+            properties.manager = extractTag(appXml, "Manager");
+            if (!properties.appVersion) {
+                properties.version = extractTag(appXml, "Version");
+            }
         }
-        const modifiedStr = extractTag(coreXml, "dcterms:modified");
-        if (modifiedStr) {
-            properties.modified = new Date(modifiedStr);
+        const customXml = zipHandler.getFileAsString("docProps/custom.xml");
+        if (customXml) {
+            properties.customProperties = this.parseCustomProperties(customXml);
         }
         return properties;
     }
+    parseCustomProperties(xml) {
+        const customProps = {};
+        const propertyElements = XMLParser_1.XMLParser.extractElements(xml, "property");
+        for (const propXml of propertyElements) {
+            const nameMatch = propXml.match(/name="([^"]+)"/);
+            if (!nameMatch || !nameMatch[1])
+                continue;
+            const name = XMLBuilder_1.XMLBuilder.unescapeXml(nameMatch[1]);
+            if (propXml.includes("<vt:lpwstr>")) {
+                const value = XMLParser_1.XMLParser.extractBetweenTags(propXml, "<vt:lpwstr>", "</vt:lpwstr>");
+                if (value !== undefined) {
+                    customProps[name] = XMLBuilder_1.XMLBuilder.unescapeXml(value);
+                }
+            }
+            else if (propXml.includes("<vt:r8>")) {
+                const value = XMLParser_1.XMLParser.extractBetweenTags(propXml, "<vt:r8>", "</vt:r8>");
+                if (value !== undefined) {
+                    customProps[name] = parseFloat(value);
+                }
+            }
+            else if (propXml.includes("<vt:bool>")) {
+                const value = XMLParser_1.XMLParser.extractBetweenTags(propXml, "<vt:bool>", "</vt:bool>");
+                if (value !== undefined) {
+                    customProps[name] = value === "true";
+                }
+            }
+            else if (propXml.includes("<vt:filetime>")) {
+                const value = XMLParser_1.XMLParser.extractBetweenTags(propXml, "<vt:filetime>", "</vt:filetime>");
+                if (value !== undefined) {
+                    customProps[name] = new Date(value);
+                }
+            }
+        }
+        return customProps;
+    }
     parseStyles(zipHandler) {
         const styles = [];
         const stylesXml = zipHandler.getFileAsString(types_1.DOCX_PATHS.STYLES);
@@ -682,11 +1619,23 @@ class DocumentParser {
                     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");
+                    const sep = XMLParser_1.XMLParser.extractAttribute(cols, "w:sep");
+                    const colElements = XMLParser_1.XMLParser.extractElements(cols, "w:col");
+                    const columnWidths = [];
+                    for (const col of colElements) {
+                        const width = XMLParser_1.XMLParser.extractAttribute(col, "w:w");
+                        if (width) {
+                            columnWidths.push(parseInt(width.toString(), 10));
+                        }
+                    }
+                    const toBool = (val) => val === "1" || val === 1 || val === "true" || val === true;
                     if (num) {
                         sectionProps.columns = {
-                            count: parseInt(num, 10),
-                            space: space ? parseInt(space, 10) : undefined,
-                            equalWidth: equalWidth === "1" || equalWidth === "true",
+                            count: parseInt(num.toString(), 10),
+                            space: space ? parseInt(space.toString(), 10) : undefined,
+                            equalWidth: equalWidth ? toBool(equalWidth) : undefined,
+                            separator: sep ? toBool(sep) : undefined,
+                            columnWidths: columnWidths.length > 0 ? columnWidths : undefined,
                         };
                     }
                 }
@@ -748,6 +1697,40 @@ class DocumentParser {
                     }
                 }
             }
+            const vAlignElements = XMLParser_1.XMLParser.extractElements(sectPr, "w:vAlign");
+            if (vAlignElements.length > 0) {
+                const vAlign = vAlignElements[0];
+                if (vAlign) {
+                    const val = XMLParser_1.XMLParser.extractAttribute(vAlign, "w:val");
+                    if (val) {
+                        sectionProps.verticalAlignment = val;
+                    }
+                }
+            }
+            const paperSrcElements = XMLParser_1.XMLParser.extractElements(sectPr, "w:paperSrc");
+            if (paperSrcElements.length > 0) {
+                const paperSrc = paperSrcElements[0];
+                if (paperSrc) {
+                    const first = XMLParser_1.XMLParser.extractAttribute(paperSrc, "w:first");
+                    const other = XMLParser_1.XMLParser.extractAttribute(paperSrc, "w:other");
+                    if (first || other) {
+                        sectionProps.paperSource = {
+                            first: first ? parseInt(first.toString(), 10) : undefined,
+                            other: other ? parseInt(other.toString(), 10) : undefined,
+                        };
+                    }
+                }
+            }
+            const textDirElements = XMLParser_1.XMLParser.extractElements(sectPr, "w:textDirection");
+            if (textDirElements.length > 0) {
+                const textDir = textDirElements[0];
+                if (textDir) {
+                    const val = XMLParser_1.XMLParser.extractAttribute(textDir, "w:val");
+                    if (val) {
+                        sectionProps.textDirection = val;
+                    }
+                }
+            }
             return new Section_1.Section(sectionProps);
         }
         catch (error) {
@@ -789,6 +1772,46 @@ class DocumentParser {
         if (rPrXml) {
             runFormatting = this.parseRunFormattingFromXml(rPrXml);
         }
+        const qFormat = styleXml.includes("<w:qFormat/>") || styleXml.includes("<w:qFormat ");
+        const semiHidden = styleXml.includes("<w:semiHidden/>") || styleXml.includes("<w:semiHidden ");
+        const unhideWhenUsed = styleXml.includes("<w:unhideWhenUsed/>") || styleXml.includes("<w:unhideWhenUsed ");
+        const locked = styleXml.includes("<w:locked/>") || styleXml.includes("<w:locked ");
+        const personal = styleXml.includes("<w:personal/>") || styleXml.includes("<w:personal ");
+        const autoRedefine = styleXml.includes("<w:autoRedefine/>") || styleXml.includes("<w:autoRedefine ");
+        let uiPriority;
+        if (styleXml.includes("<w:uiPriority")) {
+            const uiPriorityStart = styleXml.indexOf("<w:uiPriority");
+            const uiPriorityEnd = styleXml.indexOf("/>", uiPriorityStart);
+            if (uiPriorityEnd !== -1) {
+                const uiPriorityTag = styleXml.substring(uiPriorityStart, uiPriorityEnd + 2);
+                const valStr = XMLParser_1.XMLParser.extractAttribute(uiPriorityTag, "w:val");
+                if (valStr) {
+                    uiPriority = parseInt(valStr, 10);
+                }
+            }
+        }
+        let link;
+        if (styleXml.includes("<w:link")) {
+            const linkStart = styleXml.indexOf("<w:link");
+            const linkEnd = styleXml.indexOf("/>", linkStart);
+            if (linkEnd !== -1) {
+                const linkTag = styleXml.substring(linkStart, linkEnd + 2);
+                link = XMLParser_1.XMLParser.extractAttribute(linkTag, "w:val") || undefined;
+            }
+        }
+        let aliases;
+        if (styleXml.includes("<w:aliases")) {
+            const aliasesStart = styleXml.indexOf("<w:aliases");
+            const aliasesEnd = styleXml.indexOf("/>", aliasesStart);
+            if (aliasesEnd !== -1) {
+                const aliasesTag = styleXml.substring(aliasesStart, aliasesEnd + 2);
+                aliases = XMLParser_1.XMLParser.extractAttribute(aliasesTag, "w:val") || undefined;
+            }
+        }
+        let tableStyle;
+        if (typeAttr === 'table') {
+            tableStyle = this.parseTableStyleProperties(styleXml);
+        }
         const properties = {
             styleId,
             name,
@@ -799,6 +1822,16 @@ class DocumentParser {
             customStyle: customStyleAttr === "1" || customStyleAttr === "true",
             paragraphFormatting,
             runFormatting,
+            tableStyle,
+            qFormat: qFormat || undefined,
+            semiHidden: semiHidden || undefined,
+            unhideWhenUsed: unhideWhenUsed || undefined,
+            locked: locked || undefined,
+            personal: personal || undefined,
+            autoRedefine: autoRedefine || undefined,
+            uiPriority,
+            link,
+            aliases,
         };
         return Style_1.Style.create(properties);
     }
@@ -873,7 +1906,7 @@ class DocumentParser {
         if (rPrXml.includes("<w:caps/>") || rPrXml.includes("<w:caps ")) {
             formatting.allCaps = true;
         }
-        const uElement = XMLParser_1.XMLParser.extractBetweenTags(rPrXml, "<w:u", "/>");
+        const uElement = XMLParser_1.XMLParser.extractSelfClosingTag(rPrXml, "w:u");
         if (uElement) {
             const uVal = XMLParser_1.XMLParser.extractAttribute(`<w:u${uElement}`, "w:val");
             if (uVal === "single" ||
@@ -887,7 +1920,7 @@ class DocumentParser {
                 formatting.underline = true;
             }
         }
-        const vertAlignElement = XMLParser_1.XMLParser.extractBetweenTags(rPrXml, "<w:vertAlign", "/>");
+        const vertAlignElement = XMLParser_1.XMLParser.extractSelfClosingTag(rPrXml, "w:vertAlign");
         if (vertAlignElement) {
             const val = XMLParser_1.XMLParser.extractAttribute(`<w:vertAlign${vertAlignElement}`, "w:val");
             if (val === "subscript") {
@@ -897,28 +1930,28 @@ class DocumentParser {
                 formatting.superscript = true;
             }
         }
-        const rFontsElement = XMLParser_1.XMLParser.extractBetweenTags(rPrXml, "<w:rFonts", "/>");
+        const rFontsElement = XMLParser_1.XMLParser.extractSelfClosingTag(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", "/>");
+        const szElement = XMLParser_1.XMLParser.extractSelfClosingTag(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", "/>");
+        const colorElement = XMLParser_1.XMLParser.extractSelfClosingTag(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", "/>");
+        const highlightElement = XMLParser_1.XMLParser.extractSelfClosingTag(rPrXml, "w:highlight");
         if (highlightElement) {
             const val = XMLParser_1.XMLParser.extractAttribute(`<w:highlight${highlightElement}`, "w:val");
             if (val) {
@@ -947,6 +1980,258 @@ class DocumentParser {
         }
         return formatting;
     }
+    parseTableStyleProperties(styleXml) {
+        const tableStyle = {};
+        const tblPrXml = XMLParser_1.XMLParser.extractBetweenTags(styleXml, "<w:tblPr>", "</w:tblPr>");
+        if (tblPrXml) {
+            tableStyle.table = this.parseTableFormattingFromXml(tblPrXml);
+            if (tblPrXml.includes("<w:tblStyleRowBandSize")) {
+                const tag = XMLParser_1.XMLParser.extractSelfClosingTag(tblPrXml, "w:tblStyleRowBandSize");
+                if (tag) {
+                    const val = XMLParser_1.XMLParser.extractAttribute(`<w:tblStyleRowBandSize${tag}`, "w:val");
+                    if (val) {
+                        tableStyle.rowBandSize = parseInt(val, 10);
+                    }
+                }
+            }
+            if (tblPrXml.includes("<w:tblStyleColBandSize")) {
+                const tag = XMLParser_1.XMLParser.extractSelfClosingTag(tblPrXml, "w:tblStyleColBandSize");
+                if (tag) {
+                    const val = XMLParser_1.XMLParser.extractAttribute(`<w:tblStyleColBandSize${tag}`, "w:val");
+                    if (val) {
+                        tableStyle.colBandSize = parseInt(val, 10);
+                    }
+                }
+            }
+        }
+        const tcPrXml = XMLParser_1.XMLParser.extractBetweenTags(styleXml, "<w:tcPr>", "</w:tcPr>");
+        if (tcPrXml) {
+            tableStyle.cell = this.parseTableCellFormattingFromXml(tcPrXml);
+        }
+        const trPrXml = XMLParser_1.XMLParser.extractBetweenTags(styleXml, "<w:trPr>", "</w:trPr>");
+        if (trPrXml) {
+            tableStyle.row = this.parseTableRowFormattingFromXml(trPrXml);
+        }
+        tableStyle.conditionalFormatting = this.parseConditionalFormattingFromXml(styleXml);
+        return tableStyle;
+    }
+    parseTableFormattingFromXml(tblPrXml) {
+        const formatting = {};
+        if (tblPrXml.includes("<w:tblInd")) {
+            const tag = XMLParser_1.XMLParser.extractSelfClosingTag(tblPrXml, "w:tblInd");
+            if (tag) {
+                const w = XMLParser_1.XMLParser.extractAttribute(`<w:tblInd${tag}`, "w:w");
+                if (w) {
+                    formatting.indent = parseInt(w, 10);
+                }
+            }
+        }
+        if (tblPrXml.includes("<w:jc")) {
+            const tag = XMLParser_1.XMLParser.extractSelfClosingTag(tblPrXml, "w:jc");
+            if (tag) {
+                const val = XMLParser_1.XMLParser.extractAttribute(`<w:jc${tag}`, "w:val");
+                if (val === 'left' || val === 'center' || val === 'right') {
+                    formatting.alignment = val;
+                }
+            }
+        }
+        if (tblPrXml.includes("<w:tblCellSpacing")) {
+            const tag = XMLParser_1.XMLParser.extractSelfClosingTag(tblPrXml, "w:tblCellSpacing");
+            if (tag) {
+                const w = XMLParser_1.XMLParser.extractAttribute(`<w:tblCellSpacing${tag}`, "w:w");
+                if (w) {
+                    formatting.cellSpacing = parseInt(w, 10);
+                }
+            }
+        }
+        const bordersXml = XMLParser_1.XMLParser.extractBetweenTags(tblPrXml, "<w:tblBorders>", "</w:tblBorders>");
+        if (bordersXml) {
+            formatting.borders = this.parseBordersFromXml(bordersXml, false);
+        }
+        if (tblPrXml.includes("<w:shd")) {
+            formatting.shading = this.parseShadingFromXml(tblPrXml);
+        }
+        const marginXml = XMLParser_1.XMLParser.extractBetweenTags(tblPrXml, "<w:tblCellMar>", "</w:tblCellMar>");
+        if (marginXml) {
+            formatting.cellMargins = this.parseCellMarginsFromXml(marginXml);
+        }
+        return formatting;
+    }
+    parseTableCellFormattingFromXml(tcPrXml) {
+        const formatting = {};
+        const bordersXml = XMLParser_1.XMLParser.extractBetweenTags(tcPrXml, "<w:tcBorders>", "</w:tcBorders>");
+        if (bordersXml) {
+            formatting.borders = this.parseBordersFromXml(bordersXml, true);
+        }
+        if (tcPrXml.includes("<w:shd")) {
+            formatting.shading = this.parseShadingFromXml(tcPrXml);
+        }
+        const marginXml = XMLParser_1.XMLParser.extractBetweenTags(tcPrXml, "<w:tcMar>", "</w:tcMar>");
+        if (marginXml) {
+            formatting.margins = this.parseCellMarginsFromXml(marginXml);
+        }
+        if (tcPrXml.includes("<w:vAlign")) {
+            const tag = XMLParser_1.XMLParser.extractSelfClosingTag(tcPrXml, "w:vAlign");
+            if (tag) {
+                const val = XMLParser_1.XMLParser.extractAttribute(`<w:vAlign${tag}`, "w:val");
+                if (val === 'top' || val === 'center' || val === 'bottom') {
+                    formatting.verticalAlignment = val;
+                }
+            }
+        }
+        return formatting;
+    }
+    parseTableRowFormattingFromXml(trPrXml) {
+        const formatting = {};
+        if (trPrXml.includes("<w:trHeight")) {
+            const tag = XMLParser_1.XMLParser.extractSelfClosingTag(trPrXml, "w:trHeight");
+            if (tag) {
+                const val = XMLParser_1.XMLParser.extractAttribute(`<w:trHeight${tag}`, "w:val");
+                const hRule = XMLParser_1.XMLParser.extractAttribute(`<w:trHeight${tag}`, "w:hRule");
+                if (val) {
+                    formatting.height = parseInt(val, 10);
+                }
+                if (hRule === 'auto' || hRule === 'exact' || hRule === 'atLeast') {
+                    formatting.heightRule = hRule;
+                }
+            }
+        }
+        if (trPrXml.includes("<w:cantSplit/>") || trPrXml.includes("<w:cantSplit ")) {
+            formatting.cantSplit = true;
+        }
+        if (trPrXml.includes("<w:tblHeader/>") || trPrXml.includes("<w:tblHeader ")) {
+            formatting.isHeader = true;
+        }
+        return formatting;
+    }
+    parseConditionalFormattingFromXml(styleXml) {
+        const conditionalFormatting = [];
+        let searchFrom = 0;
+        while (true) {
+            const startIdx = styleXml.indexOf("<w:tblStylePr", searchFrom);
+            if (startIdx === -1)
+                break;
+            const endIdx = styleXml.indexOf("</w:tblStylePr>", startIdx);
+            if (endIdx === -1)
+                break;
+            const tblStylePrXml = styleXml.substring(startIdx, endIdx + 15);
+            const typeAttr = XMLParser_1.XMLParser.extractAttribute(tblStylePrXml, "w:type");
+            if (typeAttr) {
+                const conditional = {
+                    type: typeAttr,
+                };
+                const pPrXml = XMLParser_1.XMLParser.extractBetweenTags(tblStylePrXml, "<w:pPr>", "</w:pPr>");
+                if (pPrXml) {
+                    conditional.paragraphFormatting = this.parseParagraphFormattingFromXml(pPrXml);
+                }
+                const rPrXml = XMLParser_1.XMLParser.extractBetweenTags(tblStylePrXml, "<w:rPr>", "</w:rPr>");
+                if (rPrXml) {
+                    conditional.runFormatting = this.parseRunFormattingFromXml(rPrXml);
+                }
+                const tblPrXml = XMLParser_1.XMLParser.extractBetweenTags(tblStylePrXml, "<w:tblPr>", "</w:tblPr>");
+                if (tblPrXml) {
+                    conditional.tableFormatting = this.parseTableFormattingFromXml(tblPrXml);
+                }
+                const tcPrXml = XMLParser_1.XMLParser.extractBetweenTags(tblStylePrXml, "<w:tcPr>", "</w:tcPr>");
+                if (tcPrXml) {
+                    conditional.cellFormatting = this.parseTableCellFormattingFromXml(tcPrXml);
+                }
+                const trPrXml = XMLParser_1.XMLParser.extractBetweenTags(tblStylePrXml, "<w:trPr>", "</w:trPr>");
+                if (trPrXml) {
+                    conditional.rowFormatting = this.parseTableRowFormattingFromXml(trPrXml);
+                }
+                conditionalFormatting.push(conditional);
+            }
+            searchFrom = endIdx + 15;
+        }
+        return conditionalFormatting.length > 0 ? conditionalFormatting : undefined;
+    }
+    parseBordersFromXml(bordersXml, includeDiagonals) {
+        const borders = {};
+        const borderTypes = ['top', 'bottom', 'left', 'right', 'insideH', 'insideV'];
+        for (const type of borderTypes) {
+            if (bordersXml.includes(`<w:${type}`)) {
+                const tag = XMLParser_1.XMLParser.extractSelfClosingTag(bordersXml, `w:${type}`);
+                if (tag) {
+                    const style = XMLParser_1.XMLParser.extractAttribute(`<w:${type}${tag}`, "w:val");
+                    const size = XMLParser_1.XMLParser.extractAttribute(`<w:${type}${tag}`, "w:sz");
+                    const space = XMLParser_1.XMLParser.extractAttribute(`<w:${type}${tag}`, "w:space");
+                    const color = XMLParser_1.XMLParser.extractAttribute(`<w:${type}${tag}`, "w:color");
+                    const border = {};
+                    if (style)
+                        border.style = style;
+                    if (size)
+                        border.size = parseInt(size, 10);
+                    if (space)
+                        border.space = parseInt(space, 10);
+                    if (color)
+                        border.color = color;
+                    if (Object.keys(border).length > 0) {
+                        borders[type] = border;
+                    }
+                }
+            }
+        }
+        if (includeDiagonals) {
+            const diagonalTypes = ['tl2br', 'tr2bl'];
+            for (const type of diagonalTypes) {
+                if (bordersXml.includes(`<w:${type}`)) {
+                    const tag = XMLParser_1.XMLParser.extractSelfClosingTag(bordersXml, `w:${type}`);
+                    if (tag) {
+                        const style = XMLParser_1.XMLParser.extractAttribute(`<w:${type}${tag}`, "w:val");
+                        const size = XMLParser_1.XMLParser.extractAttribute(`<w:${type}${tag}`, "w:sz");
+                        const space = XMLParser_1.XMLParser.extractAttribute(`<w:${type}${tag}`, "w:space");
+                        const color = XMLParser_1.XMLParser.extractAttribute(`<w:${type}${tag}`, "w:color");
+                        const border = {};
+                        if (style)
+                            border.style = style;
+                        if (size)
+                            border.size = parseInt(size, 10);
+                        if (space)
+                            border.space = parseInt(space, 10);
+                        if (color)
+                            border.color = color;
+                        if (Object.keys(border).length > 0) {
+                            borders[type] = border;
+                        }
+                    }
+                }
+            }
+        }
+        return borders;
+    }
+    parseShadingFromXml(xml) {
+        const tag = XMLParser_1.XMLParser.extractSelfClosingTag(xml, "w:shd");
+        if (!tag)
+            return undefined;
+        const shading = {};
+        const val = XMLParser_1.XMLParser.extractAttribute(`<w:shd${tag}`, "w:val");
+        const color = XMLParser_1.XMLParser.extractAttribute(`<w:shd${tag}`, "w:color");
+        const fill = XMLParser_1.XMLParser.extractAttribute(`<w:shd${tag}`, "w:fill");
+        if (val)
+            shading.val = val;
+        if (color)
+            shading.color = color;
+        if (fill)
+            shading.fill = fill;
+        return Object.keys(shading).length > 0 ? shading : undefined;
+    }
+    parseCellMarginsFromXml(marginXml) {
+        const margins = {};
+        const marginTypes = ['top', 'bottom', 'left', 'right'];
+        for (const type of marginTypes) {
+            if (marginXml.includes(`<w:${type}`)) {
+                const tag = XMLParser_1.XMLParser.extractSelfClosingTag(marginXml, `w:${type}`);
+                if (tag) {
+                    const w = XMLParser_1.XMLParser.extractAttribute(`<w:${type}${tag}`, "w:w");
+                    if (w) {
+                        margins[type] = parseInt(w, 10);
+                    }
+                }
+            }
+        }
+        return Object.keys(margins).length > 0 ? margins : undefined;
+    }
     static getRawXml(zipHandler, partName) {
         try {
             const file = zipHandler.getFile(partName);