docxmlater 9.5.38 → 9.6.0

package/dist/core/DocumentParser.js

@@ -34,8 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocumentParser = void 0;
+const AlternateContent_1 = require("../elements/AlternateContent");
 const Bookmark_1 = require("../elements/Bookmark");
 const Comment_1 = require("../elements/Comment");
+const CustomXml_1 = require("../elements/CustomXml");
+const PreservedElement_1 = require("../elements/PreservedElement");
+const MathElement_1 = require("../elements/MathElement");
 const Field_1 = require("../elements/Field");
 const FieldHelpers_1 = require("../elements/FieldHelpers");
 const Footer_1 = require("../elements/Footer");
@@ -58,6 +62,7 @@ const Style_1 = require("../formatting/Style");
 const diagnostics_1 = require("../utils/diagnostics");
 const logger_1 = require("../utils/logger");
 const parsingHelpers_1 = require("../utils/parsingHelpers");
+const units_1 = require("../utils/units");
 function getLogger() {
     return (0, logger_1.createScopedLogger)((0, logger_1.getGlobalLogger)(), 'DocumentParser');
 }
@@ -139,6 +144,10 @@ class DocumentParser {
             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 nextAC = this.findNextTopLevelTag(bodyContent, "mc:AlternateContent", pos);
+            const nextMath = this.findNextTopLevelTag(bodyContent, "m:oMathPara", pos);
+            const nextCXml = this.findNextTopLevelTag(bodyContent, "w:customXml", pos);
+            const nextAltChunk = this.findNextTopLevelTag(bodyContent, "w:altChunk", pos);
             const candidates = [];
             if (nextP !== -1)
                 candidates.push({ type: "p", pos: nextP });
@@ -146,6 +155,14 @@ class DocumentParser {
                 candidates.push({ type: "tbl", pos: nextTbl });
             if (nextSdt !== -1)
                 candidates.push({ type: "sdt", pos: nextSdt });
+            if (nextAC !== -1)
+                candidates.push({ type: "alternateContent", pos: nextAC });
+            if (nextMath !== -1)
+                candidates.push({ type: "mathParagraph", pos: nextMath });
+            if (nextCXml !== -1)
+                candidates.push({ type: "customXml", pos: nextCXml });
+            if (nextAltChunk !== -1)
+                candidates.push({ type: "altChunk", pos: nextAltChunk });
             if (candidates.length === 0)
                 break;
             candidates.sort((a, b) => a.pos - b.pos);
@@ -231,6 +248,46 @@ class DocumentParser {
                         pos = next.pos + 1;
                     }
                 }
+                else if (next.type === "alternateContent") {
+                    const elementXml = this.extractSingleElement(bodyContent, "mc:AlternateContent", next.pos);
+                    if (elementXml) {
+                        bodyElements.push(new AlternateContent_1.AlternateContent(elementXml));
+                        pos = next.pos + elementXml.length;
+                    }
+                    else {
+                        pos = next.pos + 1;
+                    }
+                }
+                else if (next.type === "mathParagraph") {
+                    const elementXml = this.extractSingleElement(bodyContent, "m:oMathPara", next.pos);
+                    if (elementXml) {
+                        bodyElements.push(new MathElement_1.MathParagraph(elementXml));
+                        pos = next.pos + elementXml.length;
+                    }
+                    else {
+                        pos = next.pos + 1;
+                    }
+                }
+                else if (next.type === "customXml") {
+                    const elementXml = this.extractSingleElement(bodyContent, "w:customXml", next.pos);
+                    if (elementXml) {
+                        bodyElements.push(new CustomXml_1.CustomXmlBlock(elementXml));
+                        pos = next.pos + elementXml.length;
+                    }
+                    else {
+                        pos = next.pos + 1;
+                    }
+                }
+                else if (next.type === "altChunk") {
+                    const elementXml = this.extractSingleElement(bodyContent, "w:altChunk", next.pos);
+                    if (elementXml) {
+                        bodyElements.push(new PreservedElement_1.PreservedElement(elementXml, 'altChunk', 'block'));
+                        pos = next.pos + elementXml.length;
+                    }
+                    else {
+                        pos = next.pos + 1;
+                    }
+                }
             }
         }
         if (bodyElements.length > 0 && pos < bodyContent.length) {
@@ -526,6 +583,11 @@ class DocumentParser {
         let moveToIndex = 0;
         let bookmarkStartIndex = 0;
         let bookmarkEndIndex = 0;
+        let proofErrIndex = 0;
+        let permStartIndex = 0;
+        let permEndIndex = 0;
+        let oMathIndex = 0;
+        let rubyIndex = 0;
         const findClosingTagEnd = (content, tagName, startPos) => {
             const closingTag = `</${tagName}>`;
             const closingPos = content.indexOf(closingTag, startPos);
@@ -615,6 +677,46 @@ class DocumentParser {
                 });
                 searchPos = tagEnd + 1;
             }
+            else if (tagName === "w:proofErr") {
+                children.push({
+                    type: "w:proofErr",
+                    pos: tagStart,
+                    index: proofErrIndex++,
+                });
+                searchPos = tagEnd + 1;
+            }
+            else if (tagName === "w:permStart") {
+                children.push({
+                    type: "w:permStart",
+                    pos: tagStart,
+                    index: permStartIndex++,
+                });
+                searchPos = tagEnd + 1;
+            }
+            else if (tagName === "w:permEnd") {
+                children.push({
+                    type: "w:permEnd",
+                    pos: tagStart,
+                    index: permEndIndex++,
+                });
+                searchPos = tagEnd + 1;
+            }
+            else if (tagName === "m:oMath") {
+                children.push({
+                    type: "m:oMath",
+                    pos: tagStart,
+                    index: oMathIndex++,
+                });
+                searchPos = selfClosing ? tagEnd + 1 : findClosingTagEnd(paraContent, "m:oMath", tagEnd);
+            }
+            else if (tagName === "w:ruby") {
+                children.push({
+                    type: "w:ruby",
+                    pos: tagStart,
+                    index: rubyIndex++,
+                });
+                searchPos = selfClosing ? tagEnd + 1 : findClosingTagEnd(paraContent, "w:ruby", tagEnd);
+            }
             else {
                 searchPos = tagEnd + 1;
             }
@@ -676,6 +778,17 @@ class DocumentParser {
                             }
                         }
                     }
