@a3s-lab/office 0.12.0 → 0.13.0

package/dist/internal/features/work/work-spreadsheet-matrix-profile.d.ts

@@ -0,0 +1,64 @@
+import type { Cell, CellMatrix } from '@fortune-sheet/core';
+export declare const SPREADSHEET_SHOWN_COMMENT_CELLS_PROPERTY = "__a3sShownCommentCells";
+export interface SpreadsheetMatrixProfile {
+    columnCount: number;
+    formulaCells: readonly Readonly<{
+        column: number;
+        row: number;
+    }>[];
+    fortuneReady: boolean;
+    historyRoot: object;
+    historyState: object;
+    populatedCellCount: number;
+    protectionCellKey: string;
+    rowCount: number;
+    shownCommentCells: readonly Readonly<{
+        c: number;
+        r: number;
+    }>[];
+}
+export interface SpreadsheetMatrixCellChange {
+    column: number;
+    current: Cell | null | undefined;
+    previous: Cell | null | undefined;
+    row: number;
+}
+interface ImportedSpreadsheetMatrixOptions {
+    columnCount: number;
+    formulaCells: readonly Readonly<{
+        column: number;
+        row: number;
+    }>[];
+    fortuneReady: boolean;
+    populatedCellCount: number;
+    protectionCellKey: string;
+    rowCount: number;
+    shownCommentCells: readonly Readonly<{
+        c: number;
+        r: number;
+    }>[];
+}
+/**
+ * Freezes a package-owned import cell before it becomes controlled content.
+ * Fortune can then share the cell as an Immer base value without recursively
+ * freezing or cloning every populated cell during editor initialization.
+ */
+export declare function freezeImportedSpreadsheetCell(cell: Cell): Cell;
+/**
+ * Authenticates a normalized, package-owned matrix for clone-free projection.
+ * The registry is identity-based, so an edited or host-created matrix cannot
+ * accidentally inherit the optimization.
+ */
+export declare function registerImportedSpreadsheetMatrix(data: CellMatrix, options: ImportedSpreadsheetMatrixOptions): void;
+/**
+ * Carries import-time summaries across a bounded cell edit without rescanning
+ * the complete matrix. The source identity must have been authenticated by
+ * this package and must already be directly consumable by Fortune.
+ */
+export declare function registerDerivedSpreadsheetMatrix(data: CellMatrix, source: CellMatrix, changes: readonly SpreadsheetMatrixCellChange[]): boolean;
+export declare function spreadsheetMatrixProfile(data: CellMatrix | undefined): SpreadsheetMatrixProfile | undefined;
+export declare function attachSpreadsheetShownCommentCells(data: CellMatrix, cells: readonly Readonly<{
+    c: number;
+    r: number;
+}>[]): void;
+export {};

package/dist/internal/features/work/work-spreadsheet-package-scan-worker-client.d.ts

@@ -0,0 +1,6 @@
+import type { SpreadsheetPackageScanResult } from './work-spreadsheet-package-scan-worker-protocol';
+/**
+ * Decompresses and classifies worksheet XML away from the UI thread. A null
+ * result preserves the existing main-thread parser as a compatibility path.
+ */
+export declare function scanSpreadsheetPackageInWorker(bytes: ArrayBuffer, signal?: AbortSignal, onFastPathCandidate?: () => void): Promise<SpreadsheetPackageScanResult | null>;

package/dist/internal/features/work/work-spreadsheet-package-scan-worker-protocol.d.ts

