@a3s-lab/office 0.29.0 → 0.31.0

package/README.md

@@ -54,6 +54,24 @@ workflows, and a separate Rust automation plane.
 - **Automate deterministically** through the native CLI, standard MCP server,
   or packaged Office Skill.
 
+## Latest on `main`
+
+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 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.
+
 ## See it working
 
 The images below are committed visual-regression baselines from the real
@@ -110,11 +128,11 @@ baseline rather than one specific release.
 
 | Capability | A3S Office today | Traditional Office baseline |
 | --- | --- | --- |
-| Text, paragraphs, lists, and styles | **Supported** — structured editing, independent native ASCII, high ANSI, East Asian, and complex-script font slots with direct/theme identity, native all-caps and small-caps effects, exact DOCX character scale plus signed spacing, half-point kerning thresholds, all five native East Asian emphasis marks, native hidden text with explicit visible resets, native character borders with 25 visible line styles plus `nil` and `none`, direct or theme color, width, spacing, shadow, and frame semantics, four independent native outline/shadow/emboss/imprint effects with conflict-safe authoring, and baseline position in one advanced font dialog, all 18 native DOCX underline values with direct or theme color identity, independent native single/double strikethrough with explicit resets, formatting revisions, clipboard, format painter, and undo/redo | Mature authoring with a broader long-tail style and typography catalog |
+| Text, paragraphs, lists, and styles | **Supported** — structured editing, independent native ASCII, high ANSI, East Asian, and complex-script font slots with direct/theme identity, independent Latin/East Asian/bidi proofing-language slots and explicit proofing inclusion/exclusion, native all-caps and small-caps effects, exact DOCX character scale plus signed spacing, half-point kerning thresholds, all five native East Asian emphasis marks, native hidden text with explicit visible resets, native character borders with 25 visible line styles plus `nil` and `none`, direct or theme color, width, spacing, shadow, and frame semantics, four independent native outline/shadow/emboss/imprint effects with conflict-safe authoring, and baseline position in one advanced font dialog, all 18 native DOCX underline values with direct or theme color identity, independent native single/double strikethrough with explicit resets, formatting revisions, clipboard, format painter, and undo/redo | Mature authoring with a broader long-tail style and typography catalog |
 | 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** — bookmarks, links, captions, cross-references, citations, notes, and common fields | TOC/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 |
@@ -127,7 +145,7 @@ baseline rather than one specific release.
 | Formatting and style rendering | **Partial** — native fonts, colors, borders, alignment, number formats, cell styles, all 17 native non-solid OOXML pattern fills, native linear/path XLSX gradients, and one Format Cells surface that authors none, solid, pattern, or gradient fills with exact geometry and 2–256 ordered stops; static date/time entry, contrast-safe font preview, native XLSX rich-text runs, selected-text font formatting, direct formula-bar/F2 insertion or deletion, and bounded authenticated formatted-HTML paste | Disjoint multi-edit rich-text authoring, broader themes, locale formats, and advanced style effects |
 | Ribbon and shortcuts | **Partial** — common Office-style Home/Data/View commands, grid-scoped shortcuts, and focused Font-dialog aliases | Larger command catalog and platform-specific accelerators |
 | Formulas and recalculation | **Partial** — dependency-aware calculation and common formula paths | Wider functions, arrays, volatile semantics, and calculation parity |
-| Tables, pivots, charts, and rules | **Partial** — native tables, pivots, charts, conditional formatting, and validation | Calculated columns, slicers, pivot charts, advanced rules, and analysis |
+| Tables, pivots, charts, and rules | **Partial** — native tables, pivots, charts, conditional formatting, and common validation rules with complete input/error-setting authoring | Calculated columns, slicers, pivot charts, custom/dependent validation rules, advanced analysis, and broader browser alert flows |
 | Large worksheets | **Supported with boundaries** — maximum-dimension sparse import/editing and viewport-bounded Canvas painting | Highly optimized native grid with hardware-dependent limits |
 | Files and printing | **Partial** — XLS/XLSX/ODS/CSV import, XLSX export, and PDF output | Broader round trips, external data, print fidelity, and legacy conversion |
 | External data, macros, and specialist analysis | **Gap** — active macros are never executed; bounded models are still needed for data connections and solver-like tools | Established data, macro/add-in, scenario, and optimization ecosystems |
