@a3s-lab/office 0.25.0 → 0.27.0

package/dist/internal/features/work/editors/spreadsheet-rich-text-selection-controller.d.ts

@@ -0,0 +1,38 @@
+import { type Cell, type Selection } from '@fortune-sheet/core';
+import type { WorkSpreadsheetContent } from '../work-types';
+import { type SpreadsheetRichTextToggleAttribute } from './spreadsheet-rich-text-selection-format';
+interface SpreadsheetRichTextSelectionSnapshot {
+    column: number;
+    consumed: boolean;
+    editor: HTMLElement;
+    end: number;
+    root: HTMLElement;
+    row: number;
+    sheetId: string;
+    sourceCell: Cell;
+    start: number;
+}
+export interface SpreadsheetRichTextSelectionCapture {
+    content: WorkSpreadsheetContent;
+    root: HTMLElement | null;
+    selection: Selection | null | undefined;
+    sheetId: string;
+}
+export declare class SpreadsheetRichTextSelectionController {
+    private restoreTimer;
+    private snapshot;
+    capture(options: SpreadsheetRichTextSelectionCapture): boolean;
+    clear(): void;
+    canApply(content: WorkSpreadsheetContent, attribute: keyof Cell, value: unknown): boolean;
+    apply(content: WorkSpreadsheetContent, onChange: (content: WorkSpreadsheetContent) => void, attribute: keyof Cell, value: unknown): boolean;
+    canToggle(content: WorkSpreadsheetContent, attribute: SpreadsheetRichTextToggleAttribute): boolean;
+    toggle(content: WorkSpreadsheetContent, onChange: (content: WorkSpreadsheetContent) => void, attribute: SpreadsheetRichTextToggleAttribute): boolean;
+    private applyRequest;
+    restore(): boolean;
+    private cancelScheduledRestore;
+    private request;
+    private toggleRequest;
+}
+export declare function isSpreadsheetRichTextFormatPointerTarget(target: EventTarget | null): boolean;
+export declare function captureSpreadsheetRichTextSelection({ content, root, selection, sheetId, }: SpreadsheetRichTextSelectionCapture): SpreadsheetRichTextSelectionSnapshot | null;
+export {};

package/dist/internal/features/work/editors/spreadsheet-rich-text-selection-format.d.ts

@@ -0,0 +1,26 @@
+import type { Cell } from '@fortune-sheet/core';
+import type { WorkSpreadsheetContent } from '../work-types';
+export type SpreadsheetRichTextFormatAttribute = 'bl' | 'cl' | 'fc' | 'ff' | 'fs' | 'it' | 'un';
+export type SpreadsheetRichTextToggleAttribute = 'bl' | 'cl' | 'it' | 'un';
+export interface SpreadsheetTextSelection {
+    end: number;
+    start: number;
+}
+export interface SpreadsheetRichTextSelectionFormatRequest {
+    attribute: SpreadsheetRichTextFormatAttribute;
+    column: number;
+    row: number;
+    selection: SpreadsheetTextSelection;
+    sheetId: string;
+    /**
+     * A cell reconstructed from the live editor before focus moves into a
+     * ribbon popover. It is intentionally internal and still passes through all
+     * text, run-count, coordinate, and formatting bounds below.
+     */
+    sourceCell?: Cell;
+    value: unknown;
+}
+export declare function canApplySpreadsheetRichTextSelectionFormat(content: WorkSpreadsheetContent, request: SpreadsheetRichTextSelectionFormatRequest): boolean;
+export declare function applySpreadsheetRichTextSelectionFormat(content: WorkSpreadsheetContent, request: SpreadsheetRichTextSelectionFormatRequest): WorkSpreadsheetContent | null;
+export declare function formatSpreadsheetRichTextSelection(cell: Cell, selection: SpreadsheetTextSelection, attribute: SpreadsheetRichTextFormatAttribute, value: unknown): Cell | null;
+export declare function spreadsheetRichTextSelectionToggleValue(cell: Cell, selection: SpreadsheetTextSelection, attribute: SpreadsheetRichTextToggleAttribute): 0 | 1 | null;

package/dist/internal/features/work/editors/work-office-chrome.d.ts

@@ -23,6 +23,12 @@ export interface WorkOfficeQuickAccessAction {
     disabled?: boolean;
     onSelect: () => void | Promise<void>;
 }