+                    else if (runObj["w:object"]) {
+                        const runXml = extractRunXmlAtPosition(child.pos);
+                        if (runXml) {
+                            const objectXmls = XMLParser_1.XMLParser.extractElements(runXml, "w:object");
+                            if (objectXmls.length > 0 && objectXmls[0]) {
+                                const run = Run_1.Run.createFromContent([{ type: "embeddedObject", rawXml: objectXmls[0] }]);
+                                this.parseRunPropertiesFromObject(runObj["w:rPr"], run);
+                                paragraph.addRun(run);
+                            }
+                        }
+                    }
                     else {
                         const run = this.parseRunFromObject(runObj);
                         if (run) {
@@ -808,6 +921,19 @@ class DocumentParser {
                     }
                 }
             }
+            else if (child.type === "w:proofErr" || child.type === "w:permStart" || child.type === "w:permEnd") {
+                const selfCloseEnd = paraContent.indexOf(">", child.pos);
+                if (selfCloseEnd !== -1) {
+                    const rawXml = paraContent.substring(child.pos, selfCloseEnd + 1);
+                    paragraph.addContent(new PreservedElement_1.PreservedElement(rawXml, child.type, 'inline'));
+                }
+            }
+            else if (child.type === "m:oMath" || child.type === "w:ruby") {
+                const elementXml = this.extractSingleElement(paraContent, child.type, child.pos);
+                if (elementXml) {
+                    paragraph.addContent(new PreservedElement_1.PreservedElement(elementXml, child.type, 'inline'));
+                }
+            }
         }
     }
     async parseRevisionFromXml(revisionXml, tagName, relationshipManager, zipHandler, imageManager) {
@@ -2284,6 +2410,70 @@ class DocumentParser {
                         case "w:noBreakHyphen":
                             content.push({ type: "noBreakHyphen" });
                             break;
+                        case "w:lastRenderedPageBreak":
+                            content.push({ type: "lastRenderedPageBreak" });
+                            break;
+                        case "w:separator":
+                            content.push({ type: "separator" });
+                            break;
+                        case "w:continuationSeparator":
+                            content.push({ type: "continuationSeparator" });
+                            break;
+                        case "w:pgNum":
+                            content.push({ type: "pageNumber" });
+                            break;
+                        case "w:annotationRef":
+                            content.push({ type: "annotationRef" });
+                            break;
+                        case "w:dayShort":
+                            content.push({ type: "dayShort" });
+                            break;
+                        case "w:dayLong":
+                            content.push({ type: "dayLong" });
+                            break;
+                        case "w:monthShort":
+                            content.push({ type: "monthShort" });
+                            break;
+                        case "w:monthLong":
+                            content.push({ type: "monthLong" });
+                            break;
+                        case "w:yearShort":
+                            content.push({ type: "yearShort" });
+                            break;
+                        case "w:yearLong":
+                            content.push({ type: "yearLong" });
+                            break;
+                        case "w:sym": {
+                            const symElements = toArray(runObj["w:sym"]);
+                            const sym = symElements[elementIndex] || symElements[0];
+                            if (sym && typeof sym === "object") {
+                                content.push({
+                                    type: "symbol",
+                                    symbolFont: sym["@_w:font"],
+                                    symbolChar: sym["@_w:char"],
+                                });
+                            }
+                            else {
+                                content.push({ type: "symbol" });
+                            }
+                            break;
+                        }
+                        case "w:ptab": {
+                            const ptabElements = toArray(runObj["w:ptab"]);
+                            const ptab = ptabElements[elementIndex] || ptabElements[0];
+                            if (ptab && typeof ptab === "object") {
+                                content.push({
+                                    type: "positionTab",
+                                    ptabAlignment: ptab["@_w:alignment"],
+                                    ptabRelativeTo: ptab["@_w:relativeTo"],
+                                    ptabLeader: ptab["@_w:leader"],
+                                });
+                            }
+                            else {
+                                content.push({ type: "positionTab" });
+                            }
+                            break;
+                        }
                         case "w:rPr":
                             break;
                     }
@@ -2362,6 +2552,70 @@ class DocumentParser {
                 if (runObj["w:noBreakHyphen"] !== undefined) {
                     content.push({ type: "noBreakHyphen" });
                 }
+                if (runObj["w:lastRenderedPageBreak"] !== undefined) {
+                    content.push({ type: "lastRenderedPageBreak" });
+                }
+                if (runObj["w:separator"] !== undefined) {
+                    content.push({ type: "separator" });
+                }
+                if (runObj["w:continuationSeparator"] !== undefined) {
+                    content.push({ type: "continuationSeparator" });
+                }
+                if (runObj["w:pgNum"] !== undefined) {
+                    content.push({ type: "pageNumber" });
+                }
+                if (runObj["w:annotationRef"] !== undefined) {
+                    content.push({ type: "annotationRef" });
+                }
+                if (runObj["w:dayShort"] !== undefined) {
+                    content.push({ type: "dayShort" });
+                }
+                if (runObj["w:dayLong"] !== undefined) {
+                    content.push({ type: "dayLong" });
+                }
+                if (runObj["w:monthShort"] !== undefined) {
+                    content.push({ type: "monthShort" });
+                }
+                if (runObj["w:monthLong"] !== undefined) {
+                    content.push({ type: "monthLong" });
+                }
+                if (runObj["w:yearShort"] !== undefined) {
+                    content.push({ type: "yearShort" });
+                }
+                if (runObj["w:yearLong"] !== undefined) {
+                    content.push({ type: "yearLong" });
+                }
+                if (runObj["w:sym"] !== undefined) {
+                    const symElements = toArray(runObj["w:sym"]);
+                    for (const sym of symElements) {
+                        if (sym && typeof sym === "object") {
+                            content.push({
+                                type: "symbol",
+                                symbolFont: sym["@_w:font"],
+                                symbolChar: sym["@_w:char"],
+                            });
+                        }
+                        else {
+                            content.push({ type: "symbol" });
+                        }
+                    }
+                }
+                if (runObj["w:ptab"] !== undefined) {
+                    const ptabElements = toArray(runObj["w:ptab"]);
+                    for (const ptab of ptabElements) {
+                        if (ptab && typeof ptab === "object") {
+                            content.push({
+                                type: "positionTab",
+                                ptabAlignment: ptab["@_w:alignment"],
+                                ptabRelativeTo: ptab["@_w:relativeTo"],
+                                ptabLeader: ptab["@_w:leader"],
+                            });
+                        }
+                        else {
+                            content.push({ type: "positionTab" });
+                        }
+                    }
+                }
             }
             const run = Run_1.Run.createFromContent(content, { cleanXmlFromText: false });
             this.parseRunPropertiesFromObject(runObj["w:rPr"], run);
@@ -2721,6 +2975,10 @@ class DocumentParser {
             run.setSmallCaps(true);
         if ((0, parsingHelpers_1.parseOoxmlBoolean)(rPrObj["w:caps"]))
             run.setAllCaps(true);
+        if ((0, parsingHelpers_1.parseOoxmlBoolean)(rPrObj["w:cs"]))
+            run.setComplexScript(true);
+        if ((0, parsingHelpers_1.parseOoxmlBoolean)(rPrObj["w:webHidden"]))
+            run.setWebHidden(true);
         if (rPrObj["w:u"]) {
             const uVal = rPrObj["w:u"]["@_w:val"];
             run.setUnderline(uVal || true);
@@ -2785,14 +3043,24 @@ class DocumentParser {
                 run.setSuperscript(true);
         }
         if (rPrObj["w:rFonts"]) {
-            run.setFont(rPrObj["w:rFonts"]["@_w:ascii"]);
+            const rFonts = rPrObj["w:rFonts"];
+            if (rFonts["@_w:ascii"])
+                run.setFont(rFonts["@_w:ascii"]);
+            if (rFonts["@_w:hAnsi"])
+                run.setFontHAnsi(rFonts["@_w:hAnsi"]);
+            if (rFonts["@_w:eastAsia"])
+                run.setFontEastAsia(rFonts["@_w:eastAsia"]);
+            if (rFonts["@_w:cs"])
+                run.setFontCs(rFonts["@_w:cs"]);
+            if (rFonts["@_w:hint"])
+                run.setFontHint(rFonts["@_w:hint"]);
         }
         if (rPrObj["w:sz"]) {
-            run.setSize(parseInt(rPrObj["w:sz"]["@_w:val"], 10) / 2);
+            run.setSize((0, units_1.halfPointsToPoints)(parseInt(rPrObj["w:sz"]["@_w:val"], 10)));
         }
         if (rPrObj["w:szCs"]) {
-            const szCsVal = parseInt(rPrObj["w:szCs"]["@_w:val"], 10) / 2;
-            const sizeVal = rPrObj["w:sz"] ? parseInt(rPrObj["w:sz"]["@_w:val"], 10) / 2 : undefined;
+            const szCsVal = (0, units_1.halfPointsToPoints)(parseInt(rPrObj["w:szCs"]["@_w:val"], 10));
+            const sizeVal = rPrObj["w:sz"] ? (0, units_1.halfPointsToPoints)(parseInt(rPrObj["w:sz"]["@_w:val"], 10)) : undefined;
             if (sizeVal === undefined || szCsVal !== sizeVal) {
                 run.setSizeCs(szCsVal);
             }
@@ -2844,10 +3112,10 @@ class DocumentParser {
                     prevProps.font = prevRPr["w:rFonts"]["@_w:ascii"];
                 }
                 if (prevRPr["w:sz"]) {
-                    prevProps.size = (0, parsingHelpers_1.safeParseInt)(prevRPr["w:sz"]["@_w:val"]) / 2;
+                    prevProps.size = (0, units_1.halfPointsToPoints)((0, parsingHelpers_1.safeParseInt)(prevRPr["w:sz"]["@_w:val"]));
                 }
                 if (prevRPr["w:szCs"]) {
-                    const szCsVal = (0, parsingHelpers_1.safeParseInt)(prevRPr["w:szCs"]["@_w:val"]) / 2;
+                    const szCsVal = (0, units_1.halfPointsToPoints)((0, parsingHelpers_1.safeParseInt)(prevRPr["w:szCs"]["@_w:val"]));
                     if (!prevRPr["w:sz"] || szCsVal !== prevProps.size) {
                         prevProps.sizeCs = szCsVal;
                     }
@@ -3037,10 +3305,14 @@ class DocumentParser {
             const docPrObj = imageObj["wp:docPr"];
             let name = "image";
             let description = "Image";
+            let title = undefined;
             let docPrId = 1;
             if (docPrObj) {
                 name = docPrObj["@_name"] || "image";
                 description = docPrObj["@_descr"] || "Image";
+                if (docPrObj["@_title"]) {
+                    title = String(docPrObj["@_title"]);
+                }
                 const idAttr = docPrObj["@_id"];
                 if (idAttr) {
                     docPrId = parseInt(String(idAttr), 10);
@@ -3057,12 +3329,23 @@ class DocumentParser {
             let anchor = undefined;
             if (isFloating && anchorObj) {
                 const toBool = (val) => val === "1" || val === 1 || val === true;
+                const toOptInt = (val) => {
+                    if (val === undefined || val === null)
+                        return undefined;
+                    const n = parseInt(String(val), 10);
+                    return isNaN(n) ? undefined : n;
+                };
                 anchor = {
                     behindDoc: toBool(anchorObj["@_behindDoc"]),
                     locked: toBool(anchorObj["@_locked"]),
                     layoutInCell: toBool(anchorObj["@_layoutInCell"]),
                     allowOverlap: toBool(anchorObj["@_allowOverlap"]),
                     relativeHeight: parseInt(anchorObj["@_relativeHeight"] || "251658240", 10),
+                    simplePos: toBool(anchorObj["@_simplePos"]),
+                    distT: toOptInt(anchorObj["@_distT"]),
+                    distB: toOptInt(anchorObj["@_distB"]),
+                    distL: toOptInt(anchorObj["@_distL"]),
+                    distR: toOptInt(anchorObj["@_distR"]),
                 };
             }
             const graphicObj = imageObj["a:graphic"];
@@ -3135,6 +3418,7 @@ class DocumentParser {
                 height,
                 name,
                 description,
+                title,
                 effectExtent,
                 wrap,
                 position,
@@ -3266,6 +3550,20 @@ class DocumentParser {
         }
         return Object.keys(effects).length > 0 ? effects : undefined;
     }
+    parseBorderElement(borderObj) {
+        if (!borderObj)
+            return undefined;
+        const border = {
+            style: (borderObj["@_w:val"] || "single"),
+        };
+        if (borderObj["@_w:sz"])
+            border.size = parseInt(borderObj["@_w:sz"], 10);
+        if (borderObj["@_w:space"])
+            border.space = parseInt(borderObj["@_w:space"], 10);
+        if (borderObj["@_w:color"])
+            border.color = borderObj["@_w:color"];
+        return border;
+    }
     async parseTableFromObject(tableObj, relationshipManager, zipHandler, imageManager, rawTableXml) {
         try {
             const table = new Table_1.Table();
@@ -3467,6 +3765,18 @@ class DocumentParser {
                 table.setAlignment(alignment);
             }
         }
+        if (tblPrObj["w:tblStyleRowBandSize"]) {
+            const val = parseInt(tblPrObj["w:tblStyleRowBandSize"]["@_w:val"] || "0", 10);
+            if (val > 0) {
+                table.setStyleRowBandSize(val);
+            }
+        }
+        if (tblPrObj["w:tblStyleColBandSize"]) {
+            const val = parseInt(tblPrObj["w:tblStyleColBandSize"]["@_w:val"] || "0", 10);
+            if (val > 0) {
+                table.setStyleColBandSize(val);
+            }
+        }
         if (tblPrObj["w:shd"]) {
             const shd = tblPrObj["w:shd"];
             const shading = {};
@@ -3483,32 +3793,18 @@ class DocumentParser {
         if (tblPrObj["w:tblBorders"]) {
             const bordersObj = tblPrObj["w:tblBorders"];
             const borders = {};
-            const parseBorder = (borderObj) => {
-                if (!borderObj)
-                    return undefined;
-                const border = {
-                    style: borderObj["@_w:val"] || "single",
-                };
-                if (borderObj["@_w:sz"])
-                    border.size = parseInt(borderObj["@_w:sz"], 10);
-                if (borderObj["@_w:space"])
-                    border.space = parseInt(borderObj["@_w:space"], 10);
-                if (borderObj["@_w:color"])
-                    border.color = borderObj["@_w:color"];
-                return border;
-            };
             if (bordersObj["w:top"])
-                borders.top = parseBorder(bordersObj["w:top"]);
+                borders.top = this.parseBorderElement(bordersObj["w:top"]);
             if (bordersObj["w:bottom"])
-                borders.bottom = parseBorder(bordersObj["w:bottom"]);
+                borders.bottom = this.parseBorderElement(bordersObj["w:bottom"]);
             if (bordersObj["w:left"])
-                borders.left = parseBorder(bordersObj["w:left"]);
+                borders.left = this.parseBorderElement(bordersObj["w:left"]);
             if (bordersObj["w:right"])
-                borders.right = parseBorder(bordersObj["w:right"]);
+                borders.right = this.parseBorderElement(bordersObj["w:right"]);
             if (bordersObj["w:insideH"])
-                borders.insideH = parseBorder(bordersObj["w:insideH"]);
+                borders.insideH = this.parseBorderElement(bordersObj["w:insideH"]);
             if (bordersObj["w:insideV"])
-                borders.insideV = parseBorder(bordersObj["w:insideV"]);
+                borders.insideV = this.parseBorderElement(bordersObj["w:insideV"]);
             if (Object.keys(borders).length > 0) {
                 table.setBorders(borders);
             }
@@ -3588,6 +3884,33 @@ class DocumentParser {
                 row.setGridAfter(val);
             }
         }
+        if (trPrObj["w:wBefore"]) {
+            const w = parseInt(trPrObj["w:wBefore"]["@_w:w"] || "0", 10);
+            const type = trPrObj["w:wBefore"]["@_w:type"] || "dxa";
+            if (w > 0) {
+                row.setWBefore(w, type);
+            }
+        }
+        if (trPrObj["w:wAfter"]) {
+            const w = parseInt(trPrObj["w:wAfter"]["@_w:w"] || "0", 10);
+            const type = trPrObj["w:wAfter"]["@_w:type"] || "dxa";
+            if (w > 0) {
+                row.setWAfter(w, type);
+            }
+        }
+        if (trPrObj["w:tblCellSpacing"]) {
+            const w = parseInt(trPrObj["w:tblCellSpacing"]["@_w:w"] || "0", 10);
+            const type = trPrObj["w:tblCellSpacing"]["@_w:type"] || "dxa";
+            if (w > 0) {
+                row.setRowCellSpacing(w, type);
+            }
+        }
+        if (trPrObj["w:cnfStyle"]) {
+            const val = trPrObj["w:cnfStyle"]["@_w:val"];
+            if (val) {
+                row.setCnfStyle(val);
+            }
+        }
     }
     parseTablePropertyExceptionsFromObject(tblPrExObj) {
         if (!tblPrExObj)
@@ -3682,28 +4005,14 @@ class DocumentParser {
                 if (tcPr["w:tcBorders"]) {
                     const bordersObj = tcPr["w:tcBorders"];
                     const borders = {};
-                    const parseBorder = (borderObj) => {
-                        if (!borderObj)
-                            return undefined;
-                        const border = {
-                            style: borderObj["@_w:val"] || "single",
-                        };
-                        if (borderObj["@_w:sz"])
-                            border.size = parseInt(borderObj["@_w:sz"], 10);
-                        if (borderObj["@_w:space"])
-                            border.space = parseInt(borderObj["@_w:space"], 10);
-                        if (borderObj["@_w:color"])
-                            border.color = borderObj["@_w:color"];
-                        return border;
-                    };
                     if (bordersObj["w:top"])
-                        borders.top = parseBorder(bordersObj["w:top"]);
+                        borders.top = this.parseBorderElement(bordersObj["w:top"]);
                     if (bordersObj["w:bottom"])
-                        borders.bottom = parseBorder(bordersObj["w:bottom"]);
+                        borders.bottom = this.parseBorderElement(bordersObj["w:bottom"]);
                     if (bordersObj["w:left"])
-                        borders.left = parseBorder(bordersObj["w:left"]);
+                        borders.left = this.parseBorderElement(bordersObj["w:left"]);
                     if (bordersObj["w:right"])
-                        borders.right = parseBorder(bordersObj["w:right"]);
+                        borders.right = this.parseBorderElement(bordersObj["w:right"]);
                     if (Object.keys(borders).length > 0) {
                         cell.setBorders(borders);
                     }
@@ -4792,6 +5101,14 @@ class DocumentParser {
                         start: start ? parseInt(start, 10) : undefined,
                         format: fmt,
                     };
+                    const chapStyle = XMLParser_1.XMLParser.extractAttribute(pgNumType, "w:chapStyle");
+                    if (chapStyle) {
+                        sectionProps.chapStyle = parseInt(chapStyle, 10);
+                    }
+                    const chapSep = XMLParser_1.XMLParser.extractAttribute(pgNumType, "w:chapSep");
+                    if (chapSep) {
+                        sectionProps.chapSep = chapSep;
+                    }
                 }
             }
             if (XMLParser_1.XMLParser.hasSelfClosingTag(sectPr, "w:titlePg")) {
@@ -4863,6 +5180,106 @@ class DocumentParser {
                     }
                 }
             }
+            if (XMLParser_1.XMLParser.hasSelfClosingTag(sectPr, "w:bidi")) {
+                sectionProps.bidi = true;
+            }
+            if (XMLParser_1.XMLParser.hasSelfClosingTag(sectPr, "w:rtlGutter")) {
+                sectionProps.rtlGutter = true;
+            }
+            const docGridElements = XMLParser_1.XMLParser.extractElements(sectPr, "w:docGrid");
+            if (docGridElements.length > 0) {
+                const docGrid = docGridElements[0];
+                if (docGrid) {
+                    const gridType = XMLParser_1.XMLParser.extractAttribute(docGrid, "w:type");
+                    const linePitch = XMLParser_1.XMLParser.extractAttribute(docGrid, "w:linePitch");
+                    const charSpace = XMLParser_1.XMLParser.extractAttribute(docGrid, "w:charSpace");
+                    sectionProps.docGrid = {};
+                    if (gridType)
+                        sectionProps.docGrid.type = gridType;
+                    if (linePitch)
+                        sectionProps.docGrid.linePitch = parseInt(linePitch, 10);
+                    if (charSpace)
+                        sectionProps.docGrid.charSpace = parseInt(charSpace, 10);
+                }
+            }
+            const lnNumElements = XMLParser_1.XMLParser.extractElements(sectPr, "w:lnNumType");
+            if (lnNumElements.length > 0) {
+                const lnNum = lnNumElements[0];
+                if (lnNum) {
+                    const countBy = XMLParser_1.XMLParser.extractAttribute(lnNum, "w:countBy");
+                    const start = XMLParser_1.XMLParser.extractAttribute(lnNum, "w:start");
+                    const distance = XMLParser_1.XMLParser.extractAttribute(lnNum, "w:distance");
+                    const restart = XMLParser_1.XMLParser.extractAttribute(lnNum, "w:restart");
+                    sectionProps.lineNumbering = {};
+                    if (countBy)
+                        sectionProps.lineNumbering.countBy = parseInt(countBy, 10);
+                    if (start)
+                        sectionProps.lineNumbering.start = parseInt(start, 10);
+                    if (distance)
+                        sectionProps.lineNumbering.distance = parseInt(distance, 10);
+                    if (restart)
+                        sectionProps.lineNumbering.restart = restart;
+                }
+            }
+            const extractChildAttr = (parentXml, childTag, attr) => {
+                const els = XMLParser_1.XMLParser.extractElements(parentXml, childTag);
+                if (els.length > 0 && els[0])
+                    return XMLParser_1.XMLParser.extractAttribute(els[0], attr);
+                return undefined;
+            };
+            const footnotePrElements = XMLParser_1.XMLParser.extractElements(sectPr, "w:footnotePr");
+            if (footnotePrElements.length > 0 && footnotePrElements[0]) {
+                const fnPr = footnotePrElements[0];
+                const props = {};
+                const pos = extractChildAttr(fnPr, "w:pos", "w:val");
+                if (pos)
+                    props.position = pos;
+                const fmt = extractChildAttr(fnPr, "w:numFmt", "w:val");
+                if (fmt)
+                    props.numberFormat = fmt;
+                const startVal = extractChildAttr(fnPr, "w:numStart", "w:val");
+                if (startVal)
+                    props.startNumber = parseInt(startVal, 10);
+                const restart = extractChildAttr(fnPr, "w:numRestart", "w:val");
+                if (restart)
+                    props.restart = restart;
+                if (Object.keys(props).length > 0)
+                    sectionProps.footnotePr = props;
+            }
+            const endnotePrElements = XMLParser_1.XMLParser.extractElements(sectPr, "w:endnotePr");
+            if (endnotePrElements.length > 0 && endnotePrElements[0]) {
+                const enPr = endnotePrElements[0];
+                const props = {};
+                const pos = extractChildAttr(enPr, "w:pos", "w:val");
+                if (pos)
+                    props.position = pos;
+                const fmt = extractChildAttr(enPr, "w:numFmt", "w:val");
+                if (fmt)
+                    props.numberFormat = fmt;
+                const startVal = extractChildAttr(enPr, "w:numStart", "w:val");
+                if (startVal)
+                    props.startNumber = parseInt(startVal, 10);
+                const restart = extractChildAttr(enPr, "w:numRestart", "w:val");
+                if (restart)
+                    props.restart = restart;
+                if (Object.keys(props).length > 0)
+                    sectionProps.endnotePr = props;
+            }
+            if (XMLParser_1.XMLParser.hasSelfClosingTag(sectPr, "w:noEndnote")) {
+                sectionProps.noEndnote = true;
+            }
+            if (XMLParser_1.XMLParser.hasSelfClosingTag(sectPr, "w:formProt")) {
+                sectionProps.formProt = true;
+            }
+            const printerElements = XMLParser_1.XMLParser.extractElements(sectPr, "w:printerSettings");
+            if (printerElements.length > 0) {
+                const printer = printerElements[0];
+                if (printer) {
+                    const rId = XMLParser_1.XMLParser.extractAttribute(printer, "r:id");
+                    if (rId)
+                        sectionProps.printerSettingsId = rId;
+                }
+            }
             return new Section_1.Section(sectionProps);
         }
         catch (error) {
@@ -5118,7 +5535,7 @@ class DocumentParser {
         if (szElement) {
             const val = XMLParser_1.XMLParser.extractAttribute(`<w:sz${szElement}`, "w:val");
             if (val) {
-                formatting.size = parseInt(val, 10) / 2;
+                formatting.size = (0, units_1.halfPointsToPoints)(parseInt(val, 10));
             }
         }
         const colorElement = XMLParser_1.XMLParser.extractSelfClosingTag(rPrXml, "w:color");