@@ -216,6 +234,34 @@ is requested. The complete gap inventory and exit evidence live in the
   undoable action. Safe inline DOCX fields round-trip natively, while nested,
   incomplete, cross-paragraph, deleted, or instructionless structures stay
   text and produce an explicit compatibility warning.
+  Writer Table of Contents blocks reuse the same heading outline and live
+  Worker/WASM page resolver instead of maintaining parallel heading or page
+  state. Insert, customize, and explicit refresh each commit one TipTap
+  transaction and one Undo record. Semantic headings and native outline-level
+  paragraphs cover levels 1–9; included items without a native paragraph
+  identity receive one in the same transaction so hyperlinks survive
+  structural edits. Page-number visibility and alignment,
+  dot/dash/underline/no leaders, and at most 512 cached entries remain typed in
+  the DOM. DOCX export writes a native `w:sdt`/`TOC` content control and live
+  field with cached entries; import accepts the common `\\o`, `\\h`, `\\z`,
+  `\\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,
@@ -577,6 +623,34 @@ Protection ranges, passwordless editable ranges, and conditional formatting
 also remain compact and round-trip through native XLSX records without
 allocating every covered cell.
 
+### Complete Spreadsheet data-validation settings
+
+Data → Data Validation authors list, whole-number, decimal, date, and text-length
+rules across one or more selected ranges. The same dialog now owns the complete
+common input and error metadata: `allowBlank`, `showDropdownArrow`,
+`hintTitle`, `hintValue`, `prohibitInput`, `errorStyle`, `errorTitle`, and
+`errorMessage`. Titles are bounded to 32 Unicode code points, the input message
+to 255, and the error message to 225. Disabling a message keeps its text so a
+later re-enable does not discard the user's draft.
+
+The mounted grid reads compact rules without expanding blank cells, honors
+`allowBlank`, can hide the in-cell list arrow, shows the authored input title
+and message, and uses the authored error title and message when rejecting an
+invalid value. The current Fortune boundary still has one blocking browser
+alert path whenever error alerts are enabled. `stop`, `warning`, and
+`information` therefore round-trip as exact native file semantics, but the
+browser does not yet reproduce the separate warning/information confirmation
+branches of a desktop suite. Custom formulas and dependent lists also remain
+explicit gaps.
+
+XLSX import and export preserve `allowBlank`, `showErrorMessage`,
+`showInputMessage`, `errorStyle`, `errorTitle`, `error`, `promptTitle`, and
+`prompt`. The public `showDropdownArrow` name describes what users see, while
+SpreadsheetML stores the inverse in `showDropDown`. On the public Playground
+home page, choose **新建 → 数据验证** to inspect list, date, and priority
+examples with all three alert styles. This is a normal user-facing template,
+not an `?e2e=` fixture or a documentation-only example.
+
 Native XLSX pattern fills retain all 17 non-solid OOXML pattern identities plus
 their foreground and background RGB, theme, indexed, automatic, and tint color
 origins. Canvas draws them only for visible cells, behind text and below table
@@ -757,6 +831,44 @@ layout. Browser and PDF paint are bounded visual approximations; the OOXML
 semantics remain exact. The Playground's **字符边框** template exercises the
 complete authoring and one-step Undo path.
 
+Native Writer character shading retains one exact `w:shd` value rather than a
+flattened CSS fill. The typed model preserves every WordprocessingML pattern,
+direct or automatic foreground/background colors, independent theme channels
+with tint and shade, and explicit `nil`. Document defaults, paragraph and
+character styles, conditional table styles, body, page chrome, notes,
+formatting revisions, strict/transitional import, exact export, and reopen use
+the same resolver. Invalid or spoofed leaves fail closed and are diagnosed.
+
+The shared `Cmd/Ctrl+D` Advanced Font Settings dialog distinguishes mixed,
+Follow style, explicit no-shading, and editable pattern/color states; changes
+commit with Format Painter and one-step Undo semantics. The DOM stores bounded
+JSON in `data-office-run-shading`, while CSS projects patterns without changing
+line geometry, so eligible content stays on the Worker/WASM path. Native
+`w:highlight` remains independent and takes display precedence without
+clobbering shading. The Playground's **字符底纹** template demonstrates the
+complete flow.
+
+Native Writer proofing languages retain the three independent WordprocessingML
+`w:lang` slots: Latin `w:val`, East Asian `w:eastAsia`, and bidi `w:bidi`.
+Native `w:noProof` remains an independent three-state property: inherited,
+explicitly checked with `w:val="false"`, or excluded from proofing. The Review
+ribbon's **设置校对语言** dialog accepts bounded BCP 47 language tags, keeps
+untouched mixed slots unchanged, exposes Follow style for each slot, and applies
+the touched language and proofing-state fields through one transaction and one
+Undo record. The same contract is available while editing headers and footers.
+
+Document defaults, paragraph and character styles, body text, headers,
+footers, footnotes, endnotes, formatting revisions, strict/transitional DOCX
+import, exact export, and reopen share the closed model. Malformed, duplicated,
+misplaced, namespace-spoofed, nested, text-bearing, extra-attribute, invalid-tag,
+or invalid on/off input fails closed and appears in compatibility diagnostics.
+The DOM stores canonical JSON in `data-office-proofing-languages`, stores an
+explicit Boolean in `data-office-no-proof`, and projects the effective `lang`
+and `spellcheck` attributes without claiming a bundled dictionary or grammar
+service. Valid effective languages also reach the Worker/WASM text-layout run
+and RustyBuzz shaping buffer. The Playground's **校对语言** template demonstrates
+Latin, East Asian, bidi, explicitly checked, and excluded states.
+
 Supported native OMML equations now survive as bounded structured objects in
 the document body, headers, footers, footnotes, and endnotes. Inline and display
 math, Unicode runs with literal/normal-text semantics, math script/style,
@@ -1457,6 +1569,8 @@ 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/)
 - [A3S Office 0.27.0 documentation](https://a3s-lab.github.io/Office/docs/0.27.0/)

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

@@ -1,5 +1,5 @@
 import jszip from "jszip";
-import { serializeUtf8Xml, directChildren, xmlNamespacePrefix, parseXml, firstDescendant, decodeXmlBytes, directChild, descendants, 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: [
@@ -1251,6 +1438,164 @@ function hexFactor(value) {
 function isDocxThemeResolver(source) {
     return Boolean(source && 'colors' in source && source.colors instanceof Map && 'fonts' in source && source.fonts instanceof Map);
 }
+const LANGUAGE_ATTRIBUTES = new Map([
+    [
+        'val',
+        'latin'
+    ],
+    [
+        'eastAsia',
+        'eastAsia'
+    ],
+    [
+        'bidi',
+        'bidi'
+    ]
+]);
+function inspectDocxProofingLanguages(properties) {
+    if (!properties) return {
+        status: 'absent',
+        spoofedCount: 0
+    };
+    const matches = directChildren(properties, 'lang');
+    if (!matches.length) return {
+        status: 'absent',
+        spoofedCount: 0
+    };
+    const native = matches.filter((element)=>isWordElement(element));
+    const spoofedCount = matches.length - native.length;
+    if (1 !== matches.length || 1 !== native.length) return {
+        status: 'invalid',
+        spoofedCount
+    };
+    const element = native[0];
+    if (!element || element.childNodes.length) return {
+        status: 'invalid',
+        spoofedCount
+    };
+    const languages = {};
+    for (const attribute of Array.from(element.attributes)){
+        if (work_docx_proofing_isNamespaceDeclaration(attribute)) continue;
+        const name = wordAttributeLocalName(element, attribute);
+        const slot = name ? LANGUAGE_ATTRIBUTES.get(name) : void 0;
+        if (!slot) return {
+            status: 'invalid',
+            spoofedCount
+        };
+        const language = normalizeDocumentLanguageTag(attribute.value);
+        if (!language) return {
+            status: 'invalid',
+            spoofedCount
+        };
+        languages[slot] = language;
+    }
+    return Object.keys(languages).length ? {
+        status: 'valid',
+        value: languages,
+        spoofedCount
+    } : {
+        status: 'invalid',
+        spoofedCount
+    };
+}
+function inspectDocxNoProof(properties) {
+    if (!properties) return {
+        status: 'absent',
+        spoofedCount: 0
+    };
+    const matches = directChildren(properties, 'noProof');
+    if (!matches.length) return {
+        status: 'absent',
+        spoofedCount: 0
+    };
+    const native = matches.filter((element)=>isWordElement(element));
+    const spoofedCount = matches.length - native.length;
+    if (1 !== matches.length || 1 !== native.length) return {
+        status: 'invalid',
+        spoofedCount
+    };
+    const element = native[0];
+    if (!element || element.childNodes.length) return {
+        status: 'invalid',
+        spoofedCount
+    };
+    const attributes = Array.from(element.attributes).filter((attribute)=>!work_docx_proofing_isNamespaceDeclaration(attribute));
+    if (attributes.length > 1 || attributes.some((attribute)=>'val' !== wordAttributeLocalName(element, attribute))) return {
+        status: 'invalid',
+        spoofedCount
+    };
+    if (!attributes.length) return {
+        status: 'valid',
+        value: true,
+        spoofedCount
+    };
+    const value = onOffValue(attributes[0]?.value);
+    return void 0 === value ? {
+        status: 'invalid',
+        spoofedCount
+    } : {
+        status: 'valid',
+        value,
+        spoofedCount
+    };
+}
+function resolveDocxProofing(propertySources) {
+    let languages;
+    let noProof;
+    let invalidCount = 0;
+    let spoofedCount = 0;
+    for (const properties of propertySources){
+        const languageInspection = inspectDocxProofingLanguages(properties);
+        spoofedCount += languageInspection.spoofedCount;
+        if ('valid' === languageInspection.status) languages = {
+            ...languages,
+            ...languageInspection.value
+        };
+        else if ('invalid' === languageInspection.status) invalidCount += 1;
+        const noProofInspection = inspectDocxNoProof(properties);
+        spoofedCount += noProofInspection.spoofedCount;
+        if ('valid' === noProofInspection.status) noProof = noProofInspection.value;
+        else if ('invalid' === noProofInspection.status) invalidCount += 1;
+    }
+    return {
+        languages,
+        noProof,
+        invalidCount,
+        spoofedCount
+    };
+}
+function documentProofingLanguageDocxOptions(source) {
+    const languages = normalizeDocumentProofingLanguages(source);
+    if (!languages) return;
+    return {
+        ...languages.latin ? {
+            value: languages.latin
+        } : {},
+        ...languages.eastAsia ? {
+            eastAsia: languages.eastAsia
+        } : {},
+        ...languages.bidi ? {
+            bidirectional: languages.bidi
+        } : {}
+    };
+}
+function isWordElement(element) {
+    return DOCX_WORDPROCESSING_NAMESPACES.has(element.namespaceURI ?? '');
+}
+function work_docx_proofing_isNamespaceDeclaration(attribute) {
+    return 'xmlns' === attribute.name || 'xmlns' === attribute.prefix || 'http://www.w3.org/2000/xmlns/' === attribute.namespaceURI;
+}
+function wordAttributeLocalName(element, attribute) {
+    if (attribute.namespaceURI === element.namespaceURI) return attribute.localName;
+    const prefix = element.prefix ?? element.tagName.split(':')[0];
+    const lexicalPrefix = prefix ? `${prefix}:` : '';
+    return null === attribute.namespaceURI && lexicalPrefix && attribute.name.startsWith(lexicalPrefix) ? attribute.name.slice(lexicalPrefix.length) : null;
+}
+function onOffValue(source) {
+    const value = source?.trim().toLowerCase();
+    if ('1' === value || 'true' === value || 'on' === value) return true;
+    if ('0' === value || 'false' === value || 'off' === value) return false;
+}
 function paragraphAlignment(element, docx) {
     const alignment = element.style.textAlign;
     if ('center' === alignment) return docx.AlignmentType.CENTER;
@@ -1579,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, docxCharacterPositionHalfPointsFromProperties, docxCharacterPositionValue, docxCharacterScalePercentFromProperties, docxCharacterScaleValue, docxCharacterSpacingTwipsFromProperties, docxCharacterSpacingValue, docxEmphasisMarkRunOptions, docxKerningThresholdValue, docxThemeColor, docxThemeFont, domDirection, hasNonWhitespaceXmlText, inspectDocxEmphasisMark, inspectDocxKerningThresholdHalfPoints, mergeDocxIgnorableExtensions, mergeDocxIgnorableExtensionsAtPairs, paragraphAlignment, paragraphBidirectional, paragraphDirectionOptions, paragraphIndent, paragraphPaginationOptions, paragraphSpacingOptions, paragraphTabStops, parseBoundedDocxInteger, parseDocxColorSchemeMappingElement, parseDocxParagraphDefaultCollapsed, parseDocxTwipsMeasure, patchDocxBibliography, patchDocxExplicitZeroCharacterSpacing, patchDocxExplicitZeroKerningThresholds, patchDocxParagraphDefaultCollapsed, readDocxBibliography, resolveDocxEmphasisMark, resolveDocxKerningThresholdHalfPoints, 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 };