@@ -0,0 +1,49 @@
+import type { CellMatrix } from '@fortune-sheet/core';
+import type { WorkBook } from 'xlsx';
+import type { SpreadsheetImportWorkbookMetadata } from './work-spreadsheet-import-worker-protocol';
+import type { PlainXlsxCellChunk } from './work-xlsx-plain-fast-path';
+import type { XlsxWorksheetXmlScan } from './work-xlsx-worksheet-scan';
+export interface SpreadsheetPackageScanWorkerRequest {
+    bytes: ArrayBuffer;
+    kind: 'scan';
+}
+export interface SpreadsheetPackageScanResult {
+    plainWorksheets: Record<string, SpreadsheetPlainWorksheet> | null;
+    workbook: WorkBook | null;
+    worksheets: Record<string, XlsxWorksheetXmlScan>;
+}
+export interface SpreadsheetPlainWorksheet {
+    columnCount: number;
+    data: CellMatrix;
+    populatedCellCount: number;
+    rowCount: number;
+}
+export type SpreadsheetPackageScanWorkerResponse = {
+    kind: 'workbook';
+    workbook: SpreadsheetImportWorkbookMetadata;
+} | {
+    columnCount: number;
+    kind: 'plain-worksheet-start';
+    name: string;
+    rowCount: number;
+} | {
+    columnCount: number;
+    dense: true;
+    kind: 'worksheet';
+    name: string;
+    populatedCellCount: number;
+    properties: Record<string, unknown>;
+    rowCount: number;
+} | {
+    chunk: PlainXlsxCellChunk;
+    kind: 'plain-cells';
+    name: string;
+} | {
+    kind: 'fast-path-rejected';
+} | {
+    fastPath: boolean;
+    kind: 'success';
+    worksheets: SpreadsheetPackageScanResult['worksheets'];
+} | {
+    kind: 'failure';
+};

package/dist/internal/features/work/work-spreadsheet-package-scan.worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/internal/features/work/work-xlsx-formula-diagnostics.d.ts

@@ -1,3 +1,5 @@
 import type { OoxmlPackage } from './work-ooxml-package';
 import type { WorkCompatibilityIssue } from './work-types';
-export declare function diagnoseXlsxFormulas(archive: OoxmlPackage): Promise<WorkCompatibilityIssue[]>;
+import { type XlsxFormulaFeatures } from './work-xlsx-formulas';
+import type { XlsxWorksheetXmlScan } from './work-xlsx-worksheet-scan';
+export declare function diagnoseXlsxFormulas(archive: OoxmlPackage, importedFeatures?: XlsxFormulaFeatures | null, worksheetScans?: Readonly<Record<string, XlsxWorksheetXmlScan>>): Promise<WorkCompatibilityIssue[]>;

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

@@ -2,6 +2,7 @@ import type { Cell } from '@fortune-sheet/core';
 import type { WorkSheet } from 'xlsx';
 import { OoxmlPackage } from './work-ooxml-package';
 import type { WorkSpreadsheetCalculationSettings, WorkSpreadsheetContent, WorkSpreadsheetFormulaMetadata, WorkSpreadsheetFormulaRange, WorkSpreadsheetSheet } from './work-types';
