@a3s-lab/office 0.29.0 → 0.31.0

package/dist/0~work-docx-export.js

@@ -1,8 +1,8 @@
 import jszip from "jszip";
-import { normalizeDocumentBookmarkName, normalizeDocumentEmphasisMark, DOCUMENT_STRIKE_STYLE_ATTRIBUTE, applyDocumentImageIdentityToElement, documentEmphasisMarkFromElement, DOCUMENT_PAGE_BORDER_EDGES, DOCUMENT_UNDERLINE_STYLE_ATTRIBUTE, documentScriptFontSlotFromElement, normalizeDocumentColumns, createDocumentImageIdentityRegistry, serializeDocumentScriptFonts, documentCharacterSpacingTwipsFromElement, uniqueDocumentParagraphIdentity, documentCharacterPositionHalfPointsFromElement, normalizeDocumentTableVerticalAlign, documentTableColumnPercentagesFromElement, normalizeDocumentTextCase, documentTableCellMarginOverridesFromElement, applyDocumentTableRowIdentityToElement, normalizeDocumentBookmarksHtml, documentImageIdentityFromElement, documentTableGeometryFromElement, normalizeDocumentTableRowHeightRule, normalizeDocumentScriptFonts, documentNoteKey, DOCUMENT_LEGACY_TEXT_EMBOSS_ATTRIBUTE, normalizeDocumentHiddenText, documentLegacyTextEffectsConflict, normalizeDocumentTableBorderWidth, normalizeDocumentCharacterSpacingTwips, normalizeDocumentParagraphId, documentStrikeFormattingFromElement, normalizeDocumentTableBorderStyle, normalizeDocumentBookmarkReferencesHtml, documentCitationInstruction, documentImageWrapContourFromElement, documentImagePositionFromElement, normalizeDocumentCharacterScalePercent, documentScriptFontsFromElement, normalizeDocumentUnderlineStyle, documentPageMarginsForLayout, normalizeDocumentPageChrome, normalizeDocumentImageLayer, documentFontNameFromCssFamily, documentKerningThresholdHalfPointsFromElement, documentImageCropFromElement, documentBookmarkReferenceInstruction, normalizeDocumentPageBorders, documentImageLayerFromElement, normalizeDocumentLegacyTextEffects, documentCaptionLabel, documentCaptionKind, applyDocumentParagraphIdentityToElement, DOCUMENT_LEGACY_TEXT_IMPRINT_ATTRIBUTE, isContourImageLayout, parseDocumentScriptFonts, normalizeDocumentStrikeStyle, normalizeDocumentImageIdentity, createDocumentParagraphIdentityRegistry, documentCitationTags, docxDocumentFieldKind, normalizeTableColor, documentTableBordersFromElement, documentSections, wrapsBesideImage, normalizeDocumentCharacterPositionHalfPoints, normalizeDocumentKerningThresholdHalfPoints, defaultDocumentImageWrapContour, normalizeDocumentParagraphIdentity, normalizeDocumentPaperSource, DOCUMENT_LEGACY_TEXT_OUTLINE_ATTRIBUTE, documentEquationFromElement, documentLegacyTextEffectsFromElement, parseDocumentCharacterFormatting, documentScriptFontFamily, documentParagraphIdentityFromElement, DOCUMENT_LEGACY_TEXT_SHADOW_ATTRIBUTE, normalizeDocumentEquation, documentUnderlineFormattingFromElement, normalizeDocumentBookmarkNativeId, parseDocumentParagraphShadingElement, DOCUMENT_PAGE_MARGIN_KEYS, uniqueDocumentImageIdentity, documentHiddenTextFromElement, parseDocumentParagraphFormatting, documentImageLayoutFromElement, documentScriptFontSlotFromHint, documentTableRowIdentityFromElement, documentPageHorizontalMarginTwips, collectDocumentNotes, documentPageGeometryForLayout, normalizeDocumentScriptFontSlot, DOCUMENT_LEGACY_TEXT_EFFECT_NAMES, documentCharacterScalePercentFromElement, normalizeDocumentPageMargins, normalizeDocumentLegacyTextEffect, documentNoteKind } from "./6282.js";
-import { normalizeDocumentParagraphBorders, serializeUtf8Xml, DOCUMENT_PARAGRAPH_BORDER_EDGES, normalizeDocumentRunBorder, parseDocumentRunBorder, parseXml, decodeXmlBytes, parseDocxThemeReference, patchDocxThemeReferences, descendants, resolvePartTarget, attribute as work_ooxml_package_attribute, parseDocumentParagraphBordersElement, DOCUMENT_RUN_BORDER_ATTRIBUTE, directChildren, xmlNamespacePrefix, parseDocumentRunBorderElement, DocxThemePatchCollector, directChild } from "./4121.js";
+import { normalizeDocumentBookmarkName, normalizeDocumentEmphasisMark, DOCUMENT_STRIKE_STYLE_ATTRIBUTE, applyDocumentImageIdentityToElement, documentEmphasisMarkFromElement, DOCUMENT_PAGE_BORDER_EDGES, DOCUMENT_UNDERLINE_STYLE_ATTRIBUTE, createDocumentImageIdentityRegistry, normalizeDocumentColumns, normalizeDocumentTableVerticalAlign, normalizeDocumentTextCase, documentCharacterSpacingTwipsFromElement, documentCharacterPositionHalfPointsFromElement, documentTableColumnPercentagesFromElement, documentTableCellMarginOverridesFromElement, applyDocumentTableRowIdentityToElement, normalizeDocumentBookmarksHtml, documentImageIdentityFromElement, documentTableGeometryFromElement, normalizeDocumentTableRowHeightRule, documentNoteKey, DOCUMENT_LEGACY_TEXT_EMBOSS_ATTRIBUTE, normalizeDocumentHiddenText, documentLegacyTextEffectsConflict, normalizeDocumentTableBorderWidth, normalizeDocumentCharacterSpacingTwips, documentStrikeFormattingFromElement, normalizeDocumentTableBorderStyle, normalizeDocumentBookmarkReferencesHtml, documentCitationInstruction, documentImageWrapContourFromElement, documentImagePositionFromElement, normalizeDocumentCharacterScalePercent, normalizeDocumentUnderlineStyle, normalizeDocumentPageChrome, documentPageMarginsForLayout, normalizeDocumentImageLayer, documentKerningThresholdHalfPointsFromElement, documentImageCropFromElement, documentBookmarkReferenceInstruction, normalizeDocumentPageBorders, documentImageLayerFromElement, normalizeDocumentLegacyTextEffects, documentCaptionLabel, documentCaptionKind, DOCUMENT_LEGACY_TEXT_IMPRINT_ATTRIBUTE, isContourImageLayout, normalizeDocumentImageIdentity, normalizeTableColor, normalizeDocumentStrikeStyle, documentTableBordersFromElement, documentSections, documentCitationTags, docxDocumentFieldKind, wrapsBesideImage, normalizeDocumentCharacterPositionHalfPoints, normalizeDocumentKerningThresholdHalfPoints, defaultDocumentImageWrapContour, normalizeDocumentPaperSource, DOCUMENT_LEGACY_TEXT_OUTLINE_ATTRIBUTE, documentEquationFromElement, documentLegacyTextEffectsFromElement, parseDocumentCharacterFormatting, documentUnderlineFormattingFromElement, DOCUMENT_LEGACY_TEXT_SHADOW_ATTRIBUTE, normalizeDocumentEquation, parseDocumentParagraphFormatting, documentTableRowIdentityFromElement, normalizeDocumentBookmarkNativeId, collectDocumentNotes, DOCUMENT_PAGE_MARGIN_KEYS, uniqueDocumentImageIdentity, documentHiddenTextFromElement, documentImageLayoutFromElement, documentPageHorizontalMarginTwips, documentPageGeometryForLayout, DOCUMENT_LEGACY_TEXT_EFFECT_NAMES, documentCharacterScalePercentFromElement, normalizeDocumentPageMargins, normalizeDocumentLegacyTextEffect, documentNoteKind } from "./6282.js";
+import { normalizeDocumentRunBorder, parseDocumentScriptFonts, normalizeDocumentIndexesHtml, parseXml, parseDocumentRunShading, applyDocumentParagraphIdentityToElement, DOCUMENT_RUN_SHADING_ATTRIBUTE, documentScriptFontSlotFromElement, DOCUMENT_HIGHLIGHT_ATTRIBUTE, parseDocxThemeReference, serializeDocumentScriptFonts, attribute as work_ooxml_package_attribute, createDocumentParagraphIdentityRegistry, uniqueDocumentParagraphIdentity, DOCUMENT_NO_PROOF_ATTRIBUTE, documentHighlightForCssColor, directChildren, documentTableOfContentsValueFromElement, DOCUMENT_PROOFING_LANGUAGES_ATTRIBUTE, DocxThemePatchCollector, normalizeDocumentScriptFonts, normalizeDocumentParagraphIdentity, normalizeDocumentHighlight, normalizeDocumentParagraphBorders, serializeUtf8Xml, DOCUMENT_PARAGRAPH_BORDER_EDGES, parseDocumentRunBorder, normalizeDocumentNoProof, decodeXmlBytes, documentParagraphIdentityFromElement, normalizeDocumentParagraphId, documentIndexValueFromElement, descendants, resolvePartTarget, documentProofingLanguagesFromElement, documentScriptFontFamily, parseDocumentRunShadingElement, parseDocumentProofingLanguages, documentHighlightFromElement, parseDocumentParagraphBordersElement, DOCUMENT_RUN_BORDER_ATTRIBUTE, parseDocumentRunBorderElement, xmlNamespacePrefix, documentScriptFontSlotFromHint, documentNoProofFromElement, documentScriptFontsFromElement, normalizeDocumentRunShading, documentIndexEntryFromElement, directChild, normalizeDocumentScriptFontSlot, patchDocxThemeReferences, parseDocumentParagraphShadingElement, documentFontNameFromCssFamily } from "./4121.js";
 import { assignDocxNoteIds, patchDocxPageColor, normalizeDocxCommentId, assignDocxCommentThreads } from "./0~4980.js";
