@a3s-lab/office 0.11.0 → 0.13.0

package/dist/0~document-editor.js

@@ -16,15 +16,15 @@ import extension_underline from "@tiptap/extension-underline";
 import starter_kit from "@tiptap/starter-kit";
 import { BubbleMenu } from "@tiptap/react/menus";
 import { TableMap, isInTable, selectedRect } from "@tiptap/pm/tables";
+import { documentTableSizing, transferChangedDocumentTextStatistics, documentPageBordersVisible, DOCUMENT_PAGE_BORDER_EDGES, documentTableRowOptions, normalizeDocumentColumns, clampDocumentMargin, materializeLazyDocumentEditorRoot, DOCUMENT_BOOKMARK_DUPLICATE_MESSAGE, documentCitationCount, nextDocumentTabAlignment, normalizedTabPosition, isDocumentParagraphArtBorderStyle, resolveDocumentPageBorders, documentLazyHtmlChunkFragment, DOCUMENT_CHUNK_VISIBLE_IDS_META, MAX_DOCUMENT_IMAGE_RELATIVE_HEIGHT, retainAnchoredDocumentComments, DocumentTableRowIdentity, work_document_page_margins_twipsToMillimeters, DEFAULT_DOCUMENT_TABLE_CELL_FORMAT, resolveWorkDocumentEditorInput, collectDocumentTextLayoutParagraphs, documentBulletListStyle, readOfficeDocumentCollaboration as readWorkOfficeDocumentCollaboration, documentOrderedListState, normalizeDocumentPageChrome, documentTextStatistics, documentPageMarginsForLayout, invalidateDocumentLazyHtmlProjection, documentTableCellFormat, normalizeDocumentPageGeometry, normalizeDocumentImageLayer, documentImageProperties, isValidDocumentCitationTag, sanitizeDocumentPageChromeHtml, pageTwipsToMillimeters, normalizeDocumentPageBorders, activeDocumentSection, DocumentParagraphFormatting, normalizeDocumentHtml, documentInitialSectionLayout, documentModelHasTrustedInitialIntegrityFeatures, documentModelUsesWindowing, documentParagraphDirection, documentParagraphPagination, documentPageChromeLegacyFields, documentChunkMountedIds, collectDocumentCommentAnchors, canChangeDocumentIndent, DocumentSuperscript, documentSectionById, activeDocumentBookmark, DocumentEquation, documentLazyHtmlProjectionFingerprint, documentLazyHtmlProjection, normalizeDocumentParagraphIndent, updateDocumentGutterPosition, mountWorkLiveDocumentCapture, registerDocumentPageSurfaceGeometry, syncDocumentContentFromHtml, editorDocumentCaptionTargets, resolveDocumentPageChrome, documentImageLayoutOptions, MAX_DOCUMENT_NUMBERING_START, resolveDocumentPageSize, editorDocumentBookmarkReferenceTargets, serializeWorkDocumentNode, DOCUMENT_CHUNK_PAGINATION_META, createOfficeDocumentCollaborationBinding as createWorkOfficeDocumentCollaborationBinding, documentModelForContent, selectedDocumentChunkId, documentCommentViews, documentParagraphSpacing, normalizeDocumentTabStops, patchDocumentLazyHtmlProjection, documentBookmarkNameExists, collectDocumentChanges, DocumentImage, resolveDocumentPageMargins, updateDocumentPageMarginMode, canSetDocumentTableRowRepeatHeader, millimetersToPixels as work_document_layout_millimetersToPixels, DOCUMENT_CHUNK_HYDRATION_META, documentTabLeaderLabel, createSchemaDerivedWorkDocumentModel, updateDocumentCustomPageMillimeters, documentCommentDraftRange, documentParagraphTabStops, documentTableHorizontalAlignment, documentParagraphIndent, canInsertDocumentComment, documentTextLayoutBatches, normalizeDocumentImageWrapSide, updateDocumentPageOrientation, documentCitationStyleDetails, validateDocumentBookmarkName, setCustomDocumentColumns, updateDocumentPageMarginMillimeters, documentCitationStyle, documentTransactionsOnlyHydrateChunks, DEFAULT_DOCUMENT_TABLE_CELL_MARGINS, DOCUMENT_TABLE_STYLE_OPTIONS, updateDocumentColumnWidth, updateDocumentPaperSizePreset, documentPageMetrics, createDocumentBibliography, DocumentSubscript, DocumentParagraphIdentity, updateDocumentPageChromeVariant, updateDocumentMirrorMargins, activeDocumentTableStyle, measureDocumentLayoutBlocksIncrementally, createWorkDocumentExtensions } from "./6282.js";
 import { useOfficeTaskPaneEscape, normalizeOfficeFontFamily, OfficeCheckbox, useOfficeDialog, useOfficeTaskPaneModal, CommittedOfficeNumberField, officeFontFamilyLabel, officeFontFamilies, CollectionState, createOfficeKernelClient, OfficeNumberField } from "./0~7048.js";
 import { office_text_field_OfficeTextArea, Popover, officeOverlayPortalRoot, button_Button, useOfficePublishPresenceLocation, OfficeTiptapPresenceLayer, icon_button_IconButton, office_text_field_OfficeTextField, useDialogFocusScope, useOfficeEditorWheelZoom, office_text_field_OfficeFileInput } from "./0~6090.js";
 import { WorkOfficePreviewBar, isWorkspaceContextMenuKeyboardEvent, Tabs, WorkOfficeZoomControls, WorkOfficeStatusBar, Dialog, WorkOfficeRibbon, workspaceContextMenuPosition, OfficeSelect, WorkspaceContextMenu, WorkOfficeRibbonGroup, WorkOfficeRibbonButton } from "./0~4595.js";
-import { documentTableSizing, documentTableRowOptions, documentCommentViews, documentParagraphSpacing, documentPageBordersVisible, DOCUMENT_PAGE_BORDER_EDGES, normalizeDocumentColumns, clampDocumentMargin, normalizeDocumentTabStops, DOCUMENT_BOOKMARK_DUPLICATE_MESSAGE, createWorkDocumentModel, nextDocumentTabAlignment, documentBookmarkNameExists, normalizedTabPosition, DocumentImage, collectDocumentChanges, documentCitationCount, isDocumentParagraphArtBorderStyle, resolveDocumentPageMargins, updateDocumentPageMarginMode, resolveDocumentPageBorders, canSetDocumentTableRowRepeatHeader, MAX_DOCUMENT_IMAGE_RELATIVE_HEIGHT, retainAnchoredDocumentComments, DocumentTableRowIdentity, work_document_page_margins_twipsToMillimeters, DEFAULT_DOCUMENT_TABLE_CELL_FORMAT, resolveWorkDocumentEditorInput, collectDocumentTextLayoutParagraphs, millimetersToPixels as work_document_layout_millimetersToPixels, documentBulletListStyle, readOfficeDocumentCollaboration as readWorkOfficeDocumentCollaboration, documentTabLeaderLabel, documentOrderedListState, normalizeDocumentPageChrome, documentPageMarginsForLayout, documentTableCellFormat, updateDocumentCustomPageMillimeters, documentCommentDraftRange, normalizeDocumentPageGeometry, documentParagraphTabStops, normalizeDocumentImageLayer, documentImageProperties, documentParagraphIndent, documentTableHorizontalAlignment, isValidDocumentCitationTag, canInsertDocumentComment, sanitizeDocumentPageChromeHtml, pageTwipsToMillimeters, normalizeDocumentPageBorders, DocumentParagraphFormatting, activeDocumentSection, documentTextLayoutBatches, normalizeDocumentImageWrapSide, normalizeDocumentHtml, documentParagraphDirection, documentParagraphPagination, updateDocumentPageOrientation, documentCitationStyleDetails, documentInitialSectionLayout, documentPageChromeLegacyFields, setCustomDocumentColumns, collectDocumentCommentAnchors, documentCitationStyle, updateDocumentPageMarginMillimeters, canChangeDocumentIndent, validateDocumentBookmarkName, DEFAULT_DOCUMENT_TABLE_CELL_MARGINS, DocumentSuperscript, documentSectionById, DOCUMENT_TABLE_STYLE_OPTIONS, updateDocumentColumnWidth, updateDocumentPaperSizePreset, DocumentEquation, documentPageMetrics, normalizeDocumentParagraphIndent, updateDocumentGutterPosition, mountWorkLiveDocumentCapture, activeDocumentBookmark, createDocumentBibliography, DocumentSubscript, DocumentParagraphIdentity, syncDocumentContentFromHtml, updateDocumentPageChromeVariant, editorDocumentCaptionTargets, resolveDocumentPageChrome, updateDocumentMirrorMargins, documentImageLayoutOptions, MAX_DOCUMENT_NUMBERING_START, resolveDocumentPageSize, activeDocumentTableStyle, editorDocumentBookmarkReferenceTargets, createOfficeDocumentCollaborationBinding as createWorkOfficeDocumentCollaborationBinding, measureDocumentLayoutBlocksIncrementally, createWorkDocumentExtensions } from "./8928.js";
 import { createOfficeId as createWorkId } from "./5184.js";
 import { normalizeDocumentHref, DOCUMENT_LINK_VALIDATION_MESSAGE } from "./0~work-document-links.js";
 import { OfficeColorPicker, isOfficeShortcutBlocked } from "./0~3635.js";
 import { OfficeTableInsertPopover, readOfficeFileAsDataUrl } from "./0~9445.js";
