@a3s-lab/office 0.30.0 → 0.31.0

package/README.md

@@ -56,18 +56,19 @@ workflows, and a separate Rust automation plane.
 
 ## Latest on `main`
 
-The `0.30.0` release and current Pages deployment expose these capabilities as
-normal user-facing Playground templates, with matching implementation detail
-in the versioned documentation:
+The `0.31.0` release plus the current `main` branch expose these capabilities
+as normal user-facing Playground templates, with matching implementation
+detail in the documentation:
 
 | Editor | Latest capability | Public entry |
 | --- | --- | --- |
 | Writer | Insert, customize, navigate, and explicitly refresh a typed Table of Contents with heading and native outline levels 1–9, hyperlinks, page numbers, alignment, four leader styles, and native DOCX `TOC` round trips | Playground **Latest capabilities → 可更新目录** · [Document reference](docs/latest/en/components/document.mdx#native-table-of-contents) |
+| Writer | Mark primary and secondary index terms, cross-references, and bold/italic page numbers; insert, navigate, customize, and refresh a bounded native index with editable DOCX `XE` and `INDEX` round trips | Playground **Latest capabilities → 原生索引** · [Document reference](docs/latest/en/components/document.mdx#native-document-index) |
 | Writer | Native character shading with exact `w:shd` patterns, foreground/background color identity, explicit resets, authoring, and DOCX reopen | Playground **Latest capabilities → 字符底纹** · [Document reference](docs/latest/en/components/document.mdx#native-character-shading) |
 | Writer | Independent Latin, East Asian, and bidi proofing languages plus explicit `w:noProof` inclusion/exclusion | Playground **Latest capabilities → 校对语言** · [Document reference](docs/latest/en/components/document.mdx#native-proofing-languages) |
 | Spreadsheet | Complete common Data Validation input, blank/dropdown, and Stop/Warning/Information error settings with native XLSX round trips | Playground **Latest capabilities → 数据验证** · [Spreadsheet reference](docs/latest/en/components/spreadsheet.mdx#data-validation) |
 
-The same four entries remain available under **新建**. The highlighted strip
+The same five entries remain available under **新建**. The highlighted strip
 exists so a capability is discoverable from the first Playground viewport
 instead of only through a deep documentation section or an `?e2e=` fixture.
 
@@ -131,7 +132,7 @@ baseline rather than one specific release.
 | Page layout and rendering | **Partial** — sections, margins, page size, columns, headers/footers, fields, and live pagination | Desktop-grade pagination, print layout, and vector output |
 | Tables, pictures, and equations | **Partial** — rich table geometry, floating pictures, crop/wrap, and structured OMML | Broader drawings, text boxes, charts, WordArt, and SmartArt |
 | Comments, revisions, and collaboration | **Partial** — comments, suggestions, text/format revisions, decisions, Yjs presence, and host relay contracts | Full revision families plus integrated sharing and review services |
-| References and document generation | **Partial** — typed Table of Contents authoring and refresh, bookmarks, links, captions, cross-references, citations, notes, and common fields | Index authoring, mail merge, compare/combine, and broader fields |
+| References and document generation | **Partial** — typed Table of Contents and native index authoring/refresh, bookmarks, links, captions, cross-references, citations, notes, and common fields | Mail merge, compare/combine, tables of figures/authorities, and broader fields |
 | Ribbon and shortcuts | **Supported** — responsive Office-style ribbon and editor-scoped daily-writing shortcuts | Complete desktop shortcut and contextual-tool surface |
 | Very large documents | **Supported with boundaries** — bounded 100,000-block plain-document windows and measured edit/navigation budgets | Native-engine virtualization with device-dependent limits |
 | DOCX and PDF fidelity | **Partial** — source-aware DOCX preservation and live-layout raster PDF export | Broader legacy/OOXML compatibility and searchable vector PDF output |
@@ -246,6 +247,21 @@ is requested. The complete gap inventory and exit evidence live in the
   `\\u`, full-range `\\n`, and space-separator `\\p` subset while diagnosing
   lossy custom style mappings. The Playground's **可更新目录** template exposes
   the complete flow.
+  Writer indexes use hidden, selectable inline entry atoms and a separate
+  selectable generated block. Primary terms, secondary terms, cross-references,
+  and bold/italic page-number intent remain typed; duplicate terms on the same
+  page merge while retaining every stable marker target. The live Worker/WASM
+  field resolver remains the only page-number source. Mark, edit, insert,
+  customize, and explicit all-index refresh each commit one TipTap transaction
+  and one Undo record. At most 2,048 markers contribute to at most 512 cached
+  rows, with explicit truncation beyond either bound. DOCX export writes
+  native `XE` simple fields and a real `w:sdt`/`INDEX` content control with cached
+  `Index1`/`Index2` rows, columns, cross-references, page emphasis, alignment,
+  and dot/dash/underline/no leaders. Import accepts the lossless common `XE`
+  `\\b`, `\\i`, and `\\t` plus `INDEX` `\\c`, `\\e`, and `\\r` subset;
+  unsupported switches remain diagnosed instead of approximated. The
+  Playground's **原生索引** template exposes marking, navigation, refresh,
+  export, and reopen.
 - **Framework choice** — React components, Vue 3 adapters, Custom Elements,
   and a framework-neutral Core API over the same engine.
 - **Responsive computation** — Lazy editor chunks, cancellable Workers,
@@ -1553,6 +1569,7 @@ without hard-coded return URLs.
 
 - [Live Playground](https://a3s-lab.github.io/Office/)
 - [Documentation center](https://a3s-lab.github.io/Office/docs/)
+- [A3S Office 0.31.0 documentation](https://a3s-lab.github.io/Office/docs/0.31.0/)
 - [A3S Office 0.30.0 documentation](https://a3s-lab.github.io/Office/docs/0.30.0/)
 - [A3S Office 0.29.0 documentation](https://a3s-lab.github.io/Office/docs/0.29.0/)
 - [A3S Office 0.28.0 documentation](https://a3s-lab.github.io/Office/docs/0.28.0/)

package/dist/{0~7231.js → 0~4808.js}

@@ -1,5 +1,5 @@
 import jszip from "jszip";
-import { serializeUtf8Xml, directChildren, xmlNamespacePrefix, normalizeDocumentLanguageTag, parseXml, firstDescendant, decodeXmlBytes, directChild, descendants, normalizeDocumentProofingLanguages, attribute as work_ooxml_package_attribute } from "./4121.js";
+import { normalizeDocumentIndexEntryDraft, serializeUtf8Xml, directChildren, xmlNamespacePrefix, normalizeDocumentLanguageTag, parseXml, firstDescendant, decodeXmlBytes, directChild, descendants, normalizeDocumentProofingLanguages, attribute as work_ooxml_package_attribute, normalizeDocumentIndexOptions } from "./4121.js";
 import { normalizeDocumentEmphasisMark, normalizeDocumentCharacterScalePercent, documentCitationStyle, normalizeDocumentKerningThresholdHalfPoints, normalizeDocumentCharacterPositionHalfPoints, normalizeDocumentCharacterSpacingTwips, normalizeDocumentTabStops, createDocumentBibliography, documentCitationStyleDetails } from "./6282.js";
 const BIBLIOGRAPHY_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/bibliography';
 const CUSTOM_XML_NAMESPACE = 'http://schemas.openxmlformats.org/officeDocument/2006/customXml';
@@ -708,6 +708,193 @@ function isAllowedExtensionNamespace(namespace, context) {
 function isNamespacePrefix(value) {
     return /^[A-Za-z_][A-Za-z0-9_.-]*$/.test(value) && 'xml' !== value;
 }
+function parseDocumentIndexEntryInstruction(instruction) {
+    const command = /^\s*XE\b/i.exec(instruction);
+    if (!command) return {
+        supported: false,
+        reason: 'not-index-entry'
+    };
+    const parsed = parseLeadingFieldValue(instruction.slice(command[0].length));
+    if (!parsed) return {
+        supported: false,
+        reason: 'invalid-instruction'
+    };
+    const switches = parseFieldSwitches(parsed.rest);
+    if (!switches) return {
+        supported: false,
+        reason: 'invalid-instruction'
+    };
+    for (const name of switches.keys())if (![
+        'b',
+        'i',
+        't'
+    ].includes(name)) return {
+        supported: false,
+        reason: 'unsupported-switch'
+    };
+    const boldValue = valueSwitch(switches, 'b');
+    const italicValue = valueSwitch(switches, 'i');
+    if (null != boldValue || null != italicValue) return {
+        supported: false,
+        reason: 'invalid-instruction'
+    };
+    const crossReferenceValue = valueSwitch(switches, 't');
+    if (switches.has('t') && !crossReferenceValue) return {
+        supported: false,
+        reason: 'invalid-instruction'
+    };
+    const terms = splitIndexEntryTerms(parsed.value);
+    const value = normalizeDocumentIndexEntryDraft({
+        mainEntry: terms.mainEntry,
+        subEntry: terms.subEntry,
+        crossReference: crossReferenceValue?.replace(/^see\s+/i, '') ?? '',
+        pageBold: switches.has('b'),
+        pageItalic: switches.has('i')
+    });
+    return value ? {
+        supported: true,
+        value
+    } : {
+        supported: false,
+        reason: 'invalid-entry'
+    };
+}
+function documentIndexEntryInstruction(source) {
+    const value = normalizeDocumentIndexEntryDraft(source);
+    if (!value) throw new Error('Document index entry is invalid.');
+    const term = value.subEntry ? `${escapeFieldValue(value.mainEntry)}:${escapeFieldValue(value.subEntry)}` : escapeFieldValue(value.mainEntry);
+    const switches = [];
+    if (value.crossReference) switches.push(`\\t "See ${escapeFieldValue(value.crossReference)}"`);
+    else {
+        if (value.pageBold) switches.push('\\b');
+        if (value.pageItalic) switches.push('\\i');
+    }
+    return `XE "${term}"${switches.length ? ` ${switches.join(' ')}` : ''}`;
+}
+function parseDocumentIndexInstruction(instruction) {
+    const command = /^\s*INDEX\b/i.exec(instruction);
+    if (!command) return {
+        supported: false,
+        reason: 'not-index'
+    };
+    const switches = parseFieldSwitches(instruction.slice(command[0].length));
+    if (!switches) return {
+        supported: false,
+        reason: 'invalid-instruction'
+    };
+    for (const name of switches.keys())if (![
+        'c',
+        'e',
+        'r'
+    ].includes(name)) return {
+        supported: false,
+        reason: 'unsupported-switch'
+    };
+    const columnsValue = valueSwitch(switches, 'c');
+    if (switches.has('c') && !/^[1-4]$/.test(columnsValue ?? '')) return {
+        supported: false,
+        reason: 'invalid-columns'
+    };
+    const separator = valueSwitch(switches, 'e');
+    if (switches.has('e') && void 0 === separator) return {
+        supported: false,
+        reason: 'invalid-instruction'
+    };
+    if (switches.has('r') && null !== valueSwitch(switches, 'r')) return {
+        supported: false,
+        reason: 'invalid-instruction'
+    };
+    return {
+        supported: true,
+        options: normalizeDocumentIndexOptions({
+            columns: columnsValue ? Number(columnsValue) : 1,
+            format: switches.has('r') ? 'run-in' : 'indented',
+            rightAlignPageNumbers: !switches.has('e'),
+            leader: switches.has('e') ? 'none' : 'dot'
+        })
+    };
+}
+function documentIndexInstruction(source) {
+    const options = normalizeDocumentIndexOptions(source);
+    const switches = options.columns > 1 ? [
+        `\\c "${options.columns}"`
+    ] : [];
+    if ('run-in' === options.format) switches.push('\\r');
+    if (!options.rightAlignPageNumbers) switches.push('\\e ", "');
+    return `INDEX${switches.length ? ` ${switches.join(' ')}` : ''}`;
+}
+function splitIndexEntryTerms(source) {
+    let escaped = false;
+    for(let index = 0; index < source.length; index += 1){
+        const character = source[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if ('\\' === character) {
+            escaped = true;
+            continue;
+        }
+        if (':' === character) return {
+            mainEntry: unescapeFieldValue(source.slice(0, index)),
+            subEntry: unescapeFieldValue(source.slice(index + 1))
+        };
+    }
+    return {
+        mainEntry: unescapeFieldValue(source),
+        subEntry: ''
+    };
+}
+function parseLeadingFieldValue(source) {
+    const trimmed = source.trimStart();
+    if (!trimmed) return null;
+    if ('"' !== trimmed[0]) {
+        const match = /^([^\s\\]+)([\s\S]*)$/.exec(trimmed);
+        return match?.[1] ? {
+            value: match[1],
+            rest: match[2] ?? ''
+        } : null;
+    }
+    let escaped = false;
+    for(let index = 1; index < trimmed.length; index += 1){
+        const character = trimmed[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if ('\\' === character) {
+            escaped = true;
+            continue;
+        }
+        if ('"' === character) return {
+            value: trimmed.slice(1, index),
+            rest: trimmed.slice(index + 1)
+        };
+    }
+    return null;
+}
+function parseFieldSwitches(source) {
+    const switches = new Map();
+    const matcher = /\\([a-z])(?:\s+("([^"\\]*(?:\\.[^"\\]*)*)"|([^\\\s]+)))?/gi;
+    let cursor = 0;
+    for(let match = matcher.exec(source); match; match = matcher.exec(source)){
+        if (source.slice(cursor, match.index).trim()) return null;
+        const name = match[1]?.toLowerCase();
+        if (!name || switches.has(name)) return null;
+        switches.set(name, unescapeFieldValue(match[3] ?? match[4] ?? '') || null);
+        cursor = matcher.lastIndex;
+    }
+    return source.slice(cursor).trim() ? null : switches;
+}
+function valueSwitch(switches, name) {
+    return switches.has(name) ? switches.get(name) : void 0;
+}
+function escapeFieldValue(value) {
+    return value.replaceAll('\\', '\\\\').replaceAll('"', '\\"').replaceAll(':', '\\:');
+}
+function unescapeFieldValue(value) {
+    return value.replace(/\\([\\":])/g, '$1');
+}
 const STRICT_WORDPROCESSING_NAMESPACE = 'http://purl.oclc.org/ooxml/wordprocessingml/main';
 const UNIVERSAL_TWIP_RATIOS = {
     mm: [
@@ -1737,4 +1924,4 @@ function isParagraphPartRoot(root, path) {
     const expected = /^word\/header\d*\.xml$/i.test(path) ? 'hdr' : /^word\/footer\d*\.xml$/i.test(path) ? 'ftr' : /^word\/footnotes\.xml$/i.test(path) ? 'footnotes' : /^word\/endnotes\.xml$/i.test(path) ? 'endnotes' : 'document';
     return root.localName === expected && DOCX_WORDPROCESSING_NAMESPACES.has(root.namespaceURI ?? '');
 }
-export { DOCX_COLOR_SCHEME_MAPPING_ATTRIBUTES, DOCX_WORDPROCESSING_NAMESPACES, DocxParagraphDefaultCollapsedPatchCollector, STRICT_WORDPROCESSING_NAMESPACE, XMLNS_NAMESPACE, XML_NAMESPACE, assertXmlRoot, cloneXmlElement, createDocxThemeResolver, cssColorToHex, cssFontFamily, cssFontSize, dataBoolean, documentProofingLanguageDocxOptions, docxCharacterPositionHalfPointsFromProperties, docxCharacterPositionValue, docxCharacterScalePercentFromProperties, docxCharacterScaleValue, docxCharacterSpacingTwipsFromProperties, docxCharacterSpacingValue, docxEmphasisMarkRunOptions, docxKerningThresholdValue, docxThemeColor, docxThemeFont, domDirection, hasNonWhitespaceXmlText, inspectDocxEmphasisMark, inspectDocxKerningThresholdHalfPoints, inspectDocxNoProof, inspectDocxProofingLanguages, mergeDocxIgnorableExtensions, mergeDocxIgnorableExtensionsAtPairs, paragraphAlignment, paragraphBidirectional, paragraphDirectionOptions, paragraphIndent, paragraphPaginationOptions, paragraphSpacingOptions, paragraphTabStops, parseBoundedDocxInteger, parseDocxColorSchemeMappingElement, parseDocxParagraphDefaultCollapsed, parseDocxTwipsMeasure, patchDocxBibliography, patchDocxExplicitZeroCharacterSpacing, patchDocxExplicitZeroKerningThresholds, patchDocxParagraphDefaultCollapsed, readDocxBibliography, resolveDocxEmphasisMark, resolveDocxKerningThresholdHalfPoints, resolveDocxProofing, resolveDocxThemeResolver, xmlAttributeLocalName, xmlAttributeNamespace, xmlDeclaredPrefix, xmlNamespaceUri };
+export { DOCX_COLOR_SCHEME_MAPPING_ATTRIBUTES, DOCX_WORDPROCESSING_NAMESPACES, DocxParagraphDefaultCollapsedPatchCollector, STRICT_WORDPROCESSING_NAMESPACE, XMLNS_NAMESPACE, XML_NAMESPACE, assertXmlRoot, cloneXmlElement, createDocxThemeResolver, cssColorToHex, cssFontFamily, cssFontSize, dataBoolean, documentIndexEntryInstruction, documentIndexInstruction, documentProofingLanguageDocxOptions, docxCharacterPositionHalfPointsFromProperties, docxCharacterPositionValue, docxCharacterScalePercentFromProperties, docxCharacterScaleValue, docxCharacterSpacingTwipsFromProperties, docxCharacterSpacingValue, docxEmphasisMarkRunOptions, docxKerningThresholdValue, docxThemeColor, docxThemeFont, domDirection, hasNonWhitespaceXmlText, inspectDocxEmphasisMark, inspectDocxKerningThresholdHalfPoints, inspectDocxNoProof, inspectDocxProofingLanguages, mergeDocxIgnorableExtensions, mergeDocxIgnorableExtensionsAtPairs, paragraphAlignment, paragraphBidirectional, paragraphDirectionOptions, paragraphIndent, paragraphPaginationOptions, paragraphSpacingOptions, paragraphTabStops, parseBoundedDocxInteger, parseDocumentIndexEntryInstruction, parseDocumentIndexInstruction, parseDocxColorSchemeMappingElement, parseDocxParagraphDefaultCollapsed, parseDocxTwipsMeasure, patchDocxBibliography, patchDocxExplicitZeroCharacterSpacing, patchDocxExplicitZeroKerningThresholds, patchDocxParagraphDefaultCollapsed, readDocxBibliography, resolveDocxEmphasisMark, resolveDocxKerningThresholdHalfPoints, resolveDocxProofing, resolveDocxThemeResolver, xmlAttributeLocalName, xmlAttributeNamespace, xmlDeclaredPrefix, xmlNamespaceUri };

package/dist/0~5050.js

@@ -276,6 +276,15 @@ function documentCurrentPage(editor) {
     });
     return page;
 }
+function documentHasRefreshableFields(editor) {
+    let found = false;
+    editor.state.doc.descendants((node)=>{
+        if ('documentField' !== node.type.name) return !found;
+        found = true;
+        return false;
+    });
+    return found;
+}
 async function copyDocumentSelection(selection) {
     try {
         if (!navigator.clipboard?.writeText) throw new Error('Clipboard API is unavailable');
@@ -297,4 +306,4 @@ function mergeOfficeTiptapExtensions(editorName, builtInExtensions, additionalEx
         ...additionalExtensions
     ];
 }
-export { createWorkDocumentSelectionAction, createWorkDocumentSelectionSnapshot, customSelectionMenuItems, documentAgentMenuItems, documentCurrentPage, documentCustomSelectionMenuItems, documentPageCount, documentPlainTextAsHtml, mergeOfficeTiptapExtensions };
+export { createWorkDocumentSelectionAction, createWorkDocumentSelectionSnapshot, customSelectionMenuItems, documentAgentMenuItems, documentCurrentPage, documentCustomSelectionMenuItems, documentHasRefreshableFields, documentPageCount, documentPlainTextAsHtml, mergeOfficeTiptapExtensions };

package/dist/{0~7360.js → 0~7240.js}

@@ -1,5 +1,5 @@
-import { documentRunBorderDomAttributes, normalizeDocumentRunBorder, normalizeDocumentParagraphBorder, serializeDocumentRunBorder, serializeDocumentRunShading, documentScriptFontFallbackSlots, attribute as work_ooxml_package_attribute, documentScriptFontsDomAttributes, documentHighlightFromDocxValue, documentTableOfContentsHtml, directChildren as work_ooxml_package_directChildren, documentParagraphShadingDomAttributes, serializeDocxThemeReference, documentParagraphBordersDomAttributes, normalizeDocumentScriptFontHint, normalizeDocumentScriptFonts, DOCUMENT_PARAGRAPH_BORDER_STYLES, normalizeDocumentParagraphBorders as work_document_paragraph_borders_normalizeDocumentParagraphBorders, DOCUMENT_PARAGRAPH_BORDER_EDGES, documentScriptFontFamily, normalizeDocumentThemeFont, normalizeDocumentParagraphId, documentHighlightDomAttributes, descendants, documentHighlightCssColor, xmlNamespacePrefix, normalizeDocumentFontName, documentProofingDomAttributes, work_document_paragraph_shading_DOCUMENT_PARAGRAPH_SHADING_PATTERNS, directChild, documentScriptFontSegments, childPath, parseDocumentTableOfContentsInstruction, documentRunShadingDomAttributes } from "./4121.js";
-import { docxThemeFont, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, resolveDocxProofing, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, STRICT_WORDPROCESSING_NAMESPACE, docxCharacterSpacingTwipsFromProperties, parseBoundedDocxInteger, xmlAttributeLocalName, docxCharacterScalePercentFromProperties, resolveDocxEmphasisMark, docxCharacterPositionHalfPointsFromProperties, docxThemeColor, parseDocxParagraphDefaultCollapsed, resolveDocxKerningThresholdHalfPoints, resolveDocxThemeResolver as work_docx_theme_resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, xmlAttributeNamespace, parseDocxTwipsMeasure } from "./0~7231.js";
+import { documentRunBorderDomAttributes, normalizeDocumentRunBorder, normalizeDocumentParagraphBorder, serializeDocumentRunBorder, serializeDocumentRunShading, documentIndexEntryHtml, attribute as work_ooxml_package_attribute, documentScriptFontFallbackSlots, documentScriptFontsDomAttributes, documentHighlightFromDocxValue, documentTableOfContentsHtml, directChildren as work_ooxml_package_directChildren, documentParagraphShadingDomAttributes, serializeDocxThemeReference, documentParagraphBordersDomAttributes, normalizeDocumentScriptFontHint, normalizeDocumentScriptFonts, DOCUMENT_PARAGRAPH_BORDER_STYLES, normalizeDocumentParagraphBorders as work_document_paragraph_borders_normalizeDocumentParagraphBorders, DOCUMENT_PARAGRAPH_BORDER_EDGES, documentScriptFontFamily, normalizeDocumentThemeFont, normalizeDocumentParagraphId, documentHighlightDomAttributes, descendants, documentIndexHtml, documentHighlightCssColor, xmlNamespacePrefix, normalizeDocumentFontName, documentProofingDomAttributes, work_document_paragraph_shading_DOCUMENT_PARAGRAPH_SHADING_PATTERNS, directChild, documentScriptFontSegments, childPath, parseDocumentTableOfContentsInstruction, documentRunShadingDomAttributes } from "./4121.js";
+import { docxThemeFont, XML_NAMESPACE as work_docx_settings_xml_XML_NAMESPACE, parseDocumentIndexEntryInstruction, resolveDocxProofing, parseDocumentIndexInstruction, XMLNS_NAMESPACE as work_docx_settings_xml_XMLNS_NAMESPACE, STRICT_WORDPROCESSING_NAMESPACE, docxCharacterSpacingTwipsFromProperties, parseBoundedDocxInteger, xmlAttributeLocalName, docxCharacterScalePercentFromProperties, resolveDocxEmphasisMark, docxCharacterPositionHalfPointsFromProperties, docxThemeColor, parseDocxParagraphDefaultCollapsed, resolveDocxKerningThresholdHalfPoints, resolveDocxThemeResolver as work_docx_theme_resolveDocxThemeResolver, DOCX_WORDPROCESSING_NAMESPACES, xmlAttributeNamespace, parseDocxTwipsMeasure } from "./0~4808.js";
 import { normalizeDocumentEmphasisMark, normalizeDocumentPageBorders, documentCharacterPositionDomAttributes, DOCUMENT_PAGE_BORDER_EDGES, normalizeDocumentTabStops, documentTextCaseFromWordFlags, documentStrikeDomAttributes, documentAutoLineHeight, documentKerningDomAttributes, normalizeDocumentUnderlineColor, documentCharacterScaleDomAttributes, serializeDocumentParagraphFormatting, normalizeDocumentPaperSource, documentEquationText, documentLegacyTextEffectsDomAttributes, documentLegacyTextEffectsConflict, documentCharacterSpacingDomAttributes, normalizeDocumentParagraphIndent, normalizeDocumentEquation, renderDocumentAutoLineHeight, documentUnderlineDomAttributes, normalizeDocumentUnderlineStyle, applyDocumentTextCaseStyle, documentHiddenTextDomAttributes, importedDocumentCharacterFormatting, DOCUMENT_LEGACY_TEXT_EFFECT_NAMES, createDocumentEquationElement, normalizeDocumentPageGeometry, serializeDocumentTabStops, documentWordLineHeightFactor, documentEmphasisMarkDomAttributes, normalizeDocumentPageMargins } from "./6282.js";
 function docxCaptionSequenceKind(instruction) {
     const identifier = /^\s*SEQ\s+([^\s\\]+)/i.exec(instruction)?.[1]?.toLowerCase();
@@ -4074,6 +4074,235 @@ function nextEquationMarker(state) {
     return marker;
 }
 const WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
+const work_docx_index_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
+function markDocxIndexes(document) {
+    const fields = docxFieldOccurrences(document);
+    const entries = fields.flatMap((field, index)=>{
+        const parsed = parseDocumentIndexEntryInstruction(field.instruction);
+        if (!parsed.supported || !docxFieldOccurrenceIsInlineEditable(field)) return [];
+        const marker = {
+            start: `__A3S_WORK_INDEX_ENTRY_START_${index + 1}__`,
+            end: `__A3S_WORK_INDEX_ENTRY_END_${index + 1}__`,
+            id: `index-entry-import-${index + 1}`,
+            value: parsed.value
+        };
+        insertFieldBoundaryMarkers(document, field, marker.start, marker.end);
+        return [
+            marker
+        ];
+    });
+    const indexes = [];
+    for (const field of fields){
+        if (!supportedDocxIndexField(field)) continue;
+        const parsed = parseDocumentIndexInstruction(field.instruction);
+        if (!parsed.supported) continue;
+        const control = work_docx_index_import_closestAncestor(field.start, 'sdt');
+        if (!control || !document.documentElement.contains(control)) continue;
+        const index = indexes.length + 1;
+        const marker = {
+            marker: `__A3S_WORK_DOCUMENT_INDEX_${index}__`,
+            id: `document-index-import-${index}`,
+            options: {
+                ...parsed.options,
+                leader: importedIndexLeader(control, parsed.options)
+            },
+            entries: importedIndexEntries(control, index)
+        };
+        control.replaceWith(markerParagraph(document, marker.marker));
+        indexes.push(marker);
+    }
+    return {
+        entries,
+        indexes
+    };
+}
+function applyImportedDocxIndexMarkers(document, markers) {
+    for (const entry of markers.entries){
+        const html = documentIndexEntryHtml({
+            id: entry.id,
+            ...entry.value
+        });
+        const parsed = document.createRange().createContextualFragment(html);
+        const replacement = parsed.firstElementChild;
+        if (replacement instanceof HTMLElement) replaceMarkerRange(document.body, entry.start, entry.end, replacement);
+    }
+    const importedEntries = Array.from(document.body.querySelectorAll('[data-document-index-entry]'));
+    for (const index of markers.indexes){
+        const text = textNodes(document.body).find((node)=>node.data.includes(index.marker));
+        if (!text) continue;
+        const entries = index.entries.map((entry, entryIndex)=>{
+            const targets = importedEntries.filter((candidate)=>normalizedTerm(candidate.dataset.indexMainEntry) === normalizedTerm(entry.mainEntry) && normalizedTerm(candidate.dataset.indexSubEntry) === normalizedTerm(entry.subEntry));
+            const targetIds = targets.flatMap((candidate)=>{
+                const id = candidate.dataset.indexEntryId?.trim();
+                return id ? [
+                    id
+                ] : [];
+            });
+            return {
+                ...entry,
+                pages: entry.pages.map((page)=>({
+                        ...page,
+                        targetIds: targetIds.length ? targetIds : [
+                            `index-entry-import-${index.id}-${entryIndex + 1}`
+                        ]
+                    }))
+            };
+        });
+        const fragment = document.createRange().createContextualFragment(documentIndexHtml({
+            id: index.id,
+            options: index.options,
+            entries
+        }));
+        closestHtmlBlock(text.parentElement)?.replaceWith(fragment);
+    }
+}
+function hasImportedDocxIndexMarkers(markers) {
+    return markers.entries.length > 0 || markers.indexes.length > 0;
+}
+function supportedDocxIndexEntryField(field) {
+    return parseDocumentIndexEntryInstruction(field.instruction).supported && docxFieldOccurrenceIsInlineEditable(field);
+}
+function supportedDocxIndexField(field) {
+    return parseDocumentIndexInstruction(field.instruction).supported && field.complete && !field.nested && !field.inDeletion && Boolean(work_docx_index_import_closestAncestor(field.start, 'sdt'));
+}
+function importedIndexEntries(control, indexNumber) {
+    const entries = [];
+    let currentMain = '';
+    let row = 0;
+    for (const paragraph of descendants(control, 'p')){
+        const style = directChild(directChild(paragraph, 'pPr') ?? paragraph, 'pStyle');
+        const styleName = work_ooxml_package_attribute(style ?? paragraph, 'val') ?? '';
+        const level = /^Index([12])$/i.exec(styleName)?.[1];
+        if (!level) continue;
+        row += 1;
+        const parsed = importedIndexParagraph(paragraph, indexNumber, row);
+        if (parsed) {
+            if ('1' === level) {
+                currentMain = parsed.term;
+                if (!parsed.pages.length && !parsed.crossReference) continue;
+                entries.push({
+                    mainEntry: parsed.term,
+                    subEntry: '',
+                    crossReference: parsed.crossReference,
+                    pages: parsed.pages
+                });
+                continue;
+            }
+            if (currentMain) entries.push({
+                mainEntry: currentMain,
+                subEntry: parsed.term,
+                crossReference: parsed.crossReference,
+                pages: parsed.pages
+            });
+        }
+    }
+    return entries;
+}
+function importedIndexParagraph(paragraph, indexNumber, row) {
+    const textElements = descendants(paragraph, 't');
+    const values = textElements.map((element)=>element.textContent ?? '');
+    const combined = values.join('').replace(/\s+/g, ' ').trim();
+    if (!combined) return null;
+    const crossReference = /^(.+?),\s*(?:see|参见)\s+(.+)$/i.exec(combined);
+    if (crossReference?.[1] && crossReference[2]) return {
+        term: crossReference[1].trim(),
+        crossReference: crossReference[2].trim(),
+        pages: []
+    };
+    const pageElements = textElements.filter((element)=>/^\d{1,6}$/.test((element.textContent ?? '').trim()));
+    const pages = pageElements.map((element, pageIndex)=>{
+        const properties = directChild(work_docx_index_import_closestAncestor(element, 'r') ?? element, 'rPr');
+        return {
+            pageNumber: Number((element.textContent ?? '').trim()),
+            pageBold: Boolean(properties && directChild(properties, 'b')),
+            pageItalic: Boolean(properties && directChild(properties, 'i')),
+            targetIds: [
+                `index-entry-import-${indexNumber}-${row}-${pageIndex + 1}`
+            ]
+        };
+    });
+    const pageText = pageElements.map((element)=>element.textContent ?? '');
+    let term = combined;
+    for (const value of pageText)term = term.replace(new RegExp(`(?:,\\s*)?${escapeRegExp(value)}\\s*$`), '');
+    term = term.replace(/[,\s]+$/, '').trim();
+    return term ? {
+        term,
+        crossReference: '',
+        pages
+    } : null;
+}
+function importedIndexLeader(control, options) {
+    if (!options.rightAlignPageNumbers) return 'none';
+    const tab = descendants(control, 'tab').find((candidate)=>candidate.parentElement?.localName === 'tabs' && 'right' === work_ooxml_package_attribute(candidate, 'val'));
+    const leader = work_ooxml_package_attribute(tab ?? control, 'leader');
+    if ('hyphen' === leader) return 'dash';
+    if ('underscore' === leader) return 'underline';
+    if (!leader || 'none' === leader) return 'none';
+    return 'dot';
+}
+function insertFieldBoundaryMarkers(document, field, start, end) {
+    if ('fldChar' === field.start.localName && 'fldChar' === field.end.localName) {
+        field.start.parentNode?.insertBefore(markerText(document, start), field.start);
+        field.end.parentNode?.insertBefore(markerText(document, end), field.end.nextSibling);
+        return;
+    }
+    field.start.parentNode?.insertBefore(markerRun(document, start), field.start);
+    field.end.parentNode?.insertBefore(markerRun(document, end), field.end.nextSibling);
+}
+function markerParagraph(document, marker) {
+    const paragraph = document.createElementNS(WORD_NAMESPACE, 'w:p');
+    paragraph.append(markerRun(document, marker));
+    return paragraph;
+}
+function markerRun(document, value) {
+    const run = document.createElementNS(WORD_NAMESPACE, 'w:r');
+    run.append(markerText(document, value));
+    return run;
+}
+function markerText(document, value) {
+    const text = document.createElementNS(WORD_NAMESPACE, 'w:t');
+    text.setAttributeNS(work_docx_index_import_XML_NAMESPACE, 'xml:space', 'preserve');
+    text.textContent = value;
+    return text;
+}
+function replaceMarkerRange(root, start, end, replacement) {
+    const nodes = textNodes(root);
+    const startNode = nodes.find((node)=>node.data.includes(start));
+    const endNode = nodes.find((node)=>node.data.includes(end));
+    if (!startNode || !endNode) return;
+    const range = root.ownerDocument.createRange();
+    range.setStart(startNode, startNode.data.indexOf(start));
+    range.setEnd(endNode, endNode.data.indexOf(end) + end.length);
+    range.deleteContents();
+    range.insertNode(replacement);
+}
+function textNodes(root) {
+    const walker = root.ownerDocument?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
+    const nodes = [];
+    if (!walker) return nodes;
+    while(walker.nextNode())nodes.push(walker.currentNode);
+    return nodes;
+}
+function closestHtmlBlock(element) {
+    let current = element;
+    while(current && current.parentElement?.tagName.toLowerCase() !== 'body')current = current.parentElement;
+    return current;
+}
+function work_docx_index_import_closestAncestor(element, localName) {
+    let current = element;
+    while(current){
+        if (current.localName === localName) return current;
+        current = current.parentElement;
+    }
+    return null;
+}
+function normalizedTerm(value) {
+    return (value ?? '').normalize('NFKC').replace(/\s+/g, ' ').trim().toLowerCase();
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+const work_docx_table_of_contents_import_WORD_NAMESPACE = 'http://schemas.openxmlformats.org/wordprocessingml/2006/main';
 const work_docx_table_of_contents_import_XML_NAMESPACE = 'http://www.w3.org/XML/1998/namespace';
 function markDocxTablesOfContents(document) {
     const tables = [];
@@ -4093,7 +4322,7 @@ function markDocxTablesOfContents(document) {
             },
             entries: importedTableOfContentsEntries(element, tableIndex)
         };
-        element.replaceWith(markerParagraph(document, marker.marker));
+        element.replaceWith(work_docx_table_of_contents_import_markerParagraph(document, marker.marker));
         tables.push(marker);
     }
     return {
@@ -4104,7 +4333,7 @@ function applyImportedDocxTableOfContentsMarkers(document, markers) {
     const headings = importedHtmlHeadings(document);
     for (const table of markers.tables){
         const usedHeadingIndexes = new Set();
-        const text = textNodes(document.body).find((node)=>node.data.includes(table.marker));
+        const text = work_docx_table_of_contents_import_textNodes(document.body).find((node)=>node.data.includes(table.marker));
         if (!text) continue;
         const entries = table.entries.map((entry)=>{
             const headingIndex = headings.findIndex((heading, index)=>!usedHeadingIndexes.has(index) && heading.level === entry.level && normalizedTitle(heading.title) === normalizedTitle(entry.title));
@@ -4121,7 +4350,7 @@ function applyImportedDocxTableOfContentsMarkers(document, markers) {
             options: table.options,
             entries
         }));
-        const block = closestHtmlBlock(text.parentElement);
+        const block = work_docx_table_of_contents_import_closestHtmlBlock(text.parentElement);
         if (block) block.replaceWith(fragment);
     }
 }
@@ -4165,10 +4394,10 @@ function importedTableOfContentsLeader(element, options) {
     if (!leader || 'none' === leader) return 'none';
     return 'dot';
 }
-function markerParagraph(document, marker) {
-    const paragraph = document.createElementNS(WORD_NAMESPACE, 'w:p');
-    const run = document.createElementNS(WORD_NAMESPACE, 'w:r');
-    const text = document.createElementNS(WORD_NAMESPACE, 'w:t');
+function work_docx_table_of_contents_import_markerParagraph(document, marker) {
+    const paragraph = document.createElementNS(work_docx_table_of_contents_import_WORD_NAMESPACE, 'w:p');
+    const run = document.createElementNS(work_docx_table_of_contents_import_WORD_NAMESPACE, 'w:r');
+    const text = document.createElementNS(work_docx_table_of_contents_import_WORD_NAMESPACE, 'w:t');
     text.setAttributeNS(work_docx_table_of_contents_import_XML_NAMESPACE, 'xml:space', 'preserve');
     text.textContent = marker;
     run.append(text);
@@ -4191,14 +4420,14 @@ function importedHtmlHeadings(document) {
         ];
     });
 }
-function textNodes(root) {
+function work_docx_table_of_contents_import_textNodes(root) {
     const walker = root.ownerDocument?.createTreeWalker(root, NodeFilter.SHOW_TEXT);
     const nodes = [];
     if (!walker) return nodes;
     while(walker.nextNode())nodes.push(walker.currentNode);
     return nodes;
 }
-function closestHtmlBlock(element) {
+function work_docx_table_of_contents_import_closestHtmlBlock(element) {
     let current = element;
     while(current && current.parentElement?.tagName.toLowerCase() !== 'body')current = current.parentElement;
     return current;
@@ -7410,12 +7639,12 @@ function resolvedRunFormatting(propertySources, theme, runText, requestedFontSlo
     };
 }
 function insertRunMarkers(document, run, properties, startMarker, endMarker) {
-    const start = markerText(document, startMarker);
-    const end = markerText(document, endMarker);
+    const start = work_docx_run_formatting_import_markerText(document, startMarker);
+    const end = work_docx_run_formatting_import_markerText(document, endMarker);
     run.insertBefore(start, properties?.nextSibling ?? run.firstChild);
     run.append(end);
 }
-function markerText(document, marker) {
+function work_docx_run_formatting_import_markerText(document, marker) {
     const text = document.createElementNS(work_docx_run_formatting_import_WORD_NAMESPACE, 'w:t');
     text.setAttributeNS(work_docx_run_formatting_import_XML_NAMESPACE, 'xml:space', 'preserve');
     text.textContent = marker;
@@ -7698,4 +7927,4 @@ function work_docx_run_formatting_import_formatNumber(value) {
 function formatLineHeightFactor(value) {
     return Number(value.toFixed(4)).toString();
 }
-export { applyImportedDocxEquationMarkers, applyImportedDocxParagraphAlignmentMarkers, applyImportedDocxParagraphBorderMarkers, applyImportedDocxParagraphDirectionMarkers, applyImportedDocxParagraphFormattingChangeMarkers, applyImportedDocxParagraphIndentMarkers, applyImportedDocxParagraphPaginationMarkers, applyImportedDocxParagraphShadingMarkers, applyImportedDocxParagraphSpacingMarkers, applyImportedDocxParagraphTabStopMarkers, applyImportedDocxRunFormattingMarkers, applyImportedDocxTableOfContentsMarkers, createDocxParagraphStyleResolver, createDocxTableStyleResolver, createImportedDocxRunFormattingMarkerState, docxCaptionBookmark, docxCaptionReferenceTarget, docxCaptionSequenceKind, docxEquationHtml, docxFieldInstructions, docxFieldOccurrenceIsInlineEditable, docxFieldOccurrences, docxFieldResultText, docxRunPropertySources, docxTableCellStyleLayers, docxTablePropertySources, docxTableRunPropertySources, hasImportedDocxParagraphAlignmentMarkers, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphDirectionMarkers, hasImportedDocxParagraphFormattingChangeMarkers, hasImportedDocxParagraphIndentMarkers, hasImportedDocxParagraphPaginationMarkers, hasImportedDocxParagraphShadingMarkers, hasImportedDocxParagraphSpacingMarkers, hasImportedDocxParagraphTabStopMarkers, hasImportedDocxRunFormattingMarkers, hasImportedDocxTableOfContentsMarkers, hasInvalidDocxFieldStructure, importedDocxStrike, importedDocxUnderline, inspectDocxEquation, inspectDocxHiddenText, inspectDocxLegacyTextEffects, inspectDocxPageBorders, inspectDocxPageMarginSettings, inspectDocxPageMargins, inspectDocxPageSize, inspectDocxPaperSource, inspectDocxRunBorder, inspectDocxRunFonts, inspectDocxRunShading, isDocxEquationLikeRoot, isSupportedDocxEquationPlacement, isSupportedDocxParagraphFormattingChange, isSupportedDocxRunFormattingChange, markDocxPackageEquations, markDocxParagraphAlignments, markDocxParagraphBorders, markDocxParagraphDirections, markDocxParagraphFormattingChanges, markDocxParagraphIndents, markDocxParagraphPagination, markDocxParagraphShading, markDocxParagraphSpacing, markDocxParagraphTabStops, markDocxRunFormattingIntoState, markDocxTablesOfContents, parseDirectDocxParagraphShading, parseDocxPageBorders, parseDocxPageGeometry, parseDocxPageMargins, parseDocxPaperSource, resolveDocxHiddenText, resolveDocxLegacyTextEffects, resolveDocxParagraphBordersForParagraph, resolveDocxRunBorder, resolveDocxRunShading, resolveDocxTableStyleResolver, supportedDocxTableOfContentsField };
+export { applyImportedDocxEquationMarkers, applyImportedDocxIndexMarkers, applyImportedDocxParagraphAlignmentMarkers, applyImportedDocxParagraphBorderMarkers, applyImportedDocxParagraphDirectionMarkers, applyImportedDocxParagraphFormattingChangeMarkers, applyImportedDocxParagraphIndentMarkers, applyImportedDocxParagraphPaginationMarkers, applyImportedDocxParagraphShadingMarkers, applyImportedDocxParagraphSpacingMarkers, applyImportedDocxParagraphTabStopMarkers, applyImportedDocxRunFormattingMarkers, applyImportedDocxTableOfContentsMarkers, createDocxParagraphStyleResolver, createDocxTableStyleResolver, createImportedDocxRunFormattingMarkerState, docxCaptionBookmark, docxCaptionReferenceTarget, docxCaptionSequenceKind, docxEquationHtml, docxFieldInstructions, docxFieldOccurrenceIsInlineEditable, docxFieldOccurrences, docxFieldResultText, docxRunPropertySources, docxTableCellStyleLayers, docxTablePropertySources, docxTableRunPropertySources, hasImportedDocxIndexMarkers, hasImportedDocxParagraphAlignmentMarkers, hasImportedDocxParagraphBorderMarkers, hasImportedDocxParagraphDirectionMarkers, hasImportedDocxParagraphFormattingChangeMarkers, hasImportedDocxParagraphIndentMarkers, hasImportedDocxParagraphPaginationMarkers, hasImportedDocxParagraphShadingMarkers, hasImportedDocxParagraphSpacingMarkers, hasImportedDocxParagraphTabStopMarkers, hasImportedDocxRunFormattingMarkers, hasImportedDocxTableOfContentsMarkers, hasInvalidDocxFieldStructure, importedDocxStrike, importedDocxUnderline, inspectDocxEquation, inspectDocxHiddenText, inspectDocxLegacyTextEffects, inspectDocxPageBorders, inspectDocxPageMarginSettings, inspectDocxPageMargins, inspectDocxPageSize, inspectDocxPaperSource, inspectDocxRunBorder, inspectDocxRunFonts, inspectDocxRunShading, isDocxEquationLikeRoot, isSupportedDocxEquationPlacement, isSupportedDocxParagraphFormattingChange, isSupportedDocxRunFormattingChange, markDocxIndexes, markDocxPackageEquations, markDocxParagraphAlignments, markDocxParagraphBorders, markDocxParagraphDirections, markDocxParagraphFormattingChanges, markDocxParagraphIndents, markDocxParagraphPagination, markDocxParagraphShading, markDocxParagraphSpacing, markDocxParagraphTabStops, markDocxRunFormattingIntoState, markDocxTablesOfContents, parseDirectDocxParagraphShading, parseDocxPageBorders, parseDocxPageGeometry, parseDocxPageMargins, parseDocxPaperSource, resolveDocxHiddenText, resolveDocxLegacyTextEffects, resolveDocxParagraphBordersForParagraph, resolveDocxRunBorder, resolveDocxRunShading, resolveDocxTableStyleResolver, supportedDocxIndexEntryField, supportedDocxIndexField, supportedDocxTableOfContentsField };