-import { paragraphTabStops, mergeDocxIgnorableExtensionsAtPairs, patchDocxBibliography, docxKerningThresholdValue, docxCharacterPositionValue, docxCharacterScaleValue, docxEmphasisMarkRunOptions, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, paragraphAlignment, paragraphSpacingOptions, xmlNamespaceUri, hasNonWhitespaceXmlText, patchDocxExplicitZeroCharacterSpacing, cloneXmlElement, cssColorToHex, DocxParagraphDefaultCollapsedPatchCollector, assertXmlRoot, xmlDeclaredPrefix, paragraphIndent, domDirection, DOCX_WORDPROCESSING_NAMESPACES, paragraphBidirectional, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, patchDocxParagraphDefaultCollapsed, xmlAttributeNamespace, dataBoolean, mergeDocxIgnorableExtensions, patchDocxExplicitZeroKerningThresholds, parseDocxColorSchemeMappingElement, paragraphPaginationOptions, DOCX_COLOR_SCHEME_MAPPING_ATTRIBUTES, xmlAttributeLocalName, cssFontSize, paragraphDirectionOptions, cssFontFamily, docxCharacterSpacingValue } from "./0~7043.js";
+import { paragraphTabStops, mergeDocxIgnorableExtensionsAtPairs, patchDocxBibliography, docxKerningThresholdValue, docxCharacterPositionValue, documentIndexInstruction, docxCharacterScaleValue, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, paragraphAlignment, xmlNamespaceUri, paragraphSpacingOptions, docxEmphasisMarkRunOptions, documentIndexEntryInstruction, hasNonWhitespaceXmlText, patchDocxExplicitZeroCharacterSpacing, cloneXmlElement, cssColorToHex, xmlDeclaredPrefix, assertXmlRoot, DOCX_WORDPROCESSING_NAMESPACES, paragraphIndent, domDirection, xmlAttributeNamespace, paragraphBidirectional, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, mergeDocxIgnorableExtensions, DocxParagraphDefaultCollapsedPatchCollector, dataBoolean, patchDocxParagraphDefaultCollapsed, patchDocxExplicitZeroKerningThresholds, parseDocxColorSchemeMappingElement, paragraphPaginationOptions, DOCX_COLOR_SCHEME_MAPPING_ATTRIBUTES, documentProofingLanguageDocxOptions, xmlAttributeLocalName, cssFontSize, paragraphDirectionOptions, cssFontFamily, docxCharacterSpacingValue } from "./0~4808.js";
 import { normalizeDocumentHref } from "./0~work-document-links.js";
 const WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 class DocxBookmarkPatchCollector {
@@ -2374,6 +2374,292 @@ function docxDocumentFieldRun(element, docx) {
     if (!docxDocumentFieldKind(instruction)) return new docx.TextRun(display);
     return new docx.SimpleField(instruction, display);
 }
+const work_docx_index_export_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_index_export_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+class DocxIndexPatchCollector {
+    patches = [];
+    add(element) {
+        const value = documentIndexValueFromElement(element);
+        const patch = {
+            marker: `__A3S_WORK_DOCUMENT_INDEX_${this.patches.length + 1}__`,
+            options: value.options,
+            entries: value.entries
+        };
+        this.patches.push(patch);
+        return patch;
+    }
+}
+function docxDocumentIndex(element, docx, collector) {
+    const patch = collector.add(element);
+    return [
+        new docx.Paragraph({
+            children: [
+                new docx.TextRun(patch.marker)
+            ]
+        })
+    ];
+}
+function docxIndexEntryRun(element, docx) {
+    const value = documentIndexEntryFromElement(element);
+    return value ? new docx.SimpleField(documentIndexEntryInstruction(value)) : null;
+}
+async function patchDocxIndexes(buffer, patches) {
+    if (!patches.length) return buffer;
+    const archive = await jszip.loadAsync(buffer);
+    const entry = archive.file('word/document.xml');
+    if (!entry) return buffer;
+    const document = parseXml(await entry.async('text'), 'generated DOCX word/document.xml');
+    const paragraphs = descendants(document, 'p');
+    for (const patch of patches){
+        const paragraph = paragraphs.find((candidate)=>descendants(candidate, 't').some((text)=>(text.textContent ?? '').includes(patch.marker)));
+        if (!paragraph) throw new Error(`Generated DOCX did not emit the marker for document index ${patch.marker}.`);
+        paragraph.replaceWith(createIndexContentControl(document, patch));
+    }
+    archive.file('word/document.xml', new XMLSerializer().serializeToString(document));
+    return archive.generateAsync({
+        type: 'arraybuffer'
+    });
+}
+function createIndexContentControl(document, patch) {
+    const control = wordElement(document, 'sdt');
+    const properties = wordElement(document, 'sdtPr');
+    const documentPart = wordElement(document, 'docPartObj');
+    const gallery = wordElement(document, 'docPartGallery');
+    work_docx_index_export_setWordAttribute(document, gallery, 'val', 'Indexes');
+    documentPart.append(gallery, wordElement(document, 'docPartUnique'));
+    properties.append(documentPart);
+    const content = wordElement(document, 'sdtContent');
+    const fieldStart = indexFieldStartParagraph(document, patch.options);
+    content.append(fieldStart);
+    const cached = cachedIndexParagraphs(document, patch);
+    if (!cached.length) cached.push(emptyIndexParagraph(document));
+    const last = cached.at(-1);
+    last?.append(fieldCharacterRun(document, 'end'));
+    content.append(...cached);
+    control.append(properties, content);
+    return control;
+}
+function indexFieldStartParagraph(document, options) {
+    const paragraph = wordElement(document, 'p');
+    paragraph.append(fieldCharacterRun(document, 'begin'));
+    const instructionRun = wordElement(document, 'r');
+    const instruction = wordElement(document, 'instrText');
+    instruction.setAttributeNS(work_docx_index_export_XML_NAMESPACE, 'xml:space', 'preserve');
+    instruction.textContent = ` ${documentIndexInstruction(options)} `;
+    instructionRun.append(instruction);
+    paragraph.append(instructionRun, fieldCharacterRun(document, 'separate'));
+    return paragraph;
+}
+function cachedIndexParagraphs(document, patch) {
+    const paragraphs = [];
+    let currentMain = '';
+    for (const entry of patch.entries){
+        if (entry.subEntry && entry.mainEntry !== currentMain) paragraphs.push(cachedIndexParagraph(document, patch.options, {
+            style: 'Index1',
+            term: entry.mainEntry,
+            crossReference: '',
+            pages: []
+        }));
+        paragraphs.push(cachedIndexParagraph(document, patch.options, {
+            style: entry.subEntry ? 'Index2' : 'Index1',
+            term: entry.subEntry || entry.mainEntry,
+            crossReference: entry.crossReference,
+            pages: entry.pages
+        }));
+        currentMain = entry.mainEntry;
+    }
+    return paragraphs;
+}
+function cachedIndexParagraph(document, options, source) {
+    const paragraph = wordElement(document, 'p');
+    const properties = wordElement(document, 'pPr');
+    const style = wordElement(document, 'pStyle');
+    work_docx_index_export_setWordAttribute(document, style, 'val', source.style);
+    properties.append(style);
+    if (source.pages.length && options.rightAlignPageNumbers) {
+        const tabs = wordElement(document, 'tabs');
+        const tab = wordElement(document, 'tab');
+        work_docx_index_export_setWordAttribute(document, tab, 'val', 'right');
+        const leader = docxIndexLeader(options.leader);
+        if (leader) work_docx_index_export_setWordAttribute(document, tab, 'leader', leader);
+        work_docx_index_export_setWordAttribute(document, tab, 'pos', '9360');
+        tabs.append(tab);
+        properties.append(tabs);
+    }
+    paragraph.append(properties, textRun(document, source.term));
+    if (source.crossReference) {
+        paragraph.append(textRun(document, `, See ${source.crossReference}`));
+        return paragraph;
+    }
+    if (!source.pages.length) return paragraph;
+    paragraph.append(options.rightAlignPageNumbers ? tabRun(document) : textRun(document, ', '));
+    for (const [index, page] of source.pages.entries()){
+        if (index > 0) paragraph.append(textRun(document, ', '));
+        paragraph.append(textRun(document, String(page.pageNumber), {
+            bold: page.pageBold,
+            italic: page.pageItalic
+        }));
+    }
+    return paragraph;
+}
+function emptyIndexParagraph(document) {
+    const paragraph = wordElement(document, 'p');
+    const properties = wordElement(document, 'pPr');
+    const style = wordElement(document, 'pStyle');
+    work_docx_index_export_setWordAttribute(document, style, 'val', 'Index1');
+    properties.append(style);
+    paragraph.append(properties);
+    return paragraph;
+}
+function textRun(document, value, style = {}) {
+    const run = wordElement(document, 'r');
+    if (style.bold || style.italic) {
+        const properties = wordElement(document, 'rPr');
+        if (style.bold) properties.append(wordElement(document, 'b'));
+        if (style.italic) properties.append(wordElement(document, 'i'));
+        run.append(properties);
+    }
+    const text = wordElement(document, 't');
+    if (/^\s|\s$/.test(value)) text.setAttributeNS(work_docx_index_export_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = value;
+    run.append(text);
+    return run;
+}
+function tabRun(document) {
+    const run = wordElement(document, 'r');
+    run.append(wordElement(document, 'tab'));
+    return run;
+}
+function fieldCharacterRun(document, type) {
+    const run = wordElement(document, 'r');
+    const character = wordElement(document, 'fldChar');
+    work_docx_index_export_setWordAttribute(document, character, 'fldCharType', type);
+    run.append(character);
+    return run;
+}
+function docxIndexLeader(value) {
+    if ('dash' === value) return 'hyphen';
+    if ('underline' === value) return 'underscore';
+    if ('dot' === value) return 'dot';
+    return null;
+}
+function wordElement(document, localName) {
+    return document.createElementNS(work_docx_index_export_WORD_NAMESPACE, wordQualifiedName(document.documentElement, localName));
+}
+function work_docx_index_export_setWordAttribute(document, element, localName, value) {
+    for (const candidate of Array.from(element.attributes))if (candidate.localName === localName && (candidate.namespaceURI === work_docx_index_export_WORD_NAMESPACE || !candidate.namespaceURI)) element.removeAttributeNode(candidate);
+    element.setAttributeNS(work_docx_index_export_WORD_NAMESPACE, wordQualifiedName(document.documentElement, localName), value);
+}
+function wordQualifiedName(root, localName) {
+    return `${xmlNamespacePrefix(root, work_docx_index_export_WORD_NAMESPACE) ?? 'w'}:${localName}`;
+}
+const work_docx_run_shading_export_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+class DocxRunShadingPatchCollector {
+    patches = [];
+    nextMarker = 1;
+    usedColors;
+    constructor(sourceHtml){
+        this.usedColors = work_docx_run_shading_export_sourceColors(sourceHtml);
+    }
+    marker(source) {
+        const shading = normalizeDocumentRunShading(source);
+        if (!shading) return null;
+        let marker = '';
+        do {
+            const value = 0xd00000 + this.nextMarker;
+            if (value > 0xdfffff) throw new Error('DOCX character shading marker space is exhausted.');
+            marker = value.toString(16).padStart(6, '0').toUpperCase();
+            this.nextMarker += 1;
+        }while (this.usedColors.has(marker))
+        this.usedColors.add(marker);
+        this.patches.push({
+            marker,
+            shading
+        });
+        return marker;
+    }
+    hasMarker(value) {
+        const marker = value?.toUpperCase();
+        return Boolean(marker && this.patches.some((patch)=>patch.marker === marker));
+    }
+}
+function documentRunShadingDocxOptions(source, collector) {
+    const marker = collector.marker(source);
+    return marker ? {
+        shading: {
+            type: 'clear',
+            color: 'auto',
+            fill: marker
+        }
+    } : {};
+}
+async function patchDocxRunShading(buffer, patches) {
+    if (!patches.length) return buffer;
+    const archive = await jszip.loadAsync(buffer);
+    const byMarker = new Map(patches.map((patch)=>[
+            patch.marker,
+            patch
+        ]));
+    const applied = new Set();
+    for (const entry of Object.values(archive.files)){
+        if (entry.dir || !/^word\/(?:document|header\d+|footer\d+|footnotes|endnotes|comments)\.xml$/i.test(entry.name)) continue;
+        const document = parseXml(await entry.async('text'), entry.name);
+        let changed = false;
+        for (const element of Array.from(document.getElementsByTagName('*'))){
+            if ('shd' !== element.localName || element.namespaceURI !== work_docx_run_shading_export_WORD_NAMESPACE || element.parentElement?.localName !== 'rPr') continue;
+            const marker = work_docx_run_shading_export_wordAttribute(element, 'fill')?.toUpperCase();
+            const patch = marker ? byMarker.get(marker) : void 0;
+            if (marker && patch) {
+                replaceRunShadingAttributes(document, element, patch.shading);
+                applied.add(marker);
+                changed = true;
+            }
+        }
+        if (changed) archive.file(entry.name, serializeUtf8Xml(document));
+    }
+    const missing = patches.filter((patch)=>!applied.has(patch.marker));
+    if (missing.length) throw new Error(`Generated DOCX is missing ${missing.length} character shading marker(s).`);
+    return archive.generateAsync({
+        type: 'arraybuffer'
+    });
+}
+function setDocxRunShadingAttributes(document, element, source) {
+    const shading = normalizeDocumentRunShading(source);
+    if (!shading) return false;
+    work_docx_run_shading_export_setWordAttribute(document, element, 'val', shading.pattern);
+    setShadingColorAttributes(document, element, shading.color, 'color');
+    setShadingColorAttributes(document, element, shading.fill, 'fill');
+    return true;
+}
+function replaceRunShadingAttributes(document, element, shading) {
+    for (const attribute of Array.from(element.attributes))if ('xmlns' !== attribute.name && !attribute.name.startsWith('xmlns:')) element.removeAttributeNode(attribute);
+    element.replaceChildren();
+    setDocxRunShadingAttributes(document, element, shading);
+}
+function setShadingColorAttributes(document, element, color, kind) {
+    if (!color) return;
+    work_docx_run_shading_export_setWordAttribute(document, element, kind, 'auto' === color.value ? 'auto' : color.value.slice(1).toUpperCase());
+    if (!color.theme) return;
+    const themeName = 'color' === kind ? 'themeColor' : 'themeFill';
+    const tintName = 'color' === kind ? 'themeTint' : 'themeFillTint';
+    const shadeName = 'color' === kind ? 'themeShade' : 'themeFillShade';
+    work_docx_run_shading_export_setWordAttribute(document, element, themeName, color.theme.theme);
+    if (color.theme.tint) work_docx_run_shading_export_setWordAttribute(document, element, tintName, color.theme.tint);
+    if (color.theme.shade) work_docx_run_shading_export_setWordAttribute(document, element, shadeName, color.theme.shade);
+}
+function work_docx_run_shading_export_sourceColors(source) {
+    const colors = new Set();
+    for (const match of source.matchAll(/#([0-9a-f]{6})\b/gi))if (match[1]) colors.add(match[1].toUpperCase());
+    return colors;
+}
+function work_docx_run_shading_export_wordAttribute(element, name) {
+    return element.getAttributeNS(element.namespaceURI ?? work_docx_run_shading_export_WORD_NAMESPACE, name) ?? element.getAttribute(`${element.prefix ?? 'w'}:${name}`);
+}
+function work_docx_run_shading_export_setWordAttribute(document, element, name, value) {
+    const namespace = element.namespaceURI ?? work_docx_run_shading_export_WORD_NAMESPACE;
+    const prefix = element.prefix ?? xmlNamespacePrefix(document.documentElement, namespace) ?? 'w';
+    element.setAttributeNS(namespace, `${prefix}:${name}`, value);
+}
 const MAX_RUN_FORMATTING_CHANGE_PATCHES = 65536;
 const RUN_FORMATTING_PART_PATTERN = /^word\/(?:document|header\d*|footer\d*|footnotes|endnotes)\.xml$/i;
 class DocxRunFormattingChangePatchCollector {
@@ -2474,17 +2760,17 @@ function setRunFormattingChange(document, run, patch) {
     if (existing.length > 1) throw new Error('Generated DOCX run contains duplicate properties.');
     const properties = existing[0] ?? insertRunProperties(document, run, wordNamespace, prefix);
     if (directChildren(properties, 'rPrChange').some((element)=>element.namespaceURI === wordNamespace)) throw new Error('Generated DOCX run already contains a formatting revision.');
-    const change = wordElement(document, wordNamespace, prefix, 'rPrChange');
+    const change = work_docx_format_change_export_wordElement(document, wordNamespace, prefix, 'rPrChange');
     work_docx_format_change_export_setWordAttribute(change, wordNamespace, prefix, 'id', String(patch.id));
     work_docx_format_change_export_setWordAttribute(change, wordNamespace, prefix, 'author', patch.author);
     work_docx_format_change_export_setWordAttribute(change, wordNamespace, prefix, 'date', patch.date);
-    const before = wordElement(document, wordNamespace, prefix, 'rPr');
+    const before = work_docx_format_change_export_wordElement(document, wordNamespace, prefix, 'rPr');
     appendFormattingProperties(document, before, wordNamespace, prefix, patch.before);
     change.append(before);
     properties.append(change);
 }
 function insertRunProperties(document, run, namespace, prefix) {
-    const properties = wordElement(document, namespace, prefix, 'rPr');
+    const properties = work_docx_format_change_export_wordElement(document, namespace, prefix, 'rPr');
     run.insertBefore(properties, run.firstChild);
     return properties;
 }
@@ -2503,6 +2789,7 @@ function appendFormattingProperties(document, properties, namespace, prefix, ser
     appendTextCaseProperties(document, properties, namespace, prefix, byType.get('textStyle'));
     appendStrikeProperties(document, properties, namespace, prefix, byType.get('strike'));
     appendLegacyTextEffectsProperties(document, properties, namespace, prefix, byType.get('textStyle'));
+    appendNoProofProperty(document, properties, namespace, prefix, byType.get('textStyle'));
     appendSnapToGridProperty(document, properties, namespace, prefix, byType.get('textStyle'));
     appendHiddenTextProperty(document, properties, namespace, prefix, byType.get('textStyle'));
     appendColorProperty(document, properties, namespace, prefix, byType.get('textStyle'));
@@ -2511,16 +2798,33 @@ function appendFormattingProperties(document, properties, namespace, prefix, ser
     appendKerningThresholdProperty(document, properties, namespace, prefix, byType.get('textStyle'));
     appendCharacterPositionProperty(document, properties, namespace, prefix, byType.get('textStyle'));
     appendFontSizeProperties(document, properties, namespace, prefix, byType.get('textStyle'));
-    appendHighlightProperty(document, properties, namespace, prefix, byType.get('highlight'));
+    appendHighlightProperty(document, properties, namespace, prefix, byType.get('highlight'), !parseDocumentRunShading(byType.get('textStyle')?.attrs?.runShading));
     appendUnderlineProperty(document, properties, namespace, prefix, byType.get('underline'));
     appendRunBorderProperty(document, properties, namespace, prefix, byType.get('textStyle'));
+    appendRunShadingProperty(document, properties, namespace, prefix, byType.get('textStyle'));
     appendVerticalAlignProperty(document, properties, namespace, prefix, byType);
     appendEmphasisMarkProperty(document, properties, namespace, prefix, byType.get('textStyle'));
+    appendProofingLanguagesProperty(document, properties, namespace, prefix, byType.get('textStyle'));
+}
+function appendNoProofProperty(document, properties, namespace, prefix, mark) {
+    const noProof = normalizeDocumentNoProof(mark?.attrs?.noProof);
+    if (null === noProof) return;
+    if (noProof) properties.append(work_docx_format_change_export_wordElement(document, namespace, prefix, 'noProof'));
+    else appendValuedProperty(document, properties, namespace, prefix, 'noProof', '0');
+}
+function appendProofingLanguagesProperty(document, properties, namespace, prefix, mark) {
+    const languages = parseDocumentProofingLanguages(mark?.attrs?.proofingLanguages);
+    if (!languages) return;
+    const element = work_docx_format_change_export_wordElement(document, namespace, prefix, 'lang');
+    if (languages.latin) work_docx_format_change_export_setWordAttribute(element, namespace, prefix, 'val', languages.latin);
+    if (languages.eastAsia) work_docx_format_change_export_setWordAttribute(element, namespace, prefix, 'eastAsia', languages.eastAsia);
+    if (languages.bidi) work_docx_format_change_export_setWordAttribute(element, namespace, prefix, 'bidi', languages.bidi);
+    properties.append(element);
 }
 function appendRunBorderProperty(document, properties, namespace, prefix, mark) {
     const border = parseDocumentRunBorder(mark?.attrs?.runBorder);
     if (!border) return;
-    const element = wordElement(document, namespace, prefix, 'bdr');
+    const element = work_docx_format_change_export_wordElement(document, namespace, prefix, 'bdr');
     work_docx_format_change_export_setWordAttribute(element, namespace, prefix, 'val', border.style);
     if (border.color) {
         work_docx_format_change_export_setWordAttribute(element, namespace, prefix, 'color', 'auto' === border.color.value ? 'auto' : border.color.value.slice(1).toUpperCase());
@@ -2536,6 +2840,13 @@ function appendRunBorderProperty(document, properties, namespace, prefix, mark)
     if (void 0 !== border.frame) work_docx_format_change_export_setWordAttribute(element, namespace, prefix, 'frame', border.frame ? '1' : '0');
     properties.append(element);
 }
+function appendRunShadingProperty(document, properties, namespace, prefix, mark) {
+    const shading = parseDocumentRunShading(mark?.attrs?.runShading);
+    if (!shading) return;
+    const element = work_docx_format_change_export_wordElement(document, namespace, prefix, 'shd');
+    if (!setDocxRunShadingAttributes(document, element, shading)) return;
+    properties.append(element);
+}
 function appendLegacyTextEffectsProperties(document, properties, namespace, prefix, mark) {
     const effects = {};
     const attributes = [
@@ -2563,14 +2874,14 @@ function appendLegacyTextEffectsProperties(document, properties, namespace, pref
     if (documentLegacyTextEffectsConflict(effects)) throw new Error('Document contains conflicting legacy text effects.');
     for (const name of DOCUMENT_LEGACY_TEXT_EFFECT_NAMES){
         const value = effects[name];
-        if (void 0 !== value) if (value) properties.append(wordElement(document, namespace, prefix, name));
+        if (void 0 !== value) if (value) properties.append(work_docx_format_change_export_wordElement(document, namespace, prefix, name));
         else appendValuedProperty(document, properties, namespace, prefix, name, '0');
     }
 }
 function appendHiddenTextProperty(document, properties, namespace, prefix, mark) {
     const hiddenText = normalizeDocumentHiddenText(mark?.attrs?.hiddenText);
     if (null === hiddenText) return;
-    if (hiddenText) properties.append(wordElement(document, namespace, prefix, 'vanish'));
+    if (hiddenText) properties.append(work_docx_format_change_export_wordElement(document, namespace, prefix, 'vanish'));
     else appendValuedProperty(document, properties, namespace, prefix, 'vanish', '0');
 }
 function appendEmphasisMarkProperty(document, properties, namespace, prefix, mark) {
@@ -2601,7 +2912,7 @@ function appendCharacterSpacingProperty(document, properties, namespace, prefix,
 function appendFontProperties(document, properties, namespace, prefix, mark) {
     const scriptFonts = parseDocumentScriptFonts('string' == typeof mark?.attrs?.scriptFonts ? mark.attrs.scriptFonts : void 0);
     if (scriptFonts) {
-        const fonts = wordElement(document, namespace, prefix, 'rFonts');
+        const fonts = work_docx_format_change_export_wordElement(document, namespace, prefix, 'rFonts');
         for (const [name, value] of [
             [
                 'ascii',
@@ -2645,7 +2956,7 @@ function appendFontProperties(document, properties, namespace, prefix, mark) {
     }
     const family = firstFontFamily(mark?.attrs?.fontFamily);
     if (!family) return;
-    const fonts = wordElement(document, namespace, prefix, 'rFonts');
+    const fonts = work_docx_format_change_export_wordElement(document, namespace, prefix, 'rFonts');
     for (const name of [
         'ascii',
         'hAnsi',
@@ -2659,7 +2970,7 @@ function appendUnderlineProperty(document, properties, namespace, prefix, mark)
     const style = normalizeDocumentUnderlineStyle(mark.attrs?.underlineStyle) ?? 'single';
     const color = normalizedHex(mark.attrs?.underlineColor);
     const theme = themeReference(mark.attrs?.underlineThemeColor);
-    const underline = wordElement(document, namespace, prefix, 'u');
+    const underline = work_docx_format_change_export_wordElement(document, namespace, prefix, 'u');
     work_docx_format_change_export_setWordAttribute(underline, namespace, prefix, 'val', style);
     const resolved = color ?? normalizedHex(theme?.resolved);
     if (resolved) work_docx_format_change_export_setWordAttribute(underline, namespace, prefix, 'color', resolved);
@@ -2667,7 +2978,7 @@ function appendUnderlineProperty(document, properties, namespace, prefix, mark)
     properties.append(underline);
 }
 function appendBooleanProperty(document, properties, namespace, prefix, marks, mark, property) {
-    if (marks.has(mark)) properties.append(wordElement(document, namespace, prefix, property));
+    if (marks.has(mark)) properties.append(work_docx_format_change_export_wordElement(document, namespace, prefix, property));
 }
 function appendStrikeProperties(document, properties, namespace, prefix, mark) {
     if (!mark) return;
@@ -2676,14 +2987,14 @@ function appendStrikeProperties(document, properties, namespace, prefix, mark) {
     appendValuedProperty(document, properties, namespace, prefix, 'dstrike', 'double' === style ? '1' : '0');
 }
 function appendValuedProperty(document, properties, namespace, prefix, property, value) {
-    const element = wordElement(document, namespace, prefix, property);
+    const element = work_docx_format_change_export_wordElement(document, namespace, prefix, property);
     work_docx_format_change_export_setWordAttribute(element, namespace, prefix, 'val', value);
     properties.append(element);
 }
 function appendTextCaseProperties(document, properties, namespace, prefix, mark) {
     const textCase = mark?.attrs?.textCase;
-    if ('all-caps' === textCase) properties.append(wordElement(document, namespace, prefix, 'caps'));
-    else if ('small-caps' === textCase) properties.append(wordElement(document, namespace, prefix, 'smallCaps'));
+    if ('all-caps' === textCase) properties.append(work_docx_format_change_export_wordElement(document, namespace, prefix, 'caps'));
+    else if ('small-caps' === textCase) properties.append(work_docx_format_change_export_wordElement(document, namespace, prefix, 'smallCaps'));
     else if ('none' === textCase) {
         appendValuedProperty(document, properties, namespace, prefix, 'caps', '0');
         appendValuedProperty(document, properties, namespace, prefix, 'smallCaps', '0');
@@ -2693,7 +3004,7 @@ function appendColorProperty(document, properties, namespace, prefix, mark) {
     const color = normalizedHex(mark?.attrs?.color);
     const theme = themeReference(mark?.attrs?.themeColor);
     if (!color && !theme) return;
-    const element = wordElement(document, namespace, prefix, 'color');
+    const element = work_docx_format_change_export_wordElement(document, namespace, prefix, 'color');
     work_docx_format_change_export_setWordAttribute(element, namespace, prefix, 'val', color ?? normalizedHex(theme?.resolved) ?? '000000');
     if (theme) setThemeAttributes(element, namespace, prefix, theme, 'themeColor');
     properties.append(element);
@@ -2704,11 +3015,14 @@ function appendFontSizeProperties(document, properties, namespace, prefix, mark)
     appendValuedProperty(document, properties, namespace, prefix, 'sz', String(halfPoints));
     appendValuedProperty(document, properties, namespace, prefix, 'szCs', String(halfPoints));
 }
-function appendHighlightProperty(document, properties, namespace, prefix, mark) {
+function appendHighlightProperty(document, properties, namespace, prefix, mark, allowFallbackShading) {
+    const nativeHighlight = normalizeDocumentHighlight(mark?.attrs?.nativeHighlight) ?? documentHighlightForCssColor(mark?.attrs?.color);
+    if (nativeHighlight) return void appendValuedProperty(document, properties, namespace, prefix, 'highlight', nativeHighlight);
+    if (!allowFallbackShading) return;
     const fill = normalizedHex(mark?.attrs?.color);
     const theme = themeReference(mark?.attrs?.themeFill);
     if (!fill && !theme) return;
-    const shading = wordElement(document, namespace, prefix, 'shd');
+    const shading = work_docx_format_change_export_wordElement(document, namespace, prefix, 'shd');
     work_docx_format_change_export_setWordAttribute(shading, namespace, prefix, 'val', 'clear');
     work_docx_format_change_export_setWordAttribute(shading, namespace, prefix, 'color', 'auto');
     work_docx_format_change_export_setWordAttribute(shading, namespace, prefix, 'fill', fill ?? normalizedHex(theme?.resolved) ?? 'FFFFFF');
@@ -2756,7 +3070,7 @@ function normalizedHex(value) {
     const match = /^#?([0-9a-f]{6})$/i.exec(value.trim());
     return match?.[1]?.toUpperCase() ?? null;
 }
-function wordElement(document, namespace, prefix, name) {
+function work_docx_format_change_export_wordElement(document, namespace, prefix, name) {
     return document.createElementNS(namespace, `${prefix}:${name}`);
 }
 function work_docx_format_change_export_setWordAttribute(element, namespace, prefix, name, value) {
@@ -3530,10 +3844,10 @@ async function patchDocxNumberingRestartRules(buffer, rules) {
             if (!definition) continue;
             let restart = directChild(definition, 'lvlRestart');
             if (!restart) {
-                restart = document.createElementNS(work_docx_numbering_WORD_NAMESPACE, wordQualifiedName(document.documentElement, 'lvlRestart'));
+                restart = document.createElementNS(work_docx_numbering_WORD_NAMESPACE, work_docx_numbering_wordQualifiedName(document.documentElement, 'lvlRestart'));
                 definition.insertBefore(restart, directChild(definition, 'pPr') ?? null);
             }
-            restart.setAttributeNS(work_docx_numbering_WORD_NAMESPACE, wordQualifiedName(document.documentElement, 'val'), String(restartAfterLevel));
+            restart.setAttributeNS(work_docx_numbering_WORD_NAMESPACE, work_docx_numbering_wordQualifiedName(document.documentElement, 'val'), String(restartAfterLevel));
         }
     }
     archive.file('word/numbering.xml', new XMLSerializer().serializeToString(document));
@@ -3541,7 +3855,7 @@ async function patchDocxNumberingRestartRules(buffer, rules) {
         type: 'arraybuffer'
     });
 }
-function wordQualifiedName(root, localName) {
+function work_docx_numbering_wordQualifiedName(root, localName) {
     return `${xmlNamespacePrefix(root, work_docx_numbering_WORD_NAMESPACE) ?? root.prefix ?? 'w'}:${localName}`;
 }
 const work_docx_paragraph_format_change_export_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
@@ -3971,6 +4285,127 @@ function docxBorderStyle(style, docx) {
 function docxColor(color) {
     return color.replace(/^#/, '').toUpperCase();
 }
+const work_docx_table_of_contents_export_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_table_of_contents_export_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+class DocxTableOfContentsPatchCollector {
+    patches = [];
+    add(element) {
+        const value = documentTableOfContentsValueFromElement(element);
+        const patch = {
+            options: value.options,
+            entries: value.entries
+        };
+        this.patches.push(patch);
+        return patch;
+    }
+}
+function docxTableOfContents(element, docx, collector) {
+    const patch = collector.add(element);
+    const options = patch.options;
+    return new docx.TableOfContents('Table of Contents', {
+        hyperlink: options.hyperlinks,
+        headingStyleRange: `${options.minLevel}-${options.maxLevel}`,
+        pageNumbersEntryLevelsRange: options.showPageNumbers ? void 0 : `${options.minLevel}-${options.maxLevel}`,
+        entryAndPageNumberSeparator: options.showPageNumbers && !options.rightAlignPageNumbers ? ' ' : void 0,
+        useAppliedParagraphOutlineLevel: true,
+        hideTabAndPageNumbersInWebView: true,
+        cachedEntries: patch.entries.map((entry)=>({
+                title: entry.title,
+                level: entry.level,
+                page: options.showPageNumbers ? entry.pageNumber : void 0,
+                href: options.hyperlinks ? entry.targetId : void 0
+            }))
+    });
+}
+async function patchDocxTableOfContents(buffer, patches) {
+    if (!patches.length) return buffer;
+    const archive = await jszip.loadAsync(buffer);
+    const entry = archive.file('word/document.xml');
+    if (!entry) return buffer;
+    const document = parseXml(await entry.async('text'), 'generated DOCX word/document.xml');
+    const tables = descendants(document, 'sdt').filter((element)=>descendants(element, 'instrText').some((instruction)=>/^\s*TOC\b/i.test(instruction.textContent ?? '')));
+    if (tables.length !== patches.length) throw new Error(`Generated DOCX emitted ${tables.length} table(s) of contents for ${patches.length} source block(s).`);
+    for (const [index, table] of tables.entries()){
+        const patch = patches[index];
+        if (patch) patchTableOfContents(document, table, patch.options);
+    }
+    addTableOfContentsBookmarks(document, patches);
+    archive.file('word/document.xml', new XMLSerializer().serializeToString(document));
+    return archive.generateAsync({
+        type: 'arraybuffer'
+    });
+}
+function patchTableOfContents(document, table, options) {
+    for (const tabStop of descendants(table, 'tab')){
+        if (tabStop.parentElement?.localName !== 'tabs') continue;
+        const value = work_ooxml_package_attribute(tabStop, 'val');
+        if ('right' !== value) continue;
+        if (!options.showPageNumbers || !options.rightAlignPageNumbers) {
+            const parent = tabStop.parentElement;
+            tabStop.remove();
+            if (parent && !directChildren(parent, 'tab').length) parent.remove();
+            continue;
+        }
+        const leader = docxTableOfContentsLeader(options.leader);
+        if (leader) work_docx_table_of_contents_export_setWordAttribute(document, tabStop, 'leader', leader);
+        else removeWordAttribute(tabStop, 'leader');
+    }
+    if (options.showPageNumbers && options.rightAlignPageNumbers) return;
+    for (const tab of descendants(table, 'tab')){
+        if (tab.parentElement?.localName === 'tabs') continue;
+        if (!options.showPageNumbers) {
+            tab.remove();
+            continue;
+        }
+        const text = document.createElementNS(work_docx_table_of_contents_export_WORD_NAMESPACE, work_docx_table_of_contents_export_wordQualifiedName(document.documentElement, 't'));
+        text.setAttributeNS(work_docx_table_of_contents_export_XML_NAMESPACE, 'xml:space', 'preserve');
+        text.textContent = ' ';
+        tab.replaceWith(text);
+    }
+}
+function addTableOfContentsBookmarks(document, patches) {
+    const names = new Set(descendants(document, 'bookmarkStart').flatMap((bookmark)=>{
+        const name = work_ooxml_package_attribute(bookmark, 'name')?.trim();
+        return name ? [
+            name
+        ] : [];
+    }));
+    let nextId = Math.max(0, ...descendants(document, 'bookmarkStart').map((bookmark)=>Number(work_ooxml_package_attribute(bookmark, 'id') ?? 0))) + 1;
+    const targets = new Set(patches.flatMap((patch)=>patch.options.hyperlinks ? patch.entries.map((candidate)=>candidate.targetId) : []));
+    for (const target of targets){
+        if (names.has(target)) continue;
+        const paragraphId = /^heading-([0-9a-f]{8})$/i.exec(target)?.[1];
+        if (!paragraphId) continue;
+        const paragraph = descendants(document, 'p').find((candidate)=>work_ooxml_package_attribute(candidate, 'paraId')?.toLowerCase() === paragraphId.toLowerCase());
+        if (!paragraph) continue;
+        const start = document.createElementNS(work_docx_table_of_contents_export_WORD_NAMESPACE, work_docx_table_of_contents_export_wordQualifiedName(document.documentElement, 'bookmarkStart'));
+        const end = document.createElementNS(work_docx_table_of_contents_export_WORD_NAMESPACE, work_docx_table_of_contents_export_wordQualifiedName(document.documentElement, 'bookmarkEnd'));
+        work_docx_table_of_contents_export_setWordAttribute(document, start, 'id', String(nextId));
+        work_docx_table_of_contents_export_setWordAttribute(document, start, 'name', target);
+        work_docx_table_of_contents_export_setWordAttribute(document, end, 'id', String(nextId));
+        nextId += 1;
+        const properties = directChild(paragraph, 'pPr');
+        paragraph.insertBefore(start, properties?.nextSibling ?? paragraph.firstChild);
+        paragraph.append(end);
+        names.add(target);
+    }
+}
+function docxTableOfContentsLeader(value) {
+    if ('dash' === value) return 'hyphen';
+    if ('underline' === value) return 'underscore';
+    if ('dot' === value) return 'dot';
+    return null;
+}
+function work_docx_table_of_contents_export_setWordAttribute(document, element, localName, value) {
+    removeWordAttribute(element, localName);
+    element.setAttributeNS(work_docx_table_of_contents_export_WORD_NAMESPACE, work_docx_table_of_contents_export_wordQualifiedName(document.documentElement, localName), value);
+}
+function removeWordAttribute(element, localName) {
+    for (const candidate of Array.from(element.attributes))if (candidate.localName === localName && (candidate.namespaceURI === work_docx_table_of_contents_export_WORD_NAMESPACE || !candidate.namespaceURI)) element.removeAttributeNode(candidate);
+}
+function work_docx_table_of_contents_export_wordQualifiedName(root, localName) {
+    return `${xmlNamespacePrefix(root, work_docx_table_of_contents_export_WORD_NAMESPACE) ?? 'w'}:${localName}`;
+}
 const work_docx_table_sizing_export_TWIPS_PER_PIXEL = 15;
 function documentTableSizingDocxOptions(table, docx) {
     const geometry = documentTableGeometryFromElement(table);
@@ -7956,7 +8391,7 @@ async function createDocxBlob(content, sourcePackage) {
     const docx = await import("docx");
     const normalizedContent = {
         ...content,
-        html: normalizeDocumentBookmarkReferencesHtml(normalizeDocumentBookmarksHtml(content.html))
+        html: normalizeDocumentIndexesHtml(normalizeDocumentBookmarkReferencesHtml(normalizeDocumentBookmarksHtml(content.html)))
     };
     const noteCollection = collectDocumentNotes(normalizedContent.html);
     const comments = anchoredDocumentComments(normalizedContent);
@@ -7991,8 +8426,12 @@ async function createDocxBlob(content, sourcePackage) {
         legacyTextEffectsPatches: new DocxLegacyTextEffectsPatchCollector(JSON.stringify(normalizedContent)),
         runBorderPatches: new DocxRunBorderPatchCollector(JSON.stringify(normalizedContent)),
         usedRunBorderMarkers: new Set(),
+        runShadingPatches: new DocxRunShadingPatchCollector(JSON.stringify(normalizedContent)),
+        usedRunShadingMarkers: new Set(),
         usedNativeTextEffectMarkers: new Set(),
         paragraphFormattingChangePatches: new DocxParagraphFormattingChangePatchCollector(),
+        tableOfContentsPatches: new DocxTableOfContentsPatchCollector(),
+        indexPatches: new DocxIndexPatchCollector(),
         hasExplicitZeroCharacterSpacing: false,
         hasExplicitZeroKerningThreshold: false
     };
@@ -8047,7 +8486,8 @@ async function createDocxBlob(content, sourcePackage) {
     const hiddenTextPatched = await patchDocxHiddenText(runFontsPatched, noteContext.hiddenTextPatches.patches.filter((patch)=>noteContext.usedNativeTextEffectMarkers.has(patch.marker)));
     const legacyTextEffectsPatched = await patchDocxLegacyTextEffects(hiddenTextPatched, noteContext.legacyTextEffectsPatches.patches.filter((patch)=>noteContext.usedNativeTextEffectMarkers.has(patch.marker)));
     const runBordersPatched = await patchDocxRunBorders(legacyTextEffectsPatched, noteContext.runBorderPatches.patches.filter((patch)=>noteContext.usedRunBorderMarkers.has(patch.marker)));
-    const formattingChangesPatched = await patchDocxRunFormattingChanges(runBordersPatched, noteContext.formattingChangePatches.patches);
+    const runShadingPatched = await patchDocxRunShading(runBordersPatched, noteContext.runShadingPatches.patches.filter((patch)=>noteContext.usedRunShadingMarkers.has(patch.marker)));
+    const formattingChangesPatched = await patchDocxRunFormattingChanges(runShadingPatched, noteContext.formattingChangePatches.patches);
     const noteImageRelationshipsPatched = await patchDocxNoteImageRelationships(formattingChangesPatched);
     const commentMetadataPatched = await patchDocxCommentMetadata(noteImageRelationshipsPatched, commentThreads);
     const numberingPatched = await patchDocxNumberingRestartRules(commentMetadataPatched, noteContext.numberingRestartRules);
@@ -8062,7 +8502,9 @@ async function createDocxBlob(content, sourcePackage) {
     const bookmarkPatched = await patchDocxBookmarks(imageIdentityPatched, noteContext.bookmarkPatches.patches);
     const paragraphDefaultCollapsedPatched = await patchDocxParagraphDefaultCollapsed(bookmarkPatched, noteContext.paragraphDefaultCollapsedPatches.patches);
     const paragraphIdentityPatched = await patchDocxParagraphIdentities(paragraphDefaultCollapsedPatched, noteContext.paragraphIdentityPatches.patches);
-    const paragraphFormattingChangesPatched = await patchDocxParagraphFormattingChanges(paragraphIdentityPatched, noteContext.paragraphFormattingChangePatches.patches);
+    const tableOfContentsPatched = await patchDocxTableOfContents(paragraphIdentityPatched, noteContext.tableOfContentsPatches.patches);
+    const indexPatched = await patchDocxIndexes(tableOfContentsPatched, noteContext.indexPatches.patches);
+    const paragraphFormattingChangesPatched = await patchDocxParagraphFormattingChanges(indexPatched, noteContext.paragraphFormattingChangePatches.patches);
     const equationPatched = await patchDocxEquations(paragraphFormattingChangesPatched, noteContext.equationPatches.patches);
     const patched = await patchDocxPageColor(equationPatched, normalizedContent.pageColor);
     const preserved = sourcePackage ? await preserveDocxSourcePackage(patched, sourcePackage, {
@@ -8132,6 +8574,10 @@ function markDocxRunBorderUsed(border, context) {
     const marker = border?.color?.toUpperCase();
     if (context.runBorderPatches.hasMarker(marker)) context.usedRunBorderMarkers.add(marker);
 }
+function markDocxRunShadingUsed(shading, context) {
+    const marker = shading?.fill?.toUpperCase();
+    if (context.runShadingPatches.hasMarker(marker)) context.usedRunShadingMarkers.add(marker);
+}
 function work_docx_export_sectionProperties(layout, docx) {
     const landscape = 'landscape' === layout.orientation;
     const dimensions = documentPageGeometryForLayout(layout);
@@ -8229,6 +8675,10 @@ async function blockToFileChildren(element, docx, noteContext) {
     if (element.hasAttribute('data-document-bibliography')) return [
         docxBibliographyParagraph(element, docx, paragraphBidirectional(element))
     ];
+    if (element.hasAttribute('data-document-table-of-contents')) return [
+        docxTableOfContents(element, docx, noteContext.tableOfContentsPatches)
+    ];
+    if (element.hasAttribute('data-document-index')) return docxDocumentIndex(element, docx, noteContext.indexPatches);
     if (element.hasAttribute('data-document-caption')) return [
         docxCaptionParagraph(element, await paragraphRuns(element, docx, noteContext), docx, paragraphBidirectional(element))
     ];
@@ -8303,6 +8753,7 @@ async function work_docx_export_inlineRuns(root, docx, noteContext) {
             if (!node.textContent) return [];
             markDocxNativeTextEffectStyleUsed(inherited.style, noteContext);
             markDocxRunBorderUsed(inherited.border, noteContext);
+            markDocxRunShadingUsed(inherited.shading, noteContext);
             if (revision?.kind === 'insertion') return [
                 new docx.InsertedTextRun({
                     ...inherited,
@@ -8339,6 +8790,12 @@ async function work_docx_export_inlineRuns(root, docx, noteContext) {
         if (node.hasAttribute('data-document-field')) return [
             docxDocumentFieldRun(node, docx)
         ];
+        if (node.hasAttribute('data-document-index-entry')) {
+            const entry = docxIndexEntryRun(node, docx);
+            return entry ? [
+                entry
+            ] : [];
+        }
         if (node.hasAttribute('data-document-equation')) {
             const equation = noteContext.equationPatches.marker(node);
             return [
@@ -8360,19 +8817,32 @@ async function work_docx_export_inlineRuns(root, docx, noteContext) {
         const formattingChange = node.hasAttribute('data-document-change') && 'formatting' === node.dataset.changeKind ? noteContext.formattingChangePatches.register(node, docxRevisionId(node, noteContext)) : null;
         const commentBoundary = node.hasAttribute('data-document-comment') ? nextDocxCommentBoundary(node.dataset.commentId, noteContext) : null;
         const backgroundColor = cssColorToHex(node.style.backgroundColor);
+        const hasExplicitRunShading = 'span' === tag && node.hasAttribute(DOCUMENT_RUN_SHADING_ATTRIBUTE);
+        const explicitRunShading = hasExplicitRunShading ? parseDocumentRunShadingElement(node) : null;
+        if (hasExplicitRunShading && !explicitRunShading) throw new Error('Document contains invalid character shading.');
+        const hasHighlightSemantics = node.hasAttribute(DOCUMENT_HIGHLIGHT_ATTRIBUTE) || node.hasAttribute('data-color') || 'mark' === tag || Boolean(backgroundColor) && !hasExplicitRunShading;
+        const explicitHighlight = hasHighlightSemantics ? documentHighlightFromElement(node) : null;
         const direction = domDirection(node);
         const resolvedColor = cssColorToHex(node.style.color) ?? inherited.color;
         const themeColorMarker = noteContext.themePatches.marker('color', parseDocxThemeReference(node.dataset.officeThemeColor), resolvedColor ? `#${resolvedColor}` : null);
-        const resolvedShading = backgroundColor ? {
-            fill: backgroundColor
-        } : inherited.shading;
-        const themeFillMarker = noteContext.themePatches.marker('fill', parseDocxThemeReference(node.dataset.officeThemeFill), resolvedShading?.fill ? `#${resolvedShading.fill}` : null);
+        const runShading = explicitRunShading ? documentRunShadingDocxOptions(explicitRunShading, noteContext.runShadingPatches).shading : void 0;
+        const customHighlightFill = hasHighlightSemantics && !explicitHighlight ? backgroundColor : null;
+        const resolvedShading = runShading ?? (customHighlightFill ? {
+            fill: customHighlightFill
+        } : inherited.shading);
+        const themeFillMarker = !runShading && customHighlightFill ? noteContext.themePatches.marker('fill', parseDocxThemeReference(node.dataset.officeThemeFill), `#${customHighlightFill}`) : null;
         const explicitTextCase = normalizeDocumentTextCase(node.dataset.officeTextCase);
         const explicitCharacterSpacing = documentCharacterSpacingTwipsFromElement(node);
         const explicitCharacterScale = documentCharacterScalePercentFromElement(node);
         const explicitKerningThreshold = documentKerningThresholdHalfPointsFromElement(node);
         const explicitEmphasisMark = documentEmphasisMarkFromElement(node);
         const explicitHiddenText = documentHiddenTextFromElement(node);
+        const hasExplicitProofingLanguages = 'span' === tag && node.hasAttribute(DOCUMENT_PROOFING_LANGUAGES_ATTRIBUTE);
+        const explicitProofingLanguages = hasExplicitProofingLanguages ? documentProofingLanguagesFromElement(node) : null;
+        if (hasExplicitProofingLanguages && !explicitProofingLanguages) throw new Error('Document contains invalid proofing languages.');
+        const hasExplicitNoProof = 'span' === tag && node.hasAttribute(DOCUMENT_NO_PROOF_ATTRIBUTE);
+        const explicitNoProof = hasExplicitNoProof ? documentNoProofFromElement(node) : null;
+        if (hasExplicitNoProof && null === explicitNoProof) throw new Error('Document contains invalid proofing state.');
         const hasExplicitLegacyTextEffects = 'span' === tag && [
             DOCUMENT_LEGACY_TEXT_OUTLINE_ATTRIBUTE,
             DOCUMENT_LEGACY_TEXT_SHADOW_ATTRIBUTE,
@@ -8410,6 +8880,8 @@ async function work_docx_export_inlineRuns(root, docx, noteContext) {
         const strike = docxStrikeRunOptions(node, inherited);
         const scriptFontMarker = noteContext.runFontPatches.marker(documentScriptFontsFromElement(node), documentScriptFontSlotFromElement(node), node.style.fontFamily);
         const runBorder = explicitRunBorder ? documentRunBorderDocxOptions(explicitRunBorder, noteContext.runBorderPatches).border : inherited.border;
+        const language = hasExplicitProofingLanguages ? documentProofingLanguageDocxOptions(explicitProofingLanguages) : inherited.language;
+        const noProof = hasExplicitNoProof ? explicitNoProof ?? false : inherited.noProof;
         const style = {
             ...inherited,
             style: nativeTextEffectStyle,
@@ -8429,10 +8901,13 @@ async function work_docx_export_inlineRuns(root, docx, noteContext) {
             kern,
             position,
             emphasisMark,
+            language,
+            noProof,
             border: runBorder,
             shading: themeFillMarker ? {
                 fill: themeFillMarker
             } : resolvedShading,
+            highlight: hasHighlightSemantics ? explicitHighlight ?? (customHighlightFill ? 'none' : void 0) : inherited.highlight,
             snapToGrid: dataBoolean(node.dataset.officeWordSnapToGrid) ?? inherited.snapToGrid,
             rightToLeft: void 0 === direction ? inherited.rightToLeft : 'rtl' === direction,
             ...textCaseOptions
@@ -8440,6 +8915,7 @@ async function work_docx_export_inlineRuns(root, docx, noteContext) {
         if ('br' === tag) {
             markDocxNativeTextEffectStyleUsed(style.style, noteContext);
             markDocxRunBorderUsed(style.border, noteContext);
+            markDocxRunShadingUsed(style.shading, noteContext);
             return [
                 new docx.TextRun({
                     ...style,