-import { mergeOfficeTiptapExtensions, documentTextStatistics, documentCurrentPage, documentPageCount, documentAgentMenuItems, createWorkDocumentSelectionSnapshot, documentPlainTextAsHtml, createWorkDocumentSelectionAction, documentCustomSelectionMenuItems } from "./0~5050.js";
+import { mergeOfficeTiptapExtensions, documentCurrentPage, documentPageCount, documentAgentMenuItems, createWorkDocumentSelectionSnapshot, documentPlainTextAsHtml, documentCustomSelectionMenuItems, createWorkDocumentSelectionAction } from "./0~5050.js";
 import { WorkEditorLoadingState, documentLayoutFontKey, useOfficeCollaborationLocationNavigator, OFFICE_DOCUMENT_LAYOUT_HEBREW_FONT_ID, useOfficeEditorInitialFocus, OFFICE_DOCUMENT_LAYOUT_FONT_ID, OFFICE_DOCUMENT_LAYOUT_ARABIC_FONT_ID, OFFICE_DOCUMENT_LAYOUT_LATIN_FONT_ID } from "./432.js";
 import { useOfficeDraft, InlineNotice } from "./0~345.js";
 import { documentPageColor, normalizeDocumentPageColor } from "./0~work-document-page-color.js";
@@ -33,6 +33,128 @@ __webpack_require__.r(document_editor_namespaceObject);
 __webpack_require__.d(document_editor_namespaceObject, {
     DocumentEditor: ()=>DocumentEditor
 });
