@a3s-lab/office 0.2.2 → 0.4.0

package/dist/4104.js

@@ -1,10 +1,460 @@
 import jszip from "jszip";
-import { documentContentLayoutProperties, mountWorkLiveDocumentCapture } from "./2881.js";
-import { createOfficeId as createWorkId, createArtifact as createWorkArtifact } from "./1134.js";
-import { workSpreadsheetChartSupportsGrouping, parseXml, attribute, normalizeSpreadsheetPrintTitleColumns, normalizeSpreadsheetPrintTitleRows, normalizeWorkSpreadsheetErrorBars, directChildren, workSpreadsheetChartSupportsBarSpacing, xlsxTwoCellAnchorMarkers, normalizeWorkSpreadsheetChartGrouping, xlsxDrawingAnchorToBounds, normalizeWorkSpreadsheetChartAxisGroup, normalizeWorkSpreadsheetScatterStyle, firstDescendant, descendants, workSpreadsheetChartAxisIsCategoryAxis, normalizeWorkSpreadsheetDoughnutHoleSize, normalizeWorkSpreadsheetChartAxes, parseSpreadsheetPrintTitles, editableSpreadsheetFormula, normalizeWorkSpreadsheetChartLegendPosition, effectiveSpreadsheetCalculationSettings, normalizeWorkSpreadsheetTrendline, normalizeWorkSpreadsheetDataLabels, normalizeSpreadsheetPrintArea, bytesToDataUrl, OoxmlPackage, formatSpreadsheetCellRanges, normalizeWorkSpreadsheetChartSmoothLines, spreadsheetCellAddress, spreadsheetFormulaRangeForCell, spreadsheetPivotFilterValueKey, normalizeWorkSpreadsheetBubbleScale, normalizeWorkSpreadsheetChartSeriesStyle, qualifySpreadsheetRange, normalizeWorkSpreadsheetBubbleSizeRepresents, workSpreadsheetChartSupportsTrendlines, normalizeWorkSpreadsheetChartLegendOverlay, normalizeWorkSpreadsheetChartGapWidth, workSpreadsheetChartGroupingIsStacked, stripSpreadsheetSheetQualifier, workSpreadsheetChartSupportsSmoothLines, refreshSpreadsheetPivotTables, workSpreadsheetChartSupportsErrorBars, contentTypeForPart, workSpreadsheetChartAxisDefaultLabelPosition, isValidSpreadsheetDefinedName, spreadsheetPivotValidation, resolveSpreadsheetChart, parseSpreadsheetCellRanges, spreadsheetPivotFields, xmlNamespacePrefix, normalizeWorkSpreadsheetChartOverlap, spreadsheetFormulaRangeConflict, spreadsheetFormulaForXlsx, workSpreadsheetChartUsesNumericXAxis, normalizeWorkSpreadsheetChartColor, readXlsxDrawingAnchor, directChild, workSpreadsheetChartSupportsAxes, workSpreadsheetChartAxisShowsMajorGridlinesByDefault, normalizeWorkSpreadsheetRadarStyle, normalizeWorkSpreadsheetCombinationSeriesType } from "./8715.js";
-import { editableRangeRequiresCredentials, normalizeSpreadsheetConditionalIconSetFormat, defaultSpreadsheetDataBarOptions, normalizeSpreadsheetConditionalVisualOptions, normalizeSheetProtectionAuthority, applySpreadsheetCellProtectionRanges, normalizeSpreadsheetPaperSize, defaultSpreadsheetColorScaleThresholds, applyPasswordlessEditableRanges, sheetHasProtectionState, spreadsheetConditionalComparisonNeedsUpperValue, isSpreadsheetConditionalComparisonOperator, defaultSpreadsheetConditionalIconThresholds, DEFAULT_PROTECTION_HINT, isSpreadsheetConditionalIconSetName, spreadsheetConditionalThresholdsEqual, spreadsheetConditionalIconSetCount } from "./8728.js";
+import { MarkdownManager } from "@tiptap/markdown";
+import { getSchema } from "@tiptap/core";
+import { OFFICE_COLLABORATION_PROTOCOL as WORK_OFFICE_COLLABORATION_PROTOCOL, OfficeCollaborationError as WorkOfficeCollaborationError, assertWorkOfficeCollaborationOrigin } from "./9787.js";
+import { createWorkDocumentModel, documentContentLayoutProperties, documentModelForContent, mountWorkLiveDocumentCapture, materializeWorkDocumentContent as work_document_model_codec_materializeWorkDocumentContent, createWorkDocumentExtensions, positionWorkLiveDocumentCapture } from "./8928.js";
+import { contentTypeForPart, directChildren, bytesToDataUrl, OoxmlPackage, parseXml, firstDescendant, xmlNamespacePrefix, directChild, descendants, createArtifact as createWorkArtifact, createOfficeId as createWorkId, attribute } from "./5184.js";
+import { spreadsheetFormulaForXlsx, workSpreadsheetChartSupportsGrouping, normalizeSpreadsheetPrintArea, spreadsheetFormulaRangeConflict, formatSpreadsheetCellRanges, effectiveSpreadsheetCalculationSettings, normalizeWorkSpreadsheetChartSmoothLines, editableSpreadsheetFormula, spreadsheetCellAddress, spreadsheetFormulaRangeForCell, spreadsheetPivotFilterValueKey, normalizeWorkSpreadsheetBubbleScale, normalizeWorkSpreadsheetChartSeriesStyle, qualifySpreadsheetRange, normalizeSpreadsheetPrintTitleColumns, normalizeSpreadsheetPrintTitleRows, normalizeWorkSpreadsheetErrorBars, normalizeWorkSpreadsheetBubbleSizeRepresents, workSpreadsheetChartSupportsBarSpacing, workSpreadsheetChartSupportsTrendlines, workSpreadsheetChartGroupingIsStacked, normalizeWorkSpreadsheetChartGrouping, normalizeWorkSpreadsheetChartLegendOverlay, workSpreadsheetChartSupportsSmoothLines, normalizeWorkSpreadsheetChartGapWidth, xlsxTwoCellAnchorMarkers, xlsxDrawingAnchorToBounds, stripSpreadsheetSheetQualifier, workSpreadsheetChartSupportsErrorBars, refreshSpreadsheetPivotTables, normalizeWorkSpreadsheetChartAxisGroup, normalizeWorkSpreadsheetScatterStyle, workSpreadsheetChartAxisDefaultLabelPosition, isValidSpreadsheetDefinedName, spreadsheetPivotValidation, resolveSpreadsheetChart, workSpreadsheetChartAxisIsCategoryAxis, parseSpreadsheetCellRanges, spreadsheetPivotFields, normalizeWorkSpreadsheetDoughnutHoleSize, normalizeWorkSpreadsheetChartAxes, normalizeWorkSpreadsheetChartOverlap, workSpreadsheetChartUsesNumericXAxis, readXlsxDrawingAnchor, parseSpreadsheetPrintTitles, normalizeWorkSpreadsheetChartLegendPosition, normalizeWorkSpreadsheetChartColor, workSpreadsheetChartSupportsAxes, workSpreadsheetChartAxisShowsMajorGridlinesByDefault, normalizeWorkSpreadsheetTrendline, normalizeWorkSpreadsheetRadarStyle, normalizeWorkSpreadsheetCombinationSeriesType, normalizeWorkSpreadsheetDataLabels } from "./8715.js";
+import { editableRangeRequiresCredentials, normalizeSpreadsheetConditionalIconSetFormat, defaultSpreadsheetDataBarOptions, normalizeSpreadsheetConditionalVisualOptions, normalizeSheetProtectionAuthority, applySpreadsheetCellProtectionRanges, normalizeSpreadsheetPaperSize, defaultSpreadsheetColorScaleThresholds, applyPasswordlessEditableRanges, sheetHasProtectionState, spreadsheetConditionalComparisonNeedsUpperValue, isSpreadsheetConditionalComparisonOperator, defaultSpreadsheetConditionalIconThresholds, DEFAULT_PROTECTION_HINT, isSpreadsheetConditionalIconSetName, spreadsheetConditionalThresholdsEqual, spreadsheetConditionalIconSetCount } from "./4476.js";
 import { materializeWorkFile } from "./9356.js";
+import "./2591.js";
+import "./3818.js";
+import "./4560.js";
 import "./6489.js";
