@a3s-lab/office 0.30.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, 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, parseDocxThemeReference, parseXml, parseDocumentRunShading, applyDocumentParagraphIdentityToElement, DOCUMENT_RUN_SHADING_ATTRIBUTE, documentScriptFontSlotFromElement, DOCUMENT_HIGHLIGHT_ATTRIBUTE, 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, documentScriptFontFamily, descendants, resolvePartTarget, documentProofingLanguagesFromElement, documentHighlightFromElement, parseDocumentRunShadingElement, parseDocumentProofingLanguages, patchDocxThemeReferences, parseDocumentParagraphBordersElement, DOCUMENT_RUN_BORDER_ATTRIBUTE, parseDocumentRunBorderElement, xmlNamespacePrefix, documentScriptFontSlotFromHint, documentNoProofFromElement, documentScriptFontsFromElement, normalizeDocumentRunShading, normalizeDocumentScriptFontSlot, directChild, parseDocumentParagraphShadingElement, documentFontNameFromCssFamily } from "./4121.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, documentProofingLanguageDocxOptions, xmlAttributeLocalName, cssFontSize, paragraphDirectionOptions, cssFontFamily, docxCharacterSpacingValue } from "./0~7231.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,185 @@ 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 = [];
@@ -2581,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;
 }
@@ -2630,13 +2809,13 @@ function appendFormattingProperties(document, properties, namespace, prefix, ser
 function appendNoProofProperty(document, properties, namespace, prefix, mark) {
     const noProof = normalizeDocumentNoProof(mark?.attrs?.noProof);
     if (null === noProof) return;
-    if (noProof) properties.append(wordElement(document, namespace, prefix, 'noProof'));
+    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 = wordElement(document, namespace, prefix, 'lang');
+    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);
@@ -2645,7 +2824,7 @@ function appendProofingLanguagesProperty(document, properties, namespace, prefix
 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());
@@ -2664,7 +2843,7 @@ function appendRunBorderProperty(document, properties, namespace, prefix, mark)
 function appendRunShadingProperty(document, properties, namespace, prefix, mark) {
     const shading = parseDocumentRunShading(mark?.attrs?.runShading);
     if (!shading) return;
-    const element = wordElement(document, namespace, prefix, 'shd');
+    const element = work_docx_format_change_export_wordElement(document, namespace, prefix, 'shd');
     if (!setDocxRunShadingAttributes(document, element, shading)) return;
     properties.append(element);
 }
@@ -2695,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) {
@@ -2733,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',
@@ -2777,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',
@@ -2791,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);
@@ -2799,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;
@@ -2808,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');
@@ -2825,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);
@@ -2843,7 +3022,7 @@ function appendHighlightProperty(document, properties, namespace, prefix, mark,
     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');
@@ -2891,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) {
@@ -3665,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));
@@ -3676,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';
@@ -8212,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);
@@ -8252,6 +8431,7 @@ async function createDocxBlob(content, sourcePackage) {
         usedNativeTextEffectMarkers: new Set(),
         paragraphFormattingChangePatches: new DocxParagraphFormattingChangePatchCollector(),
         tableOfContentsPatches: new DocxTableOfContentsPatchCollector(),
+        indexPatches: new DocxIndexPatchCollector(),
         hasExplicitZeroCharacterSpacing: false,
         hasExplicitZeroKerningThreshold: false
     };
