@a3s-lab/office 0.26.0 → 0.28.0

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,23 @@ 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;
+    legacyTextOutline?: boolean;
+    legacyTextShadow?: boolean;
+    legacyTextEmboss?: boolean;
+    legacyTextImprint?: boolean;
     wordLineHeightFactor?: number;
     wordSnapToGrid?: boolean;
     fontSize?: number;
@@ -25,4 +42,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-legacy-text-effects.d.ts

@@ -0,0 +1,27 @@
+export declare const DOCUMENT_LEGACY_TEXT_OUTLINE_ATTRIBUTE = "data-office-legacy-text-outline";
+export declare const DOCUMENT_LEGACY_TEXT_SHADOW_ATTRIBUTE = "data-office-legacy-text-shadow";
+export declare const DOCUMENT_LEGACY_TEXT_EMBOSS_ATTRIBUTE = "data-office-legacy-text-emboss";
+export declare const DOCUMENT_LEGACY_TEXT_IMPRINT_ATTRIBUTE = "data-office-legacy-text-imprint";
+export declare const DOCUMENT_LEGACY_TEXT_EFFECT_NAMES: readonly ["outline", "shadow", "emboss", "imprint"];
+export type WorkDocumentLegacyTextEffectName = (typeof DOCUMENT_LEGACY_TEXT_EFFECT_NAMES)[number];
+export interface WorkDocumentLegacyTextEffects {
+    outline?: boolean;
+    shadow?: boolean;
+    emboss?: boolean;
+    imprint?: boolean;
+}
+export interface WorkDocumentLegacyTextEffectCss {
+    WebkitTextFillColor?: string;
+    WebkitTextStroke?: string;
+    paintOrder?: string;
+    textShadow?: string;
+}
+export declare function normalizeDocumentLegacyTextEffect(value: unknown): boolean | null;
+export declare function normalizeDocumentLegacyTextEffects(value: unknown): WorkDocumentLegacyTextEffects | null;
+export declare function documentLegacyTextEffectsConflict(effects: WorkDocumentLegacyTextEffects): boolean;
+export declare function documentLegacyTextEffectFromElement(element: HTMLElement, effect: WorkDocumentLegacyTextEffectName): boolean | null;
+export declare function documentLegacyTextEffectsFromElement(element: HTMLElement): WorkDocumentLegacyTextEffects | null;
+export declare function documentLegacyTextEffectsFromTextStyleAttributes(attributes: Record<string, unknown>): WorkDocumentLegacyTextEffects | null;
+export declare function documentLegacyTextEffectsDomAttributes(value: WorkDocumentLegacyTextEffects): Record<string, string>;
+export declare function documentLegacyTextEffectsCss(value: WorkDocumentLegacyTextEffects): WorkDocumentLegacyTextEffectCss;
+export declare function documentLegacyTextStyleAttributeName(effect: WorkDocumentLegacyTextEffectName): string;

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,25 @@
+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;
+        legacyTextOutline?: boolean | null;
+        legacyTextShadow?: boolean | null;
+        legacyTextEmboss?: boolean | null;
+        legacyTextImprint?: 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,17 @@
+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;
+    lookup(marker: string | undefined): DocxHiddenTextPatch | undefined;
+    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-legacy-text-effects-diagnostics.d.ts

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

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

@@ -0,0 +1,18 @@
+import { type WorkDocumentLegacyTextEffects } from './work-document-legacy-text-effects';
+export interface DocxLegacyTextEffectsPatch {
+    marker: string;
+    style?: string;
+    effects: WorkDocumentLegacyTextEffects;
+}
+export declare class DocxLegacyTextEffectsPatchCollector {
+    readonly patches: DocxLegacyTextEffectsPatch[];
+    private nextMarker;
+    private readonly occupied;
+    private readonly patchesByMarker;
+    private readonly markersByEffectsAndStyle;
+    constructor(source: string);
+    marker(value: WorkDocumentLegacyTextEffects, inheritedStyle?: string): string;
+    lookup(marker: string | undefined): DocxLegacyTextEffectsPatch | undefined;
+    private originalStyle;
+}
+export declare function patchDocxLegacyTextEffects(buffer: ArrayBuffer, patches: readonly DocxLegacyTextEffectsPatch[]): Promise<ArrayBuffer>;

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

