@a3s-lab/office 0.12.0 → 0.13.1

package/dist/{8928.js → 6282.js}

@@ -1,6 +1,6 @@
 import { Extension, Mark, Node as core_Node, ResizableNodeView, generateHTML, getSchema, mergeAttributes } from "@tiptap/core";
 import { Collaboration, isChangeOrigin } from "@tiptap/extension-collaboration";
-import { NodeSelection, Plugin, PluginKey, TextSelection } from "@tiptap/pm/state";
+import { NodeSelection, Plugin, PluginKey, Selection, TextSelection } from "@tiptap/pm/state";
 import { AddMarkStep, Mapping, RemoveMarkStep, ReplaceAroundStep, ReplaceStep } from "@tiptap/pm/transform";
 import { defaultDeleteFilter, defaultProtectedNodes, prosemirrorJSONToYXmlFragment, ySyncPluginKey, yXmlFragmentToProsemirrorJSON } from "@tiptap/y-tiptap";
 import extension_color from "@tiptap/extension-color";
@@ -195,6 +195,71 @@ function normalizedReferenceText(value) {
 function stringAttribute(value) {
     return 'string' == typeof value ? value.trim() : '';
 }
+const DOCUMENT_INTEGRITY_BOOKMARK = 1;
+const DOCUMENT_INTEGRITY_FIELD = 2;
+const DOCUMENT_INTEGRITY_IMAGE = 4;
+const DOCUMENT_INTEGRITY_NOTE = 8;
+const DOCUMENT_INTEGRITY_PARAGRAPH_IDENTITY = 16;
+const DOCUMENT_INTEGRITY_TABLE_ROW_IDENTITY = 32;
+const featureCache = new WeakMap();
+function documentHasIntegrityFeature(document1, feature) {
+    return (documentIntegrityFeatures(document1, true) & feature) !== 0;
+}
+function primeDocumentIntegrityFeatures(document1) {
+    document1.forEach(primeDocumentIntegrityNode);
+}
+function primeDocumentIntegrityNode(node) {
+    if ('documentChunk' === node.type.name) {
+        const features = nonNegativeInteger(node.attrs.integrityFeatures);
+        if (null !== features) featureCache.set(node, features);
+        if (true !== node.attrs.windowContainer) return;
+    }
+    node.forEach(primeDocumentIntegrityNode);
+}
+function documentIntegrityFeatures(node, cacheNode) {
+    if (cacheNode) {
+        const cached = featureCache.get(node);
+        if (void 0 !== cached) return cached;
+    }
+    let features = nodeIntegrityFeatures(node);
+    node.forEach((child)=>{
+        features |= documentIntegrityFeatures(child, 'documentChunk' === child.type.name);
+    });
+    if (cacheNode) featureCache.set(node, features);
+    return features;
+}
+function nodeIntegrityFeatures(node) {
+    let features = 0;
+    switch(node.type.name){
+        case 'documentBookmarkBoundary':
+            features |= DOCUMENT_INTEGRITY_BOOKMARK;
+            break;
+        case 'documentCrossReference':
+            if ('bookmark' === node.attrs.targetType) features |= DOCUMENT_INTEGRITY_BOOKMARK;
+            break;
+        case 'documentField':
+            features |= DOCUMENT_INTEGRITY_FIELD;
+            break;
+        case 'image':
+            features |= DOCUMENT_INTEGRITY_IMAGE;
+            break;
+        case 'documentNote':
+        case 'documentNoteReference':
+            features |= DOCUMENT_INTEGRITY_NOTE;
+            break;
+    }
+    if (node.isText && node.marks.some((mark)=>'link' === mark.type.name && 'string' == typeof mark.attrs.href && mark.attrs.href.startsWith('#'))) features |= DOCUMENT_INTEGRITY_BOOKMARK;
+    if (identityComponent(node.attrs.paragraphId) || identityComponent(node.attrs.textId)) features |= DOCUMENT_INTEGRITY_PARAGRAPH_IDENTITY;
+    if (identityComponent(node.attrs.rowId) || identityComponent(node.attrs.rowTextId)) features |= DOCUMENT_INTEGRITY_TABLE_ROW_IDENTITY;
+    return features;
+}
+function identityComponent(value) {
+    return 'string' == typeof value && value.trim().length > 0;
+}
+function nonNegativeInteger(value) {
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number >= 0 ? number : null;
+}
 const BOOKMARK_NAME_PATTERN = /^[\p{L}_][\p{L}\p{N}_]*$/u;
 const BOOKMARK_UI_NAME_PATTERN = /^[\p{L}][\p{L}\p{N}_]*$/u;
 const MAX_BOOKMARK_NAME_LENGTH = 40;
@@ -403,6 +468,7 @@ function createDocumentBookmarkPlugin(boundaryNodeName) {
     });
 }
 function normalizeDocumentBookmarks(state, boundaryNodeName, oldState, transactions = []) {
+    if ('documentBookmarkBoundary' === boundaryNodeName && !documentHasIntegrityFeature(state.doc, 1)) return null;
     const collection = collectDocumentBookmarkPairs(state.doc, boundaryNodeName);
     const retained = oldState ? retainedDocumentBookmarkPairs(oldState, state, transactions, boundaryNodeName) : new Set();
     const ordered = [
@@ -1351,31 +1417,519 @@ function millimetersToPixels(value) {
 function validMargin(value, fallback) {
     return Number.isFinite(value) ? clampDocumentMargin(value) : fallback;
 }
+const DOCUMENT_HTML_FINGERPRINT_VERSION = 'p1';
+const DOCUMENT_HTML_HASH_BASE = 0x01000193;
+const LEGACY_FNV_OFFSET = 0x811c9dc5;
+function createDocumentHtmlFingerprintSegment(source, from = 0, to = source.length) {
+    if (!Number.isSafeInteger(from) || !Number.isSafeInteger(to) || from < 0 || to < from || to > source.length) throw new RangeError('The document HTML fingerprint range is invalid.');
+    let hash = 0;
+    for(let index = from; index < to; index += 1)hash = Math.imul(hash, DOCUMENT_HTML_HASH_BASE) + source.charCodeAt(index) >>> 0;
+    const length = to - from;
+    return {
+        hash,
+        length,
+        power: documentHtmlHashPower(length)
+    };
+}
+function combineDocumentHtmlFingerprintSegments(segments) {
+    let combined = {
+        hash: 0,
+        length: 0,
+        power: 1
+    };
+    for (const segment of segments)combined = {
+        hash: Math.imul(combined.hash, segment.power) + segment.hash >>> 0,
+        length: combined.length + segment.length,
+        power: Math.imul(combined.power, segment.power) >>> 0
+    };
+    return combined;
+}
+function documentHtmlFingerprintForSegment(segment) {
+    return `${DOCUMENT_HTML_FINGERPRINT_VERSION}:${segment.length.toString(36)}:${segment.hash.toString(36)}`;
+}
+function documentHtmlFingerprint(html) {
+    return documentHtmlFingerprintForSegment(createDocumentHtmlFingerprintSegment(html));
+}
+function documentHtmlFingerprintMatches(html, candidate) {
+    return candidate.startsWith(`${DOCUMENT_HTML_FINGERPRINT_VERSION}:`) ? candidate === documentHtmlFingerprint(html) : candidate === legacyDocumentHtmlFingerprint(html);
+}
+function legacyDocumentHtmlFingerprint(html) {
+    let hash = LEGACY_FNV_OFFSET;
+    for(let index = 0; index < html.length; index += 1){
+        hash ^= html.charCodeAt(index);
+        hash = Math.imul(hash, DOCUMENT_HTML_HASH_BASE);
+    }
+    return `${html.length.toString(36)}:${(hash >>> 0).toString(36)}`;
+}
+function documentHtmlHashPower(length) {
+    let exponent = length;
+    let factor = DOCUMENT_HTML_HASH_BASE;
+    let power = 1;
+    while(exponent > 0){
+        if (exponent % 2 === 1) power = Math.imul(power, factor) >>> 0;
+        factor = Math.imul(factor, factor) >>> 0;
+        exponent = Math.floor(exponent / 2);
+    }
+    return power;
+}
+const SECTION_CLOSE = '</section>';
+const TABLE_BODY_OPEN = '<tbody>';
+const TABLE_CLOSE = '</tbody></table>';
+const projectionFingerprints = new WeakMap();
+function createDocumentLazyHtmlProjection(html, root) {
+    if (!html.startsWith('<section') || !html.endsWith(SECTION_CLOSE)) return null;
+    const sectionOpenEnd = html.indexOf('>') + 1;
+    if (sectionOpenEnd <= 0) return null;
+    let cursor = sectionOpenEnd;
+    const orderedRanges = [];
+    const ranges = new Map();
+    for (const chunk of lazyDocumentLeafChunks(root)){
+        const id = 'string' == typeof chunk.attrs?.id ? chunk.attrs.id : '';
+        if (!id || ranges.has(id)) return null;
+        const from = cursor;
+        let tablePart = null;
+        const content = chunk.content ?? [];
+        for (const node of content){
+            const scanned = scanSimpleDocumentNodeHtml(html, cursor, node);
+            if (!scanned) return null;
+            cursor = scanned.to;
+            if (scanned.tablePart) {
+                if (1 !== content.length || tablePart) return null;
+                tablePart = scanned.tablePart;
+            }
+        }
+        const range = {
+            from,
+            id,
+            tablePart,
+            to: cursor
+        };
+        orderedRanges.push(range);
+        ranges.set(id, range);
+    }
+    if (cursor !== html.length - SECTION_CLOSE.length) return null;
+    return {
+        html,
+        orderedRanges,
+        ranges
+    };
+}
+function patchDocumentLazyHtmlProjection(projection, replacements) {
+    if (!replacements.size) return projection.html;
+    for (const id of replacements.keys())if (!projection.ranges.has(id)) return null;
+    const fingerprintState = documentLazyHtmlFingerprintState(projection);
+    const parts = [];
+    let cursor = 0;
+    for (const range of projection.orderedRanges){
+        const replacement = replacements.get(range.id);
+        if (void 0 !== replacement) {
+            parts.push(projection.html.slice(cursor, range.from), replacement);
+            fingerprintState.ranges.set(range.id, createDocumentHtmlFingerprintSegment(replacement));
+            cursor = range.to;
+        }
+    }
+    parts.push(projection.html.slice(cursor));
+    const html = parts.join('');
+    let offset = 0;
+    for (const range of projection.orderedRanges){
+        const previousFrom = range.from;
+        const previousLength = range.to - previousFrom;
+        const replacement = replacements.get(range.id);
+        const nextLength = replacement?.length ?? previousLength;
+        range.from = previousFrom + offset;
+        range.to = range.from + nextLength;
+        offset += nextLength - previousLength;
+    }
+    projection.html = html;
+    fingerprintState.fingerprint = documentHtmlFingerprintForSegment(combineDocumentHtmlFingerprintSegments([
+        fingerprintState.prefix,
+        ...projection.orderedRanges.map((range)=>{
+            const segment = fingerprintState.ranges.get(range.id);
+            if (!segment) throw new Error('The lazy HTML fingerprint segment is missing.');
+            return segment;
+        }),
+        fingerprintState.suffix
+    ]));
+    return html;
+}
+function documentLazyHtmlProjectionFingerprint(projection) {
+    return projectionFingerprints.get(projection)?.fingerprint ?? null;
+}
+function documentLazyHtmlChunkFragment(html, tablePart) {
+    if (!tablePart || 'complete' === tablePart) return html;
+    const bodyOpen = html.indexOf(TABLE_BODY_OPEN);
+    const bodyClose = html.lastIndexOf('</tbody>');
+    if (bodyOpen < 0 || bodyClose < bodyOpen) return null;
+    const rowsFrom = bodyOpen + TABLE_BODY_OPEN.length;
+    if ('first' === tablePart) return html.slice(0, bodyClose);
+    if ('middle' === tablePart) return html.slice(rowsFrom, bodyClose);
+    return html.slice(rowsFrom);
+}
+function lazyDocumentLeafChunks(root) {
+    const chunks = [];
+    const pending = [
+        root
+    ];
+    while(pending.length){
+        const node = pending.pop();
+        if (!node) continue;
+        if ('documentChunk' === node.type && node.attrs?.windowContainer !== true) {
+            chunks.push(node);
+            continue;
+        }
+        for(let index = (node.content?.length ?? 0) - 1; index >= 0; index -= 1){
+            const child = node.content?.[index];
+            if (child) pending.push(child);
+        }
+    }
+    return chunks;
+}
+function documentLazyHtmlFingerprintState(projection) {
+    const existing = projectionFingerprints.get(projection);
+    if (existing) return existing;
+    const first = projection.orderedRanges[0];
+    const last = projection.orderedRanges.at(-1);
+    const ranges = new Map();
+    for (const range of projection.orderedRanges)ranges.set(range.id, createDocumentHtmlFingerprintSegment(projection.html, range.from, range.to));
+    const prefix = createDocumentHtmlFingerprintSegment(projection.html, 0, first?.from ?? projection.html.length);
+    const suffix = createDocumentHtmlFingerprintSegment(projection.html, last?.to ?? projection.html.length, projection.html.length);
+    const state = {
+        fingerprint: documentHtmlFingerprintForSegment(combineDocumentHtmlFingerprintSegments([
+            prefix,
+            ...projection.orderedRanges.map((range)=>{
+                const segment = ranges.get(range.id);
+                if (!segment) throw new Error('The lazy HTML fingerprint segment is missing.');
+                return segment;
+            }),
+            suffix
+        ])),
+        prefix,
+        ranges,
+        suffix
+    };
+    projectionFingerprints.set(projection, state);
+    return state;
+}
+function scanSimpleDocumentNodeHtml(html, from, node) {
+    if ('paragraph' === node.type) {
+        if (!html.startsWith('<p>', from)) return null;
+        const close = html.indexOf('</p>', from + 3);
+        return close < 0 ? null : {
+            tablePart: null,
+            to: close + 4
+        };
+    }
+    if ('table' !== node.type) return null;
+    const virtualIndex = Number(node.attrs?.virtualTableIndex);
+    const virtualCount = Number(node.attrs?.virtualTableCount);
+    const virtual = Boolean('string' == typeof node.attrs?.virtualTableId && node.attrs.virtualTableId && Number.isSafeInteger(virtualIndex) && Number.isSafeInteger(virtualCount) && virtualIndex >= 0 && virtualCount > 0 && virtualIndex < virtualCount);
+    let cursor = from;
+    if (!virtual || 0 === virtualIndex) {
+        if (!html.startsWith('<table', cursor)) return null;
+        const body = html.indexOf(TABLE_BODY_OPEN, cursor);
+        if (body < 0) return null;
+        cursor = body + TABLE_BODY_OPEN.length;
+    }
+    for (const row of node.content ?? []){
+        if ('tableRow' !== row.type || !html.startsWith('<tr>', cursor)) return null;
+        const close = html.indexOf('</tr>', cursor + 4);
+        if (close < 0) return null;
+        cursor = close + 5;
+    }
+    if (!virtual || virtualIndex === virtualCount - 1) {
+        if (!html.startsWith(TABLE_CLOSE, cursor)) return null;
+        cursor += TABLE_CLOSE.length;
+    }
+    const tablePart = virtual ? 1 === virtualCount ? 'complete' : 0 === virtualIndex ? 'first' : virtualIndex === virtualCount - 1 ? 'last' : 'middle' : 'complete';
+    return {
+        tablePart,
+        to: cursor
+    };
+}
+const DOCUMENT_LAZY_BLOCK_NODE = 'documentLazyBlock';
+const DOCUMENT_LAZY_INITIAL_CHUNK_COUNT = 2;
+const DOCUMENT_LAZY_POSITION_BOUNDARY = '\ufffc';
+const SIMPLE_LAZY_CONTAINER_TYPES = new Set([
+    'paragraph',
+    'table',
+    'tableCell',
+    'tableRow'
+]);
+const preparedModels = new WeakMap();
+function prepareLazyDocumentEditorSource(model, allowCreate, html) {
+    const startedAt = lazyDocumentNow();
+    const cacheHit = preparedModels.has(model);
+    let prepared = preparedModels.get(model);
+    if (prepared) {
+        if (!prepared.root) {
+            const htmlProjection = prepared.htmlProjection;
+            const rebuilt = createPreparedLazyDocumentEditorSource(model.root, prepared.payloads);
+            if (!rebuilt) return null;
+            rebuilt.htmlProjection = htmlProjection;
+            prepared = rebuilt;
+            preparedModels.set(model, rebuilt);
+        }
+    } else {
+        if (!allowCreate) return null;
+        const created = createPreparedLazyDocumentEditorSource(model.root);
+        if (!created) return null;
+        prepared = created;
+        preparedModels.set(model, created);
+    }
+    if (!prepared.htmlProjection && html) prepared.htmlProjection = createDocumentLazyHtmlProjection(html, model.root);
+    if (!prepared.root) return null;
+    const result = {
+        lazyChunkCount: prepared.lazyChunkCount,
+        payloads: prepared.payloads,
+        root: prepared.root
+    };
+    recordLazyDocumentMeasure('a3s-office.document.lazy-editor-source', startedAt, lazyDocumentNow(), {
+        cacheHit
+    });
+    return result;
+}
+function documentLazyHtmlProjection(model) {
+    return model ? preparedModels.get(model)?.htmlProjection ?? null : null;
+}
+function invalidateDocumentLazyHtmlProjection(model) {
+    if (model) {
+        const prepared = preparedModels.get(model);
+        if (prepared) prepared.htmlProjection = null;
+    }
+}
+function documentLazyChunkContent(model, chunkId) {
+    if (!model || !chunkId) return null;
+    return preparedModels.get(model)?.payloads.get(chunkId) ?? null;
+}
+function materializeLazyDocumentEditorRoot(root, model) {
+    const prepared = model ? preparedModels.get(model) : null;
+    if (!prepared) return root;
+    const visit = (node)=>{
+        if ('documentChunk' === node.type && node.attrs?.windowContainer !== true) {
+            const id = documentChunkId(node);
+            if (!id) return node;
+            if (documentChunkIsLazy(node)) {
+                const payload = prepared.payloads.get(id);
+                if (!payload) throw new Error(`The lazy document chunk payload "${id}" is missing.`);
+                return {
+                    ...node,
+                    content: [
+                        ...payload
+                    ]
+                };
+            }
+            if (node.content?.length) prepared.payloads.set(id, node.content);
+            return node;
+        }
+        if (!node.content?.length) return node;
+        let changed = false;
+        const content = node.content.map((child)=>{
+            const next = visit(child);
+            if (next !== child) changed = true;
+            return next;
+        });
+        return changed ? {
+            ...node,
+            content
+        } : node;
+    };
+    return visit(root);
+}
+function transferLazyDocumentModelState(previous, next) {
+    if (!previous) return;
+    const prepared = preparedModels.get(previous);
+    if (!prepared) return;
+    preparedModels.set(next, {
+        htmlProjection: prepared.htmlProjection,
+        lazyChunkCount: prepared.lazyChunkCount,
+        payloads: prepared.payloads,
+        root: null
+    });
+}
+function simpleDocumentNodeSize(node) {
+    if ('text' === node.type) return 'string' == typeof node.text && node.text ? node.text.length : null;
+    if (!SIMPLE_LAZY_CONTAINER_TYPES.has(node.type)) return null;
+    let size = 2;
+    for (const child of node.content ?? []){
+        const childSize = simpleDocumentNodeSize(child);
+        if (null === childSize) return null;
+        size += childSize;
+    }
+    return size;
+}
+function createPreparedLazyDocumentEditorSource(root, previousPayloads) {
+    const payloads = new Map();
+    let leafIndex = 0;
+    let lazyChunkCount = 0;
+    let unsupported = false;
+    const visit = (node)=>{
+        if ('documentChunk' === node.type && node.attrs?.windowContainer !== true) {
+            const id = documentChunkId(node);
+            const payload = id ? previousPayloads?.get(id) ?? node.content ?? [] : [];
+            if (!id || !payload.length) {
+                unsupported = true;
+                return node;
+            }
+            payloads.set(id, payload);
+            const currentIndex = leafIndex;
+            leafIndex += 1;
+            if (currentIndex < DOCUMENT_LAZY_INITIAL_CHUNK_COUNT) return node;
+            const placeholder = lazyPlaceholderForContent(id, payload);
+            if (!placeholder) {
+                unsupported = true;
+                return node;
+            }
+            lazyChunkCount += 1;
+            return {
+                ...node,
+                content: [
+                    placeholder
+                ]
+            };
+        }
+        if (!node.content?.length) return node;
+        let changed = false;
+        const content = node.content.map((child)=>{
+            const next = visit(child);
+            if (next !== child) changed = true;
+            return next;
+        });
+        return changed ? {
+            ...node,
+            content
+        } : node;
+    };
+    const compactRoot = visit(root);
+    if (unsupported || leafIndex <= DOCUMENT_LAZY_INITIAL_CHUNK_COUNT || 0 === lazyChunkCount) return null;
+    return {
+        htmlProjection: null,
+        lazyChunkCount,
+        payloads,
+        root: compactRoot
+    };
+}
+function lazyPlaceholderForContent(chunkId, content) {
+    const tapeParts = [];
+    const statistics = {
+        contentSize: 0,
+        paragraphCount: 0
+    };
+    for (const node of content)if (!appendDocumentNodePositionTape(node, tapeParts, statistics)) return null;
+    if (statistics.contentSize < 2 || tapeParts[0] !== DOCUMENT_LAZY_POSITION_BOUNDARY || tapeParts.at(-1) !== DOCUMENT_LAZY_POSITION_BOUNDARY) return null;
+    tapeParts[0] = '';
+    tapeParts[tapeParts.length - 1] = '';
+    const filler = tapeParts.join('');
+    return {
+        type: DOCUMENT_LAZY_BLOCK_NODE,
+        attrs: {
+            chunkId,
+            contentSize: statistics.contentSize,
+            paragraphCount: statistics.paragraphCount
+        },
+        ...filler ? {
+            content: [
+                {
+                    type: 'text',
+                    text: filler
+                }
+            ]
+        } : {
+            content: []
+        }
+    };
+}
+function appendDocumentNodePositionTape(node, parts, statistics) {
+    if ('text' === node.type) {
+        if ('string' != typeof node.text || !node.text) return false;
+        parts.push(node.text);
+        statistics.contentSize += node.text.length;
+        return true;
+    }
+    if (!SIMPLE_LAZY_CONTAINER_TYPES.has(node.type)) return false;
+    if ('paragraph' === node.type) statistics.paragraphCount += 1;
+    statistics.contentSize += 2;
+    parts.push(DOCUMENT_LAZY_POSITION_BOUNDARY);
+    for (const child of node.content ?? [])if (!appendDocumentNodePositionTape(child, parts, statistics)) return false;
+    parts.push(DOCUMENT_LAZY_POSITION_BOUNDARY);
+    return true;
+}
+function documentChunkIsLazy(node) {
+    return 'documentChunk' === node.type && node.attrs?.windowContainer !== true && node.content?.length === 1 && node.content[0]?.type === DOCUMENT_LAZY_BLOCK_NODE;
+}
+function documentChunkId(node) {
+    const id = node.attrs?.id;
+    return 'string' == typeof id && id ? id : null;
+}
+function lazyDocumentNow() {
+    return globalThis.performance?.now?.() ?? Date.now();
+}
+function recordLazyDocumentMeasure(name, start, end, detail) {
+    try {
+        globalThis.performance?.measure(name, {
+            detail,
+            end,
+            start
+        });
+    } catch  {}
+}
 const DOCUMENT_MODEL_SCHEMA = 'a3s.office.document';
 const DOCUMENT_MODEL_VERSION = 1;
 const MAX_DOCUMENT_MODEL_DEPTH = 256;
-const MAX_DOCUMENT_MODEL_NODES = 100000;
-const MAX_DOCUMENT_MODEL_MARKS = 500000;
-const MAX_DOCUMENT_MODEL_ATTRIBUTE_VALUES = 1000000;
+const MAX_DOCUMENT_MODEL_NODES = 2000000;
+const MAX_DOCUMENT_MODEL_MARKS = 2000000;
+const MAX_DOCUMENT_MODEL_ATTRIBUTE_VALUES = 10000000;
+const schemaValidatedDocumentModels = new WeakMap();
 function createWorkDocumentModel(html, root, previous) {
-    return {
+    return createWorkDocumentModelWithFingerprint(root, documentHtmlFingerprint(html), previous);
+}
+function createWorkDocumentModelWithFingerprint(root, htmlFingerprint, previous) {
+    const model = {
         schema: DOCUMENT_MODEL_SCHEMA,
         version: DOCUMENT_MODEL_VERSION,
         revision: nextRevision(previous),
-        htmlFingerprint: documentHtmlFingerprint(html),
+        htmlFingerprint,
         root
     };
+    transferLazyDocumentModelState(previous, model);
+    return model;
+}
+function createSchemaValidatedWorkDocumentModel(html, root, options = {}) {
+    const model = createWorkDocumentModel(html, root, options.previous);
+    schemaValidatedDocumentModels.set(model, {
+        html,
+        htmlFingerprint: model.htmlFingerprint,
+        initialIntegrityFeatures: work_document_model_nonNegativeInteger(options.initialIntegrityFeatures),
+        root
+    });
+    return model;
+}
+function createSchemaDerivedWorkDocumentModel(html, root, previous, htmlFingerprint = documentHtmlFingerprint(html)) {
+    const model = createWorkDocumentModelWithFingerprint(root, htmlFingerprint, previous);
+    schemaValidatedDocumentModels.set(model, {
+        html,
+        htmlFingerprint: model.htmlFingerprint,
+        initialIntegrityFeatures: (previous && schemaValidatedDocumentModels.get(previous)?.initialIntegrityFeatures) ?? null,
+        root
+    });
+    return model;
+}
+function documentModelHasTrustedInitialIntegrityFeatures(model) {
+    if (!model) return false;
+    const validated = schemaValidatedDocumentModels.get(model);
+    return validated?.root === model.root && null !== validated.initialIntegrityFeatures;
 }
 function documentModelForContent(content) {
     return documentModelForHtml(content.model, content.html);
 }
 function documentModelForHtml(candidate, html) {
     if (!isRecord(candidate)) return null;
-    if (candidate.schema !== DOCUMENT_MODEL_SCHEMA || candidate.version !== DOCUMENT_MODEL_VERSION || !Number.isSafeInteger(candidate.revision) || Number(candidate.revision) < 1 || candidate.htmlFingerprint !== documentHtmlFingerprint(html) || !isDocumentRoot(candidate.root)) return null;
+    const validated = schemaValidatedDocumentModels.get(candidate);
+    const trustedHtmlMatches = Boolean(validated && validated.root === candidate.root && validated.html === html && validated.htmlFingerprint === candidate.htmlFingerprint);
+    if (candidate.schema !== DOCUMENT_MODEL_SCHEMA || candidate.version !== DOCUMENT_MODEL_VERSION || !Number.isSafeInteger(candidate.revision) || Number(candidate.revision) < 1 || 'string' != typeof candidate.htmlFingerprint || !trustedHtmlMatches && !documentHtmlFingerprintMatches(html, candidate.htmlFingerprint) || validated?.root !== candidate.root && !isDocumentRoot(candidate.root)) return null;
     return candidate;
 }
-function resolveWorkDocumentEditorInput(content, fallbackHtml) {
-    const model = documentModelForContent(content);
+function resolveWorkDocumentEditorInput(content, fallbackHtml, validatedModel = documentModelForContent(content)) {
+    const model = validatedModel;
     if (!model) return {
         model: null,
         source: fallbackHtml,
@@ -1384,23 +1938,19 @@ function resolveWorkDocumentEditorInput(content, fallbackHtml) {
     };
     return {
         model,
-        source: model.root,
+        source: prepareLazyDocumentEditorSource(model, documentModelHasTrustedInitialIntegrityFeatures(model), content.html)?.root ?? model.root,
         sourceKey: `model:${model.revision}:${model.htmlFingerprint}`,
         revision: model.revision
     };
 }
-function documentHtmlFingerprint(html) {
-    let hash = 0x811c9dc5;
-    for(let index = 0; index < html.length; index += 1){
-        hash ^= html.charCodeAt(index);
-        hash = Math.imul(hash, 0x01000193);
-    }
-    return `${html.length.toString(36)}:${(hash >>> 0).toString(36)}`;
-}
 function nextRevision(previous) {
     const revision = previous?.schema === DOCUMENT_MODEL_SCHEMA && previous.version === DOCUMENT_MODEL_VERSION && Number.isSafeInteger(previous.revision) && previous.revision > 0 ? previous.revision : 0;
     return revision >= Number.MAX_SAFE_INTEGER ? 1 : revision + 1;
 }
+function work_document_model_nonNegativeInteger(value) {
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number >= 0 ? number : null;
+}
 function isDocumentRoot(value) {
     if (!isRecord(value) || 'doc' !== value.type) return false;
     const nodes = [
@@ -6503,6 +7053,7 @@ function createDocumentImageIdentityPlugin(imageNodeName = 'image') {
     });
 }
 function normalizeDocumentImageIdentities(state, imageNodeName, oldState, transactions = []) {
+    if ('image' === imageNodeName && !documentHasIntegrityFeature(state.doc, 4)) return null;
     const images = documentImages(state.doc, imageNodeName);
     if (!images.length) return null;
     const retainedPositions = oldState ? retainedDocumentImagePositions(oldState, state, transactions, imageNodeName) : new Set();
@@ -6795,14 +7346,14 @@ function createDocumentParagraphIdentityPlugin(types, rotateTextId) {
     });
 }
 function normalizeDocumentParagraphIdentities(state, trackedTypes, rotateTextId, oldState, transactions = []) {
+    if (!documentHasIntegrityFeature(state.doc, 16)) return null;
     const paragraphs = documentParagraphs(state.doc, trackedTypes);
-    const identifiedParagraphs = paragraphs.filter(({ node })=>hasDocumentParagraphIdentityComponent(node));
-    if (!identifiedParagraphs.length) return null;
+    if (!paragraphs.length) return null;
     const retainedPositions = oldState ? retainedDocumentParagraphPositions(oldState, state, transactions, trackedTypes) : new Set();
     const editedPositions = oldState && rotateTextId() && !transactions.some(isHistoryTransaction) ? editedDocumentParagraphPositions(oldState, state, transactions, trackedTypes) : new Set();
     const ordered = [
-        ...identifiedParagraphs.filter((item)=>retainedPositions.has(item.position)),
-        ...identifiedParagraphs.filter((item)=>!retainedPositions.has(item.position))
+        ...paragraphs.filter((item)=>retainedPositions.has(item.position)),
+        ...paragraphs.filter((item)=>!retainedPositions.has(item.position))
     ];
     const registry = createDocumentParagraphIdentityRegistry();
     const updates = new Map();
@@ -6882,7 +7433,7 @@ function paragraphsById(paragraphs) {
 function documentParagraphs(document1, trackedTypes) {
     const paragraphs = [];
     document1.descendants((node, position)=>{
-        if (trackedTypes.has(node.type.name)) paragraphs.push({
+        if (trackedTypes.has(node.type.name) && hasDocumentParagraphIdentityComponent(node)) paragraphs.push({
             node,
             position
         });
@@ -7051,14 +7602,14 @@ function createDocumentTableRowIdentityPlugin(rotateTextId) {
     });
 }
 function normalizeDocumentTableRowIdentities(state, rotateTextId, oldState, transactions = []) {
+    if (!documentHasIntegrityFeature(state.doc, 32)) return null;
     const rows = documentTableRows(state.doc);
-    const identifiedRows = rows.filter(({ node })=>hasDocumentTableRowIdentityComponent(node));
-    if (!identifiedRows.length) return null;
+    if (!rows.length) return null;
     const retainedPositions = oldState ? retainedDocumentTableRowPositions(oldState, state, transactions) : new Set();
     const editedPositions = oldState && rotateTextId() && !transactions.some(isHistoryTransaction) ? editedDocumentTableRowPositions(oldState, state, transactions) : new Set();
     const ordered = [
-        ...identifiedRows.filter((item)=>retainedPositions.has(item.position)),
-        ...identifiedRows.filter((item)=>!retainedPositions.has(item.position))
+        ...rows.filter((item)=>retainedPositions.has(item.position)),
+        ...rows.filter((item)=>!retainedPositions.has(item.position))
     ];
     const registry = createDocumentParagraphIdentityRegistry();
     const updates = new Map();
@@ -7156,7 +7707,7 @@ function tableRowsById(rows) {
 function documentTableRows(document1) {
     const rows = [];
     document1.descendants((node, position)=>{
-        if ('tableRow' === node.type.name) rows.push({
+        if ('tableRow' === node.type.name && hasDocumentTableRowIdentityComponent(node)) rows.push({
             node,
             position
         });
@@ -9416,68 +9967,1107 @@ const DocumentSuperscript = extension_superscript.extend({
         };
     }
 });
-const DocumentCitation = core_Node.create({
-    name: 'documentCitation',
-    inline: true,
-    group: 'inline',
-    atom: true,
-    selectable: true,
-    addOptions () {
+function documentChunkViewportRange(geometry, viewportTop, viewportBottom) {
+    if (!geometry.length) return {
+        end: 0,
+        start: 0
+    };
+    const first = firstDocumentChunkEndingAfter(geometry, viewportTop);
+    const last = lastDocumentChunkStartingBefore(geometry, viewportBottom);
+    return {
+        end: Math.min(geometry.length, Math.max(first + 1, last + 1)),
+        start: Math.max(0, first)
+    };
+}
+function documentChunkGeometry(document1, breaks) {
+    const geometry = [];
+    const orderedBreaks = [
+        ...breaks
+    ].sort((left, right)=>left.position - right.position);
+    let breakIndex = 0;
+    let top = 0;
+    document1.descendants((node, position, parent)=>{
+        if ('documentChunk' !== node.type.name) return true;
+        if (true === node.attrs.windowContainer) return true;
+        const nodeEnd = position + node.nodeSize;
+        while(breakIndex < orderedBreaks.length && (orderedBreaks[breakIndex]?.position ?? 0) <= position)breakIndex += 1;
+        let chunkBreakIndex = breakIndex;
+        let paginationExtraHeight = 0;
+        while(chunkBreakIndex < orderedBreaks.length && (orderedBreaks[chunkBreakIndex]?.position ?? nodeEnd) < nodeEnd){
+            paginationExtraHeight += Math.max(0, orderedBreaks[chunkBreakIndex]?.spacerHeight ?? 0);
+            chunkBreakIndex += 1;
+        }
+        breakIndex = chunkBreakIndex;
+        const height = positiveNumber(node.attrs.estimatedHeight, 1) + paginationExtraHeight;
+        geometry.push({
+            ...parent?.type.name === 'documentChunk' && true === parent.attrs.windowContainer ? {
+                containerId: work_document_chunk_geometry_documentChunkId(parent)
+            } : {},
+            end: top + height,
+            from: position,
+            id: work_document_chunk_geometry_documentChunkId(node),
+            paginationExtraHeight,
+            start: top,
+            to: nodeEnd
+        });
+        top += height;
+        return false;
+    });
+    return geometry;
+}
+function documentChunkPositions(document1) {
+    const positions = new Map();
+    const ancestorIdsByNode = new WeakMap();
+    document1.descendants((node, position, parent)=>{
+        const parentAncestorIds = parent ? ancestorIdsByNode.get(parent) ?? [] : [];
+        if ('documentChunk' !== node.type.name) {
+            ancestorIdsByNode.set(node, parentAncestorIds);
+            return true;
+        }
+        const ancestorIds = parent?.type.name === 'documentChunk' ? [
+            ...parentAncestorIds,
+            work_document_chunk_geometry_documentChunkId(parent)
+        ] : parentAncestorIds;
+        const id = work_document_chunk_geometry_documentChunkId(node);
+        positions.set(id, {
+            ancestorIds,
+            from: position,
+            to: position + node.nodeSize
+        });
+        ancestorIdsByNode.set(node, ancestorIds);
+        return true === node.attrs.windowContainer;
+    });
+    return positions;
+}
+function work_document_chunk_geometry_documentChunkId(node) {
+    return 'string' == typeof node.attrs.id && node.attrs.id ? node.attrs.id : `document-chunk-${node.nodeSize}`;
+}
+function firstDocumentChunkEndingAfter(geometry, offset) {
+    let lower = 0;
+    let upper = geometry.length - 1;
+    let result = upper;
+    while(lower <= upper){
+        const middle = Math.floor((lower + upper) / 2);
+        const chunk = geometry[middle];
+        if (chunk && chunk.end >= offset) {
+            result = middle;
+            upper = middle - 1;
+        } else lower = middle + 1;
+    }
+    return result;
+}
+function lastDocumentChunkStartingBefore(geometry, offset) {
+    let lower = 0;
+    let upper = geometry.length - 1;
+    let result = 0;
+    while(lower <= upper){
+        const middle = Math.floor((lower + upper) / 2);
+        const chunk = geometry[middle];
+        if (chunk && chunk.start <= offset) {
+            result = middle;
+            lower = middle + 1;
+        } else upper = middle - 1;
+    }
+    return result;
+}
+function positiveNumber(value, fallback) {
+    const number = Number(value);
+    return Number.isFinite(number) && number > 0 ? number : fallback;
+}
+const DOCUMENT_LAZY_PREVIEW_POOL_LIMIT = 12;
+function createDocumentLazyPreviewPool() {
+    return {
+        available: new Map(),
+        size: 0
+    };
+}
+function mountDocumentLazyPreview(pool, dom, content, firstPosition, paginationExtraHeight) {
+    const shape = lazyDocumentPreviewShape(content);
+    const available = pool.available.get(shape);
+    let lease = available?.pop();
+    if (lease) {
+        pool.size -= 1;
+        if (!available?.length) pool.available.delete(shape);
+    } else lease = createDocumentLazyPreview(content, shape);
+    let position = firstPosition;
+    for(let index = 0; index < content.length; index += 1){
+        const node = content[index];
+        const element = lease.nodes[index];
+        if (!node || !element) throw new Error('The lazy document preview shape is incomplete.');
+        const size = bindLazyDocumentNode(node, element, position);
+        if (null === size) throw new Error('The lazy document preview shape changed during reuse.');
+        position += size;
+    }
+    dom.replaceChildren(...lease.nodes, lease.spacer);
+    dom.dataset.documentLazyPreview = 'true';
+    dom.setAttribute('contenteditable', 'false');
+    updateDocumentLazyPreviewSpacer(lease, paginationExtraHeight);
+    return lease;
+}
+function releaseDocumentLazyPreview(pool, dom, lease) {
+    if (!lease) return;
+    dom.replaceChildren();
+    if (pool.size >= DOCUMENT_LAZY_PREVIEW_POOL_LIMIT) return;
+    const available = pool.available.get(lease.shape) ?? [];
+    available.push(lease);
+    pool.available.set(lease.shape, available);
+    pool.size += 1;
+}
+function updateDocumentLazyPreviewSpacer(lease, height) {
+    if (!lease) return;
+    lease.spacer.style.height = `${Math.max(0, height)}px`;
+}
+function documentLazyPreviewPointerPosition(event, fallback) {
+    if (!(event instanceof MouseEvent) || 0 !== event.button) return null;
+    const target = event.target;
+    if (!(target instanceof Element)) return null;
+    const preview = target.closest('[data-document-lazy-preview="true"]');
+    if (!preview) return null;
+    const textElement = target.closest('[data-document-text-position]');
+    const base = Number(textElement?.dataset.documentTextPosition);
+    let offset = 0;
+    const caret = target.ownerDocument.caretPositionFromPoint?.(event.clientX, event.clientY);
+    if (caret && caret.offsetNode.nodeType === globalThis.Node.TEXT_NODE && textElement?.contains(caret.offsetNode)) offset = Math.max(0, Math.min(caret.offset, caret.offsetNode.textContent?.length ?? 0));
+    return Number.isSafeInteger(base) ? base + offset : fallback;
+}
+function createDocumentLazyPreview(content, shape) {
+    const nodes = [];
+    let position = 0;
+    for (const node of content){
+        const rendered = createLazyDocumentNode(node, position);
+        nodes.push(rendered.element);
+        position += rendered.size;
+    }
+    const spacer = document.createElement('div');
+    spacer.dataset.documentLazyPaginationSpacer = 'true';
+    spacer.setAttribute('aria-hidden', 'true');
+    return {
+        nodes,
+        shape,
+        spacer
+    };
+}
+function createLazyDocumentNode(node, position) {
+    if ('text' === node.type && node.text) {
+        const span = document.createElement('span');
+        span.dataset.documentTextPosition = String(position);
+        span.append(document.createTextNode(node.text));
         return {
-            getContent: ()=>null,
-            onContentChange: ()=>void 0
+            element: span,
+            size: node.text.length
         };
-    },
-    addCommands () {
+    }
+    if ('paragraph' === node.type) {
+        const paragraph = document.createElement('p');
+        const size = appendLazyDocumentChildren(node, paragraph, position + 1);
+        if (!paragraph.hasChildNodes()) paragraph.append(document.createElement('br'));
         return {
-            insertDocumentCitation: (source, bibliography)=>(props)=>insertDocumentCitationCommand(props, source, bibliography),
-            insertDocumentBibliography: (bibliography)=>(props)=>insertDocumentBibliographyCommand(props, bibliography),
-            refreshDocumentCitations: (content)=>(props)=>refreshDocumentCitationsCommand(props, content),
-            renameDocumentCitationTag: (previousTag, nextTag)=>(props)=>renameDocumentCitationTagCommand(props, previousTag, nextTag),
-            setDocumentBibliography: (bibliography, renamedTag)=>({ dispatch, editor })=>{
-                    const content = this.options.getContent();
-                    if (!content) return false;
-                    if (!dispatch) return true;
-                    const next = {
-                        ...content,
-                        bibliography
-                    };
-                    this.options.onContentChange(next);
-                    const chain = editor.chain();
-                    if (renamedTag) chain.renameDocumentCitationTag(renamedTag.previous, renamedTag.next);
-                    chain.refreshDocumentCitations(next).run();
-                    return true;
-                }
+            element: paragraph,
+            size: size + 2
         };
-    },
-    addAttributes () {
+    }
+    if ('table' === node.type) {
+        const wrapper = document.createElement('div');
+        wrapper.className = 'tableWrapper';
+        const table = document.createElement('table');
+        bindLazyDocumentTableAttributes(table, node);
+        const body = document.createElement('tbody');
+        table.append(body);
+        wrapper.append(table);
+        const size = appendLazyDocumentChildren(node, body, position + 1);
         return {
-            id: work_document_citation_nodes_hiddenAttribute(''),
-            tags: work_document_citation_nodes_hiddenAttribute(''),
-            instruction: work_document_citation_nodes_hiddenAttribute(''),
-            display: work_document_citation_nodes_hiddenAttribute(''),
-            orphaned: work_document_citation_nodes_hiddenAttribute(false)
+            element: wrapper,
+            size: size + 2
         };
-    },
-    parseHTML () {
-        return [
-            {
-                tag: 'span[data-document-citation]',
-                getAttrs: (node)=>{
-                    if (!(node instanceof HTMLElement)) return false;
-                    const instruction = node.dataset.citationInstruction?.trim() ?? '';
-                    const tags = documentCitationTags(node.dataset.citationTags);
-                    const resolvedTags = tags.length ? tags : documentCitationTagsFromInstruction(instruction);
-                    return {
-                        id: node.dataset.citationId ?? '',
-                        tags: resolvedTags.join(' '),
-                        instruction: instruction || documentCitationInstruction(resolvedTags),
-                        display: node.dataset.citationDisplay?.trim() || node.textContent?.trim() || '缺失引文',
-                        orphaned: 'true' === node.dataset.citationOrphaned
-                    };
-                }
+    }
+    if ('tableRow' === node.type) {
+        const row = document.createElement('tr');
+        const size = appendLazyDocumentChildren(node, row, position + 1);
+        return {
+            element: row,
+            size: size + 2
+        };
+    }
+    if ('tableCell' === node.type || 'tableHeader' === node.type) {
+        const cell = document.createElement('tableHeader' === node.type ? 'th' : 'td');
+        const size = appendLazyDocumentChildren(node, cell, position + 1);
+        return {
+            element: cell,
+            size: size + 2
+        };
+    }
+    throw new Error(`Unsupported lazy document preview node: ${node.type}`);
+}
+function appendLazyDocumentChildren(node, parent, firstPosition) {
+    let size = 0;
+    for (const child of node.content ?? []){
+        const rendered = createLazyDocumentNode(child, firstPosition + size);
+        parent.append(rendered.element);
+        size += rendered.size;
+    }
+    return size;
+}
+function bindLazyDocumentNode(node, element, position) {
+    if ('text' === node.type && node.text && 'SPAN' === element.tagName) {
+        const text = element.firstChild;
+        if (!(text instanceof Text) || 1 !== element.childNodes.length) return null;
+        element.dataset.documentTextPosition = String(position);
+        if (text.data !== node.text) text.data = node.text;
+        return node.text.length;
+    }
+    if ('paragraph' === node.type && 'P' === element.tagName) {
+        if (!(node.content?.length ?? 0)) return 1 === element.children.length && element.firstElementChild?.tagName === 'BR' ? 2 : null;
+        const size = bindLazyDocumentChildren(node, element, position + 1);
+        return null === size ? null : size + 2;
+    }
+    if ('table' === node.type && element.classList.contains('tableWrapper')) {
+        const table = element.firstElementChild;
+        const body = table?.firstElementChild;
+        if (!(table instanceof HTMLTableElement) || body?.tagName !== 'TBODY') return null;
+        bindLazyDocumentTableAttributes(table, node);
+        const size = bindLazyDocumentChildren(node, body, position + 1);
+        return null === size ? null : size + 2;
+    }
+    if ('tableRow' === node.type && 'TR' === element.tagName) {
+        const size = bindLazyDocumentChildren(node, element, position + 1);
+        return null === size ? null : size + 2;
+    }
+    const expectedCellTag = 'tableHeader' === node.type ? 'TH' : 'TD';
+    if (('tableCell' === node.type || 'tableHeader' === node.type) && element.tagName === expectedCellTag) {
+        const size = bindLazyDocumentChildren(node, element, position + 1);
+        return null === size ? null : size + 2;
+    }
+    return null;
+}
+function bindLazyDocumentChildren(node, parent, firstPosition) {
+    const children = node.content ?? [];
+    if (parent.children.length !== children.length) return null;
+    let size = 0;
+    for(let index = 0; index < children.length; index += 1){
+        const child = children[index];
+        const element = parent.children.item(index);
+        if (!child || !(element instanceof HTMLElement)) return null;
+        const childSize = bindLazyDocumentNode(child, element, firstPosition + size);
+        if (null === childSize) return null;
+        size += childSize;
+    }
+    return size;
+}
+function bindLazyDocumentTableAttributes(table, node) {
+    setBooleanDataset(table, 'officeTableImported', node.attrs?.officeImported === true);
+    setStringDataset(table, 'documentVirtualTableId', node.attrs?.virtualTableId);
+    setNumberDataset(table, 'documentVirtualTableIndex', node.attrs?.virtualTableIndex);
+    setNumberDataset(table, 'documentVirtualTableCount', node.attrs?.virtualTableCount);
+}
+function lazyDocumentPreviewShape(content) {
+    const parts = [];
+    for (const node of content)appendLazyDocumentPreviewShape(node, parts);
+    return parts.join('');
+}
+function appendLazyDocumentPreviewShape(node, parts) {
+    const children = node.content ?? [];
+    parts.push(node.type, '[', String(children.length), '](');
+    for (const child of children)appendLazyDocumentPreviewShape(child, parts);
+    parts.push(')');
+}
+function setBooleanDataset(element, name, value) {
+    if (value) element.dataset[name] = 'true';
+    else delete element.dataset[name];
+}
+function setStringDataset(element, name, value) {
+    if ('string' == typeof value && value) element.dataset[name] = value;
+    else delete element.dataset[name];
+}
+function setNumberDataset(element, name, value) {
+    const number = Number(value);
+    if (Number.isSafeInteger(number) && number >= 0) element.dataset[name] = String(number);
+    else delete element.dataset[name];
+}
+const statisticsByDocument = new WeakMap();
+function documentWordCount(value) {
+    let asciiCount = 0;
+    let inAsciiWord = false;
+    for(let index = 0; index < value.length; index += 1){
+        const code = value.charCodeAt(index);
+        const asciiLetterOrNumber = code >= 0x30 && code <= 0x39 || code >= 0x41 && code <= 0x5a || code >= 0x61 && code <= 0x7a;
+        if (asciiLetterOrNumber) {
+            if (!inAsciiWord) asciiCount += 1;
+            inAsciiWord = true;
+            continue;
+        }
+        inAsciiWord = false;
+        if (!(code <= 0x7f) && 0xfffc !== code) return unicodeDocumentWordCount(value);
+    }
+    return asciiCount;
+}
+function unicodeDocumentWordCount(value) {
+    let count = 0;
+    for (const _match of value.matchAll(/[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]|[\p{L}\p{N}]+/gu))count += 1;
+    return count;
+}
+function documentTextStatistics(editor) {
+    const document1 = editor.state.doc;
+    const cached = statisticsByDocument.get(document1);
+    if (cached) return cached;
+    const source = editor.getText({
+        blockSeparator: '\n'
+    });
+    let characterCountWithSpaces = 0;
+    let characterCountWithoutSpaces = 0;
+    for(let index = 0; index < source.length; index += 1){
+        const codePoint = source.codePointAt(index);
+        if (void 0 !== codePoint) {
+            if (codePoint > 0xffff) index += 1;
+            if (codePoint !== "".codePointAt(0) && 0x0a !== codePoint && 0x0d !== codePoint) {
+                characterCountWithSpaces += 1;
+                if (!isEcmaScriptWhitespace(codePoint)) characterCountWithoutSpaces += 1;
             }
-        ];
+        }
+    }
+    let paragraphCount = 0;
+    document1.descendants((node)=>{
+        if (node.type.name === DOCUMENT_LAZY_BLOCK_NODE) {
+            const logicalParagraphs = Number(node.attrs.paragraphCount);
+            paragraphCount += Number.isSafeInteger(logicalParagraphs) && logicalParagraphs >= 0 ? logicalParagraphs : 0;
+            return false;
+        }
+        if (node.isTextblock) paragraphCount += 1;
+        return true;
+    });
+    const statistics = {
+        characterCountWithSpaces,
+        characterCountWithoutSpaces,
+        paragraphCount,
+        wordCount: documentWordCount(source)
+    };
+    statisticsByDocument.set(document1, statistics);
+    return statistics;
+}
+function transferDocumentTextStatistics(previous, next) {
+    const statistics = statisticsByDocument.get(previous);
+    if (statistics) statisticsByDocument.set(next, statistics);
+}
+function transferChangedDocumentTextStatistics(previous, next, changes) {
+    const cached = statisticsByDocument.get(previous);
+    if (!cached || !changes.length) return false;
+    const statistics = {
+        ...cached
+    };
+    for (const { after, before } of changes){
+        applyDocumentTextStatisticsDelta(statistics, simpleDocumentSubtreeStatistics(before), -1);
+        applyDocumentTextStatisticsDelta(statistics, simpleDocumentSubtreeStatistics(after), 1);
+    }
+    if (Object.values(statistics).some((value)=>value < 0)) return false;
+    statisticsByDocument.set(next, statistics);
+    return true;
+}
+function simpleDocumentSubtreeStatistics(root) {
+    const statistics = {
+        characterCountWithSpaces: 0,
+        characterCountWithoutSpaces: 0,
+        paragraphCount: 0,
+        wordCount: 0
+    };
+    const visit = (node)=>{
+        if (node.type.name === DOCUMENT_LAZY_BLOCK_NODE) {
+            accumulateDocumentTextStatistics(statistics, node.textContent);
+            const logicalParagraphs = Number(node.attrs.paragraphCount);
+            statistics.paragraphCount += Number.isSafeInteger(logicalParagraphs) && logicalParagraphs >= 0 ? logicalParagraphs : 0;
+            return;
+        }
+        if (node.isTextblock) {
+            accumulateDocumentTextStatistics(statistics, node.textContent);
+            statistics.paragraphCount += 1;
+            return;
+        }
+        node.forEach(visit);
+    };
+    visit(root);
+    return statistics;
+}
+function accumulateDocumentTextStatistics(statistics, source) {
+    for(let index = 0; index < source.length; index += 1){
+        const codePoint = source.codePointAt(index);
+        if (void 0 !== codePoint) {
+            if (codePoint > 0xffff) index += 1;
+            if (codePoint !== "".codePointAt(0) && 0x0a !== codePoint && 0x0d !== codePoint) {
+                statistics.characterCountWithSpaces += 1;
+                if (!isEcmaScriptWhitespace(codePoint)) statistics.characterCountWithoutSpaces += 1;
+            }
+        }
+    }
+    statistics.wordCount += documentWordCount(source);
+}
+function applyDocumentTextStatisticsDelta(target, value, direction) {
+    target.characterCountWithSpaces += direction * value.characterCountWithSpaces;
+    target.characterCountWithoutSpaces += direction * value.characterCountWithoutSpaces;
+    target.paragraphCount += direction * value.paragraphCount;
+    target.wordCount += direction * value.wordCount;
+}
+function isEcmaScriptWhitespace(codePoint) {
+    return codePoint >= 0x09 && codePoint <= 0x0d || 0x20 === codePoint || 0xa0 === codePoint || 0x1680 === codePoint || codePoint >= 0x2000 && codePoint <= 0x200a || 0x2028 === codePoint || 0x2029 === codePoint || 0x202f === codePoint || 0x205f === codePoint || 0x3000 === codePoint || 0xfeff === codePoint;
+}
+const INITIAL_DOCUMENT_CHUNK_WINDOW_SIZE = 2;
+const DOCUMENT_CHUNK_WINDOW_ROOT_MARGIN = '0px';
+const DOCUMENT_CHUNK_PAGINATION_META = 'documentChunkPaginationGeometry';
+const DOCUMENT_CHUNK_VISIBLE_IDS_META = 'documentChunkVisibleIds';
+const DOCUMENT_CHUNK_HYDRATION_META = 'documentChunkLazyHydration';
+const documentChunkWindowKey = new PluginKey('documentChunkWindow');
+const documentChunkElementRegistries = new WeakMap();
+const documentChunkContentSources = new WeakMap();
+const DocumentChunk = core_Node.create({
+    name: 'documentChunk',
+    group: 'block',
+    content: 'block+',
+    defining: true,
+    selectable: false,
+    addOptions () {
+        return {
+            getContent: ()=>null,
+            trustInitialIntegrityFeatures: false
+        };
+    },
+    addAttributes () {
+        return {
+            id: {
+                default: ''
+            },
+            blockCount: {
+                default: 0
+            },
+            estimatedHeight: {
+                default: 1
+            },
+            integrityFeatures: {
+                default: null,
+                rendered: false
+            },
+            windowContainer: {
+                default: false
+            }
+        };
+    },
+    parseHTML () {
+        return [
+            {
+                tag: 'div[data-document-chunk]',
+                getAttrs: (element)=>{
+                    if (!(element instanceof HTMLElement)) return false;
+                    return {
+                        id: element.dataset.documentChunkId ?? '',
+                        blockCount: work_document_chunk_node_positiveInteger(element.dataset.documentChunkBlocks, 0),
+                        estimatedHeight: work_document_chunk_node_positiveNumber(element.dataset.documentChunkEstimatedHeight, 1),
+                        windowContainer: 'true' === element.dataset.documentChunkWindowContainer
+                    };
+                }
+            }
+        ];
+    },
+    renderHTML ({ node, HTMLAttributes }) {
+        return [
+            'div',
+            mergeAttributes(HTMLAttributes, documentChunkDomAttributes(node)),
+            0
+        ];
+    },
+    addNodeView () {
+        return ({ decorations, editor, getPos, node })=>createDocumentChunkNodeView(editor, node, decorations, getPos);
+    },
+    addProseMirrorPlugins () {
+        const editor = this.editor;
+        const getContent = this.options.getContent;
+        documentChunkContentSources.set(editor, getContent);
+        const trustInitialIntegrityFeatures = this.options.trustInitialIntegrityFeatures;
+        return [
+            new Plugin({
+                key: documentChunkWindowKey,
+                appendTransaction: (transactions, _previous, next)=>{
+                    if (!transactions.some((transaction)=>transaction.selectionSet)) return null;
+                    const selected = selectedDocumentChunkId(next);
+                    if (!selected) return null;
+                    const transaction = next.tr;
+                    return hydrateDocumentChunks(editor, transaction, next, [
+                        selected
+                    ]).length ? transaction : null;
+                },
+                state: {
+                    init: (_configuration, state)=>{
+                        if (trustInitialIntegrityFeatures) primeDocumentIntegrityFeatures(state.doc);
+                        return createDocumentChunkWindowState(state);
+                    },
+                    apply: (transaction, current, _previous, next)=>updateDocumentChunkWindowState(transaction, current, next)
+                },
+                props: {
+                    decorations: (state)=>documentChunkWindowKey.getState(state)?.decorations ?? null,
+                    handleDOMEvents: {
+                        pointerdown: (view, event)=>handleDocumentChunkLazyPreviewPointerDown(editor, view, event)
+                    },
+                    handleKeyDown: (view, event)=>handleDocumentChunkBoundaryKeyDown(editor, view, event)
+                },
+                view: (view)=>createDocumentChunkIntersectionView(editor, view)
+            })
+        ];
+    }
+});
+function handleDocumentChunkBoundaryKeyDown(editor, view, event) {
+    const state = documentChunkWindowKey.getState(view.state);
+    if (!state?.chunkCount || event.altKey || event.shiftKey || !event.ctrlKey && !event.metaKey) return false;
+    const moveToStart = 'Home' === event.key || event.metaKey && 'ArrowUp' === event.key;
+    const moveToEnd = 'End' === event.key || event.metaKey && 'ArrowDown' === event.key;
+    if (!moveToStart && !moveToEnd) return false;
+    const selection = moveToStart ? Selection.atStart(view.state.doc) : Selection.atEnd(view.state.doc);
+    const transaction = view.state.tr.setSelection(selection);
+    const selected = selectedDocumentChunkId({
+        doc: view.state.doc,
+        selection
+    });
+    if (selected) hydrateDocumentChunks(editor, transaction, view.state, [
+        selected
+    ]);
+    const nextSelection = moveToStart ? Selection.atStart(transaction.doc) : Selection.atEnd(transaction.doc);
+    view.dispatch(transaction.setSelection(nextSelection).scrollIntoView());
+    return true;
+}
+function createDocumentChunkNodeView(editor, initialNode, initialDecorations, getPos) {
+    let node = initialNode;
+    const id = work_document_chunk_geometry_documentChunkId(node);
+    const mounted = documentChunkIsMounted(node, initialDecorations);
+    let lazyPreview = mounted && documentChunkHasLazyContent(node);
+    const registry = documentChunkElementRegistryFor(editor);
+    let paginationExtraHeight = registry.paginationExtraHeights.get(id) ?? 0;
+    const dom = document.createElement('div');
+    let lazyPreviewLease = null;
+    applyDocumentChunkNodeViewAttributes(dom, node, mounted, paginationExtraHeight);
+    if (lazyPreview) lazyPreviewLease = mountDocumentLazyPreview(registry.lazyPreviewPool, dom, requiredDocumentLazyChunkContent(editor, id), (getPos() ?? 0) + 1, paginationExtraHeight);
+    const controller = {
+        element: dom,
+        setPaginationExtraHeight (height) {
+            if (height === paginationExtraHeight) return;
+            paginationExtraHeight = height;
+            applyDocumentChunkNodeViewAttributes(dom, node, mounted, paginationExtraHeight);
+            if (lazyPreview) {
+                dom.setAttribute('contenteditable', 'false');
+                updateDocumentLazyPreviewSpacer(lazyPreviewLease, height);
+            }
+        }
+    };
+    const unregister = registerDocumentChunkController(editor, id, controller);
+    return {
+        dom,
+        ...mounted && !lazyPreview ? {
+            contentDOM: dom
+        } : {},
+        destroy () {
+            releaseDocumentLazyPreview(registry.lazyPreviewPool, dom, lazyPreviewLease);
+            lazyPreviewLease = null;
+            unregister();
+        },
+        ignoreMutation () {
+            return !mounted || lazyPreview;
+        },
+        update (nextNode, decorations) {
+            if (nextNode.type !== node.type) return false;
+            if (work_document_chunk_geometry_documentChunkId(nextNode) !== id) return false;
+            if (mounted && documentChunkHasLazyContent(nextNode) !== lazyPreview) return false;
+            if (documentChunkIsMounted(nextNode, decorations) !== mounted) return false;
+            node = nextNode;
+            lazyPreview = mounted && documentChunkHasLazyContent(node);
+            applyDocumentChunkNodeViewAttributes(dom, node, mounted, paginationExtraHeight);
+            if (lazyPreview) dom.setAttribute('contenteditable', 'false');
+            return true;
+        }
+    };
+}
+function documentChunkHasLazyContent(node) {
+    return 1 === node.childCount && node.firstChild?.type.name === DOCUMENT_LAZY_BLOCK_NODE;
+}
+function requiredDocumentLazyChunkContent(editor, chunkId) {
+    const payload = documentLazyChunkContentForEditor(editor, chunkId);
+    if (!payload?.length) throw new Error(`The lazy document chunk payload "${chunkId}" is missing.`);
+    return payload;
+}
+function handleDocumentChunkLazyPreviewPointerDown(editor, view, event) {
+    const target = event.target;
+    const chunk = target instanceof Element ? target.closest('[data-document-chunk][data-document-lazy-preview="true"]') : null;
+    const id = chunk?.dataset.documentChunkId;
+    if (!id) return false;
+    const position = documentChunkWindowKey.getState(view.state)?.positions.get(id);
+    const logicalPosition = documentLazyPreviewPointerPosition(event, (position?.from ?? 0) + 2);
+    if (null === logicalPosition) return false;
+    event.preventDefault();
+    editor.commands.setTextSelection(logicalPosition);
+    view.focus();
+    return true;
+}
+function createDocumentChunkWindowState(state) {
+    const geometry = documentChunkGeometry(state.doc, []);
+    const ids = geometry.map(({ id })=>id);
+    const positions = documentChunkPositions(state.doc);
+    const fallback = "u" < typeof IntersectionObserver;
+    const mountedIds = fallback ? new Set(ids) : new Set(ids.slice(0, INITIAL_DOCUMENT_CHUNK_WINDOW_SIZE));
+    const selected = selectedDocumentChunkId(state);
+    if (selected) mountedIds.add(selected);
+    return {
+        chunkCount: ids.length,
+        decorations: documentChunkDecorations(state.doc, mountedIds, positions),
+        fallback,
+        geometry,
+        ids,
+        mountedIds,
+        positions
+    };
+}
+function updateDocumentChunkWindowState(transaction, current, next) {
+    const meta = transaction.getMeta(documentChunkWindowKey);
+    const paginationMeta = transaction.getMeta(DOCUMENT_CHUNK_PAGINATION_META);
+    const hydrationMeta = transaction.getMeta(DOCUMENT_CHUNK_HYDRATION_META);
+    const appendedTo = transaction.getMeta('appendedTransaction');
+    const sourcePaginationMeta = appendedTo?.getMeta(DOCUMENT_CHUNK_PAGINATION_META);
+    const paginationBreaks = paginationMeta?.breaks ?? sourcePaginationMeta?.breaks.map((pageBreak)=>({
+            ...pageBreak,
+            position: transaction.mapping.map(pageBreak.position, -1)
+        }));
+    if (!meta && !paginationMeta && !transaction.docChanged && !transaction.selectionSet) return current;
+    const geometry = paginationBreaks ? documentChunkGeometry(next.doc, paginationBreaks) : transaction.docChanged && !hydrationMeta ? documentChunkGeometry(next.doc, []) : current.geometry;
+    const ids = geometry === current.geometry ? current.ids : geometry.map(({ id })=>id);
+    const positions = geometry === current.geometry ? current.positions : documentChunkPositions(next.doc);
+    const known = geometry === current.geometry ? null : new Set(ids);
+    const mountedIds = current.fallback ? new Set(ids) : new Set(Array.from(meta?.visibleIds ?? current.mountedIds).filter((id)=>!known || known.has(id)));
+    const selected = selectedDocumentChunkId(next);
+    if (selected) mountedIds.add(selected);
+    if (!transaction.docChanged && geometry === current.geometry && setsEqual(mountedIds, current.mountedIds) && ids.length === current.chunkCount) return current;
+    return {
+        chunkCount: ids.length,
+        decorations: documentChunkDecorations(next.doc, mountedIds, positions),
+        fallback: current.fallback,
+        geometry,
+        ids,
+        mountedIds,
+        positions
+    };
+}
+function createDocumentChunkIntersectionView(editor, initialView) {
+    let view = initialView;
+    let observer = null;
+    let scrollRoot = null;
+    let publishQueued = false;
+    let mountFrame = 0;
+    let synchronizedGeometry = null;
+    const observed = new Map();
+    const intersecting = new Set();
+    const registry = documentChunkElementRegistryFor(editor);
+    const dispatchVisibleWindow = (requestedIds)=>{
+        if (view.isDestroyed) return;
+        const state = documentChunkWindowKey.getState(view.state);
+        if (!state) return;
+        const visibleIds = new Set(requestedIds);
+        const selected = selectedDocumentChunkId(view.state);
+        if (selected) visibleIds.add(selected);
+        if (setsEqual(visibleIds, state.mountedIds)) return;
+        const startedAt = globalThis.performance?.now?.() ?? Date.now();
+        const transaction = view.state.tr;
+        view.dispatch(transaction.setMeta(documentChunkWindowKey, {
+            visibleIds: [
+                ...visibleIds
+            ]
+        }).setMeta(DOCUMENT_CHUNK_VISIBLE_IDS_META, {
+            visibleIds: [
+                ...visibleIds
+            ]
+        }).setMeta('addToHistory', false).setMeta('preventUpdate', true));
+        const duration = (globalThis.performance?.now?.() ?? Date.now()) - startedAt;
+        const updates = Number(view.dom.dataset.documentWindowUpdates) || 0;
+        const total = Number(view.dom.dataset.documentWindowTotalMs) || 0;
+        const maximum = Number(view.dom.dataset.documentWindowMaxMs) || 0;
+        view.dom.dataset.documentWindowUpdates = String(updates + 1);
+        view.dom.dataset.documentWindowLastMs = String(roundDuration(duration));
+        view.dom.dataset.documentWindowTotalMs = String(roundDuration(total + duration));
+        view.dom.dataset.documentWindowMaxMs = String(roundDuration(Math.max(maximum, duration)));
+    };
+    const publishIntersectionWindow = ()=>{
+        const state = documentChunkWindowKey.getState(view.state);
+        if (!state) return;
+        const visibleIds = new Set(Array.from(intersecting).filter((id)=>registry.controllers.has(id)));
+        for (const id of [
+            ...intersecting
+        ]){
+            const index = state.ids.indexOf(id);
+            if (index > 0) visibleIds.add(state.ids[index - 1]);
+            if (index >= 0 && index + 1 < state.ids.length) visibleIds.add(state.ids[index + 1]);
+        }
+        dispatchVisibleWindow(visibleIds);
+    };
+    const publishGeometryWindow = ()=>{
+        if (!scrollRoot || view.isDestroyed) return;
+        const state = documentChunkWindowKey.getState(view.state);
+        if (!state?.geometry.length) return;
+        const rootRect = scrollRoot.getBoundingClientRect();
+        const editorRect = view.dom.getBoundingClientRect();
+        const scale = view.dom.offsetWidth > 0 ? Math.max(0.01, editorRect.width / view.dom.offsetWidth) : 1;
+        const viewportTop = Math.max(0, (rootRect.top - editorRect.top) / scale);
+        const viewportBottom = Math.max(viewportTop, (rootRect.bottom - editorRect.top) / scale);
+        const { end, start } = documentChunkViewportRange(state.geometry, viewportTop, viewportBottom);
+        dispatchVisibleWindow(state.geometry.slice(start, end).map(({ id })=>id));
+    };
+    const queuePublication = (publish)=>{
+        if (publishQueued) return;
+        publishQueued = true;
+        queueMicrotask(()=>{
+            publishQueued = false;
+            publish();
+        });
+    };
+    const handleIntersections = (entries)=>{
+        for (const entry of entries){
+            const element = entry.target;
+            const id = element.dataset.documentChunkId;
+            if (id) if (entry.isIntersecting) intersecting.add(id);
+            else intersecting.delete(id);
+        }
+        queuePublication(publishIntersectionWindow);
+    };
+    const handleScroll = ()=>queuePublication(publishGeometryWindow);
+    const disconnectObserver = ()=>{
+        observer?.disconnect();
+        observer = null;
+        observed.clear();
+        intersecting.clear();
+    };
+    const ensureFallbackObserver = ()=>{
+        const state = documentChunkWindowKey.getState(view.state);
+        if (scrollRoot || observer || !state || state.fallback || 0 === state.chunkCount) return false;
+        observer = new IntersectionObserver(handleIntersections, {
+            root: null,
+            rootMargin: DOCUMENT_CHUNK_WINDOW_ROOT_MARGIN,
+            threshold: 0
+        });
+        return true;
+    };
+    const synchronizeElements = ()=>{
+        if (!observer) return;
+        for (const [id, element] of observed)if (registry.controllers.get(id)?.element !== element) {
+            observer.unobserve(element);
+            observed.delete(id);
+            intersecting.delete(id);
+        }
+        for (const [id, controller] of registry.controllers){
+            const element = controller.element;
+            if (id && observed.get(id) !== element) {
+                observed.set(id, element);
+                observer.observe(element);
+            }
+        }
+    };
+    const updateDatasets = ()=>{
+        const state = documentChunkWindowKey.getState(view.state);
+        view.dom.dataset.documentWindowed = String(Boolean(state?.chunkCount));
+        view.dom.dataset.documentChunkCount = String(state?.chunkCount ?? 0);
+        view.dom.dataset.documentMountedChunkCount = String(state?.mountedIds.size ?? 0);
+        if (state?.fallback && state.chunkCount) view.dom.dataset.documentWindowingFallback = 'true';
+        else delete view.dom.dataset.documentWindowingFallback;
+    };
+    const ensureDriver = ()=>{
+        const nextRoot = view.dom.closest('.work-document-scroll');
+        if (nextRoot) {
+            if (nextRoot !== scrollRoot) {
+                scrollRoot?.removeEventListener('scroll', handleScroll);
+                scrollRoot = nextRoot;
+                scrollRoot.addEventListener('scroll', handleScroll, {
+                    passive: true
+                });
+            }
+            disconnectObserver();
+            queuePublication(publishGeometryWindow);
+            return;
+        }
+        if (scrollRoot) {
+            scrollRoot.removeEventListener('scroll', handleScroll);
+            scrollRoot = null;
+        }
+        const created = ensureFallbackObserver();
+        if (created) synchronizeElements();
+    };
+    const synchronize = ()=>{
+        updateDatasets();
+        const state = documentChunkWindowKey.getState(view.state);
+        if (state && state.geometry !== synchronizedGeometry) {
+            synchronizedGeometry = state.geometry;
+            synchronizeDocumentChunkPaginationHeights(registry, state.geometry);
+        }
+        ensureDriver();
+        if (observer) synchronizeElements();
+    };
+    const handleElementChange = ({ id, next, previous })=>{
+        if (previous && observed.get(id) === previous.element) {
+            observer?.unobserve(previous.element);
+            observed.delete(id);
+            intersecting.delete(id);
+        }
+        if (next && observer) {
+            observed.set(id, next.element);
+            observer.observe(next.element);
+        }
+    };
+    registry.listeners.add(handleElementChange);
+    synchronize();
+    queueMicrotask(synchronize);
+    if ('function' == typeof requestAnimationFrame) mountFrame = requestAnimationFrame(()=>{
+        mountFrame = 0;
+        synchronize();
+    });
+    return {
+        destroy () {
+            if (mountFrame) cancelAnimationFrame(mountFrame);
+            registry.listeners.delete(handleElementChange);
+            scrollRoot?.removeEventListener('scroll', handleScroll);
+            scrollRoot = null;
+            disconnectObserver();
+        },
+        update (nextView) {
+            view = nextView;
+            synchronize();
+        }
+    };
+}
+function documentLazyChunkContentForEditor(editor, chunkId) {
+    const content = documentChunkContentSources.get(editor)?.() ?? null;
+    return documentLazyChunkContent(content?.model, chunkId);
+}
+function documentTransactionsOnlyHydrateChunks(transactions) {
+    const changed = transactions.filter((transaction)=>transaction.docChanged);
+    return changed.length > 0 && changed.every((transaction)=>Boolean(transaction.getMeta(DOCUMENT_CHUNK_HYDRATION_META)));
+}
+function hydrateDocumentChunks(editor, transaction, state, requestedIds) {
+    const previousDocument = transaction.doc;
+    const candidates = Array.from(new Set(requestedIds)).map((id)=>({
+            id,
+            position: documentChunkWindowKey.getState(state)?.positions.get(id)
+        })).filter((candidate)=>Boolean(candidate.position)).sort((left, right)=>right.position.from - left.position.from);
+    const hydratedIds = [];
+    const originalAnchor = transaction.selection.anchor;
+    const originalHead = transaction.selection.head;
+    for (const { id, position } of candidates){
+        const chunk = transaction.doc.nodeAt(position.from);
+        if (!chunk || 'documentChunk' !== chunk.type.name || 1 !== chunk.childCount || chunk.firstChild?.type.name !== DOCUMENT_LAZY_BLOCK_NODE) continue;
+        const payload = documentLazyChunkContentForEditor(editor, id);
+        if (!payload?.length) continue;
+        let content;
+        try {
+            content = Fragment.fromArray(payload.map((node)=>transaction.doc.type.schema.nodeFromJSON(node)));
+        } catch (error) {
+            throw new Error(`The lazy document chunk "${id}" cannot be hydrated.`, {
+                cause: error
+            });
+        }
+        if (content.size !== chunk.content.size) throw new Error(`The lazy document chunk "${id}" changed its logical size during hydration.`);
+        transaction.replaceWith(position.from + 1, position.to - 1, content);
+        hydratedIds.push(id);
+    }
+    if (!hydratedIds.length) return hydratedIds;
+    transferDocumentTextStatistics(previousDocument, transaction.doc);
+    transaction.setMeta(DOCUMENT_CHUNK_HYDRATION_META, {
+        ids: hydratedIds
+    }).setMeta('addToHistory', false).setMeta('preventUpdate', true);
+    const maximum = transaction.doc.content.size;
+    if (originalAnchor <= maximum && originalHead <= maximum) {
+        const anchor = transaction.doc.resolve(originalAnchor);
+        const head = transaction.doc.resolve(originalHead);
+        if (anchor.parent.inlineContent && head.parent.inlineContent) transaction.setSelection(TextSelection.create(transaction.doc, originalAnchor, originalHead));
+    }
+    return hydratedIds;
+}
+function documentChunkDecorations(document1, mountedIds, positions) {
+    const decoratedIds = new Set();
+    for (const id of mountedIds){
+        const position = positions.get(id);
+        if (position) {
+            decoratedIds.add(id);
+            for (const ancestorId of position.ancestorIds)decoratedIds.add(ancestorId);
+        }
+    }
+    const decorations = Array.from(decoratedIds).flatMap((id)=>{
+        const position = positions.get(id);
+        return position ? [
+            Decoration.node(position.from, position.to, {}, {
+                documentChunkMounted: true
+            })
+        ] : [];
+    });
+    return DecorationSet.create(document1, decorations);
+}
+function selectedDocumentChunkId(state) {
+    const resolved = state.doc.resolve(state.selection.anchor);
+    for(let depth = resolved.depth; depth >= 0; depth -= 1){
+        const node = resolved.node(depth);
+        if ('documentChunk' === node.type.name) return work_document_chunk_geometry_documentChunkId(node);
+    }
+    return null;
+}
+function documentChunkMountedIds(state) {
+    const chunkState = documentChunkWindowKey.getState(state);
+    return chunkState?.chunkCount ? [
+        ...chunkState.mountedIds
+    ] : null;
+}
+function documentChunkIsMounted(_node, decorations) {
+    return decorations.some((decoration)=>true === decoration.spec.documentChunkMounted);
+}
+function documentChunkElementRegistryFor(editor) {
+    let registry = documentChunkElementRegistries.get(editor);
+    if (!registry) {
+        registry = {
+            controllers: new Map(),
+            lazyPreviewPool: createDocumentLazyPreviewPool(),
+            listeners: new Set(),
+            paginationExtraHeights: new Map()
+        };
+        documentChunkElementRegistries.set(editor, registry);
+    }
+    return registry;
+}
+function registerDocumentChunkController(editor, id, controller) {
+    const registry = documentChunkElementRegistryFor(editor);
+    const previous = registry.controllers.get(id);
+    registry.controllers.set(id, controller);
+    const added = {
+        id,
+        next: controller,
+        previous
+    };
+    for (const listener of registry.listeners)listener(added);
+    return ()=>{
+        if (registry.controllers.get(id) !== controller) return;
+        registry.controllers.delete(id);
+        const removed = {
+            id,
+            previous: controller
+        };
+        for (const listener of registry.listeners)listener(removed);
+    };
+}
+function synchronizeDocumentChunkPaginationHeights(registry, geometry) {
+    const heights = new Map();
+    for (const chunk of geometry){
+        heights.set(chunk.id, chunk.paginationExtraHeight);
+        if (chunk.containerId) heights.set(chunk.containerId, (heights.get(chunk.containerId) ?? 0) + chunk.paginationExtraHeight);
+    }
+    const nextIds = new Set();
+    for (const [id, height] of heights){
+        nextIds.add(id);
+        registry.paginationExtraHeights.set(id, height);
+        registry.controllers.get(id)?.setPaginationExtraHeight(height);
+    }
+    for (const id of [
+        ...registry.paginationExtraHeights.keys()
+    ])if (!nextIds.has(id)) {
+        registry.paginationExtraHeights.delete(id);
+        registry.controllers.get(id)?.setPaginationExtraHeight(0);
+    }
+}
+function documentChunkDomAttributes(node) {
+    return {
+        'data-document-chunk': 'true',
+        'data-document-chunk-id': work_document_chunk_geometry_documentChunkId(node),
+        'data-document-chunk-blocks': String(work_document_chunk_node_positiveInteger(node.attrs.blockCount, node.childCount)),
+        'data-document-chunk-estimated-height': String(work_document_chunk_node_positiveNumber(node.attrs.estimatedHeight, 1)),
+        'data-document-chunk-window-container': String(true === node.attrs.windowContainer)
+    };
+}
+function applyDocumentChunkNodeViewAttributes(dom, node, mounted, paginationExtraHeight) {
+    for (const [name, value] of Object.entries(documentChunkDomAttributes(node)))dom.setAttribute(name, value);
+    dom.dataset.documentChunkMounted = String(mounted);
+    dom.dataset.documentChunkPaginationExtraHeight = String(paginationExtraHeight);
+    dom.className = `work-document-chunk ${mounted ? 'mounted' : 'placeholder'}`;
+    if (mounted) {
+        dom.removeAttribute('aria-hidden');
+        dom.removeAttribute('contenteditable');
+        dom.style.removeProperty('height');
+        dom.style.removeProperty('contain');
+        return;
+    }
+    dom.setAttribute('aria-hidden', 'true');
+    dom.setAttribute('contenteditable', 'false');
+    dom.style.height = `${work_document_chunk_node_positiveNumber(node.attrs.estimatedHeight, 1) + paginationExtraHeight}px`;
+    dom.style.contain = 'strict';
+}
+function setsEqual(left, right) {
+    if (left.size !== right.size) return false;
+    for (const value of left)if (!right.has(value)) return false;
+    return true;
+}
+function work_document_chunk_node_positiveInteger(value, fallback) {
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number >= 0 ? number : fallback;
+}
+function work_document_chunk_node_positiveNumber(value, fallback) {
+    const number = Number(value);
+    return Number.isFinite(number) && number > 0 ? number : fallback;
+}
+function roundDuration(value) {
+    return Math.round(10 * value) / 10;
+}
+const DocumentCitation = core_Node.create({
+    name: 'documentCitation',
+    inline: true,
+    group: 'inline',
+    atom: true,
+    selectable: true,
+    addOptions () {
+        return {
+            getContent: ()=>null,
+            onContentChange: ()=>void 0
+        };
+    },
+    addCommands () {
+        return {
+            insertDocumentCitation: (source, bibliography)=>(props)=>insertDocumentCitationCommand(props, source, bibliography),
+            insertDocumentBibliography: (bibliography)=>(props)=>insertDocumentBibliographyCommand(props, bibliography),
+            refreshDocumentCitations: (content)=>(props)=>refreshDocumentCitationsCommand(props, content),
+            renameDocumentCitationTag: (previousTag, nextTag)=>(props)=>renameDocumentCitationTagCommand(props, previousTag, nextTag),
+            setDocumentBibliography: (bibliography, renamedTag)=>({ dispatch, editor })=>{
+                    const content = this.options.getContent();
+                    if (!content) return false;
+                    if (!dispatch) return true;
+                    const next = {
+                        ...content,
+                        bibliography
+                    };
+                    this.options.onContentChange(next);
+                    const chain = editor.chain();
+                    if (renamedTag) chain.renameDocumentCitationTag(renamedTag.previous, renamedTag.next);
+                    chain.refreshDocumentCitations(next).run();
+                    return true;
+                }
+        };
+    },
+    addAttributes () {
+        return {
+            id: work_document_citation_nodes_hiddenAttribute(''),
+            tags: work_document_citation_nodes_hiddenAttribute(''),
+            instruction: work_document_citation_nodes_hiddenAttribute(''),
+            display: work_document_citation_nodes_hiddenAttribute(''),
+            orphaned: work_document_citation_nodes_hiddenAttribute(false)
+        };
+    },
+    parseHTML () {
+        return [
+            {
+                tag: 'span[data-document-citation]',
+                getAttrs: (node)=>{
+                    if (!(node instanceof HTMLElement)) return false;
+                    const instruction = node.dataset.citationInstruction?.trim() ?? '';
+                    const tags = documentCitationTags(node.dataset.citationTags);
+                    const resolvedTags = tags.length ? tags : documentCitationTagsFromInstruction(instruction);
+                    return {
+                        id: node.dataset.citationId ?? '',
+                        tags: resolvedTags.join(' '),
+                        instruction: instruction || documentCitationInstruction(resolvedTags),
+                        display: node.dataset.citationDisplay?.trim() || node.textContent?.trim() || '缺失引文',
+                        orphaned: 'true' === node.dataset.citationOrphaned
+                    };
+                }
+            }
+        ];
     },
     renderHTML ({ node, HTMLAttributes }) {
         const tags = 'string' == typeof node.attrs.tags ? documentCitationTags(node.attrs.tags) : [];
@@ -10028,6 +11618,7 @@ function createDocumentFieldIdentityPlugin(fieldNodeName = 'documentField') {
     });
 }
 function normalizeDocumentFieldIdentities(state, fieldNodeName, oldState, transactions = []) {
+    if ('documentField' === fieldNodeName && !documentHasIntegrityFeature(state.doc, 2)) return null;
     const fields = documentFields(state.doc, fieldNodeName);
     if (!fields.length) return null;
     const retained = oldState ? retainedDocumentFieldPositions(oldState, state, transactions, fieldNodeName) : new Set();
@@ -11196,6 +12787,42 @@ function syncImageDimension(element, dimension, value) {
     element.style.removeProperty(dimension);
     element.removeAttribute(dimension);
 }
+const DocumentLazyBlock = core_Node.create({
+    name: DOCUMENT_LAZY_BLOCK_NODE,
+    group: 'block',
+    content: 'text*',
+    selectable: false,
+    addAttributes () {
+        return {
+            chunkId: {
+                default: ''
+            },
+            contentSize: {
+                default: 2
+            },
+            paragraphCount: {
+                default: 0
+            }
+        };
+    },
+    parseHTML () {
+        return [
+            {
+                tag: 'div[data-document-lazy-block]'
+            }
+        ];
+    },
+    renderHTML ({ HTMLAttributes }) {
+        return [
+            'div',
+            mergeAttributes(HTMLAttributes, {
+                'data-document-lazy-block': 'true',
+                'aria-hidden': 'true'
+            }),
+            0
+        ];
+    }
+});
 const MAX_DOCUMENT_NUMBERING_START = 2147483647;
 const DocumentBulletList = BulletList.extend({
     addAttributes () {
@@ -11437,6 +13064,7 @@ function createDocumentNoteIntegrityPlugin(referenceNodeName = 'documentNoteRefe
     });
 }
 function normalizeDocumentNoteGraph(state, referenceNodeName, definitionNodeName, oldState, transactions = []) {
+    if ('documentNoteReference' === referenceNodeName && 'documentNote' === definitionNodeName && !documentHasIntegrityFeature(state.doc, 8)) return null;
     const allReferences = documentNoteNodes(state.doc, referenceNodeName);
     const nestedReferences = allReferences.filter((reference)=>positionInsideNode(state.doc, reference.position, definitionNodeName));
     const nestedReferencePositions = new Set(nestedReferences.map(({ position })=>position));
@@ -12349,6 +13977,29 @@ function reusableDocumentLayoutBlocks(previous, blockId, element, nodeTo, dirtyF
             element
         }));
 }
+function reusableDocumentChunkLayoutBlocks(previous, element, chunkFrom, chunkTo, dirtyFrom) {
+    if (chunkTo > dirtyFrom || chunkTo <= chunkFrom || !previous.length) return [];
+    let lower = 0;
+    let upper = previous.length;
+    while(lower < upper){
+        const middle = Math.floor((lower + upper) / 2);
+        if (previous[middle].from < chunkFrom) lower = middle + 1;
+        else upper = middle;
+    }
+    const reused = [];
+    for(let index = lower; index < previous.length; index += 1){
+        const candidate = previous[index];
+        if (candidate.from >= chunkTo) break;
+        if (!(candidate.to > chunkTo)) reused.push({
+            ...candidate,
+            block: {
+                ...candidate.block
+            },
+            element
+        });
+    }
+    return reused;
+}
 function isDocumentListNode(node) {
     return 'bulletList' === node.type.name || 'orderedList' === node.type.name;
 }
@@ -12422,6 +14073,401 @@ function elementForNode(editor, position) {
     if (!node || node.nodeType !== Node.ELEMENT_NODE) return null;
     return node;
 }
+const DOCUMENT_WINDOW_BLOCK_SIZE = 128;
+const DOCUMENT_WINDOW_BLOCK_THRESHOLD = 2048;
+const DOCUMENT_TABLE_WINDOW_ROW_SIZE = 16;
+const DOCUMENT_TABLE_WINDOW_ROW_THRESHOLD = 512;
+const DOCUMENT_TABLE_WINDOW_GROUP_SIZE = 32;
+const DEFAULT_PARAGRAPH_LINE_HEIGHT = 21;
+const DEFAULT_PARAGRAPH_AFTER = 8;
+const DEFAULT_TABLE_ROW_HEIGHT = 22;
+const DOCUMENT_TEXT_CHARACTERS_PER_LINE = 88;
+const DEFAULT_DOCUMENT_WINDOWING_OPTIONS = {
+    blockSize: DOCUMENT_WINDOW_BLOCK_SIZE,
+    blockThreshold: DOCUMENT_WINDOW_BLOCK_THRESHOLD,
+    tableRowSize: DOCUMENT_TABLE_WINDOW_ROW_SIZE,
+    tableRowThreshold: DOCUMENT_TABLE_WINDOW_ROW_THRESHOLD
+};
+function windowDocumentModel(root, requested = {}) {
+    if (documentSectionModelUsesWindowing(root)) return root;
+    const options = normalizeWindowingOptions(requested);
+    let changed = false;
+    const content = root.content?.map((node, sectionIndex)=>{
+        if ('documentSection' !== node.type || !node.content?.length) return node;
+        const needsBlockWindow = node.content.length >= options.blockThreshold;
+        const needsTableWindow = node.content.some((child)=>'table' === child.type && (child.content?.length ?? 0) >= options.tableRowThreshold);
+        if (!needsBlockWindow && !needsTableWindow) return node;
+        changed = true;
+        return {
+            ...node,
+            content: windowSectionContent(node.content, sectionIndex, options)
+        };
+    });
+    return changed ? {
+        ...root,
+        content
+    } : root;
+}
+function materializeWindowedDocumentModel(root) {
+    if (!documentModelUsesWindowing(root)) return root;
+    return {
+        ...root,
+        content: root.content?.map((node)=>'documentSection' === node.type ? materializeWindowedSection(node) : materializeNestedWindowing(node))
+    };
+}
+function documentModelUsesWindowing(root) {
+    const pending = [
+        root
+    ];
+    while(pending.length){
+        const node = pending.pop();
+        if (!node) continue;
+        if ('documentChunk' === node.type || 'table' === node.type && 'string' == typeof node.attrs?.virtualTableId) return true;
+        if (node.content) pending.push(...node.content);
+    }
+    return false;
+}
+function documentSectionModelUsesWindowing(root) {
+    for (const section of root.content ?? [])if ('documentSection' === section.type && section.content?.some((node)=>'documentChunk' === node.type || 'table' === node.type && 'string' == typeof node.attrs?.virtualTableId)) return true;
+    return false;
+}
+function estimateDocumentNodeHeight(node) {
+    if ('tableRow' === node.type) return estimateDocumentTableRowHeight(node);
+    if ('table' === node.type) {
+        const rows = node.content ?? [];
+        const rowsHeight = rows.reduce((height, row)=>height + estimateDocumentTableRowHeight(row), 0);
+        return Math.max(DEFAULT_TABLE_ROW_HEIGHT, rowsHeight + (node.attrs?.officeImported ? 0 : 40));
+    }
+    if ('image' === node.type) {
+        const height = finitePositiveNumber(node.attrs?.height);
+        return Math.max(DEFAULT_PARAGRAPH_LINE_HEIGHT, (height ?? 120) + 36);
+    }
+    if ('horizontalRule' === node.type || 'pageBreak' === node.type) return 38;
+    if ('heading' === node.type) {
+        const level = finitePositiveNumber(node.attrs?.level) ?? 1;
+        const lineHeight = level <= 1 ? 32 : 2 === level ? 28 : 25;
+        return estimatedDocumentNodeTextLines(node) * lineHeight + 18;
+    }
+    if ('paragraph' === node.type) return estimatedDocumentNodeTextLines(node) * DEFAULT_PARAGRAPH_LINE_HEIGHT + DEFAULT_PARAGRAPH_AFTER;
+    if ('bulletList' === node.type || 'orderedList' === node.type) return Math.max(DEFAULT_PARAGRAPH_LINE_HEIGHT + DEFAULT_PARAGRAPH_AFTER, (node.content ?? []).reduce((height, child)=>height + estimateDocumentNodeHeight(child), 0));
+    if ('listItem' === node.type || 'blockquote' === node.type) return Math.max(DEFAULT_PARAGRAPH_LINE_HEIGHT + DEFAULT_PARAGRAPH_AFTER, (node.content ?? []).reduce((height, child)=>height + estimateDocumentNodeHeight(child), 0));
+    if ('documentChunk' === node.type) return finitePositiveNumber(node.attrs?.estimatedHeight) ?? (node.content ?? []).reduce((height, child)=>height + estimateDocumentNodeHeight(child), 0);
+    const childrenHeight = (node.content ?? []).reduce((height, child)=>height + estimateDocumentNodeHeight(child), 0);
+    return Math.max(DEFAULT_PARAGRAPH_LINE_HEIGHT + DEFAULT_PARAGRAPH_AFTER, childrenHeight);
+}
+function estimateDocumentTableRowHeight(row) {
+    const explicit = finitePositiveNumber(row.attrs?.rowHeight);
+    let maximumLines = 1;
+    for (const cell of row.content ?? [])maximumLines = Math.max(maximumLines, estimatedDocumentNodeTextLines(cell));
+    const contentHeight = maximumLines * DEFAULT_PARAGRAPH_LINE_HEIGHT + 1;
+    return Math.max(DEFAULT_TABLE_ROW_HEIGHT, explicit ?? 0, contentHeight);
+}
+function windowSectionContent(source, sectionIndex, options) {
+    const logicalBlocks = source.flatMap((node, blockIndex)=>splitLargeDocumentTable(node, sectionIndex, blockIndex, options));
+    const chunks = [];
+    let pending = [];
+    const flush = ()=>{
+        if (!pending.length) return;
+        const chunkIndex = chunks.length;
+        chunks.push({
+            type: 'documentChunk',
+            attrs: {
+                id: `document-chunk-${sectionIndex + 1}-${chunkIndex + 1}`,
+                blockCount: pending.length,
+                estimatedHeight: roundHeight(pending.reduce((height, node)=>height + estimateDocumentNodeHeight(node), 0)),
+                ...void 0 !== options.trustedIntegrityFeatures ? {
+                    integrityFeatures: options.trustedIntegrityFeatures
+                } : {}
+            },
+            content: pending
+        });
+        pending = [];
+    };
+    for (const node of logicalBlocks){
+        if ('string' == typeof node.attrs?.virtualTableId) {
+            flush();
+            pending = [
+                node
+            ];
+            flush();
+            continue;
+        }
+        pending.push(node);
+        if (pending.length >= options.blockSize) flush();
+    }
+    flush();
+    return groupVirtualTableChunks(chunks, sectionIndex);
+}
+function groupVirtualTableChunks(chunks, sectionIndex) {
+    const grouped = [];
+    let index = 0;
+    while(index < chunks.length){
+        const tableId = virtualTableChunkId(chunks[index]);
+        if (!tableId) {
+            grouped.push(chunks[index]);
+            index += 1;
+            continue;
+        }
+        let end = index + 1;
+        while(end < chunks.length && virtualTableChunkId(chunks[end]) === tableId)end += 1;
+        const run = chunks.slice(index, end);
+        if (run.length <= DOCUMENT_TABLE_WINDOW_GROUP_SIZE) {
+            grouped.push(...run);
+            index = end;
+            continue;
+        }
+        for(let offset = 0; offset < run.length; offset += DOCUMENT_TABLE_WINDOW_GROUP_SIZE){
+            const leaves = run.slice(offset, offset + DOCUMENT_TABLE_WINDOW_GROUP_SIZE);
+            const groupIndex = Math.floor(offset / DOCUMENT_TABLE_WINDOW_GROUP_SIZE);
+            const integrityFeatures = combinedDocumentChunkIntegrityFeatures(leaves);
+            grouped.push({
+                type: 'documentChunk',
+                attrs: {
+                    id: `document-chunk-${sectionIndex + 1}-table-group-${grouped.length + 1}-${groupIndex + 1}`,
+                    blockCount: leaves.reduce((count, leaf)=>count + work_document_windowing_positiveInteger(leaf.attrs?.blockCount, 1), 0),
+                    estimatedHeight: roundHeight(leaves.reduce((height, leaf)=>height + (finitePositiveNumber(leaf.attrs?.estimatedHeight) ?? 1), 0)),
+                    windowContainer: true,
+                    ...null !== integrityFeatures ? {
+                        integrityFeatures
+                    } : {}
+                },
+                content: leaves
+            });
+        }
+        index = end;
+    }
+    return grouped;
+}
+function virtualTableChunkId(node) {
+    const table = node?.type === 'documentChunk' ? node.content?.[0] : void 0;
+    return table?.type === 'table' && 'string' == typeof table.attrs?.virtualTableId ? table.attrs.virtualTableId : null;
+}
+function splitLargeDocumentTable(node, sectionIndex, blockIndex, options) {
+    const rows = node.content ?? [];
+    if ('table' !== node.type || rows.length < options.tableRowThreshold) return [
+        node
+    ];
+    const sliceCount = Math.ceil(rows.length / options.tableRowSize);
+    const tableId = `document-table-${sectionIndex + 1}-${blockIndex + 1}`;
+    return Array.from({
+        length: sliceCount
+    }, (_, index)=>({
+            ...node,
+            attrs: {
+                ...node.attrs ?? {},
+                virtualTableId: tableId,
+                virtualTableIndex: index,
+                virtualTableCount: sliceCount
+            },
+            content: rows.slice(index * options.tableRowSize, (index + 1) * options.tableRowSize)
+        }));
+}
+function materializeWindowedSection(section) {
+    const flattened = flattenDocumentChunks(section.content ?? []);
+    const content = [];
+    for (const node of flattened){
+        const tableId = 'table' === node.type && 'string' == typeof node.attrs?.virtualTableId ? node.attrs.virtualTableId : null;
+        const previous = content.at(-1);
+        if (tableId && previous?.type === 'table' && previous.attrs?.virtualTableId === tableId) {
+            previous.content = [
+                ...previous.content ?? [],
+                ...node.content ?? []
+            ];
+            continue;
+        }
+        content.push(node);
+    }
+    return {
+        ...section,
+        content: content.map(stripVirtualTableAttributes)
+    };
+}
+function flattenDocumentChunks(nodes) {
+    return nodes.flatMap((node)=>'documentChunk' === node.type ? flattenDocumentChunks(node.content ?? []) : [
+            materializeNestedWindowing(node)
+        ]);
+}
+function materializeNestedWindowing(node) {
+    if (!node.content?.length) return node;
+    return {
+        ...node,
+        content: node.content.map(materializeNestedWindowing)
+    };
+}
+function stripVirtualTableAttributes(node) {
+    if ('table' !== node.type || !node.attrs?.virtualTableId) return node;
+    const { virtualTableId: _virtualTableId, virtualTableIndex: _virtualTableIndex, virtualTableCount: _virtualTableCount, ...attrs } = node.attrs;
+    return {
+        ...node,
+        attrs
+    };
+}
+function normalizeWindowingOptions(requested) {
+    const trustedIntegrityFeatures = work_document_windowing_nonNegativeInteger(requested.trustedIntegrityFeatures);
+    return {
+        blockSize: work_document_windowing_positiveInteger(requested.blockSize, DEFAULT_DOCUMENT_WINDOWING_OPTIONS.blockSize),
+        blockThreshold: work_document_windowing_positiveInteger(requested.blockThreshold, DEFAULT_DOCUMENT_WINDOWING_OPTIONS.blockThreshold),
+        tableRowSize: work_document_windowing_positiveInteger(requested.tableRowSize, DEFAULT_DOCUMENT_WINDOWING_OPTIONS.tableRowSize),
+        tableRowThreshold: work_document_windowing_positiveInteger(requested.tableRowThreshold, DEFAULT_DOCUMENT_WINDOWING_OPTIONS.tableRowThreshold),
+        ...null !== trustedIntegrityFeatures ? {
+            trustedIntegrityFeatures
+        } : {}
+    };
+}
+function combinedDocumentChunkIntegrityFeatures(chunks) {
+    let features = 0;
+    for (const chunk of chunks){
+        const value = work_document_windowing_nonNegativeInteger(chunk.attrs?.integrityFeatures);
+        if (null === value) return null;
+        features |= value;
+    }
+    return features;
+}
+function work_document_windowing_positiveInteger(value, fallback) {
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number > 0 ? number : fallback;
+}
+function work_document_windowing_nonNegativeInteger(value) {
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number >= 0 ? number : null;
+}
+function finitePositiveNumber(value) {
+    const number = Number(value);
+    return Number.isFinite(number) && number > 0 ? number : null;
+}
+function estimatedDocumentNodeTextLines(node) {
+    let completedLines = 0;
+    let currentLineLength = 0;
+    let hasText = false;
+    const visit = (current)=>{
+        if ('string' == typeof current.text) {
+            const text = current.text;
+            if (!text) return;
+            hasText = true;
+            let start = 0;
+            let newline = text.indexOf('\n');
+            while(newline >= 0){
+                currentLineLength += newline - start;
+                completedLines += Math.max(1, Math.ceil(currentLineLength / DOCUMENT_TEXT_CHARACTERS_PER_LINE));
+                currentLineLength = 0;
+                start = newline + 1;
+                newline = text.indexOf('\n', start);
+            }
+            currentLineLength += text.length - start;
+            return;
+        }
+        for (const child of current.content ?? [])visit(child);
+    };
+    visit(node);
+    if (!hasText) return 1;
+    return completedLines + Math.max(1, Math.ceil(currentLineLength / DOCUMENT_TEXT_CHARACTERS_PER_LINE));
+}
+function roundHeight(value) {
+    return Math.max(1, Math.round(100 * value) / 100);
+}
+function estimateLazyDocumentLayoutBlocks(nodes, element, chunkId, firstPosition) {
+    const blocks = [];
+    let position = firstPosition;
+    for(let index = 0; index < nodes.length; index += 1){
+        const node = nodes[index];
+        if (!node) continue;
+        const nodeSize = simpleDocumentNodeSize(node);
+        if (null === nodeSize) return [];
+        const id = `${chunkId}-child-${index}-${position}`;
+        if ('table' === node.type) blocks.push(...estimateLazyDocumentTableRows(node, element, id, position));
+        else {
+            const block = measuredDocumentBlock({
+                block: {
+                    id,
+                    height: estimateDocumentNodeHeight(node),
+                    breakBefore: false,
+                    breakAfter: 'pageBreak' === node.type,
+                    keepTogether: false,
+                    keepWithNext: false
+                },
+                element,
+                from: position,
+                to: position + nodeSize
+            });
+            block.observeResize = false;
+            blocks.push(block);
+        }
+        position += nodeSize;
+    }
+    return blocks;
+}
+function estimateLazyDocumentTableRows(table, element, blockId, tablePosition) {
+    const rows = table.content ?? [];
+    if (!rows.length) return [];
+    const virtualTableId = 'string' == typeof table.attrs?.virtualTableId && table.attrs.virtualTableId ? table.attrs.virtualTableId : blockId;
+    const sliceIndex = Number.isSafeInteger(table.attrs?.virtualTableIndex) ? Number(table.attrs?.virtualTableIndex) : 0;
+    const flowId = `${virtualTableId}-slice-${sliceIndex}`;
+    const columnCount = estimateLazyDocumentTableColumnCount(table);
+    const tableBreak = {
+        tableId: flowId,
+        columnCount,
+        colgroupHtml: '',
+        repeatedHeaderRowsHtml: [],
+        repeatedHeaderOverlayHtml: '',
+        repeatHeaderHeight: 0,
+        tableWidth: 0,
+        leadingCellOffsetLeft: 0
+    };
+    const result = [];
+    let rowPosition = tablePosition + 1;
+    for(let rowIndex = 0; rowIndex < rows.length; rowIndex += 1){
+        const row = rows[rowIndex];
+        if (!row) continue;
+        const rowSize = simpleDocumentNodeSize(row);
+        if (null === rowSize) return [];
+        result.push({
+            block: {
+                id: `${flowId}-row-${rowIndex}`,
+                height: estimateDocumentTableRowHeight(row),
+                flowId,
+                flowIndex: rowIndex,
+                flowCount: rows.length,
+                minimumFragmentsPerPage: 1
+            },
+            element,
+            from: rowPosition,
+            to: rowPosition + rowSize,
+            inlineOffsetLeft: 0,
+            inlineOffsetRight: 0,
+            observeResize: false,
+            selectionRanges: estimateLazyDocumentTableRowSelectionRanges(row, rowPosition),
+            tableBreak
+        });
+        rowPosition += rowSize;
+    }
+    return result;
+}
+function estimateLazyDocumentTableRowSelectionRanges(row, rowPosition) {
+    const ranges = [];
+    let cellPosition = rowPosition + 1;
+    for (const cell of row.content ?? []){
+        const cellSize = simpleDocumentNodeSize(cell);
+        if (null === cellSize) return [];
+        ranges.push({
+            from: cellPosition + 1,
+            to: Math.max(cellPosition + 1, cellPosition + cellSize - 1)
+        });
+        cellPosition += cellSize;
+    }
+    return ranges;
+}
+function estimateLazyDocumentTableColumnCount(table) {
+    let maximum = 1;
+    for (const row of table.content ?? []){
+        let columns = 0;
+        for (const cell of row.content ?? []){
+            const colspan = Number(cell.attrs?.colspan);
+            columns += Number.isSafeInteger(colspan) && colspan > 0 ? colspan : 1;
+        }
+        maximum = Math.max(maximum, columns);
+    }
+    return maximum;
+}
 const MAX_DOCUMENT_TEXT_LAYOUT_PARAGRAPHS = 16384;
 const MAX_DOCUMENT_TEXT_LAYOUT_RUNS = 16384;
 const MAX_DOCUMENT_TEXT_LAYOUT_BYTES = 1048576;
@@ -12442,6 +14488,7 @@ function collectDocumentTextLayoutParagraphs(editor, fonts, loadedFontIds, previ
     let textBytes = 0;
     const collectParagraph = (node, element, id, position)=>{
         if (paragraphs.length >= MAX_DOCUMENT_TEXT_LAYOUT_PARAGRAPHS) return;
+        if (!isDocumentLineFragmentNode(node)) return;
         if (reusableDocumentLayoutBlocks(previous?.blocks ?? [], id, element, position + node.nodeSize, dirtyFrom).length) return;
         const paragraph = documentTextLayoutParagraph(node, element, id, fonts, loadedFontIds);
         if (!paragraph) return;
@@ -13567,7 +15614,9 @@ async function measureDocumentLayoutBlocksIncrementally(editor, previous = null,
     const pageStyleByMetrics = new Map();
     const counts = {
         measured: 0,
-        reused: 0
+        prefixOpen: true,
+        reused: 0,
+        reusedPrefix: 0
     };
     const checkpoint = options.checkpoint ?? createDocumentLayoutMeasurementCheckpoint();
     throwIfDocumentMeasurementAborted(options.signal);
@@ -13599,6 +15648,7 @@ async function measureDocumentLayoutBlocksIncrementally(editor, previous = null,
         ],
         measuredBlockCount: counts.measured,
         reusedBlockCount: counts.reused,
+        reusedPrefixBlockCount: counts.reusedPrefix,
         unsupportedLayout
     };
 }
@@ -13640,42 +15690,54 @@ function measureSectionBlock(editor, node, offset, index, sectionPosition, previ
     const element = elementForNode(editor, position);
     if (!element) return;
     const id = documentBlockId(sectionPosition, index, position);
+    if ('documentChunk' === node.type.name) {
+        const reused = reusableDocumentChunkLayoutBlocks(previous, element, position, position + node.nodeSize, dirtyFrom);
+        if (reused.length) {
+            recordReusedDocumentBlocks(counts, reused.length);
+            sectionBlocks.push(...reused);
+            return;
+        }
+        const estimated = estimatedDocumentChunkBlocks(editor, node, element, id, position);
+        recordMeasuredDocumentBlocks(counts, estimated.length);
+        sectionBlocks.push(...estimated);
+        return;
+    }
     const paragraphPagination = documentNodeParagraphPagination(node);
     if (isDocumentListNode(node)) {
         const reused = reusableDocumentListLayoutBlocks(previous, id, position + node.nodeSize, dirtyFrom);
         if (reused.length) {
-            counts.reused += reused.length;
+            recordReusedDocumentBlocks(counts, reused.length);
             sectionBlocks.push(...reused);
             return;
         }
         const listBlocks = measureDocumentListBlocks(editor, node, element, id, position, textLayouts, maximumFragmentedTableRowHeight);
         if (listBlocks.length) {
-            counts.measured += listBlocks.length;
+            recordMeasuredDocumentBlocks(counts, listBlocks.length);
             sectionBlocks.push(...listBlocks);
             return;
         }
     }
     const reused = reusableDocumentLayoutBlocks(previous, id, element, position + node.nodeSize, dirtyFrom);
     if (reused.length) {
-        counts.reused += reused.length;
+        recordReusedDocumentBlocks(counts, reused.length);
         sectionBlocks.push(...reused);
         return;
     }
     if ('table' === node.type.name) {
         const tableRows = measureDocumentTableRows(editor, node, element, id, position, maximumFragmentedTableRowHeight);
         if (tableRows.length) {
-            counts.measured += tableRows.length;
+            recordMeasuredDocumentBlocks(counts, tableRows.length);
             sectionBlocks.push(...tableRows);
             return;
         }
     }
     const lineFragments = measureParagraphLineFragments(editor, node, element, id, position, position + node.nodeSize, paragraphPagination, textLayouts.get(id));
     if (lineFragments.length > 1) {
-        counts.measured += lineFragments.length;
+        recordMeasuredDocumentBlocks(counts, lineFragments.length);
         sectionBlocks.push(...lineFragments);
         return;
     }
-    counts.measured += 1;
+    recordMeasuredDocumentBlocks(counts, 1);
     sectionBlocks.push(measuredDocumentBlock({
         block: {
             id,
@@ -13690,6 +15752,126 @@ function measureSectionBlock(editor, node, offset, index, sectionPosition, previ
         to: position + node.nodeSize
     }));
 }
+function estimatedDocumentChunkBlocks(editor, chunk, element, chunkId, chunkPosition) {
+    const blocks = [];
+    chunk.forEach((node, offset, index)=>{
+        const position = chunkPosition + offset + 1;
+        const id = `${chunkId}-child-${index}-${position}`;
+        if ('documentChunk' === node.type.name) return void blocks.push(...estimatedDocumentChunkBlocks(editor, node, element, id, position));
+        if ('documentLazyBlock' === node.type.name) {
+            const sourceId = 'string' == typeof chunk.attrs.id ? chunk.attrs.id : '';
+            const payload = documentLazyChunkContentForEditor(editor, sourceId);
+            if (payload?.length) blocks.push(...estimateLazyDocumentLayoutBlocks(payload, element, chunkId, position));
+            return;
+        }
+        if ('table' === node.type.name) return void blocks.push(...estimatedDocumentTableRows(node, element, id, position));
+        const pagination = documentNodeParagraphPagination(node);
+        const block = measuredDocumentBlock({
+            block: {
+                id,
+                height: estimatedProseMirrorNodeHeight(node),
+                breakBefore: pagination.pageBreakBefore,
+                breakAfter: 'pageBreak' === node.type.name,
+                keepTogether: pagination.keepLines || shouldKeepDocumentBlockTogether(node),
+                keepWithNext: pagination.keepWithNext
+            },
+            element,
+            from: position,
+            to: position + node.nodeSize
+        });
+        block.observeResize = false;
+        blocks.push(block);
+    });
+    return blocks;
+}
+function estimatedDocumentTableRows(table, element, blockId, tablePosition) {
+    const rowCount = table.childCount;
+    if (!rowCount) return [];
+    const virtualTableId = 'string' == typeof table.attrs.virtualTableId && table.attrs.virtualTableId ? table.attrs.virtualTableId : blockId;
+    const sliceIndex = Number.isSafeInteger(table.attrs.virtualTableIndex) ? Number(table.attrs.virtualTableIndex) : 0;
+    const flowId = `${virtualTableId}-slice-${sliceIndex}`;
+    const columnCount = estimatedDocumentTableColumnCount(table);
+    const tableBreak = {
+        tableId: flowId,
+        columnCount,
+        colgroupHtml: '',
+        repeatedHeaderRowsHtml: [],
+        repeatedHeaderOverlayHtml: '',
+        repeatHeaderHeight: 0,
+        tableWidth: 0,
+        leadingCellOffsetLeft: 0
+    };
+    const result = [];
+    table.forEach((row, offset, rowIndex)=>{
+        const position = tablePosition + offset + 1;
+        result.push({
+            block: {
+                id: `${flowId}-row-${rowIndex}`,
+                height: estimatedProseMirrorTableRowHeight(row),
+                flowId,
+                flowIndex: rowIndex,
+                flowCount: rowCount,
+                minimumFragmentsPerPage: 1
+            },
+            element,
+            from: position,
+            to: position + row.nodeSize,
+            inlineOffsetLeft: 0,
+            inlineOffsetRight: 0,
+            observeResize: false,
+            selectionRanges: estimatedDocumentTableRowSelectionRanges(row, position),
+            tableBreak
+        });
+    });
+    return result;
+}
+function estimatedDocumentTableRowSelectionRanges(row, rowPosition) {
+    const ranges = [];
+    row.forEach((cell, offset)=>{
+        const cellPosition = rowPosition + offset + 1;
+        ranges.push({
+            from: cellPosition + 1,
+            to: Math.max(cellPosition + 1, cellPosition + cell.nodeSize - 1)
+        });
+    });
+    return ranges;
+}
+function estimatedDocumentTableColumnCount(table) {
+    let maximum = 1;
+    table.forEach((row)=>{
+        let columns = 0;
+        row.forEach((cell)=>{
+            const colspan = Number(cell.attrs.colspan);
+            columns += Number.isSafeInteger(colspan) && colspan > 0 ? colspan : 1;
+        });
+        maximum = Math.max(maximum, columns);
+    });
+    return maximum;
+}
+function estimatedProseMirrorTableRowHeight(row) {
+    const explicit = Number(row.attrs.rowHeight);
+    let maximumTextLength = 0;
+    row.forEach((cell)=>{
+        maximumTextLength = Math.max(maximumTextLength, cell.textContent.length);
+    });
+    const lines = Math.max(1, Math.ceil(maximumTextLength / 88));
+    return Math.max(22, Number.isFinite(explicit) && explicit > 0 ? explicit : 0, 21 * lines + 1);
+}
+function estimatedProseMirrorNodeHeight(node) {
+    const lines = Math.max(1, Math.ceil(node.textContent.length / 88));
+    if ('heading' === node.type.name) {
+        const level = Number(node.attrs.level);
+        const lineHeight = level <= 1 ? 32 : 2 === level ? 28 : 25;
+        return lines * lineHeight + 18;
+    }
+    if ('image' === node.type.name) {
+        const height = Number(node.attrs.height);
+        return Math.max(21, (Number.isFinite(height) && height > 0 ? height : 120) + 36);
+    }
+    if ('horizontalRule' === node.type.name || 'pageBreak' === node.type.name) return 38;
+    if ('bulletList' === node.type.name || 'orderedList' === node.type.name) return Math.max(29, 29 * node.childCount);
+    return 21 * lines + 8;
+}
 function finishMeasuredSection(section, sectionPosition, sectionIndex, layout, pageStyle, sectionBlocks, result) {
     const last = sectionBlocks.at(-1);
     if (last && 'continuous' !== layout.breakAfter && 'nextColumn' !== layout.breakAfter) last.block.breakAfter = true;
@@ -13707,6 +15889,16 @@ function finishMeasuredSection(section, sectionPosition, sectionIndex, layout, p
     }
     result.push(...sectionBlocks);
 }
+function recordReusedDocumentBlocks(counts, count) {
+    if (count <= 0) return;
+    counts.reused += count;
+    if (counts.prefixOpen) counts.reusedPrefix += count;
+}
+function recordMeasuredDocumentBlocks(counts, count) {
+    if (count <= 0) return;
+    counts.measured += count;
+    counts.prefixOpen = false;
+}
 function createDocumentLayoutMeasurementCheckpoint() {
     let deadline = documentMeasurementNow() + DOCUMENT_LAYOUT_MEASUREMENT_SLICE_MS;
     return async (signal)=>{
@@ -15437,6 +17629,33 @@ const DocumentTable = Table.extend({
                 renderHTML: (attributes)=>attributes.officeImported ? {
                         'data-office-table-imported': 'true'
                     } : {}
+            },
+            virtualTableId: {
+                default: null,
+                parseHTML: (element)=>element.dataset.documentVirtualTableId || null,
+                renderHTML: (attributes)=>'string' == typeof attributes.virtualTableId && attributes.virtualTableId ? {
+                        'data-document-virtual-table-id': attributes.virtualTableId
+                    } : {}
+            },
+            virtualTableIndex: {
+                default: null,
+                parseHTML: (element)=>nonNegativeSafeInteger(element.dataset.documentVirtualTableIndex),
+                renderHTML: (attributes)=>{
+                    const index = nonNegativeSafeInteger(attributes.virtualTableIndex);
+                    return null === index ? {} : {
+                        'data-document-virtual-table-index': String(index)
+                    };
+                }
+            },
+            virtualTableCount: {
+                default: null,
+                parseHTML: (element)=>positiveSafeInteger(element.dataset.documentVirtualTableCount),
+                renderHTML: (attributes)=>{
+                    const count = positiveSafeInteger(attributes.virtualTableCount);
+                    return null === count ? {} : {
+                        'data-document-virtual-table-count': String(count)
+                    };
+                }
             }
         };
     }
@@ -15445,6 +17664,15 @@ const DocumentTable = Table.extend({
     allowTableNodeSelection: true,
     View: WorkDocumentTableView
 });
+function nonNegativeSafeInteger(value) {
+    if (null == value || '' === value) return null;
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number >= 0 ? number : null;
+}
+function positiveSafeInteger(value) {
+    const number = Number(value);
+    return Number.isSafeInteger(number) && number > 0 ? number : null;
+}
 const DocumentTableSizing = Extension.create({
     name: 'documentTableSizing',
     addCommands () {
@@ -16230,6 +18458,13 @@ function createWorkDocumentExtensions(options = {}) {
         DocumentBulletList,
         DocumentOrderedList,
         DocumentListCommands,
+        DocumentLazyBlock,
+        DocumentChunk.configure({
+            ...options.getContent ? {
+                getContent: options.getContent
+            } : {},
+            trustInitialIntegrityFeatures: Boolean(options.trustInitialIntegrityFeatures)
+        }),
         DocumentSection,
         DocumentBookmarkBoundary,
         DocumentCaption,
@@ -16299,13 +18534,13 @@ function workDocumentSchema() {
     return work_document_model_codec_schema;
 }
 function serializeWorkDocumentNode(root) {
-    return generateHTML(root, documentExtensions());
+    return generateHTML(materializeWindowedDocumentModel(root), documentExtensions());
 }
 function createWorkDocumentModelFromContent(content) {
     const previous = content.model;
     const synchronized = syncDocumentContentFromHtml(content, content.html);
     const document1 = new DOMParser().parseFromString(synchronized.html, 'text/html');
-    const root = model_DOMParser.fromSchema(workDocumentSchema()).parse(document1.body).toJSON();
+    const root = windowDocumentModel(model_DOMParser.fromSchema(workDocumentSchema()).parse(document1.body).toJSON());
     return {
         ...synchronized,
         model: createWorkDocumentModel(synchronized.html, root, previous)
@@ -18082,4 +20317,14 @@ function capturePages(surface) {
             width: surface.pageWidth
         }));
 }
-export { DEFAULT_DOCUMENT_TABLE_CELL_FORMAT, DEFAULT_DOCUMENT_TABLE_CELL_MARGINS, DEFAULT_DOCUMENT_TABLE_GEOMETRY, DOCUMENT_BOOKMARK_DUPLICATE_MESSAGE, DOCUMENT_PAGE_BORDER_EDGES, DOCUMENT_PAGE_MARGIN_KEYS, DOCUMENT_PARAGRAPH_BORDER_EDGES, DOCUMENT_PARAGRAPH_BORDER_STYLES, DOCUMENT_PARAGRAPH_SHADING_PATTERNS, DOCUMENT_TABLE_ROW_ID_ATTRIBUTE, DOCUMENT_TABLE_ROW_TEXT_ID_ATTRIBUTE, DOCUMENT_TABLE_STYLE_OPTIONS, DocumentEquation, DocumentImage, DocumentParagraphFormatting, DocumentParagraphIdentity, DocumentSubscript, DocumentSuperscript, DocumentTableRowIdentity, DocxThemePatchCollector, MAX_DOCUMENT_IMAGE_RELATIVE_HEIGHT, MAX_DOCUMENT_NUMBERING_START, activeDocumentBookmark, activeDocumentSection, activeDocumentTableStyle, applyDocumentImageCropToElement, applyDocumentImageIdentityToElement, applyDocumentImageLayerToElement, applyDocumentImageWrapContourToElement, applyDocumentPageGeometry, applyDocumentParagraphIdentityToElement, applyDocumentTableGeometryToElement, applyDocumentTableRowIdentityToElement, canChangeDocumentIndent, canInsertDocumentComment, canSetDocumentTableRowRepeatHeader, clampDocumentMargin, collectDocumentChanges, collectDocumentCommentAnchors, collectDocumentNotes, collectDocumentTextLayoutParagraphs, createDocumentBibliography, createDocumentEquationElement, createDocumentImageIdentityRegistry, createDocumentNoteElement, createDocumentParagraphIdentityRegistry, createWorkDocumentExtensions, createWorkDocumentModel, createWorkDocumentModelFromContent, createWorkOfficeDocumentCollaborationBinding as createOfficeDocumentCollaborationBinding, defaultDocumentImageWrapContour, documentAutoLineHeight, documentBookmarkNameExists, documentBookmarkReferenceInstruction, documentBulletListStyle, documentCaptionKind, documentCaptionLabel, documentCitationCount, documentCitationInstruction, documentCitationStyle, documentCitationStyleDetails, documentCitationTags, documentCitationTagsFromInstruction, documentCommentDraftRange, documentCommentViews, documentContentLayoutProperties, documentEquationFromElement, documentEquationText, documentImageCropFromElement, documentImageIdentityFromElement, documentImageLayerFromElement, documentImageLayoutFromElement, documentImageLayoutOptions, documentImagePositionFromElement, documentImageProperties, documentImageWrapContourFromElement, documentInitialSectionLayout, documentModelForContent, documentNoteKey, documentNoteKind, documentOrderedListState, documentPageBordersVisible, documentPageChromeLegacyFields, documentPageGeometryForLayout, documentPageHorizontalMarginTwips, documentPageMarginBody, documentPageMarginsForLayout, documentPageMetrics, documentParagraphBordersDomAttributes, documentParagraphDirection, documentParagraphIdentityFromElement, documentParagraphIndent, documentParagraphPagination, documentParagraphShadingDomAttributes, documentParagraphSpacing, documentParagraphTabStops, documentSectionById, documentSectionDomAttributes, documentSections, documentTabLeaderLabel, documentTableBordersFromElement, documentTableCellFormat, documentTableCellMarginOverridesFromElement, documentTableColumnPercentagesFromElement, documentTableGeometryFromElement, documentTableHorizontalAlignment, documentTableRowIdentityFromElement, documentTableRowOptions, documentTableSizing, documentTextLayoutBatches, documentWordLineHeightFactor, docxBookmarkReferenceTarget, docxDocumentFieldKind, editorDocumentBookmarkReferenceTargets, editorDocumentCaptionTargets, importedDocumentCharacterFormatting, initializeWorkOfficeDocumentCollaboration as initializeOfficeDocumentCollaboration, isContourImageLayout, isDocumentParagraphArtBorderStyle, isValidDocumentCitationTag, materializeWorkDocumentContent, measureDocumentLayoutBlocksIncrementally, millimetersToPixels, mountWorkLiveDocumentCapture, nextDocumentTabAlignment, normalizeDocumentBookmarkName, normalizeDocumentBookmarkNativeId, normalizeDocumentBookmarkReferencesHtml, normalizeDocumentBookmarksHtml, normalizeDocumentCaptionsHtml, normalizeDocumentCitationsHtml, normalizeDocumentColumns, normalizeDocumentEquation, normalizeDocumentFieldsHtml, normalizeDocumentHtml, normalizeDocumentImageAlignment, normalizeDocumentImageCrop, normalizeDocumentImageIdentity, normalizeDocumentImageLayer, normalizeDocumentImageLayoutOptions, normalizeDocumentImagePosition, normalizeDocumentImageWrapContour, normalizeDocumentImageWrapSide, normalizeDocumentNotesHtml, normalizeDocumentPageBorders, normalizeDocumentPageChrome, normalizeDocumentPageGeometry, normalizeDocumentPageMargins, normalizeDocumentPaperSource, normalizeDocumentParagraphBorder, normalizeDocumentParagraphBorders, normalizeDocumentParagraphId, normalizeDocumentParagraphIdentity, normalizeDocumentParagraphIndent, normalizeDocumentTabStops, normalizeDocumentTableBorderStyle, normalizeDocumentTableBorderWidth, normalizeDocumentTableRowHeightRule, normalizeDocumentTableRowIdentity, normalizeDocumentTableVerticalAlign, normalizeTableColor, normalizedTabPosition, pageTwipsToMillimeters, parseDocumentCharacterFormatting, parseDocumentParagraphBordersElement, parseDocumentParagraphFormatting, parseDocumentParagraphShadingElement, parseDocxThemeReference, patchDocxThemeReferences, positionWorkLiveDocumentCapture, readWorkOfficeDocumentCollaboration as readOfficeDocumentCollaboration, renderDocumentAutoLineHeight, renderDocumentTableBorders, renderDocumentTableCellMarginOverrides, resolveDocumentPageBorders, resolveDocumentPageChrome, resolveDocumentPageMargins, resolveDocumentPageSize, resolveWorkDocumentEditorInput, retainAnchoredDocumentComments, sanitizeDocumentPageChromeHtml, serializeDocumentParagraphFormatting, serializeDocumentTabStops, serializeDocxThemeReference, serializeWorkDocumentNode, setCustomDocumentColumns, supportedDocxBookmarkReferenceInstruction, syncDocumentContentFromHtml, uniqueDocumentImageIdentity, uniqueDocumentParagraphIdentity, updateDocumentColumnWidth, updateDocumentCustomPageMillimeters, updateDocumentGutterPosition, updateDocumentMirrorMargins, updateDocumentPageChromeVariant, updateDocumentPageMarginMillimeters, updateDocumentPageMarginMode, updateDocumentPageOrientation, updateDocumentPaperSizePreset, validateDocumentBookmarkName, workDocumentSchema, workOfficeDocumentCollaborationFragment as officeDocumentCollaborationFragment, work_document_page_margins_twipsToMillimeters, wrapsBesideImage };
+const documentPageSurfaceProviders = new WeakMap();
+function registerDocumentPageSurfaceGeometry(element, provider) {
+    documentPageSurfaceProviders.set(element, provider);
+    return ()=>{
+        if (documentPageSurfaceProviders.get(element) === provider) documentPageSurfaceProviders.delete(element);
+    };
+}
+function documentPageSurfaceGeometryForElement(element) {
+    return documentPageSurfaceProviders.get(element)?.() ?? null;
+}
+export { DEFAULT_DOCUMENT_TABLE_CELL_FORMAT, DEFAULT_DOCUMENT_TABLE_CELL_MARGINS, DEFAULT_DOCUMENT_TABLE_GEOMETRY, DOCUMENT_BOOKMARK_DUPLICATE_MESSAGE, DOCUMENT_CHUNK_HYDRATION_META, DOCUMENT_CHUNK_PAGINATION_META, DOCUMENT_CHUNK_VISIBLE_IDS_META, DOCUMENT_PAGE_BORDER_EDGES, DOCUMENT_PAGE_MARGIN_KEYS, DOCUMENT_PARAGRAPH_BORDER_EDGES, DOCUMENT_PARAGRAPH_BORDER_STYLES, DOCUMENT_PARAGRAPH_SHADING_PATTERNS, DOCUMENT_TABLE_ROW_ID_ATTRIBUTE, DOCUMENT_TABLE_ROW_TEXT_ID_ATTRIBUTE, DOCUMENT_TABLE_STYLE_OPTIONS, DocumentEquation, DocumentImage, DocumentParagraphFormatting, DocumentParagraphIdentity, DocumentSubscript, DocumentSuperscript, DocumentTableRowIdentity, DocxThemePatchCollector, MAX_DOCUMENT_IMAGE_RELATIVE_HEIGHT, MAX_DOCUMENT_NUMBERING_START, activeDocumentBookmark, activeDocumentSection, activeDocumentTableStyle, applyDocumentImageCropToElement, applyDocumentImageIdentityToElement, applyDocumentImageLayerToElement, applyDocumentImageWrapContourToElement, applyDocumentPageGeometry, applyDocumentParagraphIdentityToElement, applyDocumentTableGeometryToElement, applyDocumentTableRowIdentityToElement, canChangeDocumentIndent, canInsertDocumentComment, canSetDocumentTableRowRepeatHeader, clampDocumentMargin, collectDocumentChanges, collectDocumentCommentAnchors, collectDocumentNotes, collectDocumentTextLayoutParagraphs, createDocumentBibliography, createDocumentEquationElement, createDocumentImageIdentityRegistry, createDocumentNoteElement, createDocumentParagraphIdentityRegistry, createSchemaDerivedWorkDocumentModel, createSchemaValidatedWorkDocumentModel, createWorkDocumentExtensions, createWorkDocumentModel, createWorkDocumentModelFromContent, createWorkOfficeDocumentCollaborationBinding as createOfficeDocumentCollaborationBinding, defaultDocumentImageWrapContour, documentAutoLineHeight, documentBookmarkNameExists, documentBookmarkReferenceInstruction, documentBulletListStyle, documentCaptionKind, documentCaptionLabel, documentChunkMountedIds, documentCitationCount, documentCitationInstruction, documentCitationStyle, documentCitationStyleDetails, documentCitationTags, documentCitationTagsFromInstruction, documentCommentDraftRange, documentCommentViews, documentContentLayoutProperties, documentEquationFromElement, documentEquationText, documentImageCropFromElement, documentImageIdentityFromElement, documentImageLayerFromElement, documentImageLayoutFromElement, documentImageLayoutOptions, documentImagePositionFromElement, documentImageProperties, documentImageWrapContourFromElement, documentInitialSectionLayout, documentLazyHtmlChunkFragment, documentLazyHtmlProjection, documentLazyHtmlProjectionFingerprint, documentModelForContent, documentModelForHtml, documentModelHasTrustedInitialIntegrityFeatures, documentModelUsesWindowing, documentNoteKey, documentNoteKind, documentOrderedListState, documentPageBordersVisible, documentPageChromeLegacyFields, documentPageGeometryForLayout, documentPageHorizontalMarginTwips, documentPageMarginBody, documentPageMarginsForLayout, documentPageMetrics, documentPageSurfaceGeometryForElement, documentPaperSizeForGeometry, documentParagraphBordersDomAttributes, documentParagraphDirection, documentParagraphIdentityFromElement, documentParagraphIndent, documentParagraphPagination, documentParagraphShadingDomAttributes, documentParagraphSpacing, documentParagraphTabStops, documentSectionById, documentSectionDomAttributes, documentSections, documentTabLeaderLabel, documentTableBordersFromElement, documentTableCellFormat, documentTableCellMarginOverridesFromElement, documentTableColumnPercentagesFromElement, documentTableGeometryFromElement, documentTableHorizontalAlignment, documentTableRowIdentityFromElement, documentTableRowOptions, documentTableSizing, documentTextLayoutBatches, documentTextStatistics, documentTransactionsOnlyHydrateChunks, documentWordLineHeightFactor, docxBookmarkReferenceTarget, docxDocumentFieldKind, editorDocumentBookmarkReferenceTargets, editorDocumentCaptionTargets, importedDocumentCharacterFormatting, initializeWorkOfficeDocumentCollaboration as initializeOfficeDocumentCollaboration, invalidateDocumentLazyHtmlProjection, isContourImageLayout, isDocumentParagraphArtBorderStyle, isValidDocumentCitationTag, materializeLazyDocumentEditorRoot, materializeWorkDocumentContent, measureDocumentLayoutBlocksIncrementally, millimetersToPixels, mountWorkLiveDocumentCapture, nextDocumentTabAlignment, normalizeDocumentBookmarkName, normalizeDocumentBookmarkNativeId, normalizeDocumentBookmarkReferencesHtml, normalizeDocumentBookmarksHtml, normalizeDocumentCaptionsHtml, normalizeDocumentCitationsHtml, normalizeDocumentColumns, normalizeDocumentEquation, normalizeDocumentFieldsHtml, normalizeDocumentHtml, normalizeDocumentImageAlignment, normalizeDocumentImageCrop, normalizeDocumentImageIdentity, normalizeDocumentImageLayer, normalizeDocumentImageLayoutOptions, normalizeDocumentImagePosition, normalizeDocumentImageWrapContour, normalizeDocumentImageWrapSide, normalizeDocumentNotesHtml, normalizeDocumentPageBorders, normalizeDocumentPageChrome, normalizeDocumentPageGeometry, normalizeDocumentPageMargins, normalizeDocumentPaperSource, normalizeDocumentParagraphBorder, normalizeDocumentParagraphBorders, normalizeDocumentParagraphId, normalizeDocumentParagraphIdentity, normalizeDocumentParagraphIndent, normalizeDocumentTabStops, normalizeDocumentTableBorderStyle, normalizeDocumentTableBorderWidth, normalizeDocumentTableRowHeightRule, normalizeDocumentTableRowIdentity, normalizeDocumentTableVerticalAlign, normalizeTableColor, normalizedTabPosition, pageTwipsToMillimeters, parseDocumentCharacterFormatting, parseDocumentParagraphBordersElement, parseDocumentParagraphFormatting, parseDocumentParagraphShadingElement, parseDocxThemeReference, patchDocumentLazyHtmlProjection, patchDocxThemeReferences, positionWorkLiveDocumentCapture, readWorkOfficeDocumentCollaboration as readOfficeDocumentCollaboration, registerDocumentPageSurfaceGeometry, renderDocumentAutoLineHeight, renderDocumentTableBorders, renderDocumentTableCellMarginOverrides, resolveDocumentPageBorders, resolveDocumentPageChrome, resolveDocumentPageMargins, resolveDocumentPageSize, resolveWorkDocumentEditorInput, retainAnchoredDocumentComments, sanitizeDocumentPageChromeHtml, selectedDocumentChunkId, serializeDocumentParagraphFormatting, serializeDocumentTabStops, serializeDocxThemeReference, serializeWorkDocumentNode, setCustomDocumentColumns, supportedDocxBookmarkReferenceInstruction, syncDocumentContentFromHtml, transferChangedDocumentTextStatistics, uniqueDocumentImageIdentity, uniqueDocumentParagraphIdentity, updateDocumentColumnWidth, updateDocumentCustomPageMillimeters, updateDocumentGutterPosition, updateDocumentMirrorMargins, updateDocumentPageChromeVariant, updateDocumentPageMarginMillimeters, updateDocumentPageMarginMode, updateDocumentPageOrientation, updateDocumentPaperSizePreset, validateDocumentBookmarkName, windowDocumentModel, workDocumentSchema, workOfficeDocumentCollaborationFragment as officeDocumentCollaborationFragment, work_document_page_margins_twipsToMillimeters, wrapsBesideImage };