@@ -8323,7 +8503,8 @@ async function createDocxBlob(content, sourcePackage) {
     const paragraphDefaultCollapsedPatched = await patchDocxParagraphDefaultCollapsed(bookmarkPatched, noteContext.paragraphDefaultCollapsedPatches.patches);
     const paragraphIdentityPatched = await patchDocxParagraphIdentities(paragraphDefaultCollapsedPatched, noteContext.paragraphIdentityPatches.patches);
     const tableOfContentsPatched = await patchDocxTableOfContents(paragraphIdentityPatched, noteContext.tableOfContentsPatches.patches);
-    const paragraphFormattingChangesPatched = await patchDocxParagraphFormattingChanges(tableOfContentsPatched, noteContext.paragraphFormattingChangePatches.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, {
@@ -8497,6 +8678,7 @@ async function blockToFileChildren(element, docx, noteContext) {
     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))
     ];
@@ -8608,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 [

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

@@ -1,8 +1,8 @@
 import jszip from "jszip";
-import { documentRunBorderDomAttributes, contentTypeForPart, bytesToDataUrl, OoxmlPackage, firstDescendant, normalizeDocumentParagraphId, applyDocumentParagraphIdentityToElement, descendants, documentHighlightDomAttributes, attribute as work_ooxml_package_attribute, documentHighlightFromDocxValue, serializeDocxThemeReference, normalizeDocumentTableOfContentsHtml, directChildren, documentParagraphShadingDomAttributes, documentProofingDomAttributes, documentParagraphBordersDomAttributes, directChild, documentScriptFontSegments, normalizeDocumentParagraphIdentity, documentRunShadingDomAttributes } from "./4121.js";
+import { documentRunBorderDomAttributes, contentTypeForPart, bytesToDataUrl, OoxmlPackage, normalizeDocumentIndexesHtml, firstDescendant, normalizeDocumentParagraphId, applyDocumentParagraphIdentityToElement, descendants, documentHighlightDomAttributes, attribute as work_ooxml_package_attribute, documentHighlightFromDocxValue, serializeDocxThemeReference, normalizeDocumentTableOfContentsHtml, directChildren, documentParagraphShadingDomAttributes, documentProofingDomAttributes, documentParagraphBordersDomAttributes, directChild, documentScriptFontSegments, normalizeDocumentParagraphIdentity, documentRunShadingDomAttributes } from "./4121.js";
 import { normalizeDocumentBookmarkName, renderDocumentTableCellMarginOverrides, applyDocumentImageIdentityToElement, documentCharacterPositionDomAttributes, createDocumentImageIdentityRegistry, normalizeDocumentColumns, documentStrikeDomAttributes, normalizeDocumentImageWrapContour, DOCUMENT_TABLE_ROW_ID_ATTRIBUTE, normalizeDocumentBookmarksHtml, applyDocumentTableRowIdentityToElement, normalizeDocumentCaptionsHtml, documentCharacterSpacingDomAttributes, normalizeDocumentImageAlignment, applyDocumentImageLayerToElement, normalizeDocumentNotesHtml, normalizeDocumentBookmarkReferencesHtml, documentCitationTagsFromInstruction, applyDocumentImageWrapContourToElement, documentUnderlineDomAttributes, documentHiddenTextDomAttributes, normalizeDocumentPageChrome, normalizeDocumentImageLayoutOptions, applyDocumentImageCropToElement, documentPageMarginsForLayout, applyDocumentPageGeometry, createDocumentNoteElement, normalizeDocumentImageLayer, DOCUMENT_TABLE_ROW_TEXT_ID_ATTRIBUTE, documentBookmarkReferenceInstruction, documentInitialSectionLayout, normalizeDocumentFieldsHtml, documentCaptionLabel, documentTableBordersFromElement, isContourImageLayout, normalizeDocumentCitationsHtml, normalizeDocumentImageIdentity, normalizeDocumentImageWrapSide, documentKerningDomAttributes, docxDocumentFieldKind, renderDocumentTableBorders, docxBookmarkReferenceTarget, normalizeDocumentImagePosition, wrapsBesideImage, documentPageChromeLegacyFields, documentCharacterScaleDomAttributes, DEFAULT_DOCUMENT_TABLE_GEOMETRY, documentSectionDomAttributes, DEFAULT_DOCUMENT_TABLE_CELL_MARGINS, documentPageMarginBody, documentLegacyTextEffectsDomAttributes, normalizeDocumentTableRowIdentity, normalizeDocumentBookmarkNativeId, uniqueDocumentImageIdentity, applyDocumentTableGeometryToElement, normalizeDocumentImageCrop, documentContentLayoutProperties, documentEmphasisMarkDomAttributes } from "./6282.js";
-import { markDocxRunFormattingIntoState, applyImportedDocxParagraphSpacingMarkers, hasImportedDocxParagraphDirectionMarkers, hasImportedDocxParagraphIndentMarkers, resolveDocxParagraphBordersForParagraph, applyImportedDocxParagraphShadingMarkers, markDocxParagraphSpacing, docxCaptionBookmark, docxFieldResultText, createDocxParagraphStyleResolver, docxTableCellStyleLayers, createImportedDocxRunFormattingMarkerState, parseDocxPaperSource, resolveDocxLegacyTextEffects, markDocxTablesOfContents, hasImportedDocxParagraphSpacingMarkers, docxTablePropertySources, applyImportedDocxTableOfContentsMarkers, parseDocxPageMargins, parseDirectDocxParagraphShading, markDocxPackageEquations, parseDocxPageGeometry, markDocxParagraphIndents, resolveDocxRunBorder, docxCaptionReferenceTarget, applyImportedDocxEquationMarkers, hasImportedDocxParagraphPaginationMarkers, createDocxTableStyleResolver, hasImportedDocxParagraphShadingMarkers, isDocxEquationLikeRoot, importedDocxStrike, docxTableRunPropertySources, inspectDocxPageMarginSettings, hasImportedDocxRunFormattingMarkers, applyImportedDocxParagraphFormattingChangeMarkers, hasImportedDocxTableOfContentsMarkers, hasImportedDocxParagraphTabStopMarkers, resolveDocxRunShading, docxCaptionSequenceKind, applyImportedDocxRunFormattingMarkers, markDocxParagraphAlignments, markDocxParagraphDirections, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphFormattingChangeMarkers, resolveDocxHiddenText, docxEquationHtml, docxFieldOccurrences, hasImportedDocxParagraphAlignmentMarkers, markDocxParagraphTabStops, applyImportedDocxParagraphIndentMarkers, resolveDocxTableStyleResolver, applyImportedDocxParagraphDirectionMarkers, applyImportedDocxParagraphAlignmentMarkers, markDocxParagraphPagination, importedDocxUnderline, markDocxParagraphBorders, applyImportedDocxParagraphTabStopMarkers, applyImportedDocxParagraphPaginationMarkers, docxFieldOccurrenceIsInlineEditable, applyImportedDocxParagraphBorderMarkers, docxRunPropertySources, markDocxParagraphFormattingChanges, markDocxParagraphShading, parseDocxPageBorders } from "./0~7360.js";
-import { readDocxBibliography, resolveDocxProofing, XMLNS_NAMESPACE, docxCharacterScalePercentFromProperties, docxCharacterSpacingTwipsFromProperties, parseBoundedDocxInteger, xmlAttributeLocalName, resolveDocxEmphasisMark, createDocxThemeResolver, docxCharacterPositionHalfPointsFromProperties, docxThemeColor, parseDocxParagraphDefaultCollapsed, resolveDocxKerningThresholdHalfPoints, resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, xmlAttributeNamespace } from "./0~7231.js";
+import { hasImportedDocxIndexMarkers, markDocxRunFormattingIntoState, applyImportedDocxParagraphSpacingMarkers, hasImportedDocxParagraphDirectionMarkers, hasImportedDocxParagraphIndentMarkers, resolveDocxParagraphBordersForParagraph, applyImportedDocxParagraphShadingMarkers, markDocxParagraphSpacing, docxCaptionBookmark, docxFieldResultText, createDocxParagraphStyleResolver, docxTableCellStyleLayers, createImportedDocxRunFormattingMarkerState, parseDocxPaperSource, resolveDocxLegacyTextEffects, markDocxTablesOfContents, hasImportedDocxParagraphSpacingMarkers, applyImportedDocxIndexMarkers, applyImportedDocxTableOfContentsMarkers, markDocxIndexes, parseDocxPageMargins, docxTablePropertySources, parseDirectDocxParagraphShading, markDocxParagraphIndents, markDocxPackageEquations, resolveDocxRunBorder, parseDocxPageGeometry, docxCaptionReferenceTarget, applyImportedDocxEquationMarkers, hasImportedDocxParagraphPaginationMarkers, createDocxTableStyleResolver, hasImportedDocxParagraphShadingMarkers, isDocxEquationLikeRoot, importedDocxStrike, docxTableRunPropertySources, inspectDocxPageMarginSettings, hasImportedDocxRunFormattingMarkers, applyImportedDocxParagraphFormattingChangeMarkers, hasImportedDocxTableOfContentsMarkers, hasImportedDocxParagraphTabStopMarkers, resolveDocxRunShading, docxCaptionSequenceKind, applyImportedDocxRunFormattingMarkers, markDocxParagraphAlignments, markDocxParagraphDirections, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphFormattingChangeMarkers, resolveDocxHiddenText, docxEquationHtml, docxFieldOccurrences, hasImportedDocxParagraphAlignmentMarkers, markDocxParagraphTabStops, applyImportedDocxParagraphIndentMarkers, resolveDocxTableStyleResolver, applyImportedDocxParagraphDirectionMarkers, applyImportedDocxParagraphAlignmentMarkers, markDocxParagraphPagination, importedDocxUnderline, markDocxParagraphBorders, applyImportedDocxParagraphTabStopMarkers, applyImportedDocxParagraphPaginationMarkers, docxFieldOccurrenceIsInlineEditable, applyImportedDocxParagraphBorderMarkers, docxRunPropertySources, markDocxParagraphFormattingChanges, markDocxParagraphShading, parseDocxPageBorders } from "./0~7240.js";
+import { readDocxBibliography, resolveDocxProofing, XMLNS_NAMESPACE, docxCharacterScalePercentFromProperties, docxCharacterSpacingTwipsFromProperties, parseBoundedDocxInteger, xmlAttributeLocalName, resolveDocxEmphasisMark, createDocxThemeResolver, docxCharacterPositionHalfPointsFromProperties, docxThemeColor, parseDocxParagraphDefaultCollapsed, resolveDocxKerningThresholdHalfPoints, resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, xmlAttributeNamespace } from "./0~4808.js";
 import { importDocxPageColor, importedDocumentNoteId } from "./0~4980.js";
 const WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
@@ -2899,6 +2899,10 @@ async function prepareDocxImport(buffer, sourcePackage) {
         tableOfContentsMarkers: {
             tables: []
         },
+        indexMarkers: {
+            entries: [],
+            indexes: []
+        },
         equationMarkers: {
             equations: []
         },
@@ -2965,6 +2969,7 @@ async function prepareDocxImport(buffer, sourcePackage) {
     const document = await archive.xml('word/document.xml');
     const pageColor = importDocxPageColor(document);
     const tableOfContentsMarkers = markDocxTablesOfContents(document);
+    const indexMarkers = markDocxIndexes(document);
     const paragraphIdentityMarkers = markDocxParagraphIdentities(document);
     const numbering = archive.has('word/numbering.xml') ? await archive.xml('word/numbering.xml') : null;
     const commentMarkers = await markDocxComments(document, archive);
@@ -3009,7 +3014,7 @@ async function prepareDocxImport(buffer, sourcePackage) {
     const trackChanges = Boolean(settings && firstDescendant(settings, 'trackRevisions')) || changeMarkers.changes.length > 0 || paragraphFormattingChangeMarkers.paragraphs.length > 0 || runFormattingMarkers.runs.some((run)=>Boolean(run.change));
     const sectionElements = effectiveSectionProperties(document);
     if (!sectionElements.length) return {
-        conversionBuffer: hasImportedDocxCaptionMarkers(captionMarkers) || hasImportedDocxBookmarkMarkers(bookmarkMarkers) || hasImportedDocxChangeMarkers(changeMarkers) || hasImportedDocxCommentMarkers(commentMarkers) || hasImportedDocxCitationMarkers(citationMarkers) || hasImportedDocxFieldMarkers(fieldMarkers) || hasImportedDocxTableOfContentsMarkers(tableOfContentsMarkers) || equationMarkers.changed || hasImportedDocxListMarkers(listMarkers) || hasImportedDocxImageLayoutMarkers(imageLayoutMarkers) || hasImportedDocxParagraphIdentityMarkers(paragraphIdentityMarkers) || hasImportedDocxParagraphFormattingChangeMarkers(paragraphFormattingChangeMarkers) || hasImportedDocxParagraphAlignmentMarkers(paragraphAlignmentMarkers) || hasImportedDocxParagraphDirectionMarkers(paragraphDirectionMarkers) || hasImportedDocxParagraphIndentMarkers(paragraphIndentMarkers) || hasImportedDocxParagraphSpacingMarkers(paragraphSpacingMarkers) || hasImportedDocxParagraphBorderMarkers(paragraphBorderMarkers) || hasImportedDocxParagraphShadingMarkers(paragraphShadingMarkers) || hasImportedDocxParagraphPaginationMarkers(paragraphPaginationMarkers) || hasImportedDocxRunFormattingMarkers(runFormattingMarkers) || hasImportedDocxParagraphTabStopMarkers(tabStopMarkers) || hasImportedDocxTableCellMarkers(tableCellMarkers) || hasImportedDocxTableRowMarkers(tableRowMarkers) || hasImportedDocxTableSizingMarkers(tableSizingMarkers) ? await writeDocumentXml(buffer, document, equationMarkers.parts) : buffer,
+        conversionBuffer: hasImportedDocxCaptionMarkers(captionMarkers) || hasImportedDocxBookmarkMarkers(bookmarkMarkers) || hasImportedDocxChangeMarkers(changeMarkers) || hasImportedDocxCommentMarkers(commentMarkers) || hasImportedDocxCitationMarkers(citationMarkers) || hasImportedDocxFieldMarkers(fieldMarkers) || hasImportedDocxTableOfContentsMarkers(tableOfContentsMarkers) || hasImportedDocxIndexMarkers(indexMarkers) || equationMarkers.changed || hasImportedDocxListMarkers(listMarkers) || hasImportedDocxImageLayoutMarkers(imageLayoutMarkers) || hasImportedDocxParagraphIdentityMarkers(paragraphIdentityMarkers) || hasImportedDocxParagraphFormattingChangeMarkers(paragraphFormattingChangeMarkers) || hasImportedDocxParagraphAlignmentMarkers(paragraphAlignmentMarkers) || hasImportedDocxParagraphDirectionMarkers(paragraphDirectionMarkers) || hasImportedDocxParagraphIndentMarkers(paragraphIndentMarkers) || hasImportedDocxParagraphSpacingMarkers(paragraphSpacingMarkers) || hasImportedDocxParagraphBorderMarkers(paragraphBorderMarkers) || hasImportedDocxParagraphShadingMarkers(paragraphShadingMarkers) || hasImportedDocxParagraphPaginationMarkers(paragraphPaginationMarkers) || hasImportedDocxRunFormattingMarkers(runFormattingMarkers) || hasImportedDocxParagraphTabStopMarkers(tabStopMarkers) || hasImportedDocxTableCellMarkers(tableCellMarkers) || hasImportedDocxTableRowMarkers(tableRowMarkers) || hasImportedDocxTableSizingMarkers(tableSizingMarkers) ? await writeDocumentXml(buffer, document, equationMarkers.parts) : buffer,
         sections: [
             {
                 id: 'document-section-1',
@@ -3023,6 +3028,7 @@ async function prepareDocxImport(buffer, sourcePackage) {
         commentMarkers,
         fieldMarkers,
         tableOfContentsMarkers,
+        indexMarkers,
         equationMarkers: equationMarkers.markers,
         citationMarkers,
         listMarkers,
@@ -3058,7 +3064,7 @@ async function prepareDocxImport(buffer, sourcePackage) {
     }
     if (sections.length > 1) addSectionMarkers(document, sectionElements);
     return {
-        conversionBuffer: sections.length > 1 || hasImportedDocxCaptionMarkers(captionMarkers) || hasImportedDocxBookmarkMarkers(bookmarkMarkers) || hasImportedDocxChangeMarkers(changeMarkers) || hasImportedDocxCommentMarkers(commentMarkers) || hasImportedDocxCitationMarkers(citationMarkers) || hasImportedDocxFieldMarkers(fieldMarkers) || hasImportedDocxTableOfContentsMarkers(tableOfContentsMarkers) || equationMarkers.changed || hasImportedDocxListMarkers(listMarkers) || hasImportedDocxImageLayoutMarkers(imageLayoutMarkers) || hasImportedDocxParagraphIdentityMarkers(paragraphIdentityMarkers) || hasImportedDocxParagraphFormattingChangeMarkers(paragraphFormattingChangeMarkers) || hasImportedDocxParagraphAlignmentMarkers(paragraphAlignmentMarkers) || hasImportedDocxParagraphDirectionMarkers(paragraphDirectionMarkers) || hasImportedDocxParagraphIndentMarkers(paragraphIndentMarkers) || hasImportedDocxParagraphSpacingMarkers(paragraphSpacingMarkers) || hasImportedDocxParagraphBorderMarkers(paragraphBorderMarkers) || hasImportedDocxParagraphShadingMarkers(paragraphShadingMarkers) || hasImportedDocxParagraphPaginationMarkers(paragraphPaginationMarkers) || hasImportedDocxRunFormattingMarkers(runFormattingMarkers) || hasImportedDocxParagraphTabStopMarkers(tabStopMarkers) || hasImportedDocxTableCellMarkers(tableCellMarkers) || hasImportedDocxTableRowMarkers(tableRowMarkers) || hasImportedDocxTableSizingMarkers(tableSizingMarkers) ? await writeDocumentXml(buffer, document, equationMarkers.parts) : buffer,
+        conversionBuffer: sections.length > 1 || hasImportedDocxCaptionMarkers(captionMarkers) || hasImportedDocxBookmarkMarkers(bookmarkMarkers) || hasImportedDocxChangeMarkers(changeMarkers) || hasImportedDocxCommentMarkers(commentMarkers) || hasImportedDocxCitationMarkers(citationMarkers) || hasImportedDocxFieldMarkers(fieldMarkers) || hasImportedDocxTableOfContentsMarkers(tableOfContentsMarkers) || hasImportedDocxIndexMarkers(indexMarkers) || equationMarkers.changed || hasImportedDocxListMarkers(listMarkers) || hasImportedDocxImageLayoutMarkers(imageLayoutMarkers) || hasImportedDocxParagraphIdentityMarkers(paragraphIdentityMarkers) || hasImportedDocxParagraphFormattingChangeMarkers(paragraphFormattingChangeMarkers) || hasImportedDocxParagraphAlignmentMarkers(paragraphAlignmentMarkers) || hasImportedDocxParagraphDirectionMarkers(paragraphDirectionMarkers) || hasImportedDocxParagraphIndentMarkers(paragraphIndentMarkers) || hasImportedDocxParagraphSpacingMarkers(paragraphSpacingMarkers) || hasImportedDocxParagraphBorderMarkers(paragraphBorderMarkers) || hasImportedDocxParagraphShadingMarkers(paragraphShadingMarkers) || hasImportedDocxParagraphPaginationMarkers(paragraphPaginationMarkers) || hasImportedDocxRunFormattingMarkers(runFormattingMarkers) || hasImportedDocxParagraphTabStopMarkers(tabStopMarkers) || hasImportedDocxTableCellMarkers(tableCellMarkers) || hasImportedDocxTableRowMarkers(tableRowMarkers) || hasImportedDocxTableSizingMarkers(tableSizingMarkers) ? await writeDocumentXml(buffer, document, equationMarkers.parts) : buffer,
         sections,
         pageColor,
         captionMarkers,
@@ -3067,6 +3073,7 @@ async function prepareDocxImport(buffer, sourcePackage) {
         commentMarkers,
         fieldMarkers,
         tableOfContentsMarkers,
+        indexMarkers,
         equationMarkers: equationMarkers.markers,
         citationMarkers,
         listMarkers,
@@ -3104,6 +3111,9 @@ function applyDocxSectionsToHtml(html, sections, captionMarkers = {
     fields: []
 }, tableOfContentsMarkers = {
     tables: []
+}, indexMarkers = {
+    entries: [],
+    indexes: []
 }, equationMarkers = {
     equations: []
 }, citationMarkers = {
@@ -3172,6 +3182,7 @@ function applyDocxSectionsToHtml(html, sections, captionMarkers = {
     applyImportedDocxCommentMarkers(document, commentMarkers);
     applyImportedDocxParagraphIdentityMarkers(document, paragraphIdentityMarkers);
     applyImportedDocxTableOfContentsMarkers(document, tableOfContentsMarkers);
+    applyImportedDocxIndexMarkers(document, indexMarkers);
     const notes = extractMammothDocumentNotes(document);
     const sourceNodes = Array.from(document.body.childNodes);
     document.body.replaceChildren();
@@ -3196,7 +3207,7 @@ function applyDocxSectionsToHtml(html, sections, captionMarkers = {
         document.body.append(missing);
     }
     placeMammothDocumentNotes(document, notes);
-    return normalizeDocumentBookmarkReferencesHtml(normalizeDocumentBookmarksHtml(normalizeDocumentCitationsHtml(normalizeDocumentTableOfContentsHtml(normalizeDocumentFieldsHtml(normalizeDocumentCaptionsHtml(normalizeDocumentNotesHtml(document.body.innerHTML)))), bibliography)));
+    return normalizeDocumentIndexesHtml(normalizeDocumentBookmarkReferencesHtml(normalizeDocumentBookmarksHtml(normalizeDocumentCitationsHtml(normalizeDocumentTableOfContentsHtml(normalizeDocumentFieldsHtml(normalizeDocumentCaptionsHtml(normalizeDocumentNotesHtml(document.body.innerHTML)))), bibliography))));
 }
 async function readDocxLayout(buffer) {
     const prepared = await prepareDocxImport(buffer);

package/dist/0~work-office-diagnostics.js

@@ -1,9 +1,9 @@
 import { __webpack_require__ } from "./0~rslib-runtime.js";
 import { contentTypeForPart, directChildren, OoxmlPackage, parseXml, firstDescendant, isDocumentParagraphArtBorderStyle, descendants, directChild, xmlContainsAnyElement, attribute, documentRunBorderIsVisible } from "./4121.js";
 import { normalizeDocumentBookmarkName, docxBookmarkReferenceTarget, normalizeDocumentBookmarkNativeId, DOCUMENT_LEGACY_TEXT_EFFECT_NAMES, supportedDocxBookmarkReferenceInstruction, documentCitationTagsFromInstruction, docxDocumentFieldKind } from "./6282.js";
-import { markDocxParagraphShading, inspectDocxPageSize, docxCaptionBookmark, hasInvalidDocxFieldStructure, inspectDocxLegacyTextEffects, inspectDocxPageMargins, inspectDocxPaperSource, createDocxParagraphStyleResolver, supportedDocxTableOfContentsField, docxFieldOccurrences, createDocxTableStyleResolver, inspectDocxRunFonts, inspectDocxEquation, inspectDocxPageMarginSettings, inspectDocxRunBorder, inspectDocxRunShading, markDocxParagraphBorders, isSupportedDocxParagraphFormattingChange, docxFieldOccurrenceIsInlineEditable, inspectDocxHiddenText, docxCaptionSequenceKind, inspectDocxPageBorders, isSupportedDocxRunFormattingChange, docxFieldInstructions, isSupportedDocxEquationPlacement } from "./0~7360.js";
+import { markDocxParagraphShading, inspectDocxPageSize, docxCaptionBookmark, hasInvalidDocxFieldStructure, inspectDocxLegacyTextEffects, inspectDocxPageMargins, inspectDocxPaperSource, createDocxParagraphStyleResolver, supportedDocxTableOfContentsField, docxFieldOccurrences, supportedDocxIndexEntryField, createDocxTableStyleResolver, inspectDocxEquation, inspectDocxPageMarginSettings, inspectDocxRunFonts, inspectDocxRunBorder, inspectDocxRunShading, markDocxParagraphBorders, isSupportedDocxParagraphFormattingChange, docxFieldOccurrenceIsInlineEditable, supportedDocxIndexField, docxCaptionSequenceKind, inspectDocxHiddenText, inspectDocxPageBorders, isSupportedDocxRunFormattingChange, docxFieldInstructions, isSupportedDocxEquationPlacement } from "./0~7240.js";
 import { normalizeDocumentHref } from "./0~work-document-links.js";
-import { xmlAttributeLocalName, inspectDocxProofingLanguages, readDocxBibliography, inspectDocxEmphasisMark, createDocxThemeResolver, inspectDocxNoProof, parseDocxParagraphDefaultCollapsed, DOCX_WORDPROCESSING_NAMESPACES, xmlAttributeNamespace, inspectDocxKerningThresholdHalfPoints } from "./0~7231.js";
+import { xmlAttributeLocalName, inspectDocxProofingLanguages, readDocxBibliography, inspectDocxEmphasisMark, createDocxThemeResolver, inspectDocxNoProof, parseDocxParagraphDefaultCollapsed, DOCX_WORDPROCESSING_NAMESPACES, xmlAttributeNamespace, inspectDocxKerningThresholdHalfPoints } from "./0~4808.js";
 import { updateSpreadsheetWorksheetCompatibilitySummary, inspectXlsxPivotTables, isSupportedXlsxChartLegend, isSupportedXlsxChartPlotLayout, xlsxChartNodeUsesStackedGrouping, isSupportedXlsxChartSeriesFormatting, readXlsxFormulaFeaturesFromPackage, inspectXlsxHeaderFooterText, emptySpreadsheetWorksheetCompatibilitySummary, isSupportedXlsxWorksheetImageContentType, MAX_XLSX_WORKSHEET_IMAGE_BYTES, xlsxChartSeriesFormattingShapeProperties, diagnoseXlsxProtection, isEditableXlsxPaperSizeCode, isSupportedXlsxCombinationChartNodes } from "./4104.js";
 import { spreadsheetConditionalComparisonNeedsUpperValue, isSpreadsheetConditionalIconSetName, isSpreadsheetConditionalComparisonOperator, spreadsheetConditionalIconSetCount, xlsxWorksheetCellEntries } from "./1544.js";
 import { formulaHasStructuredReference, formulaHasExternalReference, parseSpreadsheetPrintTitles, volatileSpreadsheetFormulaFunctions, stripSpreadsheetSheetQualifier } from "./8715.js";
@@ -93,6 +93,8 @@ function bookmarkIssue(code, message, severity = 'warning') {
 function diagnoseDocxCaptions(document) {
     const fields = docxFieldOccurrences(document);
     const tableOfContentsFields = fields.filter(supportedDocxTableOfContentsField);
+    const indexEntryFields = fields.filter(supportedDocxIndexEntryField);
+    const indexFields = fields.filter(supportedDocxIndexField);
     const tableOfContentsContainers = new Set(tableOfContentsFields.flatMap((field)=>{
         const container = closestAncestor(field.start, 'sdt');
         return container ? [
@@ -103,10 +105,21 @@ function diagnoseDocxCaptions(document) {
         const container = closestAncestor(field.start, 'sdt');
         return Boolean(container && tableOfContentsContainers.has(container));
     };
+    const indexContainers = new Set(indexFields.flatMap((field)=>{
+        const container = closestAncestor(field.start, 'sdt');
+        return container ? [
+            container
+        ] : [];
+    }));
+    const isIndexField = (field)=>{
+        const container = closestAncestor(field.start, 'sdt');
+        return Boolean(container && indexContainers.has(container));
+    };
+    const isSupportedBlockField = (field)=>isTableOfContentsField(field) || isIndexField(field);
     const sequences = fields.filter((field)=>docxCaptionSequenceKind(field.instruction));
     const bodyFields = fields.filter((field)=>'orphan' !== field.syntax && Boolean(docxDocumentFieldKind(field.instruction)));
     const editableBodyFields = bodyFields.filter(docxFieldOccurrenceIsInlineEditable);
-    const hasUnsupportedFieldStructure = hasInvalidDocxFieldStructure(document, isTableOfContentsField) || bodyFields.some((field)=>!docxFieldOccurrenceIsInlineEditable(field));
+    const hasUnsupportedFieldStructure = hasInvalidDocxFieldStructure(document, isSupportedBlockField) || bodyFields.some((field)=>!docxFieldOccurrenceIsInlineEditable(field));
     const bookmarkNames = new Set([
         ...captionBookmarkNames(sequences),
         ...pairedBookmarkNames(document)
@@ -137,6 +150,14 @@ function diagnoseDocxCaptions(document) {
                     severity: 'info'
                 }
             ] : [],
+            ...indexEntryFields.length || indexFields.length ? [
+                {
+                    code: 'docx.index',
+                    feature: 'Index',
+                    message: 'Native XE entries, primary and secondary terms, cross-references, page emphasis, cached INDEX rows, columns, and leader styles remain editable and round-trip in DOCX output.',
+                    severity: 'info'
+                }
+            ] : [],
             ...hasUnsupportedFieldStructure ? [
                 {
                     code: 'docx.fields.structure',
@@ -146,7 +167,7 @@ function diagnoseDocxCaptions(document) {
                 }
             ] : []
         ],
-        hasUnsupportedFields: hasUnsupportedFieldStructure || fields.some((field)=>!isTableOfContentsField(field) && !isSupportedCaptionField(field.instruction, bookmarkNames))
+        hasUnsupportedFields: hasUnsupportedFieldStructure || fields.some((field)=>!isSupportedBlockField(field) && !supportedDocxIndexEntryField(field) && !isSupportedCaptionField(field.instruction, bookmarkNames))
     };
 }
 function captionBookmarkNames(fields) {

package/dist/4104.js

@@ -590,7 +590,7 @@ async function importWorkDocumentFile(file, extension, context) {
         recordDocumentImportMeasure('a3s-office.document.mammoth', mammothStartedAt, documentImportNow());
         context?.controller.report('parsing', 0.8);
         const markersStartedAt = documentImportNow();
-        html = prepared ? applyDocxSectionsToHtml(result.value, prepared.sections, prepared.captionMarkers, prepared.bookmarkMarkers, prepared.changeMarkers, prepared.commentMarkers, prepared.fieldMarkers, prepared.tableOfContentsMarkers, prepared.equationMarkers, prepared.citationMarkers, prepared.listMarkers, prepared.imageLayoutMarkers, prepared.paragraphIdentityMarkers, prepared.paragraphFormattingChangeMarkers, prepared.paragraphAlignmentMarkers, prepared.runFormattingMarkers, prepared.paragraphDirectionMarkers, prepared.paragraphIndentMarkers, prepared.paragraphSpacingMarkers, prepared.paragraphBorderMarkers, prepared.paragraphShadingMarkers, prepared.paragraphPaginationMarkers, prepared.bibliography, prepared.tabStopMarkers, prepared.tableCellMarkers, prepared.tableRowMarkers, prepared.tableSizingMarkers) : result.value;
+        html = prepared ? applyDocxSectionsToHtml(result.value, prepared.sections, prepared.captionMarkers, prepared.bookmarkMarkers, prepared.changeMarkers, prepared.commentMarkers, prepared.fieldMarkers, prepared.tableOfContentsMarkers, prepared.indexMarkers, prepared.equationMarkers, prepared.citationMarkers, prepared.listMarkers, prepared.imageLayoutMarkers, prepared.paragraphIdentityMarkers, prepared.paragraphFormattingChangeMarkers, prepared.paragraphAlignmentMarkers, prepared.runFormattingMarkers, prepared.paragraphDirectionMarkers, prepared.paragraphIndentMarkers, prepared.paragraphSpacingMarkers, prepared.paragraphBorderMarkers, prepared.paragraphShadingMarkers, prepared.paragraphPaginationMarkers, prepared.bibliography, prepared.tabStopMarkers, prepared.tableCellMarkers, prepared.tableRowMarkers, prepared.tableSizingMarkers) : result.value;
         recordDocumentImportMeasure('a3s-office.document.markers', markersStartedAt, documentImportNow());
         const layout = prepared ? {
             ...documentContentLayoutProperties(prepared.sections[0].layout),