@@ -0,0 +1,12 @@
+import { type WorkDocumentLegacyTextEffects } from './work-document-legacy-text-effects';
+export type DocxLegacyTextEffectsInspection = {
+    status: 'absent';
+} | {
+    status: 'invalid';
+} | {
+    status: 'valid';
+    value: WorkDocumentLegacyTextEffects;
+};
+export declare function inspectDocxLegacyTextEffects(properties: Element | null | undefined): DocxLegacyTextEffectsInspection;
+export declare function docxLegacyTextEffectsFromProperties(properties: Element | null | undefined): WorkDocumentLegacyTextEffects | undefined;
+export declare function resolveDocxLegacyTextEffects(propertySources: readonly Element[]): WorkDocumentLegacyTextEffects | undefined;

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,32 @@
 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;
+    legacyTextOutline?: boolean;
+    legacyTextShadow?: boolean;
+    legacyTextEmboss?: boolean;
+    legacyTextImprint?: boolean;
     fontFamily?: string;
+    scriptFonts?: WorkDocumentScriptFonts;
+    scriptFontSlot?: WorkDocumentScriptFontSlot;
     wordLineHeightFactor?: number;
     wordSnapToGrid?: boolean;
     fontSize?: number;
@@ -17,6 +34,7 @@ export interface ImportedDocxRunFormatting {
     backgroundColor?: string;
     themeColor?: DocxThemeColorReference;
     themeFill?: DocxThemeColorReference;
+    textCase?: WorkDocumentTextCase;
 }
 export interface ImportedDocxRunFormattingMarker {
     startMarker: string;
@@ -33,7 +51,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-property-order.d.ts

@@ -0,0 +1,2 @@
+export declare const DOCX_RUN_PROPERTY_ORDER: readonly ["rStyle", "rFonts", "b", "bCs", "i", "iCs", "caps", "smallCaps", "strike", "dstrike", "outline", "shadow", "emboss", "imprint", "noProof", "snapToGrid", "vanish", "webHidden", "color", "spacing", "w", "kern", "position", "sz", "szCs", "highlight", "u", "effect", "bdr", "shd", "fitText", "vertAlign", "rtl", "cs", "em", "lang", "eastAsianLayout", "specVanish", "rPrChange"];
+export declare const DOCX_RUN_PROPERTY_RANK: Map<string, number>;

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;

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

@@ -5,6 +5,12 @@ export declare function parseDocxTwipsMeasure(source: string, options: {
     signed: boolean;
     strict: boolean;
 }): number | null;
+export declare function parseDocxHalfPointsMeasure(source: string, options: {
+    minimum: number;
+    maximum: number;
+    signed: boolean;
+    strict: boolean;
+}): number | null;
 export declare function parseBoundedDocxInteger(source: string, options: {
     minimum: number;
     maximum: number;

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

@@ -0,0 +1,3 @@
+import { type WorkDocumentUnderlineFormatting } from './work-document-underline';
+import { type DocxThemeResolver } from './work-docx-theme';
+export declare function importedDocxUnderline(element: Element, theme?: DocxThemeResolver): WorkDocumentUnderlineFormatting;

package/dist/internal/features/work/work-spreadsheet-gradient-fill-canvas.d.ts

@@ -0,0 +1,10 @@
+import type { XlsxGradientFill } from './work-xlsx-gradient-fill';
+export interface SpreadsheetGradientFillBounds {
+    endX: number;
+    endY: number;
+    startX: number;
+    startY: number;
+}
+type SpreadsheetGradientFillRect = CanvasRenderingContext2D['fillRect'];
+export declare function drawSpreadsheetGradientFill(context: CanvasRenderingContext2D, bounds: SpreadsheetGradientFillBounds, fill: XlsxGradientFill, fillRect?: SpreadsheetGradientFillRect): void;
+export {};

package/dist/internal/features/work/work-spreadsheet-native-fill-canvas.d.ts

@@ -0,0 +1,8 @@
+import type { XlsxNativeFill } from './work-xlsx-native-fill';
+/**
+ * Fortune Sheet paints a cell background immediately after beforeRenderCell.
+ * Intercepting only that first viewport paint keeps native fills behind text
+ * and avoids any fill work for cells outside the visible Canvas.
+ */
+export declare function beginSpreadsheetNativeFillRender(fill: XlsxNativeFill | undefined, context: CanvasRenderingContext2D): void;
+export declare function finishSpreadsheetNativeFillRender(context: CanvasRenderingContext2D): void;

package/dist/internal/features/work/work-spreadsheet-pattern-fill-canvas.d.ts

@@ -0,0 +1,8 @@
+import type { XlsxPatternFill } from './work-xlsx-pattern-fill';
+export interface SpreadsheetPatternFillBounds {
+    endX: number;
+    endY: number;
+    startX: number;
+    startY: number;
+}
+export declare function drawSpreadsheetPatternFillOverlay(context: CanvasRenderingContext2D, bounds: SpreadsheetPatternFillBounds, fill: XlsxPatternFill): void;

package/dist/internal/features/work/work-xlsx-cell-style-origin.d.ts

@@ -41,5 +41,6 @@ export declare function xlsxColorElementMatchesOrigin(element: Element | undefin
 export declare function applyXlsxSemanticColorOrigin(element: Element, origin: XlsxSemanticColorOrigin): void;
 export declare function xlsxSemanticColorOriginKey(origin: XlsxSemanticColorOrigin | undefined): string;
 export declare function xlsxSemanticColorOriginSupported(origin: XlsxSemanticColorOrigin, palette: XlsxSemanticPalette | undefined): boolean;
-export declare function prepareXlsxSemanticPalette(styles: Document, theme: Document | null, origins: Iterable<XlsxCellStyleOrigin>): PreparedXlsxSemanticPalette;
+export declare function prepareXlsxSemanticPalette(styles: Document, theme: Document | null, colors: Iterable<XlsxSemanticColorOrigin>): PreparedXlsxSemanticPalette;
+export declare function xlsxCellStyleOriginSemanticColors(origin: XlsxCellStyleOrigin): XlsxSemanticColorOrigin[];
 export declare function normalizeXlsxSemanticColorOrigin(value: unknown): XlsxSemanticColorOrigin | undefined;

package/dist/internal/features/work/work-xlsx-cell-style-writer.d.ts

@@ -18,6 +18,9 @@ export declare class XlsxDirectCellStyleWriter {
     styleId(baseStyleId: number, cell: Cell, border?: XlsxCellBorder): number;
     private fontId;
     private fillId;
+    private gradientFillId;
+    private exportGradientFill;
+    private fillColorElement;
     private borderId;
     private updateCounts;
 }

package/dist/internal/features/work/work-xlsx-cell-styles.d.ts

@@ -2,11 +2,15 @@ import type { Cell, Sheet } from '@fortune-sheet/core';
 import { type XlsxCellBorder } from './work-xlsx-cell-borders';
 import { type XlsxDirectCellStyleWriter } from './work-xlsx-cell-style-writer';
 import { type XlsxCellStyleOrigin } from './work-xlsx-cell-style-origin';
+import { type XlsxGradientFill } from './work-xlsx-gradient-fill';
+import { type XlsxPatternFill } from './work-xlsx-pattern-fill';
 export { XlsxDirectCellStyleWriter } from './work-xlsx-cell-style-writer';
 export interface XlsxDirectCellStyle {
     border?: XlsxCellBorder;
     column: number;
+    gradientFill?: XlsxGradientFill;
     origin?: XlsxCellStyleOrigin;
+    patternFill?: XlsxPatternFill;
     row: number;
     style: Partial<Cell>;
 }