+import type { XlsxWorksheetXmlScan } from './work-xlsx-worksheet-scan';
 export interface XlsxFormulaCell {
     address: string;
     formula: string;
@@ -29,7 +30,7 @@ type XlsxFormulaCellObject = {
     D?: boolean;
 };
 export declare function readXlsxFormulaFeatures(buffer: ArrayBuffer): Promise<XlsxFormulaFeatures>;
-export declare function readXlsxFormulaFeaturesFromPackage(archive: OoxmlPackage): Promise<XlsxFormulaFeatures>;
+export declare function readXlsxFormulaFeaturesFromPackage(archive: OoxmlPackage, worksheetScans?: Readonly<Record<string, XlsxWorksheetXmlScan>>): Promise<XlsxFormulaFeatures>;
 export declare function createSpreadsheetFormulaMetadata(worksheet: WorkSheet, features: XlsxFormulaSheetFeatures | undefined): WorkSpreadsheetFormulaMetadata | undefined;
 export declare function createXlsxFormulaCell(cell: Cell, row: number, column: number, sheet: WorkSpreadsheetSheet): XlsxFormulaCellObject;
 export declare function createXlsxErrorCell(cell: Cell): {

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

@@ -1,12 +1,13 @@
 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 { WorkSpreadsheetContent, WorkSpreadsheetDataValidationItem } from './work-types';
 import { type XlsxWorksheetChart } from './work-xlsx-charts';
+import { type FortuneConditionalFormatRule } from './work-xlsx-conditional-format';
 import { type XlsxWorksheetImage } from './work-xlsx-images';
+import { type XlsxManualPageBreaks } from './work-xlsx-page-breaks';
 import { type XlsxPageSetup } from './work-xlsx-page-setup';
-import type { WorkSpreadsheetContent, WorkSpreadsheetDataValidationItem } from './work-types';
+import { type XlsxProtectionFeatures } from './work-xlsx-protection';
+import type { XlsxWorksheetXmlScan } from './work-xlsx-worksheet-scan';
 type FrozenPane = NonNullable<Sheet['frozen']>;
 export interface XlsxDataValidation {
     references: string[];
@@ -24,6 +25,6 @@ export interface XlsxSheetFeatures {
 }
 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 readXlsxSheetFeaturesFromPackage(archive: OoxmlPackage, worksheetScans?: Readonly<Record<string, XlsxWorksheetXmlScan>>): Promise<Map<string, XlsxSheetFeatures>>;
 export declare function patchXlsxSheetFeatures(buffer: ArrayBuffer, content: WorkSpreadsheetContent): Promise<ArrayBuffer>;
 export {};

package/dist/internal/features/work/work-xlsx-pivot-diagnostics.d.ts

@@ -1,3 +1,4 @@
 import type { OoxmlPackage } from './work-ooxml-package';
 import type { WorkCompatibilityIssue } from './work-types';
-export declare function diagnoseXlsxPivots(archive: OoxmlPackage): Promise<WorkCompatibilityIssue[]>;
+import { type XlsxPivotReadResult } from './work-xlsx-pivots';
+export declare function diagnoseXlsxPivots(archive: OoxmlPackage, importedInspection?: XlsxPivotReadResult | null): Promise<WorkCompatibilityIssue[]>;

package/dist/internal/features/work/work-xlsx-plain-fast-path.d.ts

@@ -0,0 +1,54 @@
+import type { SpreadsheetImportWorkbookMetadata } from './work-spreadsheet-import-worker-protocol';
+export declare const PLAIN_XLSX_COLUMN_BITS = 14;
+export declare const PLAIN_XLSX_COLUMN_MASK: number;
+export declare const PLAIN_XLSX_CELL_CHUNK_SIZE = 4096;
+export declare const PLAIN_XLSX_ROW_CHUNK_SIZE = 256;
+export declare const PLAIN_XLSX_CELL_NUMBER = 0;
+export declare const PLAIN_XLSX_CELL_BOOLEAN = 1;
+export declare const PLAIN_XLSX_CELL_ERROR = 2;
+export declare const PLAIN_XLSX_CELL_TEXT = 3;
+export interface PlainXlsxPackageParts {
+    contentTypes: string;
+    packagePaths: readonly string[];
+    rootRelationships: string;
+    workbook: string;
+    workbookRelationships: string;
+}
+export interface PlainXlsxWorkbookSheet {
+    name: string;
+    partPath: string;
+}
+export interface PlainXlsxWorkbookPlan {
+    sheets: PlainXlsxWorkbookSheet[];
+    workbook: SpreadsheetImportWorkbookMetadata;
+}
+export interface PlainXlsxCellChunk {
+    coordinates: Uint32Array;
+    kinds: Uint8Array;
+    numericValues: Float64Array;
+    startRow: number;
+    textValues: string[];
+}
+export interface PlainXlsxWorksheetResult {
+    columnCount: number;
+    populatedCellCount: number;
+    properties: Record<string, unknown>;
+    rowCount: number;
+}
+export interface PlainXlsxRangeExtent {
+    columnCount: number;
+    rowCount: number;
+}
+/**
+ * Authenticates the deliberately small OOXML subset handled by the fast
+ * worksheet parser. Any package part or workbook construct outside this
+ * closed set returns null and leaves SheetJS as the authority.
+ */
+export declare function createPlainXlsxWorkbookPlan(parts: PlainXlsxPackageParts): PlainXlsxWorkbookPlan | null;
+/**
+ * Parses primitive dense cells with a low-allocation cursor. Row chunks may be
+ * emitted provisionally; callers must use them only when the final result is
+ * non-null because a later unsupported element invalidates the whole sheet.
+ */
+export declare function streamPlainXlsxWorksheet(source: string, visit: (chunk: PlainXlsxCellChunk) => void, start?: (extent: PlainXlsxRangeExtent) => void): PlainXlsxWorksheetResult | null;
+export declare function plainXlsxRangeExtent(reference: string): PlainXlsxRangeExtent | null;

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

@@ -0,0 +1 @@
+export declare function xlsxWorksheetRequiresSheetJsCellStyles(source: string): boolean;

package/dist/internal/features/work/work-xlsx-worksheet-scan.d.ts

@@ -0,0 +1,12 @@
+export interface XlsxWorksheetXmlScan {
+    hasDiagnosticFeatures: boolean;
+    hasFormulaFeatures: boolean;
+    hasImportedFeatures: boolean;
+    requiresSheetJsCellStyles: boolean;
+}
+/**
+ * Builds every worksheet gate in one pass over the decompressed XML. The
+ * scanner deliberately permits false positives because they only select the
+ * existing full parser path; a false negative could discard workbook state.
+ */
+export declare function scanXlsxWorksheetXml(source: string): XlsxWorksheetXmlScan;

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

@@ -0,0 +1,12 @@
+import type { CellObject, WorkSheet } from 'xlsx';
+export interface XlsxWorksheetCellEntry {
+    address: string;
+    cell: CellObject;
+    column: number;
+    row: number;
+}
+/**
+ * Iterates both SheetJS sparse address maps and dense row arrays without
+ * materializing a second list of every worksheet cell.
+ */
+export declare function xlsxWorksheetCellEntries(worksheet: WorkSheet): Generator<XlsxWorksheetCellEntry>;

package/dist/office-kernel.worker.js

@@ -13051,8 +13051,8 @@
         };
     })();
     (()=>{
-        const MAX_LAYOUT_BLOCKS = 10000;
-        const MAX_LAYOUT_PAGE_STYLES = MAX_LAYOUT_BLOCKS;
+        const MAX_LAYOUT_BLOCKS = 200000;
+        const MAX_LAYOUT_PAGE_STYLES = 10000;
         const MAX_LAYOUT_EXTENT = 1000000;
         const MAX_LAYOUT_PAGE_INDEX = 1000000;
         function layoutOfficeDocumentInJavaScript(request) {
@@ -13072,10 +13072,10 @@
                 ensurePageMetrics(pages, page);
                 if (void 0 !== block.flowCount) {
                     const end = index + block.flowCount;
-                    layoutFlow(request.blocks.slice(index, end), request.blocks.slice(end), pages, page, request.page, pageStyles, end < request.blocks.length);
+                    layoutFlow(request.blocks, index, end, pages, page, request.page, pageStyles, end < request.blocks.length);
                     index = end;
                 } else {
-                    layoutSingleBlock(block, request.blocks.slice(index + 1), pages, page, request.page, pageStyles, index + 1 < request.blocks.length);
+                    layoutSingleBlock(block, request.blocks, index + 1, pages, page, request.page, pageStyles, index + 1 < request.blocks.length);
                     index += 1;
                 }
             }
@@ -13119,7 +13119,7 @@
             }
             validateFlowSequences(request.blocks);
         }