+import * as __rspack_external_yjs from "yjs";
+const WORK_OFFICE_COLLABORATION_PRESENCE_FIELD = 'a3sOffice';
+const MAX_PRESENCE_RANGES = 64;
+const MAX_PRESENCE_ELEMENT_IDS = 128;
+function createWorkOfficeCollaborationPresence(session, initial = {}) {
+    return new WorkOfficeCollaborationPresenceImpl(session, initial);
+}
+let nextPresenceSequence = 0;
+class WorkOfficeCollaborationPresenceImpl {
+    #session;
+    #awareness;
+    #actor;
+    #presenceId;
+    #listeners = new Set();
+    #activity;
+    #location;
+    #destroyed = false;
+    constructor(session, initial){
+        session.metadata();
+        if (!session.awareness) throw new WorkOfficeCollaborationError('office.collaboration.presence_unavailable', 'Office collaboration presence requires host-provided Yjs Awareness.');
+        if (!session.actor) throw new WorkOfficeCollaborationError('office.collaboration.presence_unavailable', 'Office collaboration presence requires a typed local actor.');
+        if (!isClientId(session.awareness.clientID) || session.awareness.clientID !== session.document.clientID) throw new WorkOfficeCollaborationError('office.collaboration.presence_unavailable', 'Office collaboration Awareness must belong to the session Y.Doc.');
+        const existing = session.awareness.getLocalState()?.[WORK_OFFICE_COLLABORATION_PRESENCE_FIELD];
+        if (null != existing) throw new WorkOfficeCollaborationError('office.collaboration.presence_conflict', 'The local Awareness state already has an A3S Office presence owner.');
+        this.#session = session;
+        this.#awareness = session.awareness;
+        this.#actor = copiedActor(session.actor);
+        this.#presenceId = createPresenceId(session.document.clientID);
+        this.#activity = normalizedActivity(initial.activity ?? 'active');
+        this.#location = void 0 === initial.location || null === initial.location ? void 0 : normalizedLocalLocation(initial.location, session.kind);
+        this.#awareness.on('change', this.#onAwarenessChange);
+        try {
+            this.publish();
+        } catch (error) {
+            this.#awareness.off('change', this.#onAwarenessChange);
+            throw error;
+        }
+    }
+    local() {
+        this.ensureActive();
+        this.ensureOwnership();
+        return this.state();
+    }
+    snapshot() {
+        this.ensureActive();
+        const participants = [];
+        for (const [clientId, awarenessState] of this.#awareness.getStates()){
+            if (!isClientId(clientId) || !isRecord(awarenessState)) continue;
+            const state = validatedPresenceState(awarenessState[WORK_OFFICE_COLLABORATION_PRESENCE_FIELD], this.#session);
+            if (state) participants.push(Object.freeze({
+                ...state,
+                clientId,
+                local: clientId === this.#awareness.clientID
+            }));
+        }
+        participants.sort((left, right)=>left.clientId - right.clientId);
+        return Object.freeze({
+            localClientId: this.#awareness.clientID,
+            participants: Object.freeze(participants)
+        });
+    }
+    update(update) {
+        this.ensureActive();
+        this.ensureOwnership();
+        if (!isRecord(update)) throw invalidPresence('Presence updates must be plain objects.');
+        const nextActivity = void 0 === update.activity ? this.#activity : normalizedActivity(update.activity);
+        const nextLocation = Object.hasOwn(update, 'location') ? null === update.location ? void 0 : normalizedLocalLocation(update.location, this.#session.kind) : this.#location;
+        this.#activity = nextActivity;
+        this.#location = nextLocation;
+        this.publish();
+        return this.state();
+    }
+    subscribe(listener) {
+        this.ensureActive();
+        if ('function' != typeof listener) throw invalidPresence('Presence listeners must be functions.');
+        this.#listeners.add(listener);
+        return ()=>this.#listeners.delete(listener);
+    }
+    destroy() {
+        if (this.#destroyed) return;
+        this.#destroyed = true;
+        this.#awareness.off('change', this.#onAwarenessChange);
+        this.#listeners.clear();
+        const current = this.#awareness.getLocalState()?.[WORK_OFFICE_COLLABORATION_PRESENCE_FIELD];
+        if (isRecord(current) && current.presenceId === this.#presenceId) this.#awareness.setLocalStateField(WORK_OFFICE_COLLABORATION_PRESENCE_FIELD, null);
+    }
+    #onAwarenessChange = ()=>{
+        if (this.#destroyed) return;
+        const snapshot = this.snapshot();
+        for (const listener of this.#listeners)listener(snapshot);
+    };
+    publish() {
+        this.#awareness.setLocalStateField(WORK_OFFICE_COLLABORATION_PRESENCE_FIELD, this.state());
+    }
+    state() {
+        return Object.freeze({
+            protocol: WORK_OFFICE_COLLABORATION_PROTOCOL,
+            version: 1,
+            artifactId: this.#session.artifactId,
+            artifactKind: this.#session.kind,
+            namespace: this.#session.namespace,
+            presenceId: this.#presenceId,
+            actor: this.#actor,
+            mode: this.#session.mode,
+            activity: this.#activity,
+            location: this.#location
+        });
+    }
+    ensureOwnership() {
+        const current = this.#awareness.getLocalState()?.[WORK_OFFICE_COLLABORATION_PRESENCE_FIELD];
+        if (!isRecord(current) || current.presenceId !== this.#presenceId) throw new WorkOfficeCollaborationError('office.collaboration.presence_conflict', 'The local A3S Office presence field was replaced by another owner.');
+    }
+    ensureActive() {
+        if (!this.#destroyed) return;
+        throw new WorkOfficeCollaborationError('office.collaboration.binding_destroyed', 'The Office collaboration presence controller has been destroyed.');
+    }
+}
+function validatedPresenceState(value, session) {
+    if (!isRecord(value) || value.protocol !== WORK_OFFICE_COLLABORATION_PROTOCOL || 1 !== value.version || value.artifactId !== session.artifactId || value.artifactKind !== session.kind || value.namespace !== session.namespace || !isIdentifier(value.presenceId) || !isMode(value.mode) || !isActivity(value.activity)) return null;
+    const actor = validatedActor(value.actor);
+    if (!actor) return null;
+    const location = void 0 === value.location ? void 0 : validatedLocation(value.location, session.kind);
+    if (void 0 !== value.location && null === location) return null;
+    return Object.freeze({
+        protocol: WORK_OFFICE_COLLABORATION_PROTOCOL,
+        version: 1,
+        artifactId: session.artifactId,
+        artifactKind: session.kind,
+        namespace: session.namespace,
+        presenceId: value.presenceId,
+        actor,
+        mode: value.mode,
+        activity: value.activity,
+        location: location ?? void 0
+    });
+}
+function normalizedLocalLocation(value, kind) {
+    const location = validatedLocation(value, kind);
+    if (!location) throw invalidPresence(`The Office collaboration presence location is invalid for '${kind}'.`);
+    return location;
+}
+function validatedLocation(value, kind) {
+    if (!isRecord(value) || value.kind !== kind) return null;
+    if ('document' === kind || 'markdown' === kind) {
+        if (!isPosition(value.anchor) || !isPosition(value.head)) return null;
+        if ('document' === kind) return Object.freeze({
+            kind,
+            anchor: value.anchor,
+            head: value.head
+        });
+        if (void 0 !== value.surface && 'source' !== value.surface && 'visual' !== value.surface) return null;
+        return Object.freeze({
+            kind,
+            anchor: value.anchor,
+            head: value.head,
+            ...void 0 === value.surface ? {} : {
+                surface: value.surface
+            }
+        });
+    }
+    if ('spreadsheet' === kind) {
+        if (!isIdentifier(value.sheetId) || !Array.isArray(value.ranges) || value.ranges.length < 1 || value.ranges.length > MAX_PRESENCE_RANGES) return null;
+        const ranges = [];
+        for (const candidate of value.ranges){
+            const range = validatedSpreadsheetRange(candidate);
+            if (!range) return null;
+            ranges.push(range);
+        }
+        const activeCell = void 0 === value.activeCell ? void 0 : validatedSpreadsheetCell(value.activeCell);
+        if (void 0 !== value.activeCell && !activeCell) return null;
+        return Object.freeze({
+            kind,
+            sheetId: value.sheetId,
+            ranges: Object.freeze(ranges),
+            activeCell: activeCell ?? void 0
+        });
+    }
+    if ('presentation' === kind) {
+        if (!isIdentifier(value.slideId) || !Array.isArray(value.elementIds) || value.elementIds.length > MAX_PRESENCE_ELEMENT_IDS) return null;
+        const elementIds = [];
+        const seen = new Set();
+        for (const candidate of value.elementIds){
+            if (!isIdentifier(candidate) || seen.has(candidate)) return null;
+            seen.add(candidate);
+            elementIds.push(candidate);
+        }
+        return Object.freeze({
+            kind,
+            slideId: value.slideId,
+            elementIds: Object.freeze(elementIds)
+        });
+    }
+    if (!isPosition(value.pageIndex)) return null;
+    if (void 0 !== value.annotationId && !isIdentifier(value.annotationId)) return null;
+    return Object.freeze({
+        kind: 'pdf',
+        pageIndex: value.pageIndex,
+        annotationId: value.annotationId
+    });
+}
+function validatedSpreadsheetRange(value) {
+    if (!isRecord(value) || !isPosition(value.startRow) || !isPosition(value.startColumn) || !isPosition(value.endRow) || !isPosition(value.endColumn) || value.startRow > value.endRow || value.startColumn > value.endColumn) return null;
+    return Object.freeze({
+        startRow: value.startRow,
+        startColumn: value.startColumn,
+        endRow: value.endRow,
+        endColumn: value.endColumn
+    });
+}
+function validatedSpreadsheetCell(value) {
+    if (!isRecord(value) || !isPosition(value.row) || !isPosition(value.column)) return null;
+    return Object.freeze({
+        row: value.row,
+        column: value.column
+    });
+}
+function validatedActor(value) {
+    if (!isRecord(value) || !isIdentifier(value.id) || !isIdentifier(value.name) || !isActorKind(value.kind) || !isOptionalBoundedString(value.color, 64) || !isOptionalBoundedString(value.avatarUrl, 2048)) return null;
+    return Object.freeze({
+        id: value.id,
+        name: value.name,
+        kind: value.kind,
+        color: value.color,
+        avatarUrl: value.avatarUrl
+    });
+}
+function copiedActor(actor) {
+    return Object.freeze({
+        id: actor.id,
+        name: actor.name,
+        kind: actor.kind ?? 'human',
+        color: actor.color,
+        avatarUrl: actor.avatarUrl
+    });
+}
+function normalizedActivity(value) {
+    if (isActivity(value)) return value;
+    throw invalidPresence(`The Office collaboration presence activity '${String(value)}' is invalid.`);
+}
+function createPresenceId(clientId) {
+    nextPresenceSequence = nextPresenceSequence >= Number.MAX_SAFE_INTEGER ? 1 : nextPresenceSequence + 1;
+    return `${clientId}:${nextPresenceSequence.toString(36)}`;
+}
+function invalidPresence(message) {
+    return new WorkOfficeCollaborationError('office.collaboration.presence_invalid', message);
+}
+function isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function isIdentifier(value) {
+    return 'string' == typeof value && value.length >= 1 && value.length <= 256 && value.trim() === value;
+}
+function isOptionalBoundedString(value, maximumLength) {
+    return void 0 === value || 'string' == typeof value && value.length >= 1 && value.length <= maximumLength && value.trim() === value;
+}
+function isPosition(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+function isClientId(value) {
+    return isPosition(value);
+}
+function isActivity(value) {
+    return 'active' === value || 'idle' === value || 'away' === value;
+}
+function isMode(value) {
+    return 'view' === value || 'comment' === value || 'suggest' === value || 'edit' === value;
+}
+function isActorKind(value) {
+    return 'human' === value || 'agent' === value || 'system' === value;
+}
+const WORK_OFFICE_COLLABORATION_DEFAULT_MAX_TRANSPORT_PAYLOAD_BYTES = 67108864;
+const WORK_OFFICE_COLLABORATION_MAX_TRANSPORT_PAYLOAD_BYTES = 268435456;
+function createWorkOfficeCollaborationTransportBinding(session, transport, options = {}) {
+    return new WorkOfficeCollaborationTransportBindingImpl(session, transport, options);
+}
+class WorkOfficeCollaborationTransportBindingImpl {
+    #session;
+    #transport;
+    #maxPayloadBytes;
+    #remoteOrigins = new WeakSet();
+    #unsubscribe;
+    #destroyed = false;
+    constructor(session, transport, options){
+        session.metadata();
+        assertTransport(transport);
+        this.#session = session;
+        this.#transport = transport;
+        this.#maxPayloadBytes = normalizedMaximumPayloadBytes(options.maxPayloadBytes ?? WORK_OFFICE_COLLABORATION_DEFAULT_MAX_TRANSPORT_PAYLOAD_BYTES);
+        session.document.on('update', this.#onDocumentUpdate);
+        try {
+            const unsubscribe = transport.subscribe(this.#onTransportMessage);
+            if ('function' != typeof unsubscribe) throw new WorkOfficeCollaborationError('office.collaboration.transport_invalid', 'The Office collaboration transport subscribe function must return an unsubscribe function.');
+            this.#unsubscribe = unsubscribe;
+            if (false !== options.autoSynchronize) this.synchronize();
+        } catch (error) {
+            session.document.off('update', this.#onDocumentUpdate);
+            this.#unsubscribe?.();
+            this.#unsubscribe = void 0;
+            this.#destroyed = true;
+            throw error;
+        }
+    }
+    synchronize() {
+        this.ensureActive();
+        this.publish('sync-step-1', __rspack_external_yjs.encodeStateVector(this.#session.document));
+    }
+    destroy() {
+        if (this.#destroyed) return;
+        this.#destroyed = true;
+        this.#session.document.off('update', this.#onDocumentUpdate);
+        const unsubscribe = this.#unsubscribe;
+        this.#unsubscribe = void 0;
+        unsubscribe?.();
+    }
+    #onDocumentUpdate = (update, origin)=>{
+        if (this.#destroyed || isRemoteOrigin(this.#remoteOrigins, origin)) return;
+        this.publish('update', update, copiedLocalOrigin(origin));
+    };
+    #onTransportMessage = (value)=>{
+        if (this.#destroyed) return;
+        const message = validatedTransportMessage(value, this.#session, this.#maxPayloadBytes);
+        if (message.senderClientId === this.#session.document.clientID) return;
+        try {
+            if ('sync-step-1' === message.type) return void this.publish('sync-step-2', __rspack_external_yjs.encodeStateAsUpdate(this.#session.document, message.payload));
+            const remoteOrigin = message.origin ?? remoteSystemOrigin();
+            this.#remoteOrigins.add(remoteOrigin);
+            __rspack_external_yjs.applyUpdate(this.#session.document, message.payload, remoteOrigin);
+            this.#session.metadata();
+        } catch (error) {
+            if (error instanceof WorkOfficeCollaborationError) throw error;
+            throw invalidTransportMessage(`The '${message.type}' payload is not a valid Yjs v1 message: ${errorMessage(error)}`);
+        }
+    };
+    publish(type, payload, origin) {
+        assertPayloadSize(payload, this.#maxPayloadBytes);
+        const message = Object.freeze({
+            protocol: WORK_OFFICE_COLLABORATION_PROTOCOL,
+            version: 1,
+            artifactId: this.#session.artifactId,
+            artifactKind: this.#session.kind,
+            namespace: this.#session.namespace,
+            senderClientId: this.#session.document.clientID,
+            type,
+            payload: payload.slice(),
+            origin
+        });
+        this.#transport.publish(message);
+    }
+    ensureActive() {
+        if (!this.#destroyed) return;
+        throw new WorkOfficeCollaborationError('office.collaboration.binding_destroyed', 'The Office collaboration transport binding has been destroyed.');
+    }
+}
+function validatedTransportMessage(value, session, maximumPayloadBytes) {
+    if (!office_collaboration_transport_isRecord(value)) throw invalidTransportMessage('Office collaboration transport messages must be plain objects.');
+    if (value.protocol !== WORK_OFFICE_COLLABORATION_PROTOCOL || 1 !== value.version) throw invalidTransportMessage('The Office collaboration transport protocol or version is unsupported.');
+    if (value.artifactId !== session.artifactId || value.artifactKind !== session.kind || value.namespace !== session.namespace) throw new WorkOfficeCollaborationError('office.collaboration.transport_identity_mismatch', 'The Office collaboration transport message belongs to another artifact, kind, or namespace.');
+    if (!office_collaboration_transport_isClientId(value.senderClientId)) throw invalidTransportMessage('The Office collaboration transport sender client ID is invalid.');
+    if (!isTransportMessageType(value.type)) throw invalidTransportMessage(`The Office collaboration transport message type '${String(value.type)}' is invalid.`);
+    if (!(value.payload instanceof Uint8Array)) throw invalidTransportMessage('The Office collaboration transport payload must be a Uint8Array.');
+    assertPayloadSize(value.payload, maximumPayloadBytes);
+    const origin = copiedTransportOrigin(value.origin);
+    if ('update' !== value.type && void 0 !== origin) throw invalidTransportMessage('Only incremental Office collaboration update messages may carry a transaction origin.');
+    return Object.freeze({
+        protocol: WORK_OFFICE_COLLABORATION_PROTOCOL,
+        version: 1,
+        artifactId: session.artifactId,
+        artifactKind: session.kind,
+        namespace: session.namespace,
+        senderClientId: value.senderClientId,
+        type: value.type,
+        payload: value.payload.slice(),
+        origin
+    });
+}
+function copiedLocalOrigin(value) {
+    try {
+        return copiedTransportOrigin(value);
+    } catch  {
+        return;
+    }
+}
+function copiedTransportOrigin(value) {
+    if (void 0 === value) return;
+    if (!office_collaboration_transport_isRecord(value)) throw invalidTransportMessage('The Office collaboration transport origin must be a typed origin object.');
+    try {
+        assertWorkOfficeCollaborationOrigin(value);
+    } catch  {
+        throw invalidTransportMessage('The Office collaboration transport origin is invalid.');
+    }
+    return Object.freeze({
+        protocol: WORK_OFFICE_COLLABORATION_PROTOCOL,
+        kind: value.kind,
+        actorId: value.actorId,
+        operationId: value.operationId
+    });
+}
+function remoteSystemOrigin() {
+    return Object.freeze({
+        protocol: WORK_OFFICE_COLLABORATION_PROTOCOL,
+        kind: 'system'
+    });
+}
+function isRemoteOrigin(origins, value) {
+    return 'object' == typeof value && null !== value && origins.has(value);
+}
+function assertTransport(value) {
+    if (!value || 'function' != typeof value.publish || 'function' != typeof value.subscribe) throw new WorkOfficeCollaborationError('office.collaboration.transport_invalid', 'An Office collaboration transport must provide publish and subscribe functions.');
+}
+function normalizedMaximumPayloadBytes(value) {
+    if (!Number.isSafeInteger(value) || value < 1 || value > WORK_OFFICE_COLLABORATION_MAX_TRANSPORT_PAYLOAD_BYTES) throw new WorkOfficeCollaborationError('office.collaboration.transport_invalid', `The Office collaboration transport payload limit must be an integer between 1 and ${WORK_OFFICE_COLLABORATION_MAX_TRANSPORT_PAYLOAD_BYTES} bytes.`);
+    return value;
+}
+function assertPayloadSize(payload, maximumPayloadBytes) {
+    if (payload.byteLength <= maximumPayloadBytes) return;
+    throw new WorkOfficeCollaborationError('office.collaboration.transport_message_too_large', `The Office collaboration transport payload is ${payload.byteLength} bytes; the configured limit is ${maximumPayloadBytes} bytes.`);
+}
+function invalidTransportMessage(message) {
+    return new WorkOfficeCollaborationError('office.collaboration.transport_message_invalid', message);
+}
+function office_collaboration_transport_isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function office_collaboration_transport_isClientId(value) {
+    return Number.isSafeInteger(value) && value >= 0;
+}
+function isTransportMessageType(value) {
+    return 'sync-step-1' === value || 'sync-step-2' === value || 'update' === value;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function createWorkPdfCollaborationContent(source) {
+    return {
+        type: 'pdf',
+        source,
+        annotations: [],
+        formValues: [],
+        signaturePlacements: [],
+        redactionProposals: [],
+        pageOperations: [],
+        reviewDecisions: []
+    };
+}
 function fileNameWithoutExtension(value) {
     return value.replace(/\.[^.]+$/, '').trim() || '导入的文件';
 }
@@ -19,6 +469,32 @@ function work_file_download_downloadBlob(blob, name) {
     anchor.click();
     window.setTimeout(()=>URL.revokeObjectURL(url), 0);
 }
+const sourceBlobs = new Map();
+function rememberWorkSourceBlob(artifactId, source) {
+    sourceBlobs.set(artifactId, source);
+}
+function forgetWorkSourceBlob(artifactId) {
+    sourceBlobs.delete(artifactId);
+}
+async function readWorkSourceBlob(artifact) {
+    const source = sourceBlobs.get(artifact.id);
+    if (source) return source;
+    throw new Error(artifact.source ? 'The original file is not available in this browser session. Register it again before opening or exporting this source-backed artifact.' : 'This document has no original source file.');
+}
+async function readVerifiedWorkSourceBytes(artifact) {
+    const source = await readWorkSourceBlob(artifact);
+    const bytes = await source.arrayBuffer();
+    const expected = artifact.source?.fingerprint;
+    if (expected && await workSourceFingerprint(bytes) !== expected) throw new Error('The registered source file does not match the imported source fingerprint.');
+    return bytes;
+}
+async function workSourceFingerprint(bytes) {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) throw new Error('SHA-256 source fingerprinting is unavailable.');
+    const digest = new Uint8Array(await subtle.digest('SHA-256', bytes));
+    return `sha256:${Array.from(digest, (value)=>value.toString(16).padStart(2, '0')).join('')}`;
+}
+const DOCX_CONTENT_TYPE = 'application/vnd.openxmlformats-officedocument.wordprocessingml.document';
 async function importWorkDocumentFile(file, extension) {
     let html;
     if ('docx' === extension) {
@@ -36,7 +512,7 @@ async function importWorkDocumentFile(file, extension) {
                 "br[type='page'] => hr.work-page-break[data-page-break='true']:fresh"
             ]
         });
-        html = prepared ? applyDocxSectionsToHtml(result.value, prepared.sections, prepared.captionMarkers, prepared.changeMarkers, prepared.commentMarkers, prepared.fieldMarkers, prepared.citationMarkers, prepared.listMarkers, prepared.imageLayoutMarkers, prepared.paragraphAlignmentMarkers, prepared.runFormattingMarkers, prepared.paragraphDirectionMarkers, prepared.paragraphIndentMarkers, prepared.paragraphSpacingMarkers, prepared.paragraphPaginationMarkers, prepared.bibliography, prepared.tabStopMarkers, prepared.tableCellMarkers, prepared.tableRowMarkers, prepared.tableSizingMarkers) : result.value;
+        html = prepared ? applyDocxSectionsToHtml(result.value, prepared.sections, prepared.captionMarkers, prepared.bookmarkMarkers, prepared.changeMarkers, prepared.commentMarkers, prepared.fieldMarkers, prepared.equationMarkers, prepared.citationMarkers, prepared.listMarkers, prepared.imageLayoutMarkers, prepared.paragraphIdentityMarkers, prepared.paragraphAlignmentMarkers, prepared.runFormattingMarkers, prepared.paragraphDirectionMarkers, prepared.paragraphIndentMarkers, prepared.paragraphSpacingMarkers, prepared.paragraphBorderMarkers, prepared.paragraphShadingMarkers, prepared.paragraphPaginationMarkers, prepared.bibliography, prepared.tabStopMarkers, prepared.tableCellMarkers, prepared.tableRowMarkers, prepared.tableSizingMarkers) : result.value;
         const layout = prepared ? {
             ...documentContentLayoutProperties(prepared.sections[0].layout),
             ...prepared.pageColor ? {
@@ -63,6 +539,14 @@ async function importWorkDocumentFile(file, extension) {
             } : {}
         });
         artifact.compatibility = await analyzeDocxCompatibility(file, result.messages);
+        artifact.source = {
+            name: file.name,
+            contentType: file.type || DOCX_CONTENT_TYPE,
+            size: file.size,
+            updatedAt: file.lastModified || Date.now(),
+            fingerprint: await workSourceFingerprint(arrayBuffer)
+        };
+        rememberWorkSourceBlob(artifact.id, file);
         return artifact;
     }
     const source = await file.text();
@@ -78,9 +562,10 @@ async function importWorkDocumentFile(file, extension) {
 }
 async function createWorkDocumentBlob(artifact) {
     if ('document' !== artifact.content.type) throw new Error('当前文件不是文档。');
-    const { materializeWorkDocumentContent } = await import("./0~work-document-model-codec.js");
+    const { materializeWorkDocumentContent } = await import("./8928.js");
     const { createDocxBlob } = await import("./0~work-docx-export.js");
-    return createDocxBlob(materializeWorkDocumentContent(artifact.content));
+    const sourcePackage = artifact.source ? await readVerifiedWorkSourceBytes(artifact) : void 0;
+    return createDocxBlob(materializeWorkDocumentContent(artifact.content), sourcePackage);
 }
 function textToHtml(source) {
     const blocks = source.replace(/\r\n?/g, '\n').split(/\n{2,}/).map((block)=>block.trim()).filter(Boolean);
@@ -91,7 +576,7 @@ function textToHtml(source) {
     }).join('');
 }
 async function withStructuredDocumentModel(content) {
-    const { createWorkDocumentModelFromContent } = await import("./0~work-document-model-codec.js");
+    const { createWorkDocumentModelFromContent } = await import("./8928.js");
     return createWorkDocumentModelFromContent(content);
 }
 function escapeHtml(value) {
@@ -163,18 +648,6 @@ function loadPresentationRuntime(runtimeUrl) {
     presentationRuntimePromises.set(resolvedUrl, runtime);
     return runtime;
 }
-const sourceBlobs = new Map();
-function rememberWorkSourceBlob(artifactId, source) {
-    sourceBlobs.set(artifactId, source);
-}
-function forgetWorkSourceBlob(artifactId) {
-    sourceBlobs.delete(artifactId);
-}
-async function readWorkSourceBlob(artifact) {
-    const source = sourceBlobs.get(artifact.id);
-    if (source) return source;
-    throw new Error(artifact.source ? 'The original file is not available in this browser session. Register it again before opening the PDF.' : 'This document has no original source file.');
-}
 function workArtifactExtension(kind) {
     if ('document' === kind) return 'docx';
     if ('markdown' === kind) return 'md';
@@ -5060,7 +5533,6 @@ const PRESENTATION_EXTENSIONS = new Set([
 const PDF_EXTENSIONS = new Set([
     'pdf'
 ]);
-const WORK_IMPORT_ACCEPT = ".docx,.xlsx,.xls,.csv,.ods,.pptx,.pdf,.html,.htm,.txt,.md,.markdown";
 async function importWorkFile(file) {
     const extension = file.name.split('.').pop()?.toLowerCase() ?? '';
     if (!MARKDOWN_EXTENSIONS.has(extension) && !DOCUMENT_EXTENSIONS.has(extension) && !SPREADSHEET_EXTENSIONS.has(extension) && !PRESENTATION_EXTENSIONS.has(extension) && !PDF_EXTENSIONS.has(extension)) throw new Error('目前可导入 DOCX、XLSX、XLS、ODS、CSV、PPTX、PDF、HTML、Markdown 和文本文件。');
@@ -5495,6 +5967,343 @@ function workKindForFile(file) {
     if (PDF_EXTENSIONS.has(extension)) return 'pdf';
     return null;
 }
+const WORK_IMPORT_ACCEPT = ".docx,.xlsx,.xls,.csv,.ods,.pptx,.pdf,.html,.htm,.txt,.md,.markdown";
+const WORK_DOCUMENT_SNAPSHOT_SCHEMA = 'a3s.office.document.snapshot';
+const WORK_DOCUMENT_SNAPSHOT_VERSION = 1;
+const WORK_DOCUMENT_SNAPSHOT_MEDIA_TYPE = 'application/vnd.a3s.office.document-snapshot+json;version=1';
+const MAX_DOCUMENT_SNAPSHOT_BYTES = 16777216;
+const MAX_DOCUMENT_SNAPSHOT_DEPTH = 512;
+const MAX_DOCUMENT_SNAPSHOT_VALUES = 2000000;
+function encodeWorkDocumentSnapshot(content) {
+    assertStructuredDocumentContent(content);
+    let encoded;
+    try {
+        encoded = canonicalJson({
+            schema: WORK_DOCUMENT_SNAPSHOT_SCHEMA,
+            version: WORK_DOCUMENT_SNAPSHOT_VERSION,
+            content
+        });
+    } catch (error) {
+        throw new Error('A3S Office document snapshots must contain only JSON-compatible values.', {
+            cause: error
+        });
+    }
+    assertSnapshotSize(encoded);
+    return encoded;
+}
+function decodeWorkDocumentSnapshot(encoded) {
+    if ('string' != typeof encoded) throw new TypeError('An A3S Office document snapshot must be a string.');
+    assertSnapshotSize(encoded);
+    let candidate;
+    try {
+        candidate = JSON.parse(encoded);
+    } catch (error) {
+        throw new Error('The A3S Office document snapshot is not valid JSON.', {
+            cause: error
+        });
+    }
+    if (!work_document_snapshot_isRecord(candidate)) throw new Error('The A3S Office document snapshot envelope is invalid.');
+    if (candidate.schema !== WORK_DOCUMENT_SNAPSHOT_SCHEMA) throw new Error('The A3S Office document snapshot schema is unsupported.');
+    if (candidate.version !== WORK_DOCUMENT_SNAPSHOT_VERSION) throw new Error(`A3S Office document snapshot version ${String(candidate.version)} is unsupported.`);
+    const envelopeKeys = Object.keys(candidate);
+    if (3 !== envelopeKeys.length || !envelopeKeys.includes('schema') || !envelopeKeys.includes('version') || !envelopeKeys.includes('content')) throw new Error('The A3S Office document snapshot envelope is invalid.');
+    assertStructuredDocumentContent(candidate.content);
+    return candidate.content;
+}
+function assertStructuredDocumentContent(candidate) {
+    if (!work_document_snapshot_isRecord(candidate) || 'document' !== candidate.type || 'string' != typeof candidate.html || 'a4' !== candidate.pageSize && 'letter' !== candidate.pageSize) throw new Error('An A3S Office document snapshot must contain a valid document value.');
+    if (!candidate.model || !documentModelForContent(candidate)) throw new Error('An A3S Office document snapshot requires a synchronized structured model.');
+}
+function assertSnapshotSize(encoded) {
+    if (new TextEncoder().encode(encoded).byteLength > MAX_DOCUMENT_SNAPSHOT_BYTES) throw new Error(`The A3S Office document snapshot exceeds ${MAX_DOCUMENT_SNAPSHOT_BYTES} bytes.`);
+}
+function canonicalJson(value) {
+    const ancestors = new Set();
+    const budget = {
+        values: 0
+    };
+    return encodeCanonicalValue(value, ancestors, budget, 0);
+}
+function encodeCanonicalValue(value, ancestors, budget, depth) {
+    budget.values += 1;
+    if (budget.values > MAX_DOCUMENT_SNAPSHOT_VALUES || depth > MAX_DOCUMENT_SNAPSHOT_DEPTH) throw new TypeError('The JSON value graph exceeds the snapshot limits.');
+    if (null === value || 'string' == typeof value || 'boolean' == typeof value) return JSON.stringify(value);
+    if ('number' == typeof value) {
+        if (!Number.isFinite(value)) throw new TypeError('Non-finite numbers are not JSON-compatible.');
+        return JSON.stringify(value);
+    }
+    if ('object' != typeof value || ancestors.has(value)) throw new TypeError('The value is not an acyclic JSON value.');
+    ancestors.add(value);
+    try {
+        if (Array.isArray(value)) return `[${value.map((item)=>{
+            if (void 0 === item) throw new TypeError('Undefined array entries are not supported.');
+            return encodeCanonicalValue(item, ancestors, budget, depth + 1);
+        }).join(',')}]`;
+        const prototype = Object.getPrototypeOf(value);
+        if (prototype !== Object.prototype && null !== prototype) throw new TypeError('Only plain JSON objects are supported.');
+        const symbols = Object.getOwnPropertySymbols(value);
+        if (symbols.length) throw new TypeError('Symbol properties are not JSON-compatible.');
+        const entries = [];
+        for (const key of Object.keys(value).sort()){
+            const descriptor = Object.getOwnPropertyDescriptor(value, key);
+            if (!descriptor || descriptor.get || descriptor.set) throw new TypeError('Accessor properties are not JSON-compatible.');
+            if (void 0 !== descriptor.value) entries.push(`${JSON.stringify(key)}:${encodeCanonicalValue(descriptor.value, ancestors, budget, depth + 1)}`);
+        }
+        return `{${entries.join(',')}}`;
+    } finally{
+        ancestors.delete(value);
+    }
+}
+function work_document_snapshot_isRecord(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+const WORK_DOCUMENT_SOURCE_SCHEMA = 'a3s.office.document.source';
+const WORK_DOCUMENT_SOURCE_VERSION = 1;
+const WORK_DOCUMENT_SOURCE_MEDIA_TYPE = 'text/markdown; charset=utf-8';
+let markdownManager = null;
+let documentSchema = null;
+function projectWorkDocumentSource(content) {
+    const section = singleDocumentSection(content);
+    let source;
+    try {
+        source = documentMarkdownManager().serialize({
+            type: 'doc',
+            content: section.content ?? []
+        });
+    } catch (error) {
+        throw new Error('The structured document cannot be projected into the version 1 Markdown source contract.', {
+            cause: error
+        });
+    }
+    return {
+        schema: WORK_DOCUMENT_SOURCE_SCHEMA,
+        version: WORK_DOCUMENT_SOURCE_VERSION,
+        mediaType: WORK_DOCUMENT_SOURCE_MEDIA_TYPE,
+        content: source
+    };
+}
+function applyWorkDocumentSource(content, source) {
+    assertDocumentSource(source);
+    const model = documentModelForContent(content);
+    if (!model) throw new Error('Applying a document source requires a synchronized structured snapshot.');
+    const section = singleDocumentSection(content);
+    let parsed;
+    try {
+        parsed = documentMarkdownManager().parse(source.content);
+    } catch (error) {
+        throw new Error('The version 1 document source is not valid supported Markdown.', {
+            cause: error
+        });
+    }
+    const parsedBody = parsed.content?.length ? parsed.content : [
+        {
+            type: 'paragraph'
+        }
+    ];
+    const body = retainSurvivingDocumentCommentAnchors(section.content ?? [], parsedBody);
+    const root = normalizeDocumentRoot({
+        ...model.root,
+        content: [
+            {
+                ...section,
+                ...section.attrs ? {
+                    attrs: structuredClone(section.attrs)
+                } : {},
+                content: body
+            }
+        ]
+    });
+    const staged = {
+        ...content,
+        model: createWorkDocumentModel(content.html, root, model)
+    };
+    return work_document_model_codec_materializeWorkDocumentContent(staged);
+}
+function normalizeDocumentRoot(root) {
+    try {
+        documentSchema ??= getSchema(createWorkDocumentExtensions());
+        return documentSchema.nodeFromJSON(root).toJSON();
+    } catch (error) {
+        throw new Error('The version 1 document source cannot be represented by the Office document schema.', {
+            cause: error
+        });
+    }
+}
+function singleDocumentSection(content) {
+    const model = documentModelForContent(content);
+    if (!model) throw new Error('The document source contract requires a synchronized structured snapshot.');
+    const sections = (model.root.content ?? []).filter((node)=>'documentSection' === node.type);
+    if (1 !== sections.length || model.root.content?.length !== 1) throw new Error('The version 1 document source contract requires exactly one structured section.');
+    return sections[0];
+}
+function assertDocumentSource(source) {
+    if (!source || source.schema !== WORK_DOCUMENT_SOURCE_SCHEMA || source.version !== WORK_DOCUMENT_SOURCE_VERSION || source.mediaType !== WORK_DOCUMENT_SOURCE_MEDIA_TYPE || 'string' != typeof source.content) throw new Error('The A3S Office document source envelope is invalid.');
+}
+function documentMarkdownManager() {
+    markdownManager ??= new MarkdownManager({
+        extensions: createWorkDocumentExtensions(),
+        indentation: {
+            style: 'space',
+            size: 2
+        },
+        markedOptions: {
+            gfm: true,
+            breaks: false,
+            pedantic: false
+        }
+    });
+    return markdownManager;
+}
+const DOCUMENT_COMMENT_MARK = 'documentComment';
+const DOCUMENT_COMMENT_CONTEXT_LENGTH = 64;
+function retainSurvivingDocumentCommentAnchors(previousBody, nextBody) {
+    const previous = indexDocumentText(previousBody);
+    const next = indexDocumentText(nextBody);
+    const ranges = collectDocumentCommentAnchors(previous).flatMap((anchor)=>{
+        const anchorText = previous.content.slice(anchor.from, anchor.to);
+        if (!anchor.valid || !anchorText) return [];
+        const candidates = exactTextOccurrences(next.content, anchorText);
+        const destination = uniqueCommentDestination(next.content, anchor, candidates);
+        return null === destination ? [] : [
+            {
+                id: anchor.id,
+                from: destination,
+                to: destination + anchorText.length
+            }
+        ];
+    });
+    return applyDocumentCommentRanges(nextBody, ranges);
+}
+function indexDocumentText(nodes) {
+    const spans = [];
+    let content = '';
+    const visit = (node)=>{
+        if ('text' === node.type && 'string' == typeof node.text) {
+            const from = content.length;
+            content += node.text;
+            spans.push({
+                from,
+                to: content.length,
+                node
+            });
+        }
+        for (const child of node.content ?? [])visit(child);
+    };
+    for (const node of nodes)visit(node);
+    return {
+        content,
+        spans
+    };
+}
+function collectDocumentCommentAnchors(index) {
+    const anchors = new Map();
+    for (const span of index.spans)for (const mark of span.node.marks ?? []){
+        const id = documentCommentId(mark);
+        if (!id) continue;
+        const current = anchors.get(id);
+        if (current) {
+            current.valid = current.valid && current.to === span.from;
+            current.to = span.to;
+            continue;
+        }
+        anchors.set(id, {
+            id,
+            from: span.from,
+            to: span.to,
+            prefix: '',
+            suffix: '',
+            valid: true
+        });
+    }
+    for (const anchor of anchors.values()){
+        anchor.prefix = index.content.slice(Math.max(0, anchor.from - DOCUMENT_COMMENT_CONTEXT_LENGTH), anchor.from);
+        anchor.suffix = index.content.slice(anchor.to, anchor.to + DOCUMENT_COMMENT_CONTEXT_LENGTH);
+    }
+    return Array.from(anchors.values()).sort((left, right)=>left.from - right.from || left.id.localeCompare(right.id));
+}
+function documentCommentId(mark) {
+    if (mark.type !== DOCUMENT_COMMENT_MARK) return '';
+    const id = mark.attrs?.id;
+    return 'string' == typeof id ? id.trim() : '';
+}
+function exactTextOccurrences(content, value) {
+    const occurrences = [];
+    let cursor = 0;
+    while(cursor <= content.length - value.length){
+        const position = content.indexOf(value, cursor);
+        if (position < 0) break;
+        occurrences.push(position);
+        cursor = position + 1;
+    }
+    return occurrences;
+}
+function uniqueCommentDestination(content, anchor, candidates) {
+    if (1 === candidates.length) return candidates[0] ?? null;
+    const contextual = candidates.filter((candidate)=>{
+        const preceding = content.slice(Math.max(0, candidate - anchor.prefix.length), candidate);
+        const following = content.slice(candidate + (anchor.to - anchor.from), candidate + (anchor.to - anchor.from) + anchor.suffix.length);
+        return preceding === anchor.prefix && following === anchor.suffix;
+    });
+    return 1 === contextual.length ? contextual[0] ?? null : null;
+}
+function applyDocumentCommentRanges(nodes, ranges) {
+    let offset = 0;
+    const rewrite = (node)=>{
+        const marks = (node.marks ?? []).filter((mark)=>mark.type !== DOCUMENT_COMMENT_MARK);
+        const { content: _content, marks: _marks, ...properties } = node;
+        if ('text' === node.type && 'string' == typeof node.text) {
+            const from = offset;
+            const to = from + node.text.length;
+            offset = to;
+            const boundaries = new Set([
+                from,
+                to
+            ]);
+            for (const range of ranges){
+                if (range.from > from && range.from < to) boundaries.add(range.from);
+                if (range.to > from && range.to < to) boundaries.add(range.to);
+            }
+            const ordered = Array.from(boundaries).sort((left, right)=>left - right);
+            const rewritten = [];
+            for(let index = 0; index < ordered.length - 1; index += 1){
+                const chunkFrom = ordered[index];
+                const chunkTo = ordered[index + 1];
+                if (void 0 === chunkFrom || void 0 === chunkTo || chunkFrom === chunkTo) continue;
+                const commentMarks = ranges.filter((range)=>range.from <= chunkFrom && range.to >= chunkTo).map((range)=>({
+                        type: DOCUMENT_COMMENT_MARK,
+                        attrs: {
+                            id: range.id
+                        }
+                    }));
+                const nextMarks = [
+                    ...marks,
+                    ...commentMarks
+                ];
+                rewritten.push({
+                    ...properties,
+                    text: node.text.slice(chunkFrom - from, chunkTo - from),
+                    ...nextMarks.length ? {
+                        marks: nextMarks
+                    } : {}
+                });
+            }
+            return rewritten;
+        }
+        const content = (node.content ?? []).flatMap(rewrite);
+        return [
+            {
+                ...properties,
+                ...content.length ? {
+                    content
+                } : {},
+                ...marks.length ? {
+                    marks
+                } : {}
+            }
+        ];
+    };
+    return nodes.flatMap(rewrite);
+}
 const PDF_PAGE_DIMENSIONS = {
     a3: {
         width: 841.89,
@@ -5537,31 +6346,51 @@ async function exportWorkArtifactPdf(artifact, options = {}) {
     ]);
     let pdf = null;
     if (liveDocument) {
-        const capture = mountWorkLiveDocumentCapture(liveDocument);
+        const firstSelectedPage = livePageIndexes[0] ?? 0;
+        const capture = mountWorkLiveDocumentCapture(liveDocument, firstSelectedPage);
         try {
-            const batches = workLiveDocumentPdfCaptureBatches(livePageIndexes, liveDocument);
-            for (const batch of batches){
-                capture.snapshot.style.top = `-${batch.firstPageIndex * (liveDocument.pageHeight + liveDocument.pageGap)}px`;
-                capture.viewport.style.height = `${batch.captureHeight}px`;
+            if (uniformLiveDocumentPages(liveDocument.pages)) {
+                const batches = workLiveDocumentPdfCaptureBatches(livePageIndexes, liveDocument);
+                for (const batch of batches){
+                    const firstPage = positionWorkLiveDocumentCapture(capture, liveDocument, batch.firstPageIndex, batch.captureHeight);
+                    await nextPaint();
+                    const batchCanvas = await html2canvas(capture.viewport, {
+                        backgroundColor: capture.backgroundColor,
+                        height: batch.captureHeight,
+                        logging: false,
+                        scale: 2,
+                        useCORS: true,
+                        width: firstPage.width,
+                        windowHeight: Math.ceil(batch.captureHeight),
+                        windowWidth: Math.ceil(firstPage.width)
+                    });
+                    const scaleY = batchCanvas.height / batch.captureHeight;
+                    for (const pageIndex of batch.pageIndexes){
+                        const page = liveDocument.pages[pageIndex];
+                        if (!page) continue;
+                        const pageOffset = page.top - firstPage.top;
+                        const sourceTop = Math.round(pageOffset * scaleY);
+                        const sourceBottom = Math.round((pageOffset + page.height) * scaleY);
+                        const pageCanvas = cropDocumentCanvas(batchCanvas, sourceTop, Math.max(1, sourceBottom - sourceTop), capture.backgroundColor);
+                        pdf = appendLiveDocumentCanvasPage(pdf, pageCanvas, page, jsPDF);
+                    }
+                }
+            } else for (const pageIndex of livePageIndexes){
+                const page = liveDocument.pages[pageIndex];
+                if (!page) continue;
+                positionWorkLiveDocumentCapture(capture, liveDocument, pageIndex);
                 await nextPaint();
-                const batchCanvas = await html2canvas(capture.viewport, {
+                const pageCanvas = await html2canvas(capture.viewport, {
                     backgroundColor: capture.backgroundColor,
-                    height: batch.captureHeight,
+                    height: page.height,
                     logging: false,
                     scale: 2,
                     useCORS: true,
-                    width: liveDocument.pageWidth,
-                    windowHeight: Math.ceil(batch.captureHeight),
-                    windowWidth: Math.ceil(liveDocument.pageWidth)
+                    width: page.width,
+                    windowHeight: Math.ceil(page.height),
+                    windowWidth: Math.ceil(page.width)
                 });
-                const scaleY = batchCanvas.height / batch.captureHeight;
-                for (const pageIndex of batch.pageIndexes){
-                    const pageOffset = (pageIndex - batch.firstPageIndex) * (liveDocument.pageHeight + liveDocument.pageGap);
-                    const sourceTop = Math.round(pageOffset * scaleY);
-                    const sourceBottom = Math.round((pageOffset + liveDocument.pageHeight) * scaleY);
-                    const pageCanvas = cropDocumentCanvas(batchCanvas, sourceTop, Math.max(1, sourceBottom - sourceTop), capture.backgroundColor);
-                    pdf = appendExactCanvasPage(pdf, pageCanvas, liveDocument.orientation, liveDocument.pageSize, jsPDF);
-                }
+                pdf = appendLiveDocumentCanvasPage(pdf, pageCanvas, page, jsPDF);
             }
         } finally{
             capture.host.remove();
@@ -5569,6 +6398,7 @@ async function exportWorkArtifactPdf(artifact, options = {}) {
     } else for (const page of pages){
         const orientation = 'portrait' === page.dataset.pdfOrientation ? 'portrait' : 'landscape';
         const pageSize = pdfPageSize(page.dataset.pdfPageSize);
+        const pageDefinition = pdfPageDefinition(pageSize, orientation, finiteDatasetNumber(page.dataset.pdfPageWidthPoints, 1), finiteDatasetNumber(page.dataset.pdfPageHeightPoints, 1));
         const backgroundColor = getComputedStyle(page).backgroundColor || '#ffffff';
         const canvas = await html2canvas(page, {
             backgroundColor,
@@ -5578,7 +6408,7 @@ async function exportWorkArtifactPdf(artifact, options = {}) {
             windowWidth: Math.max(page.scrollWidth, page.clientWidth),
             windowHeight: Math.max(page.scrollHeight, page.clientHeight)
         });
-        pdf = appendCanvas(pdf, canvas, orientation, pageSize, backgroundColor, jsPDF);
+        pdf = appendCanvas(pdf, canvas, orientation, pageDefinition, backgroundColor, jsPDF);
     }
     if (!pdf) throw new Error('PDF export did not produce any pages.');
     pdf.setProperties({
@@ -5597,15 +6427,61 @@ function workLiveDocumentPdfSurfaceForExport(artifactId) {
     const pageGap = finiteDatasetNumber(element.dataset.pdfPageGap, 0);
     const pageHeight = finiteDatasetNumber(element.dataset.pdfPageHeight, 1);
     const pageWidth = finiteDatasetNumber(element.dataset.pdfPageWidth, 1);
+    const fallback = pdfPageDefinition(pdfPageSize(element.dataset.pdfPageSize), 'landscape' === element.dataset.pdfOrientation ? 'landscape' : 'portrait');
+    const pageHeightPoints = finiteDatasetNumber(element.dataset.pdfPageHeightPoints, 1) ?? fallback.height;
+    const pageWidthPoints = finiteDatasetNumber(element.dataset.pdfPageWidthPoints, 1) ?? fallback.width;
     if (null === pageCount || null === pageGap || null === pageHeight || null === pageWidth || !Number.isSafeInteger(pageCount) || pageCount > 10000 || Number(editor.dataset.paginationPages) !== pageCount) return null;
+    const sheets = Array.from(element.querySelectorAll('.work-document-page-stack > [data-work-document-page-sheet]'));
+    if (sheets.length > 0 && sheets.length !== pageCount) return null;
+    const pages = sheets.length ? sheets.map((sheet, pageIndex)=>liveDocumentPdfPageFromSheet(sheet, pageIndex)) : Array.from({
+        length: pageCount
+    }, (_, pageIndex)=>({
+            height: pageHeight,
+            left: 0,
+            orientation: 'landscape' === element.dataset.pdfOrientation ? 'landscape' : 'portrait',
+            pageHeightPoints,
+            pageSize: pdfPageSize(element.dataset.pdfPageSize),
+            pageWidthPoints,
+            top: pageIndex * (pageHeight + pageGap),
+            width: pageWidth
+        }));
+    if (pages.some((page)=>null === page)) return null;
+    const resolvedPages = pages;
+    const firstPage = resolvedPages[0];
+    if (!firstPage) return null;
+    const resolvedPageGap = resolvedPages.length > 1 ? Math.max(0, resolvedPages[1].top - firstPage.top - firstPage.height) : pageGap;
+    const surfaceWidth = Math.max(1, ...resolvedPages.map((page)=>page.left + page.width));
     return {
         element,
-        orientation: 'landscape' === element.dataset.pdfOrientation ? 'landscape' : 'portrait',
+        orientation: firstPage.orientation,
         pageCount,
-        pageGap,
-        pageHeight,
-        pageSize: pdfPageSize(element.dataset.pdfPageSize),
-        pageWidth
+        pageGap: resolvedPageGap,
+        pageHeight: firstPage.height,
+        pageHeightPoints: firstPage.pageHeightPoints,
+        pageSize: firstPage.pageSize,
+        pageWidth: surfaceWidth,
+        pageWidthPoints: firstPage.pageWidthPoints,
+        pages: resolvedPages
+    };
+}
+function liveDocumentPdfPageFromSheet(sheet, pageIndex) {
+    if (Number(sheet.dataset.pageIndex) !== pageIndex + 1) return null;
+    const height = finiteDatasetNumber(sheet.dataset.pageHeight, 1);
+    const left = finiteDatasetNumber(sheet.dataset.pageLeft, 0);
+    const pageHeightPoints = finiteDatasetNumber(sheet.dataset.pdfPageHeightPoints, 1);
+    const pageWidthPoints = finiteDatasetNumber(sheet.dataset.pdfPageWidthPoints, 1);
+    const top = finiteDatasetNumber(sheet.dataset.pageTop, 0);
+    const width = finiteDatasetNumber(sheet.dataset.pageWidth, 1);
+    if (null === height || null === left || null === pageHeightPoints || null === pageWidthPoints || null === top || null === width) return null;
+    return {
+        height,
+        left,
+        orientation: 'landscape' === sheet.dataset.pdfOrientation ? 'landscape' : 'portrait',
+        pageHeightPoints,
+        pageSize: pdfPageSize(sheet.dataset.pdfPageSize),
+        pageWidthPoints,
+        top,
+        width
     };
 }
 function workPdfPagesForExport(artifactId, options = {}) {
@@ -5647,6 +6523,17 @@ function workLiveDocumentPdfCaptureBatches(pageIndexes, page) {
     }
     return batches;
 }
+function uniformLiveDocumentPages(pages) {
+    const first = pages[0];
+    if (!first) return false;
+    const firstGap = pages[1] ? pages[1].top - first.top - first.height : 0;
+    return pages.every((page, pageIndex)=>{
+        if (page.width !== first.width || page.height !== first.height || page.left !== first.left) return false;
+        if (0 === pageIndex) return true;
+        const previous = pages[pageIndex - 1];
+        return Boolean(previous && page.top - previous.top - previous.height === firstGap);
+    });
+}
 function finiteDatasetNumber(value, minimum) {
     if (void 0 === value || '' === value.trim()) return null;
     const parsed = Number(value);
@@ -5656,20 +6543,20 @@ function finiteDatasetNumber(value, minimum) {
 function pdfSurfaceForArtifact(mode, artifactId) {
     return Array.from(document.querySelectorAll(`[data-work-pdf-surface="${mode}"][data-work-pdf-artifact]`)).find((surface)=>surface.dataset.workPdfArtifact === artifactId);
 }
-function appendCanvas(pdf, source, orientation, pageSize, backgroundColor, Pdf) {
+function appendCanvas(pdf, source, orientation, page, backgroundColor, Pdf) {
     let document1 = pdf;
+    const pageOrientation = Array.isArray(page.format) ? page.width > page.height ? 'landscape' : 'portrait' : orientation;
     const ensurePage = ()=>{
-        if (document1) document1.addPage(pageSize, orientation);
+        if (document1) document1.addPage(page.format, pageOrientation);
         else document1 = new Pdf({
-            orientation,
+            orientation: pageOrientation,
             unit: 'pt',
-            format: pageSize,
+            format: page.format,
             compress: true
         });
     };
-    const dimensions = PDF_PAGE_DIMENSIONS[pageSize];
-    const standardWidth = 'portrait' === orientation ? dimensions.width : dimensions.height;
-    const standardHeight = 'portrait' === orientation ? dimensions.height : dimensions.width;
+    const standardWidth = page.width;
+    const standardHeight = page.height;
     const sliceHeight = Math.max(1, Math.floor(source.width * standardHeight / standardWidth));
     for(let offset = 0; offset < source.height; offset += sliceHeight){
         ensurePage();
@@ -5685,23 +6572,46 @@ function appendCanvas(pdf, source, orientation, pageSize, backgroundColor, Pdf)
     }
     return document1;
 }
-function appendExactCanvasPage(pdf, source, orientation, pageSize, Pdf) {
+function appendExactCanvasPage(pdf, source, orientation, page, Pdf) {
+    const pageOrientation = Array.isArray(page.format) ? page.width > page.height ? 'landscape' : 'portrait' : orientation;
     const document1 = pdf ?? new Pdf({
-        orientation,
+        orientation: pageOrientation,
         unit: 'pt',
-        format: pageSize,
+        format: page.format,
         compress: true
     });
-    if (pdf) document1.addPage(pageSize, orientation);
-    const dimensions = PDF_PAGE_DIMENSIONS[pageSize];
-    const width = 'portrait' === orientation ? dimensions.width : dimensions.height;
-    const height = 'portrait' === orientation ? dimensions.height : dimensions.width;
+    if (pdf) document1.addPage(page.format, pageOrientation);
+    const width = page.width;
+    const height = page.height;
     document1.addImage(source.toDataURL('image/jpeg', 0.92), 'JPEG', 0, 0, width, height, void 0, 'FAST');
     return document1;
 }
+function appendLiveDocumentCanvasPage(pdf, source, page, Pdf) {
+    return appendExactCanvasPage(pdf, source, page.orientation, pdfPageDefinition(page.pageSize, page.orientation, page.pageWidthPoints, page.pageHeightPoints), Pdf);
+}
 function pdfPageSize(value) {
     return value && Object.hasOwn(PDF_PAGE_DIMENSIONS, value) ? value : 'a4';
 }
+function pdfPageDefinition(pageSize, orientation, exactWidth, exactHeight) {
+    if (null != exactWidth && null != exactHeight) return {
+        format: [
+            exactWidth,
+            exactHeight
+        ],
+        width: exactWidth,
+        height: exactHeight
+    };
+    const dimensions = PDF_PAGE_DIMENSIONS[pageSize];
+    return 'portrait' === orientation ? {
+        format: pageSize,
+        width: dimensions.width,
+        height: dimensions.height
+    } : {
+        format: pageSize,
+        width: dimensions.height,
+        height: dimensions.width
+    };
+}
 function documentCanvas(width, height) {
     const canvas = document.createElement('canvas');
     canvas.width = width;
@@ -5723,4 +6633,4 @@ function nextPaint() {
 function work_pdf_export_safeFileName(value) {
     return value.replace(/[<>:"/\\|?*\u0000-\u001f]/g, '_').trim() || 'A3S Work file';
 }
-export { MAX_XLSX_WORKSHEET_IMAGE_BYTES, WORK_IMPORT_ACCEPT as OFFICE_FILE_ACCEPT, createWorkArtifactBlob as createArtifactBlob, defaultPptxRuntimeUrl, diagnoseXlsxProtection, exportWorkArtifact as downloadArtifact, exportWorkArtifactPdf as downloadArtifactPdf, forgetWorkSourceBlob as forgetSourceBlob, importWorkFile as importOfficeFile, inspectXlsxHeaderFooterText, inspectXlsxPivotTables, isEditableXlsxPaperSizeCode, isSupportedXlsxChartLegend, isSupportedXlsxChartPlotLayout, isSupportedXlsxChartSeriesFormatting, isSupportedXlsxCombinationChartNodes, isSupportedXlsxWorksheetImageContentType, parseXlsxChartAxes, parseXlsxChartLegend, parseXlsxChartPlotLayout, parseXlsxChartSeriesStyle, parseXlsxErrorBars, parseXlsxTrendline, readWorkSourceBlob as readSourceBlob, readXlsxFormulaFeaturesFromPackage, rememberWorkSourceBlob as registerSourceBlob, workArtifactExtension as artifactExtension, workArtifactKindLabel as artifactKindLabel, workKindForFile as officeKindForFile, workPdfPagesForExport as pdfPagesForExport, xlsxChartNodeUsesStackedGrouping, xlsxChartSeriesFormattingShapeProperties, xlsxChartSeriesMarkerXml, xlsxChartSeriesShapePropertiesXml };
+export { MAX_XLSX_WORKSHEET_IMAGE_BYTES, WORK_DOCUMENT_SNAPSHOT_MEDIA_TYPE as DOCUMENT_SNAPSHOT_MEDIA_TYPE, WORK_DOCUMENT_SNAPSHOT_SCHEMA as DOCUMENT_SNAPSHOT_SCHEMA, WORK_DOCUMENT_SNAPSHOT_VERSION as DOCUMENT_SNAPSHOT_VERSION, WORK_DOCUMENT_SOURCE_MEDIA_TYPE as DOCUMENT_SOURCE_MEDIA_TYPE, WORK_DOCUMENT_SOURCE_SCHEMA as DOCUMENT_SOURCE_SCHEMA, WORK_DOCUMENT_SOURCE_VERSION as DOCUMENT_SOURCE_VERSION, WORK_IMPORT_ACCEPT as OFFICE_FILE_ACCEPT, WORK_OFFICE_COLLABORATION_DEFAULT_MAX_TRANSPORT_PAYLOAD_BYTES as OFFICE_COLLABORATION_DEFAULT_MAX_TRANSPORT_PAYLOAD_BYTES, WORK_OFFICE_COLLABORATION_MAX_TRANSPORT_PAYLOAD_BYTES as OFFICE_COLLABORATION_MAX_TRANSPORT_PAYLOAD_BYTES, WORK_OFFICE_COLLABORATION_PRESENCE_FIELD as OFFICE_COLLABORATION_PRESENCE_FIELD, applyWorkDocumentSource as applyDocumentSource, createWorkArtifactBlob as createArtifactBlob, createWorkOfficeCollaborationPresence as createOfficeCollaborationPresence, createWorkOfficeCollaborationTransportBinding as createOfficeCollaborationTransportBinding, createWorkPdfCollaborationContent as createPdfCollaborationContent, decodeWorkDocumentSnapshot as decodeDocumentSnapshot, defaultPptxRuntimeUrl, diagnoseXlsxProtection, encodeWorkDocumentSnapshot as encodeDocumentSnapshot, exportWorkArtifact as downloadArtifact, exportWorkArtifactPdf as downloadArtifactPdf, forgetWorkSourceBlob as forgetSourceBlob, importWorkFile as importOfficeFile, inspectXlsxHeaderFooterText, inspectXlsxPivotTables, isEditableXlsxPaperSizeCode, isSupportedXlsxChartLegend, isSupportedXlsxChartPlotLayout, isSupportedXlsxChartSeriesFormatting, isSupportedXlsxCombinationChartNodes, isSupportedXlsxWorksheetImageContentType, parseXlsxChartAxes, parseXlsxChartLegend, parseXlsxChartPlotLayout, parseXlsxChartSeriesStyle, parseXlsxErrorBars, parseXlsxTrendline, projectWorkDocumentSource as projectDocumentSource, readWorkSourceBlob as readSourceBlob, readXlsxFormulaFeaturesFromPackage, rememberWorkSourceBlob as registerSourceBlob, workArtifactExtension as artifactExtension, workArtifactKindLabel as artifactKindLabel, workKindForFile as officeKindForFile, workPdfPagesForExport as pdfPagesForExport, xlsxChartNodeUsesStackedGrouping, xlsxChartSeriesFormattingShapeProperties, xlsxChartSeriesMarkerXml, xlsxChartSeriesShapePropertiesXml };