+function materializeLazyDocumentUpdate(previousDocument, nextDocument, compactRoot, model) {
+    const root = materializeLazyDocumentEditorRoot(compactRoot, model);
+    const projection = documentLazyHtmlProjection(model);
+    const changed = changedLazyDocumentChunks(previousDocument, nextDocument);
+    if (!projection || !changed?.length || changed.some(({ after, before })=>!documentChunkOnlyChangesText(before, after))) {
+        invalidateDocumentLazyHtmlProjection(model);
+        return {
+            html: null,
+            htmlFingerprint: null,
+            root
+        };
+    }
+    try {
+        const replacements = new Map();
+        for (const { id } of changed){
+            const range = projection.ranges.get(id);
+            const isolated = isolatedDocumentChunk(root, id);
+            if (!range || !isolated) throw new Error('Lazy chunk is not indexed.');
+            const serialized = serializeWorkDocumentNode(isolated);
+            const sectionOpen = serialized.indexOf('>') + 1;
+            const sectionClose = serialized.lastIndexOf('</section>');
+            if (sectionOpen <= 0 || sectionClose < sectionOpen) throw new Error('Lazy chunk serialization has no section boundary.');
+            const fragment = documentLazyHtmlChunkFragment(serialized.slice(sectionOpen, sectionClose), range.tablePart);
+            if (null === fragment) throw new Error('Lazy table chunk serialization is malformed.');
+            replacements.set(id, fragment);
+        }
+        const html = patchDocumentLazyHtmlProjection(projection, replacements);
+        if (null === html) throw new Error('Lazy HTML patch could not be applied.');
+        const htmlFingerprint = documentLazyHtmlProjectionFingerprint(projection);
+        if (!htmlFingerprint) throw new Error('Lazy HTML fingerprint could not be updated.');
+        return {
+            html,
+            htmlFingerprint,
+            root
+        };
+    } catch  {
+        invalidateDocumentLazyHtmlProjection(model);
+        return {
+            html: null,
+            htmlFingerprint: null,
+            root
+        };
+    }
+}
+function transferLazyDocumentTextStatistics(previousDocument, nextDocument) {
+    const changed = changedLazyDocumentChunks(previousDocument, nextDocument);
+    if (!changed?.length || changed.some(({ after, before })=>!documentChunkOnlyChangesText(before, after))) return false;
+    return transferChangedDocumentTextStatistics(previousDocument, nextDocument, changed);
+}
+function changedLazyDocumentChunks(before, after) {
+    const changed = [];
+    const visit = (previous, next)=>{
+        if (previous === next || previous.eq(next)) return true;
+        if (previous.type !== next.type) return false;
+        if ('documentChunk' === previous.type.name && true !== previous.attrs.windowContainer && true !== next.attrs.windowContainer) {
+            const previousId = documentChunkId(previous);
+            const nextId = documentChunkId(next);
+            if (!previousId || previousId !== nextId) return false;
+            changed.push({
+                after: next,
+                before: previous,
+                id: nextId
+            });
+            return true;
+        }
+        if (!previous.sameMarkup(next) || previous.childCount !== next.childCount) return false;
+        for(let index = 0; index < previous.childCount; index += 1){
+            const previousChild = previous.child(index);
+            const nextChild = next.child(index);
+            if (!visit(previousChild, nextChild)) return false;
+        }
+        return true;
+    };
+    return visit(before, after) ? changed : null;
+}
+function documentChunkOnlyChangesText(before, after) {
+    let textChanged = false;
+    const visit = (previous, next)=>{
+        if (previous.type !== next.type || !previous.sameMarkup(next) || previous.childCount !== next.childCount) return false;
+        if (previous.isText || next.isText) {
+            if (!previous.isText || !next.isText) return false;
+            if (previous.text !== next.text) textChanged = true;
+            return true;
+        }
+        for(let index = 0; index < previous.childCount; index += 1)if (!visit(previous.child(index), next.child(index))) return false;
+        return true;
+    };
+    return visit(before, after) && textChanged;
+}
+function isolatedDocumentChunk(root, id) {
+    let section = null;
+    let chunk = null;
+    const visit = (node, activeSection)=>{
+        if (chunk) return;
+        const nextSection = 'documentSection' === node.type ? node : activeSection;
+        if ('documentChunk' === node.type && node.attrs?.windowContainer !== true && node.attrs?.id === id) {
+            section = nextSection;
+            chunk = node;
+            return;
+        }
+        for (const child of node.content ?? [])visit(child, nextSection);
+    };
+    visit(root, null);
+    const foundSection = section;
+    const foundChunk = chunk;
+    if (!foundSection || !foundChunk) return null;
+    return {
+        type: 'doc',
+        content: [
+            {
+                ...foundSection,
+                content: [
+                    foundChunk
+                ]
+            }
+        ]
+    };
+}
+function documentChunkId(node) {
+    const id = node.attrs.id;
+    return 'string' == typeof id && id ? id : null;
+}
 function documentPageSurfaceGeometry(pages, fallback, requestedPageCount = pages.length) {
     const pageCount = Math.max(1, Math.trunc(requestedPageCount));
     const metrics = Array.from({
@@ -217,10 +339,14 @@ const DocumentPagination = Extension.create({
     name: 'documentPagination',
     addCommands () {
         return {
-            applyDocumentPagination: (revision, breaks)=>({ tr })=>{
+            applyDocumentPagination: (revision, breaks)=>({ state, tr })=>{
                     tr.setMeta(documentPaginationPluginKey, {
                         kind: 'apply',
                         revision,
+                        breaks,
+                        visibleIds: documentChunkMountedIds(state) ?? []
+                    });
+                    tr.setMeta(DOCUMENT_CHUNK_PAGINATION_META, {
                         breaks
                     });
                     tr.setMeta('addToHistory', false);
@@ -228,11 +354,14 @@ const DocumentPagination = Extension.create({
                 },
             clearDocumentPagination: (revision)=>({ state, tr })=>{
                     const current = documentPaginationState(state);
-                    if (!current.decorations.find().length && current.revision === revision) return false;
+                    if (!current.breaks.length && current.revision === revision) return false;
                     tr.setMeta(documentPaginationPluginKey, {
                         kind: 'clear',
                         revision
                     });
+                    tr.setMeta(DOCUMENT_CHUNK_PAGINATION_META, {
+                        breaks: []
+                    });
                     tr.setMeta('addToHistory', false);
                     return true;
                 }
@@ -244,34 +373,54 @@ const DocumentPagination = Extension.create({
                 key: documentPaginationPluginKey,
                 state: {
                     init: ()=>({
+                            breakIndex: emptyDocumentPaginationBreakIndex(),
+                            breaks: [],
                             decorations: DecorationSet.empty,
-                            revision: 0
+                            revision: 0,
+                            visibleIds: []
                         }),
                     apply: (transaction, current, _previous, next)=>{
                         const meta = transaction.getMeta(documentPaginationPluginKey);
+                        const visibleMeta = transaction.getMeta(DOCUMENT_CHUNK_VISIBLE_IDS_META);
+                        const hydrationMeta = transaction.getMeta(DOCUMENT_CHUNK_HYDRATION_META);
                         if (meta?.kind === 'clear') return {
+                            breakIndex: emptyDocumentPaginationBreakIndex(),
+                            breaks: [],
                             decorations: DecorationSet.empty,
-                            revision: meta.revision
-                        };
-                        if (meta?.kind === 'apply') return {
-                            decorations: DecorationSet.create(next.doc, (meta.breaks ?? []).flatMap(pageBreakDecorations)),
-                            revision: meta.revision
+                            revision: meta.revision,
+                            visibleIds: documentChunkMountedIds(next) ?? []
                         };
+                        if (meta?.kind === 'apply') return createDocumentPaginationPluginState(next, meta.breaks ?? [], meta.revision, meta.visibleIds);
+                        if (transaction.docChanged && hydrationMeta) {
+                            const visibleIds = visibleMeta?.visibleIds ?? documentChunkMountedIds(next) ?? current.visibleIds;
+                            return {
+                                ...current,
+                                decorations: documentPaginationDecorationSet(next.doc, current.breakIndex, visibleIds),
+                                visibleIds: [
+                                    ...visibleIds
+                                ]
+                            };
+                        }
                         if (transaction.docChanged) {
                             const appendedTo = transaction.getMeta('appendedTransaction');
                             const sourceMeta = appendedTo?.getMeta(documentPaginationPluginKey);
-                            if (sourceMeta?.kind === 'apply') return {
-                                ...current,
-                                decorations: current.decorations.map(transaction.mapping, next.doc)
-                            };
+                            if (sourceMeta?.kind === 'apply') return createDocumentPaginationPluginState(next, mapDocumentPaginationBreaks(current.breaks, transaction.mapping), current.revision);
                             return {
+                                breakIndex: emptyDocumentPaginationBreakIndex(),
+                                breaks: [],
                                 decorations: DecorationSet.empty,
-                                revision: current.revision
+                                revision: current.revision,
+                                visibleIds: documentChunkMountedIds(next) ?? []
                             };
                         }
+                        const visibleIds = visibleMeta?.visibleIds ?? (transaction.selectionSet ? withSelectedDocumentChunk(current.visibleIds, next) : current.visibleIds);
+                        if (arraysEqual(visibleIds, current.visibleIds)) return current;
                         return {
                             ...current,
-                            decorations: current.decorations.map(transaction.mapping, next.doc)
+                            decorations: documentPaginationDecorationSet(next.doc, current.breakIndex, visibleIds),
+                            visibleIds: [
+                                ...visibleIds
+                            ]
                         };
                     }
                 },
@@ -279,6 +428,21 @@ const DocumentPagination = Extension.create({
                     decorations (state) {
                         return documentPaginationState(state).decorations;
                     }
+                },
+                view: (initialView)=>{
+                    const publishDiagnostics = (state)=>{
+                        const pagination = documentPaginationState(state);
+                        initialView.dom.dataset.paginationVisualBreaks = String(pagination.breaks.length);
+                        initialView.dom.dataset.paginationVisibleBreaks = String(visibleDocumentPaginationBreakCount(pagination.breakIndex, pagination.visibleIds));
+                        initialView.dom.dataset.paginationVisibleDecorations = String(pagination.decorations.find().length);
+                        initialView.dom.dataset.paginationIndexedChunks = String(pagination.breakIndex.byChunkId.size);
+                    };
+                    publishDiagnostics(initialView.state);
+                    return {
+                        update (nextView) {
+                            publishDiagnostics(nextView.state);
+                        }
+                    };
                 }
             })
         ];
@@ -286,10 +450,117 @@ const DocumentPagination = Extension.create({
 });
 function documentPaginationState(state) {
     return documentPaginationPluginKey.getState(state) ?? {
+        breakIndex: emptyDocumentPaginationBreakIndex(),
+        breaks: [],
         decorations: DecorationSet.empty,
-        revision: 0
+        revision: 0,
+        visibleIds: []
+    };
+}
+function createDocumentPaginationPluginState(state, breaks, revision, requestedVisibleIds) {
+    const visibleIds = requestedVisibleIds ?? documentChunkMountedIds(state) ?? [];
+    const breakIndex = indexDocumentPaginationBreaks(state.doc, breaks);
+    return {
+        breakIndex,
+        breaks: [
+            ...breaks
+        ],
+        decorations: documentPaginationDecorationSet(state.doc, breakIndex, visibleIds),
+        revision,
+        visibleIds
     };
 }
+function indexDocumentPaginationBreaks(document1, breaks) {
+    if (!breaks.length) return emptyDocumentPaginationBreakIndex();
+    const chunks = [];
+    document1.descendants((node, position)=>{
+        if ('documentChunk' !== node.type.name) return true;
+        if (true === node.attrs.windowContainer) return true;
+        chunks.push({
+            from: position,
+            id: 'string' == typeof node.attrs.id ? node.attrs.id : '',
+            to: position + node.nodeSize
+        });
+        return false;
+    });
+    if (!chunks.length) return {
+        byChunkId: new Map(),
+        outsideChunks: [
+            ...breaks
+        ]
+    };
+    const byChunkId = new Map();
+    const outsideChunks = [];
+    const orderedBreaks = [
+        ...breaks
+    ].sort(compareDocumentPaginationBreaks);
+    let chunkIndex = 0;
+    for (const pageBreak of orderedBreaks){
+        while(chunkIndex < chunks.length && pageBreak.position >= (chunks[chunkIndex]?.to ?? 1 / 0))chunkIndex += 1;
+        const chunk = chunks[chunkIndex];
+        if (chunk && pageBreak.position > chunk.from && pageBreak.position < chunk.to) {
+            const chunkBreaks = byChunkId.get(chunk.id) ?? [];
+            chunkBreaks.push(pageBreak);
+            byChunkId.set(chunk.id, chunkBreaks);
+        } else outsideChunks.push(pageBreak);
+    }
+    return {
+        byChunkId,
+        outsideChunks
+    };
+}
+function documentPaginationDecorationSet(document1, breakIndex, visibleIds) {
+    const visibleBreaks = [
+        ...breakIndex.outsideChunks
+    ];
+    for (const id of visibleIds){
+        const chunkBreaks = breakIndex.byChunkId.get(id);
+        if (chunkBreaks) visibleBreaks.push(...chunkBreaks);
+    }
+    visibleBreaks.sort(compareDocumentPaginationBreaks);
+    return DecorationSet.create(document1, visibleBreaks.flatMap(pageBreakDecorations));
+}
+function visibleDocumentPaginationBreakCount(breakIndex, visibleIds) {
+    let count = breakIndex.outsideChunks.length;
+    for (const id of visibleIds)count += breakIndex.byChunkId.get(id)?.length ?? 0;
+    return count;
+}
+function emptyDocumentPaginationBreakIndex() {
+    return {
+        byChunkId: new Map(),
+        outsideChunks: []
+    };
+}
+function compareDocumentPaginationBreaks(left, right) {
+    return left.position - right.position || left.pageIndex - right.pageIndex;
+}
+function mapDocumentPaginationBreaks(breaks, mapping) {
+    return breaks.map((pageBreak)=>({
+            ...pageBreak,
+            position: mapping.map(pageBreak.position, -1),
+            ...pageBreak.tableBreak?.cellBreaks ? {
+                tableBreak: {
+                    ...pageBreak.tableBreak,
+                    cellBreaks: pageBreak.tableBreak.cellBreaks.map((cellBreak)=>({
+                            ...cellBreak,
+                            position: mapping.map(cellBreak.position, -1)
+                        }))
+                }
+            } : {}
+        }));
+}
+function arraysEqual(left, right) {
+    if (left.length !== right.length) return false;
+    for(let index = 0; index < left.length; index += 1)if (left[index] !== right[index]) return false;
+    return true;
+}
+function withSelectedDocumentChunk(visibleIds, state) {
+    const selected = selectedDocumentChunkId(state);
+    return selected && !visibleIds.includes(selected) ? [
+        ...visibleIds,
+        selected
+    ] : visibleIds;
+}
 const DOCUMENT_NAVIGATION_COLLECTION_WINDOW_THRESHOLD = 48;
 const DOCUMENT_NAVIGATION_COLLECTION_WINDOW_LIMIT = 32;
 const DOCUMENT_NAVIGATION_COLLECTION_WINDOW_OVERSCAN = 4;
@@ -2753,10 +3024,28 @@ function fallbackPaginationPageDescriptor(sectionId, sectionIndex, layout, physi
         page: documentPageMetrics(layout)
     };
 }
-function shouldPublishDocumentUpdate(transaction) {
-    return !transaction.getMeta('preventUpdate') && false !== transaction.getMeta('addToHistory');
+function shouldPublishDocumentUpdate(transaction, appendedTransactions = []) {
+    return [
+        transaction,
+        ...appendedTransactions
+    ].some((candidate)=>candidate.docChanged && !candidate.getMeta('preventUpdate') && false !== candidate.getMeta('addToHistory'));
 }
 function applyExternalDocumentContent(editor, content) {
+    const startedAt = externalContentNow();
+    const finish = (result)=>{
+        const finishedAt = externalContentNow();
+        editor.view.dom.dataset.documentExternalApplyMs = String(Math.round((finishedAt - startedAt) * 10) / 10);
+        try {
+            globalThis.performance?.measure('a3s-office.document.external-content-apply', {
+                detail: {
+                    result
+                },
+                end: finishedAt,
+                start: startedAt
+            });
+        } catch  {}
+        return result;
+    };
     let nextDocument;
     try {
         nextDocument = createNodeFromContent(content, editor.schema, {
@@ -2764,12 +3053,12 @@ function applyExternalDocumentContent(editor, content) {
             slice: false
         });
     } catch  {
-        return 'unsupported';
+        return finish('unsupported');
     }
-    if (!(nextDocument instanceof model_Node)) return 'unsupported';
+    if (!(nextDocument instanceof model_Node)) return finish('unsupported');
     const currentDocument = editor.state.doc;
     const start = currentDocument.content.findDiffStart(nextDocument.content);
-    if (null === start) return 'unchanged';
+    if (null === start) return finish('unchanged');
     const end = currentDocument.content.findDiffEnd(nextDocument.content);
     let currentEnd = end?.a ?? currentDocument.content.size;
     let nextEnd = end?.b ?? nextDocument.content.size;
@@ -2781,11 +3070,14 @@ function applyExternalDocumentContent(editor, content) {
     try {
         const transaction = editor.state.tr.replace(start, currentEnd, nextDocument.slice(start, nextEnd)).setMeta('addToHistory', false).setMeta('preventUpdate', true);
         editor.view.dispatch(transaction);
-        return 'applied';
+        return finish('applied');
     } catch  {
-        return 'unsupported';
+        return finish('unsupported');
     }
 }
+function externalContentNow() {
+    return globalThis.performance?.now?.() ?? Date.now();
+}
 const SEARCH_CONTEXT_LENGTH = 34;
 function documentTextMatches(document1, rawQuery) {
     const query = rawQuery.toLocaleLowerCase();
@@ -5501,33 +5793,120 @@ function WorkDocumentPageBorder({ layout, physicalPage = 1, sectionPage }) {
 function formatPixels(value) {
     return Number(value.toFixed(3)).toString();
 }
-function DocumentPageStack({ pageColor, pageCount, pageGap, pageHeight, pageWidth = 794, pages = [] }) {
+const EMPTY_DOCUMENT_PAGE_DESCRIPTORS = [];
+const document_page_stack_DOCUMENT_PAGE_WINDOW_THRESHOLD = 24;
+const DOCUMENT_PAGE_INITIAL_WINDOW_SIZE = 8;
+const document_page_stack_DOCUMENT_PAGE_WINDOW_OVERSCAN = 3;
+function DocumentPageStack({ pageColor, pageCount, pageGap, pageHeight, pageWidth = 794, pages = EMPTY_DOCUMENT_PAGE_DESCRIPTORS }) {
     const count = Math.max(1, Math.trunc(pageCount));
     const gap = Math.max(0, pageGap);
     const height = Math.max(1, pageHeight);
-    const fallbackPage = {
-        width: Math.max(1, pageWidth),
+    const fallbackPage = useMemo(()=>({
+            width: Math.max(1, pageWidth),
+            height,
+            marginTop: 0,
+            marginRight: 0,
+            marginBottom: 0,
+            marginLeft: 0,
+            headerHeight: 0,
+            footerHeight: 0,
+            pageGap: gap
+        }), [
+        gap,
         height,
-        marginTop: 0,
-        marginRight: 0,
-        marginBottom: 0,
-        marginLeft: 0,
-        headerHeight: 0,
-        footerHeight: 0,
-        pageGap: gap
-    };
-    const geometry = documentPageSurfaceGeometry(pages.map((page)=>page.page ?? fallbackPage), fallbackPage, count);
-    const descriptors = geometry.frames.map((frame)=>({
+        pageWidth
+    ]);
+    const geometry = useMemo(()=>documentPageSurfaceGeometry(pages.map((page)=>page.page ?? fallbackPage), fallbackPage, count), [
+        count,
+        fallbackPage,
+        pages
+    ]);
+    const windowed = count > document_page_stack_DOCUMENT_PAGE_WINDOW_THRESHOLD;
+    const stackRef = useRef(null);
+    const [requestedWindow, setRequestedWindow] = useState(()=>initialDocumentPageWindow(count));
+    const pageWindow = windowed ? clampDocumentPageWindow(requestedWindow, count) : {
+        start: 0,
+        end: count
+    };
+    const descriptors = geometry.frames.slice(pageWindow.start, pageWindow.end).map((frame)=>({
             frame,
             page: pages[frame.pageIndex]
         }));
+    useLayoutEffect(()=>{
+        const stack = stackRef.current;
+        if (!stack) return;
+        return registerDocumentPageSurfaceGeometry(stack, ()=>{
+            if (pages.length < count) return [];
+            return geometry.frames.map((frame)=>{
+                const descriptor = pages[frame.pageIndex];
+                const pageSize = descriptor ? resolveDocumentPageSize(descriptor.layout) : null;
+                return {
+                    height: frame.height,
+                    left: frame.left,
+                    orientation: pageSize?.orientation ?? 'portrait',
+                    pageHeightPoints: pageSize?.heightPoints ?? 72 * frame.height / 96,
+                    pageIndex: frame.pageIndex,
+                    pageSize: pageSize?.preset && 'custom' !== pageSize.preset ? pageSize.preset : 'a4',
+                    pageWidthPoints: pageSize?.widthPoints ?? 72 * frame.width / 96,
+                    top: frame.top,
+                    width: frame.width
+                };
+            });
+        });
+    }, [
+        count,
+        geometry.frames,
+        pages
+    ]);
+    useLayoutEffect(()=>{
+        const stack = stackRef.current;
+        if (!stack || !windowed) return;
+        const root = stack.closest('.work-document-scroll');
+        if (!root) {
+            const next = initialDocumentPageWindow(count);
+            setRequestedWindow((current)=>documentPageWindowsEqual(current, next) ? current : next);
+            return;
+        }
+        let animationFrame = 0;
+        const update = ()=>{
+            animationFrame = 0;
+            const next = documentPageWindowForViewport(geometry.frames, stack, root);
+            setRequestedWindow((current)=>documentPageWindowsEqual(current, next) ? current : next);
+        };
+        const schedule = ()=>{
+            if (animationFrame) return;
+            animationFrame = requestAnimationFrame(update);
+        };
+        const resizeObserver = "u" < typeof ResizeObserver ? null : new ResizeObserver(schedule);
+        root.addEventListener('scroll', schedule, {
+            passive: true
+        });
+        globalThis.addEventListener('resize', schedule);
+        resizeObserver?.observe(root);
+        resizeObserver?.observe(stack);
+        update();
+        return ()=>{
+            if (animationFrame) cancelAnimationFrame(animationFrame);
+            resizeObserver?.disconnect();
+            root.removeEventListener('scroll', schedule);
+            globalThis.removeEventListener('resize', schedule);
+        };
+    }, [
+        count,
+        geometry.frames,
+        windowed
+    ]);
     return /*#__PURE__*/ jsxs(Fragment, {
         children: [
             /*#__PURE__*/ jsx("div", {
+                ref: stackRef,
                 className: "work-document-page-stack",
                 "data-page-count": count,
                 "data-page-surface-height": geometry.height,
                 "data-page-surface-width": geometry.width,
+                "data-page-window-end": pageWindow.end,
+                "data-page-window-start": pageWindow.start + 1,
+                "data-page-windowed": String(windowed),
                 "aria-hidden": "true",
                 children: descriptors.map(({ frame, page })=>{
                     const resolvedPageSize = page ? resolveDocumentPageSize(page.layout) : null;
@@ -5585,6 +5964,69 @@ function DocumentPageStack({ pageColor, pageCount, pageGap, pageHeight, pageWidt
         ]
     });
 }
+function initialDocumentPageWindow(pageCount) {
+    return {
+        start: 0,
+        end: Math.min(pageCount, DOCUMENT_PAGE_INITIAL_WINDOW_SIZE)
+    };
+}
+function clampDocumentPageWindow(pageWindow, pageCount) {
+    const start = Math.max(0, Math.min(pageCount - 1, pageWindow.start));
+    const end = Math.max(start + 1, Math.min(pageCount, pageWindow.end));
+    return {
+        start,
+        end
+    };
+}
+function documentPageWindowForViewport(frames, stack, root) {
+    if (!frames.length) return {
+        start: 0,
+        end: 1
+    };
+    const stackRect = stack.getBoundingClientRect();
+    const rootRect = root.getBoundingClientRect();
+    if (!(stackRect.width > 0) || !(rootRect.height > 0)) return initialDocumentPageWindow(frames.length);
+    const scale = Math.max(0.01, stackRect.width / Math.max(1, stack.offsetWidth));
+    const viewportTop = Math.max(0, (rootRect.top - stackRect.top) / scale);
+    const viewportBottom = Math.max(viewportTop, (rootRect.bottom - stackRect.top) / scale);
+    const firstVisible = firstDocumentPageEndingAfter(frames, viewportTop);
+    const lastVisible = lastDocumentPageStartingBefore(frames, viewportBottom);
+    return {
+        start: Math.max(0, firstVisible - document_page_stack_DOCUMENT_PAGE_WINDOW_OVERSCAN),
+        end: Math.min(frames.length, Math.max(firstVisible + 1, lastVisible + 1) + document_page_stack_DOCUMENT_PAGE_WINDOW_OVERSCAN)
+    };
+}
+function firstDocumentPageEndingAfter(frames, offset) {
+    let lower = 0;
+    let upper = frames.length - 1;
+    let result = upper;
+    while(lower <= upper){
+        const middle = Math.floor((lower + upper) / 2);
+        const frame = frames[middle];
+        if (frame && frame.top + frame.height >= offset) {
+            result = middle;
+            upper = middle - 1;
+        } else lower = middle + 1;
+    }
+    return result;
+}
+function lastDocumentPageStartingBefore(frames, offset) {
+    let lower = 0;
+    let upper = frames.length - 1;
+    let result = 0;
+    while(lower <= upper){
+        const middle = Math.floor((lower + upper) / 2);
+        const frame = frames[middle];
+        if (frame && frame.top <= offset) {
+            result = middle;
+            lower = middle + 1;
+        } else upper = middle - 1;
+    }
+    return result;
+}
+function documentPageWindowsEqual(left, right) {
+    return left.start === right.start && left.end === right.end;
+}
 function DocumentRulerTabStops({ marginLeft, pageWidth, rulerRef, tabStops, textWidth, onChange }) {
     const normalized = constrainRulerTabStops(tabStops, textWidth);
     const positionFromClientX = (clientX)=>{
@@ -13262,7 +13704,7 @@ function useDocumentPageChrome({ editor, enabled, firstPage, footerRef, headerRe
         visibleChrome
     };
 }
-function planIncrementalDocumentLayout(previous, next, dirtyFrom) {
+function planIncrementalDocumentLayout(previous, next, dirtyFrom, reusedPrefixBlockCount = 0) {
     const fullLayout = ()=>({
             blocks: next.map(({ block })=>block),
             reusedPageCount: 0,
@@ -13270,7 +13712,8 @@ function planIncrementalDocumentLayout(previous, next, dirtyFrom) {
             startPageIndex: 0
         });
     if (!previous || !Number.isFinite(dirtyFrom) || dirtyFrom <= 0 || 0 !== previous.layout.startPageIndex || previous.layout.pages.length < 3) return fullLayout();
-    const affectedBlockIndex = earliestAffectedBlockIndex(previous.blocks, next, dirtyFrom);
+    const stablePrefixBlockCount = Math.max(0, Math.min(Math.trunc(reusedPrefixBlockCount), previous.blocks.length, next.length));
+    const affectedBlockIndex = earliestAffectedBlockIndex(previous.blocks, next, dirtyFrom, stablePrefixBlockCount);
     const pageByBlockId = new Map(previous.layout.pages.flatMap((page)=>page.placements.map((placement)=>[
                 placement.blockId,
                 page.index
@@ -13288,10 +13731,6 @@ function planIncrementalDocumentLayout(previous, next, dirtyFrom) {
             block.id,
             index
         ]));
-    const previousBlockById = new Map(previous.blocks.map(({ block })=>[
-            block.id,
-            block
-        ]));
     let startPageIndex = affectedPageIndex - 1;
     while(startPageIndex > 0){
         const startBlockId = previous.layout.pages[startPageIndex]?.placements[0]?.blockId;
@@ -13313,7 +13752,7 @@ function planIncrementalDocumentLayout(previous, next, dirtyFrom) {
             startPageIndex -= 1;
             continue;
         }
-        if (!prefixMatches(previous.layout.pages, startPageIndex, previousBlockById, next, startBlockIndex)) {
+        if (!prefixMatches(previous.layout.pages, startPageIndex, previous.blocks, next, startBlockIndex, stablePrefixBlockCount)) {
             startPageIndex -= 1;
             continue;
         }
@@ -13349,13 +13788,22 @@ function mergeIncrementalDocumentLayout(previous, partial) {
         ]
     };
 }
-function earliestAffectedBlockIndex(previous, next, dirtyFrom) {
-    const positionIndex = next.findIndex((candidate)=>candidate.to > dirtyFrom);
+function earliestAffectedBlockIndex(previous, next, dirtyFrom, stablePrefixBlockCount) {
+    let lower = 0;
+    let upper = next.length;
+    while(lower < upper){
+        const middle = Math.floor((lower + upper) / 2);
+        if (next[middle].to <= dirtyFrom) lower = middle + 1;
+        else upper = middle;
+    }
+    const positionIndex = lower < next.length ? lower : -1;
     const sharedLength = Math.min(previous.length, next.length);
-    let divergentIndex = -1;
-    for(let index = 0; index < sharedLength; index += 1)if (!sameLayoutBlock(previous[index].block, next[index].block)) {
-        divergentIndex = index;
-        break;
+    let divergentIndex = stablePrefixBlockCount > 0 && stablePrefixBlockCount < sharedLength ? stablePrefixBlockCount : -1;
+    if (0 === stablePrefixBlockCount) {
+        for(let index = 0; index < sharedLength; index += 1)if (!sameLayoutBlock(previous[index].block, next[index].block)) {
+            divergentIndex = index;
+            break;
+        }
     }
     if (divergentIndex < 0 && previous.length !== next.length) divergentIndex = sharedLength;
     const candidates = [
@@ -13366,14 +13814,18 @@ function earliestAffectedBlockIndex(previous, next, dirtyFrom) {
         Math.max(0, next.length - 1)
     ]);
 }
-function prefixMatches(pages, startPageIndex, previousBlockById, next, startBlockIndex) {
-    const prefixIds = pages.slice(0, startPageIndex).flatMap((page)=>page.placements.map((placement)=>placement.blockId));
-    if (prefixIds.length !== startBlockIndex) return false;
-    return prefixIds.every((blockId, index)=>{
-        const previous = previousBlockById.get(blockId);
-        const candidate = next[index]?.block;
-        return void 0 !== previous && candidate?.id === blockId && sameLayoutBlock(previous, candidate);
-    });
+function prefixMatches(pages, startPageIndex, previous, next, startBlockIndex, stablePrefixBlockCount) {
+    let blockIndex = 0;
+    for(let pageIndex = 0; pageIndex < startPageIndex; pageIndex += 1)for (const placement of pages[pageIndex]?.placements ?? []){
+        if (blockIndex >= startBlockIndex) return false;
+        if (blockIndex >= stablePrefixBlockCount) {
+            const previousBlock = previous[blockIndex]?.block;
+            const nextBlock = next[blockIndex]?.block;
+            if (previousBlock?.id !== placement.blockId || nextBlock?.id !== placement.blockId || !sameLayoutBlock(previousBlock, nextBlock)) return false;
+        }
+        blockIndex += 1;
+    }
+    return blockIndex === startBlockIndex;
 }
 function sameLayoutBlock(left, right) {
     return left.id === right.id && left.height === right.height && left.pageStyleId === right.pageStyleId && left.breakBefore === right.breakBefore && left.breakAfter === right.breakAfter && left.keepTogether === right.keepTogether && left.keepWithNext === right.keepWithNext && left.flowId === right.flowId && left.flowIndex === right.flowIndex && left.flowCount === right.flowCount && left.minimumFragmentsPerPage === right.minimumFragmentsPerPage && left.repeatHeaderCount === right.repeatHeaderCount && left.repeatHeaderHeight === right.repeatHeaderHeight;
@@ -13492,6 +13944,7 @@ function createDocumentPaginationRunCoordinator({ cancelFrame, onAbort, onCoales
         request
     };
 }
+const MAX_DOCUMENT_BLOCK_RESIZE_OBSERVATIONS = 4096;
 function useDocumentPagination({ editor, documentRevision, enabled, layoutKey, page, selectionVersion, wasmUrl, layoutFonts, loadedLayoutFontIds }) {
     const client = useOfficeKernelClient(wasmUrl, layoutFonts);
     const editorMounted = useEditorMounted(editor);
@@ -13537,6 +13990,7 @@ function useDocumentPagination({ editor, documentRevision, enabled, layoutKey, p
                     delete editorDom.dataset.paginationFallbackGlyphs;
                     delete editorDom.dataset.paginationFlows;
                     delete editorDom.dataset.paginationMeasuredBlocks;
+                    delete editorDom.dataset.paginationObservedBlocks;
                     delete editorDom.dataset.paginationLaidOutBlocks;
                     delete editorDom.dataset.paginationPages;
                     delete editorDom.dataset.paginationReusedBlocks;
@@ -13556,6 +14010,7 @@ function useDocumentPagination({ editor, documentRevision, enabled, layoutKey, p
                     delete editorDom.dataset.paginationDocumentTriggers;
                     delete editorDom.dataset.paginationFontTriggers;
                     delete editorDom.dataset.paginationResizeTriggers;
+                    delete editorDom.dataset.paginationResizeScope;
                     delete editorDom.dataset.paginationRuns;
                     delete editorDom.dataset.paginationTextBatch;
                     delete editorDom.dataset.paginationTextBatches;
@@ -13618,7 +14073,10 @@ function useDocumentPagination({ editor, documentRevision, enabled, layoutKey, p
         };
         const observeBlocks = (blocks)=>{
             stopObservingBlocks();
-            observedBlockPositions = documentResizeObservationPositions(blocks);
+            const observation = documentResizeObservationTargets(editorDom, blocks);
+            editorDom.dataset.paginationObservedBlocks = String(observation.observedBlockCount);
+            editorDom.dataset.paginationResizeScope = observation.scope;
+            observedBlockPositions = observation.positions;
             observedElements = Array.from(observedBlockPositions.keys());
             observedHeights.clear();
             for (const element of observedElements)observedHeights.set(element, element.offsetHeight);
@@ -13700,7 +14158,7 @@ function useDocumentPagination({ editor, documentRevision, enabled, layoutKey, p
                     return;
                 }
                 const previousPagination = paginationCache.current;
-                const layoutPlan = planIncrementalDocumentLayout(previousPagination, snapshot.blocks, measurementStart);
+                const layoutPlan = planIncrementalDocumentLayout(previousPagination, snapshot.blocks, measurementStart, snapshot.reusedPrefixBlockCount);
                 editorDom.dataset.paginationLaidOutBlocks = String(layoutPlan.blocks.length);
                 editorDom.dataset.paginationReusedPages = String(layoutPlan.reusedPageCount);
                 try {
@@ -13806,7 +14264,11 @@ function useDocumentPagination({ editor, documentRevision, enabled, layoutKey, p
         const markDirty = (position)=>{
             measurementRange.invalidate(position);
         };
-        const handleDocumentUpdate = ({ transaction })=>{
+        const handleDocumentUpdate = ({ appendedTransactions, transaction })=>{
+            if (documentTransactionsOnlyHydrateChunks([
+                transaction,
+                ...appendedTransactions ?? []
+            ])) return;
             updateDiagnostic('documentTriggers', 'paginationDocumentTriggers');
             markDirty(earliestChangedPosition(transaction));
             schedule(true);
@@ -13914,6 +14376,24 @@ function documentResizeObservationPositions(blocks) {
     }
     return positions;
 }
+function documentResizeObservationTargets(editorDom, blocks) {
+    const positions = documentResizeObservationPositions(blocks);
+    if (positions.size <= MAX_DOCUMENT_BLOCK_RESIZE_OBSERVATIONS) return {
+        observedBlockCount: positions.size,
+        positions,
+        scope: 'blocks'
+    };
+    return {
+        observedBlockCount: positions.size,
+        positions: new Map([
+            [
+                editorDom,
+                0
+            ]
+        ]),
+        scope: 'document'
+    };
+}
 function deriveDocumentPaginationPageDescriptors(layout, blocks, documentNode, previousPages = [], requestedReusedPageCount = 0) {
     const blockById = new Map(blocks.map((candidate)=>[
             candidate.block.id,
@@ -14062,20 +14542,25 @@ function pageForPosition(pagination, position) {
     return block ? pagination.pageByBlockId.get(block.block.id) ?? 1 : 1;
 }
 function blockForPosition(blocks, position) {
-    const rangedBlock = blocks.find((block)=>block.selectionRanges?.some((range)=>range.from <= position && position < range.to));
-    if (rangedBlock) return rangedBlock;
+    if (!blocks.length) return;
     let lower = 0;
     let upper = blocks.length - 1;
-    let containing = blocks[0];
+    let containingIndex = 0;
     while(lower <= upper){
         const middle = Math.floor((lower + upper) / 2);
         const candidate = blocks[middle];
         if (candidate.from <= position) {
-            containing = candidate;
+            containingIndex = middle;
             lower = middle + 1;
         } else upper = middle - 1;
     }
-    return containing;
+    let overlappingFrom = containingIndex;
+    while(overlappingFrom > 0 && blocks[overlappingFrom - 1].to > position)overlappingFrom -= 1;
+    for(let index = overlappingFrom; index <= containingIndex; index += 1){
+        const candidate = blocks[index];
+        if (candidate.selectionRanges?.some((range)=>range.from <= position && position < range.to)) return candidate;
+    }
+    return blocks[containingIndex];
 }
 function pageMetricsKey(page) {
     return [
@@ -14395,20 +14880,29 @@ function DocumentEditorSurface({ artifactId, autoFocus = true, collaboration, co
     const citationsDraftFocusRef = useRef(null);
     const statisticsInvokerRef = useRef(null);
     const contentRef = useRef(effectiveContent);
+    const editorMountStartedAtRef = useRef(documentEditorNow());
+    const editorBeforeCreateAtRef = useRef(null);
+    const editorDetachedMountAtRef = useRef(null);
     const onChangeRef = useRef(onChange);
     const trackChangesRef = useRef(suggestionOnly || Boolean(effectiveContent.trackChanges));
     const collaborationBindingRef = useRef(collaborationBinding);
-    const normalizedContent = useMemo(()=>normalizeDocumentHtml(effectiveContent), [
+    const validatedModel = useMemo(()=>documentModelForContent(effectiveContent), [
         effectiveContent
     ]);
-    const editorInput = useMemo(()=>resolveWorkDocumentEditorInput(effectiveContent, normalizedContent), [
+    const normalizedContent = useMemo(()=>validatedModel ? effectiveContent.html : normalizeDocumentHtml(effectiveContent), [
         effectiveContent,
-        normalizedContent
+        validatedModel
+    ]);
+    const editorInput = useMemo(()=>resolveWorkDocumentEditorInput(effectiveContent, normalizedContent, validatedModel), [
+        effectiveContent,
+        normalizedContent,
+        validatedModel
     ]);
     const initialEditorSourceRef = useRef(editorInput.source);
     const appliedSourceKeyRef = useRef(editorInput.sourceKey);
     const activeReviewConflictsRef = useRef([]);
     const publishedDocumentRef = useRef(null);
+    const pendingLazyPublicationRef = useRef(null);
     const [taskPane, setTaskPane] = useState(null);
     const [layoutPanelTab, setLayoutPanelTab] = useState('page');
     const [findReplaceFocusRequest, setFindReplaceFocusRequest] = useState(0);
@@ -14453,7 +14947,10 @@ function DocumentEditorSurface({ artifactId, autoFocus = true, collaboration, co
             });
         }
     };
-    const editorExtensions = useMemo(()=>mergeOfficeTiptapExtensions('DocumentEditor', [
+    const trustInitialIntegrityFeatures = documentModelHasTrustedInitialIntegrityFeatures(editorInput.model);
+    const editorExtensions = useMemo(()=>{
+        const startedAt = documentEditorNow();
+        const merged = mergeOfficeTiptapExtensions('DocumentEditor', [
             ...collaborationBinding?.extensions ?? createWorkDocumentExtensions({
                 getContent: ()=>contentRef.current,
                 isTracking: ()=>trackChangesRef.current,
@@ -14469,17 +14966,22 @@ function DocumentEditorSurface({ artifactId, autoFocus = true, collaboration, co
                         trackChanges
                     };
                     commitContentChange(next);
-                }
+                },
+                trustInitialIntegrityFeatures
             }),
             extension_placeholder.configure({
                 placeholder: '在这里开始输入…'
             }),
             DocumentPagination
-        ], collaboration ? EMPTY_DOCUMENT_EXTENSIONS : extensions), [
+        ], collaboration ? EMPTY_DOCUMENT_EXTENSIONS : extensions);
+        recordDocumentEditorMeasure('a3s-office.document.editor-extensions', startedAt, documentEditorNow());
+        return merged;
+    }, [
         collaboration,
         collaborationBinding,
         commitContentChange,
-        extensions
+        extensions,
+        trustInitialIntegrityFeatures
     ]);
     const editorProps = useMemo(()=>({
             attributes: {
@@ -14492,16 +14994,107 @@ function DocumentEditorSurface({ artifactId, autoFocus = true, collaboration, co
         }), [
         commentOnly
     ]);
+    const publishDocumentUpdate = useCallback((current, previousDocument)=>{
+        if (current.isDestroyed || previousDocument.eq(current.state.doc)) return;
+        const publishStartedAt = documentEditorNow();
+        const previousContent = contentRef.current;
+        const previousModel = previousContent.model;
+        const compactRoot = current.getJSON();
+        const materialized = previousModel && documentLazyHtmlProjection(previousModel) ? materializeLazyDocumentUpdate(previousDocument, current.state.doc, compactRoot, previousModel) : {
+            html: null,
+            htmlFingerprint: null,
+            root: materializeLazyDocumentEditorRoot(compactRoot, previousModel)
+        };
+        const anchors = collectDocumentCommentAnchors(current.state.doc);
+        const retainedCommentIds = new Set(activeReviewConflictsRef.current.filter((conflict)=>'comment' === conflict.kind).map((conflict)=>conflict.id));
+        const synchronized = null === materialized.html ? syncDocumentContentFromHtml(previousContent, documentModelUsesWindowing(materialized.root) ? serializeWorkDocumentNode(materialized.root) : current.getHTML()) : {
+            ...previousContent,
+            html: materialized.html
+        };
+        const model = createSchemaDerivedWorkDocumentModel(synchronized.html, materialized.root, previousModel, materialized.htmlFingerprint ?? void 0);
+        const next = {
+            ...synchronized,
+            model,
+            comments: retainAnchoredDocumentComments(previousContent.comments ?? [], anchors, retainedCommentIds)
+        };
+        appliedSourceKeyRef.current = `model:${model.revision}:${model.htmlFingerprint}`;
+        if (!collaborationBindingRef.current) {
+            contentRef.current = next;
+            onChangeRef.current(next);
+        }
+        const publishEndedAt = documentEditorNow();
+        const publishCount = Number(current.view.dom.dataset.documentControlledPublishCount) || 0;
+        current.view.dom.dataset.documentControlledPublishCount = String(publishCount + 1);
+        current.view.dom.dataset.documentControlledPublishMode = null === materialized.html ? 'full' : 'lazy-chunk';
+        current.view.dom.dataset.documentControlledPublishMs = String(Math.round((publishEndedAt - publishStartedAt) * 10) / 10);
+        recordDocumentEditorMeasure('a3s-office.document.controlled-publish', publishStartedAt, publishEndedAt, {
+            mode: current.view.dom.dataset.documentControlledPublishMode
+        });
+    }, []);
+    const queueLazyDocumentPublication = useCallback((current, previousDocument)=>{
+        const pending = pendingLazyPublicationRef.current;
+        if (pending) {
+            pending.editor = current;
+            return;
+        }
+        const flush = ()=>{
+            const queued = pendingLazyPublicationRef.current;
+            pendingLazyPublicationRef.current = null;
+            if (queued) publishDocumentUpdate(queued.editor, queued.before);
+        };
+        pendingLazyPublicationRef.current = {
+            before: previousDocument,
+            cancel: scheduleDocumentEditorFrame(flush),
+            editor: current
+        };
+    }, [
+        publishDocumentUpdate
+    ]);
+    useEffect(()=>()=>{
+            const pending = pendingLazyPublicationRef.current;
+            pendingLazyPublicationRef.current = null;
+            if (!pending) return;
+            pending.cancel();
+            publishDocumentUpdate(pending.editor, pending.before);
+        }, [
+        publishDocumentUpdate
+    ]);
     const editor = useEditor({
+        immediatelyRender: false,
         extensions: editorExtensions,
         content: collaboration ? void 0 : initialEditorSourceRef.current,
         editable: !readOnly,
         editorProps,
+        onBeforeCreate: ()=>{
+            const beforeCreateAt = documentEditorNow();
+            editorBeforeCreateAtRef.current = beforeCreateAt;
+            recordDocumentEditorMeasure('a3s-office.document.editor-before-create', editorMountStartedAtRef.current, beforeCreateAt);
+        },
+        onMount: ()=>{
+            const mountedAt = documentEditorNow();
+            editorDetachedMountAtRef.current = mountedAt;
+            const beforeCreateAt = editorBeforeCreateAtRef.current;
+            if (null !== beforeCreateAt) recordDocumentEditorMeasure('a3s-office.document.editor-state-view', beforeCreateAt, mountedAt);
+        },
         onCreate: ({ editor: current })=>{
             publishedDocumentRef.current = current.state.doc;
+            const mountedAt = documentEditorNow();
+            const detachedMountAt = editorDetachedMountAtRef.current;
+            if (null !== detachedMountAt) recordDocumentEditorMeasure('a3s-office.document.editor-create-dispatch', detachedMountAt, mountedAt);
+            current.view.dom.dataset.documentEditorMountMs = String(Math.round((mountedAt - editorMountStartedAtRef.current) * 10) / 10);
+            recordDocumentEditorMeasure('a3s-office.document.editor-mount', editorMountStartedAtRef.current, mountedAt, {
+                source: editorInput.model ? 'model' : 'html',
+                windowed: Boolean(editorInput.model && documentModelUsesWindowing(editorInput.model.root))
+            });
+        },
+        onTransaction: ({ appendedTransactions, editor: current, transaction })=>{
+            if (documentTransactionsOnlyHydrateChunks([
+                transaction,
+                ...appendedTransactions
+            ])) publishedDocumentRef.current = current.state.doc;
         },
-        onUpdate: ({ editor: current, transaction })=>{
-            if (!shouldPublishDocumentUpdate(transaction)) {
+        onUpdate: ({ appendedTransactions, editor: current, transaction })=>{
+            if (!shouldPublishDocumentUpdate(transaction, appendedTransactions ?? [])) {
                 publishedDocumentRef.current = current.state.doc;
                 return;
             }
@@ -14509,22 +15102,13 @@ function DocumentEditorSurface({ artifactId, autoFocus = true, collaboration, co
                 publishedDocumentRef.current = current.state.doc;
                 return;
             }
-            if (publishedDocumentRef.current.eq(current.state.doc)) return;
+            const previousDocument = publishedDocumentRef.current;
+            if (previousDocument.eq(current.state.doc)) return;
+            const lazyProjection = documentLazyHtmlProjection(contentRef.current.model);
+            if (lazyProjection) transferLazyDocumentTextStatistics(previousDocument, current.state.doc);
             publishedDocumentRef.current = current.state.doc;
-            const anchors = collectDocumentCommentAnchors(current.state.doc);
-            const retainedCommentIds = new Set(activeReviewConflictsRef.current.filter((conflict)=>'comment' === conflict.kind).map((conflict)=>conflict.id));
-            const synchronized = syncDocumentContentFromHtml(contentRef.current, current.getHTML());
-            const model = createWorkDocumentModel(synchronized.html, current.getJSON(), contentRef.current.model);
-            const next = {
-                ...synchronized,
-                model,
-                comments: retainAnchoredDocumentComments(contentRef.current.comments ?? [], anchors, retainedCommentIds)
-            };
-            appliedSourceKeyRef.current = `model:${model.revision}:${model.htmlFingerprint}`;
-            if (!collaborationBinding) {
-                contentRef.current = next;
-                onChangeRef.current(next);
-            }
+            if (lazyProjection) queueLazyDocumentPublication(current, previousDocument);
+            else publishDocumentUpdate(current, previousDocument);
         },
         onSelectionUpdate: ()=>setSelectionVersion((value)=>value + 1)
     });
@@ -15478,4 +16062,24 @@ function cssPixelValue(value) {
     const parsed = Number.parseFloat(value);
     return Number.isFinite(parsed) ? parsed : 0;
 }
+function scheduleDocumentEditorFrame(callback) {
+    if ('function' == typeof requestAnimationFrame) {
+        const frame = requestAnimationFrame(callback);
+        return ()=>cancelAnimationFrame(frame);
+    }
+    const timeout = setTimeout(callback, 0);
+    return ()=>clearTimeout(timeout);
+}
+function documentEditorNow() {
+    return globalThis.performance?.now?.() ?? Date.now();
+}
+function recordDocumentEditorMeasure(name, start, end, detail) {
+    try {
+        globalThis.performance?.measure(name, {
+            detail,
+            end,
+            start
+        });
+    } catch  {}
+}
 export { document_editor_namespaceObject };