@a3s-lab/office 0.2.2 → 0.4.0

package/dist/3818.js

@@ -0,0 +1,1090 @@
+import { initializeWorkOfficeCollaborationMetadata, assertWorkOfficeCollaborationEditable, OfficeCollaborationError as WorkOfficeCollaborationError, readOfficeCollaborationMetadata as readWorkOfficeCollaborationMetadata, registerWorkOfficeCollaborationInitializer, markWorkOfficeCollaborationInitialized, assertWorkOfficeCollaborationOrigin } from "./9787.js";
+import { workOfficeCollaborationJsonEqual, canonicalWorkOfficeCollaborationJson, isWorkOfficeCollaborationRecord, cloneWorkOfficeCollaborationJson } from "./4650.js";
+import { patchWorkOfficeCollaborationFlatJsonMap, readWorkOfficeCollaborationFlatJsonMap } from "./7060.js";
+import * as __rspack_external_yjs from "yjs";
+const MAX_PDF_BYTES = 4294967296;
+const MAX_PDF_PAGES = 1000000;
+const MAX_PDF_RECORDS = 1000000;
+function validateWorkOfficePdfCollaborationContent(content) {
+    const record = requiredRecord(content, 'content');
+    assertExactKeys(record, [
+        'annotations',
+        'formValues',
+        'pageOperations',
+        'redactionProposals',
+        'reviewDecisions',
+        'signaturePlacements',
+        'source',
+        'type'
+    ], 'content');
+    if ('pdf' !== record.type) invalid("a PDF content type of 'pdf'");
+    const source = validateSource(record.source);
+    const result = {
+        type: 'pdf',
+        source,
+        annotations: validateRecords(record.annotations, 'annotation', (value)=>validateAnnotation(value, source)),
+        formValues: validateRecords(record.formValues, 'form value', validateFormValue),
+        signaturePlacements: validateRecords(record.signaturePlacements, 'signature placement', (value)=>validateSignaturePlacement(value, source)),
+        redactionProposals: validateRecords(record.redactionProposals, 'redaction proposal', (value)=>validateRedactionProposal(value, source)),
+        pageOperations: validateRecords(record.pageOperations, 'page operation', (value)=>validatePageOperation(value, source)),
+        reviewDecisions: validateRecords(record.reviewDecisions, 'review decision', validateReviewDecision)
+    };
+    assertReferences(result);
+    return result;
+}
+function validateSharedWorkOfficePdfCollaborationContent(content) {
+    try {
+        return validateWorkOfficePdfCollaborationContent(content);
+    } catch (error) {
+        if (error instanceof WorkOfficeCollaborationError) throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `The shared PDF collaboration content is invalid: ${error.message}`);
+        throw error;
+    }
+}
+function invalidWorkOfficePdfShared(label) {
+    throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `The shared PDF collaboration ${label} is invalid.`);
+}
+function validateSource(value) {
+    const source = requiredRecord(value, 'source');
+    assertExactKeys(source, [
+        'byteLength',
+        'pageCount',
+        'sha256'
+    ], 'source');
+    const sha256 = requiredString(source.sha256, 'source SHA-256');
+    if (!/^[0-9a-f]{64}$/.test(sha256)) invalid('a lowercase SHA-256 source');
+    return {
+        sha256,
+        byteLength: requiredInteger(source.byteLength, 1, MAX_PDF_BYTES, 'source byte length'),
+        pageCount: requiredInteger(source.pageCount, 1, MAX_PDF_PAGES, 'source page count')
+    };
+}
+function validateAnnotation(value, source) {
+    const record = requiredRecord(value, 'annotation');
+    assertAllowedKeys(record, [
+        'annotation',
+        'deleted',
+        'id',
+        'pageIndex',
+        'source'
+    ], 'annotation');
+    const id = requiredIdentifier(record.id, 'annotation');
+    const pageIndex = requiredPageIndex(record.pageIndex, source, 'annotation');
+    if ('base' !== record.source && 'created' !== record.source) invalid("an annotation source of 'base' or 'created'");
+    const annotation = validateJsonRecord(record.annotation, 'annotation value');
+    if (annotation.id !== id || annotation.pageIndex !== pageIndex) invalid('annotation value identity matching its record');
+    const result = {
+        id,
+        pageIndex,
+        source: record.source,
+        annotation
+    };
+    if (void 0 !== record.deleted) {
+        if (true !== record.deleted) invalid('an annotation tombstone of true');
+        result.deleted = true;
+    }
+    return result;
+}
+function validateFormValue(value) {
+    const record = requiredRecord(value, 'form value');
+    assertExactKeys(record, [
+        'id',
+        'value'
+    ], 'form value');
+    return {
+        id: requiredIdentifier(record.id, 'form field'),
+        value: requiredString(record.value, 'form field value')
+    };
+}
+function validateSignaturePlacement(value, source) {
+    const record = requiredRecord(value, 'signature placement');
+    assertExactKeys(record, [
+        'actorId',
+        'annotationId',
+        'appearance',
+        'createdAt',
+        'id',
+        'kind',
+        'pageIndex'
+    ], 'signature placement');
+    if ('signature' !== record.kind && 'initials' !== record.kind) invalid("a signature placement kind of 'signature' or 'initials'");
+    const appearance = requiredRecord(record.appearance, 'signature appearance');
+    assertExactKeys(appearance, [
+        'assetId',
+        'byteLength',
+        'mimeType',
+        'sha256'
+    ], 'signature appearance');
+    const sha256 = requiredString(appearance.sha256, 'signature SHA-256');
+    if (!/^[0-9a-f]{64}$/.test(sha256)) invalid('a lowercase SHA-256 signature appearance');
+    return {
+        id: requiredIdentifier(record.id, 'signature placement'),
+        annotationId: requiredIdentifier(record.annotationId, 'signature annotation'),
+        pageIndex: requiredPageIndex(record.pageIndex, source, 'signature placement'),
+        kind: record.kind,
+        actorId: requiredIdentifier(record.actorId, 'signature actor'),
+        createdAt: requiredTimestamp(record.createdAt, 'signature creation'),
+        appearance: {
+            assetId: requiredIdentifier(appearance.assetId, 'signature asset'),
+            sha256,
+            byteLength: requiredInteger(appearance.byteLength, 1, MAX_PDF_BYTES, 'signature byte length'),
+            mimeType: requiredString(appearance.mimeType, 'signature MIME type')
+        }
+    };
+}
+function validateRedactionProposal(value, source) {
+    const record = requiredRecord(value, 'redaction proposal');
+    assertAllowedKeys(record, [
+        'id',
+        'pageIndex',
+        'proposedAt',
+        'proposedBy',
+        'reason',
+        'rects',
+        'text'
+    ], 'redaction proposal');
+    const rects = requiredArray(record.rects, 'redaction rectangles');
+    if (0 === rects.length || rects.length > 10000) invalid('between 1 and 10,000 redaction rectangles');
+    const result = {
+        id: requiredIdentifier(record.id, 'redaction proposal'),
+        pageIndex: requiredPageIndex(record.pageIndex, source, 'redaction'),
+        rects: rects.map((rect)=>{
+            const item = requiredRecord(rect, 'redaction rectangle');
+            assertExactKeys(item, [
+                'bottom',
+                'left',
+                'right',
+                'top'
+            ], 'redaction rectangle');
+            const value = {
+                left: requiredFiniteNumber(item.left, 'redaction left'),
+                top: requiredFiniteNumber(item.top, 'redaction top'),
+                right: requiredFiniteNumber(item.right, 'redaction right'),
+                bottom: requiredFiniteNumber(item.bottom, 'redaction bottom')
+            };
+            if (value.right <= value.left || value.bottom <= value.top) invalid('a positive redaction rectangle');
+            return value;
+        }),
+        proposedBy: requiredIdentifier(record.proposedBy, 'redaction proposer'),
+        proposedAt: requiredTimestamp(record.proposedAt, 'redaction proposal')
+    };
+    if (void 0 !== record.reason) result.reason = requiredString(record.reason, 'redaction reason');
+    if (void 0 !== record.text) result.text = requiredString(record.text, 'redaction text');
+    return result;
+}
+function validatePageOperation(value, source) {
+    const record = requiredRecord(value, 'page operation');
+    const base = {
+        id: requiredIdentifier(record.id, 'page operation'),
+        proposedBy: requiredIdentifier(record.proposedBy, 'page operation proposer'),
+        proposedAt: requiredTimestamp(record.proposedAt, 'page operation proposal')
+    };
+    if ('rotate' === record.kind) {
+        assertExactKeys(record, [
+            'degrees',
+            'id',
+            'kind',
+            'pageIndices',
+            'proposedAt',
+            'proposedBy'
+        ], 'rotate page operation');
+        if (90 !== record.degrees && 180 !== record.degrees && 270 !== record.degrees) invalid('a page rotation of 90, 180, or 270 degrees');
+        return {
+            ...base,
+            kind: 'rotate',
+            pageIndices: requiredPageIndices(record.pageIndices, source, false),
+            degrees: record.degrees
+        };
+    }
+    if ('delete' === record.kind) {
+        assertExactKeys(record, [
+            'id',
+            'kind',
+            'pageIndices',
+            'proposedAt',
+            'proposedBy'
+        ], 'delete page operation');
+        const pageIndices = requiredPageIndices(record.pageIndices, source, false);
+        if (pageIndices.length >= source.pageCount) invalid('a page deletion that retains at least one source page');
+        return {
+            ...base,
+            kind: 'delete',
+            pageIndices
+        };
+    }
+    if ('reorder' === record.kind) {
+        assertExactKeys(record, [
+            'id',
+            'kind',
+            'pageOrder',
+            'proposedAt',
+            'proposedBy'
+        ], 'reorder page operation');
+        const pageOrder = requiredPageIndices(record.pageOrder, source, true);
+        return {
+            ...base,
+            kind: 'reorder',
+            pageOrder
+        };
+    }
+    invalid('a supported PDF page operation kind');
+}
+function validateReviewDecision(value) {
+    const record = requiredRecord(value, 'review decision');
+    assertExactKeys(record, [
+        'actorId',
+        'createdAt',
+        'decision',
+        'id',
+        'targetId',
+        'targetKind'
+    ], 'review decision');
+    if ('redaction' !== record.targetKind && 'page-operation' !== record.targetKind) invalid('a supported review target kind');
+    if ('approve' !== record.decision && 'reject' !== record.decision) invalid("a review decision of 'approve' or 'reject'");
+    return {
+        id: requiredIdentifier(record.id, 'review decision'),
+        targetKind: record.targetKind,
+        targetId: requiredIdentifier(record.targetId, 'review target'),
+        decision: record.decision,
+        actorId: requiredIdentifier(record.actorId, 'review actor'),
+        createdAt: requiredTimestamp(record.createdAt, 'review decision')
+    };
+}
+function assertReferences(content) {
+    const annotations = new Map(content.annotations.map((value)=>[
+            value.id,
+            value
+        ]));
+    for (const placement of content.signaturePlacements){
+        const annotation = annotations.get(placement.annotationId);
+        if (!annotation || annotation.deleted || 'created' !== annotation.source || annotation.pageIndex !== placement.pageIndex) invalid(`signature placement '${placement.id}' to reference a live created annotation on the same page`);
+    }
+    const redactions = new Set(content.redactionProposals.map(({ id })=>id));
+    const pageOperations = new Set(content.pageOperations.map(({ id })=>id));
+    const decidedTargets = new Set();
+    for (const decision of content.reviewDecisions){
+        const targets = 'redaction' === decision.targetKind ? redactions : pageOperations;
+        if (!targets.has(decision.targetId)) invalid(`review decision '${decision.id}' to reference an existing ${decision.targetKind}`);
+        const target = `${decision.targetKind}:${decision.targetId}`;
+        if (decidedTargets.has(target)) invalid(`at most one final review decision for '${target}'`);
+        decidedTargets.add(target);
+    }
+}
+function validateRecords(value, label, validate) {
+    const records = requiredArray(value, `${label}s`);
+    if (records.length > MAX_PDF_RECORDS) invalid(`at most ${MAX_PDF_RECORDS} ${label}s`);
+    const ids = new Set();
+    return records.map((item)=>{
+        const record = validate(item);
+        if (ids.has(record.id)) invalid(`a unique ${label} ID; '${record.id}' is repeated`);
+        ids.add(record.id);
+        return record;
+    });
+}
+function requiredPageIndices(value, source, complete) {
+    const pages = requiredArray(value, complete ? 'page order' : 'page indices');
+    if (complete && pages.length !== source.pageCount || !complete && 0 === pages.length) invalid(complete ? 'a complete source-page permutation' : 'at least one page index');
+    const result = pages.map((page)=>requiredPageIndex(page, source, 'page operation'));
+    if (new Set(result).size !== result.length) invalid('unique page indices');
+    return result;
+}
+function validateJsonRecord(value, label) {
+    const record = requiredRecord(value, label);
+    try {
+        return clonePdfJsonValue(record);
+    } catch (error) {
+        throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `PDF collaboration requires a JSON-compatible ${label}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function clonePdfJsonValue(value, seen = new WeakSet()) {
+    if (value instanceof Date) {
+        if (!Number.isFinite(value.getTime())) invalid('valid annotation dates');
+        return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+        if (seen.has(value)) invalid('acyclic annotation values');
+        seen.add(value);
+        const result = value.map((item)=>clonePdfJsonValue(item, seen));
+        seen.delete(value);
+        return result;
+    }
+    if (!isWorkOfficeCollaborationRecord(value)) return cloneWorkOfficeCollaborationJson(value);
+    if (seen.has(value)) invalid('acyclic annotation values');
+    seen.add(value);
+    const result = {};
+    for (const [key, item] of Object.entries(value))if (void 0 !== item) Object.defineProperty(result, key, {
+        configurable: true,
+        enumerable: true,
+        value: clonePdfJsonValue(item, seen),
+        writable: true
+    });
+    seen.delete(value);
+    return result;
+}
+function requiredPageIndex(value, source, label) {
+    return requiredInteger(value, 0, source.pageCount - 1, `${label} page index`);
+}
+function requiredTimestamp(value, label) {
+    const timestamp = requiredString(value, `${label} timestamp`);
+    if (!Number.isFinite(Date.parse(timestamp))) invalid(`an ISO-compatible ${label} timestamp`);
+    return timestamp;
+}
+function requiredIdentifier(value, label) {
+    const result = requiredString(value, `${label} ID`);
+    if (!result || result !== result.trim() || result.length > 512) invalid(`a ${label} ID containing 1 to 512 characters`);
+    return result;
+}
+function requiredString(value, label) {
+    if ('string' != typeof value) invalid(`a string ${label}`);
+    return value;
+}
+function requiredFiniteNumber(value, label) {
+    if ('number' != typeof value || !Number.isFinite(value)) invalid(`a finite number for ${label}`);
+    return value;
+}
+function requiredInteger(value, minimum, maximum, label) {
+    if (!Number.isSafeInteger(value) || value < minimum || value > maximum) invalid(`an integer ${label} between ${minimum} and ${maximum}`);
+    return value;
+}
+function requiredRecord(value, label) {
+    if (!isWorkOfficeCollaborationRecord(value)) invalid(`a valid ${label} record`);
+    return value;
+}
+function requiredArray(value, label) {
+    if (!Array.isArray(value)) invalid(`an array of ${label}`);
+    return value;
+}
+function assertExactKeys(record, keys, label) {
+    assertAllowedKeys(record, keys, label);
+    if (keys.some((key)=>!Object.hasOwn(record, key))) invalid(`a complete ${label} record`);
+}
+function assertAllowedKeys(record, keys, label) {
+    const allowed = new Set(keys);
+    if (Object.keys(record).some((key)=>!allowed.has(key))) invalid(`a ${label} record without unknown fields`);
+}
+function invalid(expected) {
+    throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `PDF collaboration requires ${expected}.`);
+}
+function appendWorkOfficePdfRecordClaims(claims, previous, next) {
+    appendClaims(claims, 'annotation', previous?.annotations ?? [], next.annotations, annotationFingerprint);
+    appendClaims(claims, 'signature-placement', previous?.signaturePlacements ?? [], next.signaturePlacements);
+    appendClaims(claims, 'redaction', previous?.redactionProposals ?? [], next.redactionProposals);
+    appendClaims(claims, 'page-operation', previous?.pageOperations ?? [], next.pageOperations);
+    appendClaims(claims, 'review-decision', previous?.reviewDecisions ?? [], next.reviewDecisions);
+}
+function assertWorkOfficePdfRecordClaims(claims, content) {
+    const fingerprints = new Map();
+    for (const raw of claims.toArray()){
+        const claim = parsedClaim(raw);
+        const identity = claimIdentity(claim.kind, claim.id);
+        const existing = fingerprints.get(identity);
+        if (void 0 !== existing && existing !== claim.fingerprint) throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `The PDF ${claim.kind} ID '${claim.id}' was concurrently assigned to different records.`);
+        fingerprints.set(identity, claim.fingerprint);
+    }
+    assertClaims(fingerprints, 'annotation', content.annotations);
+    assertAnnotationClaimIdentities(fingerprints, content.annotations);
+    assertClaims(fingerprints, 'signature-placement', content.signaturePlacements);
+    assertClaims(fingerprints, 'redaction', content.redactionProposals);
+    assertClaims(fingerprints, 'page-operation', content.pageOperations);
+    assertClaims(fingerprints, 'review-decision', content.reviewDecisions);
+}
+function assertAnnotationClaimIdentities(claims, annotations) {
+    for (const annotation of annotations){
+        const fingerprint = claims.get(claimIdentity('annotation', annotation.id));
+        if (void 0 === fingerprint) continue;
+        let claimed;
+        try {
+            claimed = JSON.parse(fingerprint);
+        } catch  {
+            invalidWorkOfficePdfShared('annotation record claim');
+        }
+        if (!isWorkOfficeCollaborationRecord(claimed) || claimed.id !== annotation.id || claimed.pageIndex !== annotation.pageIndex || claimed.source !== annotation.source) invalidWorkOfficePdfShared('annotation immutable identity claim');
+        const claimedAnnotation = isWorkOfficeCollaborationRecord(claimed.annotation) ? claimed.annotation : void 0;
+        const claimedType = claimed.type ?? claimedAnnotation?.type;
+        if ('created' === annotation.source && void 0 === claimedType || void 0 !== claimedType && claimedType !== annotation.annotation.type) invalidWorkOfficePdfShared('annotation immutable identity claim');
+    }
+}
+function appendClaims(claims, kind, previous, next, fingerprint = (value)=>value) {
+    const previousIds = new Set(previous.map(({ id })=>id));
+    for (const value of next){
+        if (previousIds.has(value.id)) continue;
+        const serialized = canonicalWorkOfficeCollaborationJson({
+            fingerprint: canonicalWorkOfficeCollaborationJson(fingerprint(value)),
+            id: value.id,
+            kind
+        });
+        if (!claims.toArray().includes(serialized)) claims.push([
+            serialized
+        ]);
+    }
+}
+function annotationFingerprint(value) {
+    return 'base' === value.source ? {
+        id: value.id,
+        pageIndex: value.pageIndex,
+        source: value.source,
+        type: value.annotation.type
+    } : value;
+}
+function assertClaims(claims, kind, values) {
+    for (const { id } of values)if (!claims.has(claimIdentity(kind, id))) invalidWorkOfficePdfShared(`${kind} record claim`);
+}
+function parsedClaim(raw) {
+    if ('string' != typeof raw) invalidWorkOfficePdfShared('record claim');
+    let value;
+    try {
+        value = JSON.parse(raw);
+    } catch  {
+        invalidWorkOfficePdfShared('record claim');
+    }
+    if (!isWorkOfficeCollaborationRecord(value) || canonicalWorkOfficeCollaborationJson(value) !== raw) invalidWorkOfficePdfShared('record claim');
+    if (Object.keys(value).some((key)=>'fingerprint' !== key && 'id' !== key && 'kind' !== key)) invalidWorkOfficePdfShared('record claim');
+    const kind = requiredClaimKind(value.kind);
+    const id = requiredClaimString(value.id, 'record claim ID');
+    const fingerprint = requiredClaimString(value.fingerprint, 'record claim fingerprint');
+    if (!id.trim() || id.length > 512) invalidWorkOfficePdfShared('record claim ID');
+    try {
+        if (canonicalWorkOfficeCollaborationJson(JSON.parse(fingerprint)) !== fingerprint) invalidWorkOfficePdfShared('record claim fingerprint');
+    } catch  {
+        invalidWorkOfficePdfShared('record claim fingerprint');
+    }
+    return {
+        fingerprint,
+        id,
+        kind
+    };
+}
+function requiredClaimKind(value) {
+    if ('annotation' === value || 'page-operation' === value || 'redaction' === value || 'review-decision' === value || 'signature-placement' === value) return value;
+    invalidWorkOfficePdfShared('record claim kind');
+}
+function requiredClaimString(value, label) {
+    if ('string' != typeof value) invalidWorkOfficePdfShared(label);
+    return value;
+}
+function claimIdentity(kind, id) {
+    return canonicalWorkOfficeCollaborationJson([
+        kind,
+        id
+    ]);
+}
+function assertWorkOfficePdfPatchSafe(previous, next, shared) {
+    if (!workOfficeCollaborationJsonEqual(previous.source, next.source)) throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', 'The immutable PDF source identity cannot be changed by a collaboration update.');
+    if (!workOfficeCollaborationJsonEqual(previous.source, shared.source)) conflict('immutable PDF source identity');
+    assertAnnotationCollection(previous.annotations, next.annotations, shared.annotations);
+    assertMutableRecordCollection(previous.formValues, next.formValues, shared.formValues, 'PDF form value');
+    assertAppendOnlyCollection(previous.signaturePlacements, next.signaturePlacements, shared.signaturePlacements, 'PDF signature placement');
+    assertAppendOnlyCollection(previous.redactionProposals, next.redactionProposals, shared.redactionProposals, 'PDF redaction proposal');
+    assertAppendOnlyCollection(previous.pageOperations, next.pageOperations, shared.pageOperations, 'PDF page operation');
+    assertAppendOnlyCollection(previous.reviewDecisions, next.reviewDecisions, shared.reviewDecisions, 'PDF review decision');
+}
+function assertAnnotationCollection(previous, next, shared) {
+    const nextById = new Map(next.map((value)=>[
+            value.id,
+            value
+        ]));
+    const sharedById = new Map(shared.map((value)=>[
+            value.id,
+            value
+        ]));
+    const previousIds = new Set(previous.map(({ id })=>id));
+    for (const before of previous){
+        const after = nextById.get(before.id);
+        const current = sharedById.get(before.id);
+        if (!after) throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `PDF annotation '${before.id}' must be retained with deleted: true instead of removing its durable record.`);
+        if (after.source !== before.source) throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `PDF annotation '${before.id}' cannot change its source identity.`);
+        if (after.pageIndex !== before.pageIndex) throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `PDF annotation '${before.id}' cannot change its page identity.`);
+        if (after.annotation.type !== before.annotation.type) throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `PDF annotation '${before.id}' cannot change its type identity.`);
+        if (before.deleted && !after.deleted) throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `PDF annotation '${before.id}' has a durable deletion tombstone that cannot be cleared.`);
+        if (!workOfficeCollaborationJsonEqual(before, after)) {
+            if (!current) removedConflict(`PDF annotation '${before.id}'`);
+            if (current.source !== before.source) conflict(`PDF annotation '${before.id}' source`);
+            if (current.pageIndex !== before.pageIndex) conflict(`PDF annotation '${before.id}' page identity`);
+            if (current.annotation.type !== before.annotation.type) conflict(`PDF annotation '${before.id}' type identity`);
+            assertCompatibleValue(before, after, current, `PDF annotation '${before.id}'`);
+        }
+    }
+    for (const after of next){
+        if (previousIds.has(after.id)) continue;
+        const current = sharedById.get(after.id);
+        if (current) {
+            if (after.source !== current.source) conflict(`PDF annotation '${after.id}' source`);
+            assertCompatibleValue({}, after, current, `PDF annotation '${after.id}'`);
+        }
+    }
+}
+function assertMutableRecordCollection(previous, next, shared, label) {
+    const nextById = new Map(next.map((value)=>[
+            value.id,
+            value
+        ]));
+    const sharedById = new Map(shared.map((value)=>[
+            value.id,
+            value
+        ]));
+    const previousIds = new Set(previous.map(({ id })=>id));
+    for (const before of previous){
+        const after = nextById.get(before.id);
+        const current = sharedById.get(before.id);
+        if (!after) {
+            if (current && !workOfficeCollaborationJsonEqual(before, current)) conflict(`${label} '${before.id}'`);
+            continue;
+        }
+        if (!workOfficeCollaborationJsonEqual(before, after)) {
+            if (!current) removedConflict(`${label} '${before.id}'`);
+            assertCompatibleValue(before, after, current, `${label} '${before.id}'`);
+        }
+    }
+    for (const after of next){
+        if (previousIds.has(after.id)) continue;
+        const current = sharedById.get(after.id);
+        if (current) assertCompatibleValue({}, after, current, `${label} '${after.id}'`);
+    }
+}
+function assertAppendOnlyCollection(previous, next, shared, label) {
+    if (previous.some((value, index)=>next[index]?.id !== value.id)) throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `${label} records are append-only and cannot be reordered or inserted before an existing record.`);
+    const nextById = new Map(next.map((value)=>[
+            value.id,
+            value
+        ]));
+    const sharedById = new Map(shared.map((value)=>[
+            value.id,
+            value
+        ]));
+    const previousIds = new Set(previous.map(({ id })=>id));
+    for (const before of previous){
+        const after = nextById.get(before.id);
+        if (!after || !workOfficeCollaborationJsonEqual(before, after)) throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `${label} '${before.id}' is an append-only audit record and cannot be changed or removed.`);
+    }
+    for (const after of next){
+        if (previousIds.has(after.id)) continue;
+        const current = sharedById.get(after.id);
+        if (current && !workOfficeCollaborationJsonEqual(after, current)) conflict(`${label} '${after.id}'`);
+    }
+}
+function assertCompatibleValue(previous, next, shared, label) {
+    if (workOfficeCollaborationJsonEqual(previous, next)) return;
+    if (isWorkOfficeCollaborationRecord(previous) && isWorkOfficeCollaborationRecord(next) && isWorkOfficeCollaborationRecord(shared)) {
+        const keys = new Set([
+            ...Object.keys(previous),
+            ...Object.keys(next)
+        ]);
+        for (const key of keys){
+            const hadPrevious = Object.hasOwn(previous, key);
+            const hasNext = Object.hasOwn(next, key);
+            const hasShared = Object.hasOwn(shared, key);
+            const fieldLabel = `${label} field '${key}'`;
+            if (!hasNext) {
+                if (hadPrevious && hasShared && !workOfficeCollaborationJsonEqual(previous[key], shared[key])) conflict(fieldLabel);
+                continue;
+            }
+            if (!hadPrevious) {
+                if (hasShared && !workOfficeCollaborationJsonEqual(next[key], shared[key])) conflict(fieldLabel);
+                continue;
+            }
+            if (!workOfficeCollaborationJsonEqual(previous[key], next[key])) {
+                if (!hasShared) removedConflict(fieldLabel);
+                assertCompatibleValue(previous[key], next[key], shared[key], fieldLabel);
+            }
+        }
+        return;
+    }
+    if (!workOfficeCollaborationJsonEqual(previous, shared) && !workOfficeCollaborationJsonEqual(next, shared)) conflict(label);
+}
+function removedConflict(label) {
+    throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `The ${label} was removed before this change could be applied. Refresh the shared snapshot before retrying.`);
+}
+function conflict(label) {
+    throw new WorkOfficeCollaborationError('office.collaboration.content_invalid', `The ${label} changed concurrently. Refresh the shared snapshot before retrying.`);
+}
+function workOfficePdfRecordCollectionRoots(document, rootName, name) {
+    return {
+        presence: document.getMap(rootName(`pdf.${name}.presence`)),
+        fields: document.getMap(rootName(`pdf.${name}.fields`)),
+        order: document.getArray(rootName(`pdf.${name}.order`))
+    };
+}
+function patchWorkOfficePdfRecords(roots, previous, next, label) {
+    const beforeById = new Map(previous.map((value)=>[
+            value.id,
+            value
+        ]));
+    const afterById = new Map(next.map((value)=>[
+            value.id,
+            value
+        ]));
+    for (const before of previous){
+        if (afterById.has(before.id)) continue;
+        const presence = roots.presence.get(before.id);
+        if (void 0 === presence) {
+            removeAll(roots.order, before.id);
+            continue;
+        }
+        if (true !== presence) invalidWorkOfficePdfShared(`${label} record presence`);
+        roots.presence.delete(before.id);
+        patchWorkOfficeCollaborationFlatJsonMap(new PdfRecordFlatJsonMap(roots.fields, before.id, label), before, void 0, `${label} '${before.id}'`);
+        removeAll(roots.order, before.id);
+    }
+    for (const after of next){
+        const before = beforeById.get(after.id);
+        if (!(before && workOfficeCollaborationJsonEqual(before, after))) {
+            roots.presence.set(after.id, true);
+            patchWorkOfficeCollaborationFlatJsonMap(new PdfRecordFlatJsonMap(roots.fields, after.id, label), before, after, `${label} '${after.id}'`);
+        }
+    }
+    patchWorkOfficePdfOrder(roots.order, previous.map(({ id })=>id), next.map(({ id })=>id));
+}
+function readWorkOfficePdfRecords(roots, label) {
+    const ids = validatedPdfOrder(roots.order, roots.presence, label);
+    const fieldsById = pdfFieldsById(roots, label);
+    return ids.map((id)=>{
+        const value = readWorkOfficeCollaborationFlatJsonMap(fieldsById.get(id) ?? new Map(), `${label} '${id}'`, invalidWorkOfficePdfShared);
+        if (value.id !== id) invalidWorkOfficePdfShared(`${label} identity`);
+        return value;
+    });
+}
+function assertWorkOfficePdfRecordCollectionEmpty(roots) {
+    return 0 === roots.presence.size && 0 === roots.fields.size && 0 === roots.order.length;
+}
+function workOfficePdfRecordCollectionUndoScope(roots) {
+    return [
+        roots.presence,
+        roots.fields,
+        roots.order
+    ];
+}
+function workOfficePdfRecordFieldChanged(transaction, roots, path) {
+    const changedKeys = transaction.changed.get(roots.fields);
+    if (!changedKeys) return false;
+    const encodedField = JSON.stringify([
+        'value',
+        ...path
+    ]);
+    for (const key of changedKeys){
+        if (null === key) return true;
+        const identity = tryDecodeRecordFieldIdentity(key);
+        if (identity?.[1] === encodedField) return true;
+    }
+    return false;
+}
+function validatedPdfOrder(order, presence, label) {
+    const seen = new Set();
+    const result = [];
+    for (const id of order.toArray()){
+        if ('string' != typeof id || !id.trim()) invalidWorkOfficePdfShared(`${label} order`);
+        if (!seen.has(id)) {
+            seen.add(id);
+            result.push(id);
+        }
+    }
+    for (const [id, value] of presence.entries())if (true !== value || !id.trim() || !seen.has(id)) invalidWorkOfficePdfShared(`${label} order and record set`);
+    if (seen.size !== presence.size) invalidWorkOfficePdfShared(`${label} order and record set`);
+    return result;
+}
+function pdfFieldsById(roots, label) {
+    const result = new Map();
+    for (const [encoded, value] of roots.fields.entries()){
+        const [id, field] = decodedRecordFieldIdentity(encoded, label);
+        if (true !== roots.presence.get(id)) invalidWorkOfficePdfShared(`${label} orphan field`);
+        let fields = result.get(id);
+        if (!fields) {
+            fields = new Map();
+            result.set(id, fields);
+        }
+        fields.set(field, value);
+    }
+    return result;
+}
+function patchWorkOfficePdfOrder(order, previous, next) {
+    if (workOfficeCollaborationJsonEqual(previous, next)) return;
+    const nextIds = new Set(next);
+    for (const id of previous)if (!nextIds.has(id)) removeAll(order, id);
+    const previousIds = new Set(previous);
+    for (const id of next)if (!(previousIds.has(id) || order.toArray().includes(id))) insertRelative(order, next, id);
+    if (!sameRelativeOrder(previous, next)) {
+        for (const id of next.filter((id)=>previousIds.has(id)))removeAll(order, id);
+        for (const id of next)if (!order.toArray().includes(id)) insertRelative(order, next, id);
+    }
+}
+class PdfRecordFlatJsonMap {
+    fields;
+    id;
+    label;
+    constructor(fields, id, label){
+        this.fields = fields;
+        this.id = id;
+        this.label = label;
+    }
+    delete(key) {
+        const encoded = encodedRecordFieldIdentity(this.id, key);
+        const hadValue = this.fields.has(encoded);
+        this.fields.delete(encoded);
+        return hadValue;
+    }
+    *entries() {
+        for (const [encoded, value] of this.fields.entries()){
+            const [id, field] = decodedRecordFieldIdentity(encoded, this.label);
+            if (id === this.id) yield [
+                field,
+                value
+            ];
+        }
+    }
+    get(key) {
+        return this.fields.get(encodedRecordFieldIdentity(this.id, key));
+    }
+    set(key, value) {
+        this.fields.set(encodedRecordFieldIdentity(this.id, key), value);
+        return this.fields;
+    }
+}
+function encodedRecordFieldIdentity(id, field) {
+    return JSON.stringify([
+        id,
+        field
+    ]);
+}
+function decodedRecordFieldIdentity(encoded, label) {
+    const identity = tryDecodeRecordFieldIdentity(encoded);
+    if (!identity?.[0].trim()) invalidWorkOfficePdfShared(`${label} field identity`);
+    if (encodedRecordFieldIdentity(identity[0], identity[1]) !== encoded) invalidWorkOfficePdfShared(`${label} field identity`);
+    return identity;
+}
+function tryDecodeRecordFieldIdentity(encoded) {
+    let identity;
+    try {
+        identity = JSON.parse(encoded);
+    } catch  {
+        return;
+    }
+    if (!Array.isArray(identity) || 2 !== identity.length || identity.some((value)=>'string' != typeof value)) return;
+    return identity;
+}
+function insertRelative(order, desired, id) {
+    const desiredIndex = desired.indexOf(id);
+    for(let index = desiredIndex - 1; index >= 0; index -= 1){
+        const currentIndex = order.toArray().indexOf(desired[index]);
+        if (currentIndex >= 0) return void order.insert(currentIndex + 1, [
+            id
+        ]);
+    }
+    for(let index = desiredIndex + 1; index < desired.length; index += 1){
+        const currentIndex = order.toArray().indexOf(desired[index]);
+        if (currentIndex >= 0) return void order.insert(currentIndex, [
+            id
+        ]);
+    }
+    order.push([
+        id
+    ]);
+}
+function sameRelativeOrder(previous, next) {
+    const nextIds = new Set(next);
+    const previousIds = new Set(previous);
+    return workOfficeCollaborationJsonEqual(previous.filter((id)=>nextIds.has(id)), next.filter((id)=>previousIds.has(id)));
+}
+function removeAll(order, id) {
+    for(let index = order.length - 1; index >= 0; index -= 1)if (order.get(index) === id) order.delete(index, 1);
+}
+const PDF_SOURCE_ROOT = 'pdf.source';
+const PDF_SOURCE_IDENTITIES_ROOT = 'pdf.source-identities';
+const PDF_RECORD_CLAIMS_ROOT = 'pdf.record-claims';
+function workOfficePdfRoots(document, rootName) {
+    return {
+        source: document.getMap(rootName(PDF_SOURCE_ROOT)),
+        sourceIdentities: document.getArray(rootName(PDF_SOURCE_IDENTITIES_ROOT)),
+        annotations: workOfficePdfRecordCollectionRoots(document, rootName, 'annotations'),
+        formValues: workOfficePdfRecordCollectionRoots(document, rootName, 'form-values'),
+        signaturePlacements: workOfficePdfRecordCollectionRoots(document, rootName, 'signature-placements'),
+        redactionProposals: workOfficePdfRecordCollectionRoots(document, rootName, 'redaction-proposals'),
+        pageOperations: workOfficePdfRecordCollectionRoots(document, rootName, 'page-operations'),
+        reviewDecisions: workOfficePdfRecordCollectionRoots(document, rootName, 'review-decisions'),
+        recordClaims: document.getArray(rootName(PDF_RECORD_CLAIMS_ROOT))
+    };
+}
+function initializeWorkOfficePdfRoots(roots, content) {
+    patchSource(roots.source, content.source);
+    roots.sourceIdentities.push([
+        canonicalWorkOfficeCollaborationJson(content.source)
+    ]);
+    appendWorkOfficePdfRecordClaims(roots.recordClaims, void 0, content);
+    patchCollections(roots, void 0, content);
+}
+function readWorkOfficePdfRoots(roots) {
+    const content = {
+        type: 'pdf',
+        source: readSource(roots.source),
+        annotations: readWorkOfficePdfRecords(roots.annotations, 'annotation'),
+        formValues: readWorkOfficePdfRecords(roots.formValues, 'form value'),
+        signaturePlacements: readWorkOfficePdfRecords(roots.signaturePlacements, 'signature placement'),
+        redactionProposals: readWorkOfficePdfRecords(roots.redactionProposals, 'redaction proposal'),
+        pageOperations: readWorkOfficePdfRecords(roots.pageOperations, 'page operation'),
+        reviewDecisions: readWorkOfficePdfRecords(roots.reviewDecisions, 'review decision')
+    };
+    const validated = validateSharedWorkOfficePdfCollaborationContent(content);
+    assertSourceIdentity(roots.sourceIdentities, validated.source);
+    assertWorkOfficePdfRecordClaims(roots.recordClaims, validated);
+    return validated;
+}
+function patchWorkOfficePdfRoots(roots, previous, next) {
+    const shared = readWorkOfficePdfRoots(roots);
+    assertWorkOfficePdfPatchSafe(previous, next, shared);
+    appendWorkOfficePdfRecordClaims(roots.recordClaims, previous, next);
+    patchCollections(roots, previous, next);
+}
+function assertWorkOfficePdfRootsEmpty(roots) {
+    if (roots.source.size > 0 || roots.sourceIdentities.length > 0 || !assertWorkOfficePdfRecordCollectionEmpty(roots.annotations) || !assertWorkOfficePdfRecordCollectionEmpty(roots.formValues) || !assertWorkOfficePdfRecordCollectionEmpty(roots.signaturePlacements) || !assertWorkOfficePdfRecordCollectionEmpty(roots.redactionProposals) || !assertWorkOfficePdfRecordCollectionEmpty(roots.pageOperations) || !assertWorkOfficePdfRecordCollectionEmpty(roots.reviewDecisions) || roots.recordClaims.length > 0) throw new WorkOfficeCollaborationError('office.collaboration.bootstrap_ambiguous', 'The PDF collaboration roots contain data without initialized metadata.');
+}
+function workOfficePdfUndoScope(roots) {
+    return [
+        ...workOfficePdfRecordCollectionUndoScope(roots.annotations),
+        ...workOfficePdfRecordCollectionUndoScope(roots.formValues)
+    ];
+}
+function workOfficePdfIrreversibleScope(roots) {
+    return [
+        ...workOfficePdfRecordCollectionUndoScope(roots.signaturePlacements),
+        ...workOfficePdfRecordCollectionUndoScope(roots.redactionProposals),
+        ...workOfficePdfRecordCollectionUndoScope(roots.pageOperations),
+        ...workOfficePdfRecordCollectionUndoScope(roots.reviewDecisions)
+    ];
+}
+function workOfficePdfIrreversibleChange(roots, transaction) {
+    const changedParents = transaction.changedParentTypes;
+    return workOfficePdfRecordFieldChanged(transaction, roots.annotations, [
+        'deleted'
+    ]) || workOfficePdfIrreversibleScope(roots).some((root)=>changedParents.has(root));
+}
+function patchCollections(roots, previous, next) {
+    patchWorkOfficePdfRecords(roots.annotations, previous?.annotations ?? [], next.annotations, 'annotation');
+    patchWorkOfficePdfRecords(roots.formValues, previous?.formValues ?? [], next.formValues, 'form value');
+    patchWorkOfficePdfRecords(roots.signaturePlacements, previous?.signaturePlacements ?? [], next.signaturePlacements, 'signature placement');
+    patchWorkOfficePdfRecords(roots.redactionProposals, previous?.redactionProposals ?? [], next.redactionProposals, 'redaction proposal');
+    patchWorkOfficePdfRecords(roots.pageOperations, previous?.pageOperations ?? [], next.pageOperations, 'page operation');
+    patchWorkOfficePdfRecords(roots.reviewDecisions, previous?.reviewDecisions ?? [], next.reviewDecisions, 'review decision');
+}
+function patchSource(target, source) {
+    target.set('sha256', source.sha256);
+    target.set('byteLength', source.byteLength);
+    target.set('pageCount', source.pageCount);
+}
+function readSource(target) {
+    const sha256 = target.get('sha256');
+    const byteLength = target.get('byteLength');
+    const pageCount = target.get('pageCount');
+    if (3 !== target.size || 'string' != typeof sha256 || 'number' != typeof byteLength || 'number' != typeof pageCount) invalidWorkOfficePdfShared('source identity');
+    return {
+        sha256,
+        byteLength,
+        pageCount
+    };
+}
+function assertSourceIdentity(identities, source) {
+    if (0 === identities.length) return;
+    if (1 !== identities.length || identities.get(0) !== canonicalWorkOfficeCollaborationJson(source)) invalidWorkOfficePdfShared('immutable source identity');
+}
+function initializeWorkOfficePdfCollaboration(session, content) {
+    assertPdfSession(session);
+    assertWorkOfficeCollaborationEditable(session);
+    const prepared = validateWorkOfficePdfCollaborationContent(content);
+    const existing = readWorkOfficeCollaborationMetadata(session);
+    if (existing?.initialized) {
+        const current = readWorkOfficePdfCollaboration(session);
+        if (!workOfficeCollaborationJsonEqual(current.source, prepared.source)) throw new WorkOfficeCollaborationError('office.collaboration.artifact_mismatch', `The PDF source does not match collaboration artifact '${session.artifactId}'.`);
+        return {
+            initialized: false,
+            content: current
+        };
+    }
+    const roots = pdfRoots(session);
+    assertWorkOfficePdfRootsEmpty(roots);
+    const origin = session.createOrigin('bootstrap');
+    session.transact(()=>{
+        const metadata = initializeWorkOfficeCollaborationMetadata(session);
+        if (metadata.initialized) return;
+        registerWorkOfficeCollaborationInitializer(session);
+        initializeWorkOfficePdfRoots(roots, prepared);
+        markWorkOfficeCollaborationInitialized(session);
+    }, origin);
+    return {
+        initialized: true,
+        content: readWorkOfficePdfCollaboration(session)
+    };
+}
+function readWorkOfficePdfCollaboration(session) {
+    assertInitializedPdfSession(session);
+    return readWorkOfficePdfRoots(pdfRoots(session));
+}
+function assertWorkOfficePdfCollaborationSource(session, source) {
+    const expected = readWorkOfficePdfCollaboration(session).source;
+    if (workOfficeCollaborationJsonEqual(expected, source)) return;
+    throw new WorkOfficeCollaborationError('office.collaboration.artifact_mismatch', `The PDF source does not match collaboration artifact '${session.artifactId}'.`);
+}
+function readWorkOfficePdfCollaborationSource(session) {
+    return readWorkOfficePdfCollaboration(session).source;
+}
+function replaceWorkOfficePdfCollaboration(session, previous, next, origin = session.localOrigin) {
+    assertInitializedPdfSession(session);
+    assertWorkOfficeCollaborationEditable(session);
+    const before = validateWorkOfficePdfCollaborationContent(previous);
+    const after = validateWorkOfficePdfCollaborationContent(next);
+    if (workOfficeCollaborationJsonEqual(before, after)) return false;
+    session.transact(()=>{
+        patchWorkOfficePdfRoots(pdfRoots(session), before, after);
+    }, origin);
+    return true;
+}
+function createWorkOfficePdfCollaborationBinding(session, options = {}) {
+    assertInitializedPdfSession(session);
+    return new WorkOfficePdfCollaborationBindingImpl(session, options);
+}
+class WorkOfficePdfCollaborationBindingImpl {
+    origin;
+    #session;
+    #undoManager;
+    #roots;
+    #undoScope;
+    #irreversibleScope;
+    #changeScope;
+    #listeners = new Set();
+    #errorListeners = new Set();
+    #historyListeners = new Set();
+    #destroyed = false;
+    #pendingChange = false;
+    #pendingLocal = true;
+    #pendingOrigin;
+    constructor(session, options){
+        this.#session = session;
+        this.#roots = pdfRoots(session);
+        this.origin = options.origin ?? session.createOrigin(session.localOrigin.kind);
+        assertWorkOfficeCollaborationOrigin(this.origin);
+        this.#undoScope = workOfficePdfUndoScope(this.#roots);
+        this.#irreversibleScope = workOfficePdfIrreversibleScope(this.#roots);
+        this.#changeScope = [
+            this.#roots.source,
+            this.#roots.sourceIdentities,
+            this.#roots.recordClaims,
+            ...this.#undoScope,
+            ...this.#irreversibleScope
+        ];
+        this.#undoManager = new __rspack_external_yjs.UndoManager(this.#undoScope, {
+            captureTimeout: options.captureTimeoutMs ?? 500,
+            trackedOrigins: new Set([
+                this.origin
+            ])
+        });
+        session.document.on('afterTransaction', this.#onTransaction);
+        this.#undoManager.on('stack-item-added', this.#onHistoryChange);
+        this.#undoManager.on('stack-item-popped', this.#onHistoryChange);
+        this.#undoManager.on('stack-item-updated', this.#onHistoryChange);
+        this.#undoManager.on('stack-cleared', this.#onHistoryChange);
+    }
+    content() {
+        this.ensureActive();
+        return readWorkOfficePdfRoots(this.#roots);
+    }
+    replace(previous, next) {
+        this.ensureActive();
+        return replaceWorkOfficePdfCollaboration(this.#session, previous, next, this.origin);
+    }
+    canUndo() {
+        this.ensureActive();
+        return this.#undoManager.canUndo();
+    }
+    canRedo() {
+        this.ensureActive();
+        return this.#undoManager.canRedo();
+    }
+    undo() {
+        this.ensureActive();
+        assertWorkOfficeCollaborationEditable(this.#session);
+        return null !== this.#undoManager.undo();
+    }
+    redo() {
+        this.ensureActive();
+        assertWorkOfficeCollaborationEditable(this.#session);
+        return null !== this.#undoManager.redo();
+    }
+    stopCapturing() {
+        this.ensureActive();
+        this.#undoManager.stopCapturing();
+    }
+    subscribe(listener) {
+        this.ensureActive();
+        this.#listeners.add(listener);
+        return ()=>this.#listeners.delete(listener);
+    }
+    subscribeError(listener) {
+        this.ensureActive();
+        this.#errorListeners.add(listener);
+        return ()=>this.#errorListeners.delete(listener);
+    }
+    subscribeHistory(listener) {
+        this.ensureActive();
+        this.#historyListeners.add(listener);
+        return ()=>this.#historyListeners.delete(listener);
+    }
+    destroy() {
+        if (this.#destroyed) return;
+        this.#destroyed = true;
+        this.#pendingChange = false;
+        this.#session.document.off('afterTransaction', this.#onTransaction);
+        this.#undoManager.off('stack-item-added', this.#onHistoryChange);
+        this.#undoManager.off('stack-item-popped', this.#onHistoryChange);
+        this.#undoManager.off('stack-item-updated', this.#onHistoryChange);
+        this.#undoManager.off('stack-cleared', this.#onHistoryChange);
+        this.#undoManager.destroy();
+        this.#listeners.clear();
+        this.#errorListeners.clear();
+        this.#historyListeners.clear();
+    }
+    #onTransaction = (transaction)=>{
+        const changedParents = new Set(transaction.changedParentTypes.keys());
+        if (workOfficePdfIrreversibleChange(this.#roots, transaction)) this.#undoManager.clear();
+        if (this.#destroyed || !this.#changeScope.some((root)=>changedParents.has(root))) return;
+        const local = transaction.origin === this.origin || transaction.origin === this.#undoManager;
+        this.#pendingLocal = this.#pendingChange ? this.#pendingLocal && local : local;
+        this.#pendingOrigin = transaction.origin;
+        if (this.#pendingChange) return;
+        this.#pendingChange = true;
+        queueMicrotask(this.#flushChange);
+    };
+    #flushChange = ()=>{
+        if (this.#destroyed || !this.#pendingChange) return;
+        const local = this.#pendingLocal;
+        const origin = this.#pendingOrigin;
+        this.#pendingChange = false;
+        this.#pendingLocal = true;
+        this.#pendingOrigin = void 0;
+        try {
+            const change = {
+                content: this.content(),
+                local,
+                origin
+            };
+            for (const listener of this.#listeners)listener(change);
+        } catch (error) {
+            for (const listener of this.#errorListeners)listener(error);
+        }
+    };
+    #onHistoryChange = ()=>{
+        for (const listener of this.#historyListeners)listener();
+    };
+    ensureActive() {
+        if (!this.#destroyed) return;
+        throw new WorkOfficeCollaborationError('office.collaboration.binding_destroyed', 'The PDF collaboration binding has been destroyed.');
+    }
+}
+function pdfRoots(session) {
+    return workOfficePdfRoots(session.document, session.rootName.bind(session));
+}
+function assertPdfSession(session) {
+    if ('pdf' === session.kind) return;
+    throw new WorkOfficeCollaborationError('office.collaboration.kind_mismatch', `A PDF collaboration binding cannot use a '${session.kind}' session.`);
+}
+function assertInitializedPdfSession(session) {
+    assertPdfSession(session);
+    const metadata = readWorkOfficeCollaborationMetadata(session);
+    if (metadata?.initialized) return;
+    throw new WorkOfficeCollaborationError('office.collaboration.not_initialized', 'The PDF collaboration session has not been initialized.');
+}
+export { assertWorkOfficePdfCollaborationSource as assertPdfCollaborationSource, createWorkOfficePdfCollaborationBinding as createOfficePdfCollaborationBinding, initializeWorkOfficePdfCollaboration as initializeOfficePdfCollaboration, readWorkOfficePdfCollaboration as readOfficePdfCollaboration, readWorkOfficePdfCollaborationSource as readOfficePdfCollaborationSource, replaceWorkOfficePdfCollaboration as replaceOfficePdfCollaboration };