@a3s-lab/office 0.29.0 → 0.30.0

package/dist/internal/features/work/editors/document-command-catalog.d.ts

@@ -598,6 +598,24 @@ export declare const documentCommandCatalog: {
             readonly editor: readonly ["Mod-Shift-e"];
         };
     };
+    readonly tableOfContents: {
+        readonly id: "references.tableOfContents";
+        readonly label: "插入或自定义目录";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "references";
+            readonly group: "tableOfContents";
+        };
+    };
+    readonly refreshTableOfContents: {
+        readonly id: "references.refreshTableOfContents";
+        readonly label: "更新目录";
+        readonly location: {
+            readonly area: "ribbon";
+            readonly tab: "references";
+            readonly group: "tableOfContents";
+        };
+    };
     readonly refreshFields: {
         readonly id: "references.refreshFields";
         readonly label: "更新域";

package/dist/internal/features/work/editors/document-font-dialog-model.d.ts

@@ -2,6 +2,7 @@ import type { Editor } from '@tiptap/core';
 import { type WorkDocumentEmphasisMark } from '../work-document-emphasis';
 import { type DocumentFontDialogScriptFontPatch, type DocumentFontFamilySource } from './document-font-dialog-script-font-model';
 import { type DocumentFontDialogRunBorderDraft, type DocumentFontDialogRunBorderPatch, type DocumentFontDialogRunBorderSource } from './document-font-dialog-run-border-model';
+import { type DocumentFontDialogRunShadingDraft, type DocumentFontDialogRunShadingPatch, type DocumentFontDialogRunShadingSource } from './document-font-dialog-run-shading-model';
 export type { DocumentFontFamilySource } from './document-font-dialog-script-font-model';
 export type DocumentCharacterSpacingMode = 'condensed' | 'expanded' | 'mixed' | 'normal';
 export type DocumentCharacterPositionMode = 'lowered' | 'mixed' | 'normal' | 'raised';
@@ -49,6 +50,7 @@ export interface DocumentFontDialogSource {
         value: boolean | null;
     };
     runBorder: DocumentFontDialogRunBorderSource;
+    runShading: DocumentFontDialogRunShadingSource;
     latinFont: DocumentFontFamilySource;
     eastAsiaFont: DocumentFontFamilySource;
     complexScriptFont: DocumentFontFamilySource;
@@ -57,7 +59,7 @@ export interface DocumentFontDialogSource {
     previewText: string;
     selectedCharacters: number;
 }
-export interface DocumentFontDialogDraft extends DocumentFontDialogRunBorderDraft {
+export interface DocumentFontDialogDraft extends DocumentFontDialogRunBorderDraft, DocumentFontDialogRunShadingDraft {
     characterScaleMode: DocumentCharacterScaleMode;
     characterScalePercent: string;
     characterPositionMode: DocumentCharacterPositionMode;
@@ -76,7 +78,7 @@ export interface DocumentFontDialogDraft extends DocumentFontDialogRunBorderDraf
     eastAsiaFont: string;
     complexScriptFont: string;
 }
-export interface DocumentFontDialogPatch extends DocumentFontDialogScriptFontPatch, DocumentFontDialogRunBorderPatch {
+export interface DocumentFontDialogPatch extends DocumentFontDialogScriptFontPatch, DocumentFontDialogRunBorderPatch, DocumentFontDialogRunShadingPatch {
     characterScalePercent?: number;
     characterPositionHalfPoints?: number;
     characterSpacingTwips?: number;
@@ -101,6 +103,7 @@ export interface DocumentFontDialogTouched {
     legacyTextEmboss: boolean;
     legacyTextImprint: boolean;
     runBorder: boolean;
+    runShading: boolean;
     kerning: boolean;
     latinFont: boolean;
 }

package/dist/internal/features/work/editors/document-font-dialog-run-shading-model.d.ts

@@ -0,0 +1,23 @@
+import type { CSSProperties } from 'react';
+import { type DocumentRunShading, type DocumentRunShadingPattern } from '../work-document-run-shading';
+export type DocumentFontDialogRunShadingMode = 'inherit' | 'mixed' | 'none' | 'value';
+export interface DocumentFontDialogRunShadingSource {
+    mixed: boolean;
+    value: DocumentRunShading | null;
+}
+export interface DocumentFontDialogRunShadingDraft {
+    runShadingMode: DocumentFontDialogRunShadingMode;
+    runShadingPattern: Exclude<DocumentRunShadingPattern, 'nil'>;
+    runShadingColor: 'auto' | `#${string}`;
+    runShadingFill: 'auto' | `#${string}`;
+}
+export interface DocumentFontDialogRunShadingPatch {
+    runShading?: DocumentRunShading | null;
+}
+export declare function addDocumentFontDialogRunShadingValue(values: Map<string, DocumentRunShading | null>, source: unknown): void;
+export declare function selectedDocumentFontDialogRunShadingValue(values: ReadonlyMap<string, DocumentRunShading | null>): DocumentFontDialogRunShadingSource;
+export declare function createDocumentFontDialogRunShadingDraft(source: DocumentFontDialogRunShadingSource): DocumentFontDialogRunShadingDraft;
+export declare function documentFontDialogRunShadingDraftError(draft: DocumentFontDialogRunShadingDraft): string | null;
+export declare function documentFontDialogRunShadingPatch(source: DocumentFontDialogRunShadingSource, draft: DocumentFontDialogRunShadingDraft, touched: boolean): DocumentFontDialogRunShadingPatch;
+export declare function documentFontDialogRunShadingFromDraft(source: DocumentFontDialogRunShadingSource, draft: DocumentFontDialogRunShadingDraft): DocumentRunShading | null;
+export declare function documentFontDialogRunShadingPreviewStyle(source: DocumentFontDialogRunShadingSource, draft: DocumentFontDialogRunShadingDraft): CSSProperties;

package/dist/internal/features/work/editors/document-font-dialog-run-shading-section.d.ts

@@ -0,0 +1,8 @@
+import type { DocumentFontDialogRunShadingDraft, DocumentFontDialogRunShadingSource } from './document-font-dialog-run-shading-model';
+export declare function DocumentFontDialogRunShadingSection({ source, draft, touched, onDraftChange, onTouched, }: {
+    source: DocumentFontDialogRunShadingSource;
+    draft: DocumentFontDialogRunShadingDraft;
+    touched: boolean;
+    onDraftChange: (patch: Partial<DocumentFontDialogRunShadingDraft>) => void;
+    onTouched: () => void;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/document-page-chrome-ribbon.d.ts

@@ -1,11 +1,12 @@
 import type { Editor } from '@tiptap/core';
 export type DocumentPageChromeEditingPart = 'footer' | 'header';
-export declare function DocumentPageChromeRibbon({ editor, editingPart, showPageNumber, onEditingPartChange, onTogglePageNumber, onOpenFontDialog, onClose, }: {
+export declare function DocumentPageChromeRibbon({ editor, editingPart, showPageNumber, onEditingPartChange, onTogglePageNumber, onOpenFontDialog, onOpenProofingDialog, onClose, }: {
     editor: Editor;
     editingPart: DocumentPageChromeEditingPart;
     showPageNumber: boolean;
     onEditingPartChange: (part: DocumentPageChromeEditingPart) => void;
     onTogglePageNumber: () => void;
     onOpenFontDialog?: () => void;
+    onOpenProofingDialog?: () => void;
     onClose: () => void;
 }): import("react").JSX.Element;

package/dist/internal/features/work/editors/document-proofing-dialog-model.d.ts

@@ -0,0 +1,22 @@
+import type { Editor } from '@tiptap/core';
+import { type WorkDocumentProofingLanguageSlot } from '../work-document-proofing';
+export interface DocumentProofingDialogValue<T> {
+    mixed: boolean;
+    value: T | null;
+}
+export interface DocumentProofingDialogSource {
+    latin: DocumentProofingDialogValue<string>;
+    eastAsia: DocumentProofingDialogValue<string>;
+    bidi: DocumentProofingDialogValue<string>;
+    noProof: DocumentProofingDialogValue<boolean>;
+    selectedCharacters: number;
+}
+export interface DocumentProofingDialogPatch {
+    languages?: Partial<Record<WorkDocumentProofingLanguageSlot, string | null>>;
+    noProof?: boolean | null;
+}
+export declare function documentProofingDialogSource(editor: Editor): DocumentProofingDialogSource;
+export declare function applyDocumentProofingDialogPatch(editor: Editor, selection: {
+    from: number;
+    to: number;
+}, patch: DocumentProofingDialogPatch): boolean;

package/dist/internal/features/work/editors/document-proofing-dialog.d.ts

@@ -0,0 +1,7 @@
+import type { DocumentProofingDialogPatch, DocumentProofingDialogSource } from './document-proofing-dialog-model';
+export declare function DocumentProofingDialog({ source, restoreFocusTarget, onApply, onClose, }: {
+    source: DocumentProofingDialogSource;
+    restoreFocusTarget: () => HTMLElement | null;
+    onApply: (patch: DocumentProofingDialogPatch) => boolean;
+    onClose: () => void;
+}): import("react").JSX.Element;

package/dist/internal/features/work/editors/document-table-of-contents-dialog.d.ts

@@ -0,0 +1,10 @@
+import type { WorkDocumentTableOfContentsOptions } from '../work-document-table-of-contents';
+export interface DocumentTableOfContentsDialogProps {
+    editing: boolean;
+    options: WorkDocumentTableOfContentsOptions;
+    restoreFocusTarget: () => HTMLElement | null;
+    onCancel: () => void;
+    onOptionsChange: (options: WorkDocumentTableOfContentsOptions) => void;
+    onSubmit: () => void;
+}
+export declare function DocumentTableOfContentsDialog({ editing, options, restoreFocusTarget, onCancel, onOptionsChange, onSubmit, }: DocumentTableOfContentsDialogProps): import("react").JSX.Element;

package/dist/internal/features/work/editors/document-toolbar.d.ts

@@ -57,11 +57,13 @@ interface DocumentToolbarProps {
     onInsertNote: (kind: WorkDocumentNoteKind) => void;
     onInsertCaption: (kind: WorkDocumentCaptionKind) => void;
     onInsertCrossReference: () => void;
+    onOpenTableOfContents: () => void;
     citationsOpen: boolean;
     citationSourceCount: number;
     onToggleCitations: () => void;
     onInsertField: (kind: WorkDocumentFieldKind) => void;
     onRefreshFields: () => void;
+    onRefreshTableOfContents: () => void;
     canInsertComment: boolean;
     onInsertComment: () => void;
     commentsOpen: boolean;
@@ -79,5 +81,5 @@ interface DocumentToolbarProps {
     onOpenWordCount: () => void;
     onOpenFindReplace: (mode: DocumentFindReplaceMode) => void;
 }
-export declare function DocumentToolbar({ editor, defaultRibbonCollapsed, reviewOnly, suggestionOnly, history, layoutOpen, layout, layoutFonts, navigationOpen, pageColor, showPageNumbers, showHiddenText, showRulers, spellcheckEnabled, viewMode, zoom, pageChromeEditor, pageChromeEditingPart, pageChromeShowPageNumber, onRequestImage, onPageChromeEditingPartChange, onClosePageChrome, onTogglePageChromePageNumber, onToggleLayout, onLayoutChange, onOpenLayout, onToggleNavigation, onTogglePageNumbers, onToggleHiddenText, onToggleRulers, onPageColorChange, onToggleSpellcheck, onViewModeChange, onZoomChange, onZoomFit, onInsertSection, onInsertNote, onInsertCaption, onInsertCrossReference, citationsOpen, citationSourceCount, onToggleCitations, onInsertField, onRefreshFields, canInsertComment, onInsertComment, commentsOpen, commentCount, onToggleComments, trackChanges, changesOpen, changeCount, findReplaceMode, fileActions, onRibbonTabChange, onToggleTrackChanges, onToggleChanges, onDecideChange, onOpenWordCount, onOpenFindReplace, }: DocumentToolbarProps): import("react").JSX.Element;
+export declare function DocumentToolbar({ editor, defaultRibbonCollapsed, reviewOnly, suggestionOnly, history, layoutOpen, layout, layoutFonts, navigationOpen, pageColor, showPageNumbers, showHiddenText, showRulers, spellcheckEnabled, viewMode, zoom, pageChromeEditor, pageChromeEditingPart, pageChromeShowPageNumber, onRequestImage, onPageChromeEditingPartChange, onClosePageChrome, onTogglePageChromePageNumber, onToggleLayout, onLayoutChange, onOpenLayout, onToggleNavigation, onTogglePageNumbers, onToggleHiddenText, onToggleRulers, onPageColorChange, onToggleSpellcheck, onViewModeChange, onZoomChange, onZoomFit, onInsertSection, onInsertNote, onInsertCaption, onInsertCrossReference, onOpenTableOfContents, citationsOpen, citationSourceCount, onToggleCitations, onInsertField, onRefreshFields, onRefreshTableOfContents, canInsertComment, onInsertComment, commentsOpen, commentCount, onToggleComments, trackChanges, changesOpen, changeCount, findReplaceMode, fileActions, onRibbonTabChange, onToggleTrackChanges, onToggleChanges, onDecideChange, onOpenWordCount, onOpenFindReplace, }: DocumentToolbarProps): import("react").JSX.Element;
 export {};

package/dist/internal/features/work/editors/spreadsheet-data-validation.d.ts

@@ -1,12 +1,18 @@
-import type { WorkSpreadsheetContent, WorkSpreadsheetDataValidationItem, WorkSpreadsheetSheet } from '../work-types';
+import type { WorkSpreadsheetContent, WorkSpreadsheetDataValidationErrorStyle, WorkSpreadsheetDataValidationItem, WorkSpreadsheetSheet } from '../work-types';
 import { type SpreadsheetCellRange } from './spreadsheet-cell-range';
 export declare const MAX_SPREADSHEET_DATA_VALIDATION_CELLS = 10000;
 export type SpreadsheetDataValidationType = 'date' | 'dropdown' | 'number' | 'number_integer' | 'text_length';
 export type SpreadsheetDataValidationOperator = 'between' | 'equal' | 'greaterOrEqualTo' | 'lessThan' | 'lessThanOrEqualTo' | 'moreThanThe' | 'noEarlierThan' | 'noLaterThan' | 'notBetween' | 'notEqualTo' | 'earlierThan' | 'laterThan';
 export interface SpreadsheetDataValidationDialogValue {
+    allowBlank: boolean;
+    errorMessage: string;
+    errorStyle: WorkSpreadsheetDataValidationErrorStyle;
+    errorTitle: string;
     hintShow: boolean;
+    hintTitle: string;
     hintValue: string;
     prohibitInput: boolean;
+    showDropdownArrow: boolean;
     type: SpreadsheetDataValidationType;
     type2: SpreadsheetDataValidationOperator | '';
     value1: string;

package/dist/internal/features/work/editors/use-document-insert-commands.d.ts

@@ -11,7 +11,9 @@ export interface DocumentInsertCommands {
     insertField: (kind: WorkDocumentFieldKind) => void;
     insertImage: (file: File) => Promise<void>;
     insertNote: (kind: WorkDocumentNoteKind) => boolean;
+    openTableOfContents: () => void;
     refreshFields: () => boolean;
+    refreshTableOfContents: () => boolean;
 }
 export declare function useDocumentInsertCommands({ contentRef, editor, resolveFieldContext, }: {
     contentRef: MutableRefObject<WorkDocumentContent>;

package/dist/internal/features/work/work-document-character-formatting.d.ts

@@ -2,6 +2,8 @@ import { Extension, type Editor } from '@tiptap/core';
 import { type WorkDocumentEmphasisMark } from './work-document-emphasis';
 import { type WorkDocumentTextCase } from './work-document-text-case';
 import { type DocumentRunBorder } from './work-document-run-border';
+import { type DocumentRunShading } from './work-document-run-shading';
+import { type WorkDocumentProofingLanguages } from './work-document-proofing';
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
         documentCharacterFormatting: {
@@ -22,6 +24,12 @@ declare module '@tiptap/core' {
             setDocumentRunBorder: (border: DocumentRunBorder) => ReturnType;
             unsetDocumentRunBorder: () => ReturnType;
             toggleDocumentRunBorder: () => ReturnType;
+            setDocumentRunShading: (shading: DocumentRunShading) => ReturnType;
+            unsetDocumentRunShading: () => ReturnType;
+            setDocumentProofingLanguages: (languages: WorkDocumentProofingLanguages) => ReturnType;
+            unsetDocumentProofingLanguages: () => ReturnType;
+            setDocumentNoProof: (noProof: boolean) => ReturnType;
+            unsetDocumentNoProof: () => ReturnType;
         };
     }
 }

package/dist/internal/features/work/work-document-format-changes.d.ts

@@ -5,6 +5,8 @@ import { type WorkDocumentTextCase } from './work-document-text-case';
 import { type WorkDocumentUnderlineFormatting } from './work-document-underline';
 import { type WorkDocumentStrikeFormatting } from './work-document-strike';
 import { type WorkDocumentScriptFontSlot, type WorkDocumentScriptFonts } from './work-document-script-fonts';
+import { type WorkDocumentHighlight } from './work-document-highlight';
+import { type WorkDocumentProofingLanguages } from './work-document-proofing';
 export declare const DOCUMENT_CHARACTER_FORMAT_MARKS: readonly ["bold", "italic", "underline", "strike", "subscript", "superscript", "textStyle", "highlight"];
 export type DocumentCharacterFormatMarkName = (typeof DOCUMENT_CHARACTER_FORMAT_MARKS)[number];
 export interface DocumentCharacterFormatMark {
@@ -36,6 +38,9 @@ export declare function importedDocumentCharacterFormatting(formatting: {
     legacyTextEmboss?: boolean;
     legacyTextImprint?: boolean;
     runBorder?: string;
+    runShading?: string;
+    proofingLanguages?: WorkDocumentProofingLanguages;
+    noProof?: boolean;
     wordLineHeightFactor?: number;
     wordSnapToGrid?: boolean;
     fontSize?: number;
@@ -43,5 +48,6 @@ export declare function importedDocumentCharacterFormatting(formatting: {
     backgroundColor?: string;
     themeColor?: string;
     themeFill?: string;
+    highlight?: WorkDocumentHighlight;
     textCase?: WorkDocumentTextCase;
 }): string;

package/dist/internal/features/work/work-document-highlight.d.ts

@@ -0,0 +1,9 @@
+export declare const DOCUMENT_HIGHLIGHT_ATTRIBUTE = "data-office-highlight";
+export type WorkDocumentHighlight = 'black' | 'blue' | 'cyan' | 'darkBlue' | 'darkCyan' | 'darkGray' | 'darkGreen' | 'darkMagenta' | 'darkRed' | 'darkYellow' | 'green' | 'lightGray' | 'magenta' | 'none' | 'red' | 'white' | 'yellow';
+export declare const DOCUMENT_HIGHLIGHT_VALUES: Set<WorkDocumentHighlight>;
+export declare function normalizeDocumentHighlight(source: unknown): WorkDocumentHighlight | null;
+export declare function documentHighlightFromDocxValue(source: unknown): WorkDocumentHighlight | null;
+export declare function documentHighlightCssColor(source: unknown): string | null;
+export declare function documentHighlightForCssColor(source: unknown): WorkDocumentHighlight | null;
+export declare function documentHighlightFromElement(element: HTMLElement): WorkDocumentHighlight | null;
+export declare function documentHighlightDomAttributes(source: unknown): Record<string, string>;

package/dist/internal/features/work/work-document-outline.d.ts

@@ -10,5 +10,6 @@ export interface WorkDocumentOutlineItem {
     hasChildren: boolean;
 }
 export declare function collectWorkDocumentOutline(document: ProseMirrorNode): WorkDocumentOutlineItem[];
+export declare function workDocumentOutlineLevel(node: ProseMirrorNode): number | null;
 export declare function currentWorkDocumentOutlineItem(items: readonly WorkDocumentOutlineItem[], position: number): WorkDocumentOutlineItem | null;
 export declare function visibleWorkDocumentOutlineItems(items: readonly WorkDocumentOutlineItem[], collapsedIds: ReadonlySet<string>, rawQuery: string): WorkDocumentOutlineItem[];

package/dist/internal/features/work/work-document-paragraph-shading.d.ts

@@ -16,3 +16,9 @@ export declare function parseDocumentParagraphShading(source: unknown): Document
 export declare function serializeDocumentParagraphShading(source: unknown): string | undefined;
 export declare function parseDocumentParagraphShadingElement(element: HTMLElement): DocumentParagraphShading | null;
 export declare function documentParagraphShadingDomAttributes(source: unknown): Record<string, string>;
+export declare function documentParagraphShadingPresentation(shading: DocumentParagraphShading): {
+    backgroundColor: string;
+    backgroundImage?: string;
+    backgroundSize?: string;
+};
+export declare function paragraphShadingBackgroundUsesForeground(shading: DocumentParagraphShading): boolean;

package/dist/internal/features/work/work-document-proofing.d.ts

@@ -0,0 +1,19 @@
+import { type WorkDocumentScriptFontSlot } from './work-document-script-fonts';
+export declare const DOCUMENT_PROOFING_LANGUAGES_ATTRIBUTE = "data-office-proofing-languages";
+export declare const DOCUMENT_NO_PROOF_ATTRIBUTE = "data-office-no-proof";
+export interface WorkDocumentProofingLanguages {
+    latin?: string;
+    eastAsia?: string;
+    bidi?: string;
+}
+export type WorkDocumentProofingLanguageSlot = keyof WorkDocumentProofingLanguages;
+export declare function normalizeDocumentLanguageTag(source: unknown): string | null;
+export declare function normalizeDocumentProofingLanguages(source: unknown): WorkDocumentProofingLanguages | null;
+export declare function serializeDocumentProofingLanguages(source: unknown): string | undefined;
+export declare function parseDocumentProofingLanguages(source: unknown): WorkDocumentProofingLanguages | null;
+export declare function normalizeDocumentNoProof(source: unknown): boolean | null;
+export declare function documentProofingLanguagesFromElement(element: HTMLElement): WorkDocumentProofingLanguages | null;
+export declare function documentNoProofFromElement(element: HTMLElement): boolean | null;
+export declare function documentProofingLanguageForScript(source: unknown, slot?: WorkDocumentScriptFontSlot | null): string | undefined;
+export declare function documentProofingDomAttributes(languagesSource: unknown, noProofSource?: unknown, slot?: WorkDocumentScriptFontSlot | null): Record<string, string>;
+export declare function patchDocumentProofingLanguages(source: unknown, patch: Partial<Record<WorkDocumentProofingLanguageSlot, string | null>>): WorkDocumentProofingLanguages | null;

package/dist/internal/features/work/work-document-run-shading.d.ts

@@ -0,0 +1,12 @@
+import { type DocumentParagraphShading, type DocumentParagraphShadingColor, type DocumentParagraphShadingPattern } from './work-document-paragraph-shading';
+export declare const DOCUMENT_RUN_SHADING_ATTRIBUTE = "data-office-run-shading";
+export type DocumentRunShading = DocumentParagraphShading;
+export type DocumentRunShadingColor = DocumentParagraphShadingColor;
+export type DocumentRunShadingPattern = DocumentParagraphShadingPattern;
+export declare const DOCUMENT_RUN_SHADING_PATTERNS: Set<DocumentParagraphShadingPattern>;
+export declare function normalizeDocumentRunShading(source: unknown): DocumentRunShading | null;
+export declare function parseDocumentRunShading(source: unknown): DocumentRunShading | null;
+export declare function serializeDocumentRunShading(source: unknown): string | undefined;
+export declare function parseDocumentRunShadingElement(element: HTMLElement): DocumentRunShading | null;
+export declare function documentRunShadingDomAttributes(source: unknown): Record<string, string>;
+export declare function documentRunShadingIsVisible(source: unknown): boolean;

package/dist/internal/features/work/work-document-table-of-contents-node.d.ts

@@ -0,0 +1,18 @@
+import { Node, type CommandProps } from '@tiptap/core';
+import { type WorkDocumentTableOfContentsBuildOptions, type WorkDocumentTableOfContentsOptions } from './work-document-table-of-contents';
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        documentTableOfContents: {
+            insertDocumentTableOfContents: (options?: WorkDocumentTableOfContentsOptions, buildOptions?: WorkDocumentTableOfContentsBuildOptions) => ReturnType;
+            updateDocumentTableOfContents: (options: WorkDocumentTableOfContentsOptions, buildOptions?: WorkDocumentTableOfContentsBuildOptions) => ReturnType;
+            refreshDocumentTablesOfContents: (buildOptions?: WorkDocumentTableOfContentsBuildOptions) => ReturnType;
+        };
+    }
+}
+export declare const DocumentTableOfContents: Node<any, any>;
+export declare function selectedDocumentTableOfContentsOptions(editor: {
+    state: CommandProps['state'];
+}): WorkDocumentTableOfContentsOptions | null;
+export declare function documentHasTableOfContents(editor: {
+    state: CommandProps['state'];
+}): boolean;

package/dist/internal/features/work/work-document-table-of-contents.d.ts

@@ -0,0 +1,51 @@
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import type { WorkDocumentFieldContextResolver } from './work-document-fields';
+export type WorkDocumentTableOfContentsLeader = 'dot' | 'dash' | 'underline' | 'none';
+export interface WorkDocumentTableOfContentsOptions {
+    minLevel: number;
+    maxLevel: number;
+    hyperlinks: boolean;
+    showPageNumbers: boolean;
+    rightAlignPageNumbers: boolean;
+    leader: WorkDocumentTableOfContentsLeader;
+}
+export interface WorkDocumentTableOfContentsEntry {
+    targetId: string;
+    title: string;
+    level: number;
+    pageNumber: number;
+}
+export interface WorkDocumentTableOfContentsValue {
+    id: string;
+    options: WorkDocumentTableOfContentsOptions;
+    entries: WorkDocumentTableOfContentsEntry[];
+    truncated: boolean;
+}
+export interface WorkDocumentTableOfContentsBuildOptions {
+    resolveContext?: WorkDocumentFieldContextResolver;
+}
+export type WorkDocumentTableOfContentsInstructionResult = {
+    supported: true;
+    options: WorkDocumentTableOfContentsOptions;
+} | {
+    supported: false;
+    reason: 'not-table-of-contents' | 'invalid-instruction' | 'invalid-level-range' | 'unsupported-switch' | 'unsupported-page-range' | 'unsupported-separator';
+};
+export declare const DEFAULT_DOCUMENT_TABLE_OF_CONTENTS_OPTIONS: WorkDocumentTableOfContentsOptions;
+export declare const MAX_DOCUMENT_TABLE_OF_CONTENTS_ENTRIES = 512;
+export declare function normalizeDocumentTableOfContentsOptions(source: Partial<WorkDocumentTableOfContentsOptions> | null | undefined): WorkDocumentTableOfContentsOptions;
+export declare function buildDocumentTableOfContentsEntries(document: ProseMirrorNode, options: WorkDocumentTableOfContentsOptions, buildOptions?: WorkDocumentTableOfContentsBuildOptions): {
+    entries: WorkDocumentTableOfContentsEntry[];
+    truncated: boolean;
+};
+export declare function documentTableOfContentsHtml(source: Omit<WorkDocumentTableOfContentsValue, 'truncated'> & {
+    truncated?: boolean;
+}): string;
+export declare function normalizeDocumentTableOfContentsHtml(source: string): string;
+export declare function documentTableOfContentsValueFromElement(element: HTMLElement, index?: number): WorkDocumentTableOfContentsValue;
+export declare function parseDocumentTableOfContentsInstruction(instruction: string): WorkDocumentTableOfContentsInstructionResult;
+export declare function documentTableOfContentsInstruction(source: WorkDocumentTableOfContentsOptions): string;
+export declare function tableOfContentsLeader(value: unknown): WorkDocumentTableOfContentsLeader | null;
+export declare function normalizeDocumentTableOfContentsValue(source: Omit<WorkDocumentTableOfContentsValue, 'truncated'> & {
+    truncated?: boolean;
+}): WorkDocumentTableOfContentsValue;

package/dist/internal/features/work/work-document-word-line-metrics.d.ts

@@ -14,6 +14,9 @@ declare module '@tiptap/extension-text-style' {
         legacyTextEmboss?: boolean | null;
         legacyTextImprint?: boolean | null;
         runBorder?: string | null;
+        runShading?: string | null;
+        proofingLanguages?: string | null;
+        noProof?: boolean | null;
         kerningThresholdHalfPoints?: number | null;
         scriptFonts?: string | null;
         scriptFontSlot?: WorkDocumentScriptFontSlot | null;

package/dist/internal/features/work/work-docx-field-instructions.d.ts

@@ -12,5 +12,5 @@ export interface DocxFieldOccurrence {
 export declare function docxFieldInstructions(root: ParentNode): string[];
 export declare function docxFieldOccurrences(root: ParentNode): DocxFieldOccurrence[];
 export declare function docxFieldOccurrenceIsInlineEditable(field: DocxFieldOccurrence): boolean;
-export declare function hasInvalidDocxFieldStructure(root: ParentNode): boolean;
+export declare function hasInvalidDocxFieldStructure(root: ParentNode, ignore?: (field: DocxFieldOccurrence) => boolean): boolean;
 export declare function docxFieldResultText(field: DocxFieldOccurrence): string;

package/dist/internal/features/work/work-docx-import.d.ts

@@ -5,6 +5,7 @@ import { type ImportedDocxCitationMarkers } from './work-docx-citation-import';
 import { type ImportedDocxCommentMarkers } from './work-docx-comment-import';
 import { type ImportedDocxEquationMarkers } from './work-docx-equation-import';
 import { type ImportedDocxFieldMarkers } from './work-docx-field-import';
+import { type ImportedDocxTableOfContentsMarkers } from './work-docx-table-of-contents-import';
 import { type ImportedDocxImageLayoutMarkers } from './work-docx-image-layout-import';
 import { type ImportedDocxListMarkers } from './work-docx-list-import';
 import { type ImportedDocxParagraphAlignmentMarkers } from './work-docx-paragraph-alignment-import';
@@ -36,6 +37,7 @@ export interface PreparedDocxImport {
     changeMarkers: ImportedDocxChangeMarkers;
     commentMarkers: ImportedDocxCommentMarkers;
     fieldMarkers: ImportedDocxFieldMarkers;
+    tableOfContentsMarkers: ImportedDocxTableOfContentsMarkers;
     equationMarkers: ImportedDocxEquationMarkers;
     citationMarkers: ImportedDocxCitationMarkers;
     listMarkers: ImportedDocxListMarkers;
@@ -58,6 +60,6 @@ export interface PreparedDocxImport {
     trackChanges: boolean;
 }
 export declare function prepareDocxImport(buffer: ArrayBuffer, sourcePackage?: OoxmlPackage): Promise<PreparedDocxImport>;
-export declare function applyDocxSectionsToHtml(html: string, sections: PreparedDocxImport['sections'], captionMarkers?: ImportedDocxCaptionMarkers, bookmarkMarkers?: ImportedDocxBookmarkMarkers, changeMarkers?: ImportedDocxChangeMarkers, commentMarkers?: ImportedDocxCommentMarkers, fieldMarkers?: ImportedDocxFieldMarkers, equationMarkers?: ImportedDocxEquationMarkers, citationMarkers?: ImportedDocxCitationMarkers, listMarkers?: ImportedDocxListMarkers, imageLayoutMarkers?: ImportedDocxImageLayoutMarkers, paragraphIdentityMarkers?: ImportedDocxParagraphIdentityMarkers, paragraphFormattingChangeMarkers?: ImportedDocxParagraphFormattingChangeMarkers, paragraphAlignmentMarkers?: ImportedDocxParagraphAlignmentMarkers, runFormattingMarkers?: ImportedDocxRunFormattingMarkers, paragraphDirectionMarkers?: ImportedDocxParagraphDirectionMarkers, paragraphIndentMarkers?: ImportedDocxParagraphIndentMarkers, paragraphSpacingMarkers?: ImportedDocxParagraphSpacingMarkers, paragraphBorderMarkers?: ImportedDocxParagraphBorderMarkers, paragraphShadingMarkers?: ImportedDocxParagraphShadingMarkers, paragraphPaginationMarkers?: ImportedDocxParagraphPaginationMarkers, bibliography?: WorkDocumentContent['bibliography'], tabStopMarkers?: ImportedDocxParagraphTabStopMarkers, tableCellMarkers?: ImportedDocxTableCellMarkers, tableRowMarkers?: ImportedDocxTableRowMarkers, tableSizingMarkers?: ImportedDocxTableSizingMarkers): string;
+export declare function applyDocxSectionsToHtml(html: string, sections: PreparedDocxImport['sections'], captionMarkers?: ImportedDocxCaptionMarkers, bookmarkMarkers?: ImportedDocxBookmarkMarkers, changeMarkers?: ImportedDocxChangeMarkers, commentMarkers?: ImportedDocxCommentMarkers, fieldMarkers?: ImportedDocxFieldMarkers, tableOfContentsMarkers?: ImportedDocxTableOfContentsMarkers, equationMarkers?: ImportedDocxEquationMarkers, citationMarkers?: ImportedDocxCitationMarkers, listMarkers?: ImportedDocxListMarkers, imageLayoutMarkers?: ImportedDocxImageLayoutMarkers, paragraphIdentityMarkers?: ImportedDocxParagraphIdentityMarkers, paragraphFormattingChangeMarkers?: ImportedDocxParagraphFormattingChangeMarkers, paragraphAlignmentMarkers?: ImportedDocxParagraphAlignmentMarkers, runFormattingMarkers?: ImportedDocxRunFormattingMarkers, paragraphDirectionMarkers?: ImportedDocxParagraphDirectionMarkers, paragraphIndentMarkers?: ImportedDocxParagraphIndentMarkers, paragraphSpacingMarkers?: ImportedDocxParagraphSpacingMarkers, paragraphBorderMarkers?: ImportedDocxParagraphBorderMarkers, paragraphShadingMarkers?: ImportedDocxParagraphShadingMarkers, paragraphPaginationMarkers?: ImportedDocxParagraphPaginationMarkers, bibliography?: WorkDocumentContent['bibliography'], tabStopMarkers?: ImportedDocxParagraphTabStopMarkers, tableCellMarkers?: ImportedDocxTableCellMarkers, tableRowMarkers?: ImportedDocxTableRowMarkers, tableSizingMarkers?: ImportedDocxTableSizingMarkers): string;
 export declare function readDocxLayout(buffer: ArrayBuffer): Promise<ImportedDocumentLayout>;
 export {};

package/dist/internal/features/work/work-docx-proofing-diagnostics.d.ts

@@ -0,0 +1,3 @@
+import { type OoxmlPackage } from './work-ooxml-package';
+import type { WorkCompatibilityIssue } from './work-types';
+export declare function diagnoseDocxProofing(archive: OoxmlPackage, document: Document): Promise<WorkCompatibilityIssue[]>;

package/dist/internal/features/work/work-docx-proofing.d.ts

@@ -0,0 +1,38 @@
+import { type WorkDocumentProofingLanguages } from './work-document-proofing';
+export interface DocxProofingLanguageOptions {
+    value?: string;
+    eastAsia?: string;
+    bidirectional?: string;
+}
+export type DocxProofingLanguagesInspection = {
+    status: 'absent';
+    spoofedCount: number;
+} | {
+    status: 'invalid';
+    spoofedCount: number;
+} | {
+    status: 'valid';
+    value: WorkDocumentProofingLanguages;
+    spoofedCount: number;
+};
+export type DocxNoProofInspection = {
+    status: 'absent';
+    spoofedCount: number;
+} | {
+    status: 'invalid';
+    spoofedCount: number;
+} | {
+    status: 'valid';
+    value: boolean;
+    spoofedCount: number;
+};
+export interface ResolvedDocxProofing {
+    languages: WorkDocumentProofingLanguages | undefined;
+    noProof: boolean | undefined;
+    invalidCount: number;
+    spoofedCount: number;
+}
+export declare function inspectDocxProofingLanguages(properties: Element | null | undefined): DocxProofingLanguagesInspection;
+export declare function inspectDocxNoProof(properties: Element | null | undefined): DocxNoProofInspection;
+export declare function resolveDocxProofing(propertySources: readonly Element[]): ResolvedDocxProofing;
+export declare function documentProofingLanguageDocxOptions(source: unknown): DocxProofingLanguageOptions | undefined;

package/dist/internal/features/work/work-docx-run-formatting-import.d.ts

@@ -8,6 +8,9 @@ import { type WorkDocumentUnderlineFormatting } from './work-document-underline'
 import { type WorkDocumentStrikeFormatting } from './work-document-strike';
 import { type WorkDocumentScriptFontSlot, type WorkDocumentScriptFonts } from './work-document-script-fonts';
 import { type DocumentRunBorder } from './work-document-run-border';
+import { type DocumentRunShading } from './work-document-run-shading';
+import { type WorkDocumentHighlight } from './work-document-highlight';
+import { type WorkDocumentProofingLanguages } from './work-document-proofing';
 export interface ImportedDocxRunFormatting {
     bold?: boolean;
     italic?: boolean;
@@ -33,10 +36,14 @@ export interface ImportedDocxRunFormatting {
     fontSize?: number;
     color?: string;
     backgroundColor?: string;
+    highlight?: WorkDocumentHighlight;
     themeColor?: DocxThemeColorReference;
     themeFill?: DocxThemeColorReference;
     textCase?: WorkDocumentTextCase;
     runBorder?: DocumentRunBorder;
+    runShading?: DocumentRunShading;
+    proofingLanguages?: WorkDocumentProofingLanguages;
+    noProof?: boolean;
 }
 export interface ImportedDocxRunFormattingMarker {
     startMarker: string;

package/dist/internal/features/work/work-docx-run-shading-diagnostics.d.ts

@@ -0,0 +1,3 @@
+import { type OoxmlPackage } from './work-ooxml-package';
+import type { WorkCompatibilityIssue } from './work-types';
+export declare function diagnoseDocxRunShading(archive: OoxmlPackage, document: Document): Promise<WorkCompatibilityIssue[]>;

package/dist/internal/features/work/work-docx-run-shading-export.d.ts

@@ -0,0 +1,17 @@
+import type { IRunOptions } from 'docx';
+import { type DocumentRunShading } from './work-document-run-shading';
+export interface DocxRunShadingPatch {
+    marker: string;
+    shading: DocumentRunShading;
+}
+export declare class DocxRunShadingPatchCollector {
+    readonly patches: DocxRunShadingPatch[];
+    private nextMarker;
+    private readonly usedColors;
+    constructor(sourceHtml: string);
+    marker(source: unknown): string | null;
+    hasMarker(value: string | null | undefined): value is string;
+}
+export declare function documentRunShadingDocxOptions(source: unknown, collector: DocxRunShadingPatchCollector): Pick<IRunOptions, 'shading'>;
+export declare function patchDocxRunShading(buffer: ArrayBuffer, patches: readonly DocxRunShadingPatch[]): Promise<ArrayBuffer>;
+export declare function setDocxRunShadingAttributes(document: Document, element: Element, source: unknown): boolean;

package/dist/internal/features/work/work-docx-run-shading.d.ts

@@ -0,0 +1,20 @@
+import type { DocumentRunShading } from './work-document-run-shading';
+import { type DocxThemeSource } from './work-docx-theme';
+export type DocxRunShadingInspection = {
+    status: 'absent';
+    spoofedCount: number;
+} | {
+    status: 'invalid';
+    spoofedCount: number;
+} | {
+    status: 'valid';
+    value: DocumentRunShading;
+    spoofedCount: number;
+};
+export interface ResolvedDocxRunShading {
+    shading: DocumentRunShading | undefined;
+    invalidCount: number;
+    spoofedCount: number;
+}
+export declare function inspectDocxRunShading(properties: Element | null | undefined, themeSource?: DocxThemeSource): DocxRunShadingInspection;
+export declare function resolveDocxRunShading(propertySources: readonly Element[], themeSource?: DocxThemeSource): ResolvedDocxRunShading;

package/dist/internal/features/work/work-docx-table-of-contents-export.d.ts

@@ -0,0 +1,11 @@
+import { type WorkDocumentTableOfContentsEntry, type WorkDocumentTableOfContentsOptions } from './work-document-table-of-contents';
+export interface DocxTableOfContentsPatch {
+    options: WorkDocumentTableOfContentsOptions;
+    entries: WorkDocumentTableOfContentsEntry[];
+}
+export declare class DocxTableOfContentsPatchCollector {
+    readonly patches: DocxTableOfContentsPatch[];
+    add(element: HTMLElement): DocxTableOfContentsPatch;
+}
+export declare function docxTableOfContents(element: HTMLElement, docx: typeof import('docx'), collector: DocxTableOfContentsPatchCollector): InstanceType<typeof docx.TableOfContents>;
+export declare function patchDocxTableOfContents(buffer: ArrayBuffer, patches: readonly DocxTableOfContentsPatch[]): Promise<ArrayBuffer>;

package/dist/internal/features/work/work-docx-table-of-contents-import.d.ts

@@ -0,0 +1,15 @@
+import { type WorkDocumentTableOfContentsEntry, type WorkDocumentTableOfContentsOptions } from './work-document-table-of-contents';
+import { type DocxFieldOccurrence } from './work-docx-field-instructions';
+export interface ImportedDocxTableOfContentsMarkers {
+    tables: ImportedDocxTableOfContentsMarker[];
+}
+export interface ImportedDocxTableOfContentsMarker {
+    marker: string;
+    id: string;
+    options: WorkDocumentTableOfContentsOptions;
+    entries: WorkDocumentTableOfContentsEntry[];
+}
+export declare function markDocxTablesOfContents(document: Document): ImportedDocxTableOfContentsMarkers;
+export declare function applyImportedDocxTableOfContentsMarkers(document: Document, markers: ImportedDocxTableOfContentsMarkers): void;
+export declare function hasImportedDocxTableOfContentsMarkers(markers: ImportedDocxTableOfContentsMarkers): boolean;
+export declare function supportedDocxTableOfContentsField(field: DocxFieldOccurrence): boolean;

package/dist/internal/features/work/work-spreadsheet-data-validation.d.ts

@@ -1,2 +1,9 @@
+import type { WorkSpreadsheetDataValidationErrorStyle } from './work-types';
+export declare const SPREADSHEET_DATA_VALIDATION_TITLE_LIMIT = 32;
+export declare const SPREADSHEET_DATA_VALIDATION_HINT_LIMIT = 255;
+export declare const SPREADSHEET_DATA_VALIDATION_ERROR_LIMIT = 225;
+export declare const SPREADSHEET_DATA_VALIDATION_ERROR_STYLES: readonly ["stop", "warning", "information"];
+export declare function normalizeSpreadsheetDataValidationErrorStyle(value: unknown): WorkSpreadsheetDataValidationErrorStyle;
+export declare function boundedSpreadsheetDataValidationText(value: unknown, limit: number): string;
 export declare function normalizeSpreadsheetDateValidationBoundary(value: string, uses1904DateSystem?: boolean): string | null;
 export declare function spreadsheetDateValidationFormula(value: string): string;