docxmlater 11.0.10 → 12.0.1

package/dist/esm/core/DocumentParser.js

@@ -32,6 +32,7 @@ import { logParagraphContent, logParsing, logTextDirection } from '../utils/diag
 import { getGlobalLogger, createScopedLogger, defaultLogger } from '../utils/logger.js';
 import { safeParseInt, isExplicitlySet, parseOoxmlBoolean, parseOnOffAttribute, } from '../utils/parsingHelpers.js';
 import { halfPointsToPoints } from '../utils/units.js';
+import { normalizeAnchorSizeRel } from '../utils/xmlSanitization.js';
 function getLogger() {
     return createScopedLogger(getGlobalLogger(), 'DocumentParser');
 }
@@ -213,9 +214,13 @@ export class DocumentParser {
                         const parsed = XMLParser.parseToObject(elementXml, {
                             trimValues: false,
                         });
-                        const sdt = await this.parseSDTFromObject(parsed['w:sdt'], relationshipManager, zipHandler, imageManager);
-                        if (sdt)
+                        const sdt = await this.parseSDTFromObject(parsed['w:sdt'], relationshipManager, zipHandler, imageManager, elementXml);
+                        if (sdt) {
                             bodyElements.push(sdt);
+                        }
+                        else {
+                            bodyElements.push(new PreservedElement(elementXml, 'sdt', 'block'));
+                        }
                         pos = next.pos + elementXml.length;
                     }
                     else {
@@ -641,6 +646,7 @@ export class DocumentParser {
         let permEndIndex = 0;
         let oMathIndex = 0;
         let rubyIndex = 0;
+        let sdtIndex = 0;
         let commentRangeStartIndex = 0;
         let commentRangeEndIndex = 0;
         const findClosingTagEnd = (content, tagName, startPos) => {
@@ -792,6 +798,14 @@ export class DocumentParser {
                 });
                 searchPos = selfClosing ? tagEnd + 1 : findClosingTagEnd(paraContent, 'w:ruby', tagEnd);
             }
+            else if (tagName === 'w:sdt') {
+                children.push({
+                    type: 'w:sdt',
+                    pos: tagStart,
+                    index: sdtIndex++,
+                });
+                searchPos = selfClosing ? tagEnd + 1 : findClosingTagEnd(paraContent, 'w:sdt', tagEnd);
+            }
             else {
                 searchPos = tagEnd + 1;
             }
@@ -872,12 +886,35 @@ export class DocumentParser {
                             paragraph.addContent(new PreservedElement(runXml, 'w:r', 'inline'));
                         }
                     }
+                    else if (runObj['mc:AlternateContent']) {
+                        const runXml = extractRunXmlAtPosition(child.pos);
+                        if (runXml) {
+                            paragraph.addContent(new PreservedElement(runXml, 'w:r', 'inline'));
+                        }
+                    }
                     else if (runObj['w:drawing']) {
+                        let imageRun = null;
                         if (zipHandler && imageManager) {
-                            const imageRun = await this.parseDrawingFromObject(runObj['w:drawing'], zipHandler, relationshipManager, imageManager);
-                            if (imageRun) {
-                                this.parseRunPropertiesFromObject(runObj['w:rPr'], imageRun);
-                                paragraph.addRun(imageRun);
+                            imageRun = await this.parseDrawingFromObject(runObj['w:drawing'], zipHandler, relationshipManager, imageManager);
+                        }
+                        if (imageRun) {
+                            this.parseRunPropertiesFromObject(runObj['w:rPr'], imageRun);
+                            paragraph.addRun(imageRun);
+                            if (runObj['w:t'] ||
+                                runObj['w:tab'] ||
+                                runObj['w:br'] ||
+                                runObj['w:cr'] ||
+                                runObj['w:noBreakHyphen']) {
+                                const siblingRun = this.parseRunFromObject(runObj);
+                                if (siblingRun) {
+                                    paragraph.addRun(siblingRun);
+                                }
+                            }
+                        }
+                        else {
+                            const runXml = extractRunXmlAtPosition(child.pos);
+                            if (runXml) {
+                                paragraph.addContent(new PreservedElement(runXml, 'w:r', 'inline'));
                             }
                         }
                     }
@@ -1064,6 +1101,12 @@ export class DocumentParser {
                     paragraph.addContent(new PreservedElement(elementXml, child.type, 'inline'));
                 }
             }
