@a3s-lab/office 0.10.0 → 0.12.0

package/dist/9356.js

@@ -1,10 +1,128 @@
-async function materializeWorkFile(file) {
-    const bytes = await file.arrayBuffer();
-    return new File([
-        bytes
-    ], file.name, {
-        lastModified: file.lastModified,
-        type: file.type
+const stageRanges = {
+    reading: [
+        0,
+        0.2
+    ],
+    parsing: [
+        0.2,
+        0.75
+    ],
+    analyzing: [
+        0.75,
+        0.95
+    ],
+    finalizing: [
+        0.95,
+        1
+    ]
+};
+class WorkFileImportController {
+    options;
+    totalBytes;
+    progress = 0;
+    constructor(options, totalBytes){
+        this.options = options;
+        this.totalBytes = totalBytes;
+    }
+    get signal() {
+        return this.options.signal;
+    }
+    throwIfAborted() {
+        if (!this.signal?.aborted) return;
+        throw workFileImportAbortError(this.signal.reason);
+    }
+    report(stage, stageProgress, bytesRead = this.totalBytes) {
+        this.throwIfAborted();
+        const boundedStageProgress = Math.max(0, Math.min(1, stageProgress));
+        const [start, end] = stageRanges[stage];
+        this.progress = Math.max(this.progress, start + (end - start) * boundedStageProgress);
+        this.options.onProgress?.({
+            stage,
+            stageProgress: boundedStageProgress,
+            progress: this.progress,
+            bytesRead: Math.max(0, Math.min(this.totalBytes, bytesRead)),
+            totalBytes: this.totalBytes
+        });
+        this.throwIfAborted();
+    }
+    async checkpoint(stage, stageProgress) {
+        this.report(stage, stageProgress);
+        await this.yieldToMainThread();
+    }
+    async yieldToMainThread() {
+        this.throwIfAborted();
+        await new Promise((resolve)=>setTimeout(resolve, 0));
+        this.throwIfAborted();
+    }
+    complete() {
+        this.report('finalizing', 1);
+    }
+}
+function workFileImportAbortError(reason) {
+    if (reason instanceof Error && 'AbortError' === reason.name) return reason;
+    if ("u" > typeof DOMException) return new DOMException('Office file import was cancelled.', 'AbortError');
+    const error = new Error('Office file import was cancelled.');
+    error.name = 'AbortError';
+    return error;
+}
+const WORK_FILE_READ_CHUNK_BYTES = 4194304;
+async function materializeWorkFile(file, controller = new WorkFileImportController({}, file.size)) {
+    return (await materializeWorkFileSource(file, controller)).file;
+}
+async function materializeWorkFileSource(file, controller) {
+    const bytes = await readWorkFileBytes(file, controller);
+    return {
+        bytes,
+        file: new File([
+            bytes
+        ], file.name, {
+            lastModified: file.lastModified,
+            type: file.type
+        })
+    };
+}
+async function readWorkFileBytes(file, controller) {
+    controller.report('reading', 0, 0);
+    if (file.size <= WORK_FILE_READ_CHUNK_BYTES) {
+        const bytes = await abortableArrayBuffer(file.arrayBuffer(), controller);
+        controller.report('reading', 1, bytes.byteLength);
+        return bytes;
+    }
+    const bytes = new Uint8Array(file.size);
+    for(let offset = 0; offset < file.size; offset += WORK_FILE_READ_CHUNK_BYTES){
+        controller.throwIfAborted();
+        const end = Math.min(file.size, offset + WORK_FILE_READ_CHUNK_BYTES);
+        const chunk = await abortableArrayBuffer(file.slice(offset, end).arrayBuffer(), controller);
+        bytes.set(new Uint8Array(chunk), offset);
+        controller.report('reading', end / file.size, end);
+        if (end < file.size) await controller.yieldToMainThread();
+    }
+    return bytes.buffer;
+}
+async function abortableArrayBuffer(pending, controller) {
+    controller.throwIfAborted();
+    const signal = controller.signal;
+    if (!signal) return pending;
+    return new Promise((resolve, reject)=>{
+        const abort = ()=>{
+            cleanup();
+            try {
+                controller.throwIfAborted();
+            } catch (error) {
+                reject(error);
+            }
+        };
+        const cleanup = ()=>signal.removeEventListener('abort', abort);
+        signal.addEventListener('abort', abort, {
+            once: true
+        });
+        pending.then((bytes)=>{
+            cleanup();
+            resolve(bytes);
+        }, (error)=>{
+            cleanup();
+            reject(error);
+        });
     });
 }
-export { materializeWorkFile };
+export { WorkFileImportController, materializeWorkFile, materializeWorkFileSource };

package/dist/core.d.ts

@@ -21,6 +21,7 @@ export type { WorkEditorAgentRequest as EditorAgentRequest } from './internal/fe
 export type { WorkDocumentReviewConflict as DocumentReviewConflict, WorkDocumentReviewConflictEvent as DocumentReviewConflictEvent, WorkDocumentReviewConflictReason as DocumentReviewConflictReason, WorkDocumentReviewKind as DocumentReviewKind, } from './internal/features/work/work-document-review-conflicts';
 export type { WorkDocumentSelectionCommandFailure as DocumentSelectionCommandFailure, WorkDocumentSelectionCommandResult as DocumentSelectionCommandResult, WorkDocumentSelectionCommands as DocumentSelectionCommands, WorkDocumentSelectionContext as DocumentSelectionContext, WorkDocumentSelectionMenuIcon as DocumentSelectionMenuIcon, WorkDocumentSelectionMenuItem as DocumentSelectionMenuItem, WorkDocumentSelectionSnapshot as DocumentSelectionSnapshot, WorkGetDocumentSelectionMenuItems as GetDocumentSelectionMenuItems, } from './internal/features/work/work-document-selection-menu';
 export type { WorkArtifactExportOptions as ArtifactExportOptions } from './internal/features/work/work-file-io';
+export type { WorkFileImportOptions as OfficeFileImportOptions, WorkFileImportProgress as OfficeFileImportProgress, WorkFileImportStage as OfficeFileImportStage, } from './internal/features/work/work-file-import';
 export { createWorkArtifactBlob as createArtifactBlob, exportWorkArtifact as downloadArtifact, importWorkFile as importOfficeFile, WORK_IMPORT_ACCEPT as OFFICE_FILE_ACCEPT, workKindForFile as officeKindForFile, } from './internal/features/work/work-file-io';
 export { decodeWorkDocumentSnapshot as decodeDocumentSnapshot, encodeWorkDocumentSnapshot as encodeDocumentSnapshot, WORK_DOCUMENT_SNAPSHOT_MEDIA_TYPE as DOCUMENT_SNAPSHOT_MEDIA_TYPE, WORK_DOCUMENT_SNAPSHOT_SCHEMA as DOCUMENT_SNAPSHOT_SCHEMA, WORK_DOCUMENT_SNAPSHOT_VERSION as DOCUMENT_SNAPSHOT_VERSION, type WorkDocumentSnapshot as DocumentSnapshot, } from './internal/features/work/work-document-snapshot';
 export { applyWorkDocumentSource as applyDocumentSource, projectWorkDocumentSource as projectDocumentSource, WORK_DOCUMENT_SOURCE_MEDIA_TYPE as DOCUMENT_SOURCE_MEDIA_TYPE, WORK_DOCUMENT_SOURCE_SCHEMA as DOCUMENT_SOURCE_SCHEMA, WORK_DOCUMENT_SOURCE_VERSION as DOCUMENT_SOURCE_VERSION, type WorkDocumentSource as DocumentSource, } from './internal/features/work/work-document-source';

package/dist/internal/features/work/editors/spreadsheet-editor-support.d.ts

@@ -21,6 +21,7 @@ export declare function spreadsheetFontSizeOptions(current: number | undefined):
 export declare function spreadsheetFontFamilyOptions(current: string | undefined): OfficeSelectOption[];
 export declare function spreadsheetSheetsWithFiniteSelections(sheets: WorkSpreadsheetContent['sheets']): WorkSpreadsheetContent['sheets'];
 export declare function spreadsheetSheetsForFortune(sheets: WorkSpreadsheetContent['sheets']): WorkSpreadsheetContent['sheets'];
+export declare function spreadsheetSheetsFromFortune(sheets: WorkSpreadsheetContent['sheets'], sourceSheets: WorkSpreadsheetContent['sheets']): WorkSpreadsheetContent['sheets'];
 export declare function finiteSpreadsheetSelection(selection: Selection | undefined): Selection;
 export declare function sameSpreadsheetWorkbookState(changed: WorkSpreadsheetContent['sheets'], rendered: WorkSpreadsheetContent['sheets']): boolean;
 export declare function sameSpreadsheetHistoryContent(left: WorkSpreadsheetContent, right: WorkSpreadsheetContent): boolean;

package/dist/internal/features/work/editors/use-spreadsheet-collaboration.d.ts

@@ -8,7 +8,7 @@ export interface SpreadsheetCollaborationHistory {
     undo: () => boolean;
 }
 export interface SpreadsheetCollaborationViewController {
-    activateSheet: (sheetId: string) => void;
+    activateSheet: (sheetId: string) => boolean;
     select: (sheetId: string, selection: Selection) => void;
     setZoom: (sheetId: string, zoomRatio: number) => void;
 }
@@ -21,6 +21,7 @@ export declare function useSpreadsheetCollaboration({ initialContent, onChange,
     content: WorkSpreadsheetContent;
     history: SpreadsheetCollaborationHistory;
     onChange: (next: WorkSpreadsheetContent) => void;
+    onDerivedChange: (next: WorkSpreadsheetContent) => void;
     readOnly: boolean;
     view: SpreadsheetCollaborationViewController;
 };

package/dist/internal/features/work/spreadsheet-sparse.d.ts

@@ -0,0 +1,5 @@
+import type { CellMatrix } from '@fortune-sheet/core';
+export declare function sparseArrayIndexes(values: readonly unknown[] | undefined): number[];
+export declare function sparseArrayEntries<T>(values: readonly T[] | undefined): Array<[number, T]>;
+export declare function sparseMatrixColumnCount(matrix: CellMatrix | undefined): number;
+export declare function cloneSparseMatrix(source: CellMatrix | undefined): CellMatrix;

package/dist/internal/features/work/work-document-file-io.d.ts

@@ -1,4 +1,5 @@
+import type { WorkFileImportContext } from './work-file-import';
 import type { WorkArtifact } from './work-types';
-export declare function importWorkDocumentFile(file: File, extension: string): Promise<WorkArtifact>;
+export declare function importWorkDocumentFile(file: File, extension: string, context?: WorkFileImportContext): Promise<WorkArtifact>;
 export declare function exportWorkDocumentArtifact(artifact: WorkArtifact): Promise<void>;
 export declare function createWorkDocumentBlob(artifact: WorkArtifact): Promise<Blob>;

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

@@ -3,7 +3,7 @@ import type { EditorState, PluginKey, Transaction } from '@tiptap/pm/state';
 import type { WorkDocumentChangeIdentity } from './work-document-changes';
 interface DocumentFormattingChangeTrackingOptions {
     isTracking: () => boolean;
-    createChange: () => WorkDocumentChangeIdentity;
+    createChange: (kind: 'formatting' | 'paragraph-formatting') => WorkDocumentChangeIdentity;
 }
 export declare function trackDocumentFormattingTransaction(transaction: Transaction, state: EditorState, type: ProseMirrorMark['type'], options: DocumentFormattingChangeTrackingOptions, pluginKey: PluginKey): void;
 export {};

package/dist/internal/features/work/work-document-paragraph-format-change-tracking.d.ts

@@ -0,0 +1,7 @@
+import type { EditorState, Transaction } from '@tiptap/pm/state';
+import type { WorkDocumentChangeIdentity } from './work-document-changes';
+interface DocumentParagraphFormattingTrackingOptions {
+    createChange: () => WorkDocumentChangeIdentity;
+}
+export declare function trackDocumentParagraphFormattingTransaction(transaction: Transaction, state: EditorState, options: DocumentParagraphFormattingTrackingOptions): boolean;
+export {};

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

@@ -0,0 +1,8 @@
+export declare const DOCUMENT_PARAGRAPH_CHANGE_ATTRIBUTES: readonly ["paragraphChangeKind", "paragraphChangeId", "paragraphChangeActorId", "paragraphChangeAuthor", "paragraphChangeDate", "paragraphChangeBefore"];
+export declare const DOCUMENT_PARAGRAPH_FORMAT_ATTRIBUTES: readonly ["textAlign", "paragraphDirection", "indentLevel", "rightIndent", "firstLineIndent", "spaceBefore", "spaceAfter", "lineHeight", "lineRule", "autoLineHeight", "keepLines", "keepWithNext", "pageBreakBefore", "widowControl", "contextualSpacing", "outlineLevel", "tabStops", "paragraphBorders", "paragraphShading", "defaultCollapsed"];
+export type DocumentParagraphFormatAttribute = (typeof DOCUMENT_PARAGRAPH_FORMAT_ATTRIBUTES)[number];
+export type DocumentParagraphFormattingSnapshot = Record<DocumentParagraphFormatAttribute, unknown>;
+export declare function serializeDocumentParagraphFormatting(attributes: Record<string, unknown>): string;
+export declare function parseDocumentParagraphFormatting(value: unknown): DocumentParagraphFormattingSnapshot | null;
+export declare function restoredDocumentParagraphAttributes(attributes: Record<string, unknown>, serialized: unknown): Record<string, unknown> | null;
+export declare function clearDocumentParagraphChangeAttributes(attributes: Record<string, unknown>): Record<string, unknown>;

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

@@ -10,6 +10,7 @@ import { type ImportedDocxListMarkers } from './work-docx-list-import';
 import { type ImportedDocxParagraphAlignmentMarkers } from './work-docx-paragraph-alignment-import';
 import { type ImportedDocxParagraphDirectionMarkers } from './work-docx-paragraph-direction-import';
 import { type ImportedDocxParagraphIdentityMarkers } from './work-docx-paragraph-identity-import';
+import { type ImportedDocxParagraphFormattingChangeMarkers } from './work-docx-paragraph-format-change-import';
 import { type ImportedDocxParagraphIndentMarkers } from './work-docx-paragraph-indent-import';
 import { type ImportedDocxParagraphPaginationMarkers } from './work-docx-paragraph-pagination-import';
 import { type ImportedDocxParagraphBorderMarkers } from './work-docx-paragraph-borders-import';
@@ -20,6 +21,7 @@ import { type ImportedDocxParagraphTabStopMarkers } from './work-docx-tab-stop-i
 import { type ImportedDocxTableCellMarkers } from './work-docx-table-cell-import';
 import { type ImportedDocxTableRowMarkers } from './work-docx-table-row-import';
 import { type ImportedDocxTableSizingMarkers } from './work-docx-table-sizing-import';
+import { OoxmlPackage } from './work-ooxml-package';
 import type { WorkDocumentContent, WorkDocumentSectionLayout } from './work-types';
 type ImportedDocumentLayout = Omit<WorkDocumentContent, 'type' | 'html'>;
 export interface PreparedDocxImport {
@@ -39,6 +41,7 @@ export interface PreparedDocxImport {
     listMarkers: ImportedDocxListMarkers;
     imageLayoutMarkers: ImportedDocxImageLayoutMarkers;
     paragraphIdentityMarkers: ImportedDocxParagraphIdentityMarkers;
+    paragraphFormattingChangeMarkers: ImportedDocxParagraphFormattingChangeMarkers;
     paragraphAlignmentMarkers: ImportedDocxParagraphAlignmentMarkers;
     paragraphDirectionMarkers: ImportedDocxParagraphDirectionMarkers;
     paragraphIndentMarkers: ImportedDocxParagraphIndentMarkers;
@@ -54,7 +57,7 @@ export interface PreparedDocxImport {
     bibliography?: WorkDocumentContent['bibliography'];
     trackChanges: boolean;
 }
-export declare function prepareDocxImport(buffer: ArrayBuffer): 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, 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 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 readDocxLayout(buffer: ArrayBuffer): Promise<ImportedDocumentLayout>;
 export {};

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

@@ -11,3 +11,4 @@ export interface ImportedDocxParagraphAlignmentMarkers {
 export declare function markDocxParagraphAlignments(document: Document, styleSource?: DocxParagraphStyleSource, tableStyleSource?: DocxTableStyleSource): ImportedDocxParagraphAlignmentMarkers;
 export declare function applyImportedDocxParagraphAlignmentMarkers(document: Document, markers: ImportedDocxParagraphAlignmentMarkers): void;
 export declare function hasImportedDocxParagraphAlignmentMarkers(markers: ImportedDocxParagraphAlignmentMarkers): boolean;
+export declare function resolveDocxParagraphAlignment(propertySources: readonly Element[]): ImportedDocxParagraphAlignment | null;

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

@@ -18,6 +18,7 @@ export interface ResolvedDocxParagraphBorders {
 }
 export declare function markDocxParagraphBorders(document: Document, styleSource?: DocxParagraphStyleSource, themeSource?: DocxThemeSource, tableStyleSource?: DocxTableStyleSource): ImportedDocxParagraphBorderMarkers;
 export declare function resolveDocxParagraphBordersForParagraph(paragraph: Element, styleSource?: DocxParagraphStyleSource, themeSource?: DocxThemeSource, tableStyleSource?: DocxTableStyleSource): ResolvedDocxParagraphBorders;
+export declare function resolveDocxParagraphBordersFromSources(propertySources: readonly Element[], themeSource?: DocxThemeSource): ResolvedDocxParagraphBorders;
 export declare function applyImportedDocxParagraphBorderMarkers(document: Document, markers: ImportedDocxParagraphBorderMarkers): void;
 export declare function hasImportedDocxParagraphBorderMarkers(markers: ImportedDocxParagraphBorderMarkers): boolean;
 export declare function parseDirectDocxParagraphBorders(properties: Element, themeSource?: DocxThemeSource): DocumentParagraphBorders | null | undefined;

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

@@ -11,3 +11,4 @@ export interface ImportedDocxParagraphDirectionMarkers {
 export declare function markDocxParagraphDirections(document: Document, styleSource?: DocxParagraphStyleSource, tableStyleSource?: DocxTableStyleSource): ImportedDocxParagraphDirectionMarkers;
 export declare function applyImportedDocxParagraphDirectionMarkers(document: Document, markers: ImportedDocxParagraphDirectionMarkers): void;
 export declare function hasImportedDocxParagraphDirectionMarkers(markers: ImportedDocxParagraphDirectionMarkers): boolean;
+export declare function resolveDocxParagraphDirection(propertySources: readonly Element[]): DocumentParagraphDirection | null;

package/dist/internal/features/work/work-docx-paragraph-format-change-export.d.ts

@@ -0,0 +1,13 @@
+interface DocxParagraphFormattingChangePatch {
+    marker: string;
+    id: number;
+    author: string;
+    date: string;
+    before: string;
+}
+export declare class DocxParagraphFormattingChangePatchCollector {
+    readonly patches: DocxParagraphFormattingChangePatch[];
+    register(element: HTMLElement, id: number): string | null;
+}
+export declare function patchDocxParagraphFormattingChanges(buffer: ArrayBuffer, patches: readonly DocxParagraphFormattingChangePatch[]): Promise<ArrayBuffer>;
+export {};

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

@@ -0,0 +1,17 @@
+import { type DocxParagraphStyleSource } from './work-docx-paragraph-styles';
+import { type DocxTableStyleSource } from './work-docx-table-styles';
+import { type DocxThemeSource } from './work-docx-theme';
+export interface ImportedDocxParagraphFormattingChangeMarker {
+    marker: string;
+    id: string;
+    author: string;
+    date: string;
+    before: string;
+}
+export interface ImportedDocxParagraphFormattingChangeMarkers {
+    paragraphs: ImportedDocxParagraphFormattingChangeMarker[];
+}
+export declare function markDocxParagraphFormattingChanges(document: Document, styleSource?: DocxParagraphStyleSource, themeSource?: DocxThemeSource, tableStyleSource?: DocxTableStyleSource): ImportedDocxParagraphFormattingChangeMarkers;
+export declare function applyImportedDocxParagraphFormattingChangeMarkers(document: Document, markers: ImportedDocxParagraphFormattingChangeMarkers): void;
+export declare function hasImportedDocxParagraphFormattingChangeMarkers(markers: ImportedDocxParagraphFormattingChangeMarkers): boolean;
+export declare function isSupportedDocxParagraphFormattingChange(change: Element): boolean;

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

@@ -11,3 +11,4 @@ export interface ImportedDocxParagraphIndentMarkers {
 export declare function markDocxParagraphIndents(document: Document, styleSource?: DocxParagraphStyleSource, tableStyleSource?: DocxTableStyleSource): ImportedDocxParagraphIndentMarkers;
 export declare function applyImportedDocxParagraphIndentMarkers(document: Document, markers: ImportedDocxParagraphIndentMarkers): void;
 export declare function hasImportedDocxParagraphIndentMarkers(markers: ImportedDocxParagraphIndentMarkers): boolean;
+export declare function resolveDocxParagraphIndent(propertySources: readonly Element[]): DocumentParagraphIndent;

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

@@ -16,3 +16,4 @@ export interface ImportedDocxParagraphPaginationMarkers {
 export declare function markDocxParagraphPagination(document: Document, styleSource?: DocxParagraphStyleSource, tableStyleSource?: DocxTableStyleSource): ImportedDocxParagraphPaginationMarkers;
 export declare function applyImportedDocxParagraphPaginationMarkers(document: Document, markers: ImportedDocxParagraphPaginationMarkers): void;
 export declare function hasImportedDocxParagraphPaginationMarkers(markers: ImportedDocxParagraphPaginationMarkers): boolean;
+export declare function resolveDocxParagraphPagination(sources: readonly Element[]): ImportedDocxParagraphPagination;

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

@@ -16,3 +16,4 @@ export declare function applyImportedDocxParagraphShadingMarkers(document: Docum
 export declare function hasImportedDocxParagraphShadingMarkers(markers: ImportedDocxParagraphShadingMarkers): boolean;
 export declare function parseDocxParagraphShadingElement(element: Element, themeSource?: DocxThemeSource): DocumentParagraphShading | null;
 export declare function parseDirectDocxParagraphShading(properties: Element, themeSource?: DocxThemeSource): DocumentParagraphShading | null | undefined;
+export declare function resolveDocxParagraphShadingFromSources(propertySources: readonly Element[], themeSource?: DocxThemeSource): DocumentParagraphShading | null;

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

@@ -11,3 +11,4 @@ export interface ImportedDocxParagraphSpacingMarkers {
 export declare function markDocxParagraphSpacing(document: Document, styleSource?: DocxParagraphStyleSource, tableStyleSource?: DocxTableStyleSource): ImportedDocxParagraphSpacingMarkers;
 export declare function applyImportedDocxParagraphSpacingMarkers(document: Document, markers: ImportedDocxParagraphSpacingMarkers): void;
 export declare function hasImportedDocxParagraphSpacingMarkers(markers: ImportedDocxParagraphSpacingMarkers): boolean;
+export declare function resolveDocxParagraphSpacing(propertySources: readonly Element[]): Partial<DocumentParagraphSpacing>;

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

@@ -12,3 +12,4 @@ export interface ImportedDocxParagraphTabStopMarkers {
 export declare function markDocxParagraphTabStops(document: Document, styleSource?: DocxParagraphStyleSource, tableStyleSource?: DocxTableStyleSource): ImportedDocxParagraphTabStopMarkers;
 export declare function applyImportedDocxParagraphTabStopMarkers(document: Document, markers: ImportedDocxParagraphTabStopMarkers): void;
 export declare function hasImportedDocxParagraphTabStopMarkers(markers: ImportedDocxParagraphTabStopMarkers): boolean;
+export declare function resolveDocxParagraphTabStops(sources: readonly Element[]): DocumentTabStop[];

package/dist/internal/features/work/work-file-data.d.ts

@@ -1 +1,7 @@
-export declare function materializeWorkFile(file: File): Promise<File>;
+import { WorkFileImportController } from './work-file-import';
+export interface MaterializedWorkFile {
+    bytes: ArrayBuffer;
+    file: File;
+}
+export declare function materializeWorkFile(file: File, controller?: WorkFileImportController): Promise<File>;
+export declare function materializeWorkFileSource(file: File, controller: WorkFileImportController): Promise<MaterializedWorkFile>;

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

@@ -0,0 +1,28 @@
+export type WorkFileImportStage = 'reading' | 'parsing' | 'analyzing' | 'finalizing';
+export interface WorkFileImportProgress {
+    stage: WorkFileImportStage;
+    stageProgress: number;
+    progress: number;
+    bytesRead: number;
+    totalBytes: number;
+}
+export interface WorkFileImportOptions {
+    signal?: AbortSignal;
+    onProgress?: (progress: WorkFileImportProgress) => void;
+}
+export interface WorkFileImportContext {
+    bytes: ArrayBuffer;
+    controller: WorkFileImportController;
+}
+export declare class WorkFileImportController {
+    private readonly options;
+    readonly totalBytes: number;
+    private progress;
+    constructor(options: WorkFileImportOptions, totalBytes: number);
+    get signal(): AbortSignal | undefined;
+    throwIfAborted(): void;
+    report(stage: WorkFileImportStage, stageProgress: number, bytesRead?: number): void;
+    checkpoint(stage: WorkFileImportStage, stageProgress: number): Promise<void>;
+    yieldToMainThread(): Promise<void>;
+    complete(): void;
+}

package/dist/internal/features/work/work-file-io.d.ts

@@ -1,8 +1,9 @@
 export { WORK_IMPORT_ACCEPT } from './work-file-contract';
+import { type WorkFileImportOptions } from './work-file-import';
 import { type WorkPresentationExportOptions } from './work-presentation-file-io';
 import { type WorkArtifact, type WorkArtifactKind } from './work-types';
 export type WorkArtifactExportOptions = WorkPresentationExportOptions;
-export declare function importWorkFile(file: File): Promise<WorkArtifact>;
+export declare function importWorkFile(file: File, options?: WorkFileImportOptions): Promise<WorkArtifact>;
 export declare function exportWorkArtifact(artifact: WorkArtifact, options?: WorkArtifactExportOptions): Promise<void>;
 export declare function createWorkArtifactBlob(artifact: WorkArtifact, options?: WorkArtifactExportOptions): Promise<Blob>;
 export declare function workKindForFile(file: File): WorkArtifactKind | null;

package/dist/internal/features/work/work-markdown-file-io.d.ts

@@ -1,3 +1,4 @@
+import type { WorkFileImportContext } from './work-file-import';
 import type { WorkArtifact } from './work-types';
-export declare function importWorkMarkdownFile(file: File): Promise<WorkArtifact>;
+export declare function importWorkMarkdownFile(file: File, context?: WorkFileImportContext): Promise<WorkArtifact>;
 export declare function createWorkMarkdownBlob(artifact: WorkArtifact): Blob;

package/dist/internal/features/work/work-office-diagnostics.d.ts

@@ -1,9 +1,10 @@
 import type { WorkBook } from 'xlsx';
+import { OoxmlPackage } from './work-ooxml-package';
 import type { WorkCompatibilityReport } from './work-types';
 interface ConversionMessage {
     type: string;
     message: string;
 }
-export declare function analyzeDocxCompatibility(file: File, messages: ConversionMessage[]): Promise<WorkCompatibilityReport>;
-export declare function analyzeSpreadsheetCompatibility(file: File, extension: string, workbook: WorkBook): Promise<WorkCompatibilityReport | null>;
+export declare function analyzeDocxCompatibility(file: File, messages: ConversionMessage[], sourcePackage?: OoxmlPackage | null): Promise<WorkCompatibilityReport>;
+export declare function analyzeSpreadsheetCompatibility(file: File, extension: string, workbook: WorkBook, sourcePackage?: OoxmlPackage | null): Promise<WorkCompatibilityReport | null>;
 export {};

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

@@ -3,4 +3,4 @@ export interface PptxImportResult {
     content: WorkPresentationContent;
     compatibility: WorkCompatibilityReport;
 }
-export declare function importPptxPresentation(file: File): Promise<PptxImportResult>;
+export declare function importPptxPresentation(file: File, sourceBytes?: ArrayBuffer): Promise<PptxImportResult>;

package/dist/internal/features/work/work-presentation-file-io.d.ts

@@ -1,3 +1,4 @@
+import type { WorkFileImportContext } from './work-file-import';
 import type { WorkArtifact } from './work-types';
 type PptxConstructor = typeof import('pptxgenjs').default;
 declare global {
@@ -9,7 +10,7 @@ export interface WorkPresentationExportOptions {
     pptxRuntimeUrl?: string;
 }
 export declare const defaultPptxRuntimeUrl: string;
-export declare function importWorkPresentationFile(file: File): Promise<WorkArtifact>;
+export declare function importWorkPresentationFile(file: File, context?: WorkFileImportContext): Promise<WorkArtifact>;
 export declare function exportWorkPresentationArtifact(artifact: WorkArtifact, options?: WorkPresentationExportOptions): Promise<void>;
 export declare function createWorkPresentationBlob(artifact: WorkArtifact, options?: WorkPresentationExportOptions): Promise<Blob>;
 export {};

package/dist/internal/features/work/work-spreadsheet-protection.d.ts

@@ -27,6 +27,7 @@ export interface FortuneSheetProtectionAuthority {
     hintText: string;
     defaultSheetHintText: string;
     allowRangeList: FortuneSheetEditableRange[];
+    cellProtectionRanges: SpreadsheetCellProtectionRange[];
     xlsxAttributes?: Record<string, string>;
 }
 export interface SpreadsheetCellProtectionRange {
@@ -37,6 +38,7 @@ export interface SpreadsheetCellProtectionRange {
 export declare function defaultSheetProtectionAuthority(enabled?: boolean): FortuneSheetProtectionAuthority;
 export declare function sheetProtectionAuthority(sheet: Sheet): FortuneSheetProtectionAuthority;
 export declare function normalizeSheetProtectionAuthority(source: unknown): FortuneSheetProtectionAuthority;
+export declare function importedSheetProtectionAuthority(authority: FortuneSheetProtectionAuthority | undefined, cellProtectionRanges: SpreadsheetCellProtectionRange[]): FortuneSheetProtectionAuthority | undefined;
 export declare function withSheetProtection(sheet: Sheet, enabled: boolean): Sheet;
 export declare function withSheetSelectionPermissions(sheet: Sheet, permissions: {
     selectLockedCells?: boolean;

package/dist/internal/features/work/work-types.d.ts

@@ -106,7 +106,7 @@ export interface WorkDocumentContent {
     comments?: WorkDocumentComment[];
     bibliography?: WorkDocumentBibliography;
 }
-export type WorkDocumentChangeKind = 'insertion' | 'deletion' | 'formatting';
+export type WorkDocumentChangeKind = 'insertion' | 'deletion' | 'formatting' | 'paragraph-formatting';
 export type WorkDocumentChangeDecisionAction = 'accept' | 'reject';
 /**
  * Immutable audit record created when an editor accepts or rejects one
@@ -192,11 +192,33 @@ export interface WorkSpreadsheetContent {
     pageBreaks?: WorkSpreadsheetPageBreaks[];
     pageSetups?: WorkSpreadsheetPageSetup[];
 }
+export interface WorkSpreadsheetCellRange {
+    row: [number, number];
+    column: [number, number];
+}
+export interface WorkSpreadsheetDataValidationItem {
+    type: string;
+    type2: string;
+    rangeTxt: string;
+    value1: string;
+    value2: string;
+    validity: string;
+    remote: boolean;
+    prohibitInput: boolean;
+    hintShow: boolean;
+    hintValue: string;
+    checked?: boolean;
+}
+export interface WorkSpreadsheetDataValidationRange {
+    ranges: WorkSpreadsheetCellRange[];
+    item: WorkSpreadsheetDataValidationItem;
+}
 export type WorkSpreadsheetSheet = Omit<Sheet, 'images'> & {
     images?: WorkSpreadsheetImage[];
     charts?: WorkSpreadsheetChart[];
     pivotTables?: WorkSpreadsheetPivotTable[];
     formulaMetadata?: WorkSpreadsheetFormulaMetadata;
+    dataValidationRanges?: WorkSpreadsheetDataValidationRange[];
 };
 export type WorkSpreadsheetPivotAggregation = 'sum' | 'count' | 'counta' | 'average' | 'max' | 'min' | 'product' | 'stdDev' | 'stdDevP' | 'var' | 'varP';
 export interface WorkSpreadsheetPivotValue {

package/dist/internal/features/work/work-xlsx-interop.d.ts

@@ -1,11 +1,12 @@
 import type { Sheet } from '@fortune-sheet/core';
+import { OoxmlPackage } from './work-ooxml-package';
 import { type FortuneConditionalFormatRule } from './work-xlsx-conditional-format';
 import { type XlsxProtectionFeatures } from './work-xlsx-protection';
 import { type XlsxManualPageBreaks } from './work-xlsx-page-breaks';
 import { type XlsxWorksheetChart } from './work-xlsx-charts';
 import { type XlsxWorksheetImage } from './work-xlsx-images';
 import { type XlsxPageSetup } from './work-xlsx-page-setup';
-import type { WorkSpreadsheetContent } from './work-types';
+import type { WorkSpreadsheetContent, WorkSpreadsheetDataValidationItem } from './work-types';
 type FrozenPane = NonNullable<Sheet['frozen']>;
 export interface XlsxDataValidation {
     references: string[];
@@ -21,19 +22,8 @@ export interface XlsxSheetFeatures {
     images: XlsxWorksheetImage[];
     charts: XlsxWorksheetChart[];
 }
-export interface FortuneDataValidationItem {
-    type: string;
-    type2: string;
-    rangeTxt: string;
-    value1: string;
-    value2: string;
-    validity: string;
-    remote: boolean;
-    prohibitInput: boolean;
-    hintShow: boolean;
-    hintValue: string;
-    checked?: boolean;
-}
+export type FortuneDataValidationItem = WorkSpreadsheetDataValidationItem;
 export declare function readXlsxSheetFeatures(buffer: ArrayBuffer): Promise<Map<string, XlsxSheetFeatures>>;
+export declare function readXlsxSheetFeaturesFromPackage(archive: OoxmlPackage): Promise<Map<string, XlsxSheetFeatures>>;
 export declare function patchXlsxSheetFeatures(buffer: ArrayBuffer, content: WorkSpreadsheetContent): Promise<ArrayBuffer>;
 export {};

package/dist/styles.css

@@ -9082,6 +9082,10 @@ button.work-office-collaboration-participant:hover .work-office-collaboration-lo
   text-decoration: none;
 }
 
+.work-document-editor :is(p, h1, h2, h3, h4, h5, h6)[data-document-change][data-change-kind="paragraph-formatting"], .work-pdf-export-page.document :is(p, h1, h2, h3, h4, h5, h6)[data-document-change][data-change-kind="paragraph-formatting"] {
+  box-shadow: inset 3px 0 #8b5cf6;
+}
+
 .work-document-list-tools {
   align-items: center;
   gap: 2px;
@@ -12039,6 +12043,10 @@ button.work-office-collaboration-participant:hover .work-office-collaboration-lo
   border-left: 3px solid #6d5bd0;
 }
 
+.work-document-change-decisions li[data-document-change-kind="paragraph-formatting"] {
+  border-left: 3px solid #8b5cf6;
+}
+
 .work-document-change-decisions li > strong {
   text-overflow: ellipsis;
   white-space: nowrap;

package/docs/latest/en/browser-editor-architecture.md

@@ -222,6 +222,18 @@ rejecting every revision requires confirmation, and an empty revision pane does
 not retain disabled bulk controls. Deleting a comment confirms that its thread
 and any unsent reply will also be removed.
 
+Paragraph formatting is a node-level review concern rather than an inline
+mark. When tracking is active, one formatting transaction compares the complete
+canonical paragraph-property set before and after each affected paragraph or
+heading. A changed set receives one shared `paragraph-formatting` identity and
+the first complete prior snapshot; later edits retain that original review
+baseline. Accept clears only the revision attributes. Reject restores the
+validated snapshot without changing child content. Both decisions are atomic
+across every node with the same identity and have their own undo boundary.
+DOCX import/export maps that model to strict or transitional `w:pPrChange`,
+while Yjs stores the same node attributes and immutable decision audit without a
+parallel transport model.
+
 Selected document text has a typed host-owned context-menu boundary.
 `getSelectionMenuItems` receives an immutable snapshot containing the selected
 plain text and structured fragment, bounded adjacent text, synchronized HTML,
@@ -350,6 +362,12 @@ real DOCX with 120 native OOXML insertions and proves bounded mounting,
 first/last focus, the 120-to-119 decision transition, spacer geometry, and zero
 console or page errors.
 
+The public formatting fixture also exercises the non-windowed review boundary
+with independent character- and paragraph-formatting cards. Focused A3S Test
+suites reject each kind separately, verify that text and the other revision
+remain intact, and prove full paragraph alignment, indentation, spacing, and
+line-height restoration with clean browser diagnostics.
+
 Spreadsheet now uses a persistent browser Rust/WASM calculation session. The
 editor initializes it with a sparse workbook replacement, sends bounded cell
 patches from stable Fortune cell operations, and requests only the dirty