+interface WorkOfficeRibbonDialogLauncher {
+    label: string;
+    shortcut?: string;
+    ariaKeyShortcuts?: string;
+    onClick: () => void;
+}
 export declare function WorkOfficeRibbon<T extends string>({ ariaLabel, tabs, defaultTab, activeTab, onTabChange, panels, fileActions, quickAccessActions, adaptive, collapsible, collapsed: controlledCollapsed, defaultCollapsed, onCollapsedChange, className, toolbarClassName, }: {
     ariaLabel: string;
     tabs: readonly WorkOfficeRibbonTab<T>[];
@@ -47,9 +53,10 @@ export declare function WorkOfficePreviewBar({ ariaLabel, label, detail, fileAct
     fileActions?: readonly WorkOfficeFileAction[];
     className?: string;
 }): import("react").JSX.Element;
-export declare function WorkOfficeRibbonGroup({ label, priority, children, }: {
+export declare function WorkOfficeRibbonGroup({ label, priority, dialogLauncher, children, }: {
     label: string;
     priority?: 'high' | 'normal' | 'low';
+    dialogLauncher?: WorkOfficeRibbonDialogLauncher;
     children: ReactNode;
 }): import("react").JSX.Element;
 export declare function WorkOfficeRibbonButton({ label, visibleLabel, badge, active, displayLabel, className, title, children, ...props }: Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'aria-label' | 'children'> & {
@@ -78,3 +85,4 @@ export declare function WorkOfficeZoomControls({ zoom, minimum, maximum, step, d
     sliderLabel: string;
     onChange: (zoom: number) => void;
 }): import("react").JSX.Element;
+export {};

package/dist/internal/features/work/work-css-color.d.ts

@@ -0,0 +1 @@
+export declare function normalizeCssColor(source: string | null | undefined): 'transparent' | `#${string}` | null;

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

@@ -1,12 +1,27 @@
-import type { Editor } from '@tiptap/core';
+import { Extension, type Editor } from '@tiptap/core';
+import { type WorkDocumentEmphasisMark } from './work-document-emphasis';
+import { type WorkDocumentTextCase } from './work-document-text-case';
 declare module '@tiptap/core' {
     interface Commands<ReturnType> {
         documentCharacterFormatting: {
+            setDocumentCharacterScale: (characterScalePercent: number) => ReturnType;
             toggleDocumentSubscript: () => ReturnType;
             toggleDocumentSuperscript: () => ReturnType;
+            setDocumentCharacterSpacing: (characterSpacingTwips: number) => ReturnType;
+            setDocumentCharacterPosition: (characterPositionHalfPoints: number) => ReturnType;
+            setDocumentKerningThreshold: (kerningThresholdHalfPoints: number) => ReturnType;
+            unsetDocumentKerningThreshold: () => ReturnType;
+            setDocumentEmphasisMark: (emphasisMark: WorkDocumentEmphasisMark) => ReturnType;
+            unsetDocumentEmphasisMark: () => ReturnType;
+            setDocumentHiddenText: (hiddenText: boolean) => ReturnType;
+            unsetDocumentHiddenText: () => ReturnType;
+            toggleDocumentHiddenText: () => ReturnType;
+            setDocumentTextCase: (textCase: WorkDocumentTextCase) => ReturnType;
+            toggleDocumentTextCase: (textCase: Exclude<WorkDocumentTextCase, 'none'>) => ReturnType;
         };
     }
 }
+export declare const DocumentCharacterFormatting: Extension<any, any>;
 export declare const DocumentSubscript: import("@tiptap/core").Mark<import("@tiptap/extension-subscript").SubscriptExtensionOptions, any>;
 export declare const DocumentSuperscript: import("@tiptap/core").Mark<import("@tiptap/extension-superscript").SuperscriptExtensionOptions, any>;
 export declare function toggleDocumentSubscript(editor: Editor): boolean;

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

@@ -0,0 +1,9 @@
+export declare const DOCUMENT_CHARACTER_POSITION_ATTRIBUTE = "data-office-character-position-half-points";
+export declare const DOCUMENT_CHARACTER_POSITION_CSS_PROPERTY = "--work-document-character-position";
+export declare const DOCUMENT_CHARACTER_POSITION_MAX_HALF_POINTS = 3168;
+export declare const DOCUMENT_CHARACTER_POSITION_MIN_HALF_POINTS: number;
+export declare function normalizeDocumentCharacterPositionHalfPoints(value: unknown): number | null;
+export declare function documentCharacterPositionDomAttributes(value: unknown): Record<string, string>;
+export declare function documentCharacterPositionHalfPointsFromElement(element: HTMLElement): number | null;
+export declare function documentCharacterPositionHalfPointsFromCss(value: unknown): number | null;
+export declare function documentCharacterPositionPoints(value: unknown): number | null;

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

@@ -0,0 +1,8 @@
+export declare const DOCUMENT_CHARACTER_SCALE_ATTRIBUTE = "data-office-character-scale-percent";
+export declare const DOCUMENT_CHARACTER_SCALE_DEFAULT_PERCENT = 100;
+export declare const DOCUMENT_CHARACTER_SCALE_MIN_PERCENT = 1;
+export declare const DOCUMENT_CHARACTER_SCALE_MAX_PERCENT = 600;
+export declare function normalizeDocumentCharacterScalePercent(value: unknown): number | null;
+export declare function documentCharacterScaleDomAttributes(value: unknown): Record<string, string>;
+export declare function documentCharacterScalePercentFromElement(element: HTMLElement): number | null;
+export declare function documentCharacterScalePercentFromCss(value: unknown): number | null;

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

@@ -0,0 +1,8 @@
+export declare const DOCUMENT_CHARACTER_SPACING_ATTRIBUTE = "data-office-character-spacing-twips";
+export declare const DOCUMENT_CHARACTER_SPACING_MAX_TWIPS = 31680;
+export declare const DOCUMENT_CHARACTER_SPACING_MIN_TWIPS: number;
+export declare function normalizeDocumentCharacterSpacingTwips(value: unknown): number | null;
+export declare function documentCharacterSpacingDomAttributes(value: unknown): Record<string, string>;
+export declare function documentCharacterSpacingTwipsFromElement(element: HTMLElement): number | null;
+export declare function documentCharacterSpacingTwipsFromCss(value: unknown): number | null;
+export declare function documentCharacterSpacingPoints(value: unknown): number | null;

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

@@ -0,0 +1,7 @@
+export declare const DOCUMENT_EMPHASIS_MARK_ATTRIBUTE = "data-office-emphasis-mark";
+export declare const DOCUMENT_EMPHASIS_MARKS: readonly ["none", "dot", "comma", "circle", "underDot"];
+export type WorkDocumentEmphasisMark = (typeof DOCUMENT_EMPHASIS_MARKS)[number];
+export declare function normalizeDocumentEmphasisMark(value: unknown): WorkDocumentEmphasisMark | null;
+export declare function documentEmphasisMarkCss(value: unknown): string;
+export declare function documentEmphasisMarkDomAttributes(value: unknown): Record<string, string>;
+export declare function documentEmphasisMarkFromElement(element: HTMLElement): WorkDocumentEmphasisMark | null;

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

@@ -1,4 +1,5 @@
 import { Node } from '@tiptap/core';
+import { type WorkDocumentEmphasisMark } from './work-document-emphasis';
 export type WorkDocumentEquationDisplay = 'inline' | 'block';
 export type WorkDocumentEquationJustification = 'left' | 'right' | 'center' | 'centerGroup';
 export type WorkDocumentEquationBarPosition = 'top' | 'bottom';
@@ -203,7 +204,7 @@ export interface WorkDocumentEquationWordFitText {
     id?: number;
 }
 export type WorkDocumentEquationWordVerticalAlignment = 'baseline' | 'superscript' | 'subscript';
-export type WorkDocumentEquationWordEmphasisMark = 'none' | 'dot' | 'comma' | 'circle' | 'underDot';
+export type WorkDocumentEquationWordEmphasisMark = WorkDocumentEmphasisMark;
 export interface WorkDocumentEquationWordLanguages {
     latin?: string;
     eastAsia?: string;

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

@@ -1,5 +1,10 @@
 import type { Mark, Schema } from '@tiptap/pm/model';
 import type { Transaction } from '@tiptap/pm/state';
+import { type WorkDocumentEmphasisMark } from './work-document-emphasis';
+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';
 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 {
@@ -13,11 +18,19 @@ export declare function restoreDocumentCharacterFormatting(transaction: Transact
 export declare function importedDocumentCharacterFormatting(formatting: {
     bold?: boolean;
     italic?: boolean;
-    underline?: boolean;
-    strike?: boolean;
+    underline?: WorkDocumentUnderlineFormatting;
+    strike?: WorkDocumentStrikeFormatting;
     subscript?: boolean;
     superscript?: boolean;
     fontFamily?: string;
+    scriptFonts?: WorkDocumentScriptFonts;
+    scriptFontSlot?: WorkDocumentScriptFontSlot;
+    characterScalePercent?: number;
+    characterPositionHalfPoints?: number;
+    characterSpacingTwips?: number;
+    kerningThresholdHalfPoints?: number;
+    emphasisMark?: WorkDocumentEmphasisMark;
+    hiddenText?: boolean;
     wordLineHeightFactor?: number;
     wordSnapToGrid?: boolean;
     fontSize?: number;
@@ -25,4 +38,5 @@ export declare function importedDocumentCharacterFormatting(formatting: {
     backgroundColor?: string;
     themeColor?: string;
     themeFill?: string;
+    textCase?: WorkDocumentTextCase;
 }): string;

package/dist/internal/features/work/work-document-hidden-text.d.ts

@@ -0,0 +1,5 @@
+export declare const DOCUMENT_HIDDEN_TEXT_ATTRIBUTE = "data-office-hidden-text";
+export declare const documentHiddenTextKeyboardShortcut = "Mod-Shift-h";
+export declare function normalizeDocumentHiddenText(value: unknown): boolean | null;
+export declare function documentHiddenTextFromElement(element: HTMLElement): boolean | null;
+export declare function documentHiddenTextDomAttributes(value: unknown): Record<string, string>;

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

@@ -0,0 +1,10 @@
+export declare const DOCUMENT_KERNING_THRESHOLD_ATTRIBUTE = "data-office-kerning-threshold-half-points";
+export declare const DOCUMENT_KERNING_THRESHOLD_MIN_HALF_POINTS = 0;
+export declare const DOCUMENT_KERNING_THRESHOLD_MAX_HALF_POINTS = 3277;
+export declare const DOCUMENT_KERNING_DEFAULT_THRESHOLD_HALF_POINTS = 24;
+export declare function normalizeDocumentKerningThresholdHalfPoints(value: unknown): number | null;
+export declare function documentKerningThresholdPoints(value: unknown): number | null;
+export declare function documentKerningIsEffective(thresholdValue: unknown, fontSizeValue: unknown): boolean;
+export declare function documentKerningDomAttributes(thresholdValue: unknown, fontSizeValue?: unknown): Record<string, string>;
+export declare function documentKerningThresholdHalfPointsFromElement(element: HTMLElement): number | null;
+export declare function documentKerningFontSizePoints(value: unknown): number;

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

@@ -1,4 +1,5 @@
 import { type DocxThemeColorReference } from './work-docx-theme-reference';
+export { normalizeCssColor } from './work-css-color';
 export type DocumentParagraphShadingPattern = 'nil' | 'clear' | 'solid' | 'horzStripe' | 'vertStripe' | 'reverseDiagStripe' | 'diagStripe' | 'horzCross' | 'diagCross' | 'thinHorzStripe' | 'thinVertStripe' | 'thinReverseDiagStripe' | 'thinDiagStripe' | 'thinHorzCross' | 'thinDiagCross' | 'pct5' | 'pct10' | 'pct12' | 'pct15' | 'pct20' | 'pct25' | 'pct30' | 'pct35' | 'pct37' | 'pct40' | 'pct45' | 'pct50' | 'pct55' | 'pct60' | 'pct62' | 'pct65' | 'pct70' | 'pct75' | 'pct80' | 'pct85' | 'pct87' | 'pct90' | 'pct95';
 export interface DocumentParagraphShadingColor {
     value: 'auto' | `#${string}`;
@@ -15,4 +16,3 @@ 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 normalizeCssColor(source: string | null | undefined): 'transparent' | `#${string}` | null;

package/dist/internal/features/work/work-document-script-font-extension.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '@tiptap/core';
+export declare const DocumentScriptFontFormatting: Extension<any, any>;

package/dist/internal/features/work/work-document-script-fonts.d.ts

@@ -0,0 +1,51 @@
+export type WorkDocumentScriptFontSlot = 'ascii' | 'highAnsi' | 'eastAsia' | 'complexScript';
+export type WorkDocumentScriptFontHint = 'default' | 'eastAsia' | 'cs';
+export type WorkDocumentThemeFont = 'majorEastAsia' | 'majorBidi' | 'majorAscii' | 'majorHAnsi' | 'minorEastAsia' | 'minorBidi' | 'minorAscii' | 'minorHAnsi';
+export interface WorkDocumentScriptFontFace {
+    /** Exact direct w:rFonts value, when present. */
+    name?: string;
+    /** Exact theme reference, when present. */
+    theme?: WorkDocumentThemeFont;
+    /** Browser-resolved family retained independently from source identity. */
+    resolved?: string;
+}
+export interface WorkDocumentScriptFonts {
+    ascii?: WorkDocumentScriptFontFace;
+    highAnsi?: WorkDocumentScriptFontFace;
+    eastAsia?: WorkDocumentScriptFontFace;
+    complexScript?: WorkDocumentScriptFontFace;
+    hint?: WorkDocumentScriptFontHint;
+}
+export interface WorkDocumentScriptFontSegment {
+    from: number;
+    to: number;
+    slot: WorkDocumentScriptFontSlot;
+}
+export interface WorkDocumentScriptFontPatch {
+    latin?: string | null;
+    eastAsia?: string | null;
+    complexScript?: string | null;
+}
+export declare const DOCUMENT_SCRIPT_FONTS_ATTRIBUTE = "data-office-script-fonts";
+export declare const DOCUMENT_SCRIPT_FONT_SLOT_ATTRIBUTE = "data-office-script-font-slot";
+export declare function normalizeDocumentScriptFonts(source: unknown): WorkDocumentScriptFonts | null;
+export declare function serializeDocumentScriptFonts(source: unknown): string | null;
+export declare function parseDocumentScriptFonts(source: string | null | undefined): WorkDocumentScriptFonts | null;
+export declare function documentScriptFontsFromElement(element: HTMLElement): WorkDocumentScriptFonts | null;
+export declare function documentScriptFontSlotFromElement(element: HTMLElement): WorkDocumentScriptFontSlot | null;
+export declare function documentScriptFontsDomAttributes(source: unknown, slot: unknown): Record<string, string>;
+export declare function documentScriptFontFamily(source: unknown, slot: WorkDocumentScriptFontSlot): string | undefined;
+export declare function documentScriptFontFallbackSlots(slot: WorkDocumentScriptFontSlot): readonly WorkDocumentScriptFontSlot[];
+export declare function documentScriptFontFamilyForRendering(source: unknown, slot: WorkDocumentScriptFontSlot, currentFontFamily?: unknown): string | undefined;
+export declare function documentScriptFontDirectFamily(source: unknown, slot: WorkDocumentScriptFontSlot): string | null;
+export declare function documentScriptFontsForAllText(fontFamily: unknown): WorkDocumentScriptFonts | null;
+export declare function patchDocumentScriptFonts(source: unknown, patch: WorkDocumentScriptFontPatch, fallbackFontFamily?: unknown): WorkDocumentScriptFonts | null;
+export declare function documentScriptFontSegments(text: string, hint?: WorkDocumentScriptFontHint, forceComplexScript?: boolean): WorkDocumentScriptFontSegment[];
+export declare function normalizeDocumentScriptFontSlot(value: unknown): WorkDocumentScriptFontSlot | null;
+export declare function normalizeDocumentScriptFontHint(value: unknown): WorkDocumentScriptFontHint | null;
+export declare function normalizeDocumentThemeFont(value: unknown): WorkDocumentThemeFont | null;
+export declare function documentScriptFontSlotFromHint(hint: WorkDocumentScriptFontHint | undefined): WorkDocumentScriptFontSlot;
+export declare function documentFontNameFromCssFamily(value: unknown): string | null;
+export declare function cssDocumentFontFamily(value: unknown): string | null;
+export declare function normalizeDocumentFontName(value: unknown): string | null;
+export declare const scriptFontSlots: readonly ["ascii", "highAnsi", "eastAsia", "complexScript"];

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

@@ -0,0 +1,21 @@
+import { type Editor } from '@tiptap/core';
+export declare const workDocumentStrikeStyles: readonly ["none", "single", "double"];
+export type WorkDocumentStrikeStyle = (typeof workDocumentStrikeStyles)[number];
+export interface WorkDocumentStrikeFormatting {
+    style: WorkDocumentStrikeStyle;
+}
+export declare const DOCUMENT_STRIKE_STYLE_ATTRIBUTE = "data-office-strike-style";
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        documentStrike: {
+            setDocumentStrike: (style: WorkDocumentStrikeStyle) => ReturnType;
+            toggleDocumentStrikeStyle: (style: Exclude<WorkDocumentStrikeStyle, 'none'>) => ReturnType;
+        };
+    }
+}
+export declare const DocumentStrike: import("@tiptap/core").Mark<import("@tiptap/extension-strike").StrikeOptions, any>;
+export declare function normalizeDocumentStrikeStyle(value: unknown): WorkDocumentStrikeStyle | null;
+export declare function documentStrikeStyle(editor: Editor): WorkDocumentStrikeStyle;
+export declare function documentStrikeFormatting(editor: Editor): WorkDocumentStrikeFormatting | null;
+export declare function documentStrikeFormattingFromElement(element: HTMLElement): WorkDocumentStrikeFormatting | null;
+export declare function documentStrikeDomAttributes(formatting: WorkDocumentStrikeFormatting): Record<string, string>;

package/dist/internal/features/work/work-document-text-case.d.ts

@@ -0,0 +1,10 @@
+export type WorkDocumentTextCase = 'none' | 'all-caps' | 'small-caps';
+export declare const DOCUMENT_TEXT_CASE_ATTRIBUTE = "data-office-text-case";
+export declare const documentTextCaseKeyboardShortcuts: {
+    readonly allCaps: "Mod-Shift-a";
+    readonly smallCaps: "Mod-Shift-k";
+};
+export declare function normalizeDocumentTextCase(value: unknown): WorkDocumentTextCase | null;
+export declare function documentTextCaseFromWordFlags(allCaps: boolean | undefined, smallCaps: boolean | undefined): WorkDocumentTextCase | null;
+export declare function applyDocumentTextCaseStyle(element: HTMLElement, textCase: WorkDocumentTextCase): void;
+export declare function documentTextCaseCss(textCase: WorkDocumentTextCase): string;

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

@@ -0,0 +1,37 @@
+import { type Editor } from '@tiptap/core';
+import { type DocxThemeColorReference } from './work-docx-theme-reference';
+export declare const workDocumentUnderlineStyles: readonly ["none", "single", "words", "double", "thick", "dotted", "dottedHeavy", "dash", "dashedHeavy", "dashLong", "dashLongHeavy", "dotDash", "dashDotHeavy", "dotDotDash", "dashDotDotHeavy", "wave", "wavyHeavy", "wavyDouble"];
+export type WorkDocumentUnderlineStyle = (typeof workDocumentUnderlineStyles)[number];
+export interface WorkDocumentUnderlineFormatting {
+    style: WorkDocumentUnderlineStyle;
+    color?: string;
+    themeColor?: DocxThemeColorReference;
+}
+export interface WorkDocumentUnderlineCommandOptions {
+    color?: string | null;
+    themeColor?: DocxThemeColorReference | string | null;
+}
+export declare const DOCUMENT_UNDERLINE_STYLE_ATTRIBUTE = "data-office-underline-style";
+export declare const DOCUMENT_UNDERLINE_COLOR_ATTRIBUTE = "data-office-underline-color";
+export declare const DOCUMENT_UNDERLINE_THEME_COLOR_ATTRIBUTE = "data-office-underline-theme-color";
+export declare const documentUnderlineKeyboardShortcuts: {
+    readonly double: "Mod-Shift-d";
+    readonly words: "Mod-Shift-w";
+};
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        documentUnderline: {
+            setDocumentUnderline: (style: WorkDocumentUnderlineStyle, options?: WorkDocumentUnderlineCommandOptions) => ReturnType;
+            setDocumentUnderlineColor: (color: string | null, themeColor?: DocxThemeColorReference | string | null) => ReturnType;
+            toggleDocumentUnderlineStyle: (style: Exclude<WorkDocumentUnderlineStyle, 'none'>) => ReturnType;
+        };
+    }
+}
+export declare const DocumentUnderline: import("@tiptap/core").Mark<import("@tiptap/extension-underline").UnderlineOptions, any>;
+export declare function normalizeDocumentUnderlineStyle(value: unknown): WorkDocumentUnderlineStyle | null;
+export declare function normalizeDocumentUnderlineColor(value: unknown): string | null;
+export declare function documentUnderlineStyle(editor: Editor): WorkDocumentUnderlineStyle;
+export declare function documentUnderlineColor(editor: Editor): string | null;
+export declare function documentUnderlineFormatting(editor: Editor): WorkDocumentUnderlineFormatting | null;
+export declare function documentUnderlineFormattingFromElement(element: HTMLElement): WorkDocumentUnderlineFormatting | null;
+export declare function documentUnderlineDomAttributes(formatting: WorkDocumentUnderlineFormatting): Record<string, string>;

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

@@ -1,9 +1,21 @@
+import { type WorkDocumentEmphasisMark } from './work-document-emphasis';
+import { type WorkDocumentTextCase } from './work-document-text-case';
+import { type WorkDocumentScriptFontSlot } from './work-document-script-fonts';
 export declare const DOCUMENT_WORD_DEFAULT_SINGLE_LINE_HEIGHT = 1.15;
 declare module '@tiptap/extension-text-style' {
     interface TextStyleAttributes {
+        characterScalePercent?: number | null;
+        characterPositionHalfPoints?: number | null;
+        characterSpacingTwips?: number | null;
+        emphasisMark?: WorkDocumentEmphasisMark | null;
+        hiddenText?: boolean | null;
+        kerningThresholdHalfPoints?: number | null;
+        scriptFonts?: string | null;
+        scriptFontSlot?: WorkDocumentScriptFontSlot | null;
         wordLineHeightFactor?: number | null;
         wordSnapToGrid?: boolean | null;
         themeColor?: string | null;
+        textCase?: WorkDocumentTextCase | null;
     }
 }
 export declare function documentWordLineHeightFactor(fontFamily: unknown): number;

package/dist/internal/features/work/work-docx-character-position.d.ts

@@ -0,0 +1,2 @@
+export declare function docxCharacterPositionValue(value: unknown): string | undefined;
+export declare function docxCharacterPositionHalfPointsFromProperties(properties: Element | null | undefined): number | undefined;

package/dist/internal/features/work/work-docx-character-scale.d.ts

@@ -0,0 +1,2 @@
+export declare function docxCharacterScaleValue(value: unknown): number | undefined;
+export declare function docxCharacterScalePercentFromProperties(properties: Element | null | undefined): number | undefined;

package/dist/internal/features/work/work-docx-character-spacing.d.ts

@@ -0,0 +1,4 @@
+export declare const DOCX_EXPLICIT_ZERO_CHARACTER_SPACING_SENTINEL: number;
+export declare function docxCharacterSpacingValue(value: unknown): number | undefined;
+export declare function docxCharacterSpacingTwipsFromProperties(properties: Element | null | undefined): number | undefined;
+export declare function patchDocxExplicitZeroCharacterSpacing(buffer: ArrayBuffer): Promise<ArrayBuffer>;

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

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

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

@@ -0,0 +1,14 @@
+import type { IRunOptions } from 'docx';
+import { type WorkDocumentEmphasisMark } from './work-document-emphasis';
+export type DocxEmphasisMarkInspection = {
+    status: 'absent';
+} | {
+    status: 'invalid';
+} | {
+    status: 'valid';
+    value: WorkDocumentEmphasisMark;
+};
+export declare function docxEmphasisMarkFromProperties(properties: Element | null | undefined): WorkDocumentEmphasisMark | undefined;
+export declare function resolveDocxEmphasisMark(propertySources: readonly Element[]): WorkDocumentEmphasisMark | undefined;
+export declare function inspectDocxEmphasisMark(properties: Element | null | undefined): DocxEmphasisMarkInspection;
+export declare function docxEmphasisMarkRunOptions(value: unknown): IRunOptions['emphasisMark'] | undefined;

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

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

package/dist/internal/features/work/work-docx-hidden-text-export.d.ts

@@ -0,0 +1,16 @@
+export interface DocxHiddenTextPatch {
+    marker: string;
+    style?: string;
+    value: boolean;
+}
+export declare class DocxHiddenTextPatchCollector {
+    readonly patches: DocxHiddenTextPatch[];
+    private nextMarker;
+    private readonly occupied;
+    private readonly patchesByMarker;
+    private readonly markersByValueAndStyle;
+    constructor(source: string);
+    marker(value: boolean, inheritedStyle?: string): string;
+    private originalStyle;
+}
+export declare function patchDocxHiddenText(buffer: ArrayBuffer, patches: readonly DocxHiddenTextPatch[]): Promise<ArrayBuffer>;

package/dist/internal/features/work/work-docx-hidden-text.d.ts

@@ -0,0 +1,11 @@
+export type DocxHiddenTextInspection = {
+    status: 'absent';
+} | {
+    status: 'invalid';
+} | {
+    status: 'valid';
+    value: boolean;
+};
+export declare function inspectDocxHiddenText(properties: Element | null | undefined): DocxHiddenTextInspection;
+export declare function docxHiddenTextFromProperties(properties: Element | null | undefined): boolean | undefined;
+export declare function resolveDocxHiddenText(propertySources: readonly Element[]): boolean | undefined;

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

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

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

@@ -0,0 +1,14 @@
+export declare const DOCX_EXPLICIT_ZERO_KERNING_THRESHOLD_SENTINEL: number;
+export type DocxKerningThresholdInspection = {
+    status: 'absent';
+} | {
+    status: 'invalid';
+} | {
+    status: 'valid';
+    value: number;
+};
+export declare function docxKerningThresholdValue(value: unknown): number | undefined;
+export declare function docxKerningThresholdHalfPointsFromProperties(properties: Element | null | undefined): number | undefined;
+export declare function resolveDocxKerningThresholdHalfPoints(propertySources: readonly Element[]): number | undefined;
+export declare function inspectDocxKerningThresholdHalfPoints(properties: Element | null | undefined): DocxKerningThresholdInspection;
+export declare function patchDocxExplicitZeroKerningThresholds(buffer: ArrayBuffer): Promise<ArrayBuffer>;

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

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

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

@@ -0,0 +1,14 @@
+import { type WorkDocumentScriptFonts } from './work-document-script-fonts';
+export interface DocxRunFontsPatch {
+    marker: string;
+    fonts: WorkDocumentScriptFonts;
+}
+export declare class DocxRunFontsPatchCollector {
+    readonly patches: DocxRunFontsPatch[];
+    private nextMarker;
+    private readonly occupied;
+    private readonly markersByFonts;
+    constructor(source: string);
+    marker(source: unknown, slot: unknown, currentFontFamily: string): string | null;
+}
+export declare function patchDocxRunFonts(buffer: ArrayBuffer, patches: readonly DocxRunFontsPatch[]): Promise<ArrayBuffer>;

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

@@ -0,0 +1,13 @@
+import { type WorkDocumentScriptFonts } from './work-document-script-fonts';
+import { type DocxThemeResolver } from './work-docx-theme';
+export type InspectedDocxRunFonts = {
+    status: 'absent';
+} | {
+    status: 'invalid';
+} | {
+    status: 'valid';
+    value: WorkDocumentScriptFonts | null;
+};
+export declare function inspectDocxRunFonts(properties: Element | null | undefined, theme?: DocxThemeResolver): InspectedDocxRunFonts;
+export declare function resolveDocxRunFonts(propertySources: readonly Element[], theme: DocxThemeResolver): WorkDocumentScriptFonts | null;
+export declare function parseDocxRunFontsElement(element: Element | undefined, theme?: DocxThemeResolver): WorkDocumentScriptFonts | null | undefined;

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

@@ -1,15 +1,28 @@
 import { type DocxParagraphStyleSource } from './work-docx-paragraph-styles';
 import { type DocxThemeSource } from './work-docx-theme';
 import { type DocxTableStyleSource } from './work-docx-table-styles';
+import { type WorkDocumentEmphasisMark } from './work-document-emphasis';
 import { type DocxThemeColorReference } from './work-docx-theme-reference';
+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';
 export interface ImportedDocxRunFormatting {
     bold?: boolean;
     italic?: boolean;
-    underline?: boolean;
-    strike?: boolean;
+    underline?: WorkDocumentUnderlineFormatting;
+    strike?: WorkDocumentStrikeFormatting;
     subscript?: boolean;
     superscript?: boolean;
+    characterScalePercent?: number;
+    characterPositionHalfPoints?: number;
+    characterSpacingTwips?: number;
+    kerningThresholdHalfPoints?: number;
+    emphasisMark?: WorkDocumentEmphasisMark;
+    hiddenText?: boolean;
     fontFamily?: string;
+    scriptFonts?: WorkDocumentScriptFonts;
+    scriptFontSlot?: WorkDocumentScriptFontSlot;
     wordLineHeightFactor?: number;
     wordSnapToGrid?: boolean;
     fontSize?: number;
@@ -17,6 +30,7 @@ export interface ImportedDocxRunFormatting {
     backgroundColor?: string;
     themeColor?: DocxThemeColorReference;
     themeFill?: DocxThemeColorReference;
+    textCase?: WorkDocumentTextCase;
 }
 export interface ImportedDocxRunFormattingMarker {
     startMarker: string;
@@ -33,7 +47,14 @@ export interface ImportedDocxRunFormattingChange {
 export interface ImportedDocxRunFormattingMarkers {
     runs: ImportedDocxRunFormattingMarker[];
 }
+export interface ImportedDocxRunFormattingMarkerState {
+    markers: ImportedDocxRunFormattingMarkers;
+    nextMarker: number;
+    occupiedText: string;
+}
 export declare function markDocxRunFormatting(document: Document, styleSource?: DocxParagraphStyleSource, themeSource?: DocxThemeSource, tableStyleSource?: DocxTableStyleSource): ImportedDocxRunFormattingMarkers;
+export declare function createImportedDocxRunFormattingMarkerState(documents: readonly Document[]): ImportedDocxRunFormattingMarkerState;
+export declare function markDocxRunFormattingIntoState(document: Document, state: ImportedDocxRunFormattingMarkerState, styleSource?: DocxParagraphStyleSource, themeSource?: DocxThemeSource, tableStyleSource?: DocxTableStyleSource): void;
 export declare function applyImportedDocxRunFormattingMarkers(document: Document, markers: ImportedDocxRunFormattingMarkers): void;
 export declare function hasImportedDocxRunFormattingMarkers(markers: ImportedDocxRunFormattingMarkers): boolean;
 export declare function isSupportedDocxRunFormattingChange(change: Element): boolean;

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

@@ -0,0 +1,9 @@
+import type { ImportedDocxRunFormatting, ImportedDocxRunFormattingChange, ImportedDocxRunFormattingMarkerState } from './work-docx-run-formatting-import';
+import type { WorkDocumentScriptFontSegment, WorkDocumentScriptFontSlot } from './work-document-script-fonts';
+interface DocxRunFormattingMarkers {
+    endMarker: string;
+    startMarker: string;
+}
+export declare function directDocxRunText(run: Element): string;
+export declare function markSegmentedDocxRunFormatting(run: Element, state: ImportedDocxRunFormattingMarkerState, segments: readonly WorkDocumentScriptFontSegment[], formattingFor: (text: string, slot: WorkDocumentScriptFontSlot) => ImportedDocxRunFormatting, changeFor: (text: string, slot: WorkDocumentScriptFontSlot) => ImportedDocxRunFormattingChange | undefined, createMarkers: () => DocxRunFormattingMarkers): void;
+export {};

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

@@ -0,0 +1,8 @@
+import type { WorkDocumentStrikeFormatting } from './work-document-strike';
+export interface ImportedDocxStrikeFlags {
+    double?: boolean;
+    single?: boolean;
+}
+export declare function importedDocxStrikeFlags(properties: Element): ImportedDocxStrikeFlags;
+export declare function importedDocxStrike(properties: Element): WorkDocumentStrikeFormatting | undefined;
+export declare function resolvedDocxStrikeFormatting(single: boolean | undefined, double: boolean | undefined, materializeNone?: boolean): WorkDocumentStrikeFormatting | undefined;

package/dist/internal/features/work/work-docx-theme-reference.d.ts

@@ -4,7 +4,7 @@ export interface DocxThemeColorReference {
     tint?: string;
     shade?: string;
 }
-type DocxThemePatchKind = 'color' | 'fill' | 'border' | 'shadingColor';
+type DocxThemePatchKind = 'color' | 'fill' | 'border' | 'shadingColor' | 'underline';
 interface DocxThemePatch {
     kind: DocxThemePatchKind;
     marker: string;