+            else if (child.type === 'w:sdt') {
+                const sdtXml = extractElementXmlAtPosition(child.pos, 'w:sdt');
+                if (sdtXml) {
+                    paragraph.addContent(new PreservedElement(sdtXml, 'w:sdt', 'inline'));
+                }
+            }
         }
     }
     async parseRevisionFromXml(revisionXml, tagName, relationshipManager, zipHandler, imageManager) {
@@ -1098,19 +1141,63 @@ export class DocumentParser {
             const hyperlinkXmls = XMLParser.extractElements(revisionXml, 'w:hyperlink');
             let xmlWithoutHyperlinks = revisionXml;
             for (const hyperlinkXml of hyperlinkXmls) {
-                xmlWithoutHyperlinks = xmlWithoutHyperlinks.split(hyperlinkXml).join('');
+                xmlWithoutHyperlinks = xmlWithoutHyperlinks
+                    .split(hyperlinkXml)
+                    .join(' '.repeat(hyperlinkXml.length));
             }
             const runXmls = XMLParser.extractElements(xmlWithoutHyperlinks, 'w:r');
-            const content = [];
+            const orderedChildren = [];
+            let runCursor = 0;
             for (const runXml of runXmls) {
+                const pos = xmlWithoutHyperlinks.indexOf(runXml, runCursor);
+                orderedChildren.push({ pos: pos === -1 ? runCursor : pos, type: 'w:r', xml: runXml });
+                if (pos !== -1) {
+                    runCursor = pos + runXml.length;
+                }
+            }
+            let hyperlinkCursor = 0;
+            for (const hyperlinkXml of hyperlinkXmls) {
+                const pos = revisionXml.indexOf(hyperlinkXml, hyperlinkCursor);
+                orderedChildren.push({
+                    pos: pos === -1 ? hyperlinkCursor : pos,
+                    type: 'w:hyperlink',
+                    xml: hyperlinkXml,
+                });
+                if (pos !== -1) {
+                    hyperlinkCursor = pos + hyperlinkXml.length;
+                }
+            }
+            orderedChildren.sort((a, b) => a.pos - b.pos);
+            const content = [];
+            for (const child of orderedChildren) {
+                if (child.type === 'w:hyperlink') {
+                    const hyperlinkObj = XMLParser.parseToObject(child.xml, { trimValues: false });
+                    const hyperlinkResult = this.parseHyperlinkFromObject(hyperlinkObj['w:hyperlink'], relationshipManager);
+                    if (hyperlinkResult.hyperlink) {
+                        content.push(hyperlinkResult.hyperlink);
+                    }
+                    result.bookmarkStarts.push(...hyperlinkResult.bookmarkStarts);
+                    result.bookmarkEnds.push(...hyperlinkResult.bookmarkEnds);
+                    continue;
+                }
+                const runXml = child.xml;
                 const runObj = XMLParser.parseToObject(runXml, { trimValues: false });
                 const runElement = runObj['w:r'];
                 if (runElement?.['w:drawing']) {
+                    let imageRun = null;
                     if (zipHandler && imageManager) {
-                        const imageRun = await this.parseDrawingFromObject(runElement['w:drawing'], zipHandler, relationshipManager, imageManager);
-                        if (imageRun) {
-                            imageRun.setRawRunXml(runXml);
-                            content.push(imageRun);
+                        imageRun = await this.parseDrawingFromObject(runElement['w:drawing'], zipHandler, relationshipManager, imageManager);
+                    }
+                    if (imageRun) {
+                        imageRun.setRawRunXml(runXml);
+                        content.push(imageRun);
+                    }
+                    else {
+                        const drawingXmls = XMLParser.extractElements(runXml, 'w:drawing');
+                        if (drawingXmls.length > 0 && drawingXmls[0]) {
+                            const run = Run.createFromContent([{ type: 'vml', rawXml: drawingXmls[0] }]);
+                            this.parseRunPropertiesFromObject(runElement['w:rPr'], run);
+                            content.push(run);
                         }
                     }
                 }
@@ -1121,15 +1208,6 @@ export class DocumentParser {
                     }
                 }
             }
-            for (const hyperlinkXml of hyperlinkXmls) {
-                const hyperlinkObj = XMLParser.parseToObject(hyperlinkXml, { trimValues: false });
-                const hyperlinkResult = this.parseHyperlinkFromObject(hyperlinkObj['w:hyperlink'], relationshipManager);
-                if (hyperlinkResult.hyperlink) {
-                    content.push(hyperlinkResult.hyperlink);
-                }
-                result.bookmarkStarts.push(...hyperlinkResult.bookmarkStarts);
-                result.bookmarkEnds.push(...hyperlinkResult.bookmarkEnds);
-            }
             const bookmarkStartXmls = XMLParser.extractElements(xmlWithoutHyperlinks, 'w:bookmarkStart');
             const bookmarkEndXmls = XMLParser.extractElements(xmlWithoutHyperlinks, 'w:bookmarkEnd');
             for (const bookmarkXml of bookmarkStartXmls) {
@@ -1170,18 +1248,33 @@ export class DocumentParser {
             return result;
         }
     }
-    parseCommentsXml(commentsXml) {
+    parseCommentsXml(commentsXml, commentsExtendedXml) {
         const comments = [];
+        const doneByParaId = commentsExtendedXml
+            ? this.parseCommentsExtendedDone(commentsExtendedXml)
+            : undefined;
         const commentXmls = XMLParser.extractElements(commentsXml, 'w:comment');
         for (const commentXml of commentXmls) {
-            const comment = this.parseCommentFromXml(commentXml);
+            const comment = this.parseCommentFromXml(commentXml, doneByParaId);
             if (comment) {
                 comments.push(comment);
             }
         }
         return comments;
     }
-    parseCommentFromXml(commentXml) {
+    parseCommentsExtendedDone(commentsExtendedXml) {
+        const doneByParaId = new Map();
+        for (const commentExXml of XMLParser.extractElements(commentsExtendedXml, 'w15:commentEx')) {
+            const paraId = XMLParser.extractAttribute(commentExXml, 'w15:paraId');
+            if (!paraId) {
+                continue;
+            }
+            const done = parseOnOffAttribute(XMLParser.extractAttribute(commentExXml, 'w15:done'));
+            doneByParaId.set(paraId.toUpperCase(), done);
+        }
+        return doneByParaId;
+    }
+    parseCommentFromXml(commentXml, doneByParaId) {
         try {
             const idAttr = XMLParser.extractAttribute(commentXml, 'w:id');
             const author = XMLParser.extractAttribute(commentXml, 'w:author') || 'Unknown';
@@ -1197,15 +1290,33 @@ export class DocumentParser {
             const id = parseInt(idAttr, 10);
             const date = dateAttr ? new Date(dateAttr) : new Date();
             const parentId = parentIdAttr ? parseInt(parentIdAttr, 10) : undefined;
-            const done = parseOnOffAttribute(doneAttr);
+            let done = parseOnOffAttribute(doneAttr);
             const runs = [];
-            const runXmls = XMLParser.extractElements(commentXml, 'w:r');
-            for (const runXml of runXmls) {
-                const runObj = XMLParser.parseToObject(runXml, { trimValues: false });
-                const run = this.parseRunFromObject(runObj['w:r']);
-                if (run) {
-                    runs.push(run);
+            const paragraphs = [];
+            const paraXmls = XMLParser.extractElements(commentXml, 'w:p');
+            const runSources = paraXmls.length > 0 ? paraXmls : [commentXml];
+            if (doneByParaId && paraXmls.length > 0) {
+                const lastParaXml = paraXmls[paraXmls.length - 1];
+                const lastParaId = XMLParser.extractAttribute(lastParaXml, 'w14:paraId');
+                if (lastParaId) {
+                    const extendedDone = doneByParaId.get(lastParaId.toUpperCase());
+                    if (extendedDone !== undefined) {
+                        done = extendedDone;
+                    }
+                }
+            }
+            for (const sourceXml of runSources) {
+                const content = this.parseCommentParagraphContent(sourceXml);
+                for (const item of content) {
+                    if (item instanceof Run) {
+                        runs.push(item);
+                    }
+                    else {
+                        runs.push(...item.runs);
+                    }
                 }
+                const pPr = paraXmls.length > 0 ? XMLParser.extractElements(sourceXml, 'w:pPr')[0] : undefined;
+                paragraphs.push({ pPr, content });
             }
             const comment = new Comment({
                 id,
@@ -1216,6 +1327,9 @@ export class DocumentParser {
                 parentId,
                 done,
             });
+            if (paraXmls.length > 0) {
+                comment.setParagraphs(paragraphs);
+            }
             return comment;
         }
         catch (error) {
@@ -1223,18 +1337,59 @@ export class DocumentParser {
             return null;
         }
     }
-    parseFootnotesXml(footnotesXml) {
+    parseCommentParagraphContent(sourceXml) {
+        const positioned = [];
+        const hyperlinkRanges = [];
+        let hyperlinkCursor = 0;
+        for (const hyperlinkXml of XMLParser.extractElements(sourceXml, 'w:hyperlink')) {
+            const start = sourceXml.indexOf(hyperlinkXml, hyperlinkCursor);
+            if (start === -1) {
+                continue;
+            }
+            hyperlinkCursor = start + hyperlinkXml.length;
+            hyperlinkRanges.push({ start, end: hyperlinkCursor });
+            const innerRuns = [];
+            for (const runXml of XMLParser.extractElements(hyperlinkXml, 'w:r')) {
+                const run = this.parseCommentRun(runXml);
+                if (run) {
+                    innerRuns.push(run);
+                }
+            }
+            positioned.push({ pos: start, item: { rawXml: hyperlinkXml, runs: innerRuns } });
+        }
+        let runCursor = 0;
+        for (const runXml of XMLParser.extractElements(sourceXml, 'w:r')) {
+            const start = sourceXml.indexOf(runXml, runCursor);
+            if (start === -1) {
+                continue;
+            }
+            runCursor = start + runXml.length;
+            if (hyperlinkRanges.some((range) => start >= range.start && start < range.end)) {
+                continue;
+            }
+            const run = this.parseCommentRun(runXml);
+            if (run) {
+                positioned.push({ pos: start, item: run });
+            }
+        }
+        return positioned.sort((a, b) => a.pos - b.pos).map((entry) => entry.item);
+    }
+    parseCommentRun(runXml) {
+        const runObj = XMLParser.parseToObject(runXml, { trimValues: false });
+        return this.parseRunFromObject(runObj['w:r']);
+    }
+    parseFootnotesXml(footnotesXml, partRels) {
         const footnotes = [];
         const footnoteXmls = XMLParser.extractElements(footnotesXml, 'w:footnote');
         for (const footnoteXml of footnoteXmls) {
-            const footnote = this.parseFootnoteFromXml(footnoteXml);
+            const footnote = this.parseFootnoteFromXml(footnoteXml, partRels);
             if (footnote) {
                 footnotes.push(footnote);
             }
         }
         return footnotes;
     }
-    parseFootnoteFromXml(footnoteXml) {
+    parseFootnoteFromXml(footnoteXml, partRels) {
         try {
             const idAttr = XMLParser.extractAttribute(footnoteXml, 'w:id');
             const typeAttr = XMLParser.extractAttribute(footnoteXml, 'w:type');
@@ -1255,7 +1410,7 @@ export class DocumentParser {
             const footnote = new Footnote({ id, type });
             const paraXmls = XMLParser.extractElements(footnoteXml, 'w:p');
             for (const paraXml of paraXmls) {
-                const para = this.parseNoteParaFromXml(paraXml);
+                const para = this.parseNoteParaFromXml(paraXml, partRels);
                 if (para) {
                     footnote.addParagraph(para);
                 }
@@ -1267,18 +1422,18 @@ export class DocumentParser {
             return null;
         }
     }
-    parseEndnotesXml(endnotesXml) {
+    parseEndnotesXml(endnotesXml, partRels) {
         const endnotes = [];
         const endnoteXmls = XMLParser.extractElements(endnotesXml, 'w:endnote');
         for (const endnoteXml of endnoteXmls) {
-            const endnote = this.parseEndnoteFromXml(endnoteXml);
+            const endnote = this.parseEndnoteFromXml(endnoteXml, partRels);
             if (endnote) {
                 endnotes.push(endnote);
             }
         }
         return endnotes;
     }
-    parseEndnoteFromXml(endnoteXml) {
+    parseEndnoteFromXml(endnoteXml, partRels) {
         try {
             const idAttr = XMLParser.extractAttribute(endnoteXml, 'w:id');
             const typeAttr = XMLParser.extractAttribute(endnoteXml, 'w:type');
@@ -1299,7 +1454,7 @@ export class DocumentParser {
             const endnote = new Endnote({ id, type });
             const paraXmls = XMLParser.extractElements(endnoteXml, 'w:p');
             for (const paraXml of paraXmls) {
-                const para = this.parseNoteParaFromXml(paraXml);
+                const para = this.parseNoteParaFromXml(paraXml, partRels);
                 if (para) {
                     endnote.addParagraph(para);
                 }
@@ -1311,15 +1466,60 @@ export class DocumentParser {
             return null;
         }
     }
-    parseNoteParaFromXml(paraXml) {
+    parseNoteParaFromXml(paraXml, partRels) {
         try {
             const para = new Paragraph();
-            const runXmls = XMLParser.extractElements(paraXml, 'w:r');
-            for (const runXml of runXmls) {
-                const runObj = XMLParser.parseToObject(runXml, { trimValues: false });
-                const run = this.parseRunFromObject(runObj['w:r']);
-                if (run) {
-                    para.addRun(run);
+            const paraObj = XMLParser.parseToObject(paraXml, { trimValues: false });
+            const pElement = paraObj['w:p'];
+            if (pElement?.['w:pPr']) {
+                this.parseParagraphPropertiesFromObject(pElement['w:pPr'], para);
+            }
+            const pPrEnd = paraXml.indexOf('</w:pPr>');
+            const contentStart = pPrEnd !== -1 ? pPrEnd + '</w:pPr>'.length : paraXml.indexOf('>') + 1;
+            const contentEnd = paraXml.lastIndexOf('</w:p>');
+            if (contentEnd <= contentStart) {
+                return para;
+            }
+            const content = paraXml.substring(contentStart, contentEnd);
+            let searchPos = 0;
+            while (searchPos < content.length) {
+                const tagStart = content.indexOf('<', searchPos);
+                if (tagStart === -1)
+                    break;
+                const tagEnd = content.indexOf('>', tagStart);
+                if (tagEnd === -1)
+                    break;
+                const tagBody = content.substring(tagStart + 1, tagEnd);
+                const tagName = tagBody.split(/[\s/>]/)[0];
+                const selfClosing = tagBody.endsWith('/');
+                if ((tagName === 'w:r' || tagName === 'w:hyperlink') && !selfClosing) {
+                    const closingTag = `</${tagName}>`;
+                    const closingPos = content.indexOf(closingTag, tagEnd);
+                    const childEnd = closingPos === -1 ? tagEnd + 1 : closingPos + closingTag.length;
+                    const childXml = content.substring(tagStart, childEnd);
+                    const childObj = XMLParser.parseToObject(childXml, { trimValues: false });
+                    if (tagName === 'w:r') {
+                        const run = this.parseRunFromObject(childObj['w:r']);
+                        if (run) {
+                            para.addRun(run);
+                        }
+                    }
+                    else {
+                        const result = this.parseHyperlinkFromObject(childObj['w:hyperlink'], partRels ?? RelationshipManager.create());
+                        if (result.hyperlink) {
+                            para.addHyperlink(result.hyperlink);
+                        }
+                        for (const bookmark of result.bookmarkStarts) {
+                            para.addBookmarkStart(bookmark);
+                        }
+                        for (const bookmark of result.bookmarkEnds) {
+                            para.addBookmarkEnd(bookmark);
+                        }
+                    }
+                    searchPos = childEnd;
+                }
+                else {
+                    searchPos = tagEnd + 1;
                 }
             }
             return para;
@@ -1417,11 +1617,28 @@ export class DocumentParser {
                         if (elementIndex < runArray.length) {
                             const child = runArray[elementIndex];
                             if (child['w:drawing']) {
+                                let imageRun = null;
                                 if (zipHandler && imageManager) {
-                                    const imageRun = await this.parseDrawingFromObject(child['w:drawing'], zipHandler, relationshipManager, imageManager);
-                                    if (imageRun) {
-                                        this.parseRunPropertiesFromObject(child['w:rPr'], imageRun);
-                                        paragraph.addRun(imageRun);
+                                    imageRun = await this.parseDrawingFromObject(child['w:drawing'], zipHandler, relationshipManager, imageManager);
+                                }
+                                if (imageRun) {
+                                    this.parseRunPropertiesFromObject(child['w:rPr'], imageRun);
+                                    paragraph.addRun(imageRun);
+                                    if (child['w:t'] ||
+                                        child['w:tab'] ||
+                                        child['w:br'] ||
+                                        child['w:cr'] ||
+                                        child['w:noBreakHyphen']) {
+                                        const siblingRun = this.parseRunFromObject(child);
+                                        if (siblingRun) {
+                                            paragraph.addRun(siblingRun);
+                                        }
+                                    }
+                                }
+                                else {
+                                    const runXml = this.objectToXml({ 'w:r': child });
+                                    if (runXml) {
+                                        paragraph.addContent(new PreservedElement(runXml, 'w:r', 'inline'));
                                     }
                                 }
                             }
@@ -1470,11 +1687,28 @@ export class DocumentParser {
                 const runChildren = Array.isArray(runs) ? runs : runs ? [runs] : [];
                 for (const child of runChildren) {
                     if (child['w:drawing']) {
+                        let imageRun = null;
                         if (zipHandler && imageManager) {
-                            const imageRun = await this.parseDrawingFromObject(child['w:drawing'], zipHandler, relationshipManager, imageManager);
-                            if (imageRun) {
-                                this.parseRunPropertiesFromObject(child['w:rPr'], imageRun);
-                                paragraph.addRun(imageRun);
+                            imageRun = await this.parseDrawingFromObject(child['w:drawing'], zipHandler, relationshipManager, imageManager);
+                        }
+                        if (imageRun) {
+                            this.parseRunPropertiesFromObject(child['w:rPr'], imageRun);
+                            paragraph.addRun(imageRun);
+                            if (child['w:t'] ||
+                                child['w:tab'] ||
+                                child['w:br'] ||
+                                child['w:cr'] ||
+                                child['w:noBreakHyphen']) {
+                                const siblingRun = this.parseRunFromObject(child);
+                                if (siblingRun) {
+                                    paragraph.addRun(siblingRun);
+                                }
+                            }
+                        }
+                        else {
+                            const runXml = this.objectToXml({ 'w:r': child });
+                            if (runXml) {
+                                paragraph.addContent(new PreservedElement(runXml, 'w:r', 'inline'));
                             }
                         }
                     }
@@ -2899,9 +3133,9 @@ export class DocumentParser {
                     return '';
                 }
                 if (typeof node === 'object') {
-                    return XMLBuilder.unescapeXml(node['#text'] || '');
+                    return node['#text'] != null ? String(node['#text']) : '';
                 }
-                return XMLBuilder.unescapeXml(String(node));
+                return String(node);
             };
             const parseBooleanAttr = (value) => {
                 if (value === undefined || value === null) {
@@ -3504,13 +3738,18 @@ export class DocumentParser {
                 anchor: finalAnchor,
                 text: displayText,
                 formatting,
+                preserveFormatting: true,
                 tooltip,
                 relationshipId: finalRelationshipId,
                 tgtFrame,
                 history,
                 docLocation,
             });
-            if (parsedRun && parsedRun.getContent().length > 1) {
+            if (parsedRuns.length > 1 && (text || parsedRuns.some((r) => r.getContent().length > 1))) {
+                hyperlink.setRuns(parsedRuns);
+            }
+            else if (parsedRun &&
+                ((parsedRuns.length === 1 && text) || parsedRun.getContent().length > 1)) {
                 hyperlink.setRun(parsedRun);
             }
             result.hyperlink = hyperlink;
@@ -3664,6 +3903,26 @@ export class DocumentParser {
                 fldLock,
                 dirty,
             });
+            const resultRuns = fieldObj['w:r'];
+            const resultRunArray = Array.isArray(resultRuns)
+                ? resultRuns
+                : resultRuns
+                    ? [resultRuns]
+                    : [];
+            const cachedRuns = [];
+            for (const runObj of resultRunArray) {
+                const run = this.parseRunFromObject(runObj);
+                if (run) {
+                    const runFormatting = run.getFormatting();
+                    cachedRuns.push({
+                        text: run.getText(),
+                        formatting: Object.keys(runFormatting).length > 0 ? runFormatting : undefined,
+                    });
+                }
+            }
+            if (cachedRuns.length > 0) {
+                field.setCachedResultRuns(cachedRuns);
+            }
             return field;
         }
         catch (error) {
@@ -3850,7 +4109,7 @@ export class DocumentParser {
         if (rPrObj['w:rFonts']) {
             const rFonts = rPrObj['w:rFonts'];
             if (rFonts['@_w:ascii'] !== undefined)
-                run.setFont(String(rFonts['@_w:ascii']));
+                run.setFontAscii(String(rFonts['@_w:ascii']));
             if (rFonts['@_w:hAnsi'] !== undefined)
                 run.setFontHAnsi(String(rFonts['@_w:hAnsi']));
             if (rFonts['@_w:eastAsia'] !== undefined)
@@ -4625,8 +4884,9 @@ export class DocumentParser {
                     'wp:cNvGraphicFramePr',
                     'a:graphic',
                 ]);
-                if (anchorExtras)
-                    image._setRawPassthrough('anchor-extra', anchorExtras);
+                if (anchorExtras) {
+                    image._setRawPassthrough('anchor-extra', normalizeAnchorSizeRel(anchorExtras));
+                }
             }
             if (docPrObj) {
                 const docPrExtras = this.collectUnmodeledChildren(docPrObj, []);
@@ -4675,7 +4935,9 @@ export class DocumentParser {
             type = 'none';
         return {
             type,
-            side: wrapObj['@_wrapText'] || 'bothSides',
+            side: type === 'none' || type === 'topAndBottom'
+                ? wrapObj['@_wrapText']
+                : wrapObj['@_wrapText'] || 'bothSides',
             distanceTop: wrapObj['@_distT'] ? parseInt(wrapObj['@_distT'], 10) : undefined,
             distanceBottom: wrapObj['@_distB'] ? parseInt(wrapObj['@_distB'], 10) : undefined,
             distanceLeft: wrapObj['@_distL'] ? parseInt(wrapObj['@_distL'], 10) : undefined,
@@ -5663,7 +5925,7 @@ export class DocumentParser {
         }
         return depth === 0 ? pos : -1;
     }
-    async parseSDTFromObject(sdtObj, relationshipManager, zipHandler, imageManager) {
+    async parseSDTFromObject(sdtObj, relationshipManager, zipHandler, imageManager, rawSdtXml) {
         try {
             if (!sdtObj)
                 return null;
@@ -5724,10 +5986,14 @@ export class DocumentParser {
                 else if (sdtPr['w14:checkbox']) {
                     properties.controlType = 'checkbox';
                     const checkboxElement = sdtPr['w14:checkbox'];
+                    const rawCheckedFont = checkboxElement?.['w14:checkedState']?.['@_w14:font'];
+                    const rawUncheckedFont = checkboxElement?.['w14:uncheckedState']?.['@_w14:font'];
                     properties.checkbox = {
                         checked: parseOoxmlBoolean(checkboxElement?.['w14:checked'], '@_w14:val'),
                         checkedState: String(checkboxElement?.['w14:checkedState']?.['@_w14:val'] ?? ''),
                         uncheckedState: String(checkboxElement?.['w14:uncheckedState']?.['@_w14:val'] ?? ''),
+                        checkedFont: rawCheckedFont === undefined ? undefined : String(rawCheckedFont),
+                        uncheckedFont: rawUncheckedFont === undefined ? undefined : String(rawUncheckedFont),
                     };
                 }
                 else if (sdtPr['w:picture']) {
@@ -5782,6 +6048,32 @@ export class DocumentParser {
                     properties.showingPlcHdr = parseOoxmlBoolean(showingPlcHdr);
                 }
             }
+            let rawSdtPrXml;
+            if (sdtPr !== undefined) {
+                if (rawSdtXml) {
+                    const prPos = rawSdtXml.indexOf('<w:sdtPr');
+                    if (prPos !== -1) {
+                        rawSdtPrXml = this.extractSingleElement(rawSdtXml, 'w:sdtPr', prPos) || undefined;
+                    }
+                }
+                if (rawSdtPrXml === undefined) {
+                    rawSdtPrXml = this.objectToXml({ 'w:sdtPr': sdtPr }) || undefined;
+                }
+            }
+            let rawSdtEndPrXml;
+            const sdtEndPr = sdtObj['w:sdtEndPr'];
+            if (sdtEndPr !== undefined) {
+                if (rawSdtXml) {
+                    const endPrPos = rawSdtXml.indexOf('<w:sdtEndPr');
+                    if (endPrPos !== -1) {
+                        rawSdtEndPrXml =
+                            this.extractSingleElement(rawSdtXml, 'w:sdtEndPr', endPrPos) || undefined;
+                    }
+                }
+                if (rawSdtEndPrXml === undefined) {
+                    rawSdtEndPrXml = this.objectToXml({ 'w:sdtEndPr': sdtEndPr }) || undefined;
+                }
+            }
             const content = [];
             const sdtContent = sdtObj['w:sdtContent'];
             if (sdtContent) {
@@ -5825,6 +6117,19 @@ export class DocumentParser {
                                     content.push(nestedSdt);
                             }
                         }
+                        else if (!elementType.startsWith('@_') && elementType !== '#text') {
+                            const others = sdtContent[elementType];
+                            const otherArray = Array.isArray(others)
+                                ? others
+                                : others !== undefined
+                                    ? [others]
+                                    : [];
+                            if (elementIndex < otherArray.length) {
+                                const rawXml = this.objectToXml({ [elementType]: otherArray[elementIndex] });
+                                if (rawXml)
+                                    content.push(new PreservedElement(rawXml, elementType, 'block'));
+                            }
+                        }
                     }
                 }
                 else {
@@ -5850,6 +6155,27 @@ export class DocumentParser {
                         if (nestedSdt)
                             content.push(nestedSdt);
                     }
+                    for (const key of Object.keys(sdtContent)) {
+                        if (key === 'w:p' ||
+                            key === 'w:tbl' ||
+                            key === 'w:sdt' ||
+                            key === '#text' ||
+                            key === '_orderedChildren' ||
+                            key.startsWith('@_')) {
+                            continue;
+                        }
+                        const others = sdtContent[key];
+                        const otherArray = Array.isArray(others)
+                            ? others
+                            : others !== undefined
+                                ? [others]
+                                : [];
+                        for (const otherObj of otherArray) {
+                            const rawXml = this.objectToXml({ [key]: otherObj });
+                            if (rawXml)
+                                content.push(new PreservedElement(rawXml, key, 'block'));
+                        }
+                    }
                 }
             }
             if (properties.buildingBlock?.gallery === 'Table of Contents') {
@@ -5858,7 +6184,12 @@ export class DocumentParser {
                     return new TableOfContentsElement(toc);
                 }
             }
-            return new StructuredDocumentTag(properties, content);
+            const sdt = new StructuredDocumentTag(properties, content);
+            if (rawSdtPrXml !== undefined)
+                sdt._setRawSdtPrXml(rawSdtPrXml);
+            if (rawSdtEndPrXml !== undefined)
+                sdt._setRawSdtEndPrXml(rawSdtEndPrXml);
+            return sdt;
         }
         catch (error) {
             defaultLogger.warn('[DocumentParser] Failed to parse SDT:', error instanceof Error
@@ -6117,10 +6448,10 @@ export class DocumentParser {
     }
     objectToXml(obj) {
         const buildXml = (o, name) => {
-            if (typeof o === 'string')
-                return o;
-            if (typeof o !== 'object')
-                return String(o);
+            if (typeof o !== 'object' || o === null) {
+                const text = String(o ?? '');
+                return name ? `<${name}>${text}</${name}>` : text;
+            }
             const keys = Object.keys(o);
             if (keys.length === 0 && !name)
                 return '';
@@ -6391,6 +6722,8 @@ export class DocumentParser {
                     return null;
                 }
             }
+            const sectPrWithChange = sectPr;
+            sectPr = sectPr.replace(/<w:sectPrChange[\s\S]*?<\/w:sectPrChange>/, '');
             const sectionProps = {};
             const pgSzElements = XMLParser.extractElements(sectPr, 'w:pgSz');
             if (pgSzElements.length > 0) {
@@ -6752,7 +7085,7 @@ export class DocumentParser {
                 }
             }
             const section = new Section(sectionProps);
-            const sectPrChangeElements = XMLParser.extractElements(sectPr, 'w:sectPrChange');
+            const sectPrChangeElements = XMLParser.extractElements(sectPrWithChange, 'w:sectPrChange');
             if (sectPrChangeElements.length > 0 && sectPrChangeElements[0]) {
                 const changeXml = sectPrChangeElements[0];
                 const id = XMLParser.extractAttribute(changeXml, 'w:id') || '0';
@@ -6799,17 +7132,20 @@ export class DocumentParser {
                 }
             }
         }
-        const basedOnElement = XMLParser.extractBetweenTags(styleXml, '<w:basedOn', '</w:basedOn>');
-        const basedOn = basedOnElement
-            ? XMLParser.extractAttribute(`<w:basedOn${basedOnElement}`, 'w:val')
-            : undefined;
-        const nextElement = XMLParser.extractBetweenTags(styleXml, '<w:next', '</w:next>');
-        const next = nextElement
-            ? XMLParser.extractAttribute(`<w:next${nextElement}`, 'w:val')
-            : undefined;
+        let basedOn;
+        const basedOnAttrs = XMLParser.extractSelfClosingTag(styleXml, 'w:basedOn');
+        if (basedOnAttrs) {
+            basedOn = XMLParser.extractAttribute(`<w:basedOn${basedOnAttrs}/>`, 'w:val');
+        }
+        let next;
+        const nextAttrs = XMLParser.extractSelfClosingTag(styleXml, 'w:next');
+        if (nextAttrs) {
+            next = XMLParser.extractAttribute(`<w:next${nextAttrs}/>`, 'w:val');
+        }
+        const styleBase = styleXml.replace(/<w:tblStylePr[\s\S]*?<\/w:tblStylePr>/g, '');
         let paragraphFormatting;
         let styleNumPr;
-        const pPrXml = XMLParser.extractBetweenTags(styleXml, '<w:pPr>', '</w:pPr>');
+        const pPrXml = XMLParser.extractBetweenTags(styleBase, '<w:pPr>', '</w:pPr>');
         if (pPrXml) {
             paragraphFormatting = this.parseParagraphFormattingFromXml(pPrXml);
             const numPrXml = XMLParser.extractBetweenTags(pPrXml, '<w:numPr>', '</w:numPr>');
@@ -6826,7 +7162,7 @@ export class DocumentParser {
             }
         }
         let runFormatting;
-        const rPrXml = XMLParser.extractBetweenTags(styleXml, '<w:rPr>', '</w:rPr>');
+        const rPrXml = XMLParser.extractBetweenTags(styleBase, '<w:rPr>', '</w:rPr>');
         if (rPrXml) {
             runFormatting = this.parseRunFormattingFromXml(rPrXml);
         }
@@ -8029,11 +8365,21 @@ export class DocumentParser {
         return namespaces;
     }
     parseDocumentBackground(docXml) {
-        const bgMatch = /<w:background([^>]*?)\/>/.exec(docXml);
-        if (!bgMatch?.[1])
+        const bgMatch = /<w:background([^>]*?)(\/>|>)/.exec(docXml);
+        if (!bgMatch)
             return undefined;
-        const attrStr = bgMatch[1];
+        const attrStr = bgMatch[1] ?? '';
         const result = {};
+        if (bgMatch[2] === '>') {
+            const innerStart = bgMatch.index + bgMatch[0].length;
+            const closeIndex = docXml.indexOf('</w:background>', innerStart);
+            if (closeIndex !== -1) {
+                const inner = docXml.substring(innerStart, closeIndex);
+                if (inner.length > 0) {
+                    result.rawInnerXml = inner;
+                }
+            }
+        }
         const colorMatch = /w:color="([^"]+)"/.exec(attrStr);
         if (colorMatch?.[1])
             result.color = colorMatch[1];