-        function layoutSingleBlock(block, next, pages, page, defaultPage, pageStyles, hasMoreBlocks) {
+        function layoutSingleBlock(block, blocks, nextIndex, pages, page, defaultPage, pageStyles, hasMoreBlocks) {
             const availableHeight = pageBodyHeight(page);
             let current = pages.at(-1);
             let currentHasContent = current.placements.length > 0;
@@ -13129,7 +13129,7 @@
                 currentHasContent = false;
             }
             const remaining = Math.max(0, availableHeight - current.usedHeight);
-            const nextHeight = nextBlockPreviewHeight(next, page, defaultPage, pageStyles);
+            const nextHeight = nextBlockPreviewHeight(blocks, nextIndex, page, defaultPage, pageStyles);
             const groupedHeight = block.height + (block.keepWithNext ? nextHeight : 0);
             const shouldAdvance = currentHasContent && (block.height > remaining || (block.keepTogether || block.keepWithNext) && groupedHeight <= availableHeight && groupedHeight > remaining);
             if (shouldAdvance) {
@@ -13139,13 +13139,13 @@
             placeFragment(block, current, availableHeight);
             if (block.breakAfter && hasMoreBlocks) pages.push(emptyPage(nextPageIndex(pages), page));
         }
-        function layoutFlow(blocks, next, pages, page, defaultPage, pageStyles, hasMoreBlocks) {
+        function layoutFlow(blocks, start, end, pages, page, defaultPage, pageStyles, hasMoreBlocks) {
             const availableHeight = pageBodyHeight(page);
-            const first = blocks[0];
-            const last = blocks.at(-1);
+            const first = blocks[start];
+            const last = blocks[end - 1];
             if (first.breakBefore && pages.at(-1)?.placements.length) pages.push(emptyPage(nextPageIndex(pages), page));
-            const totalHeight = fragmentHeight(blocks, 0, blocks.length);
-            const nextHeight = last.keepWithNext ? nextBlockPreviewHeight(next, page, defaultPage, pageStyles) : 0;
+            const totalHeight = fragmentHeight(blocks, start, end);
+            const nextHeight = last.keepWithNext ? nextBlockPreviewHeight(blocks, end, page, defaultPage, pageStyles) : 0;
             let current = pages.at(-1);
             const repeatHeaderCount = first.repeatHeaderCount ?? 0;
             const repeatHeaderHeight = first.repeatHeaderHeight ?? 0;
@@ -13154,8 +13154,8 @@
                 current = emptyPage(nextPageIndex(pages), page);
                 pages.push(current);
             }
-            if (repeatHeaderCount > 0 && repeatHeaderCount < blocks.length) {
-                const leadingHeight = fragmentHeight(blocks, 0, repeatHeaderCount + 1);
+            if (repeatHeaderCount > 0 && repeatHeaderCount < end - start) {
+                const leadingHeight = fragmentHeight(blocks, start, start + repeatHeaderCount + 1);
                 const remainingHeight = Math.max(0, availableHeight - current.usedHeight);
                 if (current.placements.length > 0 && leadingHeight <= availableHeight && leadingHeight > remainingHeight) {
                     current = emptyPage(nextPageIndex(pages), page);
@@ -13163,22 +13163,23 @@
                 }
             }
             const minimum = Math.max(1, first.minimumFragmentsPerPage ?? 1);
-            let cursor = 0;
-            while(cursor < blocks.length){
+            let cursor = start;
+            let remainingFlowHeight = totalHeight;
+            while(cursor < end){
                 current = pages.at(-1);
-                if (cursor >= repeatHeaderCount && cursor > 0 && repeatHeaderHeight > 0 && 0 === current.placements.length && 0 === current.usedHeight) current.usedHeight = repeatHeaderHeight;
+                if (cursor - start >= repeatHeaderCount && cursor > start && repeatHeaderHeight > 0 && 0 === current.placements.length && 0 === current.usedHeight) current.usedHeight = repeatHeaderHeight;
                 const currentHasContent = current.placements.length > 0;
                 const remainingHeight = Math.max(0, availableHeight - current.usedHeight);
-                const remainingFragments = blocks.length - cursor;
-                const remainingFlowHeight = fragmentHeight(blocks, cursor, blocks.length);
+                const remainingFragments = end - cursor;
                 if (nextHeight > 0 && currentHasContent && remainingFlowHeight <= remainingHeight && remainingFlowHeight + nextHeight > remainingHeight && remainingFlowHeight + nextHeight <= availableHeight) {
                     pages.push(emptyPage(nextPageIndex(pages), page));
                     continue;
                 }
-                let fitting = fragmentsFitting(blocks, cursor, blocks.length, remainingHeight);
+                let fitting = fragmentsFitting(blocks, cursor, end, remainingHeight);
                 if (fitting === remainingFragments) {
-                    placeFragments(blocks, cursor, blocks.length, current, availableHeight);
-                    cursor = blocks.length;
+                    placeFragments(blocks, cursor, end, current, availableHeight);
+                    cursor = end;
+                    remainingFlowHeight = 0;
                     continue;
                 }
                 if (0 === fitting) {
@@ -13195,18 +13196,19 @@
                     continue;
                 }
                 fitting = Math.max(1, fitting);
+                remainingFlowHeight -= fragmentHeight(blocks, cursor, cursor + fitting);
                 placeFragments(blocks, cursor, cursor + fitting, current, availableHeight);
                 cursor += fitting;
-                if (cursor < blocks.length) pages.push(emptyPage(nextPageIndex(pages), page));
+                if (cursor < end) pages.push(emptyPage(nextPageIndex(pages), page));
             }
             if (last.breakAfter && hasMoreBlocks) pages.push(emptyPage(nextPageIndex(pages), page));
         }
-        function nextBlockPreviewHeight(blocks, currentPage, defaultPage, pageStyles) {
-            const first = blocks[0];
+        function nextBlockPreviewHeight(blocks, start, currentPage, defaultPage, pageStyles) {
+            const first = blocks[start];
             if (!first || first.breakBefore) return 0;
             if (!pageMetricsEqual(currentPage, pageMetricsForBlock(first, defaultPage, pageStyles))) return 0;
             const count = Math.min(2, first.flowCount ?? 1);
-            return fragmentHeight(blocks, 0, count);
+            return fragmentHeight(blocks, start, Math.min(blocks.length, start + count));
         }
         function fragmentsFitting(blocks, start, end, availableHeight) {
             let used = 0;
@@ -13274,13 +13276,13 @@
                 const count = block.flowCount;
                 const repeatHeaderCount = block.repeatHeaderCount;
                 const repeatHeaderHeight = block.repeatHeaderHeight;
-                const flow = blocks.slice(index, index + count);
-                if (flow.length !== count) throw kernelError('office.kernel.flow_sequence_invalid', 'A layout flow must contain its declared number of fragments.');
-                flow.forEach((fragment, flowIndex)=>{
+                if (index + count > blocks.length) throw kernelError('office.kernel.flow_sequence_invalid', 'A layout flow must contain its declared number of fragments.');
+                for(let flowIndex = 0; flowIndex < count; flowIndex += 1){
+                    const fragment = blocks[index + flowIndex];
                     if (fragment.flowId !== block.flowId || fragment.flowIndex !== flowIndex || fragment.flowCount !== count || fragment.minimumFragmentsPerPage !== block.minimumFragmentsPerPage || fragment.repeatHeaderCount !== repeatHeaderCount || fragment.repeatHeaderHeight !== repeatHeaderHeight || fragment.pageStyleId !== block.pageStyleId) throw kernelError('office.kernel.flow_sequence_invalid', 'Layout flow fragments must be consecutive and consistently indexed.');
                     if (flowIndex > 0 && fragment.breakBefore) throw kernelError('office.kernel.flow_break_invalid', 'Only the first flow fragment may request breakBefore.');
                     if (flowIndex + 1 < count && fragment.breakAfter) throw kernelError('office.kernel.flow_break_invalid', 'Only the last flow fragment may request breakAfter.');
-                });
+                }
                 index += count;
             }
         }

package/dist/react.d.ts

@@ -8,13 +8,19 @@ import type { SpreadsheetEditorProps as InternalSpreadsheetEditorProps } from '.
 import type { WorkOfficeFileAction } from './internal/features/work/editors/work-office-chrome';
 import { type OfficeSurfaceProps, type OfficeTheme } from './office-surface';
 export type OfficeEditorKind = 'document' | 'markdown' | 'spreadsheet' | 'presentation' | 'pdf';
+export interface OfficeEditorPreloadOptions {
+    /** Overrides the packaged PDFium asset when preloading the PDF runtime. */
+    pdfWasmUrl?: string;
+    /** Also fetches PDFium WebAssembly. Disabled unless explicitly enabled. */
+    preloadRuntimeAssets?: boolean;
+}
 /**
  * Starts loading one editor without mounting it.
  *
  * Call this from an intent signal such as hover or keyboard focus to keep the
  * initial application bundle small without adding latency to editor opening.
  */
-export declare function preloadOfficeEditor(kind: OfficeEditorKind): Promise<void>;
+export declare function preloadOfficeEditor(kind: OfficeEditorKind, options?: OfficeEditorPreloadOptions): Promise<void>;
 export declare const defaultPdfiumWasmUrl: string;
 export declare const defaultOfficeKernelWasmUrl: string;
 export declare const defaultDocumentLayoutFontUrl: string;